def main():
from Molecule import Molecule
logger = logging.getLogger('pyar')
handler = logging.FileHandler('clustering.log', 'w')
formatter = logging.Formatter('%(message)s')
handler.setFormatter(formatter)
logger.addHandler(handler)
logger.setLevel(logging.DEBUG)
input_files = sys.argv[1:]
if len(input_files) < 2:
print('Not enough files to cluster')
sys.exit(0)
mols = []
for each_file in input_files:
mol = Molecule.from_xyz(each_file)
mol.energy = read_energy_from_xyz_file(each_file)
mols.append(mol)
plot_energy_histogram(mols)
selected = choose_geometries(mols)
cmd = ['/home/anoop/bin/molden']
fls = []
for one in selected:
fls.append(one.name+'.xyz')
print(' '.join(cmd+fls))
# subp.check_call(cmd)
return
def main():
from Molecule import Molecule
import sys
mol = Molecule.from_xyz(sys.argv[1])
method = {'charge': 0, 'multiplicity': 1, 'scftype': 'rhf'}
geometry = Psi4(mol, method)
geometry.optimize()
def main():
from Molecule import Molecule
mol = Molecule.from_xyz(sys.argv[1])
geometry = Turbomole(mol)
if len(sys.argv) == 2:
geometry.optimize()
elif len(sys.argv) == 3:
gamma_force = sys.argv[2]
geometry.optimize(gamma=gamma_force)
else:
sys.exit()
return
def setup_molecules(input_files):
molecules = []
for each_file in input_files:
try:
mol = Molecule.from_xyz(each_file)
print(each_file)
molecules.append(mol)
except IOError:
print("File {} does not exist".format(each_file))
sys.exit()
print("I've parsed these molecules as input: {}".format(
[i.name for i in molecules]))
return molecules
def main():
import sys
input_files = sys.argv[1:]
from Molecule import Molecule
method = {
'charge': 0,
'multiplicity': 1,
'scftype': 'rhf',
'software': 'orca'
}
gamma = 0.0
for m in input_files:
mol = Molecule.from_xyz(m)
if optimise(mol, method=method, gamma=gamma): print(mol.energy)
def main():
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--charge', type=int, default=0, help='charge')
parser.add_argument('-m',
'--multiplicity',
type=int,
default=1,
help='multiplicity')
parser.add_argument('--scftype',
type=str,
default='rhf',
choices=['rhf', 'uhf'],
help='SCF type (rhf/uhf)')
parser.add_argument("input_file",
metavar='file',
type=str,
help='input coordinate file')
parser.add_argument('--scan',
type=int,
nargs=2,
help='scan between two atoms')
parser.add_argument('--cycle',
type=int,
default=350,
help='maximum number of optimization cycles')
args = parser.parse_args()
from Molecule import Molecule
mol = Molecule.from_xyz(args.input_file)
method_args = {
'charge': args.charge,
'multiplicity': args.multiplicity,
'scftype': args.scftype,
'software': 'xtb'
}
Xtb(mol, method_args)
import optimiser
print('optimising')
optimiser.optimise(mol, method_args)
if args.scan:
pass
def main():
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--charge', type=int, default=0,
help='charge')
parser.add_argument('-m', '--multiplicity', type=int, default=1,
help='multiplicity')
parser.add_argument('--scftype', type=str, default='rhf',
choices=['rhf', 'uhf'],
help='SCF type (rhf/uhf)')
parser.add_argument("input_file", metavar='file',
type=str,
help='input coordinate file')
parser.add_argument('-o', '--opt', action='store_true',
help='optimize')
parser.add_argument('-g', '--gamma', type=float, default=0.0,
help='optimize')
parser.add_argument('--cycle', type=int, default=350,
help='maximum number of optimization cycles')
parser.add_argument('-f1', nargs='+', type=int,
help='atoms in the first fragment')
parser.add_argument('-f2', nargs='+', type=int,
help='atoms in the second fragment')
args = parser.parse_args()
from Molecule import Molecule
mol = Molecule.from_xyz(args.input_file)
mol.fragments = [args.f1, args.f2]
method_args = {
'charge': args.charge,
'multiplicity': args.multiplicity,
'scftype': args.scftype,
'software': 'turbomole'
}
Turbomole(mol, method_args)
if args.opt:
import optimiser
turbomole_logger.info('optimising')
optimiser.optimise(mol, method_args, args.gamma)
else:
make_coord(mol.atoms_list, mol.coordinates)
prepare_control(charge=method_args['charge'], multiplicity=method_args['multiplicity'])
turbomole_logger.info('created input file')
def main():
from Molecule import Molecule
try:
input_files = sys.argv[1:]
except:
print('usage: cluster.;y <xyz-file(s)>')
sys.exit(1)
if len(input_files) < 2:
print('Not enough files to cluster')
sys.exit(0)
mols = {}
for each_file in input_files:
mol = Molecule.from_xyz(each_file)
mol.energy = read_energy_from_xyz_file(each_file)
mols[mol.name] = mol
choose_geometries(mols)
return
def main():
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('-s', type=int, required=True, nargs=2,
help='scan between two atoms')
parser.add_argument('-c', '--charge', type=int, default=0,
help='charge')
parser.add_argument('-m', '--multiplicity', type=int, default=1,
help='multiplicity')
parser.add_argument('--scftype', type=str, default= 'rhf', choices= ['rhf', 'uhf'],
help='SCF type (rhf/uhf)')
parser.add_argument("input_file", metavar='file',
type=str,
help='input coordinate file')
parser.add_argument('-o', '--opt', action='store_true',
help='optimize')
args = parser.parse_args()
from Molecule import Molecule
mol = Molecule.from_xyz(args.input_file)
method_args = {
'charge': args.charge,
'multiplicity': args.multiplicity,
'scftype': args.scftype,
'software': 'orca'
}
a, b = args.s
coordinates = mol.coordinates
import numpy as np
start_dist = np.linalg.norm(coordinates[a] - coordinates[b])
final_distance = mol.covalent_radius[a] + mol.covalent_radius[b]
step = int(abs(final_distance - start_dist)*10)
c_k = '\n!ScanTS\n% geom scan B '+str(a)+' '+str(b)+ '= '+ str(start_dist)\
+ ', ' + str(final_distance) + ', ' + str(step) + ' end end\n'
geometry = Orca(mol, method_args, custom_keyword=c_k)
if args.opt:
import optimiser
print('optimising')
optimiser.optimise(mol, method_args, 0.0, custom_keyword=c_k)
else:
print('created input file')
def main():
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('-N',
type=int,
required=True,
help='number of points/configurations')
parser.add_argument('-mpt',
action='store_true',
help='generate random points on the surface of a unit '
'sphere')
parser.add_argument('-mmc',
action='store_true',
help='generate N configurations of two molecules')
parser.add_argument('-mcm',
action='store_true',
help='generate a composite molecule with seed and N '
'monomers')
parser.add_argument('-i',
type=str,
nargs=2,
dest='file',
help="two molecules, seed and monomer, "
"in xyz file format")
parser.add_argument('-method',
choices=['random', 'rotating', 'uniform'],
help="method for generating points")
parser.add_argument(
'-spr',
type=str,
help="create a molecules from N atoms of given elememts")
parser.add_argument('-best',
type=int,
nargs=2,
help="create the best orientation with lowest a b "
"distance")
args = parser.parse_args()
print(args)
tabu_logger.debug(args)
N = args.N
if args.file:
from Molecule import Molecule
seed = Molecule.from_xyz(args.file[0])
monomer = Molecule.from_xyz(args.file[1])
else:
seed = None
monomer = None
if args.method == 'rotating':
if args.file and monomer.number_of_atoms == 1:
pts = rotating_octants(N, angle_tabu=False)
else:
pts = rotating_octants(N, angle_tabu=True)
elif args.method == 'random':
pts = make_random_points_and_angles(N)
elif args.method == 'uniform':
pts = uniformly_distributed_points(N)
else:
print('using default method: random')
pts = make_random_points_and_angles(N)
if args.mpt:
plot_points(pts)
if args.mmc:
orientations = generate_orientations_from_points_and_angles(
seed, monomer, pts)
for i, each_orientation in enumerate(orientations):
each_orientation.mol_to_xyz('mol' + str(i) + '.xyz')
if args.mcm:
import optimiser
method_args = {
'charge': 0,
'multiplicity': 1,
'scftype': 'rhf',
'software': 'xtb'
}
for i in range(128):
result = generate_composite_molecule(seed, monomer, pts)
result.title = "trial_" + str(i).zfill(3)
optimiser.optimise(result, method_args, 0.0)
result.mol_to_xyz('result_' + str(i).zfill(3) + '.xyz')
if args.spr:
import scipy.spatial.distance as sdist
from Molecule import Molecule
from atomic_data import atomic_numbers, covalent_radii
radii = covalent_radii[atomic_numbers[args.spr.capitalize()]]
pts = pts[:, :3]
factor = pts / 10
while np.min(sdist.pdist(pts)) < 2 * radii:
pts += factor
atoms = [args.spr for _ in range(N)]
result = Molecule(atoms, pts)
result.mol_to_xyz('mol.xyz')
if args.best:
a = args.best[0]
b = seed.number_of_atoms + args.best[1]
generate_guess_for_bonding('xxx', seed, monomer, a, b, N)
except subp.CalledProcessError as e:
if e.output:
with open('xtb.out', 'w') as fb:
fb.write(e.output)
msg = "SCF Failure. Check files in" + os.getcwd()
xtb_turbo_logger.error(msg)
return False, msg, None, None
msg = [
line for line in open('engrad.out').readlines() if 'ended' in line
]
if os.path.isfile('.sccnotconverged'):
msg = "SCF Failure. Check files in" + os.getcwd()
return False, msg, None, None
if 'abnormally' in msg:
return False, msg, None, None
else:
return True, msg, interface.turbomole.get_energy(), \
interface.turbomole.get_gradients()
def main():
pass
if __name__ == "__main__":
from Molecule import Molecule
my_mol = Molecule.from_xyz(sys.argv[1])
geometry = XtbTurbo(my_mol, method={})
geometry.optimize(gamma=100.0)
