def __init__(self, A_st=None, atoms=None, symmetrynumber=None, inertia=None, geometry=None, vib_wavenumbers=None, potentialenergy=None, **kwargs): super().__init__(atoms=atoms, symmetrynumber=symmetrynumber, geometry=geometry, vib_wavenumbers=vib_wavenumbers, potentialenergy=potentialenergy, **kwargs) self.A_st = A_st self.atoms = atoms self.geometry = geometry self.symmetrynumber = symmetrynumber self.inertia = inertia self.etotal = potentialenergy self.vib_energies = c.wavenumber_to_energy(np.array(vib_wavenumbers)) self.theta = np.array(self.vib_energies) / c.kb('eV/K') self.zpe = sum(np.array(self.vib_energies)/2.) *\ c.convert_unit(from_='eV', to='kcal')*c.Na if np.sum(self.vib_energies) != 0: self.q_vib = np.product( np.divide(1, (1 - np.exp(-self.theta / c.T0('K'))))) if self.phase == 'G': if self.inertia is not None: self.I3 = self.inertia else: self.I3 = atoms.get_moments_of_inertia() *\ c.convert_unit(from_='A2', to='m2') *\ c.convert_unit(from_='amu', to='kg') self.T_I = c.h('J s')**2 / (8 * np.pi**2 * c.kb('J/K')) if self.phase == 'G': Irot = np.max(self.I3) if self.geometry == 'nonlinear': self.q_rot = np.sqrt(np.pi*Irot)/self.symmetrynumber *\ (c.T0('K')/self.T_I)**(3./2.) else: self.q_rot = (c.T0('K') * Irot / self.symmetrynumber) / self.T_I else: self.q_rot = 0. if self.A_st is not None: self.MW = mw(self.elements) * c.convert_unit(from_='g', to='kg') / c.Na self.q_trans2D = self.A_st * (2 * np.pi * self.MW * c.kb('J/K') * c.T0('K')) / c.h('J s')**2
def get_SoR(self, T, P=c.P0('bar')): """Calculates the dimensionless entropy :math:`\\frac{S^{trans}}{R}=1+\\frac{n_{degrees}}{2}+\\log\\bigg(\\big( \\frac{2\\pi mk_bT}{h^2})^\\frac{n_{degrees}}{2}\\frac{RT}{PN_a}\\bigg)` Parameters ---------- T : float Temperature in K P : float, optional Pressure (bar) or pressure-like quantity. Default is atmospheric pressure Returns ------- SoR_trans : float Translational dimensionless entropy """ V = self.get_V(T=T, P=P) unit_mass = self.molecular_weight *\ c.convert_unit(from_='g', to='kg')/c.Na return 1. + float(self.n_degrees)/2. \ + np.log((2.*np.pi*unit_mass*c.kb('J/K')*T/c.h('J s')**2) ** (float(self.n_degrees)/2.)*V/c.Na)
def get_q(self, T, ignore_q_elec=True): """Calculates the partition function :math:`q^{elec}=1 + \\omega_i \\exp\\bigg(-\\frac{E}{RT}\\bigg)` Parameters ---------- T : float Temperature in K ignore_q_elec : bool, optional Ignore contribution of electronic mode to partition function . Often necessary since DFT's value for potentialenergy is very negative causing q_elec to go to infinity. Default is True Returns ------- q_elec : float Electronic partition function """ if ignore_q_elec: return 1. else: if self.D0 is not None: Epsilon = self.D0/c.kb('eV/K')/T else: Epsilon = self.get_UoRT(T=T) return self._degeneracy*(1 + np.exp(-Epsilon))
def get_ZPE(self): """Calculates the zero point energy :math:`u^0_E=u+\\frac{3}{2}\\Theta_E k_B` Returns ------- ZPE : float Zero point energy in eV """ return self.interaction_energy \ + 1.5*self.einstein_temperature*c.kb('eV/K')
def get_ZPE(self): """Calculates the zero point energy :math:`ZPE=\\frac{1}{2}k_b\\sum_i \\Theta_{V,i}` Returns ------- zpe : float Zero point energy in eV """ valid_wavenumbers = _get_valid_vib_wavenumbers( wavenumbers=self.vib_wavenumbers, substitute=self.imaginary_substitute) vib_temperatures = c.wavenumber_to_temp(valid_wavenumbers) return 0.5 * c.kb('eV/K') * np.sum(vib_temperatures)
def get_UoRT(self, T): """Calculates the imensionless internal energy :math:`\\frac{U^{elec}}{RT}=\\frac{E}{RT}` Parameters ---------- T : float Temperature in K Returns ------- UoRT_elec : float Electronic dimensionless internal energy """ return (self.potentialenergy)/c.kb('eV/K')/T
def _get_SoR_RRHO(self, T, vib_inertia): """Calculates the dimensionless RRHO contribution to entropy Parameters ---------- T : float Temperature in K vib_inertia : float Vibrational inertia in kg m2 Returns ------- SoR_RHHO : float Dimensionless entropy of Rigid Rotor Harmonic Oscillator """ return 0.5 + np.log( (8. * np.pi**3 * vib_inertia * c.kb('J/K') * T / c.h('J s')**2)** 0.5)
def get_UoRT(self, T): """Calculates the dimensionless internal energy :math:`\\frac{U^{vib}}{RT}=\\frac{u^0_E}{k_BT}+3\\frac{\\Theta_E}{T} \\bigg(\\frac{\\exp(-\\frac{\\Theta_E}{T})}{1-\\exp(-\\frac{\\Theta_E} {T})}\\bigg)` Parameters ---------- T : float Temperature in K Returns ------- UoRT_vib : float Vibrational dimensionless internal energy """ theta_E = self.einstein_temperature return self.get_ZPE()/c.kb('eV/K')/T \ + 3.*theta_E/T*np.exp(-theta_E/T)/(1. - np.exp(-theta_E/T))
def get_q(self, T): """Calculates the partition function :math:`q^{vib}=\\exp\\bigg({\\frac{-u}{k_BT}}\\bigg)\\bigg(\\frac{ \\exp(-\\frac{\\Theta_E}{2T})}{1-\\exp(\\frac{-\\Theta_E}{T})}\\bigg)` Parameters ---------- T : float Temperature in K Returns ------- q_vib : float Vibrational partition function """ u = self.interaction_energy theta_E = self.einstein_temperature return np.exp(-u/c.kb('eV/K')/T) \ * (np.exp(-theta_E/2./T)/(1. - np.exp(-theta_E/T)))
def get_ZPE(self): """Calculates the zero point energy :math:`ZPE=\\frac{1}{2}k_b\\sum_i \\omega_i\\Theta_{V,i}` Returns ------- zpe : float Zero point energy in eV """ zpe = [] valid_wavenumbers = _get_valid_vib_wavenumbers( wavenumbers=self.vib_wavenumbers, substitute=self.imaginary_substitute) vib_temperatures = c.wavenumber_to_temp(valid_wavenumbers) scaled_wavenumbers = self._get_scaled_wavenumber(valid_wavenumbers) for theta_i, w_i in zip(vib_temperatures, scaled_wavenumbers): zpe = 0.5 * c.kb('eV/K') * theta_i * w_i return np.sum(zpe)
def get_q(self, T, P=c.P0('bar')): """Calculates the partition function :math:`q_{trans} = \\bigg(\\frac{2\\pi \\sum_{i}^{atoms}m_ikT}{h^2} \\bigg)^\\frac {n_{degrees}} {2}V` Parameters ---------- T : float Temperature in K P : float, optional Pressure (bar) or pressure-like quantity. Default is atmospheric pressure Returns ------- q_trans : float Translational partition function """ V = self.get_V(T=T, P=P) unit_mass = self.molecular_weight *\ c.convert_unit(from_='g', to='kg')/c.Na return V*(2*np.pi*c.kb('J/K')*T*unit_mass/c.h('J s')**2) \ ** (float(self.n_degrees)/2.)
def test_kb(self): self.assertEqual(c.kb('J/K'), 1.38064852e-23) with self.assertRaises(KeyError): c.kb('arbitrary unit')