From 16a0b1e1c892b8cd128ce0bf2014b9bf5f915cb5 Mon Sep 17 00:00:00 2001 From: Jerome Kieffer Date: Wed, 20 Nov 2024 17:30:08 +0100 Subject: [PATCH 01/23] Start implementing medfilt in OpenCL --- src/pyFAI/opencl/azim_csr.py | 211 ++++++++++++++++++++- src/pyFAI/resources/openCL/medfilt.cl | 136 +++++++++++++ src/pyFAI/resources/openCL/meson.build | 1 + src/pyFAI/resources/openCL/ocl_azim_CSR.cl | 2 +- 4 files changed, 343 insertions(+), 7 deletions(-) create mode 100644 src/pyFAI/resources/openCL/medfilt.cl diff --git a/src/pyFAI/opencl/azim_csr.py b/src/pyFAI/opencl/azim_csr.py index 62c24b8de..da2403c4e 100644 --- a/src/pyFAI/opencl/azim_csr.py +++ b/src/pyFAI/opencl/azim_csr.py @@ -28,7 +28,7 @@ __authors__ = ["Jérôme Kieffer", "Giannis Ashiotis"] __license__ = "MIT" -__date__ = "06/09/2024" +__date__ = "20/11/2024" __copyright__ = "ESRF, Grenoble" __contact__ = "jerome.kieffer@esrf.fr" @@ -313,7 +313,6 @@ def set_kernel_arguments(self): ("normalization_factor", numpy.float32(1.0)), ("apply_normalization", numpy.int8(0)), ("output", self.cl_mem["output"]))) - self.cl_kernel_args["csr_integrate"] = OrderedDict((("output", self.cl_mem["output"]), ("data", self.cl_mem["data"]), ("indices", self.cl_mem["indices"]), @@ -326,7 +325,6 @@ def set_kernel_arguments(self): ("sum_count", self.cl_mem["sum_count"]), ("merged", self.cl_mem["merged"]), ("shared", pyopencl.LocalMemory(16)))) - self.cl_kernel_args["corrections4a"] = OrderedDict((("image", self.cl_mem["image_raw"]), ("dtype", numpy.int8(0)), ("error_model", numpy.int8(0)), @@ -351,7 +349,6 @@ def set_kernel_arguments(self): ("normalization_factor", numpy.float32(1.0)), ("apply_normalization", numpy.int8(0)), ("output4", self.cl_mem["output4"]))) - self.cl_kernel_args["csr_integrate4"] = OrderedDict((("output4", self.cl_mem["output4"]), ("data", self.cl_mem["data"]), ("indices", self.cl_mem["indices"]), @@ -365,7 +362,6 @@ def set_kernel_arguments(self): ("sem", self.cl_mem["sem"]), ("shared", pyopencl.LocalMemory(32)) )) - self.cl_kernel_args["csr_sigma_clip4"] = OrderedDict((("output4", self.cl_mem["output4"]), ("data", self.cl_mem["data"]), ("indices", self.cl_mem["indices"]), @@ -380,9 +376,22 @@ def set_kernel_arguments(self): ("sem", self.cl_mem["sem"]), ("shared", pyopencl.LocalMemory(32)) )) - self.cl_kernel_args["csr_integrate_single"] = self.cl_kernel_args["csr_integrate"] self.cl_kernel_args["csr_integrate4_single"] = self.cl_kernel_args["csr_integrate4"] + self.cl_kernel_args["csr_medfilt"] = OrderedDict((("output4", self.cl_mem["output4"]), + ("data", self.cl_mem["data"]), + ("indices", self.cl_mem["indices"]), + ("indptr", self.cl_mem["indptr"]), + ("quant_min", numpy.float32(0.5)), + ("quant_max", numpy.float32(0.5)), + ("error_model", numpy.int8(1)), + ("empty", numpy.float32(self.empty)), + ("merged8", self.cl_mem["merged8"]), + ("averint", self.cl_mem["averint"]), + ("std", self.cl_mem["std"]), + ("sem", self.cl_mem["sem"]), + ("shared", pyopencl.LocalMemory(32)) + )) self.cl_kernel_args["memset_out"] = OrderedDict(((i, self.cl_mem[i]) for i in ("sum_data", "sum_count", "merged"))) self.cl_kernel_args["memset_ng"] = OrderedDict(((i, self.cl_mem[i]) for i in ("averint", "std", "merged8"))) self.cl_kernel_args["u8_to_float"] = OrderedDict(((i, self.cl_mem[i]) for i in ("tmp", "image"))) @@ -1055,5 +1064,195 @@ def sigma_clip(self, data, dark=None, dummy=None, delta_dummy=None, std, sem, merged[:, 7]) return res + def medfilt(self, data, dark=None, dummy=None, delta_dummy=None, + variance=None, dark_variance=None, + flat=None, solidangle=None, polarization=None, absorption=None, + dark_checksum=None, flat_checksum=None, solidangle_checksum=None, + polarization_checksum=None, absorption_checksum=None, dark_variance_checksum=None, + safe=True, error_model=ErrorModel.NO, + normalization_factor=1.0, + quant_min=0.5, quant_max=0.5, + out_avgint=None, out_sem=None, out_std=None, out_merged=None): + """ + Perform a median-filter/quantile mean in azimuthal space. + + + Averaging is performed using the CSR representation of the look-up table on all + arrays after sorting pixels by apparant intensity and taking only the selected ones + based on quantiles and the length of the ensemble. + + :param dark: array of same shape as data for pre-processing + :param dummy: value for invalid data + :param delta_dummy: precesion for dummy assessement + :param variance: array of same shape as data for pre-processing + :param dark_variance: array of same shape as data for pre-processing + :param flat: array of same shape as data for pre-processing + :param solidangle: array of same shape as data for pre-processing + :param polarization: array of same shape as data for pre-processing + :param dark_checksum: CRC32 checksum of the given array + :param flat_checksum: CRC32 checksum of the given array + :param solidangle_checksum: CRC32 checksum of the given array + :param polarization_checksum: CRC32 checksum of the given array + :param safe: if True (default) compares arrays on GPU according to their checksum, unless, use the buffer location is used + :param preprocess_only: return the dark subtracted; flat field & solidangle & polarization corrected image, else + :param error_model: enum ErrorModel + :param normalization_factor: divide raw signal by this value + :param quant_min: start percentile/100 to use. Use 0.5 for the median (default). 0<=quant_min<=1 + :param quant_max: stop percentile/100 to use. Use 0.5 for the median (default). 0<=quant_max<=1 + :param out_avgint: destination array or pyopencl array for sum of all data + :param out_sem: destination array or pyopencl array for uncertainty on mean value + :param out_std: destination array or pyopencl array for uncertainty on pixel value + :param out_merged: destination array or pyopencl array for averaged data (float8!) + :return: namedtuple with "position intensity error signal variance normalization count" + """ + error_model = ErrorModel.parse(error_model) + events = [] + with self.sem: + kernel_correction_name = "corrections4a" + corrections4 = self.kernels.corrections4a + kw_corr = self.cl_kernel_args[kernel_correction_name] + kw_corr["image"] = self.send_buffer(data, "image", convert=False) + kw_corr["dtype"] = numpy.int8(32) if data.dtype.itemsize > 4 else dtype_converter(data.dtype) + wg = max(self.workgroup_size["memset_ng"]) + wdim_bins = int(self.bins + wg - 1) // wg * wg, + memset = self.kernels.memset_out(self.queue, wdim_bins, (wg,), *list(self.cl_kernel_args["memset_ng"].values())) + events.append(EventDescription("memset_ng", memset)) + kw_int = self.cl_kernel_args["csr_sigma_clip4"] + + if dummy is not None: + do_dummy = numpy.int8(1) + dummy = numpy.float32(dummy) + if delta_dummy is None: + delta_dummy = numpy.float32(0.0) + else: + delta_dummy = numpy.float32(abs(delta_dummy)) + else: + do_dummy = numpy.int8(0) + dummy = numpy.float32(self.empty) + delta_dummy = numpy.float32(0.0) + + kw_corr["do_dummy"] = do_dummy + kw_corr["dummy"] = dummy + kw_corr["delta_dummy"] = delta_dummy + kw_corr["normalization_factor"] = numpy.float32(normalization_factor) + + if variance is not None: + error_model = ErrorModel.VARIANCE + self.send_buffer(variance, "variance") + kw_int["error_model"] = kw_corr["error_model"] = numpy.int8(error_model) + if dark_variance is not None: + if not dark_variance_checksum: + dark_variance_checksum = calc_checksum(dark_variance, safe) + if dark_variance_checksum != self.on_device["dark_variance"]: + self.send_buffer(dark_variance, "dark_variance", dark_variance_checksum) + else: + do_dark = numpy.int8(0) + kw_corr["do_dark"] = do_dark + + if dark is not None: + do_dark = numpy.int8(1) + # TODO: what is do_checksum=False and image not on device ... + if not dark_checksum: + dark_checksum = calc_checksum(dark, safe) + if dark_checksum != self.on_device["dark"]: + self.send_buffer(dark, "dark", dark_checksum) + else: + do_dark = numpy.int8(0) + kw_corr["do_dark"] = do_dark + + if flat is not None: + do_flat = numpy.int8(1) + if not flat_checksum: + flat_checksum = calc_checksum(flat, safe) + if self.on_device["flat"] != flat_checksum: + self.send_buffer(flat, "flat", flat_checksum) + else: + do_flat = numpy.int8(0) + kw_corr["do_flat"] = do_flat + + if solidangle is not None: + do_solidangle = numpy.int8(1) + if not solidangle_checksum: + solidangle_checksum = calc_checksum(solidangle, safe) + if solidangle_checksum != self.on_device["solidangle"]: + self.send_buffer(solidangle, "solidangle", solidangle_checksum) + else: + do_solidangle = numpy.int8(0) + kw_corr["do_solidangle"] = do_solidangle + + if polarization is not None: + do_polarization = numpy.int8(1) + if not polarization_checksum: + polarization_checksum = calc_checksum(polarization, safe) + if polarization_checksum != self.on_device["polarization"]: + self.send_buffer(polarization, "polarization", polarization_checksum) + else: + do_polarization = numpy.int8(0) + kw_corr["do_polarization"] = do_polarization + + if absorption is not None: + do_absorption = numpy.int8(1) + if not absorption_checksum: + absorption_checksum = calc_checksum(absorption, safe) + if absorption_checksum != self.on_device["absorption"]: + self.send_buffer(absorption, "absorption", absorption_checksum) + else: + do_absorption = numpy.int8(0) + kw_corr["do_absorption"] = do_absorption + + wg = max(self.workgroup_size[kernel_correction_name]) + wdim_data = int(self.size + wg - 1) // wg * wg, + ev = corrections4(self.queue, wdim_data, (wg,), *list(kw_corr.values())) + events.append(EventDescription(kernel_correction_name, ev)) + + kw_int["quant_min"] = numpy.float32(quant_min) + kw_int["quant_max"] = numpy.float32(quant_max) + + wg_min = min(self.workgroup_size["csr_sigma_clip4"]) + kw_int["shared"] = pyopencl.LocalMemory(32 * wg_min) + wdim_bins = (self.bins * wg_min), + integrate = self.kernels.csr_sigma_clip4(self.queue, wdim_bins, (wg_min,), *kw_int.values()) + events.append(EventDescription("csr_sigma_clip4", integrate)) + + if out_merged is None: + merged = numpy.empty((self.bins, 8), dtype=numpy.float32) + else: + merged = out_merged.data + if out_avgint is None: + avgint = numpy.empty(self.bins, dtype=numpy.float32) + else: + avgint = out_avgint.data + if out_sem is None: + sem = numpy.empty(self.bins, dtype=numpy.float32) + elif out_sem is False: + sem = None + else: + sem = out_sem.data + + if out_std is None: + std = numpy.empty(self.bins, dtype=numpy.float32) + elif out_std is False: + std = None + else: + std = out_std.data + + if avgint is not None: + ev = pyopencl.enqueue_copy(self.queue, avgint, self.cl_mem["averint"]) + events.append(EventDescription("copy D->H avgint", ev)) + if std is not None: + ev = pyopencl.enqueue_copy(self.queue, std, self.cl_mem["std"]) + events.append(EventDescription("copy D->H std", ev)) + if sem is not None: + ev = pyopencl.enqueue_copy(self.queue, sem, self.cl_mem["sem"]) + events.append(EventDescription("copy D->H sem", ev)) + + ev = pyopencl.enqueue_copy(self.queue, merged, self.cl_mem["merged8"]) + events.append(EventDescription("copy D->H merged8", ev)) + self.profile_multi(events) + res = Integrate1dtpl(self.bin_centers, avgint, sem, merged[:, 0], merged[:, 2], merged[:, 4], merged[:, 6], + std, sem, merged[:, 7]) + return res + + # Name of the default "process" method __call__ = integrate diff --git a/src/pyFAI/resources/openCL/medfilt.cl b/src/pyFAI/resources/openCL/medfilt.cl new file mode 100644 index 000000000..8bbd7c51e --- /dev/null +++ b/src/pyFAI/resources/openCL/medfilt.cl @@ -0,0 +1,136 @@ +/* + * Project: Azimuthal regroupping OpenCL kernel for PyFAI. + * Preprocessing program + * + * + * Copyright (C) 2024-2024 European Synchrotron Radiation Facility + * Grenoble, France + * + * Principal authors: J. Kieffer (kieffer@esrf.fr) + * Last revision: 20/11/2024 + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + + */ + +/** + * \file + * + * \brief OpenCL kernels performing median filtering | quantile averages + * + * Constant to be provided at build time: + * + * Files to be co-built: + * collective/reduction.cl + * collective/scan.cl + * collective/comb_sort.cl + */ + +#include "for_eclipse.h" + +/** + * \brief Performs sigma clipping in azimuthal rings based on a LUT in CSR form for background extraction + * + * Grid: 1D grid with one workgroup processes one bin in a collaborative manner, + * + * @param weights Float pointer to global memory storing the input image. + * @param coefs Float pointer to global memory holding the coeficient part of the LUT + * @param indices Integer pointer to global memory holding the corresponding index of the coeficient + * @param indptr Integer pointer to global memory holding the pointers to the coefs and indices for the CSR matrix + * @param cutoff Discard any value with |value - mean| > cutoff*sigma + * @param cycle number of cycle + * @param error_model 0:disable, 1:variance, 2:poisson, 3:azimuthal, 4:hybrid + * @param summed contains all the data + * @param averint Average signal + * @param stdevpix Float pointer to the output 1D array with the propagated error (std) + * @param stdevpix Float pointer to the output 1D array with the propagated error (sem) + * @param shared Buffer of shared memory of size WORKGROUP_SIZE * 8 * sizeof(float) + */ + +kernel void +csr_medfilt ( const global float4 *data4, + global float4 *work4, + const global float *coefs, + const global int *indices, + const global int *indptr, + const float quant_min, + const float quant_max, + const char error_model, + const float empty, + global float8 *summed, + global float *averint, + global float *stdevpix, + global float *stderrmean, + volatile local float8 *shared8 + ) +{ + int bin_num = get_group_id(0); + int wg = get_local_size(0); + int tid = get_local_id(0); + int start = indptr[bin_num]; + int stop = indptr[bin_num+1]; + int cnt; + char curr_error_model=error_model; + volatile local int counter[1]; + float8 result; + + // first populate the work4 array from data4 + for (int i=start+tid; i 0.0f) { + averint[bin_num] = aver; + stdevpix[bin_num] = std; + stderrmean[bin_num] = sqrt(result.s2) / result.s4; + } + else { + averint[bin_num] = empty; + stderrmean[bin_num] = empty; + stdevpix[bin_num] = empty; + } + } +} //end csr_sigma_clip4 kernel diff --git a/src/pyFAI/resources/openCL/meson.build b/src/pyFAI/resources/openCL/meson.build index 6aae56dc2..635d7bbe2 100644 --- a/src/pyFAI/resources/openCL/meson.build +++ b/src/pyFAI/resources/openCL/meson.build @@ -5,6 +5,7 @@ py.install_sources( 'bitonic.cl', 'deactivate_atomic64.cl', 'kahan.cl', + 'medfilt.cl', 'memset.cl', 'ocl_azim_CSR.cl', 'ocl_azim_LUT.cl', diff --git a/src/pyFAI/resources/openCL/ocl_azim_CSR.cl b/src/pyFAI/resources/openCL/ocl_azim_CSR.cl index edb5e0b46..54076de2e 100644 --- a/src/pyFAI/resources/openCL/ocl_azim_CSR.cl +++ b/src/pyFAI/resources/openCL/ocl_azim_CSR.cl @@ -827,7 +827,7 @@ csr_integrate4_single( const global float4 *weights, * @param indptr Integer pointer to global memory holding the pointers to the coefs and indices for the CSR matrix * @param cutoff Discard any value with |value - mean| > cutoff*sigma * @param cycle number of cycle - * @param error_model 0:diable, 1:variance, 2:poisson, 3:azimuthal, 4:hybrid + * @param error_model 0:disable, 1:variance, 2:poisson, 3:azimuthal, 4:hybrid * @param summed contains all the data * @param averint Average signal * @param stdevpix Float pointer to the output 1D array with the propagated error (std) From 7b7171199037c37af3e1659429b3425dbe892937 Mon Sep 17 00:00:00 2001 From: Jerome Kieffer Date: Thu, 21 Nov 2024 17:38:34 +0100 Subject: [PATCH 02/23] Change organisation of grid: collective work is always along dim 0 --- src/pyFAI/opencl/test/test_collective.py | 6 ++-- .../resources/openCL/collective/comb_sort.cl | 22 ++++++------ src/pyFAI/resources/openCL/collective/scan.cl | 2 +- src/pyFAI/resources/openCL/medfilt.cl | 34 ++++++++++++------- 4 files changed, 36 insertions(+), 28 deletions(-) diff --git a/src/pyFAI/opencl/test/test_collective.py b/src/pyFAI/opencl/test/test_collective.py index abc90fe78..0f28d1236 100644 --- a/src/pyFAI/opencl/test/test_collective.py +++ b/src/pyFAI/opencl/test/test_collective.py @@ -33,7 +33,7 @@ __contact__ = "jerome.kieffer@esrf.eu" __license__ = "MIT" __copyright__ = "2013 European Synchrotron Radiation Facility, Grenoble, France" -__date__ = "12/11/2024" +__date__ = "21/11/2024" import logging import numpy @@ -250,7 +250,7 @@ def test_sort(self): data_d = pyopencl.array.to_device(self.queue, data) # print(ref.shape, (ref.shape[0],min(wg, self.max_valid_wg)), (1, min(wg, self.max_valid_wg)), positions) try: - evt = self.program.test_combsort_float(self.queue, (ref.shape[0],min(wg, self.max_valid_wg)), (1, min(wg, self.max_valid_wg)), + evt = self.program.test_combsort_float(self.queue, (min(wg, self.max_valid_wg), ref.shape[0]), (min(wg, self.max_valid_wg), 1), data_d.data, positions_d.data, pyopencl.LocalMemory(4*min(wg, self.max_valid_wg))) @@ -290,7 +290,7 @@ def test_sort4(self): data_d = pyopencl.array.to_device(self.queue, data) # print(ref.shape, (ref.shape[0],min(wg, self.max_valid_wg)), (1, min(wg, self.max_valid_wg)), positions) try: - evt = self.program.test_combsort_float4(self.queue, (ref.shape[0],min(wg, self.max_valid_wg)), (1, min(wg, self.max_valid_wg)), + evt = self.program.test_combsort_float4(self.queue, (min(wg, self.max_valid_wg), ref.shape[0]), (min(wg, self.max_valid_wg),1), data_d.data, positions_d.data, pyopencl.LocalMemory(4*min(wg, self.max_valid_wg))) diff --git a/src/pyFAI/resources/openCL/collective/comb_sort.cl b/src/pyFAI/resources/openCL/collective/comb_sort.cl index a952c4f16..41c51c9bd 100644 --- a/src/pyFAI/resources/openCL/collective/comb_sort.cl +++ b/src/pyFAI/resources/openCL/collective/comb_sort.cl @@ -15,11 +15,9 @@ int inline first_step(int step, int size, float ratio) { while (step=size) step=previous_step(step, ratio); - // if (get_local_id(0) == 0) printf("- %d %d\n", step, size); return step; } @@ -61,8 +59,8 @@ int passe(global volatile float* elements, int step, local int* shared) { - int wg = get_local_size(1); - int tid = get_local_id(1); + int wg = get_local_size(0); + int tid = get_local_id(0); int cnt = 0; int i, j, k; barrier(CLK_GLOBAL_MEM_FENCE); @@ -120,8 +118,8 @@ int passe_float4(global volatile float4* elements, int step, local int* shared) { - int wg = get_local_size(1); - int tid = get_local_id(1); + int wg = get_local_size(0); + int tid = get_local_id(0); int cnt = 0; int i, j, k; @@ -171,14 +169,14 @@ int passe_float4(global volatile float4* elements, return 0; } -// workgroup: (1, wg) -// grid: (nb_lines, wg) +// workgroup: (wg, 1) +// grid: (wg, nb_lines) // shared: wg*sizeof(int) kernel void test_combsort_float(global volatile float* elements, global int* positions, local int* shared) { - int gid = get_group_id(0); + int gid = get_group_id(1); int step = 11; // magic value float ratio=1.3f; // magic value int cnt; @@ -202,14 +200,14 @@ kernel void test_combsort_float(global volatile float* elements, } -// workgroup: (1, wg) -// grid: (nb_lines, wg) +// workgroup: (wg, 1) +// grid: (wg, nb_lines) // shared: wg*sizeof(int) kernel void test_combsort_float4(global volatile float4* elements, global int* positions, local int* shared) { - int gid = get_group_id(0); + int gid = get_group_id(1); int step = 11; // magic value float ratio=1.3f; // magic value int cnt; diff --git a/src/pyFAI/resources/openCL/collective/scan.cl b/src/pyFAI/resources/openCL/collective/scan.cl index a4ff2d7bf..cda7a783a 100644 --- a/src/pyFAI/resources/openCL/collective/scan.cl +++ b/src/pyFAI/resources/openCL/collective/scan.cl @@ -1,6 +1,6 @@ /* - * Cumsum all elements in a shared memory + * Cumsum all elements in a shared memory along dim 0 * * Nota: the first wg-size elements, are used. * The shared buffer needs to be twice this size of the workgroup diff --git a/src/pyFAI/resources/openCL/medfilt.cl b/src/pyFAI/resources/openCL/medfilt.cl index 8bbd7c51e..2b926fbe2 100644 --- a/src/pyFAI/resources/openCL/medfilt.cl +++ b/src/pyFAI/resources/openCL/medfilt.cl @@ -47,7 +47,9 @@ /** * \brief Performs sigma clipping in azimuthal rings based on a LUT in CSR form for background extraction * - * Grid: 1D grid with one workgroup processes one bin in a collaborative manner, + * Grid: 2D grid with one workgroup processes one bin in a collaborative manner, + * dim 0: index of bin, size=1 + * dim 1: collaboarative working group size, probably optimal in the range 32-128 * * @param weights Float pointer to global memory storing the input image. * @param coefs Float pointer to global memory holding the coeficient part of the LUT @@ -77,18 +79,19 @@ csr_medfilt ( const global float4 *data4, global float *averint, global float *stdevpix, global float *stderrmean, - volatile local float8 *shared8 + local int* shared // size of the workgroup size ) { int bin_num = get_group_id(0); - int wg = get_local_size(0); - int tid = get_local_id(0); + int wg = get_local_size(1); + int tid = get_local_id(1); int start = indptr[bin_num]; int stop = indptr[bin_num+1]; - int cnt; + int size = stop-start; + int cnt, step=11; char curr_error_model=error_model; - volatile local int counter[1]; float8 result; + float ratio=1.3f; // first populate the work4 array from data4 for (int i=start+tid; i0; step=previous_step(step, ratio)) + cnt = passe_float4(&work4[start], size, step, shared); + + while (cnt) + cnt = passe_float4(&work4[start], size, 1, shared); + + // Then perform the cumsort of the weights + // In blelloch scan, one workgroup can + - //TODO + // + // finally barrier(CLK_GLOBAL_MEM_FENCE); From 438d4a32aea2e66bc81925012a40442430341c89 Mon Sep 17 00:00:00 2001 From: Jerome Kieffer Date: Fri, 22 Nov 2024 14:06:17 +0100 Subject: [PATCH 03/23] WIP --- src/pyFAI/resources/openCL/medfilt.cl | 45 ++++++++++++++++++++++----- 1 file changed, 38 insertions(+), 7 deletions(-) diff --git a/src/pyFAI/resources/openCL/medfilt.cl b/src/pyFAI/resources/openCL/medfilt.cl index 2b926fbe2..d97013643 100644 --- a/src/pyFAI/resources/openCL/medfilt.cl +++ b/src/pyFAI/resources/openCL/medfilt.cl @@ -79,7 +79,8 @@ csr_medfilt ( const global float4 *data4, global float *averint, global float *stdevpix, global float *stderrmean, - local int* shared // size of the workgroup size + local int* shared_int // size of the workgroup size + local int* shared_float // size of the workgroup size ) { int bin_num = get_group_id(0); @@ -89,9 +90,11 @@ csr_medfilt ( const global float4 *data4, int stop = indptr[bin_num+1]; int size = stop-start; int cnt, step=11; + int niter, idx; char curr_error_model=error_model; float8 result; - float ratio=1.3f; + float sum=0.0f, ratio=1.3f; + float2 acc_sig, acc_nrm, acc_var; // first populate the work4 array from data4 for (int i=start+tid; i Date: Mon, 25 Nov 2024 17:53:22 +0100 Subject: [PATCH 04/23] Untested medfilt kernel --- src/pyFAI/resources/openCL/medfilt.cl | 102 +++++++++++++++++++++----- 1 file changed, 84 insertions(+), 18 deletions(-) diff --git a/src/pyFAI/resources/openCL/medfilt.cl b/src/pyFAI/resources/openCL/medfilt.cl index d97013643..c45febec7 100644 --- a/src/pyFAI/resources/openCL/medfilt.cl +++ b/src/pyFAI/resources/openCL/medfilt.cl @@ -7,7 +7,7 @@ * Grenoble, France * * Principal authors: J. Kieffer (kieffer@esrf.fr) - * Last revision: 20/11/2024 + * Last revision: 25/11/2024 * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal @@ -44,12 +44,44 @@ #include "for_eclipse.h" +float2 inline sum_float2_reduction(local float* shared) +{ + int wg = get_local_size(0) * get_local_size(1); + int tid = get_local_id(0) + get_local_size(0)*get_local_id(1); + + // local reduction based implementation + for (int stride=wg>>1; stride>0; stride>>=1) + { + barrier(CLK_LOCAL_MEM_FENCE); + if ((tidstart)?work4[i-1].s0:0.0f; + float4 w = work4[i]; + if ((q_last>=qmin) && (w.s0<=qmax)){ + cnt ++; + acc_sig = dw_plus_fp(acc_sig, w.s1); + acc_var = dw_plus_fp(acc_var, w.s2); + acc_nrm = dw_plus_fp(acc_nrm, w.s3); + acc_nrm2 = dw_plus_dw(acc_nrm2, fp_times_fp(w.s3, w.s3)); + } +// Now parallel reductions, one after the other :-/ + shared_int[tid] = cnt; + cnt = sum_int_reduction(shared_int); + + shared_float[2*tid] = acc_sig.s0; + shared_float[2*tid+1] = acc_sig.s1; + acc_sig = sum_float2_reduction(shared_float); + + shared_float[2*tid] = acc_var.s0; + shared_float[2*tid+1] = acc_var.s1; + acc_var = sum_float2_reduction(shared_float); + + shared_float[2*tid] = acc_nrm.s0; + shared_float[2*tid+1] = acc_nrm.s1; + acc_nrm = sum_float2_reduction(shared_float); + + shared_float[2*tid] = acc_nrm2.s0; + shared_float[2*tid+1] = acc_nrm2.s1; + acc_nrm2 = sum_float2_reduction(shared_float); + } // Finally store the accumulated value if (get_local_id(0) == 0) { - summed[bin_num] = result; - if (result.s6 > 0.0f) { - averint[bin_num] = aver; - stdevpix[bin_num] = std; - stderrmean[bin_num] = sqrt(result.s2) / result.s4; + summed[bin_num] = (float8)(acc_sig.s0, acc_sig.s1, + acc_var.s0, acc_var.s1, + acc_nrm.s0, acc_nrm.s1, + (float)cnt, acc_nrm2.s0); + if (acc_nrm2.s0 > 0.0f) { + averint[bin_num] = acc_sig.s0/acc_nrm.s0 ; + stdevpix[bin_num] = sqrt(acc_var.s0/acc_nrm2.s0) ; + stderrmean[bin_num] = sqrt(acc_var.s0) / acc_nrm.s0; } else { averint[bin_num] = empty; @@ -174,4 +240,4 @@ csr_medfilt ( const global float4 *data4, stdevpix[bin_num] = empty; } } -} //end csr_sigma_clip4 kernel +} //end csr_medfilt kernel From f66755ac8d9b688b60cca1989c675df17194a983 Mon Sep 17 00:00:00 2001 From: Jerome Kieffer Date: Tue, 26 Nov 2024 09:58:33 +0100 Subject: [PATCH 05/23] Code compiles (under nvidia) --- src/pyFAI/resources/openCL/medfilt.cl | 26 ++++++++++++-------------- 1 file changed, 12 insertions(+), 14 deletions(-) diff --git a/src/pyFAI/resources/openCL/medfilt.cl b/src/pyFAI/resources/openCL/medfilt.cl index c45febec7..99323b388 100644 --- a/src/pyFAI/resources/openCL/medfilt.cl +++ b/src/pyFAI/resources/openCL/medfilt.cl @@ -63,9 +63,7 @@ float2 inline sum_float2_reduction(local float* shared) here.s1 = shared[pos_here+1]; there.s0 = shared[pos_there]; there.s1 = shared[pos_there+1]; - shared[2*tid+1] = here.s1; - here = - += shared[tid+stride]; + here = dw_plus_dw(here, there); shared[2*tid] = here.s0; shared[2*tid+1] = here.s1; } @@ -113,7 +111,7 @@ csr_medfilt ( const global float4 *data4, global float *averint, global float *stdevpix, global float *stderrmean, - local int* shared_int // size of the workgroup size + local int* shared_int, // size of the workgroup size local float* shared_float // size of 2x the workgroup size ) { @@ -128,7 +126,7 @@ csr_medfilt ( const global float4 *data4, char curr_error_model=error_model; float8 result; float sum=0.0f, ratio=1.3f; - float2 acc_sig, acc_nrm, acc_var; + float2 acc_sig, acc_nrm, acc_var, acc_nrm2; // first populate the work4 array from data4 for (int i=start+tid; i0; step=previous_step(step, ratio)) - cnt = passe_float4(&work4[start], size, step, shared); + cnt = passe_float4(&work4[start], size, step, shared_int); while (cnt) - cnt = passe_float4(&work4[start], size, 1, shared); + cnt = passe_float4(&work4[start], size, 1, shared_int); // Then perform the cumsort of the weights to s0 // In blelloch scan, one workgroup can process 2wg in size. niter = (size + 2*wg-1)/(2*wg); sum = 0.0f; - for (int i=0; i Date: Wed, 4 Dec 2024 17:27:22 +0100 Subject: [PATCH 06/23] Code is integrated, but wrong for now... --- src/pyFAI/opencl/azim_csr.py | 28 ++++++++++++++++++--------- src/pyFAI/resources/openCL/medfilt.cl | 27 +++++++++++++------------- 2 files changed, 33 insertions(+), 22 deletions(-) diff --git a/src/pyFAI/opencl/azim_csr.py b/src/pyFAI/opencl/azim_csr.py index 22becef07..4a51c8513 100644 --- a/src/pyFAI/opencl/azim_csr.py +++ b/src/pyFAI/opencl/azim_csr.py @@ -28,7 +28,7 @@ __authors__ = ["Jérôme Kieffer", "Giannis Ashiotis"] __license__ = "MIT" -__date__ = "20/11/2024" +__date__ = "04/12/2024" __copyright__ = "ESRF, Grenoble" __contact__ = "jerome.kieffer@esrf.fr" @@ -70,11 +70,16 @@ class OCL_CSR_Integrator(OpenclProcessing): BufferDescription("solidangle", 1, numpy.float32, mf.READ_ONLY), BufferDescription("absorption", 1, numpy.float32, mf.READ_ONLY), BufferDescription("mask", 1, numpy.int8, mf.READ_ONLY), + ] kernel_files = ["silx:opencl/doubleword.cl", "pyfai:openCL/preprocess.cl", "pyfai:openCL/memset.cl", - "pyfai:openCL/ocl_azim_CSR.cl" + "pyfai:openCL/ocl_azim_CSR.cl", + "pyfai:openCL/collective/reduction.cl", + "pyfai:openCL/collective/scan.cl", + "pyfai:openCL/collective/comb_sort.cl", + "pyfai:openCL/medfilt.cl" ] mapping = {numpy.int8: "s8_to_float", numpy.uint8: "u8_to_float", @@ -162,6 +167,7 @@ def __init__(self, lut, image_size, checksum=None, BufferDescription("sem", self.bins, numpy.float32, mf.READ_WRITE), BufferDescription("merged", self.bins, numpy.float32, mf.WRITE_ONLY), BufferDescription("merged8", (self.bins, 8), numpy.float32, mf.WRITE_ONLY), + BufferDescription("work4", (self.data_size, 4), numpy.float32, mf.READ_WRITE), ] try: self.set_profiling(profile) @@ -383,6 +389,7 @@ def set_kernel_arguments(self): self.cl_kernel_args["csr_integrate_single"] = self.cl_kernel_args["csr_integrate"] self.cl_kernel_args["csr_integrate4_single"] = self.cl_kernel_args["csr_integrate4"] self.cl_kernel_args["csr_medfilt"] = OrderedDict((("output4", self.cl_mem["output4"]), + ("work4", self.cl_mem["work4"]), ("data", self.cl_mem["data"]), ("indices", self.cl_mem["indices"]), ("indptr", self.cl_mem["indptr"]), @@ -394,7 +401,8 @@ def set_kernel_arguments(self): ("averint", self.cl_mem["averint"]), ("std", self.cl_mem["std"]), ("sem", self.cl_mem["sem"]), - ("shared", pyopencl.LocalMemory(32)) + ("shared_int", pyopencl.LocalMemory(128)), + ("shared_float", pyopencl.LocalMemory(128)), )) self.cl_kernel_args["memset_out"] = OrderedDict(((i, self.cl_mem[i]) for i in ("sum_data", "sum_count", "merged"))) self.cl_kernel_args["memset_ng"] = OrderedDict(((i, self.cl_mem[i]) for i in ("averint", "std", "merged8"))) @@ -607,6 +615,7 @@ def integrate_legacy(self, data, dummy=None, delta_dummy=None, integrate = self.kernels.csr_integrate_single(self.queue, wdim_bins, (wg_max,), *kw_int.values()) events.append(EventDescription("csr_integrate_single", integrate)) else: + #TODO reshape this kernel with (wg, nbin)\(wg,1) rather than (self.bins * wg_min)\(wg_min) #2348 wdim_bins = (self.bins * wg_min), kw_int["shared"] = pyopencl.LocalMemory(16 * wg_min) # sizeof(float4) == 16 integrate = self.kernels.csr_integrate(self.queue, wdim_bins, (wg_min,), *kw_int.values()) @@ -1121,7 +1130,7 @@ def medfilt(self, data, dark=None, dummy=None, delta_dummy=None, wdim_bins = int(self.bins + wg - 1) // wg * wg, memset = self.kernels.memset_out(self.queue, wdim_bins, (wg,), *list(self.cl_kernel_args["memset_ng"].values())) events.append(EventDescription("memset_ng", memset)) - kw_int = self.cl_kernel_args["csr_sigma_clip4"] + kw_int = self.cl_kernel_args["csr_medfilt"] if dummy is not None: do_dummy = numpy.int8(1) @@ -1212,11 +1221,12 @@ def medfilt(self, data, dark=None, dummy=None, delta_dummy=None, kw_int["quant_min"] = numpy.float32(quant_min) kw_int["quant_max"] = numpy.float32(quant_max) - wg_min = min(self.workgroup_size["csr_sigma_clip4"]) - kw_int["shared"] = pyopencl.LocalMemory(32 * wg_min) - wdim_bins = (self.bins * wg_min), - integrate = self.kernels.csr_sigma_clip4(self.queue, wdim_bins, (wg_min,), *kw_int.values()) - events.append(EventDescription("csr_sigma_clip4", integrate)) + wg_min = min(self.workgroup_size["csr_medfilt"]) + kw_int["shared_int"] = pyopencl.LocalMemory(4 * wg_min) + kw_int["shared_float"] = pyopencl.LocalMemory(8 * wg_min) + wdim_bins = (wg_min, self.bins) + integrate = self.kernels.csr_medfilt(self.queue, wdim_bins, (wg_min,1), *kw_int.values()) + events.append(EventDescription("medfilt", integrate)) if out_merged is None: merged = numpy.empty((self.bins, 8), dtype=numpy.float32) diff --git a/src/pyFAI/resources/openCL/medfilt.cl b/src/pyFAI/resources/openCL/medfilt.cl index 99323b388..fc6992d74 100644 --- a/src/pyFAI/resources/openCL/medfilt.cl +++ b/src/pyFAI/resources/openCL/medfilt.cl @@ -81,19 +81,20 @@ float2 inline sum_float2_reduction(local float* shared) * dim 0: collaboarative working group size, probably optimal in the range 32-128 * dim 1: index of bin, size=1 * - * @param weights Float pointer to global memory storing the input image. - * @param coefs Float pointer to global memory holding the coeficient part of the LUT - * @param indices Integer pointer to global memory holding the corresponding index of the coeficient - * @param indptr Integer pointer to global memory holding the pointers to the coefs and indices for the CSR matrix - * @param cutoff Discard any value with |value - mean| > cutoff*sigma - * @param cycle number of cycle - * @param error_model 0:disable, 1:variance, 2:poisson, 3:azimuthal, 4:hybrid - * @param summed contains all the data - * @param averint Average signal - * @param stdevpix Float pointer to the output 1D array with the propagated error (std) - * @param stdevpix Float pointer to the output 1D array with the propagated error (sem) - * @param shared Buffer of shared memory of size WORKGROUP_SIZE * 8 * sizeof(float) - */ + * @param weights Float pointer to global memory storing the input image. + * @param coefs Float pointer to global memory holding the coeficient part of the LUT + * @param indices Integer pointer to global memory holding the corresponding index of the coeficient + * @param indptr Integer pointer to global memory holding the pointers to the coefs and indices for the CSR matrix + * @param quant_min start percentile/100 to use. Use 0.5 for the median + * @param quant_max stop percentile/100 to use. Use 0.5 for the median + * @param error_model 0:disable, 1:variance, 2:poisson, 3:azimuthal, 4:hybrid + * @param summed contains all the data + * @param averint Average signal + * @param stdevpix Float pointer to the output 1D array with the propagated error (std) + * @param stdevpix Float pointer to the output 1D array with the propagated error (sem) + * @param shared_int Buffer of shared memory of size WORKGROUP_SIZE * sizeof(int) + * @param shared_float Buffer of shared memory of size WORKGROUP_SIZE * 2 * sizeof(float) + * */ From 92ac57f408e0bf48af09248ace78b7cf735628a8 Mon Sep 17 00:00:00 2001 From: Jerome Kieffer Date: Wed, 4 Dec 2024 18:11:08 +0100 Subject: [PATCH 07/23] Fix kernel for numerical precision --- src/pyFAI/resources/openCL/medfilt.cl | 46 ++++++++++++++------------- 1 file changed, 24 insertions(+), 22 deletions(-) diff --git a/src/pyFAI/resources/openCL/medfilt.cl b/src/pyFAI/resources/openCL/medfilt.cl index fc6992d74..db20941c5 100644 --- a/src/pyFAI/resources/openCL/medfilt.cl +++ b/src/pyFAI/resources/openCL/medfilt.cl @@ -122,8 +122,8 @@ csr_medfilt ( const global float4 *data4, int start = indptr[bin_num]; int stop = indptr[bin_num+1]; int size = stop-start; - int cnt, step=11; - int niter, idx; + int sum_cnt, cnt, step=11; + int idx; char curr_error_model=error_model; float8 result; float sum=0.0f, ratio=1.3f; @@ -148,6 +148,7 @@ csr_medfilt ( const global float4 *data4, barrier(CLK_GLOBAL_MEM_FENCE); // then perform the sort in the work space along the s0 component + step = first_step(step, size, ratio); for (step=step; step>0; step=previous_step(step, ratio)) @@ -158,9 +159,10 @@ csr_medfilt ( const global float4 *data4, // Then perform the cumsort of the weights to s0 // In blelloch scan, one workgroup can process 2wg in size. - niter = (size + 2*wg-1)/(2*wg); + + sum = 0.0f; - for (int i=0; i Date: Thu, 5 Dec 2024 09:25:02 +0100 Subject: [PATCH 08/23] Going from 32->256 threads/WG gains 20% in speed --- src/pyFAI/opencl/azim_csr.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/pyFAI/opencl/azim_csr.py b/src/pyFAI/opencl/azim_csr.py index 4a51c8513..bc78b8f7e 100644 --- a/src/pyFAI/opencl/azim_csr.py +++ b/src/pyFAI/opencl/azim_csr.py @@ -28,7 +28,7 @@ __authors__ = ["Jérôme Kieffer", "Giannis Ashiotis"] __license__ = "MIT" -__date__ = "04/12/2024" +__date__ = "05/12/2024" __copyright__ = "ESRF, Grenoble" __contact__ = "jerome.kieffer@esrf.fr" @@ -1221,7 +1221,7 @@ def medfilt(self, data, dark=None, dummy=None, delta_dummy=None, kw_int["quant_min"] = numpy.float32(quant_min) kw_int["quant_max"] = numpy.float32(quant_max) - wg_min = min(self.workgroup_size["csr_medfilt"]) + wg_min = max(self.workgroup_size["csr_medfilt"]) kw_int["shared_int"] = pyopencl.LocalMemory(4 * wg_min) kw_int["shared_float"] = pyopencl.LocalMemory(8 * wg_min) wdim_bins = (wg_min, self.bins) From df294364b750dcf03f70f240b1cfb20f54e3d4f8 Mon Sep 17 00:00:00 2001 From: Jerome Kieffer Date: Thu, 5 Dec 2024 14:33:40 +0100 Subject: [PATCH 09/23] Remains at least a bug since one fragment of a pixel is missing --- src/pyFAI/opencl/azim_csr.py | 2 + src/pyFAI/opencl/test/test_ocl_azim_csr.py | 51 ++++++++++++++-------- src/pyFAI/resources/openCL/medfilt.cl | 9 ++-- 3 files changed, 42 insertions(+), 20 deletions(-) diff --git a/src/pyFAI/opencl/azim_csr.py b/src/pyFAI/opencl/azim_csr.py index bc78b8f7e..49f907adf 100644 --- a/src/pyFAI/opencl/azim_csr.py +++ b/src/pyFAI/opencl/azim_csr.py @@ -179,6 +179,7 @@ def __init__(self, lut, image_size, checksum=None, self.buffer_dtype = {i.name:numpy.dtype(i.dtype) for i in self.buffers} if numpy.allclose(self._data, numpy.ones(self._data.shape)): self.cl_mem["data"] = None + self.cl_kernel_args["csr_medfilt"]["data"] = None self.cl_kernel_args["csr_sigma_clip4"]["data"] = None self.cl_kernel_args["csr_integrate"]["data"] = None self.cl_kernel_args["csr_integrate4"]["data"] = None @@ -1263,6 +1264,7 @@ def medfilt(self, data, dark=None, dummy=None, delta_dummy=None, ev = pyopencl.enqueue_copy(self.queue, merged, self.cl_mem["merged8"]) events.append(EventDescription("copy D->H merged8", ev)) self.profile_multi(events) + res = Integrate1dtpl(self.bin_centers, avgint, sem, merged[:, 0], merged[:, 2], merged[:, 4], merged[:, 6], std, sem, merged[:, 7]) return res diff --git a/src/pyFAI/opencl/test/test_ocl_azim_csr.py b/src/pyFAI/opencl/test/test_ocl_azim_csr.py index cf2bce570..707416028 100644 --- a/src/pyFAI/opencl/test/test_ocl_azim_csr.py +++ b/src/pyFAI/opencl/test/test_ocl_azim_csr.py @@ -33,7 +33,7 @@ __contact__ = "jerome.kieffer@esrf.eu" __license__ = "MIT" __copyright__ = "2019-2021 European Synchrotron Radiation Facility, Grenoble, France" -__date__ = "28/06/2022" +__date__ = "05/12/2024" import logging import numpy @@ -43,10 +43,9 @@ if ocl: import pyopencl.array from ...test.utilstest import UtilsTest -from silx.opencl.common import _measure_workgroup_size from ...integrator.azimuthal import AzimuthalIntegrator from ...method_registry import IntegrationMethod -from scipy.ndimage import gaussian_filter1d +from ...containers import ErrorModel logger = logging.getLogger(__name__) @@ -81,10 +80,12 @@ def tearDownClass(cls): cls.ai = None @unittest.skipUnless(ocl, "pyopencl is missing") - def integrate_ng(self, block_size=None): + def integrate_ng(self, block_size=None, method_called="integrate_ng", extra=None): """ tests the 1d histogram kernel, with variable workgroup size """ + if extra is None: + extra={} from ..azim_csr import OCL_CSR_Integrator data = numpy.ones(self.ai.detector.shape) npt = 500 @@ -95,14 +96,14 @@ def integrate_ng(self, block_size=None): dim=1, default=None, degradable=False) # Retrieve the CSR array - cpu_integrate = self.ai._integrate1d_legacy(data, npt, unit=unit, method=csr_method) + cpu_integrate = self.ai._integrate1d_ng(data, npt, unit=unit, method=csr_method) r_m = cpu_integrate[0] csr_engine = list(self.ai.engines.values())[0] csr = csr_engine.engine.lut - ref = self.ai._integrate1d_ng(data, npt, unit=unit, method=method) - integrator = OCL_CSR_Integrator(csr, data.size, block_size=block_size) + ref = self.ai._integrate1d_ng(data, npt, unit=unit, method=method, error_model="poisson") + integrator = OCL_CSR_Integrator(csr, data.size, block_size=block_size, empty=-1) solidangle = self.ai.solidAngleArray() - res = integrator.integrate_ng(data, solidangle=solidangle) + res = integrator.__getattribute__(method_called)(data, solidangle=solidangle, error_model=ErrorModel.POISSON, **extra) # for info, res contains: position intensity error signal variance normalization count # Start with smth easy: the position @@ -112,23 +113,25 @@ def integrate_ng(self, block_size=None): if "AMD" in integrator.ctx.devices[0].platform.name: logger.warning("This test is known to be complicated for AMD-GPU, relax the constrains for them") else: - self.assertLessEqual(delta.max(), 1, "counts are almost the same") - self.assertEqual(delta.sum(), 0, "as much + and -") + if method_called=="integrate_ng": + self.assertLessEqual(delta.max(), 1, "counts are almost the same") + self.assertEqual(delta.sum(), 0, "as much + and -") + elif method_called=="medfilt": + pix = csr[2][1:]-csr[2][:-1] + for i,j in zip(pix,res.count): + print(j-i,i,j) # Intensities are not that different: delta = ref.intensity - res.intensity - self.assertLessEqual(abs(delta.max()), 1e-5, "intensity is almost the same") + self.assertLessEqual(abs(delta).max(), 1e-5, "intensity is almost the same") # histogram of normalization - ref = self.ai._integrate1d_ng(solidangle, npt, unit=unit, method=method).sum_signal - sig = res.normalization - err = abs((sig - ref).max()) + err = abs((res.normalization - ref.sum_normalization).max()) self.assertLess(err, 5e-4, "normalization content is the same: %s<5e-5" % (err)) # histogram of signal - ref = self.ai._integrate1d_ng(data, npt, unit=unit, method=method).sum_signal - sig = res.signal - self.assertLess(abs((sig - ref).sum()), 5e-5, "signal content is the same") + print(res.signal - ref.sum_signal) + self.assertLess(abs((res.signal - ref.sum_signal).sum()), 5e-5, "signal content is the same") @unittest.skipUnless(ocl, "pyopencl is missing") def test_integrate_ng(self): @@ -144,6 +147,20 @@ def test_integrate_ng_single(self): """ self.integrate_ng(block_size=1) + @unittest.skipUnless(ocl, "pyopencl is missing") + def test_sigma_clip(self): + """ + tests the sigma-clipping kernel, default block size + """ + self.integrate_ng(None, "sigma_clip",{"cutoff":100.0, "cycle":0,}) + + @unittest.skipUnless(ocl, "pyopencl is missing") + def test_medfilt(self): + """ + tests the median filtering kernel, default block size + """ + self.integrate_ng(None, "medfilt", {"quant_min":0, "quant_max":1}) + def suite(): loader = unittest.defaultTestLoader.loadTestsFromTestCase diff --git a/src/pyFAI/resources/openCL/medfilt.cl b/src/pyFAI/resources/openCL/medfilt.cl index db20941c5..00df7a673 100644 --- a/src/pyFAI/resources/openCL/medfilt.cl +++ b/src/pyFAI/resources/openCL/medfilt.cl @@ -129,13 +129,15 @@ csr_medfilt ( const global float4 *data4, float sum=0.0f, ratio=1.3f; float2 acc_sig, acc_nrm, acc_var, acc_nrm2; +// if (tid==0)printf("bin %d start %d stop %d\n",bin_num,start, stop); // first populate the work4 array from data4 for (int i=start+tid; i Date: Thu, 5 Dec 2024 15:48:39 +0100 Subject: [PATCH 10/23] Fix upper limit noise --- src/pyFAI/opencl/azim_csr.py | 5 ++++- src/pyFAI/opencl/test/test_ocl_azim_csr.py | 4 ++-- src/pyFAI/resources/openCL/medfilt.cl | 5 +++++ 3 files changed, 11 insertions(+), 3 deletions(-) diff --git a/src/pyFAI/opencl/azim_csr.py b/src/pyFAI/opencl/azim_csr.py index 49f907adf..5ac301e9b 100644 --- a/src/pyFAI/opencl/azim_csr.py +++ b/src/pyFAI/opencl/azim_csr.py @@ -42,6 +42,7 @@ else: raise ImportError("pyopencl is not installed") from ..containers import Integrate1dtpl, Integrate2dtpl, ErrorModel +from ..utils import EPS32 from . import processing, OpenclProcessing EventDescription = processing.EventDescription BufferDescription = processing.BufferDescription @@ -1220,12 +1221,14 @@ def medfilt(self, data, dark=None, dummy=None, delta_dummy=None, events.append(EventDescription(kernel_correction_name, ev)) kw_int["quant_min"] = numpy.float32(quant_min) - kw_int["quant_max"] = numpy.float32(quant_max) + kw_int["quant_max"] = numpy.float32(quant_max)*EPS32 wg_min = max(self.workgroup_size["csr_medfilt"]) kw_int["shared_int"] = pyopencl.LocalMemory(4 * wg_min) kw_int["shared_float"] = pyopencl.LocalMemory(8 * wg_min) wdim_bins = (wg_min, self.bins) + + integrate = self.kernels.csr_medfilt(self.queue, wdim_bins, (wg_min,1), *kw_int.values()) events.append(EventDescription("medfilt", integrate)) diff --git a/src/pyFAI/opencl/test/test_ocl_azim_csr.py b/src/pyFAI/opencl/test/test_ocl_azim_csr.py index 707416028..cdabfc58f 100644 --- a/src/pyFAI/opencl/test/test_ocl_azim_csr.py +++ b/src/pyFAI/opencl/test/test_ocl_azim_csr.py @@ -119,7 +119,7 @@ def integrate_ng(self, block_size=None, method_called="integrate_ng", extra=None elif method_called=="medfilt": pix = csr[2][1:]-csr[2][:-1] for i,j in zip(pix,res.count): - print(j-i,i,j) + print(i, j, i-j) # Intensities are not that different: delta = ref.intensity - res.intensity @@ -159,7 +159,7 @@ def test_medfilt(self): """ tests the median filtering kernel, default block size """ - self.integrate_ng(None, "medfilt", {"quant_min":0, "quant_max":1}) + self.integrate_ng(None, "medfilt", {"quant_min":0, "quant_max":1.0}) def suite(): diff --git a/src/pyFAI/resources/openCL/medfilt.cl b/src/pyFAI/resources/openCL/medfilt.cl index 00df7a673..11d29520e 100644 --- a/src/pyFAI/resources/openCL/medfilt.cl +++ b/src/pyFAI/resources/openCL/medfilt.cl @@ -202,6 +202,11 @@ csr_medfilt ( const global float4 *data4, acc_var = dw_plus_fp(acc_var, w.s2); acc_nrm = dw_plus_fp(acc_nrm, w.s3); acc_nrm2 = dw_plus_dw(acc_nrm2, fp_times_fp(w.s3, w.s3)); + + } + else{ + printf("bin:%d tid:%d qmin:%6.3f qlast:%6.3f qcur:%6.3f qmax:%6.3f\n", + bin_num, tid, qmin, q_last, w.s0,qmax); } } // Now parallel reductions, one after the other :-/ From 3ad9055b70a6727b5194beaa77248265b80b9160 Mon Sep 17 00:00:00 2001 From: Jerome Kieffer Date: Thu, 5 Dec 2024 15:53:13 +0100 Subject: [PATCH 11/23] fix test --- src/pyFAI/opencl/test/test_ocl_azim_csr.py | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/src/pyFAI/opencl/test/test_ocl_azim_csr.py b/src/pyFAI/opencl/test/test_ocl_azim_csr.py index cdabfc58f..11ea849bd 100644 --- a/src/pyFAI/opencl/test/test_ocl_azim_csr.py +++ b/src/pyFAI/opencl/test/test_ocl_azim_csr.py @@ -118,20 +118,22 @@ def integrate_ng(self, block_size=None, method_called="integrate_ng", extra=None self.assertEqual(delta.sum(), 0, "as much + and -") elif method_called=="medfilt": pix = csr[2][1:]-csr[2][:-1] - for i,j in zip(pix,res.count): - print(i, j, i-j) + self.assertTrue(numpy.allclose(res.count, pix), "all pixels have been counted") # Intensities are not that different: delta = ref.intensity - res.intensity self.assertLessEqual(abs(delta).max(), 1e-5, "intensity is almost the same") # histogram of normalization - err = abs((res.normalization - ref.sum_normalization).max()) + err = abs((res.normalization - ref.sum_normalization)).max() self.assertLess(err, 5e-4, "normalization content is the same: %s<5e-5" % (err)) # histogram of signal - print(res.signal - ref.sum_signal) - self.assertLess(abs((res.signal - ref.sum_signal).sum()), 5e-5, "signal content is the same") + self.assertLess(abs((res.signal - ref.sum_signal)).max(), 5e-5, "signal content is the same") + + # histogram of variance + self.assertLess(abs((res.variance - ref.sum_variance)).max(), 5e-5, "signal content is the same") + @unittest.skipUnless(ocl, "pyopencl is missing") def test_integrate_ng(self): @@ -159,7 +161,7 @@ def test_medfilt(self): """ tests the median filtering kernel, default block size """ - self.integrate_ng(None, "medfilt", {"quant_min":0, "quant_max":1.0}) + self.integrate_ng(None, "medfilt", {"quant_min":0, "quant_max":1}) def suite(): From ebb71389328009f5c00aea568fe6cf6673adfb4f Mon Sep 17 00:00:00 2001 From: Jerome Kieffer Date: Thu, 5 Dec 2024 16:02:00 +0100 Subject: [PATCH 12/23] Add test and ensure engine compatibility --- src/pyFAI/resources/openCL/medfilt.cl | 7 ------- src/pyFAI/test/test_medfilt_engine.py | 30 +++++++++++++++++++++++++-- 2 files changed, 28 insertions(+), 9 deletions(-) diff --git a/src/pyFAI/resources/openCL/medfilt.cl b/src/pyFAI/resources/openCL/medfilt.cl index 11d29520e..589cd0b45 100644 --- a/src/pyFAI/resources/openCL/medfilt.cl +++ b/src/pyFAI/resources/openCL/medfilt.cl @@ -129,7 +129,6 @@ csr_medfilt ( const global float4 *data4, float sum=0.0f, ratio=1.3f; float2 acc_sig, acc_nrm, acc_var, acc_nrm2; -// if (tid==0)printf("bin %d start %d stop %d\n",bin_num,start, stop); // first populate the work4 array from data4 for (int i=start+tid; i Date: Thu, 5 Dec 2024 16:28:00 +0100 Subject: [PATCH 13/23] Implement `medfilt` into AzimuthalIntegrator --- src/pyFAI/integrator/azimuthal.py | 306 +++++++++++++++++++++++++++++- version.py | 4 +- 2 files changed, 305 insertions(+), 5 deletions(-) diff --git a/src/pyFAI/integrator/azimuthal.py b/src/pyFAI/integrator/azimuthal.py index 0c209a2ba..c53bf839e 100644 --- a/src/pyFAI/integrator/azimuthal.py +++ b/src/pyFAI/integrator/azimuthal.py @@ -30,7 +30,7 @@ __contact__ = "Jerome.Kieffer@ESRF.eu" __license__ = "MIT" __copyright__ = "European Synchrotron Radiation Facility, Grenoble, France" -__date__ = "10/10/2024" +__date__ = "05/12/2024" __status__ = "stable" __docformat__ = 'restructuredtext' @@ -49,6 +49,7 @@ from ..io.ponifile import PoniFile error = None from ..method_registry import IntegrationMethod +from ..utils.decorators import deprecated # from .load_engines import ocl_sort #ocl_azim_csr, ocl_azim_lut, , histogram, splitBBox, \ @@ -1147,8 +1148,8 @@ def integrate2d_ng(self, data, npt_rad, npt_azim=360, integrate2d = _integrate2d_ng = integrate2d_ng - - def medfilt1d(self, data, npt_rad=1024, npt_azim=512, + @deprecated(since_version="2024.12", only_once=True, replacement="medfilt1d_ng", deprecated_since="2024.12") + def medfilt1d_legacy(self, data, npt_rad=1024, npt_azim=512, correctSolidAngle=True, radial_range=None, azimuth_range=None, polarization_factor=None, dark=None, flat=None, @@ -1285,6 +1286,305 @@ def medfilt1d(self, data, npt_rad=1024, npt_azim=512, result._set_normalization_factor(normalization_factor) return result + medfilt1d = medfilt1d_legacy + + def medfilt1d_ng(self, data, + npt=1024, + correctSolidAngle=True, + polarization_factor=None, + variance=None, + error_model=ErrorModel.NO, + radial_range=None, + azimuth_range=None, + dark=None, + flat=None, + absorption=None, + method=("full", "csr", "cython"), + unit=units.Q, + percentile=50, + dummy=None, + delta_dummy=None, + mask=None, + normalization_factor=1.0, + metadata=None, + safe=True, + **kwargs): + """Performs iteratively the 1D integration with variance propagation + and performs a sigm-clipping at each iteration, i.e. + all pixel which intensity differs more than thres*std is + discarded for next iteration. + + Keep only pixels with intensty: + + ``|I - | < thres * σ(I)`` + + This enforces a symmetric, bell-shaped distibution (i.e. gaussian-like) + and is very good at extracting background or amorphous isotropic scattering + out of Bragg peaks. + + :param data: input image as numpy array + :param npt_rad: number of radial points + :param bool correctSolidAngle: correct for solid angle of each pixel if True + :param float polarization_factor: polarization factor between: + -1 (vertical) + +1 (horizontal). + - 0 for circular polarization or random, + - None for no correction, + - True for using the former correction + :param radial_range: The lower and upper range of the radial unit. If not provided, range is simply (data.min(), data.max()). Values outside the range are ignored. + :type radial_range: (float, float), optional + :param azimuth_range: The lower and upper range of the azimuthal angle in degree. If not provided, range is simply (data.min(), data.max()). Values outside the range are ignored. + :type azimuth_range: (float, float), optional + + :param ndarray dark: dark noise image + :param ndarray flat: flat field image + :param ndarray absorption: Detector absorption (image) + :param ndarray variance: the variance of the signal + :param str error_model: can be "poisson" to assume a poissonian detector (variance=I) or "azimuthal" to take the std² in each ring (better, more expenive) + :param unit: unit to be used for integration + :param IntegrationMethod method: IntegrationMethod instance or 3-tuple with (splitting, algorithm, implementation) + :param percentile: which percentile use for cutting out. + percentil can be a 2-tuple to specify a region to average out, + like: (25,75) to average the second and third quartile. + :param mask: masked out pixels array + :param float normalization_factor: Value of a normalization monitor + :param metadata: any other metadata, + :type metadata: JSON serializable dict + :param safe: set to False to skip some tests + :return: Integrate1D like result like + + The difference with the previous `medfilt_legacy` implementation is that there is no 2D regrouping. + """ + for k in kwargs: + if k == "npt_azim": + logger.warning("'npt_azim' argument is not used in sigma_clip_ng as not 2D intergration is performed anymore") + else: + logger.warning("Got unknown argument %s %s", k, kwargs[k]) + + error_model = ErrorModel.parse(error_model) + if variance is not None: + assert variance.size == data.size + error_model = ErrorModel.VARIANCE + + unit = units.to_unit(unit) + if radial_range: + radial_range = tuple(radial_range[i] / unit.scale for i in (0, -1)) + if azimuth_range is not None: + azimuth_range = self.normalize_azimuth_range(azimuth_range) + try: + quant_min = min(percentile)/100 + quant_max = max(percentile)/100 + except: + quant_min = quant_max = percentile/100.0 + + method = self._normalize_method(method, dim=1, default=self.DEFAULT_METHOD_1D) + + if mask is None: + has_mask = "from detector" + mask = self.mask + mask_crc = self.detector.get_mask_crc() + if mask is None: + has_mask = False + mask_crc = None + else: + has_mask = "user provided" + mask = numpy.ascontiguousarray(mask) + mask_crc = crc32(mask) + + if dark is None: + dark = self.detector.darkcurrent + if dark is None: + has_dark = False + else: + has_dark = "from detector" + else: + has_dark = "provided" + + if flat is None: + flat = self.detector.flatfield + if dark is None: + has_flat = False + else: + has_flat = "from detector" + else: + has_flat = "provided" + + if correctSolidAngle: + solidangle = self.solidAngleArray(data.shape, correctSolidAngle) + else: + solidangle = None + + if polarization_factor is None: + polarization = polarization_crc = None + else: + polarization, polarization_crc = self.polarization(data.shape, polarization_factor, with_checksum=True) + + if (method.algo_lower == "csr"): + "This is the only method implemented for now ..." + # Prepare LUT if needed! + # initialize the CSR integrator in Cython as it may be needed later on. + cython_method = IntegrationMethod.select_method(method.dimension, method.split_lower, method.algo_lower, "cython")[0] + if cython_method not in self.engines: + cython_engine = self.engines[cython_method] = Engine() + else: + cython_engine = self.engines[cython_method] + with cython_engine.lock: + # Validate that the engine used is the proper one + cython_integr = cython_engine.engine + cython_reset = None + if cython_integr is None: + cython_reset = "of first initialization" + if (not cython_reset) and safe: + if cython_integr.unit != unit: + cython_reset = "unit was changed" + if cython_integr.bins != npt: + cython_reset = "number of points changed" + if cython_integr.size != data.size: + cython_reset = "input image size changed" + if cython_integr.empty != self._empty: + cython_reset = "empty value changed " + if (mask is not None) and (not cython_integr.check_mask): + cython_reset = "mask but CSR was without mask" + elif (mask is None) and (cython_integr.check_mask): + cython_reset = "no mask but CSR has mask" + elif (mask is not None) and (cython_integr.mask_checksum != mask_crc): + cython_reset = "mask changed" + if (radial_range is None) and (cython_integr.pos0_range is not None): + cython_reset = "radial_range was defined in CSR" + elif (radial_range is not None) and cython_integr.pos0_range != (min(radial_range), max(radial_range)): + cython_reset = "radial_range is defined but not the same as in CSR" + if (azimuth_range is None) and (cython_integr.pos1_range is not None): + cython_reset = "azimuth_range not defined and CSR had azimuth_range defined" + elif (azimuth_range is not None) and cython_integr.pos1_range != (min(azimuth_range), max(azimuth_range)): + cython_reset = "azimuth_range requested and CSR's azimuth_range don't match" + if cython_reset: + logger.info("AI.sigma_clip_ng: Resetting Cython integrator because %s", cython_reset) + split = method.split_lower + if split == "pseudo": + split = "full" + try: + cython_integr = self.setup_sparse_integrator(data.shape, npt, mask=mask, + mask_checksum=mask_crc, + unit=unit, split=split, algo="CSR", + pos0_range=radial_range, + pos1_range=azimuth_range, + empty=self._empty, + scale=False) + except MemoryError: # CSR method is hungry... + logger.warning("MemoryError: falling back on forward implementation") + cython_integr = None + self.reset_engines() + method = self.DEFAULT_METHOD_1D + else: + cython_engine.set_engine(cython_integr) + if method not in self.engines: + # instanciated the engine + engine = self.engines[method] = Engine() + else: + engine = self.engines[method] + with engine.lock: + # Validate that the engine used is the proper one + integr = engine.engine + reset = None + # This whole block uses CSR, Now we should treat all the various implementation: Cython, OpenCL and finally Python. + + # Validate that the engine used is the proper one + if integr is None: + reset = "of first initialization" + if (not reset) and safe: + if integr.unit != unit: + reset = "unit was changed" + if integr.bins != npt: + reset = "number of points changed" + if integr.size != data.size: + reset = "input image size changed" + if integr.empty != self._empty: + reset = "empty value changed " + if (mask is not None) and (not integr.check_mask): + reset = "mask but CSR was without mask" + elif (mask is None) and (integr.check_mask): + reset = "no mask but CSR has mask" + elif (mask is not None) and (integr.mask_checksum != mask_crc): + reset = "mask changed" + # TODO + if (radial_range is None) and (integr.pos0_range is not None): + reset = "radial_range was defined in CSR" + elif (radial_range is not None) and integr.pos0_range != (min(radial_range), max(radial_range)): + reset = "radial_range is defined but not the same as in CSR" + if (azimuth_range is None) and (integr.pos1_range is not None): + reset = "azimuth_range not defined and CSR had azimuth_range defined" + elif (azimuth_range is not None) and integr.pos1_range != (min(azimuth_range), max(azimuth_range)): + reset = "azimuth_range requested and CSR's azimuth_range don't match" + + if reset: + logger.info("ai.sigma_clip_ng: Resetting ocl_csr integrator because %s", reset) + csr_integr = self.engines[cython_method].engine + if method.impl_lower == "opencl": + try: + integr = method.class_funct_ng.klass(csr_integr.lut, + image_size=data.size, + checksum=csr_integr.lut_checksum, + empty=self._empty, + unit=unit, + mask_checksum=csr_integr.mask_checksum, + bin_centers=csr_integr.bin_centers, + platformid=method.target[0], + deviceid=method.target[1]) + except MemoryError: + logger.warning("MemoryError: falling back on default forward implementation") + self.reset_engines() + method = self.DEFAULT_METHOD_1D + else: + # Copy some properties from the cython integrator + integr.pos0_range = csr_integr.pos0_range + integr.pos1_range = csr_integr.pos1_range + engine.set_engine(integr) + elif method.impl_lower in ("python", "cython"): + integr = method.class_funct_ng.klass(lut=csr_integr.lut, + image_size=data.size, + empty=self._empty, + unit=unit, + mask_checksum=csr_integr.mask_checksum, + bin_centers=csr_integr.bin_centers) + # Copy some properties from the cython integrator + integr.pos0_range = csr_integr.pos0_range + integr.pos1_range = csr_integr.pos1_range + engine.set_engine(integr) + else: + logger.error(f"Implementation {method.impl_lower} not supported") + else: + integr = self.engines[method].engine + kwargs = {"dark":dark, "dummy":dummy, "delta_dummy":delta_dummy, + "variance":variance, "dark_variance":None, + "flat":flat, "solidangle":solidangle, "polarization":polarization, "absorption":absorption, + "error_model":error_model, "normalization_factor":normalization_factor, + "quant_min":quant_min, "quant_max":quant_max} + + intpl = integr.medfilt(data, **kwargs) + else: + raise RuntimeError("Not yet implemented. Sorry") + result = Integrate1dResult(intpl.position * unit.scale, intpl.intensity, intpl.sem) + result._set_method_called("sigma_clip_ng") + result._set_method(method) + result._set_compute_engine(str(method)) + result._set_percentile(percentile) + result._set_unit(unit) + result._set_has_mask_applied(has_mask) + result._set_has_dark_correction(has_dark) + result._set_has_flat_correction(has_flat) + result._set_metadata(metadata) + result._set_sum_signal(intpl.signal) + result._set_sum_normalization(intpl.normalization) + result._set_sum_normalization2(intpl.norm_sq) + result._set_std(intpl.std) + result._set_sem(intpl.sem) + result._set_sum_variance(intpl.variance) + result._set_count(intpl.count) + result._set_polarization_factor(polarization_factor) + result._set_normalization_factor(normalization_factor) + result._set_error_model(error_model) + return result + def sigma_clip_legacy(self, data, npt_rad=1024, npt_azim=512, correctSolidAngle=True, polarization_factor=None, radial_range=None, azimuth_range=None, diff --git a/version.py b/version.py index 324cf9028..dbeb16fc1 100755 --- a/version.py +++ b/version.py @@ -47,7 +47,7 @@ __authors__ = ["Jérôme Kieffer", "V. Valls"] __license__ = "MIT" __copyright__ = "European Synchrotron Radiation Facility, Grenoble, France" -__date__ = "10/10/2024" +__date__ = "05/12/2024" __status__ = "production" __docformat__ = 'restructuredtext' __all__ = ["date", "version_info", "strictversion", "hexversion", "debianversion", @@ -61,7 +61,7 @@ "final": 15} MAJOR = 2024 -MINOR = 11 +MINOR = 12 MICRO = 0 RELEV = "dev" # <16 SERIAL = 0 # <16 From 7cfa9ff0f850d6834c3ff9effd5faac32ef44f9b Mon Sep 17 00:00:00 2001 From: Jerome Kieffer Date: Thu, 5 Dec 2024 18:10:44 +0100 Subject: [PATCH 14/23] Handle the case "median filter" Tests remain noisy --- src/pyFAI/ext/CSR_common.pxi | 5 +++-- src/pyFAI/integrator/azimuthal.py | 2 +- src/pyFAI/opencl/azim_csr.py | 2 +- src/pyFAI/resources/openCL/medfilt.cl | 12 ++++++++++-- 4 files changed, 15 insertions(+), 6 deletions(-) diff --git a/src/pyFAI/ext/CSR_common.pxi b/src/pyFAI/ext/CSR_common.pxi index 9a83af563..5e84f350c 100644 --- a/src/pyFAI/ext/CSR_common.pxi +++ b/src/pyFAI/ext/CSR_common.pxi @@ -29,7 +29,7 @@ __author__ = "Jérôme Kieffer" __contact__ = "Jerome.kieffer@esrf.fr" -__date__ = "19/11/2024" +__date__ = "05/12/2024" __status__ = "stable" __license__ = "MIT" @@ -859,7 +859,8 @@ cdef class CsrIntegrator(object): for i in range(start, stop): former_element = element element = work[i] - if (qmin<=former_element.s0) and (element.s0 <= qmax): + if ((qmin<=former_element.s0) and (element.s0 <= qmax)) or \ + ((qmin>=former_element.s0) and (element.s0 >= qmax)): #specific case where qmin==qmax acc_sig = acc_sig + element.s1 acc_var = acc_var + element.s2 acc_norm = acc_norm + element.s3 diff --git a/src/pyFAI/integrator/azimuthal.py b/src/pyFAI/integrator/azimuthal.py index c53bf839e..2f47c1616 100644 --- a/src/pyFAI/integrator/azimuthal.py +++ b/src/pyFAI/integrator/azimuthal.py @@ -1148,7 +1148,7 @@ def integrate2d_ng(self, data, npt_rad, npt_azim=360, integrate2d = _integrate2d_ng = integrate2d_ng - @deprecated(since_version="2024.12", only_once=True, replacement="medfilt1d_ng", deprecated_since="2024.12") + @deprecated(since_version="2024.12.0", only_once=True, replacement="medfilt1d_ng", deprecated_since="2024.12.0") def medfilt1d_legacy(self, data, npt_rad=1024, npt_azim=512, correctSolidAngle=True, radial_range=None, azimuth_range=None, diff --git a/src/pyFAI/opencl/azim_csr.py b/src/pyFAI/opencl/azim_csr.py index 5ac301e9b..5080ddab3 100644 --- a/src/pyFAI/opencl/azim_csr.py +++ b/src/pyFAI/opencl/azim_csr.py @@ -1221,7 +1221,7 @@ def medfilt(self, data, dark=None, dummy=None, delta_dummy=None, events.append(EventDescription(kernel_correction_name, ev)) kw_int["quant_min"] = numpy.float32(quant_min) - kw_int["quant_max"] = numpy.float32(quant_max)*EPS32 + kw_int["quant_max"] = numpy.float32(quant_max)#*EPS32 wg_min = max(self.workgroup_size["csr_medfilt"]) kw_int["shared_int"] = pyopencl.LocalMemory(4 * wg_min) diff --git a/src/pyFAI/resources/openCL/medfilt.cl b/src/pyFAI/resources/openCL/medfilt.cl index 589cd0b45..e86115df0 100644 --- a/src/pyFAI/resources/openCL/medfilt.cl +++ b/src/pyFAI/resources/openCL/medfilt.cl @@ -105,7 +105,7 @@ csr_medfilt ( const global float4 *data4, const global int *indices, const global int *indptr, const float quant_min, - const float quant_max, + float quant_max, const char error_model, const float empty, global float8 *summed, @@ -129,6 +129,10 @@ csr_medfilt ( const global float4 *data4, float sum=0.0f, ratio=1.3f; float2 acc_sig, acc_nrm, acc_var, acc_nrm2; + // ensure the last element is always taken + if (quant_max == 1.0f) + quant_max = 1.1f; + // first populate the work4 array from data4 for (int i=start+tid; istart)?work4[i-1].s0:0.0f; float4 w = work4[i]; - if ((q_last>=qmin) && (w.s0<=qmax)){ + if (((q_last>=qmin) && (w.s0<=qmax))|| + ((q_last<=qmin) && (w.s0>=qmax))) { // case qmin==qmax cnt ++; acc_sig = dw_plus_fp(acc_sig, w.s1); acc_var = dw_plus_fp(acc_var, w.s2); From 9d7e7d94b1b5bbe107d3d29407f43323cde8325b Mon Sep 17 00:00:00 2001 From: Jerome Kieffer Date: Thu, 5 Dec 2024 18:27:00 +0100 Subject: [PATCH 15/23] Try to mitigate noisy test --- src/pyFAI/test/test_medfilt_engine.py | 25 ++++++++++++------------- 1 file changed, 12 insertions(+), 13 deletions(-) diff --git a/src/pyFAI/test/test_medfilt_engine.py b/src/pyFAI/test/test_medfilt_engine.py index 7ff4a1cea..e84cc9bd8 100644 --- a/src/pyFAI/test/test_medfilt_engine.py +++ b/src/pyFAI/test/test_medfilt_engine.py @@ -130,21 +130,20 @@ def test_opencl(self): print(engine) obt = engine.medfilt(self.img, solidangle=self.ai.solidAngleArray(), - quant_min=0,quant_max=1, # taking all Like this it works like a normal mean + quant_min=0,quant_max=1, # taking all like this: it works like a normal mean error_model="poisson") - - # print(ref.count-obt.count) - # print() self.assertTrue(numpy.allclose(ref.radial, obt.position), "radial matches") - self.assertTrue(numpy.allclose(ref.sum_signal, obt.signal), "signal matches") - self.assertTrue(numpy.allclose(ref.sum_variance, obt.variance), "variance matches") - self.assertTrue(numpy.allclose(ref.sum_normalization, obt.normalization), "normalization matches") - self.assertTrue(numpy.allclose(ref.sum_normalization2, obt.norm_sq), "norm_sq matches") - # self.assertTrue(numpy.allclose(ref.count, obt.count), "count matches") # not valid with pixel splitting - self.assertTrue(numpy.allclose(ref.intensity, obt.intensity), "intensity matches") - self.assertTrue(numpy.allclose(ref.sigma, obt.sigma), "sigma matches") - self.assertTrue(numpy.allclose(ref.std, obt.std), "std matches") - self.assertTrue(numpy.allclose(ref.sem, obt.sem), "sem matches") + print(ref.sum_signal- obt.signal) + thres = 1e-6 + self.assertLessEqual(numpy.sum(abs(ref.sum_signal-obt.signal)>thres), 3, "signal matches") + self.assertLessEqual(numpy.sum(abs(ref.sum_variance-obt.variance)>thres), 10, "variance matches") + self.assertLessEqual(numpy.sum(abs(ref.sum_normalization-obt.normalization)>thres), 3, "normalization matches") + self.assertLessEqual(numpy.sum(abs(ref.sum_normalization2-obt.norm_sq)>1e6), 50, "norm_sq matches") + # self.assertTrue(numpy.allclose(engine._indptr[1:]-engine._indptr[:-1], obt.count), "count matches") # not valid with pixel splitting + self.assertLessEqual(numpy.sum(ref.intensity!=obt.intensity), 3, "intensity matches") + self.assertLessEqual(numpy.sum(ref.sigma!=obt.sigma), 50, "sigma matches") + self.assertLessEqual(numpy.sum(ref.std!=obt.std), 50, "std matches") + self.assertLessEqual(numpy.sum(ref.sem!=obt.sem), 50, "sem matches") def suite(): From 524bd04ad388a4d1f2047230ab38d26d1f99c8f3 Mon Sep 17 00:00:00 2001 From: Jerome Kieffer Date: Fri, 6 Dec 2024 16:00:42 +0100 Subject: [PATCH 16/23] Fix OpenCL median filtering --- src/pyFAI/opencl/azim_csr.py | 24 +++++++++++++++++- src/pyFAI/resources/openCL/medfilt.cl | 11 ++++---- src/pyFAI/test/test_medfilt_engine.py | 36 ++++++++++++++++----------- 3 files changed, 51 insertions(+), 20 deletions(-) diff --git a/src/pyFAI/opencl/azim_csr.py b/src/pyFAI/opencl/azim_csr.py index 5080ddab3..b849cb0c2 100644 --- a/src/pyFAI/opencl/azim_csr.py +++ b/src/pyFAI/opencl/azim_csr.py @@ -28,7 +28,7 @@ __authors__ = ["Jérôme Kieffer", "Giannis Ashiotis"] __license__ = "MIT" -__date__ = "05/12/2024" +__date__ = "06/12/2024" __copyright__ = "ESRF, Grenoble" __contact__ = "jerome.kieffer@esrf.fr" @@ -188,6 +188,7 @@ def __init__(self, lut, image_size, checksum=None, self.send_buffer(self._data, "data") self.send_buffer(self._indices, "indices") self.send_buffer(self._indptr, "indptr") + if "amd" in self.ctx.devices[0].platform.name.lower(): self.workgroup_size["csr_integrate4_single"] = (1, 1) # Very bad performances on AMD GPU for diverging threads! @@ -481,6 +482,27 @@ def send_buffer(self, data, dest, checksum=None, workgroup_size=None, convert=Tr self.on_device[dest] = checksum return dest_buffer + def get_buffer(self, name, out=None): + """retrive a Send a numpy array to the device, including the type conversion on the device if possible + + :param name: name of the buffer + :param out: pre-allocated destination numpy array + :return: the numpy array + """ + if out is None: + if name in self.cl_mem: + for buf in self.buffers: + if buf.name == name: + shape = buf.size + dtype = buf.dtype + out = numpy.empty(shape, dtype) + else: + logger.error("No such buffer declared") + + ev = pyopencl.enqueue_copy(self.queue, out, self.cl_mem[name]) + self.events.append(EventDescription(f"copy D->H {name}", ev)) + return out + def integrate_legacy(self, data, dummy=None, delta_dummy=None, dark=None, flat=None, solidangle=None, polarization=None, absorption=None, dark_checksum=None, flat_checksum=None, solidangle_checksum=None, diff --git a/src/pyFAI/resources/openCL/medfilt.cl b/src/pyFAI/resources/openCL/medfilt.cl index e86115df0..8c72aeda3 100644 --- a/src/pyFAI/resources/openCL/medfilt.cl +++ b/src/pyFAI/resources/openCL/medfilt.cl @@ -7,7 +7,7 @@ * Grenoble, France * * Principal authors: J. Kieffer (kieffer@esrf.fr) - * Last revision: 25/11/2024 + * Last revision: 06/12/2024 * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal @@ -131,7 +131,7 @@ csr_medfilt ( const global float4 *data4, // ensure the last element is always taken if (quant_max == 1.0f) - quant_max = 1.1f; + quant_max = 1.000001f; // first populate the work4 array from data4 for (int i=start+tid; istart)?work4[i-1].s0:0.0f; float4 w = work4[i]; - if (((q_last>=qmin) && (w.s0<=qmax))|| - ((q_last<=qmin) && (w.s0>=qmax))) { // case qmin==qmax + if((((q_last>=qmin) && (w.s0<=qmax)) // case several contribution + || ((q_last<=qmin) && (w.s0>=qmax))) // case unique contribution qmin==qmax + && (w.s3)) { // non empty cnt ++; acc_sig = dw_plus_fp(acc_sig, w.s1); acc_var = dw_plus_fp(acc_var, w.s2); diff --git a/src/pyFAI/test/test_medfilt_engine.py b/src/pyFAI/test/test_medfilt_engine.py index e84cc9bd8..2bc1cd5ff 100644 --- a/src/pyFAI/test/test_medfilt_engine.py +++ b/src/pyFAI/test/test_medfilt_engine.py @@ -32,7 +32,7 @@ __contact__ = "Jerome.Kieffer@ESRF.eu" __license__ = "MIT" __copyright__ = "European Synchrotron Radiation Facility, Grenoble, France" -__date__ = "05/12/2024" +__date__ = "06/12/2024" import unittest import numpy @@ -125,25 +125,33 @@ def test_opencl(self): method[-1] = "opencl" method = tuple(method) ref = self.ai.integrate1d(self.img, self.npt, unit="2th_rad", method=method, error_model="poisson") - print(ref.method) engine = self.ai.engines[ref.method].engine - print(engine) obt = engine.medfilt(self.img, solidangle=self.ai.solidAngleArray(), quant_min=0,quant_max=1, # taking all like this: it works like a normal mean error_model="poisson") self.assertTrue(numpy.allclose(ref.radial, obt.position), "radial matches") - print(ref.sum_signal- obt.signal) - thres = 1e-6 - self.assertLessEqual(numpy.sum(abs(ref.sum_signal-obt.signal)>thres), 3, "signal matches") - self.assertLessEqual(numpy.sum(abs(ref.sum_variance-obt.variance)>thres), 10, "variance matches") - self.assertLessEqual(numpy.sum(abs(ref.sum_normalization-obt.normalization)>thres), 3, "normalization matches") - self.assertLessEqual(numpy.sum(abs(ref.sum_normalization2-obt.norm_sq)>1e6), 50, "norm_sq matches") - # self.assertTrue(numpy.allclose(engine._indptr[1:]-engine._indptr[:-1], obt.count), "count matches") # not valid with pixel splitting - self.assertLessEqual(numpy.sum(ref.intensity!=obt.intensity), 3, "intensity matches") - self.assertLessEqual(numpy.sum(ref.sigma!=obt.sigma), 50, "sigma matches") - self.assertLessEqual(numpy.sum(ref.std!=obt.std), 50, "std matches") - self.assertLessEqual(numpy.sum(ref.sem!=obt.sem), 50, "sem matches") + + + + thres = 1e-4 + thres_cnt = 1 + + + # self.assertLessEqual(numpy.sum(abs(ref.sum_signal-obt.signal)>thres), thres_cnt, "signal matches") + # self.assertLessEqual(numpy.sum(abs(ref.sum_variance-obt.variance)>thres), thres_cnt, "variance matches") + # self.assertLessEqual(numpy.sum(abs(ref.sum_normalization-obt.normalization)>thres), thres_cnt, "normalization matches") + # self.assertLessEqual(numpy.sum(abs(ref.sum_normalization2-obt.norm_sq)>thres), thres_cnt, "norm_sq matches") + self.assertTrue(numpy.allclose(engine._indptr[1:]-engine._indptr[:-1], obt.count), "count matches") # not valid with pixel splitting + self.assertTrue(numpy.allclose(ref.sum_signal, obt.signal, atol=1e-4, rtol=1e-6), "signal matches") + self.assertTrue(numpy.allclose(ref.sum_variance, obt.variance, atol=1e-4, rtol=1e-6), "variance matches") + self.assertTrue(numpy.allclose(ref.sum_normalization, obt.normalization, atol=1e-4, rtol=1e-6), "normalization matches") + self.assertTrue(numpy.allclose(ref.sum_normalization2, obt.norm_sq, atol=1e-2, rtol=1e-3), "norm_sq matches") + + self.assertLessEqual(numpy.sum(abs(ref.intensity-obt.intensity)>thres), thres_cnt, "intensity matches") + self.assertLessEqual(numpy.sum(abs(ref.sigma-obt.sigma)>thres), thres_cnt, "sigma matches") + self.assertLessEqual(numpy.sum(abs(ref.std-obt.std>thres)), thres_cnt, "std matches") + self.assertLessEqual(numpy.sum(abs(ref.sem-obt.sem>thres)), thres_cnt, "sem matches") def suite(): From fe1b0b83b204b2953830ec6809a10d172bf5f58b Mon Sep 17 00:00:00 2001 From: Jerome Kieffer Date: Fri, 6 Dec 2024 16:44:06 +0100 Subject: [PATCH 17/23] Debug parallel implementation on CPU/Intel driver --- src/pyFAI/opencl/azim_csr.py | 17 ++++++++++++++--- src/pyFAI/opencl/test/test_ocl_azim_csr.py | 17 +++++++++++------ 2 files changed, 25 insertions(+), 9 deletions(-) diff --git a/src/pyFAI/opencl/azim_csr.py b/src/pyFAI/opencl/azim_csr.py index b849cb0c2..33d20daf3 100644 --- a/src/pyFAI/opencl/azim_csr.py +++ b/src/pyFAI/opencl/azim_csr.py @@ -32,6 +32,7 @@ __copyright__ = "ESRF, Grenoble" __contact__ = "jerome.kieffer@esrf.fr" +import math import logging from collections import OrderedDict import numpy @@ -301,7 +302,16 @@ def compile_kernels(self, kernel_file=None): else: wg_max = self.kernels.max_workgroup_size(kernel_name) wg_min = self.kernels.min_workgroup_size(kernel_name) - self.workgroup_size[kernel_name] = (wg_min, wg_max) + if kernel_name=="csr_medfilt": + # limit the wg size due to + device = self.ctx.devices[0] + maxthreads = device.local_mem_size/12/4 + self.workgroup_size[kernel_name] = (wg_min, + min(wg_max, 2**(int(math.log2(maxthreads))))) + else: + self.workgroup_size[kernel_name] = (wg_min, wg_max) + + def set_kernel_arguments(self): """Tie arguments of OpenCL kernel-functions to the actual kernels @@ -1243,8 +1253,7 @@ def medfilt(self, data, dark=None, dummy=None, delta_dummy=None, events.append(EventDescription(kernel_correction_name, ev)) kw_int["quant_min"] = numpy.float32(quant_min) - kw_int["quant_max"] = numpy.float32(quant_max)#*EPS32 - + kw_int["quant_max"] = numpy.float32(quant_max) wg_min = max(self.workgroup_size["csr_medfilt"]) kw_int["shared_int"] = pyopencl.LocalMemory(4 * wg_min) kw_int["shared_float"] = pyopencl.LocalMemory(8 * wg_min) @@ -1292,6 +1301,8 @@ def medfilt(self, data, dark=None, dummy=None, delta_dummy=None, res = Integrate1dtpl(self.bin_centers, avgint, sem, merged[:, 0], merged[:, 2], merged[:, 4], merged[:, 6], std, sem, merged[:, 7]) + # print(self.get_buffer("merged8")[0]) + # raise RuntimeError() return res diff --git a/src/pyFAI/opencl/test/test_ocl_azim_csr.py b/src/pyFAI/opencl/test/test_ocl_azim_csr.py index 11ea849bd..93b5dd557 100644 --- a/src/pyFAI/opencl/test/test_ocl_azim_csr.py +++ b/src/pyFAI/opencl/test/test_ocl_azim_csr.py @@ -33,7 +33,7 @@ __contact__ = "jerome.kieffer@esrf.eu" __license__ = "MIT" __copyright__ = "2019-2021 European Synchrotron Radiation Facility, Grenoble, France" -__date__ = "05/12/2024" +__date__ = "06/12/2024" import logging import numpy @@ -120,13 +120,13 @@ def integrate_ng(self, block_size=None, method_called="integrate_ng", extra=None pix = csr[2][1:]-csr[2][:-1] self.assertTrue(numpy.allclose(res.count, pix), "all pixels have been counted") - # Intensities are not that different: - delta = ref.intensity - res.intensity - self.assertLessEqual(abs(delta).max(), 1e-5, "intensity is almost the same") # histogram of normalization - err = abs((res.normalization - ref.sum_normalization)).max() - self.assertLess(err, 5e-4, "normalization content is the same: %s<5e-5" % (err)) + print(ref.sum_normalization) + print(res.normalization) + err = abs((res.normalization - ref.sum_normalization)) + print(err) + self.assertLess(err.max(), 5e-4, "normalization content is the same: %s<5e-5" % (err.max)) # histogram of signal self.assertLess(abs((res.signal - ref.sum_signal)).max(), 5e-5, "signal content is the same") @@ -134,6 +134,11 @@ def integrate_ng(self, block_size=None, method_called="integrate_ng", extra=None # histogram of variance self.assertLess(abs((res.variance - ref.sum_variance)).max(), 5e-5, "signal content is the same") + # Intensities are not that different: + delta = ref.intensity - res.intensity + print(delta) + self.assertLessEqual(abs(delta).max(), 1e-5, "intensity is almost the same") + @unittest.skipUnless(ocl, "pyopencl is missing") def test_integrate_ng(self): From b23d02a13e69c192b3af5325eea98b19358e273e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C3=A9r=C3=B4me=20Kieffer?= Date: Sat, 7 Dec 2024 21:35:32 +0100 Subject: [PATCH 18/23] fix code execution with Intel CPU driver --- src/pyFAI/opencl/azim_csr.py | 2 -- src/pyFAI/opencl/test/test_ocl_azim_csr.py | 8 ++++---- src/pyFAI/resources/openCL/collective/reduction.cl | 8 ++++++-- src/pyFAI/resources/openCL/medfilt.cl | 4 +++- 4 files changed, 13 insertions(+), 9 deletions(-) diff --git a/src/pyFAI/opencl/azim_csr.py b/src/pyFAI/opencl/azim_csr.py index 33d20daf3..c48de18fe 100644 --- a/src/pyFAI/opencl/azim_csr.py +++ b/src/pyFAI/opencl/azim_csr.py @@ -1301,8 +1301,6 @@ def medfilt(self, data, dark=None, dummy=None, delta_dummy=None, res = Integrate1dtpl(self.bin_centers, avgint, sem, merged[:, 0], merged[:, 2], merged[:, 4], merged[:, 6], std, sem, merged[:, 7]) - # print(self.get_buffer("merged8")[0]) - # raise RuntimeError() return res diff --git a/src/pyFAI/opencl/test/test_ocl_azim_csr.py b/src/pyFAI/opencl/test/test_ocl_azim_csr.py index 93b5dd557..e8c31df26 100644 --- a/src/pyFAI/opencl/test/test_ocl_azim_csr.py +++ b/src/pyFAI/opencl/test/test_ocl_azim_csr.py @@ -122,10 +122,10 @@ def integrate_ng(self, block_size=None, method_called="integrate_ng", extra=None # histogram of normalization - print(ref.sum_normalization) - print(res.normalization) + # print(ref.sum_normalization) + # print(res.normalization) err = abs((res.normalization - ref.sum_normalization)) - print(err) + # print(err) self.assertLess(err.max(), 5e-4, "normalization content is the same: %s<5e-5" % (err.max)) # histogram of signal @@ -136,7 +136,7 @@ def integrate_ng(self, block_size=None, method_called="integrate_ng", extra=None # Intensities are not that different: delta = ref.intensity - res.intensity - print(delta) + # print(delta) self.assertLessEqual(abs(delta).max(), 1e-5, "intensity is almost the same") diff --git a/src/pyFAI/resources/openCL/collective/reduction.cl b/src/pyFAI/resources/openCL/collective/reduction.cl index e1c01d7df..a1222156b 100644 --- a/src/pyFAI/resources/openCL/collective/reduction.cl +++ b/src/pyFAI/resources/openCL/collective/reduction.cl @@ -17,7 +17,9 @@ int inline sum_int_reduction(local int* shared) shared[tid] += shared[tid+stride]; } barrier(CLK_LOCAL_MEM_FENCE); - return shared[0]; + int res = shared[0]; + barrier(CLK_LOCAL_MEM_FENCE); + return res; } /* sum all elements in a shared memory, same size as the workgroup size 0 @@ -35,7 +37,9 @@ int inline sum_int_atomic(local int* shared) if (tid) atomic_add(shared, value); barrier(CLK_LOCAL_MEM_FENCE); - return shared[0]; + int res = shared[0]; + barrier(CLK_LOCAL_MEM_FENCE); + return res; } /* diff --git a/src/pyFAI/resources/openCL/medfilt.cl b/src/pyFAI/resources/openCL/medfilt.cl index 8c72aeda3..ebf2d2ffb 100644 --- a/src/pyFAI/resources/openCL/medfilt.cl +++ b/src/pyFAI/resources/openCL/medfilt.cl @@ -70,7 +70,9 @@ float2 inline sum_float2_reduction(local float* shared) } barrier(CLK_LOCAL_MEM_FENCE); - return (float2)(shared[0], shared[1]); + float2 res = (float2)(shared[0], shared[1]); + barrier(CLK_LOCAL_MEM_FENCE); + return res; } From 56f69289cb08deeade5811167deeff451ef5026f Mon Sep 17 00:00:00 2001 From: Jerome Kieffer Date: Sat, 7 Dec 2024 21:42:22 +0100 Subject: [PATCH 19/23] Discard pixel without weight --- src/pyFAI/ext/CSR_common.pxi | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/pyFAI/ext/CSR_common.pxi b/src/pyFAI/ext/CSR_common.pxi index 5e84f350c..101fc64ca 100644 --- a/src/pyFAI/ext/CSR_common.pxi +++ b/src/pyFAI/ext/CSR_common.pxi @@ -859,8 +859,9 @@ cdef class CsrIntegrator(object): for i in range(start, stop): former_element = element element = work[i] - if ((qmin<=former_element.s0) and (element.s0 <= qmax)) or \ - ((qmin>=former_element.s0) and (element.s0 >= qmax)): #specific case where qmin==qmax + if ((element.s3!=0) and + (((qmin<=former_element.s0) and (element.s0 <= qmax)) or + ((qmin>=former_element.s0) and (element.s0 >= qmax))): #specific case where qmin==qmax acc_sig = acc_sig + element.s1 acc_var = acc_var + element.s2 acc_norm = acc_norm + element.s3 From c9e256936deb6ee77844f6b00a00a5eea426f834 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Sat, 7 Dec 2024 20:42:33 +0000 Subject: [PATCH 20/23] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- src/pyFAI/ext/CSR_common.pxi | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/pyFAI/ext/CSR_common.pxi b/src/pyFAI/ext/CSR_common.pxi index 101fc64ca..e152bf43a 100644 --- a/src/pyFAI/ext/CSR_common.pxi +++ b/src/pyFAI/ext/CSR_common.pxi @@ -859,8 +859,8 @@ cdef class CsrIntegrator(object): for i in range(start, stop): former_element = element element = work[i] - if ((element.s3!=0) and - (((qmin<=former_element.s0) and (element.s0 <= qmax)) or + if ((element.s3!=0) and + (((qmin<=former_element.s0) and (element.s0 <= qmax)) or ((qmin>=former_element.s0) and (element.s0 >= qmax))): #specific case where qmin==qmax acc_sig = acc_sig + element.s1 acc_var = acc_var + element.s2 From 60fa0f42129cd042db3c39253441cd8293820d25 Mon Sep 17 00:00:00 2001 From: Jerome Kieffer Date: Sat, 7 Dec 2024 21:46:11 +0100 Subject: [PATCH 21/23] Typo --- src/pyFAI/ext/CSR_common.pxi | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/pyFAI/ext/CSR_common.pxi b/src/pyFAI/ext/CSR_common.pxi index e152bf43a..c8201f1f7 100644 --- a/src/pyFAI/ext/CSR_common.pxi +++ b/src/pyFAI/ext/CSR_common.pxi @@ -861,7 +861,7 @@ cdef class CsrIntegrator(object): element = work[i] if ((element.s3!=0) and (((qmin<=former_element.s0) and (element.s0 <= qmax)) or - ((qmin>=former_element.s0) and (element.s0 >= qmax))): #specific case where qmin==qmax + ((qmin>=former_element.s0) and (element.s0 >= qmax)))): #specific case where qmin==qmax acc_sig = acc_sig + element.s1 acc_var = acc_var + element.s2 acc_norm = acc_norm + element.s3 From b225d11acc8ca816cc949ad0320f8115cb141f05 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C3=A9r=C3=B4me=20Kieffer?= Date: Sun, 8 Dec 2024 17:28:56 +0100 Subject: [PATCH 22/23] some documentation on medfilt --- .../usage/tutorial/AzimuthalFilter.ipynb | 810 ++++++++++++++++++ doc/source/usage/tutorial/index.rst | 1 + src/pyFAI/detectors/_others.py | 2 +- 3 files changed, 812 insertions(+), 1 deletion(-) create mode 100644 doc/source/usage/tutorial/AzimuthalFilter.ipynb diff --git a/doc/source/usage/tutorial/AzimuthalFilter.ipynb b/doc/source/usage/tutorial/AzimuthalFilter.ipynb new file mode 100644 index 000000000..e4c4eb156 --- /dev/null +++ b/doc/source/usage/tutorial/AzimuthalFilter.ipynb @@ -0,0 +1,810 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "abc04a99-5bd9-4c99-bcba-9a124bed6bb7", + "metadata": {}, + "source": [ + "# Filtering signal in azimuthal space\n", + "\n", + "Usually, diffraction signal presents a polar symmetry, this means all pixel with the same azimuthal angle (χ) have similar intensities. The best way to exploit this is to take the mean, what is called *azimuthal average*. But the average is very sensitive to outlier, like gaps, missing pixels, shadows, cosmic rays or reflection coming from larger crystallite. In this tutorial we will see two alternative ways to remove those unwanted signal and focus on the majority of pixels: **sigma clipping** and **median filtering**." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "e669b71d-8dc6-4eab-b505-0792255c1eb1", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "os.environ[\"PYOPENCL_CTX\"] = \"0:1\"" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "7235a6ba-2b59-4156-84b9-86826c48e741", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:pyFAI.gui.matplotlib:matplotlib already loaded, setting its backend may not work\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a9b5301f046a4cc09a91336578c05c96", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from matplotlib.pyplot import subplots\n", + "%matplotlib inline\n", + "from pyFAI.gui import jupyter\n", + "import numpy, fabio, pyFAI\n", + "from pyFAI import benchmark\n", + "from pyFAI.test.utilstest import UtilsTest\n", + "\n", + "ai = pyFAI.load(UtilsTest.getimage(\"Pilatus6M.poni\"))\n", + "img = fabio.open(UtilsTest.getimage(\"Pilatus6M.cbf\")).data\n", + "fig, ax = subplots(1, 2)\n", + "jupyter.display(img, ax=ax[1])\n", + "jupyter.plot1d(ai.integrate1d(img, 1000), ax=ax[0])\n", + "ax[1].set_title(\"With a few Bragg peaks\")\n", + "pass" + ] + }, + { + "cell_type": "markdown", + "id": "55fac493-e871-44b9-a8c7-b4014024182e", + "metadata": {}, + "source": [ + "## Azimuthal sigma-clipping\n", + "\n", + "The idea is to discard pixels which look like outliers in the distribution of all pixels contributing to a single azimuthal bin.\n", + "It requires an error model like *poisson* but it has been proven to be better to use the variance in the given azimuthal ring.\n", + "All details are available in this publication: https://doi.org/10.1107/S1600576724011038 also available at https://doi.org/10.48550/arXiv.2411.09515 " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "c2fe4732-a6d1-4919-97f3-7d27193e666e", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "62fcf9a0922c4ecda33d7d12232c4bb2", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = subplots(1, 2)\n", + "jupyter.display(img, ax=ax[1])\n", + "jupyter.plot1d(ai.sigma_clip(img, 1000, error_model=\"hybrid\", method=(\"no\", \"csr\", \"cython\")), ax=ax[0])\n", + "ax[1].set_title(\"With a few Bragg peaks\")\n", + "ax[0].set_title(\"Sigma_clipping\")\n", + "pass" + ] + }, + { + "cell_type": "markdown", + "id": "6a57a43a-85f0-4258-b4bc-76ad72d1b4e1", + "metadata": {}, + "source": [ + "Of course, *sigma-clip* takes several extra parameters like the number of iterations to perform, the cut-off, the error model, ... \n", + "There are alo a few limitation: \n", + "* The algorithm needs to be the CSR-sparse matrix multiplication: since several integration are needed, it makes no sense to use an histogram based algorithm.\n", + "* The algorithm is available with any implementation: Python (using scipy.saprse), Cython and OpenCL, and it runs just fine on GPU.\n", + "* Sigma-clipping is incompatible with any kind of pixel splitting: With pixel splitting, a single pixel can contribute to several azimuthal bins and discarding a pixel in one ring could disable it in the neighboring ring (or not, since bins are processed in parallel).\n", + "\n", + "### Sigma-clipping performances:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "480b7770-8292-4e39-ba35-6cfbf2150f38", + "metadata": {}, + "outputs": [], + "source": [ + "method = [\"no\", \"csr\", \"cython\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "9da36255-dbc4-4206-b725-d233e4261265", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pilatus1M.poni\n", + " cython\n", + "9.9 ms ± 731 μs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", + "11.3 ms ± 945 μs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", + " python\n", + "10.8 ms ± 49.7 μs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:pyFAI.opencl.azim_csr:Please upgrade to silx v2.2+\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "179 ms ± 663 μs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", + " python\n", + "2.01 ms ± 167 μs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "4.91 ms ± 4.47 μs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", + "Pilatus2M.poni\n", + " cython\n", + "16.8 ms ± 94.7 μs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", + "23.9 ms ± 803 μs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", + " python\n", + "27.8 ms ± 136 μs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:pyFAI.opencl.azim_csr:Please upgrade to silx v2.2+\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "539 ms ± 2.95 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + " python\n", + "4.66 ms ± 52.6 μs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "18.5 ms ± 25.8 μs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", + "Eiger4M.poni\n", + " cython\n", + "26.6 ms ± 184 μs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "43.4 ms ± 808 μs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", + " python\n", + "54.1 ms ± 206 μs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:pyFAI.opencl.azim_csr:Please upgrade to silx v2.2+\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.1 s ± 1.74 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + " python\n", + "8.39 ms ± 22.6 μs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "34.8 ms ± 172 μs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", + "Pilatus6M.poni\n", + " cython\n", + "36.3 ms ± 178 μs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "50.7 ms ± 698 μs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", + " python\n", + "80.3 ms ± 206 μs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:pyFAI.opencl.azim_csr:Please upgrade to silx v2.2+\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.57 s ± 5.99 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + " python\n", + "11.5 ms ± 52 μs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "39.3 ms ± 66.6 μs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", + "Eiger9M.poni\n", + " cython\n", + "74.7 ms ± 10.4 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "120 ms ± 2.78 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", + " python\n", + "166 ms ± 2.1 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:pyFAI.opencl.azim_csr:Please upgrade to silx v2.2+\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.26 s ± 29 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + " python\n", + "18.6 ms ± 51.9 μs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "102 ms ± 195 μs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", + "Mar3450.poni\n", + " cython\n", + "69.3 ms ± 1.51 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "114 ms ± 986 μs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", + " python\n", + "176 ms ± 738 μs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:pyFAI.opencl.azim_csr:Please upgrade to silx v2.2+\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.48 s ± 31.1 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + " python\n", + "20.8 ms ± 265 μs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:silx.utils.ExternalResources:Detected corruped file /tmp/pyFAI_testdata_jerome/Fairchild.poni\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "102 ms ± 1.03 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", + "Fairchild.poni\n", + " cython\n" + ] + }, + { + "ename": "RuntimeError", + "evalue": "Scattering vector q cannot be calculated without knowing wavelength !!!", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mRuntimeError\u001b[0m Traceback (most recent call last)", + "File \u001b[0;32m:16\u001b[0m\n", + "File \u001b[0;32m~/.venv/py311/lib/python3.11/site-packages/IPython/core/interactiveshell.py:2480\u001b[0m, in \u001b[0;36mInteractiveShell.run_line_magic\u001b[0;34m(self, magic_name, line, _stack_depth)\u001b[0m\n\u001b[1;32m 2478\u001b[0m kwargs[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mlocal_ns\u001b[39m\u001b[38;5;124m'\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mget_local_scope(stack_depth)\n\u001b[1;32m 2479\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mbuiltin_trap:\n\u001b[0;32m-> 2480\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 2482\u001b[0m \u001b[38;5;66;03m# The code below prevents the output from being displayed\u001b[39;00m\n\u001b[1;32m 2483\u001b[0m \u001b[38;5;66;03m# when using magics with decorator @output_can_be_silenced\u001b[39;00m\n\u001b[1;32m 2484\u001b[0m \u001b[38;5;66;03m# when the last Python token in the expression is a ';'.\u001b[39;00m\n\u001b[1;32m 2485\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mgetattr\u001b[39m(fn, magic\u001b[38;5;241m.\u001b[39mMAGIC_OUTPUT_CAN_BE_SILENCED, \u001b[38;5;28;01mFalse\u001b[39;00m):\n", + "File \u001b[0;32m~/.venv/py311/lib/python3.11/site-packages/IPython/core/magics/execution.py:1185\u001b[0m, in \u001b[0;36mExecutionMagics.timeit\u001b[0;34m(self, line, cell, local_ns)\u001b[0m\n\u001b[1;32m 1183\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m index \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m10\u001b[39m):\n\u001b[1;32m 1184\u001b[0m number \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m10\u001b[39m \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39m index\n\u001b[0;32m-> 1185\u001b[0m time_number \u001b[38;5;241m=\u001b[39m \u001b[43mtimer\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtimeit\u001b[49m\u001b[43m(\u001b[49m\u001b[43mnumber\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1186\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m time_number \u001b[38;5;241m>\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;241m0.2\u001b[39m:\n\u001b[1;32m 1187\u001b[0m \u001b[38;5;28;01mbreak\u001b[39;00m\n", + "File \u001b[0;32m~/.venv/py311/lib/python3.11/site-packages/IPython/core/magics/execution.py:173\u001b[0m, in \u001b[0;36mTimer.timeit\u001b[0;34m(self, number)\u001b[0m\n\u001b[1;32m 171\u001b[0m gc\u001b[38;5;241m.\u001b[39mdisable()\n\u001b[1;32m 172\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 173\u001b[0m timing \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43minner\u001b[49m\u001b[43m(\u001b[49m\u001b[43mit\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtimer\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 174\u001b[0m \u001b[38;5;28;01mfinally\u001b[39;00m:\n\u001b[1;32m 175\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m gcold:\n", + "File \u001b[0;32m:1\u001b[0m, in \u001b[0;36minner\u001b[0;34m(_it, _timer)\u001b[0m\n", + "File \u001b[0;32m~/.venv/py311/lib/python3.11/site-packages/pyFAI/integrator/azimuthal.py:235\u001b[0m, in \u001b[0;36mAzimuthalIntegrator.integrate1d\u001b[0;34m(self, data, npt, filename, correctSolidAngle, variance, error_model, radial_range, azimuth_range, mask, dummy, delta_dummy, polarization_factor, dark, flat, absorption, method, unit, safe, normalization_factor, metadata)\u001b[0m\n\u001b[1;32m 233\u001b[0m split \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mfull\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 234\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 235\u001b[0m cython_integr \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msetup_sparse_integrator\u001b[49m\u001b[43m(\u001b[49m\u001b[43mshape\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnpt\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmask\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 236\u001b[0m \u001b[43m \u001b[49m\u001b[43mradial_range\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mazimuth_range\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 237\u001b[0m \u001b[43m \u001b[49m\u001b[43mmask_checksum\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmask_crc\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 238\u001b[0m \u001b[43m \u001b[49m\u001b[43munit\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43munit\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msplit\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msplit\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43malgo\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmethod\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43malgo_lower\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 239\u001b[0m \u001b[43m \u001b[49m\u001b[43mempty\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mempty\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mscale\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[1;32m 240\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mMemoryError\u001b[39;00m: \u001b[38;5;66;03m# sparse methods are hungry...\u001b[39;00m\n\u001b[1;32m 241\u001b[0m logger\u001b[38;5;241m.\u001b[39mwarning(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mMemoryError: falling back on forward implementation\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n", + "File \u001b[0;32m~/.venv/py311/lib/python3.11/site-packages/pyFAI/integrator/common.py:377\u001b[0m, in \u001b[0;36mIntegrator.setup_sparse_integrator\u001b[0;34m(self, shape, npt, mask, pos0_range, pos1_range, mask_checksum, unit, split, algo, empty, scale)\u001b[0m\n\u001b[1;32m 375\u001b[0m pos \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39marray_from_unit(shape, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcorner\u001b[39m\u001b[38;5;124m\"\u001b[39m, unit, scale\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m)\n\u001b[1;32m 376\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 377\u001b[0m pos0 \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43marray_from_unit\u001b[49m\u001b[43m(\u001b[49m\u001b[43mshape\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mcenter\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43munit0\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mscale\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[1;32m 378\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m split \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mno\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n\u001b[1;32m 379\u001b[0m dpos0 \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n", + "File \u001b[0;32m~/.venv/py311/lib/python3.11/site-packages/pyFAI/geometry/core.py:1092\u001b[0m, in \u001b[0;36mGeometry.array_from_unit\u001b[0;34m(self, shape, typ, unit, scale)\u001b[0m\n\u001b[1;32m 1089\u001b[0m meth_name \u001b[38;5;241m=\u001b[39m unit\u001b[38;5;241m.\u001b[39mget(typ)\n\u001b[1;32m 1090\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m meth_name \u001b[38;5;129;01mand\u001b[39;00m meth_name \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mdir\u001b[39m(Geometry):\n\u001b[1;32m 1091\u001b[0m \u001b[38;5;66;03m# fast path may be available\u001b[39;00m\n\u001b[0;32m-> 1092\u001b[0m out \u001b[38;5;241m=\u001b[39m \u001b[43mGeometry\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[38;5;18;43m__dict__\u001b[39;49m\u001b[43m[\u001b[49m\u001b[43mmeth_name\u001b[49m\u001b[43m]\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mshape\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1093\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m scale \u001b[38;5;129;01mand\u001b[39;00m unit:\n\u001b[1;32m 1094\u001b[0m out \u001b[38;5;241m=\u001b[39m out \u001b[38;5;241m*\u001b[39m unit\u001b[38;5;241m.\u001b[39mscale\n", + "File \u001b[0;32m~/.venv/py311/lib/python3.11/site-packages/pyFAI/geometry/core.py:524\u001b[0m, in \u001b[0;36mGeometry.qArray\u001b[0;34m(self, shape)\u001b[0m\n\u001b[1;32m 522\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_sem:\n\u001b[1;32m 523\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_cached_array\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mq_center\u001b[39m\u001b[38;5;124m\"\u001b[39m) \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 524\u001b[0m qa \u001b[38;5;241m=\u001b[39m \u001b[43mnumpy\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfromfunction\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mqFunction\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mshape\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 525\u001b[0m \u001b[43m \u001b[49m\u001b[43mdtype\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mnumpy\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfloat32\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 526\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_cached_array[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mq_center\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m qa\n\u001b[1;32m 528\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_cached_array[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mq_center\u001b[39m\u001b[38;5;124m\"\u001b[39m]\n", + "File \u001b[0;32m~/.venv/py311/lib/python3.11/site-packages/numpy/_core/numeric.py:1927\u001b[0m, in \u001b[0;36mfromfunction\u001b[0;34m(function, shape, dtype, like, **kwargs)\u001b[0m\n\u001b[1;32m 1923\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m _fromfunction_with_like(\n\u001b[1;32m 1924\u001b[0m like, function, shape, dtype\u001b[38;5;241m=\u001b[39mdtype, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m 1926\u001b[0m args \u001b[38;5;241m=\u001b[39m indices(shape, dtype\u001b[38;5;241m=\u001b[39mdtype)\n\u001b[0;32m-> 1927\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunction\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/.venv/py311/lib/python3.11/site-packages/pyFAI/geometry/core.py:449\u001b[0m, in \u001b[0;36mGeometry.qFunction\u001b[0;34m(self, d1, d2, param, path)\u001b[0m\n\u001b[1;32m 435\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 436\u001b[0m \u001b[38;5;124;03mCalculates the q value for the center of a given pixel (or set\u001b[39;00m\n\u001b[1;32m 437\u001b[0m \u001b[38;5;124;03mof pixels) in nm-1\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 446\u001b[0m \u001b[38;5;124;03m:rtype: float or array of floats.\u001b[39;00m\n\u001b[1;32m 447\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 448\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mwavelength:\n\u001b[0;32m--> 449\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mRuntimeError\u001b[39;00m((\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mScattering vector q cannot be calculated\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 450\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m without knowing wavelength !!!\u001b[39m\u001b[38;5;124m\"\u001b[39m))\n\u001b[1;32m 452\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m (_geometry \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m) \u001b[38;5;129;01mand\u001b[39;00m (path \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcython\u001b[39m\u001b[38;5;124m\"\u001b[39m):\n\u001b[1;32m 453\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m param \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n", + "\u001b[0;31mRuntimeError\u001b[0m: Scattering vector q cannot be calculated without knowing wavelength !!!" + ] + } + ], + "source": [ + "%%time \n", + "perfs_integrate_python = {}\n", + "perfs_integrate_cython = {}\n", + "perfs_integrate_opencl = {}\n", + "perfs_sigma_clip_python = {}\n", + "perfs_sigma_clip_cython = {}\n", + "perfs_sigma_clip_opencl = {}\n", + "\n", + "for ds in pyFAI.benchmark.PONIS:\n", + " ai = pyFAI.load(UtilsTest.getimage(ds))\n", + " if ai.wavelength is None: ai.wavelength=1.54e-10\n", + " img = fabio.open(UtilsTest.getimage(pyFAI.benchmark.datasets[ds])).data\n", + " size = numpy.prod(ai.detector.shape)\n", + " print(ds)\n", + " print(\" Cython\")\n", + " meth = tuple(method)\n", + " nbin = max(ai.detector.shape)\n", + " perfs_integrate_cython[size] = %timeit -o ai.integrate1d(img, nbin, method=meth)\n", + " perfs_sigma_clip_cython[size] = %timeit -o ai.sigma_clip(img, nbin, method=meth, error_model=\"azimuthal\")\n", + " print(\" Python\")\n", + " meth = tuple(method[:2]+[\"python\"])\n", + " perfs_integrate_python[size] = %timeit -o ai.integrate1d(img, nbin, method=meth)\n", + " perfs_sigma_clip_python[size] = %timeit -o ai.sigma_clip(img, nbin, method=meth, error_model=\"azimuthal\")\n", + "\n", + " print(\" OpenCL\")\n", + " meth = tuple(method[:2]+[\"opencl\"])\n", + " perfs_integrate_opencl[size] = %timeit -o ai.integrate1d(img, nbin, method=meth)\n", + " perfs_sigma_clip_opencl[size] = %timeit -o ai.sigma_clip(img, nbin, method=meth, error_model=\"azimuthal\")" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "48c02ebf-e7fa-4f49-a5db-2892f11e21e7", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Performance of Sigma-clipping vs integrate')" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f08158c458ba4075817283cf8ef32fd0", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = subplots()\n", + "ax.set_xlabel(\"Image size (Mpix)\")\n", + "ax.set_ylabel(\"Frames per seconds\")\n", + "sizes = numpy.array(list(perfs_integrate_python.keys()))/1e6\n", + "ax.plot(sizes, [1/i.best for i in perfs_integrate_python.values()], label=\"Integrate/Python\", color='green', linestyle='dashed', marker='1')\n", + "ax.plot(sizes, [1/i.best for i in perfs_integrate_cython.values()], label=\"Integrate/Cython\", color='orange', linestyle='dashed', marker='1')\n", + "ax.plot(sizes, [1/i.best for i in perfs_integrate_opencl.values()], label=\"Integrate/OpenCL\", color='blue', linestyle='dashed', marker='1')\n", + "ax.plot(sizes, [1/i.best for i in perfs_sigma_clip_python.values()], label=\"Sigma-clip/Python\", color='green', linestyle='dotted', marker='2')\n", + "ax.plot(sizes, [1/i.best for i in perfs_sigma_clip_cython.values()], label=\"Sigma-clip/Cython\", color='orange', linestyle='dotted', marker='2')\n", + "ax.plot(sizes, [1/i.best for i in perfs_sigma_clip_opencl.values()], label=\"Sigma-clip/OpenCL\", color='blue', linestyle='dotted', marker='2')\n", + "ax.set_yscale(\"log\")\n", + "ax.legend()\n", + "ax.set_title(\"Performance of Sigma-clipping vs integrate\")" + ] + }, + { + "cell_type": "markdown", + "id": "147e1d95-d808-4735-a74e-a1b19b79f7ef", + "metadata": {}, + "source": [ + "The biggest limitation of sigma-clipping is its incompatibility with pixel-splitting, feature needed when oversampling, i.e. taking many more points than the size of the diagonal of the image.\n", + "While oversampling is not recommended in general case (due to the cross-corelation between bins it creates), it can be a nessessary evil, especially when performing Rietveld refinement where 5 points per peaks are needed, resolution that cannot be obtained with the pixel-size/distance couple accessible by th experimental setup.\n", + "\n", + "## Median filter in Azimuthal space\n", + "\n", + "The idea is to sort all pixels contibuting to an azimuthal bin and to average out all pixel between the lower and upper quantile. \n", + "When those two thresholds are at one half, this filter provides actually the median.\n", + "In order to compatible with pixel splitting, each pixel is duplicated as many times as it contributes to different bins.\n", + "After sorting pixels according to their normalization corrected signal, the cummulative sum of normalization is performed in order to detemine which pixel to average out.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "b1a35b63-e77a-47c1-a5a1-09d06f44ec62", + "metadata": {}, + "outputs": [], + "source": [ + "ai = pyFAI.load(UtilsTest.getimage(\"Pilatus6M.poni\"))\n", + "img = fabio.open(UtilsTest.getimage(\"Pilatus6M.cbf\")).data\n", + "\n", + "method = [\"full\", \"csr\", \"cython\"]\n", + "percentile=(40,60)\n", + "pol=0.99" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "f160d7dd-c19d-4df1-890e-a7d94db55a16", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "7bbbf073bc9340d8a01a011424fe9090", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = subplots(1, 2)\n", + "jupyter.display(img, ax=ax[1])\n", + "jupyter.plot1d(ai.medfilt1d_ng(img, 1000, method=method, percentile=percentile, polarization_factor=pol), ax=ax[0])\n", + "ax[1].set_title(\"With a few Bragg peaks\")\n", + "ax[0].set_title(\"Median filtering\")\n", + "pass" + ] + }, + { + "cell_type": "markdown", + "id": "d7882217-35de-4f5e-9b87-efc5c87eb2cf", + "metadata": {}, + "source": [ + "Unlike the *sigma-clipping*, this median filter does not equires any error model; but the computationnal cost induced by the sort is huge. In addition, the median is very sensitive and requires a good geometry and modelisation of the polarization." + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "af56d591-e634-4bb8-a4a3-0828e745205a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pilatus1M.poni\n", + " Cython\n", + "11.4 ms ± 6.09 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "27.4 ms ± 2.59 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", + " Python\n", + "13.5 ms ± 49.9 μs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:pyFAI.opencl.azim_csr:Please upgrade to silx v2.2+\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.04 s ± 10.2 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + " OpenCL\n", + "2.15 ms ± 6.52 μs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", + "93.6 ms ± 299 μs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", + "Pilatus2M.poni\n", + " Cython\n", + "18.8 ms ± 855 μs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "92.8 ms ± 677 μs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", + " Python\n", + "40 ms ± 1.58 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:pyFAI.opencl.azim_csr:Please upgrade to silx v2.2+\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.55 s ± 16.3 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + " OpenCL\n", + "5.44 ms ± 4.75 μs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", + "385 ms ± 14.3 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "Eiger4M.poni\n", + " Cython\n", + "29.8 ms ± 456 μs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "154 ms ± 3.29 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", + " Python\n", + "80.6 ms ± 420 μs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:pyFAI.opencl.azim_csr:Please upgrade to silx v2.2+\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "6.17 s ± 12 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + " OpenCL\n", + "9.71 ms ± 12.1 μs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", + "732 ms ± 23.2 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "Pilatus6M.poni\n", + " Cython\n", + "43.7 ms ± 3.42 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "219 ms ± 5.86 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + " Python\n", + "130 ms ± 2.22 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:pyFAI.opencl.azim_csr:Please upgrade to silx v2.2+\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "9.23 s ± 132 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + " OpenCL\n", + "13.2 ms ± 59.2 μs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", + "1.06 s ± 15.5 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "Eiger9M.poni\n", + " Cython\n", + "67.7 ms ± 756 μs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "370 ms ± 3.54 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + " Python\n", + "216 ms ± 3.26 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:pyFAI.opencl.azim_csr:Please upgrade to silx v2.2+\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "15.1 s ± 97.2 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + " OpenCL\n", + "21.9 ms ± 596 μs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "2 s ± 13 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "Mar3450.poni\n", + " Cython\n", + "73 ms ± 781 μs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "393 ms ± 10.2 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + " Python\n", + "256 ms ± 1.65 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:pyFAI.opencl.azim_csr:Please upgrade to silx v2.2+\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "17.3 s ± 71.8 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + " OpenCL\n", + "24.6 ms ± 44.3 μs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "2.35 s ± 16.3 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "Fairchild.poni\n", + " Cython\n", + "96.6 ms ± 793 μs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "417 ms ± 932 μs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + " Python\n", + "380 ms ± 1.64 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:pyFAI.opencl.azim_csr:Please upgrade to silx v2.2+\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "20.7 s ± 88.3 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + " OpenCL\n", + "30.2 ms ± 1.18 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "2.6 s ± 50.3 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "CPU times: user 16min 23s, sys: 15.3 s, total: 16min 38s\n", + "Wall time: 13min 5s\n" + ] + } + ], + "source": [ + "%%time \n", + "perf2_integrate_python = {}\n", + "perf2_integrate_cython = {}\n", + "perf2_integrate_opencl = {}\n", + "perf2_medfilt_python = {}\n", + "perf2_medfilt_cython = {}\n", + "perf2_medfilt_opencl = {}\n", + "\n", + "for ds in pyFAI.benchmark.PONIS:\n", + " ai = pyFAI.load(UtilsTest.getimage(ds))\n", + " if ai.wavelength is None: ai.wavelength=1.54e-10\n", + " img = fabio.open(UtilsTest.getimage(pyFAI.benchmark.datasets[ds])).data\n", + " size = numpy.prod(ai.detector.shape)\n", + " print(ds)\n", + " print(\" Cython\")\n", + " meth = tuple(method)\n", + " nbin = max(ai.detector.shape)\n", + " perf2_integrate_cython[size] = %timeit -o ai.integrate1d(img, nbin, method=meth)\n", + " perf2_medfilt_cython[size] = %timeit -o ai.medfilt1d_ng(img, nbin, method=meth)\n", + " print(\" Python\")\n", + " meth = tuple(method[:2]+[\"python\"])\n", + " perf2_integrate_python[size] = %timeit -o ai.integrate1d(img, nbin, method=meth)\n", + " perf2_medfilt_python[size] = %timeit -o ai.medfilt1d_ng(img, nbin, method=meth)\n", + "\n", + " print(\" OpenCL\")\n", + " meth = tuple(method[:2]+[\"opencl\"])\n", + " perf2_integrate_opencl[size] = %timeit -o ai.integrate1d(img, nbin, method=meth)\n", + " perf2_medfilt_opencl[size] = %timeit -o ai.medfilt1d_ng(img, nbin, method=meth)" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "a8caf1c6-630e-4056-a01a-1e1707437c2d", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ae718543801543a69761a0b7e1775c3f", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = subplots()\n", + "ax.set_xlabel(\"Image size (Mpix)\")\n", + "ax.set_ylabel(\"Frames per seconds\")\n", + "sizes = numpy.array(list(perf2_integrate_python.keys()))/1e6\n", + "ax.plot(sizes, [1/i.best for i in perf2_integrate_python.values()], label=\"Integrate/Python\", color='green', linestyle='dashed', marker='1')\n", + "ax.plot(sizes, [1/i.best for i in perf2_integrate_cython.values()], label=\"Integrate/Cython\", color='orange', linestyle='dashed', marker='1')\n", + "ax.plot(sizes, [1/i.best for i in perf2_integrate_opencl.values()], label=\"Integrate/OpenCL\", color='blue', linestyle='dashed', marker='1')\n", + "ax.plot(sizes, [1/i.best for i in perf2_medfilt_python.values()], label=\"Medfilt/Python\", color='green', linestyle='dotted', marker='2')\n", + "ax.plot(sizes, [1/i.best for i in perf2_medfilt_cython.values()], label=\"Medfilt/Cython\", color='orange', linestyle='dotted', marker='2')\n", + "ax.plot(sizes, [1/i.best for i in perf2_medfilt_opencl.values()], label=\"Medfilt/OpenCL\", color='blue', linestyle='dotted', marker='2')\n", + "ax.set_yscale(\"log\")\n", + "ax.legend()\n", + "ax.set_title(\"Performance of Median filtering vs integrate\")\n", + "pass" + ] + }, + { + "cell_type": "markdown", + "id": "00b7c06d-8f92-4cd4-b259-2ff6914eff4b", + "metadata": {}, + "source": [ + "As one can see, the penalities are much larger for OpenCL than for Cython.\n", + "\n", + "## Conclusion\n", + "*Sigma-clipping* and *median-filtering* are alternatives to azimuthal integration and offer the ability to reject outlier. They are mot more difficult to use but slightly slower owing to their greater complexity." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "40609090-3f85-40e1-8d4e-30d42ecd6878", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/doc/source/usage/tutorial/index.rst b/doc/source/usage/tutorial/index.rst index 3b2a0bcb0..faff44b89 100644 --- a/doc/source/usage/tutorial/index.rst +++ b/doc/source/usage/tutorial/index.rst @@ -27,6 +27,7 @@ a good Python fluency and to a certain extent, of the pyFAI library. Flatfield Ellipse/ellipse PixelSplitting + AzimuthalFilter Variance/uncertainties LogScale/Guinier multi-geometry diff --git a/src/pyFAI/detectors/_others.py b/src/pyFAI/detectors/_others.py index 1506b8d93..f978f8785 100644 --- a/src/pyFAI/detectors/_others.py +++ b/src/pyFAI/detectors/_others.py @@ -58,7 +58,7 @@ def __init__(self, pixel1=15e-6, pixel2=15e-6, max_shape=None, orientation=0): Detector.__init__(self, pixel1=pixel1, pixel2=pixel2, max_shape=max_shape, orientation=orientation) def __repr__(self): - return f"Detector {self.name}%s\t PixelSize= {to_eng(self._pixel1)}m, {to_eng(self._pixel2)}m" + return f"Detector {self.name}\t PixelSize= {to_eng(self._pixel1)}m, {to_eng(self._pixel2)}m" def get_config(self): """Return the configuration with arguments to the constructor From ce279ea603d44a590211a1f4f7413b61aa778d86 Mon Sep 17 00:00:00 2001 From: Jerome Kieffer Date: Sun, 8 Dec 2024 21:05:57 +0100 Subject: [PATCH 23/23] re-run the benchmark on 32-CPU core, A5000 GPU --- .../usage/tutorial/AzimuthalFilter.ipynb | 367 +++++++----------- 1 file changed, 137 insertions(+), 230 deletions(-) diff --git a/doc/source/usage/tutorial/AzimuthalFilter.ipynb b/doc/source/usage/tutorial/AzimuthalFilter.ipynb index e4c4eb156..03c567b21 100644 --- a/doc/source/usage/tutorial/AzimuthalFilter.ipynb +++ b/doc/source/usage/tutorial/AzimuthalFilter.ipynb @@ -10,17 +10,6 @@ "Usually, diffraction signal presents a polar symmetry, this means all pixel with the same azimuthal angle (χ) have similar intensities. The best way to exploit this is to take the mean, what is called *azimuthal average*. But the average is very sensitive to outlier, like gaps, missing pixels, shadows, cosmic rays or reflection coming from larger crystallite. In this tutorial we will see two alternative ways to remove those unwanted signal and focus on the majority of pixels: **sigma clipping** and **median filtering**." ] }, - { - "cell_type": "code", - "execution_count": 7, - "id": "e669b71d-8dc6-4eab-b505-0792255c1eb1", - "metadata": {}, - "outputs": [], - "source": [ - "import os\n", - "os.environ[\"PYOPENCL_CTX\"] = \"0:1\"" - ] - }, { "cell_type": "code", "execution_count": 1, @@ -36,24 +25,9 @@ }, { "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "a9b5301f046a4cc09a91336578c05c96", - "version_major": 2, - "version_minor": 0 - }, - "image/png": "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", - "text/html": [ - "\n", - "
\n", - "
\n", - " Figure\n", - "
\n", - " \n", - "
\n", - " " - ], + "image/png": "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", "text/plain": [ - "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + "
" ] }, "metadata": {}, @@ -97,24 +71,9 @@ "outputs": [ { "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "62fcf9a0922c4ecda33d7d12232c4bb2", - "version_major": 2, - "version_minor": 0 - }, - "image/png": "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", - "text/html": [ - "\n", - "
\n", - "
\n", - " Figure\n", - "
\n", - " \n", - "
\n", - " " - ], + "image/png": "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", "text/plain": [ - "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + "
" ] }, "metadata": {}, @@ -156,7 +115,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 4, "id": "9da36255-dbc4-4206-b725-d233e4261265", "metadata": {}, "outputs": [ @@ -165,11 +124,11 @@ "output_type": "stream", "text": [ "Pilatus1M.poni\n", - " cython\n", - "9.9 ms ± 731 μs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", - "11.3 ms ± 945 μs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", - " python\n", - "10.8 ms ± 49.7 μs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n" + " Cython\n", + "6.77 ms ± 97.3 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", + "7.19 ms ± 53.2 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", + " Python\n", + "10.2 ms ± 25.6 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n" ] }, { @@ -183,16 +142,16 @@ "name": "stdout", "output_type": "stream", "text": [ - "179 ms ± 663 μs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", - " python\n", - "2.01 ms ± 167 μs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "4.91 ms ± 4.47 μs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", + "153 ms ± 243 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", + " OpenCL\n", + "865 µs ± 40.9 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "2.6 ms ± 3.76 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", "Pilatus2M.poni\n", - " cython\n", - "16.8 ms ± 94.7 μs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", - "23.9 ms ± 803 μs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", - " python\n", - "27.8 ms ± 136 μs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n" + " Cython\n", + "13.6 ms ± 124 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", + "15.3 ms ± 160 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", + " Python\n", + "33.9 ms ± 60.5 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n" ] }, { @@ -206,16 +165,16 @@ "name": "stdout", "output_type": "stream", "text": [ - "539 ms ± 2.95 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - " python\n", - "4.66 ms ± 52.6 μs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "18.5 ms ± 25.8 μs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", + "520 ms ± 779 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + " OpenCL\n", + "1.22 ms ± 69.7 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "6.01 ms ± 6.42 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", "Eiger4M.poni\n", - " cython\n", - "26.6 ms ± 184 μs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "43.4 ms ± 808 μs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", - " python\n", - "54.1 ms ± 206 μs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n" + " Cython\n", + "21.2 ms ± 154 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "29.1 ms ± 381 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", + " Python\n", + "61.3 ms ± 240 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n" ] }, { @@ -229,16 +188,16 @@ "name": "stdout", "output_type": "stream", "text": [ - "1.1 s ± 1.74 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - " python\n", - "8.39 ms ± 22.6 μs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "34.8 ms ± 172 μs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", + "1.08 s ± 1.91 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + " OpenCL\n", + "2.02 ms ± 34.7 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "10.5 ms ± 28 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", "Pilatus6M.poni\n", - " cython\n", - "36.3 ms ± 178 μs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "50.7 ms ± 698 μs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", - " python\n", - "80.3 ms ± 206 μs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n" + " Cython\n", + "29.9 ms ± 542 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "33.3 ms ± 373 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", + " Python\n", + "84.7 ms ± 436 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n" ] }, { @@ -252,16 +211,16 @@ "name": "stdout", "output_type": "stream", "text": [ - "1.57 s ± 5.99 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - " python\n", - "11.5 ms ± 52 μs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "39.3 ms ± 66.6 μs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", + "1.51 s ± 1.11 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + " OpenCL\n", + "2.66 ms ± 19.2 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "13.4 ms ± 36 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", "Eiger9M.poni\n", - " cython\n", - "74.7 ms ± 10.4 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "120 ms ± 2.78 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", - " python\n", - "166 ms ± 2.1 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n" + " Cython\n", + "52.8 ms ± 560 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "67.2 ms ± 287 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", + " Python\n", + "152 ms ± 386 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n" ] }, { @@ -275,16 +234,16 @@ "name": "stdout", "output_type": "stream", "text": [ - "3.26 s ± 29 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - " python\n", - "18.6 ms ± 51.9 μs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "102 ms ± 195 μs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", + "2.82 s ± 3.49 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + " OpenCL\n", + "3.97 ms ± 13.9 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "25 ms ± 21.4 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", "Mar3450.poni\n", - " cython\n", - "69.3 ms ± 1.51 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "114 ms ± 986 μs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", - " python\n", - "176 ms ± 738 μs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n" + " Cython\n", + "58 ms ± 1.09 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "69.3 ms ± 205 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", + " Python\n", + "168 ms ± 478 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n" ] }, { @@ -298,46 +257,36 @@ "name": "stdout", "output_type": "stream", "text": [ - "3.48 s ± 31.1 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - " python\n", - "20.8 ms ± 265 μs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" + "3.1 s ± 2.21 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + " OpenCL\n", + "4.47 ms ± 30.8 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "27.5 ms ± 28.8 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", + "Fairchild.poni\n", + " Cython\n", + "87.5 ms ± 793 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "113 ms ± 585 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", + "Compiler time: 0.25 s\n", + " Python\n", + "385 ms ± 1.2 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "WARNING:silx.utils.ExternalResources:Detected corruped file /tmp/pyFAI_testdata_jerome/Fairchild.poni\n" + "WARNING:pyFAI.opencl.azim_csr:Please upgrade to silx v2.2+\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "102 ms ± 1.03 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", - "Fairchild.poni\n", - " cython\n" - ] - }, - { - "ename": "RuntimeError", - "evalue": "Scattering vector q cannot be calculated without knowing wavelength !!!", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mRuntimeError\u001b[0m Traceback (most recent call last)", - "File \u001b[0;32m:16\u001b[0m\n", - "File \u001b[0;32m~/.venv/py311/lib/python3.11/site-packages/IPython/core/interactiveshell.py:2480\u001b[0m, in \u001b[0;36mInteractiveShell.run_line_magic\u001b[0;34m(self, magic_name, line, _stack_depth)\u001b[0m\n\u001b[1;32m 2478\u001b[0m kwargs[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mlocal_ns\u001b[39m\u001b[38;5;124m'\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mget_local_scope(stack_depth)\n\u001b[1;32m 2479\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mbuiltin_trap:\n\u001b[0;32m-> 2480\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 2482\u001b[0m \u001b[38;5;66;03m# The code below prevents the output from being displayed\u001b[39;00m\n\u001b[1;32m 2483\u001b[0m \u001b[38;5;66;03m# when using magics with decorator @output_can_be_silenced\u001b[39;00m\n\u001b[1;32m 2484\u001b[0m \u001b[38;5;66;03m# when the last Python token in the expression is a ';'.\u001b[39;00m\n\u001b[1;32m 2485\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mgetattr\u001b[39m(fn, magic\u001b[38;5;241m.\u001b[39mMAGIC_OUTPUT_CAN_BE_SILENCED, \u001b[38;5;28;01mFalse\u001b[39;00m):\n", - "File \u001b[0;32m~/.venv/py311/lib/python3.11/site-packages/IPython/core/magics/execution.py:1185\u001b[0m, in \u001b[0;36mExecutionMagics.timeit\u001b[0;34m(self, line, cell, local_ns)\u001b[0m\n\u001b[1;32m 1183\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m index \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m10\u001b[39m):\n\u001b[1;32m 1184\u001b[0m number \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m10\u001b[39m \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39m index\n\u001b[0;32m-> 1185\u001b[0m time_number \u001b[38;5;241m=\u001b[39m \u001b[43mtimer\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtimeit\u001b[49m\u001b[43m(\u001b[49m\u001b[43mnumber\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1186\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m time_number \u001b[38;5;241m>\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;241m0.2\u001b[39m:\n\u001b[1;32m 1187\u001b[0m \u001b[38;5;28;01mbreak\u001b[39;00m\n", - "File \u001b[0;32m~/.venv/py311/lib/python3.11/site-packages/IPython/core/magics/execution.py:173\u001b[0m, in \u001b[0;36mTimer.timeit\u001b[0;34m(self, number)\u001b[0m\n\u001b[1;32m 171\u001b[0m gc\u001b[38;5;241m.\u001b[39mdisable()\n\u001b[1;32m 172\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 173\u001b[0m timing \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43minner\u001b[49m\u001b[43m(\u001b[49m\u001b[43mit\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtimer\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 174\u001b[0m \u001b[38;5;28;01mfinally\u001b[39;00m:\n\u001b[1;32m 175\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m gcold:\n", - "File \u001b[0;32m:1\u001b[0m, in \u001b[0;36minner\u001b[0;34m(_it, _timer)\u001b[0m\n", - "File \u001b[0;32m~/.venv/py311/lib/python3.11/site-packages/pyFAI/integrator/azimuthal.py:235\u001b[0m, in \u001b[0;36mAzimuthalIntegrator.integrate1d\u001b[0;34m(self, data, npt, filename, correctSolidAngle, variance, error_model, radial_range, azimuth_range, mask, dummy, delta_dummy, polarization_factor, dark, flat, absorption, method, unit, safe, normalization_factor, metadata)\u001b[0m\n\u001b[1;32m 233\u001b[0m split \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mfull\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 234\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 235\u001b[0m cython_integr \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msetup_sparse_integrator\u001b[49m\u001b[43m(\u001b[49m\u001b[43mshape\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnpt\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmask\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 236\u001b[0m \u001b[43m \u001b[49m\u001b[43mradial_range\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mazimuth_range\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 237\u001b[0m \u001b[43m \u001b[49m\u001b[43mmask_checksum\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmask_crc\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 238\u001b[0m \u001b[43m \u001b[49m\u001b[43munit\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43munit\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msplit\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msplit\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43malgo\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmethod\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43malgo_lower\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 239\u001b[0m \u001b[43m \u001b[49m\u001b[43mempty\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mempty\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mscale\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[1;32m 240\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mMemoryError\u001b[39;00m: \u001b[38;5;66;03m# sparse methods are hungry...\u001b[39;00m\n\u001b[1;32m 241\u001b[0m logger\u001b[38;5;241m.\u001b[39mwarning(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mMemoryError: falling back on forward implementation\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n", - "File \u001b[0;32m~/.venv/py311/lib/python3.11/site-packages/pyFAI/integrator/common.py:377\u001b[0m, in \u001b[0;36mIntegrator.setup_sparse_integrator\u001b[0;34m(self, shape, npt, mask, pos0_range, pos1_range, mask_checksum, unit, split, algo, empty, scale)\u001b[0m\n\u001b[1;32m 375\u001b[0m pos \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39marray_from_unit(shape, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcorner\u001b[39m\u001b[38;5;124m\"\u001b[39m, unit, scale\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m)\n\u001b[1;32m 376\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 377\u001b[0m pos0 \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43marray_from_unit\u001b[49m\u001b[43m(\u001b[49m\u001b[43mshape\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mcenter\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43munit0\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mscale\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[1;32m 378\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m split \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mno\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n\u001b[1;32m 379\u001b[0m dpos0 \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n", - "File \u001b[0;32m~/.venv/py311/lib/python3.11/site-packages/pyFAI/geometry/core.py:1092\u001b[0m, in \u001b[0;36mGeometry.array_from_unit\u001b[0;34m(self, shape, typ, unit, scale)\u001b[0m\n\u001b[1;32m 1089\u001b[0m meth_name \u001b[38;5;241m=\u001b[39m unit\u001b[38;5;241m.\u001b[39mget(typ)\n\u001b[1;32m 1090\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m meth_name \u001b[38;5;129;01mand\u001b[39;00m meth_name \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mdir\u001b[39m(Geometry):\n\u001b[1;32m 1091\u001b[0m \u001b[38;5;66;03m# fast path may be available\u001b[39;00m\n\u001b[0;32m-> 1092\u001b[0m out \u001b[38;5;241m=\u001b[39m \u001b[43mGeometry\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[38;5;18;43m__dict__\u001b[39;49m\u001b[43m[\u001b[49m\u001b[43mmeth_name\u001b[49m\u001b[43m]\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mshape\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1093\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m scale \u001b[38;5;129;01mand\u001b[39;00m unit:\n\u001b[1;32m 1094\u001b[0m out \u001b[38;5;241m=\u001b[39m out \u001b[38;5;241m*\u001b[39m unit\u001b[38;5;241m.\u001b[39mscale\n", - "File \u001b[0;32m~/.venv/py311/lib/python3.11/site-packages/pyFAI/geometry/core.py:524\u001b[0m, in \u001b[0;36mGeometry.qArray\u001b[0;34m(self, shape)\u001b[0m\n\u001b[1;32m 522\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_sem:\n\u001b[1;32m 523\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_cached_array\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mq_center\u001b[39m\u001b[38;5;124m\"\u001b[39m) \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 524\u001b[0m qa \u001b[38;5;241m=\u001b[39m \u001b[43mnumpy\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfromfunction\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mqFunction\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mshape\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 525\u001b[0m \u001b[43m \u001b[49m\u001b[43mdtype\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mnumpy\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfloat32\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 526\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_cached_array[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mq_center\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m qa\n\u001b[1;32m 528\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_cached_array[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mq_center\u001b[39m\u001b[38;5;124m\"\u001b[39m]\n", - "File \u001b[0;32m~/.venv/py311/lib/python3.11/site-packages/numpy/_core/numeric.py:1927\u001b[0m, in \u001b[0;36mfromfunction\u001b[0;34m(function, shape, dtype, like, **kwargs)\u001b[0m\n\u001b[1;32m 1923\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m _fromfunction_with_like(\n\u001b[1;32m 1924\u001b[0m like, function, shape, dtype\u001b[38;5;241m=\u001b[39mdtype, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m 1926\u001b[0m args \u001b[38;5;241m=\u001b[39m indices(shape, dtype\u001b[38;5;241m=\u001b[39mdtype)\n\u001b[0;32m-> 1927\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunction\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/.venv/py311/lib/python3.11/site-packages/pyFAI/geometry/core.py:449\u001b[0m, in \u001b[0;36mGeometry.qFunction\u001b[0;34m(self, d1, d2, param, path)\u001b[0m\n\u001b[1;32m 435\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 436\u001b[0m \u001b[38;5;124;03mCalculates the q value for the center of a given pixel (or set\u001b[39;00m\n\u001b[1;32m 437\u001b[0m \u001b[38;5;124;03mof pixels) in nm-1\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 446\u001b[0m \u001b[38;5;124;03m:rtype: float or array of floats.\u001b[39;00m\n\u001b[1;32m 447\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 448\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mwavelength:\n\u001b[0;32m--> 449\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mRuntimeError\u001b[39;00m((\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mScattering vector q cannot be calculated\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 450\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m without knowing wavelength !!!\u001b[39m\u001b[38;5;124m\"\u001b[39m))\n\u001b[1;32m 452\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m (_geometry \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m) \u001b[38;5;129;01mand\u001b[39;00m (path \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcython\u001b[39m\u001b[38;5;124m\"\u001b[39m):\n\u001b[1;32m 453\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m param \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n", - "\u001b[0;31mRuntimeError\u001b[0m: Scattering vector q cannot be calculated without knowing wavelength !!!" + "8.89 s ± 17.5 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + " OpenCL\n", + "4.36 ms ± 16.7 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "32.1 ms ± 69.3 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", + "CPU times: user 37min 21s, sys: 26.2 s, total: 37min 47s\n", + "Wall time: 5min 13s\n" ] } ], @@ -374,7 +323,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 5, "id": "48c02ebf-e7fa-4f49-a5db-2892f11e21e7", "metadata": {}, "outputs": [ @@ -384,30 +333,15 @@ "Text(0.5, 1.0, 'Performance of Sigma-clipping vs integrate')" ] }, - "execution_count": 22, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" }, { "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "f08158c458ba4075817283cf8ef32fd0", - "version_major": 2, - "version_minor": 0 - }, - "image/png": "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", - "text/html": [ - "\n", - "
\n", - "
\n", - " Figure\n", - "
\n", - " \n", - "
\n", - " " - ], + "image/png": "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", "text/plain": [ - "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + "
" ] }, "metadata": {}, @@ -427,6 +361,7 @@ "ax.plot(sizes, [1/i.best for i in perfs_sigma_clip_opencl.values()], label=\"Sigma-clip/OpenCL\", color='blue', linestyle='dotted', marker='2')\n", "ax.set_yscale(\"log\")\n", "ax.legend()\n", + "\n", "ax.set_title(\"Performance of Sigma-clipping vs integrate\")" ] }, @@ -435,20 +370,22 @@ "id": "147e1d95-d808-4735-a74e-a1b19b79f7ef", "metadata": {}, "source": [ + "The penalties is very limited in Cython, much more in Python.\n", + "\n", "The biggest limitation of sigma-clipping is its incompatibility with pixel-splitting, feature needed when oversampling, i.e. taking many more points than the size of the diagonal of the image.\n", - "While oversampling is not recommended in general case (due to the cross-corelation between bins it creates), it can be a nessessary evil, especially when performing Rietveld refinement where 5 points per peaks are needed, resolution that cannot be obtained with the pixel-size/distance couple accessible by th experimental setup.\n", + "While oversampling is not recommended in general case (due to the cross-corelation between bins it creates), it can be a nessessary evil, especially when performing Rietveld refinement where 5 points per peaks are needed, resolution that cannot be obtained with the pixel-size/distance couple accessible by the experimental setup.\n", "\n", "## Median filter in Azimuthal space\n", "\n", "The idea is to sort all pixels contibuting to an azimuthal bin and to average out all pixel between the lower and upper quantile. \n", "When those two thresholds are at one half, this filter provides actually the median.\n", - "In order to compatible with pixel splitting, each pixel is duplicated as many times as it contributes to different bins.\n", - "After sorting pixels according to their normalization corrected signal, the cummulative sum of normalization is performed in order to detemine which pixel to average out.\n" + "In order to be compatible with pixel splitting, each pixel is duplicated as many times as it contributes to different bins.\n", + "After sorting fragments of pixels according to their normalization corrected signal, the cummulative sum of normalization is performed in order to detemine which fragments to average out.\n" ] }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 6, "id": "b1a35b63-e77a-47c1-a5a1-09d06f44ec62", "metadata": {}, "outputs": [], @@ -463,30 +400,15 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 7, "id": "f160d7dd-c19d-4df1-890e-a7d94db55a16", "metadata": {}, "outputs": [ { "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "7bbbf073bc9340d8a01a011424fe9090", - "version_major": 2, - "version_minor": 0 - }, - "image/png": "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", - "text/html": [ - "\n", - "
\n", - "
\n", - " Figure\n", - "
\n", - " \n", - "
\n", - " " - ], + "image/png": "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", "text/plain": [ - "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + "
" ] }, "metadata": {}, @@ -512,7 +434,7 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 8, "id": "af56d591-e634-4bb8-a4a3-0828e745205a", "metadata": {}, "outputs": [ @@ -522,10 +444,10 @@ "text": [ "Pilatus1M.poni\n", " Cython\n", - "11.4 ms ± 6.09 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "27.4 ms ± 2.59 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", + "6.67 ms ± 114 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "24.2 ms ± 1.35 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", " Python\n", - "13.5 ms ± 49.9 μs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n" + "12.7 ms ± 36.3 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n" ] }, { @@ -539,16 +461,16 @@ "name": "stdout", "output_type": "stream", "text": [ - "1.04 s ± 10.2 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "1.18 s ± 4.07 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", " OpenCL\n", - "2.15 ms ± 6.52 μs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", - "93.6 ms ± 299 μs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", + "864 µs ± 506 ns per loop (mean ± std. dev. of 7 runs, 1,000 loops each)\n", + "9.94 ms ± 12.5 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", "Pilatus2M.poni\n", " Cython\n", - "18.8 ms ± 855 μs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "92.8 ms ± 677 μs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", + "13.5 ms ± 748 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "67.9 ms ± 782 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", " Python\n", - "40 ms ± 1.58 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n" + "46 ms ± 81.9 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n" ] }, { @@ -562,16 +484,16 @@ "name": "stdout", "output_type": "stream", "text": [ - "3.55 s ± 16.3 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "4.05 s ± 23.4 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", " OpenCL\n", - "5.44 ms ± 4.75 μs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", - "385 ms ± 14.3 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "1.31 ms ± 467 ns per loop (mean ± std. dev. of 7 runs, 1,000 loops each)\n", + "32.9 ms ± 20.2 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", "Eiger4M.poni\n", " Cython\n", - "29.8 ms ± 456 μs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "154 ms ± 3.29 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", + "22.9 ms ± 1.85 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "116 ms ± 1.13 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", " Python\n", - "80.6 ms ± 420 μs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n" + "82.9 ms ± 173 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n" ] }, { @@ -585,16 +507,16 @@ "name": "stdout", "output_type": "stream", "text": [ - "6.17 s ± 12 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "7.04 s ± 33.5 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", " OpenCL\n", - "9.71 ms ± 12.1 μs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", - "732 ms ± 23.2 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "2.15 ms ± 788 ns per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", + "58.1 ms ± 20.8 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", "Pilatus6M.poni\n", " Cython\n", - "43.7 ms ± 3.42 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "219 ms ± 5.86 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "31.4 ms ± 784 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "155 ms ± 1.45 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", " Python\n", - "130 ms ± 2.22 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n" + "113 ms ± 160 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n" ] }, { @@ -608,16 +530,16 @@ "name": "stdout", "output_type": "stream", "text": [ - "9.23 s ± 132 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "10.3 s ± 69.1 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", " OpenCL\n", - "13.2 ms ± 59.2 μs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", - "1.06 s ± 15.5 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "2.89 ms ± 1.74 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", + "83 ms ± 76.4 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", "Eiger9M.poni\n", " Cython\n", - "67.7 ms ± 756 μs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "370 ms ± 3.54 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "48.9 ms ± 491 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "243 ms ± 3.7 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", " Python\n", - "216 ms ± 3.26 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" + "182 ms ± 694 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" ] }, { @@ -631,16 +553,16 @@ "name": "stdout", "output_type": "stream", "text": [ - "15.1 s ± 97.2 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "17.4 s ± 160 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", " OpenCL\n", - "21.9 ms ± 596 μs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "2 s ± 13 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "4.37 ms ± 1.58 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", + "148 ms ± 137 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", "Mar3450.poni\n", " Cython\n", - "73 ms ± 781 μs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "393 ms ± 10.2 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "54.5 ms ± 771 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "257 ms ± 1.2 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", " Python\n", - "256 ms ± 1.65 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" + "227 ms ± 493 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" ] }, { @@ -654,16 +576,16 @@ "name": "stdout", "output_type": "stream", "text": [ - "17.3 s ± 71.8 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "19.8 s ± 33.5 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", " OpenCL\n", - "24.6 ms ± 44.3 μs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "2.35 s ± 16.3 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "5.12 ms ± 21.2 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "174 ms ± 394 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", "Fairchild.poni\n", " Cython\n", - "96.6 ms ± 793 μs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "417 ms ± 932 μs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "86.3 ms ± 373 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "406 ms ± 6.62 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", " Python\n", - "380 ms ± 1.64 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" + "311 ms ± 830 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" ] }, { @@ -677,12 +599,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "20.7 s ± 88.3 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "24.4 s ± 94.8 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", " OpenCL\n", - "30.2 ms ± 1.18 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "2.6 s ± 50.3 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "CPU times: user 16min 23s, sys: 15.3 s, total: 16min 38s\n", - "Wall time: 13min 5s\n" + "4.76 ms ± 12.9 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "185 ms ± 131 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", + "CPU times: user 22min 42s, sys: 26.1 s, total: 23min 8s\n", + "Wall time: 14min 10s\n" ] } ], @@ -719,30 +641,15 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 9, "id": "a8caf1c6-630e-4056-a01a-1e1707437c2d", "metadata": {}, "outputs": [ { "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "ae718543801543a69761a0b7e1775c3f", - "version_major": 2, - "version_minor": 0 - }, - "image/png": "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", - "text/html": [ - "\n", - "
\n", - "
\n", - " Figure\n", - "
\n", - " \n", - "
\n", - " " - ], + "image/png": "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", "text/plain": [ - "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + "
" ] }, "metadata": {}, @@ -771,7 +678,7 @@ "id": "00b7c06d-8f92-4cd4-b259-2ff6914eff4b", "metadata": {}, "source": [ - "As one can see, the penalities are much larger for OpenCL than for Cython.\n", + "As one can see, the penalities are much larger for OpenCL and Python than for Cython.\n", "\n", "## Conclusion\n", "*Sigma-clipping* and *median-filtering* are alternatives to azimuthal integration and offer the ability to reject outlier. They are mot more difficult to use but slightly slower owing to their greater complexity." @@ -802,7 +709,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.2" + "version": "3.11.0" } }, "nbformat": 4,