def dispersion_energy(dimers, ml_type='KRR', load_path=None, return_pairs=False, infile=None, options=None): #defines cell parameters for grid computations if isinstance(dimers, list): d_list = dimers else: d_list = [dimers] # load options (all defaults) and get the KRR models if options is None: if infile is None: options = Options() else: options = Options(config_file=infile) energies = [] mon_a_list, mon_b_list = fill_monomer_lists(d_list, options, ml_type, load_path) cell = Cell.lattice_parameters(100., 100., 100.) for ma, mb in zip(mon_a_list, mon_b_list): disp = Dispersion(options, ma, cell) disp.add_system(mb) en = disp.compute_dispersion() energies.append(en) return np.asarray(energies)
def predict_from_monomer_list(monomer_a, monomer_b, load_path=None, return_pairs=False): ''' Compute energy components from two lists of monomers Uses default options, places mon_a in outer loop monomer list to outer loop Parameters ---------- mon_a: list of (or single) qcel Molecules mon_b: list of (or single) qcel Molecules return_pairs: bool to control returning of full atom-pairwise decomposition ''' if isinstance(monomer_a, list): mon_a_list = monomer_a else: mon_a_list = [monomer_a] if isinstance(monomer_b, list): mon_b_list = monomer_b else: mon_b_list = [monomer_b] options = Options() models = load_krr_models(options) energies = [] for A in mon_a_list: mon_a = mol_to_sys(A, options) if load_path is None: mon_a = predict_atomic_properties(mon_a, models) else: mon_a = load_atomic_properties(mon_a, load_path) for B in mon_b_list: mon_b = mol_to_sys(B, options) if load_path is None: mon_b = predict_atomic_properties(mon_b, models) else: mon_b = load_atomic_properties(mon_b, load_path) try: en = energy_kernel(mon_a, mon_b, options) except: en = "Error" energies.append(en) return energies
def get_elst_energy(params, pathname, ref): elst_param_dict = { 'Cl' : abs(params[0] ) , 'F' : abs(params[1] ) , 'S1' : abs(params[2] ) , 'S2' : abs(params[3] ) , 'HS' : abs(params[4] ) , 'HC' : abs(params[5] ) , 'HN' : abs(params[6] ) , 'HO' : abs(params[7] ) , 'C4' : abs(params[8] ) , 'C3' : abs(params[9] ) , 'C2' : abs(params[10]) , 'N3' : abs(params[11]) , 'N2' : abs(params[12]) , 'N1' : abs(params[13]) , 'O1' : abs(params[14]) , 'O2' : abs(params[15]) , 'Br' : abs(params[16])} print(elst_param_dict) #set globals options = Options('config.ini') options.set_damping_exponents(elst_param_dict) dimer_xyz = sorted(glob.glob(pathname + "/*.xyz")) dimers = [cliff.load_dimer_xyz(f) for f in dimer_xyz] elst_r = ref[:,1] en = cliff.electrostatic_energy(dimers,ml_type='NN', options=options) res = elst_r - en rmse = np.sqrt(np.average(np.square(res))) print(rmse) print("") return rmse
def exchange_energy(dimers, ml_type='KRR', load_path=None, return_pairs=False, infile=None, options=None): #defines cell parameters for grid computations if isinstance(dimers, list): d_list = dimers else: d_list = [dimers] # load options (all defaults) and get the KRR models if options is None: if infile is None: options = Options() else: options = Options(config_file=infile) energies = [] mon_a_list, mon_b_list = fill_monomer_lists(d_list, options, ml_type, load_path) cell = Cell.lattice_parameters(100., 100., 100.) for ma, mb in zip(mon_a_list, mon_b_list): rep = Repulsion(options, ma, cell) rep.add_system(mb) en = rep.compute_repulsion() # try: # mtp = Electrostatics(options,ma, cell) # mtp.add_system(mb) # en = mtp.mtp_energy() # except: # en = "Error" energies.append(en) return np.asarray(energies)
def predict_from_dimers(dimers, load_path=None, return_pairs=False): ''' Compute energy components from a list of dimers. Uses all default options, turns off logging Parameters ---------- dimers: qcel Molecule class or list of Molecule class return_pairs: bool to control returning of full atom-pairwise decomposition ''' if isinstance(dimers, list): d_list = dimers else: d_list = [dimers] # load options (all defaults) and get the KRR models options = Options() models = load_krr_models(options) energies = [] for dimer in d_list: mon_a, mon_b = mol_to_sys(dimer, options) if load_path is None: mon_a = predict_atomic_properties(mon_a, models) mon_b = predict_atomic_properties(mon_b, models) else: mon_a = load_atomic_properties(mon_a, load_path) mon_b = load_atomic_properties(mon_b, load_path) try: en = energy_kernel(mon_a, mon_b, options) except: en = "Error" energies.append(en) return np.asarray(energies)
def get_indu_energy(params, pathname, ref): indu_param_dict = { 'Cl' : abs(params[0] ) , 'F' : abs(params[1] ) , 'S1' : abs(params[2] ) , 'S2' : abs(params[3] ) , 'HS' : abs(params[4] ) , 'HC' : abs(params[5] ) , 'HN' : abs(params[6] ) , 'HO' : abs(params[7] ) , 'C4' : abs(params[8] ) , 'C3' : abs(params[9] ) , 'C2' : abs(params[10]) , 'N3' : abs(params[11]) , 'N2' : abs(params[12]) , 'N1' : abs(params[13]) , 'O1' : abs(params[14]) , 'O2' : abs(params[15]) , 'Br' : abs(params[16])} smearing_coeff = abs(params[17]) print(indu_param_dict) print(smearing_coeff) #set globals options = Options('config.ini') options.set_induction_sr_params(indu_param_dict) options.set_indu_smearing_coeff(smearing_coeff) dimer_xyz = sorted(glob.glob(pathname + "/*.xyz")) dimers = [cliff.load_dimer_xyz(f) for f in dimer_xyz] ind_r = ref[:,3] en = cliff.induction_energy(dimers,ml_type='NN', options=options) res = ind_r - en rmse = np.sqrt(np.average(np.square(res))) print(rmse) print("") return rmse
def get_energy(params, pathname, gamma, ref): # grab parameters elst_params = params[:17] exch_params = params[17:34] indu_params = params[34:52] disp_params = params[52:] elst_param_dict = { 'Cl' : abs(elst_params[0] ) , 'F' : abs(elst_params[1] ) , 'S1' : abs(elst_params[2] ) , 'S2' : abs(elst_params[3] ) , 'HS' : abs(elst_params[4] ) , 'HC' : abs(elst_params[5] ) , 'HN' : abs(elst_params[6] ) , 'HO' : abs(elst_params[7] ) , 'C4' : abs(elst_params[8] ) , 'C3' : abs(elst_params[9] ) , 'C2' : abs(elst_params[10]) , 'N3' : abs(elst_params[11]) , 'N2' : abs(elst_params[12]) , 'N1' : abs(elst_params[13]) , 'O1' : abs(elst_params[14]) , 'O2' : abs(elst_params[15]) , 'Br' : abs(elst_params[16])} exch_param_dict = { 'Cl' : abs(exch_params[0] ) , 'F' : abs(exch_params[1] ) , 'S1' : abs(exch_params[2] ) , 'S2' : abs(exch_params[3] ) , 'HS' : abs(exch_params[4] ) , 'HC' : abs(exch_params[5] ) , 'HN' : abs(exch_params[6] ) , 'HO' : abs(exch_params[7] ) , 'C4' : abs(exch_params[8] ) , 'C3' : abs(exch_params[9] ) , 'C2' : abs(exch_params[10]) , 'N3' : abs(exch_params[11]) , 'N2' : abs(exch_params[12]) , 'N1' : abs(exch_params[13]) , 'O1' : abs(exch_params[14]) , 'O2' : abs(exch_params[15]) , 'Br' : abs(exch_params[16])} indu_param_dict = { 'Cl' : abs(indu_params[1]), 'F' : abs(indu_params[2]), 'S1' : abs(indu_params[3]), 'S2' : abs(indu_params[4]), 'HS' : abs(indu_params[5]), 'HC' : abs(indu_params[6]), 'HN' : abs(indu_params[7]), 'HO' : abs(indu_params[8]), 'C4' : abs(indu_params[9]), 'C3' : abs(indu_params[10]), 'C2' : abs(indu_params[11]), 'N3' : abs(indu_params[12]), 'N2' : abs(indu_params[13]), 'N1' : abs(indu_params[14]), 'O1' : abs(indu_params[15]), 'O2' : abs(indu_params[16]), 'Br' : abs(indu_params[17]) } disp_param_dict = { 'Cl' : abs(disp_params[0] ) , 'F' : abs(disp_params[1] ) , 'S1' : abs(disp_params[2] ) , 'S2' : abs(disp_params[3] ) , 'HS' : abs(disp_params[4] ) , 'HC' : abs(disp_params[5] ) , 'HN' : abs(disp_params[6] ) , 'HO' : abs(disp_params[7] ) , 'C4' : abs(disp_params[8] ) , 'C3' : abs(disp_params[9] ) , 'C2' : abs(disp_params[10]) , 'N3' : abs(disp_params[11]) , 'N2' : abs(disp_params[12]) , 'N1' : abs(disp_params[13]) , 'O1' : abs(disp_params[14]) , 'O2' : abs(disp_params[15]) , 'Br' : abs(disp_params[16])} print("Parameters: ") print("Elst") pprint.pprint(elst_param_dict) print("Exch") pprint.pprint(exch_param_dict) print("Indu") print(f"Smearing coefficient: {abs(indu_params[0])}") pprint.pprint(indu_param_dict) print("Disp") pprint.pprint(disp_param_dict) #set globals options = Options('config.ini') options.set_damping_exponents(elst_param_dict) options.set_indu_smearing_coeff(abs(indu_params[0])) options.set_induction_sr_params(indu_param_dict) options.set_exchange_int_params(exch_param_dict) options.set_disp_coeffs(disp_param_dict) dimer_xyz = sorted(glob.glob(pathname + "/*.xyz")) dimers = [cliff.load_dimer_xyz(f) for f in dimer_xyz] energies = cliff.predict_from_dimers(dimers) total_e = energies[:,0] elst_e = energies[:,1] exch_e = energies[:,2] indu_e = energies[:,3] disp_e = energies[:,4] total_r = ref[:,0] elst_r = ref[:,1] exch_r = ref[:,2] indu_r = ref[:,3] disp_r = ref[:,4] total_err = total_r - total_e elst_err = elst_r - elst_e exch_err = exch_r - exch_e indu_err = indu_r - indu_e disp_err = disp_r - disp_e mse_total = np.average(np.square(total_err)) mse_elst = np.average(np.square(elst_err)) mse_exch = np.average(np.square(exch_err)) mse_indu = np.average(np.square(indu_err)) mse_disp = np.average(np.square(disp_err)) print("MSEs (kcal/mol):") print(f"Elst {mse_elst}") print(f"Exch {mse_exch}") print(f"Indu {mse_indu}") print(f"Disp {mse_disp}") ret_val = gamma * (mse_elst + mse_exch + mse_indu + mse_disp) + (1.0-gamma) * mse_total print(f"Multi-target metric (gamma = {gamma}): {ret_val}") return ret_val
def predict_from_monomer_list(monomer_a, monomer_b, ml_type='KRR', load_path=None, return_pairs=False, infile=None, options=None): ''' Compute energy components from two lists of monomers Uses default options, places mon_a in outer loop monomer list to outer loop Parameters ---------- mon_a: list of (or single) qcel Molecules mon_b: list of (or single) qcel Molecules return_pairs: bool to control returning of full atom-pairwise decomposition ''' if isinstance(monomer_a, list): mon_a_list = monomer_a else: mon_a_list = [monomer_a] if isinstance(monomer_b, list): mon_b_list = monomer_b else: mon_b_list = [monomer_b] if options is None: if infile is None: options = Options() else: options = Options(config_file=infile) mon_a_sys = [] mon_b_sys = [] if ml_type.upper() == "KRR": if load_path is None: models = load_krr_models(options) for A in mon_a_list: try: mon_a = mol_to_sys(A, options) if load_path is None: mon_a = predict_atomic_properties(mon_a, models) else: mon_a = load_atomic_properties(mon_a, load_path) mon_a_sys.append(mon_a) except: mon_a_sys.append(None) for B in mon_b_list: try: mon_b = mol_to_sys(B, options) if load_path is None: mon_b = predict_atomic_properties(mon_b, models) else: mon_b = load_atomic_properties(mon_b, load_path) mon_b_sys.append(mon_b) except: mon_b_sys.append(None) elif (ml_type.upper() == "NN") and (using_apnet): model_path = os.path.dirname(os.path.realpath(__file__)) model_path += '/models/apnet/cliff_pbe0atz.h5' ma_props = apnet.predict_cliff_properties(mon_a_list, model_path) mb_props = apnet.predict_cliff_properties(mon_b_list, model_path) for nA, A in enumerate(mon_a_list): mon_a = mol_to_sys(A, options) mon_a.set_properties(ma_props[nA]) mon_a_sys.append(mon_a) for nB, B in enumerate(mon_b_list): mon_b = mol_to_sys(B, options) mon_b.set_properties(mb_props[nB]) mon_b_sys.append(mon_b) elif (ml_type.upper() == "NN") and not using_apnet: raise Exception(f"ML type {ml_type} requested, but APNET not found!") else: raise Exception(f"ML type {ml_type} not understood!") energies = [] for mon_a in mon_a_sys: for mon_b in mon_b_sys: try: en = energy_kernel(mon_a, mon_b, options, return_pairs=return_pairs) except: en = None energies.append(en) return energies
def predict_from_dimers(dimers, ml_type='KRR', load_path=None, return_pairs=False, infile=None, options=None): ''' Compute energy components from a list of dimers. Uses all default options, turns off logging Parameters ---------- dimers: qcel Molecule class or list of Molecule class return_pairs: bool to control returning of full atom-pairwise decomposition ''' if isinstance(dimers, list): d_list = dimers else: d_list = [dimers] # load options (all defaults) and get the KRR models if options is None: if infile is None: options = Options() else: options = Options(config_file=infile) energies = [] mon_a_list = [] mon_b_list = [] s = time.time() if ml_type.upper() == "KRR": # get atomic properties if load_path is None: models = load_krr_models(options) # get the monomers for dimer in d_list: try: mon_a, mon_b = mol_to_sys(dimer, options) if load_path is None: mon_a = predict_atomic_properties(mon_a, models) mon_b = predict_atomic_properties(mon_b, models) else: mon_a = load_atomic_properties(mon_a, load_path) mon_b = load_atomic_properties(mon_b, load_path) mon_a_list.append(mon_a) mon_b_list.append(mon_b) except: mon_a_list.append(None) mon_b_list.append(None) elif (ml_type.upper() == "NN") and using_apnet: ma_s = [] mb_s = [] for dimer in d_list: ma_s.append(dimer.get_fragment(0)) mb_s.append(dimer.get_fragment(1)) model_path = os.path.dirname(os.path.realpath(__file__)) model_path += '/models/apnet/cliff_pbe0atz.h5' s1 = time.time() ma_props = apnet.predict_cliff_properties(ma_s, model_path) mb_props = apnet.predict_cliff_properties(mb_s, model_path) f1 = time.time() print(f"apnet time: {f1-s1} s") for nd, dimer in enumerate(d_list): mon_a, mon_b = mol_to_sys(dimer, options) mon_a.set_properties(ma_props[nd]) mon_b.set_properties(mb_props[nd]) mon_a_list.append(mon_a) mon_b_list.append(mon_b) elif (ml_type.upper() == "NN") and not using_apnet: raise Exception(f"ML type {ml_type} requested, but APNET not found!") else: raise Exception(f"ML type {ml_type} not understood!") f = time.time() print(f"Time spent predicting atomic properties: {f-s} s") for ma, mb in zip(mon_a_list, mon_b_list): try: en = energy_kernel(ma, mb, options, return_pairs=return_pairs) except: en = None energies.append(en) return energies