Welcome to pyFAI Discussions!

[kif]

👋 Welcome!

There are now two main communication channels with pyFAI developers:

1. A public mailing list, [email protected] informs you about new release of the software, new features available. To subscribe to this mailing list, send an email to [email protected].
2. For more technical questions, GitHub Discussions or Issues are good places to:

• Ask questions you’re wondering about.
• Share ideas.
• Engage with other community members.
• Welcome others and are open-minded. Remember that this is a community we
  build together 💪.

To get started, comment below with an introduction of yourself and tell us about what you do with this community.

[kewh5868]

Hello! My name is Keith White, I am a graduate student at University of Colorado Boulder, and am using GIWAXS for my phd research.

I wanted to ask about the current FiberIntegrator class in pyFAI. I would like to perform pixel splitting, but understand that this can augment intensity about the missing wedge.

I was wondering if there were any pyFAI objects that store something analogous to a missing wedge mask so that I can reapply the missing wedge after using splitpix to resample my reciprocal space corrected data. I wrote a routine to generate a mask to reapply this after running bbox on the 2D image, but I would prefer to having a mask that is directly calculated. Also, I wanted to ask if there are any other foreseeable issues (i.e., overly skewed intensity) that may arise from using splitpix.

Thanks for any help!

[kif]

Hi Keith,

The problem with the missing wedge is that it is a discontinuity and any pixel splitting method assumes the pixel is contiguous, which is incompatible. Any pixel (in the input image) being crossed by the discontinuity will be spread over all output bins (i.e. pixels in the transformed image) of the missing wedge, where there will be a very small contribution for the signal and for the normalization. As a consequence, the average intensity is the same on all bins of the missing wedge.

There is another discontinuity in the azimuthal dimension but specific code has been added to deal with it. Adding such a modification for the missing wedge is a lot of tedious work (~6 month of work) with major refactoring of all rebinning engines (there are several of them).

One way to address this would be to use oversampling (i.e. split every pixel in 4, 9 ....), and reuse the code without pixel splitting. I discarded oversample in favour of pixel splitting for performance reasons (much slower).

Since the bins in the missing wedge have very little contribution, one could discard all pixels without significant contribution.
Here is a modification of the cell #11 of this notebook in the documentation
https://www.silx.org/doc/pyFAI/latest/usage/tutorial/FiberGrazingIncidence.html#FiberIntegrator-methods-use-non-pixel-splitting-by-default

res2d_no = fi.integrate2d_grazing_incidence(data=data, sample_orientation=6, incident_angle=numpy.deg2rad(0.12))
res2d_bbox = fi.integrate2d_grazing_incidence(data=data, sample_orientation=6, incident_angle=numpy.deg2rad(0.12),
                                              method=("bbox", "csr", "cython")
                                             )

fig, axes = subplots(ncols=3, figsize=(15,5))
plot2d(result=res2d_no, ax=axes[0])
plot2d(result=res2d_bbox, ax=axes[1])
update_style(ax=axes[0])
update_style(ax=axes[1])
axes[0].set_title("Pixel-splitting=no")
axes[1].set_title("Pixel-splitting=bbox")

# mask out pixels without much contribution
res2d_bbox.intensity[res2d_bbox.sum_normalization<0.5] = 0
plot2d(result=res2d_bbox, ax=axes[2])
axes[2].set_title("Pixel-splitting=bbox + Mask");
update_style(ax=axes[2])

Like this, most bins on the missing wedge appear empty.

Cheers,
Jérôme

[kif]

[kif]

In principle, pyFAI provides average intensity which is the weighted mean: sum_intensity/sum_normalization. PyFAI guaranties the conservation on the sum_intensity, i.e. the total photon count in this array is the same as in the input image, minor errors are originating from numerical rounding errors (linked to floating point representation of numbers).