def test_smoke(self):
wavelength_axis = calculate_wavelength_bins(2.5, 12.5, 3)
peff = PolarisationEfficiency(wavelength_axis)
assert peff.combined_efficiency_matrix.shape == tuple(
[len(wavelength_axis), 4, 4])
def __init__(
self,
model,
angle,
L12=2859,
footprint=60,
L2S=120,
dtheta=3.3, # angular resolution
lo_wavelength=2.8,
hi_wavelength=18,
dlambda=3.3,
rebin=2):
self.model = model
# turn off resolution smearing
self.model.dq = 0
self.bkg = model.bkg.value
self.angle = angle
# the fractional width of a square wavelength resolution
self.dlambda = dlambda / 100.
self.rebin = rebin / 100.
self.wavelength_bins = calculate_wavelength_bins(
lo_wavelength, hi_wavelength, rebin)
# nominal Q values
bin_centre = 0.5 * (self.wavelength_bins[1:] +
self.wavelength_bins[:-1])
self.q = general.q(angle, bin_centre)
# keep a tally of the direct and reflected beam
self.direct_beam = np.zeros((self.wavelength_bins.size - 1))
self.reflected_beam = np.zeros((self.wavelength_bins.size - 1))
# wavelength generator
a = PN('PLP0000711.nx.hdf')
q, i, di = a.process(normalise=False,
normalise_bins=False,
rebin_percent=0,
lo_wavelength=lo_wavelength,
hi_wavelength=hi_wavelength)
q = q.squeeze()
i = i.squeeze()
self.spectrum_dist = SpectrumDist(q, i)
# angular resolution generator, based on a trapezoidal distribution
# The slit settings are the optimised set typically used in an
# experiment
self.dtheta = dtheta / 100.
self.footprint = footprint
s1, s2 = general.slit_optimiser(footprint,
self.dtheta,
angle=angle,
L2S=L2S,
L12=L12,
verbose=False)
div, alpha, beta = general.div(s1, s2, L12=L12)
self.angular_dist = trapz(c=(alpha - beta) / 2. / alpha,
d=(alpha + beta) / 2. / alpha,
loc=-alpha,
scale=2 * alpha)
def test_input(self):
wavelength_axis = calculate_wavelength_bins(2.5, 12.5,
3).reshape(1, -1)
with pytest.raises(ValueError):
peff = PolarisationEfficiency(wavelength_axis)
assert peff
def test_config_difference(self):
wavelength_axis = calculate_wavelength_bins(2.5, 12.5, 3)
p_PF = PolarisationEfficiency(wavelength_axis, config="PF")
p_full = PolarisationEfficiency(wavelength_axis, config="full")
with pytest.raises(AssertionError):
assert_equal(
p_PF.combined_efficiency_matrix,
p_full.combined_efficiency_matrix,
)
def test_calculate_bins(self):
bins = plp.calculate_wavelength_bins(2., 18, 2.)
assert_almost_equal(bins[0], 1.98)
assert_almost_equal(bins[-1], 18.18)
def __init__(
self,
model,
angle,
L12=2859,
footprint=60,
L2S=120,
dtheta=3.3,
lo_wavelength=2.8,
hi_wavelength=18,
dlambda=3.3,
rebin=2,
gravity=False,
force_gaussian=False,
force_uniform_wavelength=False,
):
self.model = model
self.bkg = model.bkg.value
self.angle = angle
# dlambda refers to the FWHM of the gaussian approximation to a uniform
# distribution. The full width of the uniform distribution is
# dlambda/0.68.
self.dlambda = dlambda / 100.0
# the rebin percentage refers to the full width of the bins. You have to
# multiply this value by 0.68 to get the equivalent contribution to the
# resolution function.
self.rebin = rebin / 100.0
self.wavelength_bins = calculate_wavelength_bins(
lo_wavelength, hi_wavelength, rebin
)
bin_centre = 0.5 * (
self.wavelength_bins[1:] + self.wavelength_bins[:-1]
)
# angular deviation due to gravity
# --> no correction for gravity affecting width of angular resolution
elevations = 0
if gravity:
speeds = general.wavelength_velocity(bin_centre)
# trajectories through slits for different wavelengths
trajectories = pm.find_trajectory(L12 / 1000.0, 0, speeds)
# elevation at sample
elevations = pm.elevation(
trajectories, speeds, (L12 + L2S) / 1000.0
)
# nominal Q values
self.q = general.q(angle - elevations, bin_centre)
# keep a tally of the direct and reflected beam
self.direct_beam = np.zeros((self.wavelength_bins.size - 1))
self.reflected_beam = np.zeros((self.wavelength_bins.size - 1))
# beam monitor counts for normalisation
self.bmon_direct = 0
self.bmon_reflect = 0
self.gravity = gravity
# wavelength generator
self.force_uniform_wavelength = force_uniform_wavelength
if force_uniform_wavelength:
self.spectrum_dist = uniform(
loc=lo_wavelength - 1, scale=hi_wavelength - lo_wavelength + 1
)
else:
a = PN("PLP0000711.nx.hdf")
q, i, di = a.process(
normalise=False,
normalise_bins=False,
rebin_percent=0.5,
lo_wavelength=max(0, lo_wavelength - 1),
hi_wavelength=hi_wavelength + 1,
)
q = q.squeeze()
i = i.squeeze()
self.spectrum_dist = SpectrumDist(q, i)
self.force_gaussian = force_gaussian
# angular resolution generator, based on a trapezoidal distribution
# The slit settings are the optimised set typically used in an
# experiment. dtheta/theta refers to the FWHM of a Gaussian
# approximation to a trapezoid.
# stores the q vectors contributing towards each datapoint
self._res_kernel = {}
self._min_samples = 0
self.dtheta = dtheta / 100.0
self.footprint = footprint
self.angle = angle
self.L2S = L2S
self.L12 = L12
s1, s2 = general.slit_optimiser(
footprint,
self.dtheta,
angle=angle,
L2S=L2S,
L12=L12,
verbose=False,
)
div, alpha, beta = general.div(s1, s2, L12=L12)
self.div, self.s1, self.s2 = s1, s2, div
if force_gaussian:
self.angular_dist = norm(scale=div / 2.3548)
else:
self.angular_dist = trapz(
c=(alpha - beta) / 2.0 / alpha,
d=(alpha + beta) / 2.0 / alpha,
loc=-alpha,
scale=2 * alpha,
)
def test_calculate_bins(self):
bins = plp.calculate_wavelength_bins(2., 18, 2.)
assert_almost_equal(bins[0], 1.98)
assert_almost_equal(bins[-1], 18.18)
