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)