def runtestgeo(tmpdir, name, thresh, deleteH=True, geo_type="oct"):
initgeo = resource_filename(Requirement.parse("molSimplify"),
"tests/inputs/geocheck/" + name + "/init.xyz")
optgeo = resource_filename(Requirement.parse("molSimplify"),
"tests/inputs/geocheck/" + name + "/opt.xyz")
refjson = resource_filename(Requirement.parse("molSimplify"),
"tests/refs/geocheck/" + name + "/ref.json")
mymol = mol3D()
mymol.readfromxyz(optgeo)
init_mol = mol3D()
init_mol.readfromxyz(initgeo)
if geo_type == "oct":
_, _, dict_struct_info = mymol.IsOct(init_mol=init_mol,
debug=False,
flag_deleteH=deleteH)
elif geo_type == "one_empty":
_, _, dict_struct_info = mymol.IsStructure(
init_mol=init_mol,
dict_check=dict_oneempty_check_st,
angle_ref=oneempty_angle_ref,
num_coord=5,
debug=False,
flag_deleteH=deleteH)
with open(refjson, "r") as fo:
dict_ref = json.load(fo)
# passGeo = (sorted(dict_ref.items()) == sorted(dict_struct_info.items()))
print("ref: ", dict_ref)
print("now: ", dict_struct_info)
passGeo = comparedict(dict_ref, dict_struct_info, thresh)
return passGeo
def getAllLigands(xyz):
mymol3d = mol3D()
mymol3d.readfromxyz(xyz)
# OUTPUT
# -mol3D: mol3D of all ligands
mm = mymol3d.findMetal()[0]
mbonded = mymol3d.getBondedAtoms(mm)
ligands=[]
ligAtoms=[]
#Get the 1st atom of one ligand
for iatom in mbonded:
if iatom not in ligAtoms:
lig = [iatom]
oldlig = []
while len(lig) > len(oldlig):
#make a copy of lig
oldlig = lig[:]
for i in oldlig:
lbonded = mymol3d.getBondedAtoms(i)
for j in lbonded:
if (j != mm) and (j not in lig):
lig.append(j)
newlig = mol3D()
for i in lig:
newlig.addAtom(mymol3d.atoms[i])
ligAtoms.append(i)
ligands.append(newlig)
print "Ligand analysis of xyz file: ",xyz
print "There are ",len(ligands)," ligand(s) bonded with metal center\
",mm," in the complex"
for i in range(0,len(ligands)):
print "Number of atoms in ligand # ",i," : ",ligands[i].natoms
return ligands
def getAllLigands(xyz):
mymol3d = mol3D()
mymol3d.readfromxyz(xyz)
# OUTPUT
# -mol3D: mol3D of all ligands
mm = mymol3d.findMetal()[0]
mbonded = mymol3d.getBondedAtoms(mm)
ligands = []
ligAtoms = []
# Get the 1st atom of one ligand
for iatom in mbonded:
if iatom not in ligAtoms:
lig = [iatom]
oldlig = []
while len(lig) > len(oldlig):
# make a copy of lig
oldlig = lig[:]
for i in oldlig:
lbonded = mymol3d.getBondedAtoms(i)
for j in lbonded:
if (j != mm) and (j not in lig):
lig.append(j)
newlig = mol3D()
for i in lig:
newlig.addAtom(mymol3d.atoms[i])
ligAtoms.append(i)
ligands.append(newlig)
print("Ligand analysis of xyz file: ", xyz)
print("There are ", len(ligands), " ligand(s) bonded with metal center\
", mm, " in the complex")
for i in range(0, len(ligands)):
print("Number of atoms in ligand # ", i, " : ", ligands[i].natoms)
return ligands
def get_geo_metrics(init_mol, job_info, geofile):
mol_now = read_geometry_to_mol(geofile)
dict_geo_metrics = {}
info_list = ['flag_oct']
dict_info = ['inspect_oct_angle_devi_max', 'inspect_max_del_sig_angle',
'inspect_dist_del_all', 'inspect_dist_del_eq', 'inspect_devi_linear_avrg',
'inspect_devi_linear_max']
actural_dict_info = ['actural_rmsd_max']
mol = mol3D()
mol.copymol3D(mol_now)
inspect_flag, _, dict_oct, inspect_flag_loose, _ = mol.Oct_inspection(init_mol=init_mol,
catoms_arr=job_info['catoms'])
_mol = mol3D()
_mol.copymol3D(mol_now)
flag_oct, _, dict_oct_info = _mol.IsOct(init_mol=init_mol)
actural_dict_geo = {}
inspect_dict_geo = {}
for key in dict_oct_info:
val = dict_oct_info[key] if (dict_oct_info[key] != -1) and (dict_oct_info[key] != "lig_mismatch") else 1.20 * dict_oct_check_st[key]
actural_dict_geo['actural_%s' % key] = val
for key in dict_oct:
inspect_dict_geo['inspect_%s' % key] = dict_oct[key]
for info in info_list:
dict_geo_metrics.update({info: locals()[info]})
for info in dict_info:
dict_geo_metrics.update({info: inspect_dict_geo[info]})
for info in actural_dict_info:
dict_geo_metrics.update({info: actural_dict_geo[info]})
return dict_geo_metrics
def compareNumAtoms(xyz1,xyz2):
print "Checking total number of atoms"
mol1 = mol3D()
mol1.readfromxyz(xyz1)
mol2 = mol3D()
mol2.readfromxyz(xyz1)
# Compare number of atoms
passNumAtoms = (mol1.natoms == mol2.natoms)
print "Pass total number of atoms check: ",passNumAtoms
return passNumAtoms
def freeze_bottom_n_layers(super_cell, n):
frozen_cell = mol3D()
frozen_cell.copymol3D(super_cell)
counter = 0
while counter < n:
frozen_cell_new = freeze_under_layer(frozen_cell)
frozen_cell = mol3D()
frozen_cell.copymol3D(frozen_cell_new)
counter += 1
return frozen_cell
def compareNumAtoms(xyz1, xyz2):
print("Checking total number of atoms")
mol1 = mol3D()
mol1.readfromxyz(xyz1)
mol2 = mol3D()
mol2.readfromxyz(xyz1)
# Compare number of atoms
passNumAtoms = (mol1.natoms == mol2.natoms)
print("Pass total number of atoms check: ", passNumAtoms)
return passNumAtoms
def obtain_mol3d(self):
new_mol = mol3D()
this_mol = mol3D()
this_mol.readfromxyz(self.geopath)
if this_mol.natoms > 0:
self.mol = this_mol
self.natoms = this_mol.natoms
self.health = True
else:
self.comments.append('geo file appears empty')
self.health = False
def fuzzy_compare_xyz(xyz1, xyz2, thresh):
fuzzyEqual = False
mol1 = mol3D()
mol1.readfromxyz(xyz1)
mol2 = mol3D()
mol2.readfromxyz(xyz2)
mol1, U, d0, d1 = kabsch(mol1, mol2)
rmsd12 = mol1.rmsd(mol2)
print(('rmsd is ' + '{0:.2f}'.format(rmsd12)))
if rmsd12 < thresh:
fuzzyEqual = True
return fuzzyEqual
def fuzzy_compare_xyz(xyz1,xyz2,thresh):
fuzzyEqual=False
mol1 = mol3D()
mol1.readfromxyz(xyz1)
mol2 = mol3D()
mol2.readfromxyz(xyz2)
mol1,U,d0,d1 = kabsch(mol1,mol2)
rmsd12 = mol1.rmsd(mol2)
print('rmsd is ' +'{0:.2f}'.format(rmsd12))
if rmsd12 < thresh:
fuzzyEqual=True
return fuzzyEqual
def process_geometry_optimizations(this_run, basedir, outfile, output):
energy, ss_act, ss_target, tot_time, thermo_grad_error, solvent_cont, tot_step = output.wordgrab(
['FINAL', 'S-SQUARED:', 'S-SQUARED:', 'processing', 'Maximum component of gradient is too large',
'C-PCM contribution to final energy:', 'Optimization Cycle'],
[2, 2, 4, 3, 0, 4, 3], last_line=True)
check_conv(this_run, tot_time, energy, output)
this_run.geo_opt = True
scrpath = basedir + '/scr/'
optimpath = scrpath + 'optim.xyz'
this_run.scrpath = optimpath
if this_run.converged:
if os.path.getsize(optimpath) > 45:
this_run.init_energy = float(output.wordgrab(['FINAL ENERGY'], 'whole_line')[0][0][2])
try:
extract_optimized_geo(optimpath)
this_run.geopath = scrpath + 'optimized.xyz'
except:
this_run.geopath = optimpath
if os.path.isfile(outfile):
diople_vec, diople_moment = grab_dipole_moment(outfile)
this_run.diople_vec = diople_vec
this_run.diople_moment = diople_moment
else:
raise ValueError("Output file does not exist: ", outfile)
read_molden_file(this_run)
obtain_wavefunction_molden(this_run)
this_run.init_mol = mol3D()
this_run.init_mol.readfromtxt(get_initgeo(optimpath))
this_run.mol = mol3D()
this_run.mol.readfromtxt(get_lastgeo(optimpath))
try:
use_initmol = False if (this_run.iscsd or this_run.isMutation) else True
this_run.check_oct_needs_init(debug=False, external=True, use_initmol=use_initmol)
except:
print("Warning: falied get geo_check!!!")
### Note that we should put get_ligsymmetry_graphdet to avoid building the graph for this_run.init_mol before the geocheck
this_run.init_ligand_symmetry, this_run.init_mol_graph_det = get_ligsymmetry_graphdet(this_run.init_mol)
this_run.ligand_symmetry, this_run.mol_graph_det = get_ligsymmetry_graphdet(this_run.mol)
this_run.obtain_rsmd()
this_run.obtain_ML_dists()
this_run.get_check_flags()
this_run.get_optimization_time_step(current_path=outfile)
if this_run.geo_flag:
this_run.status = 0
else:
this_run.status = 1
else:
print(("Warning: optim file %s is empty. Skipping this run." % optimpath))
this_run.converged = False
else:
this_run.status = 7
return this_run
def assemble_connectivity_from_parts(metal_mol, custom_ligand_dict):
## custom_ligand_dict.keys() must be eq_ligands_list, ax_ligand_list
## ax_con_int_list ,eq_con_int_list
## with types: eq/ax_ligand2_list list of mol3D
## eq/ax_con_int_list list of list/tuple of int e.g, [[1,2] [1,2]]
blank_mol = mol3D()
# start with the connectivity matrix of the whole comlpex
n_total = 1+ sum(m.mol.natoms for m in custom_ligand_dict["eq_ligand_list"]) + \
sum(m.mol.natoms for m in custom_ligand_dict["ax_ligand_list"])
con_mat = np.zeros((n_total, n_total))
this_complex = mol3D()
this_complex.copymol3D(metal_mol)
live_row = 1 # metal goes in row 0
for i, class_lig in enumerate(custom_ligand_dict["eq_ligand_list"]):
this_lig = class_lig.mol
this_dim = this_lig.natoms
this_con = custom_ligand_dict["eq_con_int_list"][i]
this_lig.convert2OBMol()
this_lig.createMolecularGraph()
con_mat[live_row:live_row + this_dim,
live_row:live_row + this_dim] = this_lig.graph
for con_atoms in this_con:
con_mat[0, live_row + con_atoms] = 1
con_mat[live_row + con_atoms, 0] = 1
live_row = live_row + this_dim
this_complex.combine(this_lig, [], dirty=True)
for i, class_lig in enumerate(custom_ligand_dict["ax_ligand_list"]):
this_lig = class_lig.mol
this_dim = this_lig.natoms
this_con = custom_ligand_dict["ax_con_int_list"][i]
this_lig.convert2OBMol()
this_lig.createMolecularGraph()
con_mat[live_row:live_row + this_dim,
live_row:live_row + this_dim] = this_lig.graph
for con_atoms in this_con:
con_mat[0, live_row + con_atoms] = 1
con_mat[live_row + con_atoms, 0] = 1
live_row = live_row + this_dim
this_complex.combine(this_lig, [], dirty=True)
if not int(sum(con_mat[:, 0])) == 6:
print('coordination number is ' + str(sum(con_mat[:, 0])))
print('error, not oct ')
sys.exit()
# overwrite the connectivity matrix
this_complex.graph = con_mat
return this_complex
def substplaceff_mode3(core, substr, substreact, compreact, cpoint, args, connected, frozenats):
enc = 0
# align substrate according to connection atom and shadow atom
substr.alignmol(substr.getAtom(substreact), atom3D('H', cpoint))
# perform rotations
Bcoords = core.getAtomCoords(compreact)
adjsidx = substr.getBondedAtoms(substreact)[0]
if substr.natoms > 1:
# align ligand center of symmetry
substr = align_lig_centersym(Bcoords, substr, substreact, core, False)
if substr.natoms > 2:
# check for linear molecule and align
substr = check_rotate_linear_lig(Bcoords, substr, substreact)
# check for symmetric molecule
substr = check_rotate_symm_lig(Bcoords, substr, substreact, core)
# rotate around M-L axis to minimize steric repulsion
substr = rotate_MLaxis_minimize_steric(
Bcoords, substr, substreact, core)
# distort substrate molecule
adjsidx = substr.getBondedAtoms(substreact)[0]
XYBL = XYcoeff*(substr.getAtom(substreact).rad +
substr.getAtom(adjsidx).rad)
substr.BCM(adjsidx, substreact, XYBL)
# combine molecules
ts3D = mol3D()
ts3D.copymol3D(core)
ts3D = ts3D.combine(substr)
ts3D.charge += substr.charge
if 'a' in args.ffoption or args.substplaceff:
ts3D, enc = ffopt(args.ff, ts3D, connected, 1,
frozenats, False, [], 'Adaptive')
return ts3D, enc
def __init__(self, infile, active_sites=None):
# also, molecule no longer explicitly optimized in this function
self.infile = infile
infile_type = self.infile.split('.')[-1]
print(self.infile)
self.OH_bond_length = 0.975
self.molecule = mol3D.mol3D()
self.molecule.OBMol = self.molecule.getOBMol(infile,
infile_type,
ffclean=False)
self.molecule.convert2mol3D()
if active_sites == None:
self.active_sites = self.standardActiveSites()
else:
self.active_sites = active_sites
self.bond_length_cutoffs = {
'C': 1.953,
'H': 1.443,
'I': 2.543,
'Cl': 2.154,
'B': 2.027,
'N': 1.834,
'F': 1.707,
'Br': 2.423,
'P': 2.297,
'S': 2.198,
'O': 1.810
} # X-O (angstroms)
self.dtheta = 5 # change this if you want to
self.binding_dict = {'O2': self.bindO2, 'O': self.bindO, 'OH': self.bindOH, 'O2H': self.bindO2H, 'CN' : self.bindCN, \
'CO': self.bindCO}
def get_metal_and_bonded_atoms(job_outfile, geometry=None):
"""Get metal and bonded atoms of complex.
Parameters
----------
job_outfile : str
Path for output file.
geometry : str, optional
Type of geometry to define metal bonding. Default is None.
Returns
-------
geo_flag : bool
Flag describing geometry. True if good geometry.
"""
# given the path to the outfile of a job, returns a the metal atom index and a list of indices for the metal bonded atoms
# indices are zero-indexed...Terachem uses 1 indexed lists
xyz_path = job_outfile.rsplit('.', 1)[0] + '.xyz'
mol = mol3D()
mol.readfromxyz(xyz_path)
metal_index = mol.findMetal()[0]
if geometry in ['Oct', 'oct', 'Octahedral', 'octahedral']:
bonded_atom_indices = mol.getBondedAtomsOct(metal_index)
else:
print('Warning, generic getBondedAtoms() used for: ' + job_outfile + '. Check behavior')
bonded_atom_indices = mol.getBondedAtoms(metal_index)
return metal_index, bonded_atom_indices
def compareMLBL(xyz1,xyz2,thresh):
print "Checking metal-ligand bond length"
mol1 = mol3D()
mol1.readfromxyz(xyz1)
mol2 = mol3D()
mol2.readfromxyz(xyz1)
bl1 = getMetalLigBondLength(mol1)
bl2 = getMetalLigBondLength(mol2)
passMLBL =True
for i in range(0,len(bl1)):
if not fuzzy_equal(bl1[i],bl2[i],thresh):
print "Error! Metal-Ligand bondlength mismatch for bond # ",i
passMLBL = False
print "Pass metal-ligand bond length check: ",passMLBL
print "Threshold for bondlength difference: ",thresh
return passMLBL
def xyz2gxyz(filename):
# convert normal xyz file to gamess format
mol = mol3D() # create mol3D object
mol.readfromxyz(filename) # read molecule
gfilename = filename.replace('.xyz', '.gxyz') # new file name
mol.writegxyz(gfilename) # write gamess formatted xyz file
return gfilename.split('.gxyz')[0]
def check_top_layer_correct(super_cell, atom_type):
# remove the layer on
# top of the cell if
# wrong material is exposed
trimmed_cell = mol3D()
trimmed_cell.copymol3D(super_cell)
globs = globalvars()
elements = globs.elementsbynum()
print(('chekcing surface for ' + atom_type + '\n'))
if not atom_type in elements:
print("unkown surface type, unable to trim ")
return trimmed_cell
else:
stop_flag = False
counter = 0 # 3 tries max
while not stop_flag:
atom_type_surf = find_all_surface_atoms(
trimmed_cell, tol=1e-3, type_of_atom=atom_type)
top_surf = find_all_surface_atoms(
trimmed_cell, tol=1e-3, type_of_atom=False)
# print("top surf",top_surf)
# print("atom top surf",atom_type_surf)
if set(atom_type_surf) == set(top_surf):
print('match')
stop_flag = True
else:
counter += 1
trimmed_cell = shave_surface_layer(trimmed_cell, 1e-3)
if counter == 3:
print('unable to find target atom in 3 cuts')
stop_flag = True
return trimmed_cell
def compareMLBL(xyz1, xyz2, thresh):
print("Checking metal-ligand bond length")
mol1 = mol3D()
mol1.readfromxyz(xyz1)
mol2 = mol3D()
mol2.readfromxyz(xyz1)
bl1 = getMetalLigBondLength(mol1)
bl2 = getMetalLigBondLength(mol2)
passMLBL = True
for i in range(0, len(bl1)):
if not fuzzy_equal(bl1[i], bl2[i], thresh):
print("Error! Metal-Ligand bondlength mismatch for bond # ", i)
passMLBL = False
print("Pass metal-ligand bond length check: ", passMLBL)
print("Threshold for bondlength difference: ", thresh)
return passMLBL
def shave__type(super_cell, dim, mode):
## dim = 0,1,2
# x,y,z
# mode = 1 for max, -1 for min
shaved_cell = mol3D()
shaved_cell.copymol3D(super_cell)
TOL = 1e-1
dim_ref = 1000
if (mode == -1):
for i, atoms in enumerate(super_cell.getAtoms()):
coords = atoms.coords()
if (coords[dim] < dim_ref):
dim_ref = coords[dim]
del_list = list()
for i, atoms in enumerate(super_cell.getAtoms()):
coords = atoms.coords()
if abs(coords[dim] - dim_ref) < TOL:
del_list.append(i)
if (mode == 1):
extents = find_extents(super_cell)
dim_max = extents[dim]
del_list = list()
for i, atoms in enumerate(super_cell.getAtoms()):
coords = atoms.coords()
if abs(coords[dim] - dim_max) < TOL:
del_list.append(i)
# return
shaved_cell.deleteatoms(del_list)
return shaved_cell
def read_run(outfile_PATH):
# Evaluates all aspects of a run using the outfile and derivative files
results = manager_io.read_outfile(outfile_PATH, long_output=True)
infile_dict = manager_io.read_infile(outfile_PATH)
results['levela'], results['levelb'] = infile_dict['levelshifta'], infile_dict['levelshiftb']
results['method'], results['hfx'] = infile_dict['method'], infile_dict['hfx']
results['constraints'] = infile_dict['constraints']
mullpop_path = os.path.join(os.path.split(outfile_PATH)[0], 'scr', 'mullpop')
if os.path.exists(mullpop_path):
mullpops = manager_io.read_mullpop(outfile_PATH)
metal_types = ['Cr', 'Mn', 'Fe', 'Co', 'Ni', 'Mo', 'Tc', 'Ru', 'Rh']
metals = [i for i in mullpops if i.split()[0] in metal_types]
if len(metals) > 1:
results['metal_spin'] = np.nan
elif len(metals) == 0:
pass
else:
results['metal_spin'] = float(metals[0].split()[-1])
else:
results['metal_spin'] = np.nan
optim_path = os.path.join(os.path.split(outfile_PATH)[0], 'scr', 'optim.xyz')
check_geo = False
if os.path.isfile(optim_path):
fil = open(optim_path, 'r')
lines = fil.readlines()
fil.close()
if len(lines) > 0:
check_geo = True # Only apply geo check if an optimized geometry exists
if check_geo:
tools.extract_optimized_geo(optim_path)
optimized_path = os.path.join(os.path.split(optim_path)[0], 'optimized.xyz')
mol = mol3D()
mol.readfromxyz(optimized_path)
IsOct, flag_list, oct_check = mol.IsOct(dict_check=mol.dict_oct_check_st,
silent=True)
if IsOct:
IsOct = True
else:
IsOct = False
results['Is_Oct'] = IsOct
results['Flag_list'] = flag_list
results['Oct_check_details'] = oct_check
else:
results['Is_Oct'] = None
results['Flag_list'] = None
results['Oct_check_details'] = None
return results
def read_geometry_to_mol(geofile):
with open(geofile, 'r') as fo:
num_atoms = int(fo.readline().split()[0])
num_lines = num_atoms + 2 ## +2 for the xyz format.
with open(geofile, 'r') as fo:
geotext = fo.readlines()[-num_lines:]
mol = mol3D()
mol.readfromtxt(geotext)
return mol
def change_basis(mol, old_basis, new_basis):
new_mol = mol3D()
new_mol.copymol3D(mol)
point_coefficients = [get_basis_coefficients(
at.coords(), old_basis) for at in new_mol.getAtoms()]
new_points = [get_basis_coefficients(
point, new_basis) for point in point_coefficients]
for i, at in enumerate(new_mol.getAtoms()):
at.setcoords(new_points[i])
return new_mol
def zero_x(super_cell):
zeroed_cell = mol3D()
zeroed_cell.copymol3D(super_cell)
TOL = 1e-1
xmin = 1000
for i, atoms in enumerate(super_cell.getAtoms()):
coords = atoms.coords()
if (coords[0] < xmin):
xmin = coords[0]
zeroed_cell.translate([-1*xmin, 0, 0])
return zeroed_cell
def zero_z(super_cell):
zeroed_cell = mol3D()
zeroed_cell.copymol3D(super_cell)
TOL = 1e-1
zmin = 1000
for i, atoms in enumerate(super_cell.getAtoms()):
coords = atoms.coords()
if (coords[2] < zmin):
zmin = coords[2]
zeroed_cell.translate([0, 0, -1*zmin])
return zeroed_cell
def process_single_points(this_run, basedir, output):
energy, ss_act, ss_target, tot_time, thermo_grad_error, solvent_cont, tot_step = output.wordgrab(
['FINAL', 'S-SQUARED:', 'S-SQUARED:', 'processing', 'Maximum component of gradient is too large',
'C-PCM contribution to final energy:', 'Optimization Cycle'],
[2, 2, 4, 3, 0, 4, 3], last_line=True)
this_run.geo_opt = False
this_run.converged = True if not energy == None else False
if this_run.converged:
this_run.tot_step = tot_step
this_run.init_energy = energy
scrpath = basedir + '/scr/'
optimpath = scrpath + 'xyz.xyz'
this_run.scrpath = optimpath
this_run.init_mol = mol3D()
this_run.init_mol.readfromtxt(get_initgeo(optimpath))
this_run.mol = mol3D()
this_run.mol.readfromtxt(get_initgeo(optimpath))
obtain_wavefunction_molden(this_run)
read_molden_file(this_run)
return this_run
def zero_y(super_cell):
zeroed_cell = mol3D()
zeroed_cell.copymol3D(super_cell)
TOL = 1e-1
ymin = 1000
for i, atoms in enumerate(super_cell.getAtoms()):
coords = atoms.coords()
if (coords[1] < ymin):
ymin = coords[1]
zeroed_cell.translate([0, -1*ymin, 0])
return zeroed_cell
def common_processing(jobname, basedir, output, outfile, spin,
dbname=False, gene=False):
dbname = jobname if dbname == False else dbname
this_run = DFTRun(dbname, external=True)
this_run.name = dbname
this_run.octahedral = True
if gene != False:
# Assigns a gene, which is used during design
temp_name = "_".join(jobname.split('_')[0:13]) #stops before job manager extra keywords
translate_dict = translate_job_name(temp_name)
this_run.gene = translate_dict['gene']
energy, ss_act, ss_target, tot_time, thermo_grad_error, solvent_cont, tot_step, d3_energy = output.wordgrab(
['FINAL', 'S-SQUARED:', 'S-SQUARED:', 'processing', 'Maximum component of gradient is too large',
'C-PCM contribution to final energy:', 'Optimization Cycle', 'DFTD Dispersion Correction:'],
[2, 2, 4, 3, 0, 4, 3, -2], last_line=True)
iscsd = isCSD(dbname)
this_run.isMutation = isMutation(dbname)
this_run.iscsd = iscsd
this_run.charge = output.wordgrab(['Total charge'], -1)[0][0]
try:
this_run.charge = int(this_run.charge)
except:
this_run.charge = False
if not d3_energy == None:
this_run.d3opt_flag = True
else:
this_run.d3_energy = np.nan
this_run.d3opt_flag = False
if not (this_run.iscsd or this_run.isMutation):
print(("jobname: ", dbname))
bind_complex_info(this_run, dbname, spin)
else:
init_mol = mol3D()
init_mol.readfromxyz(basedir + '/%s.xyz' % jobname)
bind_csd_info(this_run, dbname, spin, init_mol)
this_run.outpath = outfile
this_run.tot_time = tot_time
this_run.alpha = output.wordgrab(['Hartree-Fock exact exchange:'], -1)[0][0] * 100
this_run.functional = output.wordgrab(['DFT Functional requested:'], -1)[0][0]
this_run.terachem_version = output.wordgrab(['TeraChem'], 2)[0][0]
this_run.alpha_level_shift = output.wordgrab(['Alpha level shift'], -1)[0][0]
this_run.beta_level_shift = output.wordgrab(['Beta level shift'], -1)[0][0]
this_run.basis = output.wordgrab(['Using basis set:'], -1)[0][0]
if not energy == None:
this_run.energy = float(energy)
else:
this_run.energy = np.nan
this_run = collect_spin_info(this_run, spin, ss_act, ss_target)
scrpath = basedir + '/scr/'
this_run.scrpath_real = scrpath
if os.path.isdir(this_run.scrpath_real):
calculate_mulliken_spins(this_run)
return this_run
def get_geo_metrics(init_mol, job_info, geofile, frame=-1):
mol_now = read_geometry_to_mol(geofile, frame=frame)
dict_geo_metrics = {}
info_list = ['flag_oct']
dict_info = [
'inspect_oct_angle_devi_max', 'inspect_max_del_sig_angle',
'inspect_dist_del_all', 'inspect_dist_del_eq',
'inspect_devi_linear_avrg', 'inspect_devi_linear_max'
]
actural_dict_info = ['actural_rmsd_max']
mol = mol3D()
mol.copymol3D(mol_now)
inspect_flag, _, dict_oct, inspect_flag_loose, _ = mol.Oct_inspection(
init_mol=init_mol, catoms_arr=job_info['catoms'])
_mol = mol3D()
_mol.copymol3D(mol_now)
flag_oct, _, dict_oct_info = _mol.IsOct(init_mol=init_mol)
eqsym, maxdent, ligdents, homoleptic, ligsym = init_mol.get_symmetry_denticity(
)
if not maxdent > 1:
choice = 'mono'
else:
choice = 'multi'
actural_dict_geo = {}
inspect_dict_geo = {}
for key in dict_oct_info:
val = dict_oct_info[key] if (dict_oct_info[key] != -1) and (dict_oct_info[key] != "lig_mismatch") else 1.20 * \
dict_oct_check_st[
choice][
key]
actural_dict_geo['actural_%s' % key] = val
for key in dict_oct:
inspect_dict_geo['inspect_%s' % key] = dict_oct[key]
for info in info_list:
dict_geo_metrics.update({info: locals()[info]})
for info in dict_info:
dict_geo_metrics.update({info: inspect_dict_geo[info]})
for info in actural_dict_info:
dict_geo_metrics.update({info: actural_dict_geo[info]})
return dict_geo_metrics
def runtestgeo_optonly(tmpdir, name, thresh, deleteH=True, geo_type="oct"):
optgeo = resource_filename(Requirement.parse("molSimplify"),
"tests/inputs/geocheck/" + name + "/opt.xyz")
refjson = resource_filename(Requirement.parse("molSimplify"),
"tests/refs/geocheck/" + name + "/ref.json")
mymol = mol3D()
mymol.readfromxyz(optgeo)
if geo_type == "oct":
_, _, dict_struct_info = mymol.IsOct(debug=False, flag_deleteH=deleteH)
with open(refjson, "r") as fo:
dict_ref = json.load(fo)
passGeo = comparedict(dict_ref, dict_struct_info, thresh)
return passGeo
def fvalency(xyzf):
# setting properties
xyz = mol3D()
xyz.readfromxyz(xyzf)
# getting idxs of interest
midx = xyz.findMetal()[0] # monometallic complexes
# list of idx of the first-coord sphere
fidx_list = xyz.getBondedAtoms(midx)
fvalency_list = []
for idx in fidx_list:
valency = len(xyz.getBondedAtoms(idx)) - 1
fvalency_list.append(valency)
return fvalency_list
def FillMatchedO2(self, qdatas, energy, cat_fn, AS_CHELPG):
for i, entry in enumerate(self.catO2_df["CatalystO2_File_Name"]):
catO2_entry_name = catalyst_name(entry)
for qdata in qdatas:
if qdata.filename.split('_')[0] == catO2_entry_name:
#if qdata.filename.split('_')[1] == entry.split('_')[1]:
self.catO2_df.at[i, energy] = qdata.E
self.catO2_df.at[i, cat_fn] = qdata.filename
try:
chelpgs = qdata.chelpg
active_site_index = self.catO2_df.iloc[i][
'Active_Site']
self.catO2_df.at[i,
AS_CHELPG] = chelpgs[active_site_index
- 1]
except Exception as e:
print("Could not get CHELPG charges for " +
qdata.filename)
print(e)
#if self.catO2_df[i, 'Active_Site_ID'] == 'C':
if True:
self.molecule = mol3D.mol3D()
self.molecule.qdata2mol3D(qdata.atoms, qdata.coord)
print(qdata.atoms)
print(qdata.coord)
print(self.molecule.coords())
as_atom = self.molecule.atoms[active_site_index - 1]
print(as_atom.symbol(), as_atom.coords())
connection_list = self.molecule.getBondedAtomsSmart(
active_site_index, oct=False)
connection_list = [c for c in connection_list
] #This indexes from 1
#get atomic symbol of each connection
print(qdata.filename, active_site_index - 1,
connection_list)
sys.exit(-1)
if len(connection_list) == 3:
for en_conn, connection in enumerate(
connection_list):
sym_conn_list = qdata.atoms[connection]
chelpg_conn_list = qdata.chelpg[connection]
neigh = self.neighbor_dict[cat_fn][en_conn]
self.catO2_df.at[
i, neigh] = qdata.chelpg[connection]
#get CHELPG of each connection
break # assumes cat_dir does not contain multiple files for the same catalyst
def fsym(xyzf):
# setting properties
xyz = mol3D()
xyz.readfromxyz(xyzf)
# getting idxs of interest
midx = xyz.findMetal()[0] # monometallic complexes
# list of idx of the first-coord sphere
fidx_list = xyz.getBondedAtoms(midx)
fsym_list = []
for idx in fidx_list:
sym = xyz.getAtom(idx).sym
fsym_list.append(sym)
return fsym_list
def GetConf(mol, args, catoms=[]):
"""Uses distance geometry to get a random conformer.
Parameters
----------
mol : mol3D
mol3D class instance for molecule of interest.
args : Namespace
Namespace argument from inparse.
catoms : list, optional
List of connection atoms used to generate additional constraints if specified (see GetBoundsMatrices()). Default is empty.
Returns
-------
Conf3D : mol3D
mol3D class instance of new conformer.
"""
# Create a mol3D copy with a dummy metal metal
Conf3D = mol3D()
Conf3D.copymol3D(mol)
Conf3D.addAtom(atom3D('Fe', [0, 0, 0])) #Add dummy metal to the mol3D
dummy_metal = openbabel.OBAtom() #And add the dummy metal to the OBmol
dummy_metal.SetAtomicNum(26)
Conf3D.OBMol.AddAtom(dummy_metal)
for i in catoms:
Conf3D.OBMol.AddBond(i + 1, Conf3D.OBMol.NumAtoms(), 1)
natoms = Conf3D.natoms
Conf3D.createMolecularGraph()
shape = findshape(args, mol)
LB, UB = GetBoundsMatrices(Conf3D, natoms, catoms, shape)
status = False
while not status:
D = Metrize(LB, UB, natoms)
D0, status = GetCMDists(D, natoms)
G = GetMetricMatrix(D, D0, natoms)
L, V = Get3Eigs(G, natoms)
X = np.dot(V, L) # get projection
x = np.reshape(X, 3 * natoms)
res1 = optimize.fmin_cg(DistErr,
x,
fprime=DistErrGrad,
gtol=0.1,
args=(LB, UB, natoms),
disp=0)
X = np.reshape(res1, (natoms, 3))
Conf3D = SaveConf(X, Conf3D, True, catoms)
return Conf3D
def fcharge(xyzf, charge):
# setting properties
xyz = mol3D()
xyz.readfromxyz(xyzf)
xyz.calccharges(charge)
# getting idxs of interest
midx = xyz.findMetal()[0] # monometallic complexes
# list of idx of the first-coord sphere
fidx_list = xyz.getBondedAtoms(midx)
fcharge_list = []
for idx in fidx_list:
charge = xyz.partialcharges[idx]
fcharge_list.append(float(charge))
return fcharge_list
def shave_surface_layer(super_cell, TOL=1e-1):
# dlist = fractionate_points_by_plane(super_cell,n)
# points_below_plane(point,n,refd)
shaved_cell = mol3D()
shaved_cell.copymol3D(super_cell)
extents = find_extents(super_cell)
zmax = extents[2]
del_list = list()
for i, atoms in enumerate(super_cell.getAtoms()):
coords = atoms.coords()
if abs(coords[2] - zmax) < TOL:
del_list.append(i)
shaved_cell.deleteatoms(del_list)
return shaved_cell
