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