def make_Vel_plots(mol_res_obj):
Vel = mol_res_obj.RxnPathResults["electronicE"][:, 1]
Vel -= min(Vel)
degrees = mol_res_obj.RxnPathResults["electronicE"][:, 0]
plt.plot(degrees,
Constants.convert(Vel, "wavenumbers", to_AU=False),
"o",
label="Vel")
Vel_coeffs = fourier_coeffs(np.column_stack((np.radians(degrees), Vel)),
sin_order=6,
cos_order=6)
Vel_fit = calc_curves(np.radians(np.arange(0, 360, 1)),
Vel_coeffs,
function="fourier")
Vel_res = np.column_stack(
(np.arange(0, 360,
1), Constants.convert(Vel_fit, "wavenumbers", to_AU=False)))
max_arg1 = np.argmax(Vel_res[100:270, 1])
print("Vel", Vel_res[max_arg1 + 100, :])
plt.plot(Vel_res[:, 0], Vel_res[:, 1], "-b")
Vel_ZPE = mol_res_obj.VelCoeffs
velZPE = calc_curves(np.radians(np.arange(0, 360, 1)),
Vel_ZPE,
function="fourier")
res = np.column_stack(
(np.arange(0, 360,
1), Constants.convert(velZPE, "wavenumbers", to_AU=False)))
max_arg = np.argmax(res[100:270, 1])
print("Vel+ZPE", res[max_arg + 100, :])
plt.plot(res[:, 0], res[:, 1], label="Vel+ZPE")
plt.legend()
plt.show()
def fit_TDM(self, TDM):
from FourierExpansions import fourier_coeffs, calc_curves
tdm_x = np.radians(np.linspace(0, 360, len(TDM[:, 0])))
x = np.radians(np.linspace(0, 360,
len(self.tor_results[0]["eigvecs"])))
fittedTDM = np.zeros((len(x), 3))
for c, val in enumerate(["A", "B", "C"]):
coeffs = fourier_coeffs(np.column_stack((tdm_x, TDM[:, c])),
cos_order=6,
sin_order=6)
fittedTDM[:, c] = calc_curves(x, coeffs, function="fourier")
return fittedTDM
def fit_gmat(self):
from FourierExpansions import fourier_coeffs, calc_cos_coefs
fittedG = dict()
for i in np.arange(len(self.Gmatrix["gmatrix"])):
if "None" in self.PORparams:
coeffs = fourier_coeffs(np.column_stack(
(np.radians(self.Gmatrix["gmatrix"][i][:, 0]),
self.Gmatrix["gmatrix"][i][:, 1])),
cos_order=6,
sin_order=6)
else:
coeffs = calc_cos_coefs(
np.column_stack((np.radians(self.Gmatrix["gmatrix"][i][:,
0]),
self.Gmatrix["gmatrix"][i][:, 1])))
fittedG[i] = coeffs
return fittedG
def plot_fourier(self):
from Converter import Constants
from FourierExpansions import fourier_coeffs, calc_curves, calc_cos_coefs
import matplotlib.pyplot as plt
interp_degree = np.linspace(0, 360, 100)
interp_rad = np.radians(np.linspace(0, 360, 100))
EE = np.copy(self.RxnPathResults["electronicE"])
EE[:, 0] = np.radians(EE[:, 0])
cos_coeffs, sin_coeffs = fourier_coeffs(EE, cos_order=6, sin_order=6)
coeff2 = calc_cos_coefs(EE)
print("cos", cos_coeffs)
print("sin", sin_coeffs)
interpE = calc_curves(interp_rad, [cos_coeffs, sin_coeffs],
function="fourier")
interp2 = calc_curves(interp_rad, coeff2, function="cos")
plt.plot(self.RxnPathResults["electronicE"][:, 0],
self.RxnPathResults["electronicE"][:, 1], "o")
plt.plot(interp_degree, interpE)
plt.plot(interp_degree, interp2)
plt.show()
def calc_Vcoeffs(self, func):
from Converter import Constants
from FourierExpansions import fourier_coeffs, calc_cos_coefs
print("Expanding potential coefficients in Full Fourier...")
dvr_energies = self.DegreeDVRresults[
"energies"] # [degrees vOH=0 ... vOH=6]
dvr_energies[:, 1:] = Constants.convert(dvr_energies[:, 1:],
"wavenumbers",
to_AU=True)
coeff_dict = dict() # build coeff dict
rad = np.radians(dvr_energies[:, 0])
coeff_dict["Vel"] = self.VelCoeffs
if func == "cos":
for i in np.arange(
1, dvr_energies.shape[1]): # loop through saved energies
energies = np.column_stack((rad, dvr_energies[:, i]))
coeff_dict[f"V{i - 1}"] = calc_cos_coefs(energies)
else:
for i in np.arange(
1, dvr_energies.shape[1]): # loop through saved energies
energies = np.column_stack((rad, dvr_energies[:, i]))
coeff_dict[f"V{i - 1}"] = fourier_coeffs(energies)
return coeff_dict
def calculate_VelwZPE(self):
from Converter import Constants
from FourierExpansions import calc_cos_coefs, calc_4cos_coefs, fourier_coeffs, calc_curves
degree_vals = np.linspace(0, 360, len(self.MoleculeInfo.TorFiles))
norm_grad = self.RxnPathResults["norm_grad"]
idx = np.where(norm_grad[:, 1] > 4E-4)
new_degree = degree_vals[idx]
Vel = self.RxnPathResults["electronicE"][:, 1]
Vel_ZPE_dict = dict()
ZPE_dict = dict()
for i, j in enumerate(degree_vals):
freqs = self.RxnPathResults[j]["freqs"] # in hartree
# print(np.column_stack((j, freqs[-1])))
nonzero_freqs = freqs[
7:-1] # throw out translations/rotations and OH frequency
nonzero_freqs_har = Constants.convert(nonzero_freqs,
"wavenumbers",
to_AU=True)
ZPE = np.sum(nonzero_freqs_har) / 2
if j in new_degree:
if self.PORparams["twoD"]: # "twoD" in self.PORparams and
Vel_ZPE_dict[j] = Vel[i]
else:
Vel_ZPE_dict[j] = Vel[i] + ZPE
ZPE_dict[j] = ZPE
else:
pass
if "EmilData" in self.PORparams or "MixedData1" in self.PORparams:
# put together ZPE
print("CCSD Vel")
ZPE = np.array([(d, v) for d, v in ZPE_dict.items()])
sort_idxZ = np.argsort(ZPE[:, 0])
ZPE = ZPE[sort_idxZ]
ZPE[:, 0] = np.radians(ZPE[:, 0])
fit_ZPE = calc_4cos_coefs(ZPE)
# zpe_y = calc_curves(np.radians(np.arange(0, 360, 1)), fit_ZPE, function="4cos")
emil_angles = self.RxnPathResults["EmilelectronicE"][:, 0]
emil_ZPE = calc_curves(np.radians(emil_angles),
fit_ZPE,
function="4cos")
Vel_ZPE = np.column_stack(
(np.radians(emil_angles),
emil_ZPE + self.RxnPathResults["EmilelectronicE"][:, 1]))
VelwZPE_coeffs1 = calc_4cos_coefs(Vel_ZPE)
new_x = np.radians(np.arange(0, 360, 1))
y = calc_curves(new_x, VelwZPE_coeffs1, function="4cos")
y -= min(y) # shift curve so minima are at 0 instead of negative
VelwZPE_coeffs = calc_4cos_coefs(np.column_stack((new_x, y)))
npy_name = f"{self.MoleculeInfo.MoleculeName}_Emil_Velcoeffs_4order.npy"
csv_name = f"{self.MoleculeInfo.MoleculeName}_Emil_Velcoeffs_4order.csv"
else:
print("DFT Vel")
Vel_ZPE = np.array([(d, v) for d, v in Vel_ZPE_dict.items()])
sort_idx = np.argsort(Vel_ZPE[:, 0])
Vel_ZPE = Vel_ZPE[sort_idx]
Vel_ZPE[:, 0] = np.radians(Vel_ZPE[:, 0])
new_x = np.radians(np.arange(0, 360, 1))
if "MixedData2" in self.PORparams or self.PORparams[
"Vexpansion"] is "fourth":
VelwZPE_coeffs1 = calc_4cos_coefs(Vel_ZPE)
y = calc_curves(new_x, VelwZPE_coeffs1, function="4cos")
y -= min(
y) # shift curve so minima are at 0 instead of negative
VelwZPE_coeffs = calc_4cos_coefs(np.column_stack((new_x, y)))
npy_name = f"{self.MoleculeInfo.MoleculeName}_Velcoeffs_4order.npy"
csv_name = f"{self.MoleculeInfo.MoleculeName}_Velcoeffs_4order.csv"
elif self.PORparams["None"] and self.PORparams["twoD"]:
VelwZPE_coeffs1 = fourier_coeffs(Vel_ZPE)
y = calc_curves(new_x, VelwZPE_coeffs1, function="fourier")
y -= min(
y) # shift curve so minima are at 0 instead of negative
VelwZPE_coeffs = fourier_coeffs(np.column_stack((new_x, y)))
npy_name = f"{self.MoleculeInfo.MoleculeName}_Velcoeffs_6cos6sin_2D.npy"
csv_name = f"{self.MoleculeInfo.MoleculeName}_Velcoeffs_6cos6sin_2D.csv"
elif self.PORparams["None"] and self.PORparams["twoD"] is False:
VelwZPE_coeffs1 = fourier_coeffs(Vel_ZPE)
y = calc_curves(new_x, VelwZPE_coeffs1, function="fourier")
y -= min(
y) # shift curve so minima are at 0 instead of negative
VelwZPE_coeffs = fourier_coeffs(np.column_stack((new_x, y)))
npy_name = f"{self.MoleculeInfo.MoleculeName}_Velcoeffs_6cos6sin.npy"
csv_name = f"{self.MoleculeInfo.MoleculeName}_Velcoeffs_6cos6sin.csv"
elif self.PORparams["twoD"]:
VelwZPE_coeffs1 = calc_cos_coefs(Vel_ZPE)
y = calc_curves(new_x, VelwZPE_coeffs1)
y -= min(
y) # shift curve so minima are at 0 instead of negative
VelwZPE_coeffs = calc_cos_coefs(np.column_stack((new_x, y)))
npy_name = f"{self.MoleculeInfo.MoleculeName}_Velcoeffs_6order_2D.npy"
csv_name = f"{self.MoleculeInfo.MoleculeName}_Velcoeffs_6order_2D.csv"
else:
VelwZPE_coeffs1 = calc_cos_coefs(Vel_ZPE)
y = calc_curves(new_x, VelwZPE_coeffs1)
y -= min(
y) # shift curve so minima are at 0 instead of negative
VelwZPE_coeffs = calc_cos_coefs(np.column_stack((new_x, y)))
npy_name = f"{self.MoleculeInfo.MoleculeName}_Velcoeffs_6order.npy"
csv_name = f"{self.MoleculeInfo.MoleculeName}_Velcoeffs_6order.csv"
# save results
np.save(os.path.join(self.MoleculeInfo.MoleculeDir, npy_name),
VelwZPE_coeffs)
np.savetxt(os.path.join(self.MoleculeInfo.MoleculeDir, csv_name),
VelwZPE_coeffs)
return os.path.join(self.MoleculeInfo.MoleculeDir, npy_name)