def main(args):
parser = return_parser()
opts = parser.parse_args(args)
# ~~~ STRUCTURE AND CHARGE READING ~~~
mae = ft.Mae(opts.mae)
mmo = ft.MacroModel(opts.mmo)
# Select 1st structure of .mae. Sure hope your MM charges are there.
str_mae = mae.structures[0]
# Select 1st structure of .mmo.
# This structure should only contain bonds that are particular to our
# substructure.
str_mmo = mmo.structures[0]
substr_bonds = str_mmo.select_stuff('bonds', com_match=opts.subnames)
substr_atoms = atom_nums_from_bonds(substr_bonds)
# Now that we have the atoms in the substructure, we need to select
# every other atom and get those MM charges.
non_substr_atoms = []
for atom in str_mae.atoms:
if atom.index not in substr_atoms:
non_substr_atoms.append(atom)
# ~~~ WORKING ON GENERATING THE OUTPUT ~~~
if opts.format == 'jaguar':
atomic_lines = gen_atomic_section(non_substr_atoms)
# Now we just need to add these to the atomic section.
# Read or generate the .in file.
if opts.jin:
jin = ft.JaguarIn(opts.jin)
else:
jin = None
new_lines = gen_jaguar_output(mae, jin, opts.charge)
# Add the charge section.
new_lines[0:0] = atomic_lines
elif opts.format == 'gaussian':
non_substr_atom_indices = [x.index for x in non_substr_atoms]
new_lines = gen_gaussian_output(
mae,
indices_use_charge=non_substr_atom_indices,
title=mae.filename.split('.')[0],
charge=opts.charge,
multiplicity=opts.multiplicity)
# ~~~ WRITE OUTPUT ~~~
if opts.output:
with open(opts.output, 'w') as f:
for line in new_lines:
f.write(line + '\n')
else:
for line in new_lines:
print(line)
def main(args):
'''
Imports a force field object, which contains a list of all the available
parameters. Returns a list of only the user selected parameters.
'''
# basestring is deprecated in python3, str is probably safe to use in both
# but should be tested, for now sys.version_info switch can handle it
if sys.version_info > (3, 0):
if isinstance(args, str):
args = args.split()
else:
if isinstance(args, basestring):
args = args.split()
parser = return_params_parser()
opts = parser.parse_args(args)
if opts.average or opts.check:
assert opts.mmo, 'Must provide MacroModel .mmo files!'
# The function import_ff should be more like something that just
# interprets filetypes.
# ff = datatypes.import_ff(opts.ffpath)
ff = datatypes.MM3(opts.ffpath)
ff.import_ff()
# Set the selected parameter types.
if opts.all:
opts.ptypes.extend(ALL_PARM_TYPES)
logger.log(20,
'Selected parameter types: {}'.format(' '.join(opts.ptypes)))
params = []
# These two functions populate the selected parameter list. Each takes
# ff.params and returns a subset of it.
# WATCH OUT FOR DUPLICATES!
if opts.ptypes:
params.extend(trim_params_by_type(ff.params, opts.ptypes))
if opts.pfile:
params.extend(trim_params_by_file(ff.params, opts.pfile))
if opts.nozero:
new_params = []
for param in params:
if not param.value == 0.:
new_params.append(param)
params = new_params
logger.log(
20, ' -- Total number of chosen parameters: {}'.format(len(params)))
# Load MacroModel .mmo files if desired.
if opts.mmo or opts.average or opts.check:
mmos = []
for filename in opts.mmo:
mmos.append(filetypes.MacroModel(filename))
bond_dic, angle_dic, torsion_dic = gather_values(mmos)
# Check if the parameter's FF row shows up in the data gathered
# from the MacroModel .mmo file. Currently only takes into
# account bonds and angles.
if opts.check:
all_rows = bond_dic.keys() + angle_dic.keys() + torsion_dic.keys()
for param in params:
if not param.mm3_row in all_rows:
print("{} doesn't appear to be in use.".format(param))
# Change parameter values to be their averages.
if opts.average:
# bond_avg = {1857: 2.3171,
# 1858: 1.3556
# }
bond_avg = {}
for ff_row, values in bond_dic.items():
bond_avg[ff_row] = np.mean(values)
print(">> STD {}: {}".format(ff_row, np.std(values)))
angle_avg = {}
for ff_row, values in angle_dic.items():
angle_avg[ff_row] = np.mean(values)
print(">> STD {}: {}".format(ff_row, np.std(values)))
# Update parameter values.
for param in params:
if param.ptype in ['be', 'ae'] and param.mm3_row in bond_avg:
param.value = bond_avg[param.mm3_row]
if param.ptype in ['be', 'ae'] and param.mm3_row in angle_avg:
param.value = angle_avg[param.mm3_row]
# Export the updated parameters.
ff.export_ff(opts.average, params)
# Print the parameters.
if opts.printparams:
for param in params:
# if param.ptype in ['df', 'q']:
if param.allowed_range:
print('{} {} {} {}'.format(param.mm3_row, param.mm3_col,
param.allowed_range[0],
param.allowed_range[1]))
else:
print('{} {}'.format(param.mm3_row, param.mm3_col))
if opts.printtether:
for param in params:
print(' '
'{:22s}'
' '
'{:22.4f}'
' '
'{:22.4f}'.format(
'p_mm3_{}-{}'.format(param.mm3_row, param.mm3_col),
# These should be floats without me making it one here.
co.WEIGHTS['p'],
param.value))
ff.params = params
return ff