def test_with_select(self):
data = [{"A": i, "B": i * i} for i in range(1000)]
data2 = [{"A": i, "B": i * i, "C": i * i * i} for i in range(1000)]
elems = [
create(StaCustom({
"A": d["A"],
"B": d["B"],
"C": d["A"] + d["B"]
})) for d in data
]
pro = ProData(elems)
pro.select("A", "B")
execute_omp(pro)
self.assertEqual(pro.get_results(), data)
data = [[{"A": j, "B": i * j} for j in range(100)] for i in range(100)]
data2 = [[{
"A": j,
"B": i * j,
"C": i + j
} for j in range(100)] for i in range(100)]
elems = [create(StaCustom(d)) for d in data]
pro = ProData(elems)
pro.select("A", "B")
execute_omp(pro)
self.assertEqual(pro.get_results(), data)
def test_select_two(self):
ids = list(range(1000))
shuffle(ids)
data = [[
{"id": j, "A": float(i+j), "B": float(i*j)}
for j in ids]
for i in range(100)]
elems = [create(StaCustom(d)) for d in data]
pro = ProValueArray(elems)
pro.select("A", "B")
execute_omp(pro)
arrs = pro.get_results()
for i, elem in enumerate(elems):
ds = elem.get_data()
for d in ds:
self.assertEqual(arrs["A"][i][d["id"]], d["A"])
self.assertEqual(arrs["B"][i][d["id"]], d["B"])
def test_cubic_isotropic(self):
abst_atoms = []
mol_id = 0
for ix in range(10):
for iy in range(10):
for iz in range(10):
mol_id += 1
abst_atoms.extend(
self.create_rotated_abst_atoms_in_mol(
uniform(-0.5, 0.5), 6*(mol_id-1)+1, mol_id,
1.0*ix, 1.0*iy, 1.0*iz))
atoms = create(StaCustom(abst_atoms))
mols = create(StaMolecules(atoms))
mols.append_updater(AddCoMPosition(atoms))
mols.append_updater(AddInertiaMoment(atoms))
box = create(StaCustom({
"lo_x": 0.0, "hi_x": 10.0, "pbc_x": True,
"lo_y": 0.0, "hi_y": 10.0, "pbc_y": True,
"lo_z": 0.0, "hi_z": 10.0, "pbc_z": True}))
mols.append_updater(AddWrappedPosition(box))
pro = ProRDFWD(mols, box)
num_bins = 20
bin_width = 0.1
pro.set_bin(bin_width, num_bins)
execute_omp(pro)
self.assertTrue(np.allclose(
pro.get_r_axis(), np.arange(0.0, num_bins*bin_width, bin_width)))
expected_rdf = np.zeros(num_bins)
data = [
{"index": 10, "num": 6},
{"index": 14, "num": 12},
{"index": 17, "num": 8}]
for d in data:
r_inner = (d["index"]-0.5) * bin_width
r_outer = (d["index"]+0.5) * bin_width
dV = (4.0*np.pi/3.0) * (
np.power(r_outer, 3) - np.power(r_inner, 3))
expected_rdf[d["index"]] = (d["num"]/dV)/1.0
self.assertTrue(np.allclose(pro.get_rdf(), expected_rdf))
def test_with_and_without_modification(self):
n_traj = 100
n_mols = 100
abst_atoms_traj = []
mol_id = 0
for i in range(n_traj):
abst_atoms = []
mol_id = 0
for i in range(n_mols):
mol_id += 1
abst_atoms.extend(
self.create_rotated_abst_atoms_in_mol(
uniform(-1.0, 1.0), 6*(mol_id-1)+1, mol_id,
uniform(-50.0, 50.0),
uniform(-50.0, 50.0),
uniform(-50.0, 50.0)))
abst_atoms_traj.append(abst_atoms)
atomses = [
create(StaCustom(abst_atoms)) for abst_atoms in abst_atoms_traj]
boxes = [
create(StaCustom({
"lo_x": 0.0, "hi_x": 10.0, "pbc_x": True,
"lo_y": 0.0, "hi_y": 10.0, "pbc_y": True,
"lo_z": 0.0, "hi_z": 10.0, "pbc_z": True
})) for i in range(n_traj)]
molses = [
create(StaMolecules(atoms))
.append_updater(AddCoMPosition(atoms))
.append_updater(AddInertiaMoment(atoms))
.append_updater(AddWrappedPosition(box))
for atoms, box in zip(atomses, boxes)]
pro_with_modify = ProRDFWD(list(zip(molses, boxes)))
pro_without_modify = ProRDF(list(zip(molses, boxes)))
num_bins = 20
bin_width = 0.1
pro_with_modify.set_bin(bin_width, num_bins)
pro_without_modify.set_bin(bin_width, num_bins)
execute_omp([pro_with_modify, pro_without_modify])
self.assertTrue(np.allclose(
pro_with_modify.get_rdf(), pro_without_modify.get_rdf()))
self.assertTrue(np.allclose(
np.array(pro_with_modify.get_rdf_traj()),
np.array(pro_without_modify.get_rdf_traj())))
def test_for_beads(self):
n_samples = 50
interval = 1000
atomses = [
create(StaDumpAtoms("dumps_atom/atom.{}.dump".format(i), i))
for i in range(0, n_samples * interval + 1, interval)
]
boxes = [
create(StaDumpBox("dumps_atom/atom.{}.dump".format(i), i))
for i in range(0, n_samples * interval + 1, interval)
]
molses = [create(StaMolecules(atoms)) for atoms in atomses]
mappings = [[0, 1, 2, 12, 13, 14, 15, 16, 17, 18],
[3, 4, 5, 19, 20, 21, 22, 23, 24],
[6, 7, 8, 25, 26, 27, 28, 29, 30],
[9, 10, 11, 31, 32, 33, 34, 35, 36, 37]]
abst_beads = [{
"type": 1,
"indices-in-mol": mapping
} for mapping in mappings]
beadses = [
create(StaBeads(mols, abst_beads)).append_updater(
AddCoMPosition(atoms)).append_updater(
AddInertiaMoment(atoms)).append_updater(
AddWrappedPosition(box))
for atoms, box, mols in zip(atomses, boxes, molses)
]
pro = ProRDFWD(list(zip(beadses, boxes)))
num_bins = 150
bin_width = 0.1
pro.set_bin(bin_width, num_bins)
pro.set_margin(2.0)
execute_omp(pro)
Rg2s = pro.get_squared_gyration_radius()
self.assertTrue(
np.allclose(Rg2s["isotropic"], (1 / 3) * Rg2s["parallel"] +
(2 / 3) * Rg2s["perpendicular"]))
Rg2s_traj = pro.get_squared_gyration_radius_traj()
self.assertTrue(
np.allclose(np.array(Rg2s_traj["isotropic"]),
(1 / 3) * np.array(Rg2s_traj["parallel"]) +
(2 / 3) * np.array(Rg2s_traj["perpendicular"])))
def test_rotate_stick(self):
n_mols = 10
rotate_data = []
initial_atoms = []
for imol in range(n_mols):
ps = np.random.uniform(-10.0, 10.0, (3,3))
m_point = 0.5 * (ps[0] + ps[1])
cross = np.cross(ps[1] - ps[0], ps[2] - ps[0])
n_vector = cross / np.linalg.norm(cross)
rotate_data.append({"normal": n_vector, "middle": m_point})
initial_atoms.extend([
{"id": 2*imol+i+1, "mol": imol+1, "xyz": ps[i]}
for i in range(2)
])
atoms_traj = []
for i in range(181):
atoms_tmp = deepcopy(initial_atoms)
for atom in atoms_tmp:
m = rotate_data[atom["mol"]-1]["middle"]
n = rotate_data[atom["mol"]-1]["normal"]
rotated_xyz = np.array(rot(i, n, atom["xyz"]-m)) + m
atom["xu"] = rotated_xyz[0]
atom["yu"] = rotated_xyz[1]
atom["zu"] = rotated_xyz[2]
del atom["xyz"]
atoms_traj.append(create(StaCustom(atoms_tmp)))
mols_traj = [create(StaMolecules(atoms)) for atoms in atoms_traj]
pro = ProTimeCorrelationInMolecule(list(zip(mols_traj, atoms_traj)))
pro.set_indices(0, 1)
execute_omp(pro)
expects = np.array([np.cos(i*np.pi/180) for i in range(181)])
self.assertTrue(np.allclose(pro.get_time_correlation(), expects))
def test_dimension_2d(self):
abst_atoms_traj = []
for itraj in range(10):
tmp = deepcopy(self.abst_atoms)
shift_x = uniform(-100.0, 100.0)
shift_y = uniform(-100.0, 100.0)
shift_z = uniform(-100.0, 100.0)
for atom in tmp:
atom["xu"] *= itraj + 1
atom["yu"] *= itraj + 1
atom["zu"] *= itraj + 1
atom["xu"] += shift_x
atom["yu"] += shift_y
atom["zu"] += shift_z
abst_atoms_traj.append(tmp)
atomses = [create(StaCustom(a)) for a in abst_atoms_traj]
pro_xyz = ProMeanSquareDisplacement(atomses)
pro_xy = ProMeanSquareDisplacement(atomses)
pro_xy.set_dimension(True, True, False)
pro_yz = ProMeanSquareDisplacement(atomses)
pro_yz.set_dimension(False, True, True)
pro_xz = ProMeanSquareDisplacement(atomses)
pro_xz.set_dimension(True, False, True)
execute_omp([pro_xyz, pro_xy, pro_yz, pro_xz])
self.assertTrue(
np.allclose(pro_xy.get_mean_square_displacement(),
pro_yz.get_mean_square_displacement()))
self.assertTrue(
np.allclose(pro_xy.get_mean_square_displacement(),
pro_xz.get_mean_square_displacement()))
self.assertTrue(
np.allclose(
2 * pro_xyz.get_mean_square_displacement(),
pro_xz.get_mean_square_displacement() +
pro_yz.get_mean_square_displacement() +
pro_xz.get_mean_square_displacement()))
def test_dimension_3d(self):
abst_atoms_traj = []
for itraj in range(10):
tmp = deepcopy(self.abst_atoms)
shift_x = uniform(-100.0, 100.0)
shift_y = uniform(-100.0, 100.0)
shift_z = uniform(-100.0, 100.0)
for atom in tmp:
atom["xu"] *= itraj + 1
atom["yu"] *= itraj + 1
atom["zu"] *= itraj + 1
atom["xu"] += shift_x
atom["yu"] += shift_y
atom["zu"] += shift_z
abst_atoms_traj.append(tmp)
atomses = [create(StaCustom(a)) for a in abst_atoms_traj]
pro = ProMeanSquareDisplacement(atomses)
execute_omp(pro)
expect = np.array([2.0 * i * i for i in range(10)])
self.assertTrue(np.allclose(pro.get_mean_square_displacement(),
expect))
expect_array = []
for itraj in range(10):
tmp = []
for i in range(-1, 2):
for j in range(-1, 2):
for k in range(-1, 2):
tmp.append(
float(i * i + j * j + k * k) * itraj * itraj)
expect_array.append(tmp)
self.assertTrue(
np.allclose(pro.get_displacement2_array(), np.array(expect_array)))
def test_20x30_with_shift(self):
atoms = [
create(
StaCustom([{
"x": 1.0 * ix,
"y": 1.0 * iy - 10.0,
"z": 1.0 * i,
"radius": 1.0
} for ix in range(20) for iy in range(30)])) for i in range(10)
]
box = [
create(
StaCustom({
"lo_x": 0.0,
"hi_x": 20.0,
"lo_y": -10.0,
"hi_y": 20.0
})) for i in range(10)
]
pro = ProThicknessProfile(list(zip(atoms, box)))
pro.set_grid(20, 30)
pro.shift_half_delta()
execute_omp(pro)
conditions = pro.get_conditions()
for c in conditions:
self.assertEqual(
c, {
"origin_x": 0.5,
"origin_y": -9.5,
"delta_x": 1.0,
"delta_y": 1.0,
"nx": 20,
"ny": 30
})
profiles = pro.get_profiles()
addition = 0.5 * sqrt(2)
for i, p in enumerate(profiles):
self.assertTrue(
np.allclose(p, np.full((20, 30),
float(i) + addition)))
def test_squared_distance(self):
abst_atoms = []
n_atoms_in_mol = len(self.base_data)
for imol in range(10):
tmp = deepcopy(self.base_data)
shift_x = uniform(-100.0, 100.0)
shift_y = uniform(-100.0, 100.0)
shift_z = uniform(-100.0, 100.0)
for atom in tmp:
atom["id"] += imol * n_atoms_in_mol
atom["mol"] += imol
atom["xu"] += shift_x
atom["yu"] += shift_y
atom["zu"] += shift_z
abst_atoms.extend(tmp)
abst_atoms_traj = []
for itraj in range(10):
tmp = deepcopy(abst_atoms)
for atom in tmp:
atom["xu"] *= itraj + 1
atom["yu"] *= itraj + 1
atom["zu"] *= itraj + 1
abst_atoms_traj.append(tmp)
atomses = [create(StaCustom(a)) for a in abst_atoms_traj]
molses = [create(StaMolecules(a)) for a in atomses]
pro = ProDistanceInMolecule(list(zip(molses, atomses)))
pro.set_indices(0, 5)
execute_omp(pro)
expects = np.array([[20.0 * (i + 1) * (i + 1)] * 10
for i in range(10)])
self.assertTrue(np.allclose(pro.get_distance2_array(), expects))
def test_without_select(self):
data = [{"A": i, "B": i * i} for i in range(1000)]
elems = [create(StaCustom(d)) for d in data]
pro = ProData(elems)
execute_omp(pro)
self.assertEqual(pro.get_results(), data)
data = [[{"A": j, "B": i * j} for j in range(100)] for i in range(100)]
elems = [create(StaCustom(d)) for d in data]
pro = ProData(elems)
execute_omp(pro)
self.assertEqual(pro.get_results(), data)
def test_select_one(self):
data = [[
{"id": j, "A": float(i+j), "B": float(i*j)}
for j in range(1000)]
for i in range(100)]
elems = [create(StaCustom(d)) for d in data]
pro = ProValueArray(elems)
pro.select("A")
execute_omp(pro)
arr_A = pro.get_results()["A"]
for i, elem in enumerate(elems):
ds = elem.get_data()
for d in ds:
self.assertEqual(arr_A[i][d["id"]], d["A"])
def test_cubic(self):
abst_atoms = []
atom_id = 0
for ix in range(10):
for iy in range(10):
for iz in range(10):
atom_id += 1
abst_atoms.append({
"id": atom_id,
"x": 1.0 * ix,
"y": 1.0 * iy,
"z": 1.0 * iz
})
atoms = create(StaCustom(abst_atoms))
box = create(
StaCustom({
"lo_x": 0.0,
"hi_x": 10.0,
"pbc_x": True,
"lo_y": 0.0,
"hi_y": 10.0,
"pbc_y": True,
"lo_z": 0.0,
"hi_z": 10.0,
"pbc_z": True
}))
pro = ProRadialDistributionFunction(atoms, box)
num_bins = 20
bin_width = 0.1
pro.set_bin(bin_width, num_bins)
execute_omp(pro)
self.assertTrue(
np.allclose(pro.get_r_axis(),
np.arange(0.0, num_bins * bin_width, bin_width)))
expected_rdf = np.zeros(num_bins)
data = [{
"index": 10,
"num": 6
}, {
"index": 14,
"num": 12
}, {
"index": 17,
"num": 8
}]
for d in data:
r_inner = (d["index"] - 0.5) * bin_width
r_outer = (d["index"] + 0.5) * bin_width
dV = (4.0 * np.pi / 3.0) * (np.power(r_outer, 3) -
np.power(r_inner, 3))
expected_rdf[d["index"]] = (d["num"] / dV) / 1.0
self.assertTrue(np.allclose(pro.get_rdf(), expected_rdf))
def test_traj(self):
atoms_traj = []
box_traj = []
for i in range(10):
abst_atoms = []
atom_id = 0
for ix in range(10):
for iy in range(10):
for iz in range(10):
atom_id += 1
abst_atoms.append({
"id":
atom_id,
"x":
1.0 * (ix + 0.5) + uniform(-0.005, 0.005),
"y":
1.0 * (iy + 0.5) + uniform(-0.005, 0.005),
"z":
1.0 * (iz + 0.5) + uniform(-0.005, 0.005)
})
atoms_traj.append(create(StaCustom(abst_atoms)))
box_traj.append(
create(
StaCustom({
"lo_x": 0.0,
"hi_x": 10.0,
"pbc_x": True,
"lo_y": 0.0,
"hi_y": 10.0,
"pbc_y": True,
"lo_z": 0.0,
"hi_z": 10.0,
"pbc_z": True
})))
pro = ProRadialDistributionFunction(list(zip(atoms_traj, box_traj)))
num_bins = 20
bin_width = 0.1
pro.set_bin(bin_width, num_bins)
execute_omp(pro)
expected_rdf = np.zeros(num_bins)
data = [{
"index": 10,
"num": 6
}, {
"index": 14,
"num": 12
}, {
"index": 17,
"num": 8
}]
for d in data:
r_inner = (d["index"] - 0.5) * bin_width
r_outer = (d["index"] + 0.5) * bin_width
dV = (4.0 * np.pi / 3.0) * (np.power(r_outer, 3) -
np.power(r_inner, 3))
expected_rdf[d["index"]] = (d["num"] / dV) / 1.0
rdf = pro.get_rdf()
self.assertTrue(np.allclose(rdf, expected_rdf))
rdf_traj = pro.get_rdf_traj()
rdf_sum = np.zeros(num_bins)
for rdf_tmp in rdf_traj:
self.assertTrue(np.allclose(rdf_tmp, expected_rdf))
rdf_sum += rdf_tmp
self.assertTrue(np.allclose(len(rdf_traj) * rdf, rdf_sum))
