reflectorch 1.2.1__py3-none-any.whl → 1.4.0__py3-none-any.whl

reflectorch/data_generation/priors/sampler_strategies.py

@@ -73,11 +73,13 @@ class ConstrainedRoughnessSamplerStrategy(BasicSamplerStrategy):
                  roughness_mask: Tensor,
                  logdist: bool = False,
                  max_thickness_share: float = 0.5,
+                 max_total_thickness: float = None,
                  ):
         super().__init__(logdist=logdist)
         self.thickness_mask = thickness_mask
         self.roughness_mask = roughness_mask
         self.max_thickness_share = max_thickness_share
+        self.max_total_thickness = max_total_thickness
 
     def sample(self, batch_size: int,
                total_min_bounds: Tensor,
@@ -106,7 +108,8 @@ class ConstrainedRoughnessSamplerStrategy(BasicSamplerStrategy):
             thickness_mask=self.thickness_mask.to(device),
             roughness_mask=self.roughness_mask.to(device),
             widths_sampler_func=self.widths_sampler_func,
-            coef=self.max_thickness_share,
+            coef_roughness=self.max_thickness_share,
+            max_total_thickness=self.max_total_thickness,
         )
 
 class ConstrainedRoughnessAndImgSldSamplerStrategy(BasicSamplerStrategy):
@@ -129,6 +132,7 @@ class ConstrainedRoughnessAndImgSldSamplerStrategy(BasicSamplerStrategy):
                  logdist: bool = False,
                  max_thickness_share: float = 0.5,
                  max_sld_share: float = 0.2,
+                 max_total_thickness: float = None,
                  ):
         super().__init__(logdist=logdist)
         self.thickness_mask = thickness_mask
@@ -137,6 +141,7 @@ class ConstrainedRoughnessAndImgSldSamplerStrategy(BasicSamplerStrategy):
         self.isld_mask = isld_mask
         self.max_thickness_share = max_thickness_share
         self.max_sld_share = max_sld_share
