def test_compare_c_py_abeles(self):
# test python and c are equivalent
# but not the same file
s = self.structure.slabs()[..., :4]
# if not TEST_C_REFLECT:
# return
assert_(_reflect.__file__ != _creflect.__file__)
calc1 = _reflect.abeles(self.qvals, s)
calc2 = _creflect.abeles(self.qvals, s)
assert_almost_equal(calc1, calc2)
calc1 = _reflect.abeles(self.qvals, s, scale=2.)
calc2 = _creflect.abeles(self.qvals, s, scale=2.)
assert_almost_equal(calc1, calc2)
calc1 = _reflect.abeles(self.qvals, s, scale=0.5,
bkg=0.1)
# threads = 1 is a non-threaded implementation
calc2 = _creflect.abeles(self.qvals, s, scale=0.5,
bkg=0.1, threads=1)
# threads = 2 forces the calculation to go through multithreaded calcn,
# even on single core processor
calc3 = _creflect.abeles(self.qvals, s, scale=0.5,
bkg=0.1, threads=2)
assert_almost_equal(calc1, calc2)
assert_almost_equal(calc1, calc3)
def test_pnr(self):
# test pnr calculation
q = np.linspace(0.01, 0.3, 1001)
# use for spin channel PNR calculation
players = np.array([[0, 0, 0, 0, 0],
[100, 3, 0, 1, 0],
[0, 4, 0, 0, 0]])
# use for NSF calculation with abeles
pp_layers = np.array([[0, 0, 0, 0],
[100, 4., 0, 0],
[0, 4, 0, 0]])
mm_layers = np.array([[0, 0, 0, 0],
[100, 2, 0, 0],
[0, 4, 0, 0]])
r = _reflect.pnr(q, players)
pp = _reflect.abeles(q, pp_layers)
mm = _reflect.abeles(q, mm_layers)
assert_allclose(r[0], pp)
assert_allclose(r[1], mm)
def test_compare_c_py_abeles0(self):
# test two layer system
if not TEST_C_REFLECT:
return
layer0 = np.array([[0, 2.07, 0.01, 3], [0, 6.36, 0.1, 3]])
calc1 = _reflect.abeles(self.qvals, layer0, scale=0.99, bkg=1e-8)
calc2 = _creflect.abeles(self.qvals, layer0, scale=0.99, bkg=1e-8)
assert_almost_equal(calc1, calc2)
# test a negative background
calc1 = _reflect.abeles(self.qvals, layer0, scale=0.99, bkg=-5e-7)
calc2 = _creflect.abeles(self.qvals, layer0, scale=0.99, bkg=-5e-7)
assert_almost_equal(calc1, calc2)
def test_abeles_reshape(self):
# reflectivity should be able to deal with multidimensional input
s = self.structure.slabs()[..., :4]
reshaped_q = np.reshape(self.qvals, (2, 250))
reshaped_r = self.rvals.reshape(2, 250)
calc = _reflect.abeles(reshaped_q, s)
assert_equal(reshaped_r.shape, calc.shape)
assert_almost_equal(reshaped_r, calc, 15)
def test_compare_c_py_abeles2(self):
# test two layer system
if not TEST_C_REFLECT:
return
layer2 = np.array([[0, 2.07, 0.01, 3], [10, 3.47, 0.01, 3],
[100, 1.0, 0.01, 4], [0, 6.36, 0.1, 3]])
calc1 = _reflect.abeles(self.qvals, layer2, scale=0.99, bkg=1e-8)
calc2 = _creflect.abeles(self.qvals, layer2, scale=0.99, bkg=1e-8)
assert_almost_equal(calc1, calc2)
def test_c_py_abeles_absorption(self):
# https://github.com/andyfaff/refl1d_analysis/tree/master/notebooks
q = np.linspace(0.008, 0.05, 500)
depth = [0, 850, 0]
rho = [2.067, 4.3, 6.]
irho_zero = [0., 0.1, 0.]
refnx_sigma = [np.nan, 35, 5.]
w_zero = np.c_[depth, rho, irho_zero, refnx_sigma]
py_abeles = _reflect.abeles(q, w_zero)
c_abeles = _creflect.abeles(q, w_zero)
assert_almost_equal(py_abeles, c_abeles)
def test_compare_refl1d(self):
# refl1d calculated with:
# from refl1d import abeles
# x = np.linspace(0.005, 0.5, 1001)
# z = abeles.refl(x / 2,
# [0, 100, 200, 0],
# [2.07, 3.45, 5., 6.],
# irho=[0.0, 0.1, 0.01, 0],
# sigma=[3, 1, 5, 0])
# a = z.real ** 2 + z.imag ** 2
layers = np.array([[0, 2.07, 0, 0],
[100, 3.45, 0.1, 3],
[200, 5.0, 0.01, 1],
[0, 6., 0, 5]])
x = np.linspace(0.005, 0.5, 1001)
calc1 = _reflect.abeles(x, layers)
calc2 = _creflect.abeles(x, layers)
refl1d = np.load(os.path.join(self.pth, 'refl1d.npy'))
assert_almost_equal(calc1, refl1d)
assert_almost_equal(calc2, refl1d)
def time_abeles(self):
abeles(self.q, self.layers)
def test_py_abeles(self):
# test reflectivity calculation with values generated from Motofit
calc = _reflect.abeles(self.qvals, self.structure.slabs()[..., :4])
assert_almost_equal(calc, self.rvals)
