def plot_energies_all(root, basis_sets, molecules, loaded_data, types, data_set='Combined'):
for m in molecules:
if m not in loaded_data:
continue
for t in types:
data = []
forms = dict(root=root, mol=m, name=data_set, t=t)
if t is None:
save_path = '{root}/Figures/{mol}/{name}.png'.format(**forms)
else:
save_path = '{root}/Figures/{mol}/{name}.{t}.png'.format(**forms)
for d in basis_sets:
if d not in loaded_data[m]:
continue
if t not in loaded_data[m][d]:
continue
point_data = {'x':loaded_data[m][d][t][1],
'y':loaded_data[m][d][t][0],
'label':d}
data.append(point_data)
if not data:
continue
plot_scatters(data, save_path, show_legend=True, xlim=(0,360),
x_label='Dihedral angle (degrees)', y_label=r'Potential (kJ mol$^{-1}$)',
title='Dihedral profile for {mol} under all setups'.format(**forms))
def plot_apl(electrostics, charges, dispersions, root, mol, loaded_data):
for e in electrostics:
if e not in loaded_data:
continue
for q in charges:
if q not in loaded_data[e]:
continue
for lj in dispersions:
if lj not in loaded_data[e][q]:
continue
forms = dict(root=root, elec=e, charge=q, lj=lj, mol=mol)
if not os.path.exists(
'{root}/Figures/AreaPerLipid'.format(**forms)):
os.makedirs('{root}/Figures/AreaPerLipid'.format(**forms))
file_name = '{root}/Figures/AreaPerLipid/{mol}_{elec}_{charge}_{lj}.png'.format(
**forms)
apl = loaded_data[e][q][lj]['x'] * loaded_data[e][q][lj][
'y'] / 64
data = {
'x': loaded_data[e][q][lj]['e_time'] / 1000,
'y': apl,
'marker': '-'
}
plot_scatters([data],
file_name,
show_legend=False,
x_label='Time (ns)',
y_label=r'Area per lipid nm$^2$',
title='Area per lipid'.format(**forms))
def plot_thickness(self, x, y):
def linear(x,m,c):
return m*x + c
def linear_point(target,m,c):
return (target - c)/m
b_count = 9
bulk_count = np.mean((np.mean(y[0:2*b_count]),np.mean(y[-2*b_count:])))
if not bulk_count > 10:
bulk_count = np.mean(y[int(len(y)/2)-2*b_count:int(len(y)/2)+2*b_count])
drop_below, raise_above = 0,0
for i in range(len(y)):
if y[i] < 0.5*bulk_count and not drop_below and x[i] < 0:
drop_below = i
elif y[i] > 0.5*bulk_count and not raise_above and x[i] > 0:
raise_above = i
x_low = np.asarray(x[drop_below-b_count:drop_below+b_count])
x_high = np.asarray(x[raise_above-b_count:raise_above+b_count])
y_low = np.asarray(y[drop_below-b_count:drop_below+b_count])
y_high = np.asarray(y[raise_above-b_count:raise_above+b_count])
popt_low, _ = curve_fit(linear,x_low,y_low,p0=[1,1])
popt_high, _ = curve_fit(linear,x_high,y_high,p0=[1,1])
thickness = linear_point(0.5*bulk_count,*popt_high) - linear_point(0.5*bulk_count,*popt_low)
plot_scatters([{'x':x, 'y':y, 'marker':'-', 'label':'water density'}], './WaterDensity.png',
show_legend=False, x_label="Position (nm)", y_label=r'Water mass density',
title='Water mass density for {genName}'.format(**self.formatting))
return thickness
def plot_fitted_comparisons(root, molecules, descriptors, loaded_data, types):
for m in molecules:
if m not in loaded_data:
continue
for d in descriptors:
if d not in loaded_data[m]:
continue
if 'qm' not in loaded_data[m][d]:
continue
qm_fit = one_pass_lls(loaded_data[m][d]['qm'][0], loaded_data[m][d]['qm'][1], phase=[0,90], method='cauchy')
for t in types:
if t not in loaded_data[m][d]:
continue
if t == 'qm':
continue
forms = dict(root=root, mol=m, des=d, type=t, Type=t.upper())
save_path = '{root}/Figures/{mol}/{des}_Fitting.{type}.png'.format(**forms)
plotting_data = [{'x':loaded_data[m][d]['qm'][1],
'y':loaded_data[m][d]['qm'][0],
'marker':'b.',
'label':'QM raw'}]
md_fit = one_pass_lls(loaded_data[m][d][t][0], loaded_data[m][d][t][1], phase=[0,90], method='cauchy')
qm_fit_energies = [energy_at_x(qm_fit, x/10) for x in range(3600)]
md_fit_energies = [energy_at_x(md_fit, x/10) for x in range(3600)]
diff_energies = list(array(qm_fit_energies) - array(md_fit_energies))
diff_fit = one_pass_lls(dict(zip(range(3600),diff_energies)),
dict(zip(range(3600),[x/10 for x in range(3600)])), limit=3, phase=False, method='cauchy')
diff_fit_energies = [energy_at_x(diff_fit, x/10) for x in range(3600)]
plotting_data.append({'x':[x/10 for x in range(3600)],
'y':qm_fit_energies,
'marker':'b-',
'label':'QM fit'})
plotting_data.append({'x':[x/10 for x in range(3600)],
'y':md_fit_energies,
'marker':'r-',
'label':t.upper() + ' fit'})
plotting_data.append({'x':[x/10 for x in range(3600)],
'y':diff_fit_energies,
'marker':'g-',
'label':'diff fit'})
plotting_data.append({'x':[x/10 for x in range(3600)],
'y':list(array(diff_fit_energies)+array(md_fit_energies)),
'marker':'k--',
'label':'MD + diff'})
plotting_data.append({'x':loaded_data[m][d][t][1],
'y':loaded_data[m][d][t][0],
'marker':'r.',
'label':t.upper() + ' raw'})
plot_scatters(plotting_data, save_path, show_legend=False, xlim=(0,360),
x_label='Dihedral angle (degrees)', y_label=r'Potential (kJ mol$^{-1}$)',
title='Fitting to dihedral profile for {mol}:{des} with {Type}'.format(**forms))
with open('{root}/Figures/{mol}/{des}_diff_fit.{type}.txt'.format(**forms), 'w') as fh:
yaml.dump(diff_fit,fh)
def plot_energies_individual(root, molecules, basis_sets, loaded_data):
for m in molecules:
if m not in loaded_data:
continue
for d in basis_sets:
if d not in loaded_data[m]:
continue
data = [{'x':loaded_data[m][d][1],
'y':loaded_data[m][d][0],
'marker':'k-'}]
forms = dict(root=root, mol=m, basis=d)
save_path = '{root}/Figures/{mol}/{basis}.png'.format(**forms)
plot_scatters(data, save_path, show_legend=False, xlim=(0,360),
x_label='Dihedral angle (degrees)', y_label=r'Potential (kJ mol$^{-1}$)',
title='Dihedral profile for {mol} with {basis} basis set'.format(**forms))
def derivatives(energies, angles, mol, root):
save_path = '{}/Figures/Derivatives'.format(root)
if not os.path.isdir(save_path):
os.makedirs(save_path)
save_path += "/{}.png".format(mol)
derivatives, d_angles = derivative(energies, angles)
mean = np.mean([derivatives[x] for x in derivatives])
std = np.std([derivatives[x] for x in derivatives])
# determine if there exists a 10% length with all within xsd of mean
at_least_1_within = False
for i in range(len(derivatives)):
all_within_x = True
step_count = 0
for j in cycle_iterator(i, list(sorted(derivatives))):
step_count += 1
if np.abs(derivatives[j]) > mean + 1*std:
all_within_x = False
break
if step_count >= 0.1*len(derivatives):
break
if all_within_x:
at_least_1_within = True
break
if not at_least_1_within:
print("Not a series of 10 points within 1 sd of mean")
data = [{'x':d_angles, 'y':dict(zip([x for x in sorted(derivatives)],[np.abs(derivatives[x]) for x in sorted(derivatives)])), 'marker':'b.'}]
data.append({'x':[-1,361], 'y':[mean + std, mean + std], 'marker':'r--'}) # plus 1 sd
data.append({'x':[-1,361], 'y':[mean + 2*std, mean + 2*std], 'marker':'g--'}) # pls 2 sd
#data.append({'x':[-1,361], 'y':[mean-std, mean-std], 'marker':'r--'}) # min 1 sd
#data.append({'x':[-1,361], 'y':[mean-2*std, mean-2*std], 'marker':'g--'}) # min 2 sd
#data.append({'x':[-1,361], 'y':[mean-3*std, mean-3*std], 'marker':'b--'}) # min 3 sd
data.append({'x':[-1,361], 'y':[mean+3*std, mean+3*std], 'marker':'b--'}) # plus 3 sd
data.append({'x':[-1,361], 'y':[mean, mean], 'marker':'k--'}) # mean
#initial_angle = sorted(d_angles, key=lambda x:d_angles[x])[0]
#for ang in sorted(d_angles, key=lambda x:d_angles[x])[1:]:
# second_d[ang] = (derivatives[ang] - derivatives[initial_angle])/(d_angles[ang] - d_angles[initial_angle])
# second_d_angles[ang] = (d_angles[ang] + d_angles[initial_angle]) / 2
# initial_angle = ang
plot_scatters(data, save_path, xlim=(0,360),
x_label='Dihedral angle (degrees)', y_label=r'd/dx Potential (kJ mol$^{-1}$)',
title='Derivative of dihedral profile for {}'.format(mol))
def plot_energies_individual(root, molecules, basis_sets, loaded_data, types):
for t in types:
for m in molecules:
if m not in loaded_data:
continue
for d in basis_sets:
if d not in loaded_data[m]:
continue
if t not in loaded_data[m][d]:
continue
#if t in ["aa",'qm']:
# continue
data = [{'x':loaded_data[m][d][t][1],
'y':loaded_data[m][d][t][0],
'marker':'b.'}]
forms = dict(root=root, mol=m, basis=d, t=t)
if t is None:
save_path = '{root}/Figures/{mol}/{basis}.png'.format(**forms)
else:
save_path = '{root}/Figures/{mol}/{basis}.{t}.png'.format(**forms)
#print(t)
fit = one_pass_lls(loaded_data[m][d][t][0], loaded_data[m][d][t][1], phase=[0,90])
cauchy_fit = one_pass_lls(loaded_data[m][d][t][0], loaded_data[m][d][t][1], phase=[0,90], method='cauchy', printme=False)
fit_data = {'x':[x/10 for x in range(3600)],
'y':[energy_at_x(fit, x/10) for x in range(3600)],
'marker':'b-'}
#mean_fit = mean(fit_data['y'])
#print('mean', mean_fit)
#for x in fit_data['y']:
# x -= mean_fit
data.append(fit_data)
data.append({'x':[x/10 for x in range(3600)],
'y':[energy_at_x(cauchy_fit, x/10) for x in range(3600)],
'marker':'r-'})
plot_scatters(data, save_path, show_legend=False, xlim=(0,360),
x_label='Dihedral angle (degrees)', y_label=r'Potential (kJ mol$^{-1}$)',
title='Dihedral profile for {mol} under {t}'.format(**forms))
if t == 'aa' and m == 'HYDRO2':
error_term = error_lls = 0
for x in loaded_data[m][d][t][1]:
error_term += np.log(1 + (energy_at_x(cauchy_fit, loaded_data[m][d][t][1][x]) - loaded_data[m][d][t][0][x])**2)
error_lls += (energy_at_x(fit, loaded_data[m][d][t][1][x]) - loaded_data[m][d][t][0][x])**2
print('Error:', error_term, error_lls)
def determine_fitness(root, molecules, basis_sets, loaded_data):
reference_basis = '631Gd'
for m in molecules:
if m not in loaded_data:
continue
formatting = dict(root=root, mol=m, ref=reference_basis)
with open('{root}/{ref}/{mol}/phased_fitted_curve.txt'.format(**formatting), 'r') as fh:
reference_data = yaml.load(fh)
# absolute is the data as referenced between fit and actual QM results
data_absolute = []
# relative is the data referenced between fit and the reference_basis fit
data_relative = []
for d in basis_sets:
if d not in loaded_data[m]:
continue
formatting['basis'] = d
energies, angles = loaded_data[m][d]
with open('{root}/{basis}/{mol}/phased_fitted_curve.txt'.format(**formatting), 'r') as fh:
fit = yaml.load(fh)
data_absolute.append(dict(rmsd = absolute_rmsd(fit, energies, angles),
basis = d))
data_relative.append(dict(rmsd = relative_rmsd(fit, reference_data),
basis = d))
data = [{'x':angles,
'y':energies,
'marker':'r.-'},]
fit_energies = {}
for z in angles:
fit_energies[z] = energy_at_x(fit, angles[z])
data.append({'x':angles,'y':fit_energies,'marker':'b.-'})
save_path = '{root}/Figures/{mol}/{basis}_with_fit.png'.format(**formatting)
plot_scatters(data,save_path, show_legend=False, xlim=(0,360))
with open('{root}/Figures/{mol}/rmsd_data.txt'.format(**formatting), 'w') as fh:
fh.write('Absolute RMSDs from QM calculations\n')
for d in data_absolute:
fh.write('{basis:>12} : {rmsd:.2f}\n'.format(**d))
fh.write('\n')
fh.write('RMSDs relative to 6-31G(d) basis set fit\n')
for d in data_relative:
fh.write('{basis:>12} : {rmsd:.2f}\n'.format(**d))
fh.write('___________________________________\n')
def plot_energies_all(root, basis_sets, molecules, loaded_data, data_set='Combined'):
for m in molecules:
if m not in loaded_data:
continue
data = []
forms = dict(root=root, mol=m, name=data_set)
save_path = '{root}/Figures/{mol}/{name}.png'.format(**forms)
for b in basis_sets:
if b not in loaded_data[m]:
continue
point_data = {'x':loaded_data[m][b][1],
'y':loaded_data[m][b][0],
'label':b}
data.append(point_data)
plot_scatters(data, save_path, show_legend=True, xlim=(0,360),
x_label='Dihedral angle (degrees)', y_label=r'Potential (kJ mol$^{-1}$)',
title='Dihedral profile for {mol} with all basis sets'.format(**forms),
default_point='-')
def plot_potential(electrostics, charges, dispersions, root, mol, loaded_data):
for e in electrostics:
if e not in loaded_data:
continue
for q in charges:
if q not in loaded_data[e]:
continue
for lj in dispersions:
if lj not in loaded_data[e][q]:
continue
forms = dict(root=root, elec=e, charge=q, lj=lj, mol=mol)
if not os.path.exists('{root}/Figures/Potential'.format(**forms)):
os.makedirs('{root}/Figures/Potential'.format(**forms))
file_name = '{root}/Figures/Potential/{mol}_{elec}_{charge}_{lj}.png'.format(**forms)
data = {'x':loaded_data[e][q][lj]['e_time']/1000,
'y':loaded_data[e][q][lj]['pot']/1000,
'marker':'-'}
plot_scatters([data], file_name, show_legend=False,
x_label='Time (ns)', y_label=r'Potential',
title='Potential'.format(**forms))
def plot_energies_all(root,
basis_sets,
molecules,
loaded_data,
types,
data_set='Combined'):
for m in molecules:
if m not in loaded_data:
continue
for t in types:
data = []
forms = dict(root=root, mol=m, name=data_set, t=t)
if t is None:
save_path = '{root}/Figures/{mol}/{name}.png'.format(**forms)
else:
save_path = '{root}/Figures/{mol}/{name}.{t}.png'.format(
**forms)
for d in basis_sets:
if d not in loaded_data[m]:
continue
if t not in loaded_data[m][d]:
continue
point_data = {
'x': loaded_data[m][d][t][1],
'y': loaded_data[m][d][t][0],
'label': d
}
data.append(point_data)
if not data:
continue
plot_scatters(
data,
save_path,
show_legend=True,
xlim=(0, 360),
x_label='Dihedral angle (degrees)',
y_label=r'Potential (kJ mol$^{-1}$)',
title='Dihedral profile for {mol} under all setups'.format(
**forms))
def derivatives(energies, angles, mol, root):
save_path = '{}/Figures/Derivatives'.format(root)
if not os.path.isdir(save_path):
os.makedirs(save_path)
save_path += "/{}.png".format(mol)
derivatives, d_angles = derivative(energies, angles)
mean = np.mean([derivatives[x] for x in derivatives])
std = np.std([derivatives[x] for x in derivatives])
# determine if there exists a 10% length with all within xsd of mean
at_least_1_within = False
for i in range(len(derivatives)):
all_within_x = True
step_count = 0
for j in cycle_iterator(i, list(sorted(derivatives))):
step_count += 1
if np.abs(derivatives[j]) > mean + 1 * std:
all_within_x = False
break
if step_count >= 0.1 * len(derivatives):
break
if all_within_x:
at_least_1_within = True
break
if not at_least_1_within:
print("Not a series of 10 points within 1 sd of mean")
data = [{
'x':
d_angles,
'y':
dict(
zip([x for x in sorted(derivatives)],
[np.abs(derivatives[x]) for x in sorted(derivatives)])),
'marker':
'b.'
}]
data.append({
'x': [-1, 361],
'y': [mean + std, mean + std],
'marker': 'r--'
}) # plus 1 sd
data.append({
'x': [-1, 361],
'y': [mean + 2 * std, mean + 2 * std],
'marker': 'g--'
}) # pls 2 sd
#data.append({'x':[-1,361], 'y':[mean-std, mean-std], 'marker':'r--'}) # min 1 sd
#data.append({'x':[-1,361], 'y':[mean-2*std, mean-2*std], 'marker':'g--'}) # min 2 sd
#data.append({'x':[-1,361], 'y':[mean-3*std, mean-3*std], 'marker':'b--'}) # min 3 sd
data.append({
'x': [-1, 361],
'y': [mean + 3 * std, mean + 3 * std],
'marker': 'b--'
}) # plus 3 sd
data.append({'x': [-1, 361], 'y': [mean, mean], 'marker': 'k--'}) # mean
#initial_angle = sorted(d_angles, key=lambda x:d_angles[x])[0]
#for ang in sorted(d_angles, key=lambda x:d_angles[x])[1:]:
# second_d[ang] = (derivatives[ang] - derivatives[initial_angle])/(d_angles[ang] - d_angles[initial_angle])
# second_d_angles[ang] = (d_angles[ang] + d_angles[initial_angle]) / 2
# initial_angle = ang
plot_scatters(data,
save_path,
xlim=(0, 360),
x_label='Dihedral angle (degrees)',
y_label=r'd/dx Potential (kJ mol$^{-1}$)',
title='Derivative of dihedral profile for {}'.format(mol))
def plot_apl(self, x, y, time, N=64):
apl = self.calc_apl(x, y, N)
plot_scatters([{'x':np.array(time)/1000, 'y':apl, 'marker':'-', 'label':'APL'}], './APL.png',
show_legend=False, x_label="Time (ns)", y_label=r'Area per Lipid (nm$^2$)',
title='Area per lipid for {genName}'.format(**self.formatting))
def plot_vpl(self, x, y, z, time, NL=128, NW=5760, VW=0.03177):
vpl = self.calc_vpl(x, y, z, NL, NW, VW)
plot_scatters([{'x':np.array(time)/1000, 'y':vpl, 'marker':'-', 'label':'VPL'}], './VPL.png',
show_legend=False, x_label="Time (ns)", y_label=r'Volume per Lipid (nm$^3$)',
title='Volume per lipid for {genName}'.format(**self.formatting))
def plot_energies_individual(root, molecules, basis_sets, loaded_data, types):
for t in types:
for m in molecules:
if m not in loaded_data:
continue
for d in basis_sets:
if d not in loaded_data[m]:
continue
if t not in loaded_data[m][d]:
continue
#if t in ["aa",'qm']:
# continue
data = [{
'x': loaded_data[m][d][t][1],
'y': loaded_data[m][d][t][0],
'marker': 'b.'
}]
forms = dict(root=root, mol=m, basis=d, t=t)
if t is None:
save_path = '{root}/Figures/{mol}/{basis}.png'.format(
**forms)
else:
save_path = '{root}/Figures/{mol}/{basis}.{t}.png'.format(
**forms)
#print(t)
fit = one_pass_lls(loaded_data[m][d][t][0],
loaded_data[m][d][t][1],
phase=[0, 90])
cauchy_fit = one_pass_lls(loaded_data[m][d][t][0],
loaded_data[m][d][t][1],
phase=[0, 90],
method='cauchy',
printme=False)
fit_data = {
'x': [x / 10 for x in range(3600)],
'y': [energy_at_x(fit, x / 10) for x in range(3600)],
'marker': 'b-'
}
#mean_fit = mean(fit_data['y'])
#print('mean', mean_fit)
#for x in fit_data['y']:
# x -= mean_fit
data.append(fit_data)
data.append({
'x': [x / 10 for x in range(3600)],
'y':
[energy_at_x(cauchy_fit, x / 10) for x in range(3600)],
'marker':
'r-'
})
plot_scatters(
data,
save_path,
show_legend=False,
xlim=(0, 360),
x_label='Dihedral angle (degrees)',
y_label=r'Potential (kJ mol$^{-1}$)',
title='Dihedral profile for {mol} under {t}'.format(
**forms))
if t == 'aa' and m == 'HYDRO2':
error_term = error_lls = 0
for x in loaded_data[m][d][t][1]:
error_term += np.log(1 + (
energy_at_x(cauchy_fit, loaded_data[m][d][t][1]
[x]) - loaded_data[m][d][t][0][x])**2)
error_lls += (
energy_at_x(fit, loaded_data[m][d][t][1][x]) -
loaded_data[m][d][t][0][x])**2
print('Error:', error_term, error_lls)
def plot_potential(self, time, pot):
plot_scatters([{'x':np.array(time)/1000, 'y':pot, 'marker':'-', 'label':'Pot'}], './Potential.png',
show_legend=False, x_label="Time (ns)", y_label=r'Potential (kJ mol$^{-1}$)',
title='Potential for {genName}'.format(**self.formatting))
method='cauchy')
fit_angles, svd_energies, cauchy_energies = [], [], []
for i in range(360):
fit_angles.append(i)
svd_energies.append(energy_at_x(svd_fit, i))
cauchy_energies.append(energy_at_x(cauchy_fit, i))
from plotting import plot_scatters
plot_scatters([{
'x': angles,
'y': energies,
'marker': 'b.'
}, {
'x': fit_angles,
'y': svd_energies,
'marker': 'b-'
}, {
'x': fit_angles,
'y': cauchy_energies,
'marker': 'r-'
}],
'/Users/iwelsh/Desktop/testthing.png',
xlim=(0, 360))
print(cauchy_fit)
sys.exit()
start_time = process_time()
for r in roots:
for m in mols:
for t in types:
energies[x] -= mean_energy
energies[90] *= -8
energies[20] *= -6
svd_fit = one_pass_lls(energies, angles, phase=[0,90])
#print(svd_fit)
cauchy_fit = fit_torsion_terms_lls(energies, angles, fit_phase=[0,90], method='cauchy')
fit_angles, svd_energies, cauchy_energies = [], [], []
for i in range(360):
fit_angles.append(i)
svd_energies.append(energy_at_x(svd_fit, i))
cauchy_energies.append(energy_at_x(cauchy_fit, i))
from plotting import plot_scatters
plot_scatters([{'x':angles, 'y':energies, 'marker':'b.'}, {'x':fit_angles, 'y':svd_energies, 'marker':'b-'}
, {'x':fit_angles, 'y':cauchy_energies, 'marker':'r-'}],
'/Users/iwelsh/Desktop/testthing.png', xlim=(0,360))
print(cauchy_fit)
sys.exit()
start_time = process_time()
for r in roots:
for m in mols:
for t in types:
#for l in levls:
file_path = "/Users/iwelsh/GitHub/ExtractedData/Torsions/AdditionalFixedTorsions/{}/{}{}/".format(r,m,t)
if not os.path.isfile(file_path + 'energies.aa.txt'):
continue
def plot_fitted_comparisons(root, molecules, descriptors, loaded_data, types):
for m in molecules:
if m not in loaded_data:
continue
for d in descriptors:
if d not in loaded_data[m]:
continue
if 'qm' not in loaded_data[m][d]:
continue
qm_fit = one_pass_lls(loaded_data[m][d]['qm'][0],
loaded_data[m][d]['qm'][1],
phase=[0, 90],
method='cauchy')
for t in types:
if t not in loaded_data[m][d]:
continue
if t == 'qm':
continue
forms = dict(root=root, mol=m, des=d, type=t, Type=t.upper())
save_path = '{root}/Figures/{mol}/{des}_Fitting.{type}.png'.format(
**forms)
plotting_data = [{
'x': loaded_data[m][d]['qm'][1],
'y': loaded_data[m][d]['qm'][0],
'marker': 'b.',
'label': 'QM raw'
}]
md_fit = one_pass_lls(loaded_data[m][d][t][0],
loaded_data[m][d][t][1],
phase=[0, 90],
method='cauchy')
qm_fit_energies = [
energy_at_x(qm_fit, x / 10) for x in range(3600)
]
md_fit_energies = [
energy_at_x(md_fit, x / 10) for x in range(3600)
]
diff_energies = list(
array(qm_fit_energies) - array(md_fit_energies))
diff_fit = one_pass_lls(
dict(zip(range(3600), diff_energies)),
dict(zip(range(3600), [x / 10 for x in range(3600)])),
limit=3,
phase=False,
method='cauchy')
diff_fit_energies = [
energy_at_x(diff_fit, x / 10) for x in range(3600)
]
plotting_data.append({
'x': [x / 10 for x in range(3600)],
'y': qm_fit_energies,
'marker': 'b-',
'label': 'QM fit'
})
plotting_data.append({
'x': [x / 10 for x in range(3600)],
'y': md_fit_energies,
'marker': 'r-',
'label': t.upper() + ' fit'
})
plotting_data.append({
'x': [x / 10 for x in range(3600)],
'y': diff_fit_energies,
'marker': 'g-',
'label': 'diff fit'
})
plotting_data.append({
'x': [x / 10 for x in range(3600)],
'y':
list(array(diff_fit_energies) + array(md_fit_energies)),
'marker':
'k--',
'label':
'MD + diff'
})
plotting_data.append({
'x': loaded_data[m][d][t][1],
'y': loaded_data[m][d][t][0],
'marker': 'r.',
'label': t.upper() + ' raw'
})
plot_scatters(
plotting_data,
save_path,
show_legend=False,
xlim=(0, 360),
x_label='Dihedral angle (degrees)',
y_label=r'Potential (kJ mol$^{-1}$)',
title=
'Fitting to dihedral profile for {mol}:{des} with {Type}'.
format(**forms))
with open(
'{root}/Figures/{mol}/{des}_diff_fit.{type}.txt'.
format(**forms), 'w') as fh:
yaml.dump(diff_fit, fh)
