def set_mol(self, mol_file, nmol):
'''
set molecule files and number of molecules
# ---------- args
mol_file (list): list of path for molecular files (.xyz, etc)
one can also use pre-defined strings such as
H2O, CH4, benzene, ... etc.
see PyXtal document
nmol (list): number of molecules
# ---------- example
# ------ 4 benzene molecules in unit cell
mol_file = ['benzene']
nmol = [4]
# ------ molecules you make (2 * mol_1 and 2 * mol_2)
mol_file = ['./mol_1.xyz', './mol_2.xyz']
nmol = [2, 2]
'''
# ---------- check args
# ------ mol_file
if type(mol_file) is not list:
raise ValueError('mol_file must be list')
for s in mol_file:
if type(s) is not str:
raise ValueError('elements in mol_file must be string')
# ------ nmol
if type(nmol) is not list:
raise ValueError('nmol must be list')
for i in nmol:
if type(i) is not int:
raise ValueError('elements in nmol must be int')
# ------ mol_file and nmol
if not len(mol_file) == len(nmol):
raise ValueError('not len(mol_file) == len(nmol)')
# ----------
mol_data = []
pyxtal_mol_data = Collection('molecules')
pyxtal_mol_names = list(Collection('molecules'))
for i, mf in enumerate(mol_file):
if os.path.isfile(mf):
mol = Molecule.from_file(mf)
elif mf in pyxtal_mol_names:
mol = pyxtal_mol_data[mf]
else:
raise ValueError('no molecular files')
mol_data.append(mol)
# ---------- self.xxx
self.nmol = nmol
self.mol_data = mol_data
def __init__(self, numIons):
self.numIons = numIons
ref = Collection('clusters')[str(numIons)]
print('\nReference for LJ {0:3d} is {1:12.3f} eV, PG: {2:4s}'.\
format(numIons, ref['energy'], ref['pointgroup']))
self.reference = ref
self.time0 = time()
def __init__(self, numIons):
self.numIons = numIons
ref = Collection("clusters")[str(numIons)]
print("\nReference for LJ {0:3d} is {1:12.3f} eV, PG: {2:4s}".format(
numIons, ref["energy"], ref["pointgroup"]))
self.reference = ref
self.time0 = time()
def mol_from_collection(mname):
"""
Get a molecule from pyxtal.database.collection
Args:
mname: the name of the molecule
Returns:
a pymatgen Molecule object
"""
return Collection('molecules')[mname]
def mol_from_collection(mname):
"""
Get a molecule from pyxtal.database.collection
Args:
mname: the name of the molecule
Returns:
a pymatgen Molecule object
"""
try:
return Collection('molecules')[mname]
except:
printx("Could not find molecule '"+str(mname)+"' in pyxtal.database.", priority=1)
return
# ------------------------------
# External Libraries
from pymatgen.core.structure import Molecule
from pymatgen.symmetry.analyzer import PointGroupAnalyzer, generate_full_symmops
from pymatgen.core.bonds import CovalentBond
# PyXtal imports
from pyxtal.msg import printx
from pyxtal.tolerance import Tol_matrix
from pyxtal.database.element import Element
from pyxtal.operations import SymmOp, OperationAnalyzer, rotate_vector, angle
from pyxtal.database.collection import Collection
# Define functions
# ------------------------------
molecule_collection = Collection("molecules")
class pyxtal_molecule:
"""
Extended molecule class based on pymatgen.core.structure.Molecule
The added features include:
0, parse the input
1, estimate volume/tolerance/radii
2, find and store symmetry (todo)
3, get the principle axis (todo)
4, re-align the molecule (todo)
Args:
mol: a string to reprent the molecule
tm: tolerance matrix
op = o.get_op(angle=0)
mo = deepcopy(mol)
mo.apply_operation(op)
if orientation_in_wyckoff_position(mo, wyckoff_position, exact_orientation=True, randomize=False, allow_inversion=allow_inversion) is True:
allowed.append(o)
#Return the array of allowed orientations. If there are none, return False
if allowed == []:
return False
else:
return allowed
#Test Functionality
if __name__ == "__main__":
#---------------------------------------------------
#Testing water
mol = Collection('molecules')['H2O']
print("Original molecule:")
print(mol)
print()
#Apply random rotation to avoid lucky results
R = aa2matrix(1,1,random=True)
R_op = SymmOp.from_rotation_and_translation(R,[0,0,0])
mol.apply_operation(R_op)
print("Rotated molecule:")
print(mol)
print()
#pga = PointGroupAnalyzer(mol)
#mol = pga.symmetrize_molecule()['sym_mol']
def test_modules():
print("====== Testing functionality for pyXtal version 0.1dev ======")
global failed_package
failed_package = False # Record if errors occur at any level
reset()
print("Importing sys...")
try:
import sys
print("Success!")
except Exception as e:
fail(e)
sys.exit(0)
print("Importing numpy...")
try:
import numpy as np
print("Success!")
except Exception as e:
fail(e)
sys.exit(0)
I = np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]])
print("Importing pymatgen...")
try:
import pymatgen
print("Success!")
except Exception as e:
fail(e)
sys.exit(0)
try:
from pymatgen.core.operations import SymmOp
except Exception as e:
fail(e)
sys.exit(0)
print("Importing pandas...")
try:
import pandas
print("Success!")
except Exception as e:
fail(e)
sys.exit(0)
print("Importing spglib...")
try:
import spglib
print("Success!")
except Exception as e:
fail(e)
sys.exit(0)
print("Importing openbabel...")
try:
import ase
print("Success!")
except:
print(
"Error: could not import openbabel. Try reinstalling the package.")
print("Importing pyxtal...")
try:
import pyxtal
print("Success!")
except Exception as e:
fail(e)
sys.exit(0)
print("=== Testing modules ===")
# =====database.element=====
print("pyxtal.database.element")
reset()
try:
import pyxtal.database.element
except Exception as e:
fail(e)
print(" class Element")
try:
from pyxtal.database.element import Element
except Exception as e:
fail(e)
if passed():
for i in range(1, 95):
if passed():
try:
ele = Element(i)
except:
fail("Could not access Element # " + str(i))
try:
y = ele.sf
y = ele.z
y = ele.short_name
y = ele.long_name
y = ele.valence
y = ele.valence_electrons
y = ele.covalent_radius
y = ele.vdw_radius
y = ele.get_all(0)
except:
fail("Could not access attribute for element # " + str(i))
try:
ele.all_z()
ele.all_short_names()
ele.all_long_names()
ele.all_valences()
ele.all_valence_electrons()
ele.all_covalent_radii()
ele.all_vdw_radii()
except:
fail("Could not access class methods")
check()
# =====database.hall=====
print("pyxtal.database.hall")
reset()
try:
import pyxtal.database.hall
except Exception as e:
fail(e)
print(" hall_from_hm")
try:
from pyxtal.database.hall import hall_from_hm
except Exception as e:
fail(e)
if passed():
for i in range(1, 230):
if passed():
try:
hall_from_hm(i)
except:
fail("Could not access hm # " + str(i))
check()
# =====database.collection=====
print("pyxtal.database.collection")
reset()
try:
import pyxtal.database.collection
except Exception as e:
fail(e)
print(" Collection")
try:
from pyxtal.database.collection import Collection
except Exception as e:
fail(e)
if passed():
for i in range(1, 230):
if passed():
try:
molecule_collection = Collection("molecules")
except:
fail("Could not access hm # " + str(i))
check()
# =====operations=====
print("pyxtal.operations")
reset()
try:
import pyxtal.operations
except Exception as e:
fail(e)
print(" random_vector")
try:
from pyxtal.operations import random_vector
except Exception as e:
fail(e)
if passed():
try:
for i in range(10):
random_vector()
except Exception as e:
fail(e)
check()
print(" angle")
try:
from pyxtal.operations import angle
except Exception as e:
fail(e)
if passed():
try:
for i in range(10):
v1 = random_vector()
v2 = random_vector()
angle(v1, v2)
except Exception as e:
fail(e)
check()
print(" random_shear_matrix")
try:
from pyxtal.operations import random_shear_matrix
except Exception as e:
fail(e)
if passed():
try:
for i in range(10):
random_shear_matrix()
except Exception as e:
fail(e)
check()
print(" is_orthogonal")
try:
from pyxtal.operations import is_orthogonal
except Exception as e:
fail(e)
if passed():
try:
a = is_orthogonal([[1, 0, 0], [0, 1, 0], [0, 0, 1]])
b = is_orthogonal([[0, 0, 1], [1, 0, 0], [1, 0, 0]])
if a is True and b is False:
pass
else:
fail()
except Exception as e:
fail(e)
check()
print(" aa2matrix")
try:
from pyxtal.operations import aa2matrix
except Exception as e:
fail(e)
if passed():
try:
for i in range(10):
aa2matrix(1, 1, random=True)
except Exception as e:
fail(e)
check()
print(" matrix2aa")
try:
from pyxtal.operations import matrix2aa
except Exception as e:
fail(e)
if passed():
try:
for i in range(10):
m = aa2matrix(1, 1, random=True)
aa = matrix2aa(m)
except Exception as e:
fail(e)
check()
print(" rotate_vector")
try:
from pyxtal.operations import rotate_vector
except Exception as e:
fail(e)
if passed():
try:
for i in range(10):
v1 = random_vector()
v2 = random_vector()
rotate_vector(v1, v2)
except Exception as e:
fail(e)
check()
print(" are_equal")
try:
from pyxtal.operations import are_equal
except Exception as e:
fail(e)
if passed():
try:
op1 = SymmOp.from_xyz_string("x,y,z")
op2 = SymmOp.from_xyz_string("x,y,z+1")
a = are_equal(op1, op2, PBC=[0, 0, 1])
b = are_equal(op1, op2, PBC=[1, 0, 0])
if a is True and b is False:
pass
else:
fail()
except Exception as e:
fail(e)
check()
print(" class OperationAnalyzer")
try:
from pyxtal.operations import OperationAnalyzer
except Exception as e:
fail(e)
if passed():
try:
for i in range(10):
m = aa2matrix(1, 1, random=True)
t = random_vector()
op1 = SymmOp.from_rotation_and_translation(m, t)
OperationAnalyzer(op1)
except Exception as e:
fail(e)
check()
print(" class Orientation")
try:
from pyxtal.operations import Orientation
except Exception as e:
fail(e)
if passed():
try:
for i in range(10):
v1 = random_vector()
c1 = random_vector()
o = Orientation.from_constraint(v1, c1)
except Exception as e:
fail(e)
check()
# =====symmetry=====
print("pyxtal.symmetry")
reset()
try:
import pyxtal.symmetry
except Exception as e:
fail(e)
print(" get_wyckoffs (may take a moment)")
try:
from pyxtal.symmetry import get_wyckoffs
except Exception as e:
fail(e)
if passed():
try:
for i in [1, 2, 229, 230]:
get_wyckoffs(i)
get_wyckoffs(i, organized=True)
except:
fail(" Could not access Wyckoff positions for space group # " +
str(i))
check()
print(" get_wyckoff_symmetry (may take a moment)")
try:
from pyxtal.symmetry import get_wyckoff_symmetry
except Exception as e:
fail(e)
if passed():
try:
for i in [1, 2, 229, 230]:
get_wyckoff_symmetry(i)
get_wyckoff_symmetry(i, molecular=True)
except:
fail("Could not access Wyckoff symmetry for space group # " +
str(i))
check()
print(" get_wyckoffs_generators (may take a moment)")
try:
from pyxtal.symmetry import get_wyckoff_generators
except Exception as e:
fail(e)
if passed():
try:
for i in [1, 2, 229, 230]:
get_wyckoff_generators(i)
except:
fail("Could not access Wyckoff generators for space group # " +
str(i))
check()
print(" letter_from_index")
try:
from pyxtal.symmetry import letter_from_index
except Exception as e:
fail(e)
if passed():
try:
if letter_from_index(0, get_wyckoffs(47)) == "A":
pass
else:
fail()
except Exception as e:
fail(e)
check()
print(" index_from_letter")
try:
from pyxtal.symmetry import index_from_letter
except Exception as e:
fail(e)
if passed():
try:
if index_from_letter("A", get_wyckoffs(47)) == 0:
pass
else:
fail()
except Exception as e:
fail(e)
check()
print(" jk_from_i")
try:
from pyxtal.symmetry import jk_from_i
except Exception as e:
fail(e)
if passed():
try:
w = get_wyckoffs(2, organized=True)
j, k = jk_from_i(1, w)
if j == 1 and k == 0:
pass
else:
print(j, k)
fail()
except Exception as e:
fail(e)
check()
print(" i_from_jk")
try:
from pyxtal.symmetry import i_from_jk
except Exception as e:
fail(e)
if passed():
try:
w = get_wyckoffs(2, organized=True)
j, k = jk_from_i(1, w)
i = i_from_jk(j, k, w)
if i == 1:
pass
else:
print(j, k)
fail()
except Exception as e:
fail(e)
check()
print(" ss_string_from_ops")
try:
from pyxtal.symmetry import ss_string_from_ops
except Exception as e:
fail(e)
if passed():
try:
strings = ["1", "4 . .", "2 3 ."]
for i, sg in enumerate([1, 75, 195]):
ops = get_wyckoffs(sg)[0]
ss_string_from_ops(ops, sg, dim=3)
except Exception as e:
fail(e)
check()
print(" Wyckoff_position")
try:
from pyxtal.symmetry import Wyckoff_position
except Exception as e:
fail(e)
if passed():
try:
wp = Wyckoff_position.from_group_and_index(20, 1)
except Exception as e:
fail(e)
check()
print(" Group")
try:
from pyxtal.symmetry import Group
except Exception as e:
fail(e)
if passed():
try:
g3 = Group(230)
g2 = Group(80, dim=2)
g1 = Group(75, dim=1)
except Exception as e:
fail(e)
check()
# =====crystal=====
print("pyxtal.crystal")
reset()
try:
import pyxtal.crystal
except Exception as e:
fail(e)
print(" random_crystal")
try:
from pyxtal.crystal import random_crystal
except Exception as e:
fail(e)
if passed():
try:
c = random_crystal(1, ["H"], [1], 10.0)
if c.valid is True:
pass
else:
fail()
except Exception as e:
fail(e)
check()
print(" random_crystal_2D")
try:
from pyxtal.crystal import random_crystal_2D
except Exception as e:
fail(e)
if passed():
try:
c = random_crystal_2D(1, ["H"], [1], 10.0)
if c.valid is True:
pass
else:
fail()
except Exception as e:
fail(e)
check()
# =====molecule=====
print("pyxtal.molecule")
reset()
try:
import pyxtal.molecule
except Exception as e:
fail(e)
check()
print(" Collections")
try:
from pyxtal.molecule import mol_from_collection
except Exception as e:
fail(e)
if passed():
try:
h2o = mol_from_collection("H2O")
ch4 = mol_from_collection("CH4")
except Exception as e:
fail(e)
print(" get_inertia_tensor")
try:
from pyxtal.molecule import get_inertia_tensor
except Exception as e:
fail(e)
if passed():
try:
get_inertia_tensor(h2o)
get_inertia_tensor(ch4)
except Exception as e:
fail(e)
check()
print(" get_moment_of_inertia")
try:
from pyxtal.molecule import get_moment_of_inertia
except Exception as e:
fail(e)
if passed():
try:
v = random_vector()
get_moment_of_inertia(h2o, v)
get_moment_of_inertia(ch4, v)
except Exception as e:
fail(e)
check()
print(" reoriented_molecule")
try:
from pyxtal.molecule import reoriented_molecule
except Exception as e:
fail(e)
if passed():
try:
reoriented_molecule(h2o)
reoriented_molecule(ch4)
except Exception as e:
fail(e)
check()
print(" orientation_in_wyckoff_position")
try:
from pyxtal.molecule import orientation_in_wyckoff_position
except Exception as e:
fail(e)
if passed():
try:
w = get_wyckoffs(20)
ws = get_wyckoff_symmetry(20, molecular=True)
wp = Wyckoff_position.from_group_and_index(20, 1)
orientation_in_wyckoff_position(h2o, wp)
orientation_in_wyckoff_position(ch4, wp)
except Exception as e:
fail(e)
check()
# =====molecular_crystal=====
print("pyxtal.molecular_crystal")
reset()
try:
import pyxtal.crystal
except Exception as e:
fail(e)
print(" molecular_crystal")
try:
from pyxtal.molecular_crystal import molecular_crystal
except Exception as e:
fail(e)
if passed():
try:
c = molecular_crystal(1, ["H2O"], [1], 10.0)
if c.valid is True:
pass
else:
fail()
except Exception as e:
fail(e)
check()
print(" molecular_crystal_2D")
try:
from pyxtal.molecular_crystal import molecular_crystal_2D
except Exception as e:
fail(e)
if passed():
try:
c = molecular_crystal_2D(1, ["H2O"], [1], 10.0)
if c.valid is True:
pass
else:
fail()
except Exception as e:
fail(e)
check()
end(condition=2)
if len(new_coords) == 0:
new_coords = wp_coords
else:
new_coords = np.vstack([new_coords, wp_coords])
start_index += ws.multiplicity
return new_coords
# Set global variables
dim = 0
# from pyxtal.interface.LJ import LJ, LJ_force
from pyxtal.database.collection import Collection
np.random.seed(10)
pos = np.array(Collection("clusters")["20"]["position"]["data"])
# Generate a random cluster with random point group
from pyxtal.crystal import *
from copy import deepcopy
pg = random.choice(range(1, 57))
c = random_cluster(pg, ["C"], [20], 0.7)
pos = c.cart_coords
# maxr = 0
# for p in pos:
# r = np.linalg.norm(p)
# if r > maxr:
# maxr = r
# print("maxr: "+str(maxr))
if len(new_coords) == 0:
new_coords = wp_coords
else:
new_coords = np.vstack([new_coords, wp_coords])
start_index += ws.multiplicity
return new_coords
#Set global variables
dim = 0
#from pyxtal.interface.LJ import LJ, LJ_force
from pyxtal.database.collection import Collection
np.random.seed(10)
pos = np.array(Collection('clusters')['20']['position']['data'])
#Generate a random cluster with random point group
from pyxtal.crystal import *
from copy import deepcopy
pg = random.choice(range(1, 57))
c = random_cluster(pg, ['C'], [20], 0.7)
pos = c.cart_coords
#maxr = 0
#for p in pos:
# r = np.linalg.norm(p)
# if r > maxr:
# maxr = r
#print("maxr: "+str(maxr))