def test_average_reflect(self):
data11 = dataformat.QData(0.05, 0.1, 0., 0.05 * 0.05)
data12 = dataformat.QData(0.25, 0.05, 0., 0.05 * 0.25)
data13 = dataformat.QData(0.50, 0.01, 0., 0.05 * 0.50)
data1 = [data11, data12, data13]
data21 = dataformat.QData(0.05, 0.12, 0., 0.05 * 0.05)
data22 = dataformat.QData(0.25, 0.03, 0., 0.05 * 0.25)
data23 = dataformat.QData(0.50, 0.015, 0., 0.05 * 0.50)
data2 = [data21, data22, data23]
data31 = dataformat.QData(0.05, 0.14, 0., 0.05 * 0.05)
data32 = dataformat.QData(0.25, 0.07, 0., 0.05 * 0.25)
data33 = dataformat.QData(0.50, 0.005, 0., 0.05 * 0.50)
data3 = [data31, data32, data33]
layer1 = dataformat.SLDPro(1., 0., 0.)
layer2 = dataformat.SLDPro(1., 5., 0.)
sld = [[layer1, layer2]]
ddata1 = dataformat.QData(0.05, 0., 0., 0.05 * 0.05)
ddata2 = dataformat.QData(0.25, 0., 0., 0.05 * 0.25)
ddata3 = dataformat.QData(0.50, 0., 0., 0.05 * 0.50)
ddata = [ddata1, ddata2, ddata3]
a = reflect.Reflect(sld, ddata)
a.reflect = [data1, data2, data3]
a.average_ref()
assert_almost_equal(a.averagereflect[0].i, 0.12)
assert_almost_equal(a.averagereflect[1].i, 0.05)
assert_almost_equal(a.averagereflect[2].i, 0.01)
def test_fit_noi(self):
data11 = dataformat.QData(0.05, 0.1, 0., 0.05 * 0.05)
data12 = dataformat.QData(0.25, 0.05, 0., 0.05 * 0.25)
data13 = dataformat.QData(0.50, 0.01, 0., 0.05 * 0.50)
data1 = [data11, data12, data13]
data21 = dataformat.QData(0.05, 0.12, 0., 0.05 * 0.05)
data22 = dataformat.QData(0.25, 0.03, 0., 0.05 * 0.25)
data23 = dataformat.QData(0.50, 0.015, 0., 0.05 * 0.50)
data2 = [data21, data22, data23]
data31 = dataformat.QData(0.05, 0.14, 0., 0.05 * 0.05)
data32 = dataformat.QData(0.25, 0.07, 0., 0.05 * 0.25)
data33 = dataformat.QData(0.50, 0.005, 0., 0.05 * 0.50)
data3 = [data31, data32, data33]
layer1 = dataformat.SLDPro(1., 0., 0.)
layer2 = dataformat.SLDPro(1., 5., 0.)
sld = [[layer1, layer2]]
ddata1 = dataformat.QData(0.05, 0., 0., 0.05 * 0.05)
ddata2 = dataformat.QData(0.25, 0., 0., 0.05 * 0.25)
ddata3 = dataformat.QData(0.50, 0., 0., 0.05 * 0.50)
ddata = [ddata1, ddata2, ddata3]
a = reflect.Reflect(sld, ddata)
a.reflect = [data1, data2, data3]
a.average_ref()
ddata1 = dataformat.QData(0.05, None, 0., 0.05 * 0.05)
ddata2 = dataformat.QData(0.25, 0., 0., 0.05 * 0.25)
ddata3 = dataformat.QData(0.50, 0., 0., 0.05 * 0.50)
ddata = [ddata1, ddata2, ddata3]
k = compare.Compare(ddata, a.averagereflect, 1, 0)
with self.assertRaises(ValueError) as context:
k.fit()
self.assertTrue(
'No experimental data has been set for comparison, please read in a a .dat file.'
in str(context.exception))
def test_fit_noq(self):
data11 = dataformat.QData(0.05, 0.1, 0., 0.05 * 0.05)
data12 = dataformat.QData(0.25, 0.05, 0., 0.05 * 0.25)
data13 = dataformat.QData(0.50, 0.01, 0., 0.05 * 0.50)
data1 = [data11, data12, data13]
data21 = dataformat.QData(0.05, 0.12, 0., 0.05 * 0.05)
data22 = dataformat.QData(0.25, 0.03, 0., 0.05 * 0.25)
data23 = dataformat.QData(0.50, 0.015, 0., 0.05 * 0.50)
data2 = [data21, data22, data23]
data31 = dataformat.QData(0.05, 0.14, 0., 0.05 * 0.05)
data32 = dataformat.QData(0.25, 0.07, 0., 0.05 * 0.25)
data33 = dataformat.QData(0.50, 0.005, 0., 0.05 * 0.50)
data3 = [data31, data32, data33]
layer1 = dataformat.SLDPro(1., 0., 0.)
layer2 = dataformat.SLDPro(1., 5., 0.)
sld = [[layer1, layer2]]
ddata1 = dataformat.QData(0.05, 0., 0., 0.05 * 0.05)
ddata2 = dataformat.QData(0.25, 0., 0., 0.05 * 0.25)
ddata3 = dataformat.QData(0.50, 0., 0., 0.05 * 0.50)
ddata = [ddata1, ddata2, ddata3]
a = reflect.Reflect(sld, ddata)
a.reflect = [data1, data2, data3]
a.average_ref()
ddata = []
k = compare.Compare(ddata, a.averagereflect, 1, 0)
with self.assertRaises(ValueError) as context:
k.fit()
self.assertTrue(
'No q vectors have been defined -- either read a .dat file or get q vectors.'
in str(context.exception))
def test_average_reflect_noq(self):
layer1 = dataformat.SLDPro(1., 0., 0.)
layer2 = dataformat.SLDPro(1., 5., 0.)
sld = [[layer1, layer2]]
ddata = []
a = reflect.Reflect(sld, ddata)
with self.assertRaises(ValueError) as context:
a.average_ref()
self.assertTrue(
'No q vectors have been defined -- either read a .dat file or get q vectors.'
in str(context.exception))
def test_calc_ref_basic(self):
layer1 = dataformat.SLDPro(1., 0., 0.)
layer2 = dataformat.SLDPro(1., 5., 0.)
sld = [[layer1, layer2]]
data1 = dataformat.QData(0.05, 0., 0., 0.05 * 0.05)
data2 = dataformat.QData(0.25, 0., 0., 0.05 * 0.25)
data3 = dataformat.QData(0.50, 0., 0., 0.05 * 0.50)
data = [data1, data2, data3]
a = reflect.Reflect(sld, data)
a.calc_ref()
assert_equal(len(a.reflect), 1)
assert_equal(len(a.reflect[0]), 3)
def test_set_sld_profile(self):
c = None
a = dataformat.SLDPro(5., 5., 0.)
b = dataformat.SLDPro(5., 0., 0.)
slda = [a, b]
a = sld.SLD(c)
a.set_sld_profile(slda)
assert_almost_equal(a.sld_profile[0].thick, 5.)
assert_almost_equal(a.sld_profile[0].real, 5.)
assert_almost_equal(a.sld_profile[0].imag, 0.)
assert_almost_equal(a.sld_profile[1].thick, 5.)
assert_almost_equal(a.sld_profile[1].real, 0.)
assert_almost_equal(a.sld_profile[1].imag, 0.)
return
def get_sld_profile(self):
"""Calculate SLD profile.
This will calculate the SLD profile for each of the timesteps defined in the falass.job.Job. This is achieved
by summing the scattering lengths for each of the atoms found in a given layer (of defined thickness). This
total scattering length is converted to a density by division by the volume of the layer.
"""
prog = 0
self.sld_profile = []
print("Calculating SLD profile\n[ 0 % ]")
# create mask of which frames to analyse
time_mask = np.array([
True if t in self.assigned_job.times else False
for t in self.assigned_job.files.times
],
dtype=bool)
u = self.assigned_job.files.u
k = 0
for ts in u.trajectory[time_mask]:
if self.assigned_job.files.flip:
u.atoms.positions[:, 2] = readwrite.flip_zpos(
u.dimensions[2], u.atoms.positions[:, 2])
build_sld = []
z_cut = u.dimensions[2] - self.assigned_job.cut_off_size
number_of_bins = int(z_cut / self.assigned_job.layer_thickness)
for j in range(0, number_of_bins):
build_sld.append(
dataformat.SLDPro(self.assigned_job.layer_thickness, 0, 0))
for atom in u.atoms:
if atom.position[
2] < number_of_bins * self.assigned_job.layer_thickness:
bin_choose = int(atom.position[2] /
self.assigned_job.layer_thickness)
scatlen_to_add = get_scatlen(
atom.name, self.assigned_job.files.scat_lens)
build_sld[bin_choose].real += scatlen_to_add[0]
build_sld[bin_choose].imag += scatlen_to_add[1]
k += 1
prog_new = np.floor(
k / (len(u.atoms) * len(self.assigned_job.files.atoms)) *
100)
if prog_new > prog + 9:
prog = prog_new
print("[{} {} % ]".format('#' * int(prog / 10),
int(prog / 10) * 10))
for j in range(0, number_of_bins):
build_sld[j].real /= (u.dimensions[0] * u.dimensions[1] *
self.assigned_job.layer_thickness)
build_sld[j].imag /= (u.dimensions[0] * u.dimensions[1] *
self.assigned_job.layer_thickness)
self.sld_profile.append(build_sld)
def test_make_kn(self):
layer1 = dataformat.SLDPro(5., 5., 0.)
layer2 = dataformat.SLDPro(5., 0., 0.)
sld_profile = [layer1, layer2]
exp_data = [0.05, 0.25, 0.5]
layers = np.zeros((len(sld_profile), 4))
for i in range(0, len(sld_profile)):
layers[i][0] = sld_profile[i].thick
layers[i][1] = sld_profile[i].real
layers[i][2] = sld_profile[i].imag
layers[i][3] = 0
qvals = np.asfarray(exp_data).ravel()
nlayers = len(sld_profile) - 2
npnts = qvals.size
kn = reflect.make_kn(npnts, nlayers, layers, qvals)
assert_almost_equal(
kn, [[0.025 + 0j, 7.9266940191 + 0j],
[0.125 + 0j, 7.927640133 + 0j], [0.25 + 0j, 7.93059601 + 0j]])
def average_sld_profile(self):
"""Average SLD profiles.
Allows for the calculation of the average SLD profile across all of the timesteps that were studied.
"""
prog = 0
self.av_sld_profile_err = []
self.av_sld_profile = []
print("Getting average SLD profile\n[ 0 % ]")
z_cut = self.assigned_job.files.cell[0][
2] - self.assigned_job.cut_off_size
number_of_bins = int(z_cut / self.assigned_job.layer_thickness)
k = 0
for j in range(0, number_of_bins):
self.av_sld_profile.append(
dataformat.SLDPro(self.assigned_job.layer_thickness, 0, 0))
for i in range(0, len(self.assigned_job.times)):
self.av_sld_profile[j].real += self.sld_profile[i][j].real
self.av_sld_profile[j].imag += self.sld_profile[i][j].imag
self.av_sld_profile[j].real /= len(self.assigned_job.times)
self.av_sld_profile[j].imag /= len(self.assigned_job.times)
self.av_sld_profile_err.append(
dataformat.SLDPro(self.assigned_job.layer_thickness, 0, 0))
for i in range(0, len(self.assigned_job.times)):
self.av_sld_profile_err[j].real += np.square(
self.sld_profile[i][j].real - self.av_sld_profile[j].real)
self.av_sld_profile_err[j].imag += np.square(
self.sld_profile[i][j].imag - self.av_sld_profile[j].imag)
k += 1
prog_new = np.floor(
k / (number_of_bins * len(self.assigned_job.files.atoms)) *
100)
if prog_new > prog + 9:
prog = prog_new
print("[{} {} % ]".format('#' * int(prog / 10),
int(prog / 10) * 10))
self.av_sld_profile_err[j].real = np.sqrt(
1. / (len(self.assigned_job.times) -
1)) * self.av_sld_profile_err[j].real
self.av_sld_profile_err[j].imag = np.sqrt(
1. / (len(self.assigned_job.times) -
1)) * self.av_sld_profile_err[j].imag
def test_reflect(self):
layer1 = dataformat.SLDPro(1., 0., 0.)
layer2 = dataformat.SLDPro(1., 5., 0.)
sld = [[layer1, layer2]]
data1 = dataformat.QData(0.05, 0., 0., 0.05 * 0.05)
data2 = dataformat.QData(0.25, 0., 0., 0.05 * 0.25)
data3 = dataformat.QData(0.50, 0., 0., 0.05 * 0.50)
data = [data1, data2, data3]
a = reflect.Reflect(sld, data)
assert_almost_equal(a.sld_profile[0][0].thick, 1.)
assert_almost_equal(a.sld_profile[0][0].real, 0.)
assert_almost_equal(a.sld_profile[0][0].imag, 0.)
assert_almost_equal(a.sld_profile[0][1].thick, 1.)
assert_almost_equal(a.sld_profile[0][1].real, 5.)
assert_almost_equal(a.sld_profile[0][1].imag, 0.)
assert_almost_equal(a.exp_data[0].q, 0.05)
assert_almost_equal(a.exp_data[0].dq, 0.05 * 0.05)
assert_almost_equal(a.exp_data[1].q, 0.25)
assert_almost_equal(a.exp_data[1].dq, 0.25 * 0.05)
assert_almost_equal(a.exp_data[2].q, 0.50)
assert_almost_equal(a.exp_data[2].dq, 0.50 * 0.05)
def test_sldpro(self):
a = dataformat.SLDPro(1., 2., 3.)
assert_equal(a.thick, 1.)
assert_equal(a.real, 2.)
assert_equal(a.imag, 3.)
def get_sld_profile(self):
"""Calculate SLD profile.
This will calculate the SLD profile for each of the timesteps defined in the falass.job.Job. This is achieved
by summing the scattering lengths for each of the atoms found in a given layer (of defined thickness). This
total scattering length is converted to a density by division by the volume of the layer.
"""
prog = 0
self.sld_profile = []
print("Calculating SLD profile\n[ 0 % ]")
for i in range(0, len(self.assigned_job.files.atoms)):
build_sld = []
if job.check_array(self.assigned_job.times,
self.assigned_job.files.times[i]):
z_cut = self.assigned_job.files.cell[i][
2] - self.assigned_job.cut_off_size
number_of_bins = int(z_cut / self.assigned_job.layer_thickness)
for j in range(0, number_of_bins):
build_sld.append(
dataformat.SLDPro(self.assigned_job.layer_thickness, 0,
0))
self.sld_profile.append(build_sld)
k = 0
for i in range(0, len(self.assigned_job.files.atoms)):
if job.check_array(self.assigned_job.times,
self.assigned_job.files.times[i]):
z_cut = self.assigned_job.files.cell[i][
2] - self.assigned_job.cut_off_size
number_of_bins = int(z_cut / self.assigned_job.layer_thickness)
for j in range(0, len(self.assigned_job.files.atoms[i])):
if self.assigned_job.files.atoms[i][
j].zpos < number_of_bins * self.assigned_job.layer_thickness:
bin_choose = int(
self.assigned_job.files.atoms[i][j].zpos /
self.assigned_job.layer_thickness)
scatlen_to_add = get_scatlen(
self.assigned_job.files.atoms[i][j].atom,
self.assigned_job.files.scat_lens)
self.sld_profile[i][bin_choose].real += scatlen_to_add[
0]
self.sld_profile[i][bin_choose].imag += scatlen_to_add[
1]
k += 1
prog_new = np.floor(
k / (len(self.assigned_job.files.atoms[i]) *
len(self.assigned_job.files.atoms)) * 100)
if prog_new > prog + 9:
prog = prog_new
print("[{} {} % ]".format('#' * int(prog / 10),
int(prog / 10) * 10))
for i in range(0, len(self.assigned_job.files.atoms)):
if job.check_array(self.assigned_job.times,
self.assigned_job.files.times[i]) is True:
z_cut = self.assigned_job.files.cell[i][
2] - self.assigned_job.cut_off_size
number_of_bins = int(z_cut / self.assigned_job.layer_thickness)
for j in range(0, number_of_bins):
self.sld_profile[i][j].real = self.sld_profile[i][
j].real / (self.assigned_job.files.cell[i][0] *
self.assigned_job.files.cell[i][1] *
self.assigned_job.layer_thickness)
self.sld_profile[i][j].imag = self.sld_profile[i][
j].imag / (self.assigned_job.files.cell[i][0] *
self.assigned_job.files.cell[i][1] *
self.assigned_job.layer_thickness)
