pyFAI.detectors package#
Module contents#
Description of all detectors with a factory to instantiate them.
- class pyFAI.detectors.ADSC_Q210(pixel1: float | None = None, pixel2: float | None = None, splinefile: str | None = None, max_shape: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
_ADSCADSC Quantum 210r detector, 2x2 chips
Information from http://www.adsc-xray.com/products/ccd-detectors/q210r-ccd-detector/
Question: how are the gaps handled ?
- MAX_SHAPE = (4096, 4096)#
- PIXEL_SIZE = (5.1e-05, 5.1e-05)#
- aliases = ('Quantum 210',)#
- force_pixel = True#
- class pyFAI.detectors.ADSC_Q270(pixel1: float | None = None, pixel2: float | None = None, splinefile: str | None = None, max_shape: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
_ADSCADSC Quantum 270r detector, 2x2 chips
Information from http://www.adsc-xray.com/products/ccd-detectors/q270-ccd-detector/
Question: how are the gaps handled ?
- MAX_SHAPE = (4168, 4168)#
- PIXEL_SIZE = (5.1e-05, 5.1e-05)#
- aliases = ('Quantum 270',)#
- force_pixel = True#
- class pyFAI.detectors.ADSC_Q315(pixel1: float | None = None, pixel2: float | None = None, splinefile: str | None = None, max_shape: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
_ADSCADSC Quantum 315r detector, 3x3 chips
Information from http://www.adsc-xray.com/products/ccd-detectors/q315r-ccd-detector/
Question: how are the gaps handled ?
- MAX_SHAPE = (6144, 6144)#
- PIXEL_SIZE = (5.1e-05, 5.1e-05)#
- aliases = ('Quantum 315',)#
- force_pixel = True#
- class pyFAI.detectors.ADSC_Q4(pixel1: float | None = None, pixel2: float | None = None, splinefile: str | None = None, max_shape: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
_ADSCADSC Quantum 4r detector, 2x2 chips
Information from http://proteincrystallography.org/detectors/adsc.php
Question: how are the gaps handled ?
- MAX_SHAPE = (2304, 2304)#
- PIXEL_SIZE = (5.1e-05, 5.1e-05)#
- aliases = ('Quantum 4',)#
- force_pixel = True#
- class pyFAI.detectors.Aarhus(pixel1=2.4893e-05, pixel2=2.4893e-05, radius=0.29989, orientation=0)#
Bases:
CylindricalDetectorCylindrical detector made of a bent imaging-plate. Developed at the Danish university of Aarhus r = 1.2m or 0.3m
Credits: Private communication; B. B. Iversen, Center for Materials Crystallography & Dept. of Chemistry and iNANO, Aarhus University
The image has to be laid-out horizontally
Nota: the detector is bend towards the sample, hence reducing the sample-detector distance. This is why z<0 (or p3<0)
- MANUFACTURER = 'Aarhus University'#
- MAX_SHAPE = (1000, 16000)#
- __init__(pixel1=2.4893e-05, pixel2=2.4893e-05, radius=0.29989, orientation=0)#
Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None
- class pyFAI.detectors.Apex2(pixel1=0.00012, pixel2=0.00012, max_shape=None, orientation=0)#
Bases:
DetectorBrukerApex2 detector
Actually a derivative from the Fairchild detector with higher binning
- MANUFACTURER = 'Bruker'#
- MAX_SHAPE = (1024, 1024)#
- PIXEL_SIZE = (0.00012, 0.00012)#
- __init__(pixel1=0.00012, pixel2=0.00012, max_shape=None, orientation=0)#
Defaults to 2x2 binning
- aliases = ('ApexII', 'Bruker')#
- force_pixel = True#
- class pyFAI.detectors.Basler(pixel1: float | None = None, pixel2: float | None = None, splinefile: str | None = None, max_shape: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
DetectorBasler camera are simple CCD camara over GigaE
- MANUFACTURER = 'Basler'#
- MAX_SHAPE = (966, 1296)#
- PIXEL_SIZE = (3.75e-06, 3.75e-06)#
- aliases = ('aca1300',)#
- force_pixel = True#
- class pyFAI.detectors.Cirpad(pixel1=0.00013, pixel2=0.00013, max_shape=None, module_size=None, orientation=0, sensor: SensorConfig | None = None)#
Bases:
ImXPadS10- DIFFERENT_PIXEL_SIZE = 2.5#
- IS_CONTIGUOUS = False#
- IS_FLAT = False#
- MAX_SHAPE = (11200, 120)#
- MEDIUM_MODULE_SIZE = (560, 120)#
- MODULE_SIZE = (80, 120)#
- PIXEL_SIZE = (0.00013, 0.00013)#
- ROT = (0, 0, -6.74)#
- __init__(pixel1=0.00013, pixel2=0.00013, max_shape=None, module_size=None, orientation=0, sensor: SensorConfig | None = None)#
Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None
- aliases = ('CirPAD', 'XCirpad')#
- calc_cartesian_positions(d1=None, d2=None, center=True, use_cython=True)#
Calculate the position of each pixel center in cartesian coordinate and in meter of a couple of coordinates. The half pixel offset is taken into account here !!!
- Parameters:
d1 (ndarray (1D or 2D)) – the Y pixel positions (slow dimension)
d2 (ndarray (1D or 2D)) – the X pixel positions (fast dimension)
- Returns:
position in meter of the center of each pixels.
- Return type:
ndarray
d1 and d2 must have the same shape, returned array will have the same shape.
- force_pixel = True#
- get_pixel_corners(correct_binning=False)#
Calculate the position of the corner of the pixels
This should be overwritten by class representing non-contiguous detector (Xpad, …)
Precision float32 is ok: precision of 1µm for a detector size of 1m
- Returns:
4D array containing: pixel index (slow dimension) pixel index (fast dimension) corner index (A, B, C or D), triangles or hexagons can be handled the same way vertex position (z,y,x)
- uniform_pixel = False#
- class pyFAI.detectors.CylindricalDetector(pixel1=2.4893e-05, pixel2=2.4893e-05, radius=0.29989, orientation=0, sensor: SensorConfig | None = None)#
Bases:
DetectorAbstract base class for all cylindrical detecors
- IS_FLAT = False#
- MANUFACTURER = None#
- __init__(pixel1=2.4893e-05, pixel2=2.4893e-05, radius=0.29989, orientation=0, sensor: SensorConfig | None = None)#
Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None
- calc_cartesian_positions(d1=None, d2=None, center=True, use_cython=True)#
Calculate the position of each pixel center in cartesian coordinate and in meter of a couple of coordinates. The half pixel offset is taken into account here !!! Adapted to Nexus detector definition
- Parameters:
d1 (ndarray (1D or 2D)) – the Y pixel positions (slow dimension)
d2 (ndarray (1D or 2D)) – the X pixel positions (fast dimension)
center – retrieve the coordinate of the center of the pixel
use_cython – set to False to test Python implementation
- Returns:
position in meter of the center of each pixels.
- Return type:
ndarray
d1 and d2 must have the same shape, returned array will have the same shape.
- force_pixel = True#
- get_config()#
Return the configuration with arguments to the constructor
- Returns:
dict with param for serialization
- get_pixel_corners(correct_binning=False, use_cython=True)#
Calculate the position of the corner of the pixels
This should be overwritten by class representing non-contiguous detector (Xpad, …) :param correct_binning: If True, check that the produced array have the right shape regarding binning :param use_cython: set to False for testing :return: 4D array containing:
pixel index (slow dimension)
pixel index (fast dimension)
corner index (A, B, C or D), triangles or hexagons can be handled the same way
vertex position (z,y,x)
- set_config(config)#
Sets the configuration of the detector.
The configuration is either a python dictionary or a JSON string or a file containing this JSON configuration
keys in that dictionary are: pixel1, pixel2, radius
- Parameters:
config – string or JSON-serialized dict
- Returns:
self
- class pyFAI.detectors.Detector(pixel1: float | None = None, pixel2: float | None = None, splinefile: str | None = None, max_shape: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
objectGeneric class representing a 2D detector
- API_VERSION = '1.2'#
- CORNERS = 4#
- DELTA_DUMMY = None#
- DUMMY = None#
- HAVE_TAPER = False#
If true a spline file is mandatory to correct the geometry
- IS_CONTIGUOUS = True#
- IS_FLAT = True#
- MANUFACTURER = None#
- ORIENTATION = 0#
- SENSORS = ()#
- __init__(pixel1: float | None = None, pixel2: float | None = None, splinefile: str | None = None, max_shape: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None
- aliases = ()#
- property binning: tuple[int, int]#
- calc_cartesian_positions(d1=None, d2=None, center=True, use_cython=True)#
Calculate the position of each pixel center in cartesian coordinate and in meter of a couple of coordinates. The half pixel offset is taken into account here !!! Adapted to Nexus detector definition
- Parameters:
d1 (ndarray (1D or 2D)) – the Y pixel positions (slow dimension)
d2 (ndarray (1D or 2D)) – the X pixel positions (fast dimension)
center – retrieve the coordinate of the center of the pixel, unless gives one corner
use_cython – set to False to test Python implementation
- Returns:
position in meter of the center of each pixels.
- Return type:
3xndarray, the later being None if IS_FLAT
d1 and d2 must have the same shape, returned array will have the same shape.
pos_z is None for flat detectors
- calc_mask()#
Method calculating the mask for a given detector
Detectors with gaps should overwrite this method with something actually calculating the mask!
- Returns:
the mask with valid pixel to 0
- Return type:
numpy ndarray of int8 or None
- property darkcurrent#
- classmethod default_sensor() SensorConfig | None#
Sensor assumed for this detector when the user does not provide one.
This is the first entry of SENSORS, the allowed sensors of the detector. When several are possible, it is logged that the first one is assumed. Detectors which do not know their sensor (empty SENSORS) return None.
- Returns:
a new SensorConfig (the instances are mutable), or None
- property delta_dummy#
- property dummy#
- dynamic_mask(img)#
Calculate the dynamic mask for the given image.
This uses the dummy and delta_dummy properties in addition to the static mask.
- Parameters:
img – 2D array with the image to analyse
- Returns:
the mask with valid pixel to 0
- Return type:
numpy ndarray of int8 or None
- classmethod factory(name: str, config: None | str | dict[str, Any] = None)#
Create a pyFAI detector from a name.
If the detector is a known detector class, config in injected as constructor arguments.
If the name is an existing hdf5 filename, the config argument is ignored.
- Parameters:
name (str) – A name of a detector or an existing hdf5 detector description file.
config (dict or JSON representation of it.) – configuration of the detector
- Returns:
an instance of the right detector, set-up if possible
- Return type:
- property flatfield#
- force_pixel = False#
- classmethod from_dict(dico)#
Creates a brand new detector from the description of the detector as a dict
- Parameters:
dico – JSON serializable dictionary
- Returns:
Detector instance
- getFit2D() dict#
Helper method to serialize the description of a detector using the Fit2d units
- Returns:
representation of the detector easy to serialize
- Return type:
dict
- getPyFAI() dict#
Helper method to serialize the description of a detector using the pyFAI way with everything in S.I units.
- Returns:
representation of the detector easy to serialize
- Return type:
dict
- get_binning() tuple[int, int]#
- get_config()#
Return the configuration with arguments to the constructor
Derivative classes should implement this method if they change the constructor!
- Returns:
dict with param for serialization
- get_darkcurrent()#
- get_darkcurrent_crc()#
- get_dummies(img)#
Calculate the actual dummy value from dtype of the img
- Parameters:
img – numpy array (or actually its dtype)
- Returns:
actual (dummy, delta_dummy) values as data_d (i.e. float32)
- get_flatfield()#
- get_flatfield_crc()#
- get_mask()#
- get_mask_crc()#
- get_maskfile()#
- get_name()#
Get a meaningful name for detector
- get_pixel1() float#
- get_pixel2() float#
- get_pixel_corners(correct_binning=False)#
Calculate the position of the corner of the pixels
This should be overwritten by class representing non-contiguous detector (Xpad, …)
Precision float32 is ok: precision of 1µm for a detector size of 1m :param correct_binning: If True, check that the produced array have the right shape regarding binning :return: 4D array containing …
pixel index (slow dimension)
pixel index (fast dimension)
corner index (A, B, C or D), triangles or hexagons can be handled the same way
vertex position (z,y,x)
- get_splineFile() str#
- guess_binning(data)#
Guess the binning/mode depending on the image shape
If the binning changes, this enforces the reset of the mask.
- Parameters:
data – 2-tuple with the shape of the image or the image with a .shape attribute.
- Returns:
True if the data fit the detector
- Return type:
bool
- property mask#
- property maskfile#
- property name#
Get a meaningful name for detector
- property orientation#
- property origin#
What are the coordinates of the detector’s origin ?
- property pixel1: float#
- property pixel2: float#
- registry: ClassVar[dict] = {'aarhus': <class 'pyFAI.detectors._non_flat.Aarhus'>, 'aca1300': <class 'pyFAI.detectors._others.Basler'>, 'adsc_q210': <class 'pyFAI.detectors._adsc.ADSC_Q210'>, 'adsc_q270': <class 'pyFAI.detectors._adsc.ADSC_Q270'>, 'adsc_q315': <class 'pyFAI.detectors._adsc.ADSC_Q315'>, 'adsc_q4': <class 'pyFAI.detectors._adsc.ADSC_Q4'>, 'agilent_titan': <class 'pyFAI.detectors._others.Titan'>, 'agilenttitan': <class 'pyFAI.detectors._others.Titan'>, 'apex2': <class 'pyFAI.detectors._others.Apex2'>, 'apexii': <class 'pyFAI.detectors._others.Apex2'>, 'basler': <class 'pyFAI.detectors._others.Basler'>, 'bruker': <class 'pyFAI.detectors._others.Apex2'>, 'cirpad': <class 'pyFAI.detectors._imxpad.Cirpad'>, 'condor': <class 'pyFAI.detectors._others.Fairchild'>, 'd5': <class 'pyFAI.detectors._imxpad.Xpad_flat'>, 'detector': <class 'pyFAI.detectors._common.Detector'>, 'dexela2923': <class 'pyFAI.detectors._others.Dexela2923'>, 'dexela_2923': <class 'pyFAI.detectors._others.Dexela2923'>, 'eiger16m': <class 'pyFAI.detectors._dectris.Eiger16M'>, 'eiger1m': <class 'pyFAI.detectors._dectris.Eiger1M'>, 'eiger216m': <class 'pyFAI.detectors._dectris.Eiger2_16M'>, 'eiger21m': <class 'pyFAI.detectors._dectris.Eiger2_1M'>, 'eiger21m-w': <class 'pyFAI.detectors._dectris.Eiger2_1MW'>, 'eiger2250k': <class 'pyFAI.detectors._dectris.Eiger2_250k'>, 'eiger22m-w': <class 'pyFAI.detectors._dectris.Eiger2_2MW'>, 'eiger24m': <class 'pyFAI.detectors._dectris.Eiger2_4M'>, 'eiger2500k': <class 'pyFAI.detectors._dectris.Eiger2_500k'>, 'eiger29m': <class 'pyFAI.detectors._dectris.Eiger2_9M'>, 'eiger2_16m': <class 'pyFAI.detectors._dectris.Eiger2_16M'>, 'eiger2_1m': <class 'pyFAI.detectors._dectris.Eiger2_1M'>, 'eiger2_1m-w': <class 'pyFAI.detectors._dectris.Eiger2_1MW'>, 'eiger2_1mw': <class 'pyFAI.detectors._dectris.Eiger2_1MW'>, 'eiger2_250k': <class 'pyFAI.detectors._dectris.Eiger2_250k'>, 'eiger2_2m-w': <class 'pyFAI.detectors._dectris.Eiger2_2MW'>, 'eiger2_2mw': <class 'pyFAI.detectors._dectris.Eiger2_2MW'>, 'eiger2_4m': <class 'pyFAI.detectors._dectris.Eiger2_4M'>, 'eiger2_500k': <class 'pyFAI.detectors._dectris.Eiger2_500k'>, 'eiger2_9m': <class 'pyFAI.detectors._dectris.Eiger2_9M'>, 'eiger2_cdte_16m': <class 'pyFAI.detectors._dectris.Eiger2CdTe_16M'>, 'eiger2_cdte_1m': <class 'pyFAI.detectors._dectris.Eiger2CdTe_1M'>, 'eiger2_cdte_1m-w': <class 'pyFAI.detectors._dectris.Eiger2CdTe_1MW'>, 'eiger2_cdte_2m-w': <class 'pyFAI.detectors._dectris.Eiger2CdTe_2MW'>, 'eiger2_cdte_4m': <class 'pyFAI.detectors._dectris.Eiger2CdTe_4M'>, 'eiger2_cdte_500k': <class 'pyFAI.detectors._dectris.Eiger2CdTe_500k'>, 'eiger2_cdte_9m': <class 'pyFAI.detectors._dectris.Eiger2CdTe_9M'>, 'eiger2cdte16m': <class 'pyFAI.detectors._dectris.Eiger2CdTe_16M'>, 'eiger2cdte1m': <class 'pyFAI.detectors._dectris.Eiger2CdTe_1M'>, 'eiger2cdte1m-w': <class 'pyFAI.detectors._dectris.Eiger2CdTe_1MW'>, 'eiger2cdte2m-w': <class 'pyFAI.detectors._dectris.Eiger2CdTe_2MW'>, 'eiger2cdte4m': <class 'pyFAI.detectors._dectris.Eiger2CdTe_4M'>, 'eiger2cdte500k': <class 'pyFAI.detectors._dectris.Eiger2CdTe_500k'>, 'eiger2cdte9m': <class 'pyFAI.detectors._dectris.Eiger2CdTe_9M'>, 'eiger2cdte_16m': <class 'pyFAI.detectors._dectris.Eiger2CdTe_16M'>, 'eiger2cdte_1m': <class 'pyFAI.detectors._dectris.Eiger2CdTe_1M'>, 'eiger2cdte_1mw': <class 'pyFAI.detectors._dectris.Eiger2CdTe_1MW'>, 'eiger2cdte_2mw': <class 'pyFAI.detectors._dectris.Eiger2CdTe_2MW'>, 'eiger2cdte_4m': <class 'pyFAI.detectors._dectris.Eiger2CdTe_4M'>, 'eiger2cdte_500k': <class 'pyFAI.detectors._dectris.Eiger2CdTe_500k'>, 'eiger2cdte_9m': <class 'pyFAI.detectors._dectris.Eiger2CdTe_9M'>, 'eiger4m': <class 'pyFAI.detectors._dectris.Eiger4M'>, 'eiger500k': <class 'pyFAI.detectors._dectris.Eiger500k'>, 'eiger9m': <class 'pyFAI.detectors._dectris.Eiger9M'>, 'eiger_16m': <class 'pyFAI.detectors._dectris.Eiger16M'>, 'eiger_1m': <class 'pyFAI.detectors._dectris.Eiger1M'>, 'eiger_4m': <class 'pyFAI.detectors._dectris.Eiger4M'>, 'eiger_500k': <class 'pyFAI.detectors._dectris.Eiger500k'>, 'eiger_9m': <class 'pyFAI.detectors._dectris.Eiger9M'>, 'fairchild': <class 'pyFAI.detectors._others.Fairchild'>, 'fairchild_condor_486:90': <class 'pyFAI.detectors._others.Fairchild'>, 'fairchildcondor486:90': <class 'pyFAI.detectors._others.Fairchild'>, 'frelon': <class 'pyFAI.detectors._esrf.FReLoN'>, 'hf-130k': <class 'pyFAI.detectors._adsc.HF_130K'>, 'hf-1m': <class 'pyFAI.detectors._adsc.HF_1M'>, 'hf-2.4m': <class 'pyFAI.detectors._adsc.HF_2M'>, 'hf-262k': <class 'pyFAI.detectors._adsc.HF_262k'>, 'hf-4m': <class 'pyFAI.detectors._adsc.HF_4M'>, 'hf-9.4m': <class 'pyFAI.detectors._adsc.HF_9M'>, 'hf_130k': <class 'pyFAI.detectors._adsc.HF_130K'>, 'hf_1m': <class 'pyFAI.detectors._adsc.HF_1M'>, 'hf_262k': <class 'pyFAI.detectors._adsc.HF_262k'>, 'hf_2m': <class 'pyFAI.detectors._adsc.HF_2M'>, 'hf_4m': <class 'pyFAI.detectors._adsc.HF_4M'>, 'hf_9m': <class 'pyFAI.detectors._adsc.HF_9M'>, 'imxpad_s10': <class 'pyFAI.detectors._imxpad.ImXPadS10'>, 'imxpad_s140': <class 'pyFAI.detectors._imxpad.ImXPadS140'>, 'imxpad_s70': <class 'pyFAI.detectors._imxpad.ImXPadS70'>, 'imxpad_s70_v': <class 'pyFAI.detectors._imxpad.ImXPadS70V'>, 'imxpads10': <class 'pyFAI.detectors._imxpad.ImXPadS10'>, 'imxpads140': <class 'pyFAI.detectors._imxpad.ImXPadS140'>, 'imxpads70': <class 'pyFAI.detectors._imxpad.ImXPadS70'>, 'imxpads70v': <class 'pyFAI.detectors._imxpad.ImXPadS70V'>, 'jungfrau': <class 'pyFAI.detectors._psi.Jungfrau'>, 'jungfrau16mcor': <class 'pyFAI.detectors._psi.Jungfrau_16M_cor'>, 'jungfrau1m': <class 'pyFAI.detectors._psi.Jungfrau1M'>, 'jungfrau4m': <class 'pyFAI.detectors._psi.Jungfrau4M'>, 'jungfrau500k': <class 'pyFAI.detectors._psi.Jungfrau'>, 'jungfrau8m': <class 'pyFAI.detectors._psi.Jungfrau8M'>, 'jungfrau_16m_cor': <class 'pyFAI.detectors._psi.Jungfrau_16M_cor'>, 'jungfrau_1m': <class 'pyFAI.detectors._psi.Jungfrau1M'>, 'jungfrau_4m': <class 'pyFAI.detectors._psi.Jungfrau4M'>, 'jungfrau_500k': <class 'pyFAI.detectors._psi.Jungfrau'>, 'jungfrau_8m': <class 'pyFAI.detectors._psi.Jungfrau8M'>, 'lambda10m': <class 'pyFAI.detectors._xspectrum.Lambda10M'>, 'lambda250k': <class 'pyFAI.detectors._xspectrum.Lambda250k'>, 'lambda2m': <class 'pyFAI.detectors._xspectrum.Lambda2M'>, 'lambda60k': <class 'pyFAI.detectors._xspectrum.Lambda60k'>, 'lambda7.5m': <class 'pyFAI.detectors._xspectrum.Lambda7M5'>, 'lambda750k': <class 'pyFAI.detectors._xspectrum.Lambda750k'>, 'lambda7m5': <class 'pyFAI.detectors._xspectrum.Lambda7M5'>, 'lambda9m': <class 'pyFAI.detectors._xspectrum.Lambda9M'>, 'lambda_10m': <class 'pyFAI.detectors._xspectrum.Lambda10M'>, 'lambda_250k': <class 'pyFAI.detectors._xspectrum.Lambda250k'>, 'lambda_2m': <class 'pyFAI.detectors._xspectrum.Lambda2M'>, 'lambda_60k': <class 'pyFAI.detectors._xspectrum.Lambda60k'>, 'lambda_7.5m': <class 'pyFAI.detectors._xspectrum.Lambda7M5'>, 'lambda_750k': <class 'pyFAI.detectors._xspectrum.Lambda750k'>, 'lambda_9m': <class 'pyFAI.detectors._xspectrum.Lambda9M'>, 'mar133': <class 'pyFAI.detectors._rayonix.Rayonix133'>, 'mar165': <class 'pyFAI.detectors._rayonix.RayonixSx165'>, 'mar225': <class 'pyFAI.detectors._rayonix.RayonixMx225'>, 'mar300': <class 'pyFAI.detectors._rayonix.RayonixMx300'>, 'mar345': <class 'pyFAI.detectors._rayonix.Mar345'>, 'mar3450': <class 'pyFAI.detectors._rayonix.Mar345'>, 'mar555': <class 'pyFAI.detectors._rayonix.Mar555'>, 'mar_133': <class 'pyFAI.detectors._rayonix.Rayonix133'>, 'mar_165': <class 'pyFAI.detectors._rayonix.RayonixSx165'>, 'mar_225': <class 'pyFAI.detectors._rayonix.RayonixMx225'>, 'mar_300': <class 'pyFAI.detectors._rayonix.RayonixMx300'>, 'mar_345': <class 'pyFAI.detectors._rayonix.Mar345'>, 'mar_555': <class 'pyFAI.detectors._rayonix.Mar555'>, 'maxipix': <class 'pyFAI.detectors._esrf.Maxipix'>, 'maxipix1x1': <class 'pyFAI.detectors._esrf.Maxipix'>, 'maxipix2x2': <class 'pyFAI.detectors._esrf.Maxipix2x2'>, 'maxipix5x1': <class 'pyFAI.detectors._esrf.Maxipix5x1'>, 'maxipix_1x1': <class 'pyFAI.detectors._esrf.Maxipix'>, 'maxipix_2x2': <class 'pyFAI.detectors._esrf.Maxipix2x2'>, 'maxipix_5x1': <class 'pyFAI.detectors._esrf.Maxipix5x1'>, 'mythen': <class 'pyFAI.detectors._dectris.Mythen'>, 'mythen1280': <class 'pyFAI.detectors._dectris.Mythen'>, 'mythen_1280': <class 'pyFAI.detectors._dectris.Mythen'>, 'oxd_titan': <class 'pyFAI.detectors._others.Titan'>, 'oxdtitan': <class 'pyFAI.detectors._others.Titan'>, 'perkin': <class 'pyFAI.detectors._others.Perkin'>, 'perkin_detector': <class 'pyFAI.detectors._others.Perkin'>, 'perkin_elmer': <class 'pyFAI.detectors._others.Perkin'>, 'perkindetector': <class 'pyFAI.detectors._others.Perkin'>, 'perkinelmer': <class 'pyFAI.detectors._others.Perkin'>, 'picam_hq': <class 'pyFAI.detectors._others.RaspberryPi12M'>, 'picam_v1': <class 'pyFAI.detectors._others.RaspberryPi5M'>, 'picam_v2': <class 'pyFAI.detectors._others.RaspberryPi8M'>, 'picamhq': <class 'pyFAI.detectors._others.RaspberryPi12M'>, 'picamv1': <class 'pyFAI.detectors._others.RaspberryPi5M'>, 'picamv2': <class 'pyFAI.detectors._others.RaspberryPi8M'>, 'pilatus100k': <class 'pyFAI.detectors._dectris.Pilatus100k'>, 'pilatus1m': <class 'pyFAI.detectors._dectris.Pilatus1M'>, 'pilatus1m_cdte': <class 'pyFAI.detectors._dectris.PilatusCdTe1M'>, 'pilatus1mcdte': <class 'pyFAI.detectors._dectris.PilatusCdTe1M'>, 'pilatus200k': <class 'pyFAI.detectors._dectris.Pilatus200k'>, 'pilatus2m': <class 'pyFAI.detectors._dectris.Pilatus2M'>, 'pilatus2m_cdte': <class 'pyFAI.detectors._dectris.PilatusCdTe2M'>, 'pilatus2mcdte': <class 'pyFAI.detectors._dectris.PilatusCdTe2M'>, 'pilatus300k': <class 'pyFAI.detectors._dectris.Pilatus300k'>, 'pilatus300k_cdte': <class 'pyFAI.detectors._dectris.PilatusCdTe300k'>, 'pilatus300kcdte': <class 'pyFAI.detectors._dectris.PilatusCdTe300k'>, 'pilatus300kw': <class 'pyFAI.detectors._dectris.Pilatus300kw'>, 'pilatus300kw_cdte': <class 'pyFAI.detectors._dectris.PilatusCdTe300kw'>, 'pilatus300kwcdte': <class 'pyFAI.detectors._dectris.PilatusCdTe300kw'>, 'pilatus41m': <class 'pyFAI.detectors._dectris.Pilatus4_1M'>, 'pilatus41mcdte': <class 'pyFAI.detectors._dectris.Pilatus4_CdTe_1M'>, 'pilatus4260k': <class 'pyFAI.detectors._dectris.Pilatus4_260k'>, 'pilatus4260kcdte': <class 'pyFAI.detectors._dectris.Pilatus4_CdTe_260k'>, 'pilatus4260kw': <class 'pyFAI.detectors._dectris.Pilatus4_260kw'>, 'pilatus4260kwcdte': <class 'pyFAI.detectors._dectris.Pilatus4_CdTe_260kw'>, 'pilatus42m': <class 'pyFAI.detectors._dectris.Pilatus4_2M'>, 'pilatus42mcdte': <class 'pyFAI.detectors._dectris.Pilatus4_CdTe_2M'>, 'pilatus44m': <class 'pyFAI.detectors._dectris.Pilatus4_4M'>, 'pilatus44mcdte': <class 'pyFAI.detectors._dectris.Pilatus4_CdTe_4M'>, 'pilatus4_1m': <class 'pyFAI.detectors._dectris.Pilatus4_1M'>, 'pilatus4_1m_cdte': <class 'pyFAI.detectors._dectris.Pilatus4_CdTe_1M'>, 'pilatus4_260k': <class 'pyFAI.detectors._dectris.Pilatus4_260k'>, 'pilatus4_260k_cdte': <class 'pyFAI.detectors._dectris.Pilatus4_CdTe_260k'>, 'pilatus4_260kw': <class 'pyFAI.detectors._dectris.Pilatus4_260kw'>, 'pilatus4_260kw_cdte': <class 'pyFAI.detectors._dectris.Pilatus4_CdTe_260kw'>, 'pilatus4_2m': <class 'pyFAI.detectors._dectris.Pilatus4_2M'>, 'pilatus4_2m_cdte': <class 'pyFAI.detectors._dectris.Pilatus4_CdTe_2M'>, 'pilatus4_4m': <class 'pyFAI.detectors._dectris.Pilatus4_4M'>, 'pilatus4_4m_cdte': <class 'pyFAI.detectors._dectris.Pilatus4_CdTe_4M'>, 'pilatus4_cdte_1m': <class 'pyFAI.detectors._dectris.Pilatus4_CdTe_1M'>, 'pilatus4_cdte_260k': <class 'pyFAI.detectors._dectris.Pilatus4_CdTe_260k'>, 'pilatus4_cdte_260kw': <class 'pyFAI.detectors._dectris.Pilatus4_CdTe_260kw'>, 'pilatus4_cdte_2m': <class 'pyFAI.detectors._dectris.Pilatus4_CdTe_2M'>, 'pilatus4_cdte_4m': <class 'pyFAI.detectors._dectris.Pilatus4_CdTe_4M'>, 'pilatus6m': <class 'pyFAI.detectors._dectris.Pilatus6M'>, 'pilatus900k': <class 'pyFAI.detectors._dectris.Pilatus900k'>, 'pilatus900kw_cdte': <class 'pyFAI.detectors._dectris.PilatusCdTe900kw'>, 'pilatus900kwcdte': <class 'pyFAI.detectors._dectris.PilatusCdTe900kw'>, 'pilatus_100k': <class 'pyFAI.detectors._dectris.Pilatus100k'>, 'pilatus_1m': <class 'pyFAI.detectors._dectris.Pilatus1M'>, 'pilatus_1m_cdte': <class 'pyFAI.detectors._dectris.PilatusCdTe1M'>, 'pilatus_200k': <class 'pyFAI.detectors._dectris.Pilatus200k'>, 'pilatus_2m': <class 'pyFAI.detectors._dectris.Pilatus2M'>, 'pilatus_2m_cdte': <class 'pyFAI.detectors._dectris.PilatusCdTe2M'>, 'pilatus_300k': <class 'pyFAI.detectors._dectris.Pilatus300k'>, 'pilatus_300k_cdte': <class 'pyFAI.detectors._dectris.PilatusCdTe300k'>, 'pilatus_300kw': <class 'pyFAI.detectors._dectris.Pilatus300kw'>, 'pilatus_300kw_cdte': <class 'pyFAI.detectors._dectris.PilatusCdTe300kw'>, 'pilatus_6m': <class 'pyFAI.detectors._dectris.Pilatus6M'>, 'pilatus_900k': <class 'pyFAI.detectors._dectris.Pilatus900k'>, 'pilatus_900kw_cdte': <class 'pyFAI.detectors._dectris.PilatusCdTe900kw'>, 'pilatus_cdte_1m': <class 'pyFAI.detectors._dectris.PilatusCdTe1M'>, 'pilatus_cdte_2m': <class 'pyFAI.detectors._dectris.PilatusCdTe2M'>, 'pilatus_cdte_300k': <class 'pyFAI.detectors._dectris.PilatusCdTe300k'>, 'pilatus_cdte_300kw': <class 'pyFAI.detectors._dectris.PilatusCdTe300kw'>, 'pilatus_cdte_900kw': <class 'pyFAI.detectors._dectris.PilatusCdTe900kw'>, 'pilatuscdte1m': <class 'pyFAI.detectors._dectris.PilatusCdTe1M'>, 'pilatuscdte2m': <class 'pyFAI.detectors._dectris.PilatusCdTe2M'>, 'pilatuscdte300k': <class 'pyFAI.detectors._dectris.PilatusCdTe300k'>, 'pilatuscdte300kw': <class 'pyFAI.detectors._dectris.PilatusCdTe300kw'>, 'pilatuscdte900kw': <class 'pyFAI.detectors._dectris.PilatusCdTe900kw'>, 'pixirad-1': <class 'pyFAI.detectors._hexagonal.Pixirad1'>, 'pixirad-2': <class 'pyFAI.detectors._hexagonal.Pixirad2'>, 'pixirad-4': <class 'pyFAI.detectors._hexagonal.Pixirad4'>, 'pixirad-8': <class 'pyFAI.detectors._hexagonal.Pixirad8'>, 'pixirad1': <class 'pyFAI.detectors._hexagonal.Pixirad1'>, 'pixirad2': <class 'pyFAI.detectors._hexagonal.Pixirad2'>, 'pixirad4': <class 'pyFAI.detectors._hexagonal.Pixirad4'>, 'pixirad8': <class 'pyFAI.detectors._hexagonal.Pixirad8'>, 'pixium': <class 'pyFAI.detectors._others.Pixium'>, 'pixium4700': <class 'pyFAI.detectors._others.Pixium'>, 'pixium4700detector': <class 'pyFAI.detectors._others.Pixium'>, 'pixium_4700': <class 'pyFAI.detectors._others.Pixium'>, 'pixium_4700_detector': <class 'pyFAI.detectors._others.Pixium'>, 'quantum210': <class 'pyFAI.detectors._adsc.ADSC_Q210'>, 'quantum270': <class 'pyFAI.detectors._adsc.ADSC_Q270'>, 'quantum315': <class 'pyFAI.detectors._adsc.ADSC_Q315'>, 'quantum4': <class 'pyFAI.detectors._adsc.ADSC_Q4'>, 'quantum_210': <class 'pyFAI.detectors._adsc.ADSC_Q210'>, 'quantum_270': <class 'pyFAI.detectors._adsc.ADSC_Q270'>, 'quantum_315': <class 'pyFAI.detectors._adsc.ADSC_Q315'>, 'quantum_4': <class 'pyFAI.detectors._adsc.ADSC_Q4'>, 'rapid': <class 'pyFAI.detectors._non_flat.Rapid'>, 'rapidii': <class 'pyFAI.detectors._non_flat.Rapid'>, 'raspberrypi12m': <class 'pyFAI.detectors._others.RaspberryPi12M'>, 'raspberrypi5m': <class 'pyFAI.detectors._others.RaspberryPi5M'>, 'raspberrypi8m': <class 'pyFAI.detectors._others.RaspberryPi8M'>, 'rayonix133': <class 'pyFAI.detectors._rayonix.Rayonix133'>, 'rayonix_lx170': <class 'pyFAI.detectors._rayonix.RayonixLx170'>, 'rayonix_lx170-hs': <class 'pyFAI.detectors._rayonix.RayonixLx170'>, 'rayonix_lx170_hs': <class 'pyFAI.detectors._rayonix.RayonixLx170'>, 'rayonix_lx255': <class 'pyFAI.detectors._rayonix.RayonixLx255'>, 'rayonix_lx255-hs': <class 'pyFAI.detectors._rayonix.RayonixLx255'>, 'rayonix_lx_255hs': <class 'pyFAI.detectors._rayonix.RayonixLx255'>, 'rayonix_mx170': <class 'pyFAI.detectors._rayonix.RayonixMx170'>, 'rayonix_mx170-hs': <class 'pyFAI.detectors._rayonix.RayonixMx170'>, 'rayonix_mx170_hs': <class 'pyFAI.detectors._rayonix.RayonixMx170'>, 'rayonix_mx225': <class 'pyFAI.detectors._rayonix.RayonixMx225'>, 'rayonix_mx225_hs': <class 'pyFAI.detectors._rayonix.RayonixMx225hs'>, 'rayonix_mx225hs': <class 'pyFAI.detectors._rayonix.RayonixMx225hs'>, 'rayonix_mx300': <class 'pyFAI.detectors._rayonix.RayonixMx300'>, 'rayonix_mx300_hs': <class 'pyFAI.detectors._rayonix.RayonixMx300hs'>, 'rayonix_mx300hs': <class 'pyFAI.detectors._rayonix.RayonixMx300hs'>, 'rayonix_mx325': <class 'pyFAI.detectors._rayonix.RayonixMx325'>, 'rayonix_mx340hs': <class 'pyFAI.detectors._rayonix.RayonixMx340hs'>, 'rayonix_mx425_hs': <class 'pyFAI.detectors._rayonix.RayonixMx425hs'>, 'rayonix_mx425hs': <class 'pyFAI.detectors._rayonix.RayonixMx425hs'>, 'rayonix_sx165': <class 'pyFAI.detectors._rayonix.RayonixSx165'>, 'rayonix_sx200': <class 'pyFAI.detectors._rayonix.RayonixSx200'>, 'rayonix_sx30_hs': <class 'pyFAI.detectors._rayonix.RayonixSx30hs'>, 'rayonix_sx30hs': <class 'pyFAI.detectors._rayonix.RayonixSx30hs'>, 'rayonix_sx85_hs': <class 'pyFAI.detectors._rayonix.RayonixSx85hs'>, 'rayonix_sx85hs': <class 'pyFAI.detectors._rayonix.RayonixSx85hs'>, 'rayonixlx170': <class 'pyFAI.detectors._rayonix.RayonixLx170'>, 'rayonixlx170-hs': <class 'pyFAI.detectors._rayonix.RayonixLx170'>, 'rayonixlx170hs': <class 'pyFAI.detectors._rayonix.RayonixLx170'>, 'rayonixlx225hs': <class 'pyFAI.detectors._rayonix.RayonixLx255'>, 'rayonixlx255': <class 'pyFAI.detectors._rayonix.RayonixLx255'>, 'rayonixlx255-hs': <class 'pyFAI.detectors._rayonix.RayonixLx255'>, 'rayonixlx255hs': <class 'pyFAI.detectors._rayonix.RayonixLx255'>, 'rayonixmx170': <class 'pyFAI.detectors._rayonix.RayonixMx170'>, 'rayonixmx170-hs': <class 'pyFAI.detectors._rayonix.RayonixMx170'>, 'rayonixmx170hs': <class 'pyFAI.detectors._rayonix.RayonixMx170'>, 'rayonixmx225': <class 'pyFAI.detectors._rayonix.RayonixMx225'>, 'rayonixmx225hs': <class 'pyFAI.detectors._rayonix.RayonixMx225hs'>, 'rayonixmx300': <class 'pyFAI.detectors._rayonix.RayonixMx300'>, 'rayonixmx300hs': <class 'pyFAI.detectors._rayonix.RayonixMx300hs'>, 'rayonixmx325': <class 'pyFAI.detectors._rayonix.RayonixMx325'>, 'rayonixmx340hs': <class 'pyFAI.detectors._rayonix.RayonixMx340hs'>, 'rayonixmx425hs': <class 'pyFAI.detectors._rayonix.RayonixMx425hs'>, 'rayonixsx165': <class 'pyFAI.detectors._rayonix.RayonixSx165'>, 'rayonixsx200': <class 'pyFAI.detectors._rayonix.RayonixSx200'>, 'rayonixsx30hs': <class 'pyFAI.detectors._rayonix.RayonixSx30hs'>, 'rayonixsx85hs': <class 'pyFAI.detectors._rayonix.RayonixSx85hs'>, 'thales_electronics': <class 'pyFAI.detectors._others.Pixium'>, 'thaleselectronics': <class 'pyFAI.detectors._others.Pixium'>, 'titan': <class 'pyFAI.detectors._others.Titan'>, 'titan2kx2k': <class 'pyFAI.detectors._others.Titan'>, 'titan_2k_x_2k': <class 'pyFAI.detectors._others.Titan'>, 'xcirpad': <class 'pyFAI.detectors._imxpad.Cirpad'>, 'xpad_flat': <class 'pyFAI.detectors._imxpad.Xpad_flat'>, 'xpad_s540_flat': <class 'pyFAI.detectors._imxpad.Xpad_flat'>, 'xpads540flat': <class 'pyFAI.detectors._imxpad.Xpad_flat'>}#
- reset_pixel_corners()#
- save(filename)#
Saves the detector description into a NeXus file, adapted from: http://download.nexusformat.org/sphinx/classes/base_classes/NXdetector.html Main differences:
differentiate pixel center from pixel corner offsets
store all offsets are ndarray according to slow/fast dimension (not x, y)
- Parameters:
filename – name of the file on the disc
- property sensor#
Configuration of the sensor: material and thickness, or None
- setFit2D(**kwarg)#
Twin method of getFit2D: setup a detector instance according to a description
- Parameters:
kwarg – dictionary containing pixel1, pixel2 and splineFile
- setPyFAI(**kwarg)#
Twin method of getPyFAI: setup a detector instance according to a description
- Parameters:
kwarg – dictionary containing detector, pixel1, pixel2 and splineFile
- set_binning(bin_size: tuple[int, int] = (1, 1))#
Set the “binning” of the detector,
- Parameters:
bin_size ((int, int)) – binning as integer or tuple of integers.
- set_config(config)#
Sets the configuration of the detector.
The configuration is either a python dictionary or a JSON string or a file containing this JSON configuration
keys in that dictionary are: pixel1, pixel2, splinefile, max_shape
- Parameters:
config – string or JSON-serialized dict
- Returns:
self
- set_darkcurrent(dark)#
- set_darkfiles(files=None, method='mean')#
- Parameters:
files (str or list(str) or None) – file(s) used to compute the dark.
method (str) – method used to compute the dark, “mean” or “median”
Set the dark current from one or multiple files, avaraged according to the method provided
- set_dx(dx=None)#
set the pixel-wise displacement along X (dim2)
units: Displacement of a fraction of pixel in the direction X (along axis2)
- set_dy(dy=None)#
set the pixel-wise displacement along Y (dim1)
unit: Displacement of a fraction of pixel in the Y direction (along dim1)
- set_flatfield(flat)#
- set_flatfiles(files, method='mean')#
- Parameters:
files (str or list(str) or None) – file(s) used to compute the flat-field.
method (str) – method used to compute the dark, “mean” or “median”
Set the flat field from one or multiple files, averaged according to the method provided
- set_mask(mask)#
- set_maskfile(maskfile)#
- set_pixel1(value)#
Set the pixel size along the first dimension.
- set_pixel2(value)#
Set the pixel size along the second dimension.
- set_pixel_corners(ary)#
Sets the position of pixel corners with some additional validation
- Parameters:
ary – This a 4D array which contains: number of lines, number of columns, corner index, position in space Z, Y, X
- set_splineFile(splinefile)#
- property splineFile: str#
- property splinefile: str#
- uniform_pixel = True#
- class pyFAI.detectors.Dexela2923(pixel1: float | None = None, pixel2: float | None = None, splinefile: str | None = None, max_shape: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
DetectorDexela CMOS family detector
- MAX_SHAPE = (3888, 3072)#
- PIXEL_SIZE = (7.5e-05, 7.5e-05)#
- aliases = ('Dexela 2923',)#
- force_pixel = True#
- class pyFAI.detectors.Eiger(pixel1: float = 7.5e-05, pixel2: float = 7.5e-05, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
_DectrisEiger detector: generic description containing mask algorithm
Nota: 512k modules (514*1030) are made of 2x4 submodules of 256*256 pixels. Two missing pixels are interpolated at each sub-module boundary which explains the +2 and the +6 pixels.
- MODULE_GAP = (37, 10)#
- MODULE_SIZE = (514, 1030)#
- PIXEL_SIZE = (7.5e-05, 7.5e-05)#
- SENSORS = ({ "material": "Si", "thickness": 0.00045 },)#
- __init__(pixel1: float = 7.5e-05, pixel2: float = 7.5e-05, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None
- calc_cartesian_positions(d1=None, d2=None, center=True, use_cython=True)#
Calculate the position of each pixel center in cartesian coordinate and in meter of a couple of coordinates. The half pixel offset is taken into account here !!!
- Parameters:
d1 (ndarray (1D or 2D)) – the Y pixel positions (slow dimension)
d2 (ndarray (1D or 2D)) – the X pixel positions (fast dimension)
- Returns:
p1, p2 position in meter of the center of each pixels.
- Return type:
2-tuple of numpy.ndarray
d1 and d2 must have the same shape, returned array will have the same shape.
- force_pixel = True#
- class pyFAI.detectors.Eiger16M(pixel1: float = 7.5e-05, pixel2: float = 7.5e-05, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
EigerEiger 16M detector
- MAX_SHAPE = (4371, 4150)#
- aliases = ('Eiger 16M',)#
- class pyFAI.detectors.Eiger1M(pixel1: float = 7.5e-05, pixel2: float = 7.5e-05, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
EigerEiger 1M detector
- MAX_SHAPE = (1065, 1030)#
- aliases = ('Eiger 1M',)#
- class pyFAI.detectors.Eiger2(pixel1: float = 7.5e-05, pixel2: float = 7.5e-05, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
Eiger- MODULE_GAP = (38, 12)#
- MODULE_SIZE = (512, 1028)#
- class pyFAI.detectors.Eiger2CdTe(pixel1: float = 7.5e-05, pixel2: float = 7.5e-05, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
Eiger2Eiger2 CdTe detector: Like the Eiger2 with an extra 2-pixel gap in the middle of every module (vertically)
- SENSORS = ({ "material": "CdTe", "thickness": 0.00075 },)#
- calc_mask()#
Mask out an extra 2 pixels in the middle of each module
- class pyFAI.detectors.Eiger2CdTe_16M(pixel1: float = 7.5e-05, pixel2: float = 7.5e-05, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
Eiger2CdTeEiger2 CdTe 16M detector
- MAX_SHAPE = (4362, 4148)#
- aliases = ('Eiger2 CdTe 16M',)#
- class pyFAI.detectors.Eiger2CdTe_1M(pixel1: float = 7.5e-05, pixel2: float = 7.5e-05, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
Eiger2CdTeEiger2 CdTe 1M detector
- MAX_SHAPE = (1062, 1028)#
- aliases = ('Eiger2 CdTe 1M',)#
- class pyFAI.detectors.Eiger2CdTe_1MW(pixel1: float = 7.5e-05, pixel2: float = 7.5e-05, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
Eiger2CdTeEiger2 CdTe 1M-Wide detector
- MAX_SHAPE = (512, 2068)#
- aliases = ('Eiger2 CdTe 1M-W',)#
- class pyFAI.detectors.Eiger2CdTe_2MW(pixel1: float = 7.5e-05, pixel2: float = 7.5e-05, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
Eiger2CdTeEiger2 CdTe 2M-Wide detector
- MAX_SHAPE = (512, 4148)#
- aliases = ('Eiger2 CdTe 2M-W',)#
- class pyFAI.detectors.Eiger2CdTe_4M(pixel1: float = 7.5e-05, pixel2: float = 7.5e-05, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
Eiger2CdTeEiger2 CdTe 4M detector
- MAX_SHAPE = (2162, 2068)#
- aliases = ('Eiger2 CdTe 4M',)#
- class pyFAI.detectors.Eiger2CdTe_500k(pixel1: float = 7.5e-05, pixel2: float = 7.5e-05, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
Eiger2CdTeEiger2 CdTe 500k detector
- MAX_SHAPE = (512, 1028)#
- aliases = ('Eiger2 CdTe 500k',)#
- class pyFAI.detectors.Eiger2CdTe_9M(pixel1: float = 7.5e-05, pixel2: float = 7.5e-05, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
Eiger2CdTeEiger2 CdTe 9M detector
- MAX_SHAPE = (3262, 3108)#
- aliases = ('Eiger2 CdTe 9M',)#
- class pyFAI.detectors.Eiger2_16M(pixel1: float = 7.5e-05, pixel2: float = 7.5e-05, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
Eiger2Eiger2 16M detector
- MAX_SHAPE = (4362, 4148)#
- aliases = ('Eiger2 16M',)#
- class pyFAI.detectors.Eiger2_1M(pixel1: float = 7.5e-05, pixel2: float = 7.5e-05, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
Eiger2Eiger2 1M detector
- MAX_SHAPE = (1062, 1028)#
- aliases = ('Eiger2 1M',)#
- class pyFAI.detectors.Eiger2_1MW(pixel1: float = 7.5e-05, pixel2: float = 7.5e-05, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
Eiger2Eiger2 1M-Wide detector
- MAX_SHAPE = (512, 2068)#
- aliases = ('Eiger2 1M-W',)#
- class pyFAI.detectors.Eiger2_250k(pixel1: float = 7.5e-05, pixel2: float = 7.5e-05, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
Eiger2Eiger2 250k detector
- MAX_SHAPE = (512, 512)#
- aliases = ('Eiger2 250k',)#
- class pyFAI.detectors.Eiger2_2MW(pixel1: float = 7.5e-05, pixel2: float = 7.5e-05, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
Eiger2Eiger2 2M-Wide detector
- MAX_SHAPE = (512, 4148)#
- aliases = ('Eiger2 2M-W',)#
- class pyFAI.detectors.Eiger2_4M(pixel1: float = 7.5e-05, pixel2: float = 7.5e-05, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
Eiger2Eiger2 4M detector
- MAX_SHAPE = (2162, 2068)#
- aliases = ('Eiger2 4M',)#
- class pyFAI.detectors.Eiger2_500k(pixel1: float = 7.5e-05, pixel2: float = 7.5e-05, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
Eiger2Eiger2 500k detector
- MAX_SHAPE = (512, 1028)#
- aliases = ('Eiger2 500k',)#
- class pyFAI.detectors.Eiger2_9M(pixel1: float = 7.5e-05, pixel2: float = 7.5e-05, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
Eiger2Eiger2 9M detector
- MAX_SHAPE = (3262, 3108)#
- aliases = ('Eiger2 9M',)#
- class pyFAI.detectors.Eiger4M(pixel1: float = 7.5e-05, pixel2: float = 7.5e-05, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
EigerEiger 4M detector
- MAX_SHAPE = (2167, 2070)#
- aliases = ('Eiger 4M',)#
- class pyFAI.detectors.Eiger500k(pixel1: float = 7.5e-05, pixel2: float = 7.5e-05, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
EigerEiger 500k detector
- MAX_SHAPE = (514, 1030)#
- aliases = ('Eiger 500k',)#
- class pyFAI.detectors.Eiger9M(pixel1: float = 7.5e-05, pixel2: float = 7.5e-05, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
EigerEiger 9M detector
- MAX_SHAPE = (3269, 3110)#
- aliases = ('Eiger 9M',)#
- class pyFAI.detectors.FReLoN(splinefile: str | None = None, orientation=0)#
Bases:
DetectorFReLoN detector: The spline is mandatory to correct for geometric distortion of the taper
TODO: create automatically a mask that removes pixels out of the “valid region”
- HAVE_TAPER = True#
If true a spline file is mandatory to correct the geometry
- MANUFACTURER = 'ESRF'#
- MAX_SHAPE = (2048, 2048)#
- __init__(splinefile: str | None = None, orientation=0)#
Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None
- calc_mask()#
Returns a generic mask for Frelon detectors… All pixels which (center) turns to be out of the valid region are by default discarded
- class pyFAI.detectors.Fairchild(pixel1: float | None = None, pixel2: float | None = None, splinefile: str | None = None, max_shape: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
DetectorFairchild Condor 486:90 detector
- MANUFACTURER = 'Fairchild Semiconductor'#
- MAX_SHAPE = (4096, 4096)#
- PIXEL_SIZE = (1.5e-05, 1.5e-05)#
- aliases = ('Fairchild', 'Condor', 'Fairchild Condor 486:90')#
- force_pixel = True#
- uniform_pixel = True#
- class pyFAI.detectors.HF_130K(pixel1: float | None = None, pixel2: float | None = None, splinefile: str | None = None, max_shape: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
_ADSCADSC HF-130K 1 module
Information from http://www.adsc-xray.com/products/pixel-array-detectors/hf-130k/
- MAX_SHAPE = (256, 512)#
- PIXEL_SIZE = (0.00015, 0.00015)#
- aliases = ('HF-130k',)#
- force_pixel = True#
- class pyFAI.detectors.HF_1M(pixel1: float | None = None, pixel2: float | None = None, splinefile: str | None = None, max_shape: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
_ADSCADSC HF-1M 2x4 modules
Information from http://www.adsc-xray.com/products/pixel-array-detectors/hf-1m/
Nota: gaps between modules is not known/described
- MAX_SHAPE = (1024, 1024)#
- PIXEL_SIZE = (0.00015, 0.00015)#
- aliases = ('HF-1M',)#
- force_pixel = True#
- class pyFAI.detectors.HF_262k(pixel1: float | None = None, pixel2: float | None = None, splinefile: str | None = None, max_shape: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
_ADSCADSC HF-262k 2 module
Information from http://www.adsc-xray.com/products/pixel-array-detectors/hf-262k/
Nota: gaps between modules is not known/described
- MAX_SHAPE = (512, 512)#
- PIXEL_SIZE = (0.00015, 0.00015)#
- aliases = ('HF-262k',)#
- force_pixel = True#
- class pyFAI.detectors.HF_2M(pixel1: float | None = None, pixel2: float | None = None, splinefile: str | None = None, max_shape: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
_ADSCADSC HF-1M 3x6 modules
Information from http://www.adsc-xray.com/products/pixel-array-detectors/hf-2.4m/
Nota: gaps between modules is not known/described
- MAX_SHAPE = (1536, 1536)#
- PIXEL_SIZE = (0.00015, 0.00015)#
- aliases = ('HF-2.4M',)#
- force_pixel = True#
- class pyFAI.detectors.HF_4M(pixel1: float | None = None, pixel2: float | None = None, splinefile: str | None = None, max_shape: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
_ADSCADSC HF-4M 4x8 modules
Information from http://www.adsc-xray.com/products/pixel-array-detectors/hf-4m/
- MAX_SHAPE = (2048, 2048)#
- PIXEL_SIZE = (0.00015, 0.00015)#
- aliases = ('HF-4M',)#
- force_pixel = True#
- class pyFAI.detectors.HF_9M(pixel1: float | None = None, pixel2: float | None = None, splinefile: str | None = None, max_shape: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
_ADSCADSC HF-130K 1 module
Information from http://www.adsc-xray.com/products/pixel-array-detectors/hf-9-4m/
- MAX_SHAPE = (3072, 3072)#
- PIXEL_SIZE = (0.00015, 0.00015)#
- aliases = ('HF-9.4M',)#
- force_pixel = True#
- class pyFAI.detectors.HexDetector(pitch=None, pixel1=None, pixel2=None, max_shape=None, orientation=0)#
Bases:
DetectorAbstract class for regular hexagonal-pixel detectors
This is characterized by the pitch, distance between 2 pixels
Pixels are aligned horizontally with the provided pitch Vertically, 2 raws are separated by pitch*sqrt(3)/2 Odd raws are offsetted horizontally by pitch/2
- CORNERS = 6#
- IS_CONTIGUOUS = False#
- IS_FLAT = True#
- __init__(pitch=None, pixel1=None, pixel2=None, max_shape=None, orientation=0)#
Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None
- classmethod build_pixel_coordinates(shape, pitch=1)#
Build the 4D array with pixel coordinates for a detector composed of hexagonal-pixels
- Parameters:
shape – 2-tuple with size of the detector in number of pixels (y, x)
pitch – the distance between two pixels
- Returns:
array with pixel coordinates
- property pitch#
This is the distance between 2 pixel in the hexagonal pattern
- uniform_pixel = False#
- class pyFAI.detectors.ImXPadS10(pixel1=0.00013, pixel2=0.00013, max_shape=None, module_size=None, orientation=0, sensor: SensorConfig | None = None)#
Bases:
ModuleDetectorImXPad detector: ImXPad s10 detector with 1x1modules
- BORDER_SIZE_RELATIVE = 2.5#
- MANUFACTURER = 'ImXPad'#
- MAX_SHAPE = (120, 80)#
- MODULE_SIZE = (120, 80)#
- PIXEL_SIZE = (0.00013, 0.00013)#
- SENSORS = ()#
- __init__(pixel1=0.00013, pixel2=0.00013, max_shape=None, module_size=None, orientation=0, sensor: SensorConfig | None = None)#
Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None
- aliases = ('Imxpad S10',)#
- calc_cartesian_positions(d1=None, d2=None, center=True, use_cython=True)#
Calculate the position of each pixel center in cartesian coordinate and in meter of a couple of coordinates. The half pixel offset is taken into account here !!!
- Parameters:
d1 (ndarray (1D or 2D)) – the Y pixel positions (slow dimension)
d2 (ndarray (1D or 2D)) – the X pixel positions (fast dimension)
- Returns:
position in meter of the center of each pixels.
- Return type:
ndarray
d1 and d2 must have the same shape, returned array will have the same shape.
- calc_mask()#
Calculate the mask
- calc_pixels_edges()#
Calculate the position of the pixel edges
- force_pixel = True#
- get_pixel_corners(correct_binning=False)#
Calculate the position of the corner of the pixels
This should be overwritten by class representing non-contiguous detector (Xpad, …)
Precision float32 is ok: precision of 1µm for a detector size of 1m
- Returns:
4D array containing: pixel index (slow dimension) pixel index (fast dimension) corner index (A, B, C or D), triangles or hexagons can be handled the same way vertex position (z,y,x)
- uniform_pixel = False#
- class pyFAI.detectors.ImXPadS140(pixel1=0.00013, pixel2=0.00013, max_shape=None, module_size=None, orientation=0, sensor: SensorConfig | None = None)#
Bases:
ImXPadS10ImXPad detector: ImXPad s140 detector with 2x7modules
- BORDER_PIXEL_SIZE_RELATIVE = 2.5#
- MAX_SHAPE = (240, 560)#
- MODULE_SIZE = (120, 80)#
- PIXEL_SIZE = (0.00013, 0.00013)#
- aliases = ('Imxpad S140',)#
- force_pixel = True#
- class pyFAI.detectors.ImXPadS70(pixel1=0.00013, pixel2=0.00013, max_shape=None, module_size=None, orientation=0, sensor: SensorConfig | None = None)#
Bases:
ImXPadS10ImXPad detector: ImXPad s70 detector with 1x7modules
- BORDER_SIZE_RELATIVE = 2.5#
- MAX_SHAPE = (120, 560)#
- MODULE_SIZE = (120, 80)#
- PIXEL_EDGES = None#
- PIXEL_SIZE = (0.00013, 0.00013)#
- __init__(pixel1=0.00013, pixel2=0.00013, max_shape=None, module_size=None, orientation=0, sensor: SensorConfig | None = None)#
Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None
- aliases = ('Imxpad S70',)#
- force_pixel = True#
- class pyFAI.detectors.ImXPadS70V(pixel1=0.00013, pixel2=0.00013, max_shape=None, module_size=None, orientation=0, sensor: SensorConfig | None = None)#
Bases:
ImXPadS10ImXPad detector: ImXPad s70 detector with 1x7modules
- BORDER_SIZE_RELATIVE = 2.5#
- MAX_SHAPE = (560, 120)#
- MODULE_SIZE = (80, 120)#
- PIXEL_EDGES = None#
- PIXEL_SIZE = (0.00013, 0.00013)#
- aliases = ('Imxpad S70 V',)#
- force_pixel = True#
- class pyFAI.detectors.Jungfrau(pixel1=7.5e-05, pixel2=7.5e-05, max_shape=None, module_size=None, orientation=0, sensor: SensorConfig | None = None)#
Bases:
ModuleDetectorRaw Jungfrau module without sub-module pixel expansion applied.
- BORDER_SIZE_RELATIVE = 2.0#
- MANUFACTURER = 'PSI'#
- MAX_SHAPE = (512, 1024)#
- MODULE_SIZE = (256, 256)#
- PIXEL_SIZE = (7.5e-05, 7.5e-05)#
- SENSORS = ({ "material": "Si", "thickness": 0.00032 }, { "material": "Si", "thickness": 0.00045 })#
- __init__(pixel1=7.5e-05, pixel2=7.5e-05, max_shape=None, module_size=None, orientation=0, sensor: SensorConfig | None = None)#
Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None
- aliases = ('Jungfrau 500k',)#
- calc_cartesian_positions(d1=None, d2=None, center=True, use_cython=True)#
Calculate the position of each pixel center in cartesian coordinate and in meter of a couple of coordinates. The half pixel offset is taken into account here !!!
- Parameters:
d1 (ndarray (1D or 2D)) – the Y pixel positions (slow dimension)
d2 (ndarray (1D or 2D)) – the X pixel positions (fast dimension)
- Returns:
position in meter of the center of each pixels.
- Return type:
ndarray
d1 and d2 must have the same shape, returned array will have the same shape.
- calc_pixels_edges()#
Calculate the position of the pixel edges
- force_pixel = True#
- get_pixel_corners(correct_binning=False)#
Calculate the position of the corner of the pixels
This should be overwritten by class representing non-contiguous detector (Xpad, …)
Precision float32 is ok: precision of 1µm for a detector size of 1m
- Returns:
4D array containing: pixel index (slow dimension) pixel index (fast dimension) corner index (A, B, C or D), triangles or hexagons can be handled the same way vertex position (z,y,x)
- uniform_pixel = False#
- class pyFAI.detectors.Jungfrau1M(pixel1=7.5e-05, pixel2=7.5e-05, max_shape=None, module_size=None, orientation=0, sensor: SensorConfig | None = None)#
Bases:
Jungfrau4MJungfrau 1M module without sub-module pixel expansion applied.
- MANUFACTURER = 'PSI'#
- MAX_SHAPE = (1064, 1030)#
- MODULE_GAP = (36, 8)#
- MODULE_SIZE = (514, 1030)#
- PIXEL_SIZE = (7.5e-05, 7.5e-05)#
- aliases = ('Jungfrau 1M',)#
- force_pixel = True#
- uniform_pixel = True#
- class pyFAI.detectors.Jungfrau4M(pixel1=7.5e-05, pixel2=7.5e-05, max_shape=None, module_size=None, orientation=0, sensor: SensorConfig | None = None)#
Bases:
_DectrisJungfrau 4M module without sub-module pixel expansion applied.
- MANUFACTURER = 'PSI'#
- MAX_SHAPE = (2164, 2068)#
- MODULE_GAP = (36, 8)#
- MODULE_SIZE = (514, 1030)#
- PIXEL_SIZE = (7.5e-05, 7.5e-05)#
- SENSORS = ({ "material": "Si", "thickness": 0.00032 }, { "material": "Si", "thickness": 0.00045 })#
- __init__(pixel1=7.5e-05, pixel2=7.5e-05, max_shape=None, module_size=None, orientation=0, sensor: SensorConfig | None = None)#
Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None
- aliases = ('Jungfrau 4M',)#
- force_pixel = True#
- uniform_pixel = True#
- class pyFAI.detectors.Jungfrau8M(pixel1=7.5e-05, pixel2=7.5e-05, max_shape=None, module_size=None, orientation=0, sensor: SensorConfig | None = None)#
Bases:
JungfrauJungfrau 8M module composed of 16 modules, 12 horizontals and 4 vertical
To simplify the layout, one considers the chips (256x256) thus there are 128 chips (8 per modules)
- MANUFACTURER = 'PSI'#
- MAX_SHAPE = (3333, 3212)#
- MODULE_SIZE = (256, 256)#
- PIXEL_SIZE = (7.5e-05, 7.5e-05)#
- __init__(pixel1=7.5e-05, pixel2=7.5e-05, max_shape=None, module_size=None, orientation=0, sensor: SensorConfig | None = None)#
Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None
- aliases = ('Jungfrau 8M',)#
- calc_mask()#
Method calculating the mask for a given detector
Detectors with gaps should overwrite this method with something actually calculating the mask!
- Returns:
the mask with valid pixel to 0
- Return type:
numpy ndarray of int8 or None
- force_pixel = True#
- module_positions = ([1, 607], [1, 866], [1, 1124], [1, 1382], [69, 1646], [69, 1905], [69, 2163], [69, 2421], [259, 607], [259, 866], [259, 1124], [259, 1382], [328, 1646], [328, 1905], [328, 2163], [328, 2421], [550, 607], [550, 866], [550, 1124], [550, 1382], [619, 1646], [619, 1905], [619, 2163], [619, 2421], [667, 2698], [667, 2957], [809, 607], [809, 866], [809, 1124], [809, 1382], [597, 69], [597, 328], [856, 69], [856, 328], [878, 1646], [878, 1905], [878, 2163], [878, 2421], [926, 2698], [926, 2957], [1185, 2698], [1185, 2957], [1100, 607], [1100, 866], [1100, 1124], [1100, 1382], [1114, 69], [1114, 328], [1169, 1646], [1169, 1905], [1169, 2163], [1169, 2421], [1359, 607], [1359, 866], [1359, 1124], [1359, 1382], [1372, 69], [1372, 328], [1428, 1646], [1428, 1905], [1428, 2163], [1428, 2421], [1442, 2698], [1442, 2957], [1636, 1], [1636, 259], [1650, 538], [1650, 797], [1650, 1055], [1650, 1313], [1706, 2629], [1706, 2888], [1719, 1577], [1719, 1836], [1719, 2094], [1719, 2352], [1895, 1], [1895, 259], [1909, 538], [1909, 797], [1909, 1055], [1909, 1313], [1965, 2629], [1965, 2888], [1978, 1577], [1978, 1836], [1978, 2094], [1978, 2352], [2153, 1], [2153, 259], [2200, 538], [2200, 797], [2200, 1055], [2200, 1313], [2223, 2629], [2223, 2888], [2269, 1577], [2269, 1836], [2269, 2094], [2269, 2352], [2411, 1], [2411, 259], [2459, 538], [2459, 797], [2459, 1055], [2459, 1313], [2481, 2629], [2481, 2888], [2528, 1577], [2528, 1836], [2528, 2094], [2528, 2352], [2750, 538], [2750, 797], [2750, 1055], [2750, 1313], [2819, 1577], [2819, 1836], [2819, 2094], [2819, 2352], [3009, 538], [3009, 797], [3009, 1055], [3009, 1313], [3078, 1577], [3078, 1836], [3078, 2094], [3078, 2352])#
- uniform_pixel = True#
- class pyFAI.detectors.Jungfrau_16M_cor(pixel1=7.5e-05, pixel2=7.5e-05, max_shape=None, module_size=None, orientation=0, sensor: SensorConfig | None = None)#
Bases:
JungfrauJungfrau 16 corrected for double-sized pixels
- MAX_SHAPE = (16448, 1030)#
- MODULE_SIZE = (514, 1030)#
- aliases = ('Jungfrau 16M cor',)#
- calc_mask()#
Mask out sub-module junctions
- force_pixel = True#
- init_from_geometry(filename)#
initialize the detector from “geom” file produced at PSI
- static load_geom(geom_fname)#
“Load module geometry from ASCII file
Based on Alejandro Homs’ code
- class pyFAI.detectors.Lambda10M(pixel1=5.5e-05, pixel2=5.5e-05, max_shape=None, module_size=None, orientation=0, sensor: SensorConfig | None = None)#
Bases:
_LambdaLAMBDA 10M detector
- MAX_SHAPE = (2596, 4676)#
- aliases = ('Lambda 10M',)#
- class pyFAI.detectors.Lambda250k(pixel1=5.5e-05, pixel2=5.5e-05, max_shape=None, module_size=None, orientation=0, sensor: SensorConfig | None = None)#
Bases:
_LambdaLAMBDA 250k detector
- MAX_SHAPE = (516, 516)#
- aliases = ('Lambda 250k',)#
- class pyFAI.detectors.Lambda2M(pixel1=5.5e-05, pixel2=5.5e-05, max_shape=None, module_size=None, orientation=0, sensor: SensorConfig | None = None)#
Bases:
_LambdaLAMBDA 2M detector
- MAX_SHAPE = (1556, 1556)#
- aliases = ('Lambda 2M',)#
- class pyFAI.detectors.Lambda60k(pixel1=5.5e-05, pixel2=5.5e-05, max_shape=None, module_size=None, orientation=0, sensor: SensorConfig | None = None)#
Bases:
_LambdaLAMBDA 60k detector
- MAX_SHAPE = (256, 256)#
- aliases = ('Lambda 60k',)#
- class pyFAI.detectors.Lambda750k(pixel1=5.5e-05, pixel2=5.5e-05, max_shape=None, module_size=None, orientation=0, sensor: SensorConfig | None = None)#
Bases:
_LambdaLAMBDA 750k detector
- MAX_SHAPE = (516, 1556)#
- aliases = ('Lambda 750k',)#
- class pyFAI.detectors.Lambda7M5(pixel1=5.5e-05, pixel2=5.5e-05, max_shape=None, module_size=None, orientation=0, sensor: SensorConfig | None = None)#
Bases:
_LambdaLAMBDA 7.5M detector
- MAX_SHAPE = (2596, 2596)#
- aliases = ('Lambda 7.5M',)#
- class pyFAI.detectors.Lambda9M(pixel1=5.5e-05, pixel2=5.5e-05, max_shape=None, module_size=None, orientation=0, sensor: SensorConfig | None = None)#
Bases:
_LambdaLAMBDA 9M detector
- MAX_SHAPE = (3868, 3227)#
- aliases = ('Lambda 9M',)#
- calc_mask()#
Returns a generic mask for module based detectors…
- class pyFAI.detectors.Mar345(pixel1=0.0001, pixel2=0.0001, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#
Bases:
DetectorMar345 Imaging plate detector
In this detector, pixels are always square The valid image size are 2300, 2000, 1600, 1200, 3450, 3000, 2400, 1800
- MANUFACTURER = 'Mar Research'#
- MAX_SHAPE = (3450, 3450)#
- SENSORS = ({ "material": "BaFBr0.85I0.15", "thickness": 0.000124 },)#
- VALID_SIZE: ClassVar[dict] = {1200: 0.00015, 1600: 0.00015, 1800: 0.0001, 2000: 0.00015, 2300: 0.00015, 2400: 0.0001, 3000: 0.0001, 3450: 0.0001}#
- __init__(pixel1=0.0001, pixel2=0.0001, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#
Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None
- aliases = ('MAR 345', 'Mar3450')#
- calc_mask()#
Method calculating the mask for a given detector
Detectors with gaps should overwrite this method with something actually calculating the mask!
- Returns:
the mask with valid pixel to 0
- Return type:
numpy ndarray of int8 or None
- force_pixel = True#
- guess_binning(data)#
Guess the binning/mode depending on the image shape :param data: 2-tuple with the shape of the image or the image with a .shape attribute. :return: True if the data fit the detector :rtype: bool
- class pyFAI.detectors.Mar555(pixel1=0.000139, pixel2=0.000139, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#
Bases:
DetectorMar555 is a Selenium flat panel detector.
The detector specifications are adapted from http://xds.mpimf-heidelberg.mpg.de/html_doc/detectors.html
- MANUFACTURER = 'Mar Research'#
- MAX_SHAPE = (3072, 2560)#
- SENSORS = ({ "material": "Se", "thickness": 0.0003 },)#
- __init__(pixel1=0.000139, pixel2=0.000139, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#
Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None
- aliases = ('MAR 555',)#
- force_pixel = True#
- class pyFAI.detectors.Maxipix(pixel1=5.5e-05, pixel2=5.5e-05, max_shape=None, module_size=None, orientation=0, sensor: SensorConfig | None = None)#
Bases:
ModuleDetectorESRF Maxipix detector: generic description containing mask algorithm
Sub-classed by Maxipix2x2 and Maxipix5x1
- MANUFACTURER = 'ESRF'#
- MAX_SHAPE = (256, 256)#
- MODULE_GAP = (4, 4)#
- MODULE_SIZE = (256, 256)#
- PIXEL_SIZE = (5.5e-05, 5.5e-05)#
- SENSORS = ({ "material": "Si", "thickness": 0.0005 },)#
- __init__(pixel1=5.5e-05, pixel2=5.5e-05, max_shape=None, module_size=None, orientation=0, sensor: SensorConfig | None = None)#
Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None
- aliases = ('Maxipix 1x1', 'Maxipix1x1')#
- calc_mask()#
Returns a generic mask for Maxipix detectors…
- force_pixel = True#
- class pyFAI.detectors.Maxipix2x2(pixel1=5.5e-05, pixel2=5.5e-05, max_shape=None, module_size=None, orientation=0, sensor: SensorConfig | None = None)#
Bases:
MaxipixMaxipix 2x2 detector
- MAX_SHAPE = (516, 516)#
- aliases = ('Maxipix 2x2',)#
- class pyFAI.detectors.Maxipix5x1(pixel1=5.5e-05, pixel2=5.5e-05, max_shape=None, module_size=None, orientation=0, sensor: SensorConfig | None = None)#
Bases:
MaxipixMaxipix 5x1 detector
- MAX_SHAPE = (256, 1296)#
- aliases = ('Maxipix 5x1',)#
- class pyFAI.detectors.ModuleDetector(pixel1: float | None = None, pixel2: float | None = None, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
DetectorBase class for all modular detectors (e.g., Dectris, Lambda, Imxpad). Factors out the common logic for handling module size and gaps in configuration.
- MODULE_SIZE = (None, None)#
- __init__(pixel1: float | None = None, pixel2: float | None = None, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None
- get_config()#
Detector.get_config handles already: pixel1, pixel2, orientation, max_shape, splinefile, sensor Extends Detector.get_config to include module_size
- set_config(config: dict | str)#
Detector.set_config handles already enforcment of pixel, splinefile, orientation, sensor Extends Detector.set_config to handle module_size.
- class pyFAI.detectors.Mythen(pixel1: float | None = None, pixel2: float | None = None, splinefile: str | None = None, max_shape: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
DetectorMythen strip detector from Dectris
- MANUFACTURER = 'Dectris'#
- MAX_SHAPE = (1, 1280)#
- PIXEL_SIZE = (0.008, 5e-05)#
- SENSORS = ({ "material": "Si", "thickness": 0.00032 }, { "material": "Si", "thickness": 0.00045 }, { "material": "Si", "thickness": 0.001 })#
- aliases = ('Mythen 1280',)#
- calc_mask()#
Mythen has no masks
- force_pixel = True#
- class pyFAI.detectors.NexusDetector(filename: str | None = None, orientation: int = 0, sensor: SensorConfig | None = None)#
Bases:
DetectorClass representing a 2D detector loaded from a NeXus file
- __init__(filename: str | None = None, orientation: int = 0, sensor: SensorConfig | None = None)#
Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None
- property filename: str | None#
Returns the filename containing the description of this detector.
- Return type:
Enum[None|str]
- getFit2D()#
Helper method to serialize the description of a detector using the Fit2d units
- Returns:
representation of the detector easy to serialize
- Return type:
dict
- getPyFAI()#
Helper method to serialize the description of a detector using the pyFAI way with everything in S.I units.
- Returns:
representation of the detector easy to serialize
- Return type:
dict
- get_config()#
Return the configuration with arguments to the constructor.
- get_filename() str | None#
Returns the filename containing the description of this detector.
- Return type:
Enum[None|str]
- load(filename)#
Loads the detector description from a NeXus file, adapted from: http://download.nexusformat.org/sphinx/classes/base_classes/NXdetector.html
- Parameters:
filename – name of the file on the disk
- Returns:
self
- set_config(config: dict | str)#
set the config of the detector
For Nexus detector, the valid keys are “filename”, “orientation, “sensor”
- Parameters:
config – dict or JSON serialized dict
- Returns:
detector instance
- classmethod sload(filename)#
Instantiate the detector description from a NeXus file, adapted from: http://download.nexusformat.org/sphinx/classes/base_classes/NXdetector.html
- Parameters:
filename – name of the file on the disk
- Returns:
Detector instance
- class pyFAI.detectors.Perkin(pixel1=0.0002, pixel2=0.0002, max_shape=None, orientation=0)#
Bases:
DetectorPerkin detector
- DEFAULT_PIXEL1 = 0.0002#
- DEFAULT_PIXEL2 = 0.0002#
- MANUFACTURER = 'Perkin Elmer'#
- MAX_SHAPE = (4096, 4096)#
- PIXEL_SIZE = (0.0002, 0.0002)#
- __init__(pixel1=0.0002, pixel2=0.0002, max_shape=None, orientation=0)#
Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None
- aliases = ('Perkin detector', 'Perkin Elmer')#
- force_pixel = True#
- class pyFAI.detectors.Pilatus(pixel1: float = 0.000172, pixel2: float = 0.000172, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, x_offset_file: str | None = None, y_offset_file: str | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
_DectrisPilatus detector: generic description containing mask algorithm
Sub-classed by Pilatus1M, Pilatus2M and Pilatus6M
- MODULE_GAP = (17, 7)#
- MODULE_SIZE = (195, 487)#
- PIXEL_SIZE = (0.000172, 0.000172)#
- SENSORS = ({ "material": "Si", "thickness": 0.00032 }, { "material": "Si", "thickness": 0.00045 }, { "material": "Si", "thickness": 0.001 })#
- __init__(pixel1: float = 0.000172, pixel2: float = 0.000172, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, x_offset_file: str | None = None, y_offset_file: str | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None
- calc_cartesian_positions(d1=None, d2=None, center=True, use_cython=True)#
Calculate the position of each pixel center in cartesian coordinate and in meter of a couple of coordinates. The half pixel offset is taken into account here !!!
- Parameters:
d1 (ndarray (1D or 2D)) – the Y pixel positions (slow dimension)
d2 (ndarray (1D or 2D)) – the X pixel positions (fast dimension)
- Returns:
position in meter of the center of each pixels.
- Return type:
ndarray
d1 and d2 must have the same shape, returned array will have the same shape.
- force_pixel = True#
- get_config()#
Return the configuration with arguments to the constructor
- Returns:
dict with param for serialization
- get_splineFile()#
- set_config(config: dict | str)#
set the config of the detector
For Pilatus detector, possible keys are: max_shape, module_size, x_offset_file, y_offset_file, orientation, sensor
- Parameters:
config – dict or JSON serialized dict
- Returns:
detector instance
- set_offset_files(x_offset_file=None, y_offset_file=None)#
- set_splineFile(splinefile=None)#
In this case splinefile is a couple filenames
- property splineFile#
- property splinefile#
- class pyFAI.detectors.Pilatus100k(pixel1: float = 0.000172, pixel2: float = 0.000172, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, x_offset_file: str | None = None, y_offset_file: str | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
PilatusPilatus 100k detector
- MAX_SHAPE = (195, 487)#
- aliases = ('Pilatus 100k',)#
- class pyFAI.detectors.Pilatus1M(pixel1: float = 0.000172, pixel2: float = 0.000172, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, x_offset_file: str | None = None, y_offset_file: str | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
PilatusPilatus 1M detector
- MAX_SHAPE = (1043, 981)#
- aliases = ('Pilatus 1M',)#
- class pyFAI.detectors.Pilatus200k(pixel1: float = 0.000172, pixel2: float = 0.000172, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, x_offset_file: str | None = None, y_offset_file: str | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
PilatusPilatus 200k detector
- MAX_SHAPE = (407, 487)#
- aliases = ('Pilatus 200k',)#
- class pyFAI.detectors.Pilatus2M(pixel1: float = 0.000172, pixel2: float = 0.000172, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, x_offset_file: str | None = None, y_offset_file: str | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
PilatusPilatus 2M detector
- MAX_SHAPE = (1679, 1475)#
- aliases = ('Pilatus 2M',)#
- class pyFAI.detectors.Pilatus300k(pixel1: float = 0.000172, pixel2: float = 0.000172, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, x_offset_file: str | None = None, y_offset_file: str | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
PilatusPilatus 300k detector
- MAX_SHAPE = (619, 487)#
- aliases = ('Pilatus 300k',)#
- class pyFAI.detectors.Pilatus300kw(pixel1: float = 0.000172, pixel2: float = 0.000172, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, x_offset_file: str | None = None, y_offset_file: str | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
PilatusPilatus 300k-wide detector
- MAX_SHAPE = (195, 1475)#
- aliases = ('Pilatus 300kw',)#
- class pyFAI.detectors.Pilatus4(pixel1: float = 0.00015, pixel2: float = 0.00015, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
_DectrisPilatus4 detector: generic description containing mask algorithm
Sub-classed by Pilatus4_1M, Pilatus4_2M and Pilatus_4M
- MODULE_GAP = (20, 7)#
- MODULE_SIZE = (255, 513)#
- PIXEL_SIZE = (0.00015, 0.00015)#
- SENSORS = ({ "material": "Si", "thickness": 0.00045 },)#
- __init__(pixel1: float = 0.00015, pixel2: float = 0.00015, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None
- force_pixel = True#
- class pyFAI.detectors.Pilatus4_1M(pixel1: float = 0.00015, pixel2: float = 0.00015, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
Pilatus4- MAX_SHAPE = (1080, 1033)#
- aliases = ('Pilatus4 1M',)#
- class pyFAI.detectors.Pilatus4_260k(pixel1: float = 0.00015, pixel2: float = 0.00015, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
Pilatus4- MAX_SHAPE = (530, 513)#
- aliases = ('Pilatus4 260k',)#
- class pyFAI.detectors.Pilatus4_260kw(pixel1: float = 0.00015, pixel2: float = 0.00015, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
Pilatus4- MAX_SHAPE = (255, 1033)#
- aliases = ('Pilatus4 260kw',)#
- class pyFAI.detectors.Pilatus4_2M(pixel1: float = 0.00015, pixel2: float = 0.00015, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
Pilatus4- MAX_SHAPE = (1630, 1553)#
- aliases = ('Pilatus4 2M',)#
- class pyFAI.detectors.Pilatus4_4M(pixel1: float = 0.00015, pixel2: float = 0.00015, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
Pilatus4- MAX_SHAPE = (2180, 2073)#
- aliases = ('Pilatus4 4M',)#
- class pyFAI.detectors.Pilatus4_CdTe(pixel1: float = 0.00015, pixel2: float = 0.00015, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
Pilatus4Pilatus CdTe detector: Like the Pilatus4 with an extra gap of 1 pixel in the middle of every module (vertically)
- SENSORS = ({ "material": "CdTe", "thickness": 0.001 },)#
- calc_mask()#
Mask out an extra 3 pixel in the middle of each module
- class pyFAI.detectors.Pilatus4_CdTe_1M(pixel1: float = 0.00015, pixel2: float = 0.00015, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
Pilatus4_CdTe- MAX_SHAPE = (1080, 1033)#
- aliases = ('Pilatus4 1M CdTe',)#
- class pyFAI.detectors.Pilatus4_CdTe_260k(pixel1: float = 0.00015, pixel2: float = 0.00015, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
Pilatus4_CdTe- MAX_SHAPE = (530, 513)#
- aliases = ('Pilatus4 260k CdTe',)#
- class pyFAI.detectors.Pilatus4_CdTe_260kw(pixel1: float = 0.00015, pixel2: float = 0.00015, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
Pilatus4_CdTe- MAX_SHAPE = (255, 1033)#
- aliases = ('Pilatus4 260kw CdTe',)#
- class pyFAI.detectors.Pilatus4_CdTe_2M(pixel1: float = 0.00015, pixel2: float = 0.00015, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
Pilatus4_CdTe- MAX_SHAPE = (1630, 1553)#
- aliases = ('Pilatus4 2M CdTe',)#
- class pyFAI.detectors.Pilatus4_CdTe_4M(pixel1: float = 0.00015, pixel2: float = 0.00015, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
Pilatus4_CdTe- MAX_SHAPE = (2180, 2073)#
- aliases = ('Pilatus4 4M CdTe',)#
- class pyFAI.detectors.Pilatus6M(pixel1: float = 0.000172, pixel2: float = 0.000172, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, x_offset_file: str | None = None, y_offset_file: str | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
PilatusPilatus 6M detector
- MAX_SHAPE = (2527, 2463)#
- aliases = ('Pilatus 6M',)#
- class pyFAI.detectors.Pilatus900k(pixel1: float = 0.000172, pixel2: float = 0.000172, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, x_offset_file: str | None = None, y_offset_file: str | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
PilatusPilatus 900k detector, assembly of 3x3 modules Available at NSLS-II 12-ID.
This is different from the “Pilatus CdTe 900kw” available at ESRF ID06-LVP which is 1x9 modules
- MAX_SHAPE = (619, 1475)#
- aliases = ('Pilatus 900k',)#
- class pyFAI.detectors.PilatusCdTe(pixel1: float = 0.000172, pixel2: float = 0.000172, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, x_offset_file: str | None = None, y_offset_file: str | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
PilatusPilatus CdTe detector: Like the Pilatus with an extra 3 pixel in the middle of every module (vertically)
- SENSORS = ({ "material": "CdTe", "thickness": 0.001 },)#
- calc_mask()#
Mask out an extra 3 pixel in the middle of each module
- class pyFAI.detectors.PilatusCdTe1M(pixel1: float = 0.000172, pixel2: float = 0.000172, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, x_offset_file: str | None = None, y_offset_file: str | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
PilatusCdTePilatus CdTe 1M detector
- MAX_SHAPE = (1043, 981)#
- aliases = ('Pilatus CdTe 1M', 'Pilatus 1M CdTe', 'Pilatus1M CdTe', 'Pilatus1MCdTe')#
- class pyFAI.detectors.PilatusCdTe2M(pixel1: float = 0.000172, pixel2: float = 0.000172, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, x_offset_file: str | None = None, y_offset_file: str | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
PilatusCdTePilatus CdTe 2M detector
- MAX_SHAPE = (1679, 1475)#
- aliases = ('Pilatus CdTe 2M', 'Pilatus 2M CdTe', 'Pilatus2M CdTe', 'Pilatus2MCdTe')#
- class pyFAI.detectors.PilatusCdTe300k(pixel1: float = 0.000172, pixel2: float = 0.000172, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, x_offset_file: str | None = None, y_offset_file: str | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
PilatusCdTePilatus CdTe 300k detector
- MAX_SHAPE = (619, 487)#
- aliases = ('Pilatus CdTe 300k', 'Pilatus 300k CdTe', 'Pilatus300k CdTe', 'Pilatus300kCdTe')#
- class pyFAI.detectors.PilatusCdTe300kw(pixel1: float = 0.000172, pixel2: float = 0.000172, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, x_offset_file: str | None = None, y_offset_file: str | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
PilatusCdTePilatus CdTe 300k-wide detector
- MAX_SHAPE = (195, 1475)#
- aliases = ('Pilatus CdTe 300kw', 'Pilatus 300kw CdTe', 'Pilatus300kw CdTe', 'Pilatus300kwCdTe')#
- class pyFAI.detectors.PilatusCdTe900kw(pixel1: float = 0.000172, pixel2: float = 0.000172, max_shape: tuple[int, int] | None = None, module_size: tuple[int, int] | None = None, x_offset_file: str | None = None, y_offset_file: str | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
PilatusCdTePilatus CdTe 900k-wide detector, assembly of 1x9 modules Available at ESRF ID06-LVP
This differs from the “Pilatus 900k” detector, assembly of 3x3 modules, available at NSLS-II 12-ID.
- MAX_SHAPE = (195, 4439)#
- aliases = ('Pilatus CdTe 900kw', 'Pilatus 900kw CdTe', 'Pilatus900kw CdTe', 'Pilatus900kwCdTe')#
- class pyFAI.detectors.Pixirad1(pitch=6e-05, pixel1=None, pixel2=None, max_shape=None, orientation=0)#
Bases:
HexDetector- MANUFACTURER = 'Pixirad'#
- MAX_SHAPE = (476, 512)#
- __init__(pitch=6e-05, pixel1=None, pixel2=None, max_shape=None, orientation=0)#
Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None
- aliases = ('Pixirad-1',)#
- class pyFAI.detectors.Pixirad2(pitch=6e-05, pixel1=None, pixel2=None, max_shape=None, orientation=0)#
Bases:
HexDetector- MANUFACTURER = 'Pixirad'#
- MAX_SHAPE = (476, 1024)#
- __init__(pitch=6e-05, pixel1=None, pixel2=None, max_shape=None, orientation=0)#
Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None
- aliases = ('Pixirad-2',)#
- class pyFAI.detectors.Pixirad4(pitch=6e-05, pixel1=None, pixel2=None, max_shape=None, orientation=0)#
Bases:
HexDetector- MANUFACTURER = 'Pixirad'#
- MAX_SHAPE = (476, 2048)#
- __init__(pitch=6e-05, pixel1=None, pixel2=None, max_shape=None, orientation=0)#
Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None
- aliases = ('Pixirad-4',)#
- class pyFAI.detectors.Pixirad8(pitch=6e-05, pixel1=None, pixel2=None, max_shape=None, orientation=0)#
Bases:
HexDetector- MANUFACTURER = 'Pixirad'#
- MAX_SHAPE = (476, 4096)#
- __init__(pitch=6e-05, pixel1=None, pixel2=None, max_shape=None, orientation=0)#
Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None
- aliases = ('Pixirad-8',)#
- class pyFAI.detectors.Pixium(pixel1=0.000308, pixel2=0.000308, max_shape=None, orientation=0)#
Bases:
DetectorPIXIUM 4700 detector
High energy X ray diffraction using the Pixium 4700 flat panel detector J E Daniels, M Drakopoulos, et al.; Journal of Synchrotron Radiation 16(Pt 4):463-8 · August 2009
- DEFAULT_PIXEL1 = 0.000154#
- DEFAULT_PIXEL2 = 0.000154#
- MANUFACTURER = 'Thales Electronics'#
- MAX_SHAPE = (1910, 2480)#
- PIXEL_SIZE = (0.000308, 0.000308)#
- __init__(pixel1=0.000308, pixel2=0.000308, max_shape=None, orientation=0)#
Defaults to 2x2 binning
- aliases = ('Pixium 4700', 'Pixium 4700 detector', 'Thales Electronics')#
- force_pixel = True#
- class pyFAI.detectors.Rapid(pixel1=0.0001, pixel2=0.0001, radius=0.12726, orientation=0)#
Bases:
CylindricalDetectorCylindrical detector: Rigaku R-axis RAPID II Unlike the Aarhus detector, the detectors is bent the other direction. It covers 210° r = 127.26mm pixel size 100µm but can be binned 2x2
Credits: Private communication; Dr. Jozef Bednarčík Department of Condensed Matter Physics Institute of Physics P.J. Šafárik University, Košice, Slovakia
The image has to be laid-out horizontally
Nota: the detector is bend towards the sample, hence reducing the sample-detector distance. This is why z<0 (or p3<0)
- MANUFACTURER = 'Rigaku'#
- MAX_SHAPE = (2560, 4700)#
- __init__(pixel1=0.0001, pixel2=0.0001, radius=0.12726, orientation=0)#
Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None
- aliases = ('RapidII',)#
- class pyFAI.detectors.RaspberryPi12M(pixel1: float | None = None, pixel2: float | None = None, splinefile: str | None = None, max_shape: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
Detector8 Mpix detector from Raspberry Pi
- MAX_SHAPE = (3040, 4056)#
- PIXEL_SIZE = (1.55e-06, 1.55e-06)#
- aliases = ('Picam HQ',)#
- force_pixel = True#
- class pyFAI.detectors.RaspberryPi5M(pixel1: float | None = None, pixel2: float | None = None, splinefile: str | None = None, max_shape: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
Detector5 Mpix detector from Raspberry Pi
- MAX_SHAPE = (1944, 2592)#
- PIXEL_SIZE = (1.4e-06, 1.4e-06)#
- aliases = ('Picam v1',)#
- force_pixel = True#
- class pyFAI.detectors.RaspberryPi8M(pixel1: float | None = None, pixel2: float | None = None, splinefile: str | None = None, max_shape: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
Detector8 Mpix detector from Raspberry Pi
- MAX_SHAPE = (2464, 3280)#
- PIXEL_SIZE = (1.12e-06, 1.12e-06)#
- aliases = ('Picam v2',)#
- force_pixel = True#
- class pyFAI.detectors.Rayonix133(pixel1=6.4e-05, pixel2=6.4e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#
Bases:
_RayonixRayonix 133 2D CCD detector detector also known as mar133
personal communication from M. Blum
What should be the default binning factor for those cameras ?
Circular detector
- BINNED_PIXEL_SIZE: ClassVar[dict] = {1: 3.2e-05, 2: 6.4e-05, 4: 0.000128, 8: 0.000256}#
- MANUFACTURER: ClassVar[list] = ['Rayonix', 'Mar Research']#
- MAX_SHAPE = (4096, 4096)#
- __init__(pixel1=6.4e-05, pixel2=6.4e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#
Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None
- aliases = ('Rayonix133', 'MAR 133', 'MAR133')#
- calc_mask()#
Circular mask
- force_pixel = True#
- class pyFAI.detectors.RayonixLx170(pixel1=4.42708e-05, pixel2=4.42708e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#
Bases:
_RayonixRayonix lx170 2d CCD Detector (2x1 CCDs).
Nota: this is the same for lx170hs
- BINNED_PIXEL_SIZE: ClassVar[dict] = {1: 4.42708e-05, 2: 8.85417e-05, 3: 0.0001328125, 4: 0.0001770833, 5: 0.0002213542, 6: 0.000265625, 8: 0.0003541667, 10: 0.0004427083}#
- MAX_SHAPE = (1920, 3840)#
- __init__(pixel1=4.42708e-05, pixel2=4.42708e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#
Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None
- aliases = ('Rayonix LX170', 'Rayonix LX170-HS', 'Rayonix LX170 HS', 'RayonixLX170HS')#
- force_pixel = True#
- class pyFAI.detectors.RayonixLx255(pixel1=4.42708e-05, pixel2=4.42708e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#
Bases:
_RayonixRayonix lx255 2d Detector (3x1 CCDs)
Nota: this detector is also called lx255hs
- BINNED_PIXEL_SIZE: ClassVar[dict] = {1: 4.42708e-05, 2: 8.85417e-05, 3: 0.0001328125, 4: 0.0001770833, 5: 0.0002213542, 6: 0.000265625, 8: 0.0003541667, 10: 0.0004427083}#
- MAX_SHAPE = (1920, 5760)#
- __init__(pixel1=4.42708e-05, pixel2=4.42708e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#
Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None
- aliases = ('Rayonix LX255', 'Rayonix LX255-HS', 'Rayonix LX 255HS', 'RayonixLX225HS')#
- class pyFAI.detectors.RayonixMx170(pixel1=4.42708e-05, pixel2=4.42708e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#
Bases:
_RayonixRayonix mx170 2d CCD Detector (2x2 CCDs).
Nota: this is the same for mx170hs
- BINNED_PIXEL_SIZE: ClassVar[dict] = {1: 4.42708e-05, 2: 8.85417e-05, 3: 0.0001328125, 4: 0.0001770833, 5: 0.0002213542, 6: 0.000265625, 8: 0.0003541667, 10: 0.0004427083}#
- MAX_SHAPE = (3840, 3840)#
- __init__(pixel1=4.42708e-05, pixel2=4.42708e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#
Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None
- aliases = ('Rayonix MX170', 'Rayonix MX170-HS', 'RayonixMX170HS', 'Rayonix MX170 HS')#
- class pyFAI.detectors.RayonixMx225(pixel1=7.3242e-05, pixel2=7.3242e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#
Bases:
_RayonixRayonix mx225 2D CCD detector detector
Nota: this is the same definition for mx225he personal communication from M. Blum
- BINNED_PIXEL_SIZE: ClassVar[dict] = {1: 3.6621e-05, 2: 7.3242e-05, 3: 0.000109971, 4: 0.000146484, 8: 0.000292969}#
- MANUFACTURER: ClassVar[list] = ['Rayonix', 'Mar Research']#
- MAX_SHAPE = (6144, 6144)#
- __init__(pixel1=7.3242e-05, pixel2=7.3242e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#
Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None
- aliases = ('Rayonix MX225', 'MAR 225', 'MAR225')#
- force_pixel = True#
- class pyFAI.detectors.RayonixMx225hs(pixel1=7.8125e-05, pixel2=7.8125e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#
Bases:
_RayonixRayonix mx225hs 2D CCD detector detector
Pixel size from a personal communication from M. Blum
- BINNED_PIXEL_SIZE: ClassVar[dict] = {1: 3.90625e-05, 2: 7.8125e-05, 3: 0.0001171875, 4: 0.00015625, 5: 0.0001953125, 6: 0.000234375, 8: 0.0003125, 10: 0.000390625}#
- MAX_SHAPE = (5760, 5760)#
- __init__(pixel1=7.8125e-05, pixel2=7.8125e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#
Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None
- aliases = ('Rayonix MX225HS', 'Rayonix MX225 HS')#
- force_pixel = True#
- class pyFAI.detectors.RayonixMx300(pixel1=7.3242e-05, pixel2=7.3242e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#
Bases:
_RayonixRayonix mx300 2D detector (4x4 CCDs)
Pixel size from a personal communication from M. Blum
- BINNED_PIXEL_SIZE: ClassVar[dict] = {1: 3.6621e-05, 2: 7.3242e-05, 3: 0.000109971, 4: 0.000146484, 8: 0.000292969}#
- MANUFACTURER: ClassVar[list] = ['Rayonix', 'Mar Research']#
- MAX_SHAPE = (8192, 8192)#
- __init__(pixel1=7.3242e-05, pixel2=7.3242e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#
Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None
- aliases = ('Rayonix MX300', 'MAR 300', 'MAR300')#
- force_pixel = True#
- class pyFAI.detectors.RayonixMx300hs(pixel1=7.8125e-05, pixel2=7.8125e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#
Bases:
_RayonixRayonix mx300hs 2D detector (4x4 CCDs)
Pixel size from a personal communication from M. Blum
- BINNED_PIXEL_SIZE: ClassVar[dict] = {1: 3.90625e-05, 2: 7.8125e-05, 3: 0.0001171875, 4: 0.00015625, 5: 0.0001953125, 6: 0.000234375, 8: 0.0003125, 10: 0.000390625}#
- MAX_SHAPE = (7680, 7680)#
- __init__(pixel1=7.8125e-05, pixel2=7.8125e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#
Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None
- aliases = ('Rayonix MX300HS', 'Rayonix MX300 HS')#
- force_pixel = True#
- class pyFAI.detectors.RayonixMx325(pixel1=7.9346e-05, pixel2=7.9346e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#
Bases:
_RayonixRayonix mx325 and mx325he 2D detector (4x4 CCD chips)
Pixel size from a personal communication from M. Blum
- BINNED_PIXEL_SIZE: ClassVar[dict] = {1: 3.9673e-05, 2: 7.9346e-05, 3: 0.000119135, 4: 0.000158691, 8: 0.000317383}#
- MAX_SHAPE = (8192, 8192)#
- __init__(pixel1=7.9346e-05, pixel2=7.9346e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#
Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None
- aliases = ('Rayonix MX325',)#
- class pyFAI.detectors.RayonixMx340hs(pixel1=8.85417e-05, pixel2=8.85417e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#
Bases:
_RayonixRayonix mx340hs 2D detector (4x4 CCDs)
Pixel size from a personal communication from M. Blum
- BINNED_PIXEL_SIZE: ClassVar[dict] = {1: 4.42708e-05, 2: 8.85417e-05, 3: 0.0001328125, 4: 0.0001770833, 5: 0.0002213542, 6: 0.000265625, 8: 0.0003541667, 10: 0.0004427083}#
- MAX_SHAPE = (7680, 7680)#
- __init__(pixel1=8.85417e-05, pixel2=8.85417e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#
Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None
- aliases = ('Rayonix MX340HS', 'Rayonix MX340HS')#
- force_pixel = True#
- class pyFAI.detectors.RayonixMx425hs(pixel1=4.42708e-05, pixel2=4.42708e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#
Bases:
_RayonixRayonix mx425hs 2D CCD camera (5x5 CCD chip)
Pixel size from a personal communication from M. Blum
- BINNED_PIXEL_SIZE: ClassVar[dict] = {1: 4.42708e-05, 2: 8.85417e-05, 3: 0.0001328125, 4: 0.0001770833, 5: 0.0002213542, 6: 0.000265625, 8: 0.0003541667, 10: 0.0004427083}#
- MAX_SHAPE = (9600, 9600)#
- __init__(pixel1=4.42708e-05, pixel2=4.42708e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#
Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None
- aliases = ('Rayonix MX425HS', 'Rayonix MX425 HS')#
- class pyFAI.detectors.RayonixSx165(pixel1=3.95e-05, pixel2=3.95e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#
Bases:
_RayonixRayonix sx165 2d Detector also known as MAR165.
Circular detector
- BINNED_PIXEL_SIZE: ClassVar[dict] = {1: 3.95e-05, 2: 7.9e-05, 3: 0.000118616, 4: 0.000158, 8: 0.000316}#
- MANUFACTURER: ClassVar[list] = ['Rayonix', 'Mar Research']#
- MAX_SHAPE = (4096, 4096)#
- __init__(pixel1=3.95e-05, pixel2=3.95e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#
Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None
- aliases = ('Rayonix SX165', 'MAR 165', 'MAR165')#
- calc_mask()#
Circular mask
- force_pixel = True#
- class pyFAI.detectors.RayonixSx200(pixel1=4.8e-05, pixel2=4.8e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#
Bases:
_RayonixRayonix sx200 2d CCD Detector.
Pixel size are personal communication from M. Blum.
- BINNED_PIXEL_SIZE: ClassVar[dict] = {1: 4.8e-05, 2: 9.6e-05, 3: 0.000144, 4: 0.000192, 8: 0.000384}#
- MAX_SHAPE = (4096, 4096)#
- __init__(pixel1=4.8e-05, pixel2=4.8e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#
Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None
- aliases = ('Rayonix SX200',)#
- class pyFAI.detectors.RayonixSx30hs(pixel1=1.5625e-05, pixel2=1.5625e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#
Bases:
_RayonixRayonix sx30hs 2D CCD camera (1 CCD chip)
Pixel size from a personal communication from M. Blum
- BINNED_PIXEL_SIZE: ClassVar[dict] = {1: 1.5625e-05, 2: 3.125e-05, 3: 4.6875e-05, 4: 6.25e-05, 5: 7.8125e-05, 6: 9.375e-05, 8: 0.000125, 10: 0.00015625}#
- MAX_SHAPE = (1920, 1920)#
- __init__(pixel1=1.5625e-05, pixel2=1.5625e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#
Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None
- aliases = ('Rayonix SX30HS', 'Rayonix SX30 HS')#
- class pyFAI.detectors.RayonixSx85hs(pixel1=4.42708e-05, pixel2=4.42708e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#
Bases:
_RayonixRayonix sx85hs 2D CCD camera (1 CCD chip)
Pixel size from a personal communication from M. Blum
- BINNED_PIXEL_SIZE: ClassVar[dict] = {1: 4.42708e-05, 2: 8.85417e-05, 3: 0.0001328125, 4: 0.0001770833, 5: 0.0002213542, 6: 0.000265625, 8: 0.0003541667, 10: 0.0004427083}#
- MAX_SHAPE = (1920, 1920)#
- __init__(pixel1=4.42708e-05, pixel2=4.42708e-05, max_shape=None, orientation=0, sensor: SensorConfig | None = None)#
Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None
- aliases = ('Rayonix SX85HS', 'Rayonix SX85 HS')#
- class pyFAI.detectors.Titan(pixel1: float | None = None, pixel2: float | None = None, splinefile: str | None = None, max_shape: tuple[int, int] | None = None, orientation: int | Orientation = 0, sensor: SensorConfig | None = None)#
Bases:
DetectorTitan CCD detector from Agilent. Mask not handled
- MANUFACTURER: ClassVar[list] = ['Agilent', 'Oxford Diffraction']#
- MAX_SHAPE = (2048, 2048)#
- PIXEL_SIZE = (6e-05, 6e-05)#
- aliases = ('Titan 2k x 2k', 'Titan 2k x 2k', 'OXD Titan', 'Agilent Titan')#
- force_pixel = True#
- uniform_pixel = True#
- class pyFAI.detectors.Xpad_flat(pixel1=0.00013, pixel2=0.00013, max_shape=None, module_size=None, orientation=0, sensor: SensorConfig | None = None)#
Bases:
ImXPadS10Xpad detector: generic description for ImXPad detector with 8x7modules
- BORDER_PIXEL_SIZE_RELATIVE = 2.5#
- IS_CONTIGUOUS = False#
- MAX_SHAPE = (960, 560)#
- MODULE_GAP = (0.00357, 0)#
- MODULE_SIZE = (120, 80)#
- PIXEL_SIZE = (0.00013, 0.00013)#
- __init__(pixel1=0.00013, pixel2=0.00013, max_shape=None, module_size=None, orientation=0, sensor: SensorConfig | None = None)#
Constructor of the Detector class, most of the time, not used. :param pixel1: size of the pixel in meter along the slow dimension (often Y) :param pixel2: size of the pixel in meter along the fast dimension (often X) :param splinefile: path to file containing the geometric correction. :param max_shape: maximum size of the detector :type max_shape: 2-tuple of integers :param orientation: Orientation of the detector :param sensor: Optional sensor configuration specifying detector material and sensor thickness (in metres). :type sensor: SensorConfig | None
- aliases = ('Xpad S540 flat', 'd5')#
- calc_cartesian_positions(d1=None, d2=None, center=True, use_cython=True)#
Calculate the position of each pixel center in cartesian coordinate and in meter of a couple of coordinates. The half pixel offset is taken into account here !!! Adapted to Nexus detector definition
- Parameters:
d1 (ndarray (1D or 2D)) – the Y pixel positions (slow dimension)
d2 (ndarray (1D or 2D)) – the X pixel positions (fast dimension)
center – retrieve the coordinate of the center of the pixel
use_cython – set to False to test Numpy implementation
- Returns:
position in meter of the center of each pixels.
- Return type:
ndarray
d1 and d2 must have the same shape, returned array will have the same shape.
- calc_mask()#
Returns a generic mask for Xpad detectors… discards the first line and raw form all modules: those are 2.5x bigger and often misbehaving
- calc_pixels_edges()#
Calculate the position of the pixel edges, specific to the S540, d5 detector
- force_pixel = True#
- get_pixel_corners(correct_binning=False)#
Calculate the position of the corner of the pixels
- Returns:
4D array containing: pixel index (slow dimension) pixel index (fast dimension) corner index (A, B, C or D), triangles or hexagons can be handled the same way vertex position (z,y,x)
- uniform_pixel = False#
- pyFAI.detectors.detector_factory(name: str, config: None | str | dict[str, Any] = None)#
Create a pyFAI detector from a name.
If the detector is a known detector class, config in injected as constructor arguments.
If the name is an existing hdf5 filename, the config argument is ignored.
- Parameters:
name (str) – A name of a detector or an existing hdf5 detector description file.
config (dict or JSON representation of it.) – configuration of the detector
- Returns:
an instance of the right detector, set-up if possible
- Return type:
- pyFAI.detectors.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