+        self.max_total_thickness = max_total_thickness
 
     def sample(self, batch_size: int,
                total_min_bounds: Tensor,
@@ -169,6 +174,7 @@ class ConstrainedRoughnessAndImgSldSamplerStrategy(BasicSamplerStrategy):
             widths_sampler_func=self.widths_sampler_func,
             coef_roughness=self.max_thickness_share,
             coef_isld=self.max_sld_share,
+            max_total_thickness=self.max_total_thickness,
         )
 
 def basic_sampler(
@@ -214,15 +220,44 @@ def constrained_roughness_sampler(
         thickness_mask: Tensor,
         roughness_mask: Tensor,
         widths_sampler_func,
-        coef: float = 0.5,
+        coef_roughness: float = 0.5,
+        max_total_thickness: float = None,
 ):
     params, min_bounds, max_bounds = basic_sampler(
         batch_size, total_min_bounds, total_max_bounds, total_min_delta, total_max_delta,
         widths_sampler_func=widths_sampler_func,
     )
 
+    if max_total_thickness is not None:
+        total_thickness = max_bounds[:, thickness_mask].sum(-1)
+        indices = total_thickness > max_total_thickness
+
+        if indices.any():
+            eps = 0.01
+            rand_scale = torch.rand_like(total_thickness) * eps + 1 - eps
+            scale_coef = max_total_thickness / total_thickness * rand_scale
+            scale_coef[~indices] = 1.0
+            min_bounds[:, thickness_mask] *= scale_coef[:, None]
+            max_bounds[:, thickness_mask] *= scale_coef[:, None]
+            params[:, thickness_mask] *= scale_coef[:, None]
+
+            min_bounds[:, thickness_mask] = torch.clamp_min(
+                min_bounds[:, thickness_mask],
+                total_min_bounds[:, thickness_mask],
+            )
+
+            max_bounds[:, thickness_mask] = torch.clamp_min(
+                max_bounds[:, thickness_mask],
+                total_min_bounds[:, thickness_mask],
+            )
+
+            params[:, thickness_mask] = torch.clamp_min(
+                params[:, thickness_mask],
+                total_min_bounds[:, thickness_mask],
+            )
+
     max_roughness = torch.minimum(
-        get_max_allowed_roughness(thicknesses=params[..., thickness_mask], coef=coef),
+        get_max_allowed_roughness(thicknesses=params[..., thickness_mask], coef=coef_roughness),
         total_max_bounds[..., roughness_mask]
     )
     min_roughness = total_min_bounds[..., roughness_mask]
@@ -256,12 +291,41 @@ def constrained_roughness_and_isld_sampler(
         widths_sampler_func,
         coef_roughness: float = 0.5,
         coef_isld: float = 0.2,
+        max_total_thickness: float = None,
 ):
     params, min_bounds, max_bounds = basic_sampler(
         batch_size, total_min_bounds, total_max_bounds, total_min_delta, total_max_delta,
         widths_sampler_func=widths_sampler_func,
     )
 
+    if max_total_thickness is not None:
+        total_thickness = max_bounds[:, thickness_mask].sum(-1)
+        indices = total_thickness > max_total_thickness
+
+        if indices.any():
+            eps = 0.01
+            rand_scale = torch.rand_like(total_thickness) * eps + 1 - eps
+            scale_coef = max_total_thickness / total_thickness * rand_scale
+            scale_coef[~indices] = 1.0
+            min_bounds[:, thickness_mask] *= scale_coef[:, None]
+            max_bounds[:, thickness_mask] *= scale_coef[:, None]
+            params[:, thickness_mask] *= scale_coef[:, None]
+
+            min_bounds[:, thickness_mask] = torch.clamp_min(
+                min_bounds[:, thickness_mask],
+                total_min_bounds[:, thickness_mask],
+            )
+
+            max_bounds[:, thickness_mask] = torch.clamp_min(
+                max_bounds[:, thickness_mask],
+                total_min_bounds[:, thickness_mask],
+            )
+
+            params[:, thickness_mask] = torch.clamp_min(
+                params[:, thickness_mask],
+                total_min_bounds[:, thickness_mask],
+            )
+
     max_roughness = torch.minimum(
         get_max_allowed_roughness(thicknesses=params[..., thickness_mask], coef=coef_roughness),
         total_max_bounds[..., roughness_mask]

reflectorch/data_generation/q_generator.py

@@ -16,6 +16,7 @@ __all__ = [
     "VariableQ",
     "EquidistantQ",
     "ConstantAngle",
+    "MaskedVariableQ",
 ]
 
 
@@ -50,6 +51,8 @@ class ConstantQ(QGenerator):
                     q = q[1:]
                 else:
                     q = q[:-1]
+        self.q_min = q.min().item()
+        self.q_max = q.max().item()
         self.q = q
 
     def get_batch(self, batch_size: int, context: dict = None) -> Tensor:
@@ -63,14 +66,26 @@ class ConstantQ(QGenerator):
         """
         return self.q.clone()[None].expand(batch_size, self.q.shape[0])
     
+    def scale_q(self, q):
+        """Scales the q values to the range [-1, 1].
+
+        Args:
+            q (Tensor): unscaled q values
+
+        Returns:
+            Tensor: scaled q values
+        """
+        scaled_q_01 = (q - self.q_min) / (self.q_max - self.q_min)
+        return 2.0 * (scaled_q_01 - 0.5)
+    
 
 class VariableQ(QGenerator):
     """Q generator for reflectivity curves with variable discretization
 
     Args:
-        q_min_range (list, optional): the range for sampling the minimum q value of the curves, *q_min*. Defaults to [0.01, 0.03].
-        q_max_range (list, optional): the range for sampling the maximum q value of the curves, *q_max*. Defaults to [0.1, 0.5].
-        n_q_range (list, optional): the range for the number of points in the curves (equidistantly sampled between *q_min* and *q_max*, 
+        q_min_range (list, optional): the range for sampling the minimum q value of the curves, q_min. Defaults to [0.01, 0.03].
+        q_max_range (list, optional): the range for sampling the maximum q value of the curves, q_max. Defaults to [0.1, 0.5].
+        n_q_range (list, optional): the range for the number of points in the curves (equidistantly sampled between q_min and q_max, 
                                     the number of points varies between batches but is constant within a batch). Defaults to [64, 256].
         device (optional): the Pytorch device. Defaults to DEFAULT_DEVICE.
         dtype (optional): the Pytorch data type. Defaults to DEFAULT_DTYPE.
@@ -80,12 +95,14 @@ class VariableQ(QGenerator):
                  q_min_range: Tuple[float, float] = (0.01, 0.03),
                  q_max_range: Tuple[float, float] = (0.1, 0.5),
                  n_q_range: Tuple[int, int] = (64, 256),
+                 mode: str = 'equidistant',
                  device=DEFAULT_DEVICE,
                  dtype=DEFAULT_DTYPE,
                  ):
         self.q_min_range = q_min_range
         self.q_max_range = q_max_range
         self.n_q_range = n_q_range
+        self.mode = mode
         self.device = device
         self.dtype = dtype
 
@@ -98,14 +115,23 @@ class VariableQ(QGenerator):
         Returns:
             Tensor: generated batch of q values
         """
-        q_min = np.random.uniform(*self.q_min_range, batch_size)
-        q_max = np.random.uniform(*self.q_max_range, batch_size)
-        if self.n_q_range[0] == self.n_q_range[1]:
-            n_q = self.n_q_range[0]
-        else:
-            n_q = np.random.randint(self.n_q_range[0], self.n_q_range[1] + 1)
-        
-        q = torch.from_numpy(np.linspace(q_min, q_max, n_q).T).to(self.device).to(self.dtype)
+
+        q_min = torch.rand(batch_size, device=self.device, dtype=self.dtype) * (self.q_min_range[1] - self.q_min_range[0]) + self.q_min_range[0]
+        q_max = torch.rand(batch_size, device=self.device, dtype=self.dtype) * (self.q_max_range[1] - self.q_max_range[0]) + self.q_max_range[0]
+
+        n_q = torch.randint(self.n_q_range[0], self.n_q_range[1] + 1, (1,), device=self.device).item()
+
+        if self.mode == 'equidistant':
+            q = torch.linspace(0, 1, n_q, device=self.device, dtype=self.dtype)
+        elif self.mode == 'random':
+            q = torch.rand(n_q, device=self.device, dtype=self.dtype).sort().values
+        elif self.mode == 'logspace':
+            q = torch.logspace(
+                start=torch.log10(torch.tensor(1e-4, dtype=self.dtype, device=self.device)),
+                end=torch.log10(torch.tensor(1.0, dtype=self.dtype, device=self.device)),
+                steps=n_q, dtype=self.dtype, device=self.device)
+
+        q = q_min[:, None] + q * (q_max - q_min)[:, None]
         
         return q
     
@@ -178,49 +204,77 @@ class EquidistantQ(QGenerator):
         return qs
 
 
-class TransformerQ(QGenerator):
+class MaskedVariableQ:
     def __init__(self,
-                 q_max: float = 0.2,
-                 num_values: Union[int, Tuple[int, int]] = (30, 512),
-                 min_dq_ratio: float = 5.,
-                 device=None,
-                 dtype=torch.float64,
-                 ):
-        self.min_dq_ratio = min_dq_ratio
-        self.q_max = q_max
-        self._dq_range = q_max / num_values[1], q_max / num_values[0]
-        self._num_values = num_values
+                 q_min_range=(0.01, 0.03),
+                 q_max_range=(0.1, 0.5),
+                 n_q_range=(64, 256),
+                 mode='equidistant',
+                 shuffle_mask=False,
+                 total_thickness_constraint=True,
+                 min_points_per_fringe=4,
+                 device=DEFAULT_DEVICE,
+                 dtype=DEFAULT_DTYPE):
+        self.q_min_range = q_min_range
+        self.q_max_range = q_max_range
+        self.n_q_range = n_q_range
         self.device = device
         self.dtype = dtype
-
-    def get_batch(self, batch_size: int, context: dict = None) -> Tensor:
+        self.mode = mode
+        self.shuffle_mask = shuffle_mask
+        self.total_thickness_constraint = total_thickness_constraint
+        self.min_points_per_fringe = min_points_per_fringe
+    
+    def get_batch(self, batch_size, context):
         assert context is not None
 
-        params: BasicParams = context['params']
-        total_thickness = params.thicknesses.sum(-1)
+        q_min = torch.rand(batch_size, device=self.device, dtype=self.dtype) * (self.q_min_range[1] - self.q_min_range[0]) + self.q_min_range[0]
+        q_max = torch.rand(batch_size, device=self.device, dtype=self.dtype) * (self.q_max_range[1] - self.q_max_range[0]) + self.q_max_range[0]
 
-        assert total_thickness.shape[0] == batch_size
+        max_n_q = self.n_q_range[1]
 
-        min_dqs = torch.clamp(
-            2 * np.pi / total_thickness / self.min_dq_ratio, self._dq_range[0], self._dq_range[1] * 0.9
-        )
+        if self.mode == 'equidistant':
+            positions = torch.linspace(0, 1, max_n_q, device=self.device, dtype=self.dtype).expand(batch_size, max_n_q)
+        elif self.mode == 'random':
+            positions = torch.rand(batch_size, max_n_q, device=self.device, dtype=self.dtype)
+            positions, _ = positions.sort(dim=-1)
+        elif self.mode == 'mixed':
+            positions = torch.empty(batch_size, max_n_q, device=self.device, dtype=self.dtype)
 
-        dqs = torch.rand_like(min_dqs) * (self._dq_range[1] - min_dqs) + min_dqs
+            half = batch_size // 2 # half batch gets equidistant
+            eq_pos = torch.linspace(0, 1, max_n_q, device=self.device, dtype=self.dtype).expand(half, max_n_q)
+            positions[:half] = eq_pos
 
-        num_q_values = torch.clamp(self.q_max // dqs, *self._num_values).to(torch.int)
+            rand_pos = torch.rand(batch_size - half, max_n_q, device=self.device, dtype=self.dtype) # other half gets sorted random
+            rand_pos, _ = rand_pos.sort(dim=-1)
+            positions[half:] = rand_pos
+        else:
+            raise ValueError(f"Unknown spacing mode: {self.mode}")
 
-        q_values, mask = generate_q_padding_mask(num_q_values, self.q_max)
+        q = q_min[:, None] + positions * (q_max - q_min)[:, None]
 
-        context['tgt_key_padding_mask'] = mask
-        context['num_q_values'] = num_q_values
+        n_qs = torch.randint(self.n_q_range[0], self.n_q_range[1] + 1, (batch_size,), device=self.device)
 
-        return q_values
+        if 'params' in context and self.total_thickness_constraint: ### N_points > 1 + (Q_spread * total_thickness * min_np_per_kiessing_fringe) / (2*pi)
+            d_total = context['params'].thicknesses.sum(-1)
+            limit = 1 + ((q_max - q_min) * d_total * self.min_points_per_fringe) / (2*np.pi)
+            limit = limit.ceil().int()
+            n_qs = torch.maximum(n_qs, limit)
+            n_qs = torch.clamp(n_qs, max=self.n_q_range[1])
 
+        indices = torch.arange(max_n_q, device=self.device).expand(batch_size, max_n_q)
+        valid_mask = indices < n_qs[:, None] # right side padding
+        
+        if self.shuffle_mask: # shuffle valid positions (inter-spread padding)
+            perm = torch.argsort(torch.rand(batch_size, max_n_q, device=self.device), dim=-1)
+            valid_mask = torch.gather(valid_mask, dim=1, index=perm)
+
+        context['key_padding_mask'] = valid_mask
+        context['n_points'] = valid_mask.sum(dim=-1)
+
+        return q
+    
+    def scale_q(self, q):
+        scaled_q_01 = (q - self.q_min_range[0]) / (self.q_max_range[1] - self.q_min_range[0]) 
 
-def generate_q_padding_mask(num_q_values: Tensor, q_max: float):
-    batch_size = num_q_values.shape[0]
-    dqs = (q_max / num_q_values)[:, None]
-    q_values = torch.arange(1, num_q_values.max().item() + 1)[None].repeat(batch_size, 1) * dqs
-    mask = (q_values > q_max + dqs / 2)
-    q_values[mask] = 0.
-    return q_values, mask
+        return 2.0 * (scaled_q_01 - 0.5)

reflectorch/data_generation/reflectivity/__init__.py

@@ -10,6 +10,7 @@ from reflectorch.data_generation.reflectivity.numpy_implementations import (
     abeles_np,
 )
 from reflectorch.data_generation.reflectivity.smearing import abeles_constant_smearing
+from reflectorch.data_generation.reflectivity.smearing_pointwise import abeles_pointwise_smearing
 from reflectorch.data_generation.reflectivity.kinematical import kinematical_approximation
 
 
@@ -20,9 +21,15 @@ def reflectivity(
         sld: Tensor,
         dq: Tensor = None,
         gauss_num: int = 51,
-        constant_dq: bool = True,
+        constant_dq: bool = False,
         log: bool = False,
-        abeles_func=None,
+        q_shift: Tensor = 0.0,
+        r_scale: Tensor = 1.0,
+        background: Tensor = 0.0,
+        solvent_vf = None,
+        solvent_mode = 'fronting',
+        abeles_func = None,
+        **abeles_kwargs
 ):
     """Function which computes the reflectivity curves from thin film parameters. 
     By default it uses the fast implementation of the Abeles matrix formalism.
@@ -37,24 +44,59 @@ def reflectivity(
                             Either dq if ``constant_dq`` is ``True`` or dq/q if ``constant_dq`` is ``False``. Defaults to None.
         gauss_num (int, optional): the number of gaussians for curve smearing. Defaults to 51.
         constant_dq (bool, optional): if ``True`` the smearing is constant (constant dq at each point in the curve) 
-                                    otherwise the smearing is linear (constant dq/q at each point in the curve). Defaults to True.
+                                    otherwise the smearing is linear (constant dq/q at each point in the curve). Defaults to False.
         log (bool, optional): if True the base 10 logarithm of the reflectivity curves is returned. Defaults to False.
+        q_shift (float or Tensor, optional): misalignment in q.
+        r_scale (float or Tensor, optional): normalization factor (scales reflectivity).
+        background (float or Tensor, optional): background intensity.
         abeles_func (Callable, optional): a function implementing the simulation of the reflectivity curves, if different than the default Abeles matrix implementation ('abeles'). Defaults to None.
-
+        abeles_kwargs: Additional arguments specific to the chosen `abeles_func`.
     Returns:
-        Tensor: tensor containing the simulated reflectivity curves with shape [batch_size, n_points]
+        Tensor: the computed reflectivity curves
     """
     abeles_func = abeles_func or abeles
-    q = torch.atleast_2d(q)
+    q = torch.atleast_2d(q) + q_shift
+    q = torch.clamp(q, min=0.0)
+    
+    if solvent_vf is not None:
+        num_layers = thickness.shape[-1]
+        if solvent_mode == 'fronting':
+            assert sld.shape[-1] == num_layers + 2
+            assert solvent_vf.shape[-1] == num_layers
+            solvent_sld = sld[..., [0]]
+            idx = slice(1, num_layers)
+            sld[..., idx] = solvent_vf * solvent_sld + (1.0 - solvent_vf) * sld[..., idx]
+        elif solvent_mode == 'backing':
+            solvent_sld = sld[..., [-1]]
+            idx = slice(1, num_layers) if sld.shape[-1] == num_layers + 2 else slice(0, num_layers)
+            sld[..., idx] = solvent_vf * solvent_sld + (1.0 - solvent_vf) * sld[..., idx]
+        else:
+            raise NotImplementedError
 
     if dq is None:
-        reflectivity_curves = abeles_func(q, thickness, roughness, sld)
+        reflectivity_curves = abeles_func(q, thickness, roughness, sld, **abeles_kwargs)
     else:
-        reflectivity_curves = abeles_constant_smearing(
-            q, thickness, roughness, sld,
-            dq=dq, gauss_num=gauss_num, constant_dq=constant_dq, abeles_func=abeles_func
-        )
+        if dq.shape[-1] > 1:
+            reflectivity_curves = abeles_pointwise_smearing(
+                    q=q, dq=dq, thickness=thickness, roughness=roughness, sld=sld, 
+                    abeles_func=abeles_func, gauss_num=gauss_num,
+                    **abeles_kwargs,
+            )
+        else:
+            reflectivity_curves = abeles_constant_smearing(
+                q, thickness, roughness, sld,
+                dq=dq, gauss_num=gauss_num, constant_dq=constant_dq, abeles_func=abeles_func,
+                **abeles_kwargs,
+            )
+
+    if isinstance(r_scale, Tensor):
+        r_scale = r_scale.view(-1, *[1] * (reflectivity_curves.dim() - 1))
+    if isinstance(background, Tensor):
+        background = background.view(-1, *[1] * (reflectivity_curves.dim() - 1))
+
+    reflectivity_curves = reflectivity_curves * r_scale + background
 
     if log:
         reflectivity_curves = torch.log10(reflectivity_curves)
+
     return reflectivity_curves

reflectorch/data_generation/reflectivity/kinematical.py

@@ -51,7 +51,7 @@ def kinematical_approximation(
 
         substrate_sld = sld[:, -1:]
 
-        rf = _get_resnel_reflectivity(q, substrate_sld[:, None])
+        rf = _get_fresnel_reflectivity(q, substrate_sld[:, None])
 
         r = torch.clamp_max_(r * rf / substrate_sld.real ** 2, 1.)
 
@@ -61,12 +61,11 @@ def kinematical_approximation(
     return r
 
 
-def _get_resnel_reflectivity(q, substrate_slds):
-    _RE_CONST = 0.28174103675406496
+def _get_fresnel_reflectivity(q, substrate_slds):
+    _RE_CONST = 0.28174103675406496 # 2/sqrt(16*pi)
 
     q_c = torch.sqrt(substrate_slds + 0j) / _RE_CONST * 2
     q_prime = torch.sqrt(q ** 2 - q_c ** 2 + 0j)
     r_f = ((q - q_prime) / (q + q_prime)).abs().float() ** 2
 
-    return r_f.squeeze(-1)
-
+    return r_f.squeeze(-1)

reflectorch/data_generation/reflectivity/smearing.py

@@ -14,26 +14,41 @@ def abeles_constant_smearing(
         roughness: Tensor,
         sld: Tensor,
         dq: Tensor = None,
-        gauss_num: int = 51,
-        constant_dq: bool = True,
+        gauss_num: int = 31,
+        constant_dq: bool = False,
         abeles_func=None,
+        **abeles_kwargs
 ):
     abeles_func = abeles_func or abeles
+
+    if dq.dtype != thickness.dtype:
+        q = q.to(thickness)
+    
+    if dq.dtype != thickness.dtype:
+        dq = dq.to(thickness)
+
+    if q.shape[0] == 1:
+        q = q.repeat(thickness.shape[0], 1)
+
     q_lin = _get_q_axes(q, dq, gauss_num, constant_dq=constant_dq)
     kernels = _get_t_gauss_kernels(dq, gauss_num)
-
-    curves = abeles_func(q_lin, thickness, roughness, sld)
+    
+    curves = abeles_func(q_lin, thickness, roughness, sld, **abeles_kwargs)
 
     padding = (kernels.shape[-1] - 1) // 2
+    padded_curves = pad(curves, (padding, padding), 'reflect')
+
     smeared_curves = conv1d(
-        pad(curves[None], (padding, padding), 'reflect'), kernels[:, None], groups=kernels.shape[0],
-    )[0]
+        padded_curves, kernels[:, None], groups=kernels.shape[0],
+    )
 
     if q.shape[0] != smeared_curves.shape[0]:
-        q = q.expand(smeared_curves.shape[0], *q.shape[1:])
-
+        repeat_factor = smeared_curves.shape[0] // q.shape[0]
+        q = q.repeat(repeat_factor, 1)
+        q_lin = q_lin.repeat(repeat_factor, 1)
+    
     smeared_curves = _batch_linear_interp1d(q_lin, smeared_curves, q)
-
+        
     return smeared_curves
 
 
@@ -55,7 +70,7 @@ def _get_t_gauss_kernels(resolutions: Tensor, gaussnum: int = 51):
     return gauss_y
 
 
-def _get_q_axes(q: Tensor, resolutions: Tensor, gaussnum: int = 51, constant_dq: bool = True):
+def _get_q_axes(q: Tensor, resolutions: Tensor, gaussnum: int = 51, constant_dq: bool = False):
     if constant_dq:
         return _get_q_axes_for_constant_dq(q, resolutions, gaussnum)
     else:

reflectorch/data_generation/reflectivity/smearing_pointwise.py

@@ -0,0 +1,110 @@
+import torch
+import scipy
+import numpy as np
+from functools import lru_cache
+from typing import Tuple
+
+from reflectorch.data_generation.reflectivity.abeles import abeles
+
+#Pytorch version based on the JAX implementation of pointwise smearing in the refnx package.
+
+@lru_cache(maxsize=128)
+def gauss_legendre(n: int) -> Tuple[torch.Tensor, torch.Tensor]:
+    """
+    Calculate Gaussian quadrature abscissae and weights.
+
+    Args:
+        n (int): Gaussian quadrature order.
+
+    Returns:
+        Tuple[torch.Tensor, torch.Tensor]: The abscissae and weights for Gauss-Legendre integration.
+    """
+    return scipy.special.p_roots(n)
+
+def gauss(x: torch.Tensor) -> torch.Tensor:
+    """
+    Calculate the Gaussian function.
+
+    Args:
+        x (torch.Tensor): Input tensor.
+
+    Returns:
+        torch.Tensor: Output tensor after applying the Gaussian function.
+    """
+    return torch.exp(-0.5 * x * x)
+
+def abeles_pointwise_smearing(
+    q: torch.Tensor,
+    dq: torch.Tensor,
+    thickness: torch.Tensor,
+    roughness: torch.Tensor,
+    sld: torch.Tensor,
+    gauss_num: int = 17,
+    abeles_func=None,
+    **abeles_kwargs,
+) -> torch.Tensor:
+    """
+    Compute reflectivity with variable smearing using Gaussian quadrature.
+
+    Args:
+        q (torch.Tensor): The momentum transfer (q) values.
+        dq (torch.Tensor): The resolution for curve smearing.
+        thickness (torch.Tensor): The layer thicknesses.
+        roughness (torch.Tensor): The interlayer roughnesses.
+        sld (torch.Tensor): The SLDs of the layers.
+        sld_magnetic (torch.Tensor, optional): The magnetic SLDs of the layers.
+        magnetization_angle (torch.Tensor, optional): The magnetization angles.
+        polarizer_eff (torch.Tensor, optional): The polarizer efficiency.
+        analyzer_eff (torch.Tensor, optional): The analyzer efficiency.
+        abeles_func (Callable, optional): A function implementing the simulation of the reflectivity curves.
+        gauss_num (int, optional): Gaussian quadrature order. Defaults to 17.
+
+    Returns:
+        torch.Tensor: The computed reflectivity curves.
+    """
+    abeles_func = abeles_func or abeles
+
+    if q.shape[0] == 1:
+        q = q.repeat(thickness.shape[0], 1)
+
+    _FWHM = 2 * np.sqrt(2 * np.log(2.0))
+    _INTLIMIT = 3.5
+
+    bs = q.shape[0]
+    nq = q.shape[-1]
+    device = q.device
+
+    quad_order = gauss_num
+    abscissa, weights = gauss_legendre(quad_order)
+    abscissa = torch.tensor(abscissa)[None, :, None].to(device)
+    weights = torch.tensor(weights)[None, :, None].to(device)
+    prefactor = 1.0 / np.sqrt(2 * np.pi)
+
+    gaussvals = prefactor * gauss(abscissa * _INTLIMIT)
+
+    va = q[:, None, :] - _INTLIMIT * dq[:, None, :] / _FWHM
+    vb = q[:, None, :] + _INTLIMIT * dq[:, None, :] / _FWHM
+
+    qvals_for_res_0 = (abscissa * (vb - va) + vb + va) / 2
+    qvals_for_res = qvals_for_res_0.reshape(bs, -1)
+
+    refl_curves = abeles_func(
+        q=qvals_for_res,
+        thickness=thickness,
+        roughness=roughness,
+        sld=sld,
+        **abeles_kwargs
+    )
+
+    # Handle multiple channels
+    if refl_curves.dim() == 3:
+        n_channels = refl_curves.shape[1]
+        refl_curves = refl_curves.reshape(bs, n_channels, quad_order, nq)
+        refl_curves = refl_curves * gaussvals.unsqueeze(1) * weights.unsqueeze(1)
+        refl_curves = torch.sum(refl_curves, dim=2) * _INTLIMIT
+    else:
+        refl_curves = refl_curves.reshape(bs, quad_order, nq)
+        refl_curves = refl_curves * gaussvals * weights
+        refl_curves = torch.sum(refl_curves, dim=1) * _INTLIMIT
+
+    return refl_curves