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