def load_all_methods(self, load_data):
r'''Method which picks out coefficients for the specified chemical
from the various dictionaries and DataFrames storing it. All data is
stored as attributes. This method also sets :obj:`Tmin`, :obj:`Tmax`,
and :obj:`all_methods` as a set of methods for which the data exists for.
Called on initialization only. See the source code for the variables at
which the coefficients are stored. The coefficients can safely be
altered once the class is initialized. This method can be called again
to reset the parameters.
'''
methods = []
self.T_limits = T_limits = {}
if load_data:
if self.CASRN in permittivity.permittivity_data_CRC.index:
methods.append(CRC_CONSTANT)
self.CRC_CONSTANT_T, self.CRC_permittivity, A, B, C, D, Tmin, Tmax = permittivity.permittivity_values_CRC[
permittivity.permittivity_data_CRC.index.get_loc(
self.CASRN)].tolist()
if isnan(Tmin) and isnan(Tmax):
Tmin, Tmax = self.CRC_CONSTANT_T, self.CRC_CONSTANT_T
T_limits[CRC_CONSTANT] = (self.CRC_CONSTANT_T,
self.CRC_CONSTANT_T)
self.CRC_coeffs = [0 if isnan(x) else x for x in [A, B, C, D]]
self.CRC_Tmin = Tmin
self.CRC_Tmax = Tmax
if self.CRC_coeffs[0] and not isnan(Tmin):
methods.append(CRC)
T_limits[CRC] = (Tmin, Tmax)
self.all_methods = set(methods)
def RI(CASRN, method=None):
r'''This function handles the retrieval of a chemical's refractive
index. Lookup is based on CASRNs. Will automatically select a data source
to use if no method is provided; returns None if the data is not available.
Function has data for approximately 4500 chemicals.
Parameters
----------
CASRN : str
CASRN [-]
Returns
-------
RI : float
Refractive Index on the Na D line, [-]
T : float or None
Temperature at which refractive index reading was made; None if not
available, [K]
Other Parameters
----------------
method : string, optional
A string for the method name to use, as defined by constants in
RI_methods
Notes
-----
Only one source is available in this function. It is:
* 'CRC', a compillation of Organic RI data in [1]_.
Examples
--------
>>> RI(CASRN='64-17-5')
(1.3611, 293.15)
>>> RI("60-35-5")
(1.4278, None)
References
----------
.. [1] Haynes, W.M., Thomas J. Bruno, and David R. Lide. CRC Handbook of
Chemistry and Physics, 95E. Boca Raton, FL: CRC press, 2014.
'''
if not _RI_data_loaded: _load_RI_data()
key = ('RI', 'RIT')
if method:
value = retrieve_from_df_dict(RI_sources, CASRN, key, method)
else:
value = retrieve_any_from_df_dict(RI_sources, CASRN, key)
if value is None:
value = (None, None)
else:
if isnan(value[1]):
value = (value[0], None)
else:
value = tuple(value)
return value
def _method_indexes():
'''Returns a dictionary of method: index for all methods
that use data files to retrieve constants. The use of this function
ensures the data files are not loaded until they are needed.
'''
A = permittivity.permittivity_data_CRC['A'].values
return {
CRC_CONSTANT:
permittivity.permittivity_data_CRC.index,
CRC: [
CAS for i, CAS in enumerate(
permittivity.permittivity_data_CRC.index)
if not isnan(A[i])
],
}
def load_all_methods(self, load_data):
r'''Method which picks out coefficients for the specified chemical
from the various dictionaries and DataFrames storing it. All data is
stored as attributes. This method also sets :obj:`Tmin`, :obj:`Tmax`,
and :obj:`all_methods` as a set of methods for which the data exists for.
Called on initialization only. See the source code for the variables at
which the coefficients are stored. The coefficients can safely be
altered once the class is initialized. This method can be called again
to reset the parameters.
'''
methods = []
self.T_limits = T_limits = {}
if load_data:
if self.CASRN in interface.sigma_data_Mulero_Cachadina.index:
methods.append(STREFPROP)
sigma0, n0, sigma1, n1, sigma2, n2, Tc, self.STREFPROP_Tmin, self.STREFPROP_Tmax = interface.sigma_values_Mulero_Cachadina[
interface.sigma_data_Mulero_Cachadina.index.get_loc(
self.CASRN)].tolist()
self.STREFPROP_coeffs = [
sigma0, n0, sigma1, n1, sigma2, n2, Tc
]
T_limits[STREFPROP] = (self.STREFPROP_Tmin,
self.STREFPROP_Tmax)
if self.CASRN in interface.sigma_data_Somayajulu2.index:
methods.append(SOMAYAJULU2)
self.SOMAYAJULU2_Tt, self.SOMAYAJULU2_Tc, A, B, C = interface.sigma_values_Somayajulu2[
interface.sigma_data_Somayajulu2.index.get_loc(
self.CASRN)].tolist()
self.SOMAYAJULU2_coeffs = [A, B, C]
T_limits[SOMAYAJULU2] = (self.SOMAYAJULU2_Tt,
self.SOMAYAJULU2_Tc)
if self.CASRN in interface.sigma_data_Somayajulu.index:
methods.append(SOMAYAJULU)
self.SOMAYAJULU_Tt, self.SOMAYAJULU_Tc, A, B, C = interface.sigma_values_Somayajulu[
interface.sigma_data_Somayajulu.index.get_loc(
self.CASRN)].tolist()
self.SOMAYAJULU_coeffs = [A, B, C]
T_limits[SOMAYAJULU] = (self.SOMAYAJULU_Tt, self.SOMAYAJULU_Tc)
if self.CASRN in miscdata.VDI_saturation_dict:
methods.append(VDI_TABULAR)
Ts, props = lookup_VDI_tabular_data(self.CASRN, 'sigma')
self.VDI_Tmin = Ts[0]
self.VDI_Tmax = Ts[-1]
self.tabular_data[VDI_TABULAR] = (Ts, props)
T_limits[VDI_TABULAR] = (self.VDI_Tmin, self.VDI_Tmax)
if self.CASRN in interface.sigma_data_Jasper_Lange.index:
methods.append(JASPER)
a, b, self.JASPER_Tmin, self.JASPER_Tmax = interface.sigma_values_Jasper_Lange[
interface.sigma_data_Jasper_Lange.index.get_loc(
self.CASRN)].tolist()
if isnan(self.JASPER_Tmax
) or self.JASPER_Tmax == self.JASPER_Tmin:
# Some data is missing; and some is on a above the limit basis
self.JASPER_Tmax = a / b + 273.15
if isnan(self.JASPER_Tmin):
self.JASPER_Tmin = 0.0
self.JASPER_coeffs = [a, b]
T_limits[JASPER] = (self.JASPER_Tmin, self.JASPER_Tmax)
if self.CASRN in interface.sigma_data_VDI_PPDS_11.index:
Tm, Tc, A, B, C, D, E = interface.sigma_values_VDI_PPDS_11[
interface.sigma_data_VDI_PPDS_11.index.get_loc(
self.CASRN)].tolist()
self.VDI_PPDS_coeffs = [A, B, C, D, E]
self.VDI_PPDS_Tc = Tc
self.VDI_PPDS_Tm = Tm
methods.append(VDI_PPDS)
T_limits[VDI_PPDS] = (self.VDI_PPDS_Tm, self.VDI_PPDS_Tc)
if all((self.Tc, self.Vc, self.omega)):
methods.append(MIQUEU)
T_limits[MIQUEU] = (0.0, self.Tc)
if all((self.Tb, self.Tc, self.Pc)):
methods.append(BROCK_BIRD)
methods.append(SASTRI_RAO)
T_limits[BROCK_BIRD] = T_limits[SASTRI_RAO] = (0.0, self.Tc)
if all((self.Tc, self.Pc, self.omega)):
methods.append(PITZER)
methods.append(ZUO_STENBY)
T_limits[PITZER] = T_limits[ZUO_STENBY] = (1e-10, self.Tc)
if all((self.Tb, self.Hvap_Tb, self.MW)):
# Cache Cpl at Tb for ease of calculation of Tmax
self.Cpl_Tb = self.Cpl(self.Tb) if hasattr(
self.Cpl, '__call__') else self.Cpl
if self.Cpl_Tb:
self.Cpl_Tb = property_molar_to_mass(self.Cpl_Tb, self.MW)
methods.append(ALEEM)
# Tmin and Tmax for this method is known
Tmax_possible = self.Tb + self.Hvap_Tb / self.Cpl_Tb
# This method will ruin solve_property as it is typically valid
# well above Tc. If Tc is available, limit it to that.
if self.Tc:
Tmax_possible = min(self.Tc, Tmax_possible)
T_limits[ALEEM] = (0.0, Tmax_possible)
self.all_methods = set(methods)
def load_all_methods(self, load_data=True):
r'''Method which picks out coefficients for the specified chemical
from the various dictionaries and DataFrames storing it. All data is
stored as attributes. This method also sets :obj:`Tmin`, :obj:`Tmax`,
and :obj:`all_methods` as a set of methods for which the data exists for.
Called on initialization only. See the source code for the variables at
which the coefficients are stored. The coefficients can safely be
altered once the class is initialized. This method can be called again
to reset the parameters.
'''
self.T_limits = T_limits = {}
methods = []
Tmins, Tmaxs = [], []
if load_data:
if self.CASRN in vapor_pressure.Psat_data_WagnerMcGarry.index:
methods.append(WAGNER_MCGARRY)
A, B, C, D, self.WAGNER_MCGARRY_Pc, self.WAGNER_MCGARRY_Tc, self.WAGNER_MCGARRY_Tmin = vapor_pressure.Psat_values_WagnerMcGarry[
vapor_pressure.Psat_data_WagnerMcGarry.index.get_loc(
self.CASRN)].tolist()
self.WAGNER_MCGARRY_coefs = [A, B, C, D]
Tmins.append(self.WAGNER_MCGARRY_Tmin)
Tmaxs.append(self.WAGNER_MCGARRY_Tc)
T_limits[WAGNER_MCGARRY] = (self.WAGNER_MCGARRY_Tmin,
self.WAGNER_MCGARRY_Tc)
if self.CASRN in vapor_pressure.Psat_data_WagnerPoling.index:
methods.append(WAGNER_POLING)
A, B, C, D, self.WAGNER_POLING_Tc, self.WAGNER_POLING_Pc, Tmin, self.WAGNER_POLING_Tmax = vapor_pressure.Psat_values_WagnerPoling[
vapor_pressure.Psat_data_WagnerPoling.index.get_loc(
self.CASRN)].tolist()
# Some Tmin values are missing; Arbitrary choice of 0.1 lower limit
self.WAGNER_POLING_Tmin = Tmin if not isnan(
Tmin) else self.WAGNER_POLING_Tmax * 0.1
self.WAGNER_POLING_coefs = [A, B, C, D]
Tmins.append(Tmin)
Tmaxs.append(self.WAGNER_POLING_Tmax)
T_limits[WAGNER_POLING] = (self.WAGNER_POLING_Tmin,
self.WAGNER_POLING_Tmax)
if self.CASRN in vapor_pressure.Psat_data_AntoineExtended.index:
methods.append(ANTOINE_EXTENDED_POLING)
A, B, C, Tc, to, n, E, F, self.ANTOINE_EXTENDED_POLING_Tmin, self.ANTOINE_EXTENDED_POLING_Tmax = vapor_pressure.Psat_values_AntoineExtended[
vapor_pressure.Psat_data_AntoineExtended.index.get_loc(
self.CASRN)].tolist()
self.ANTOINE_EXTENDED_POLING_coefs = [Tc, to, A, B, C, n, E, F]
Tmins.append(self.ANTOINE_EXTENDED_POLING_Tmin)
Tmaxs.append(self.ANTOINE_EXTENDED_POLING_Tmax)
T_limits[ANTOINE_EXTENDED_POLING] = (
self.ANTOINE_EXTENDED_POLING_Tmin,
self.ANTOINE_EXTENDED_POLING_Tmax)
if self.CASRN in vapor_pressure.Psat_data_AntoinePoling.index:
methods.append(ANTOINE_POLING)
A, B, C, self.ANTOINE_POLING_Tmin, self.ANTOINE_POLING_Tmax = vapor_pressure.Psat_values_AntoinePoling[
vapor_pressure.Psat_data_AntoinePoling.index.get_loc(
self.CASRN)].tolist()
self.ANTOINE_POLING_coefs = [A, B, C]
Tmins.append(self.ANTOINE_POLING_Tmin)
Tmaxs.append(self.ANTOINE_POLING_Tmax)
T_limits[ANTOINE_POLING] = (self.ANTOINE_POLING_Tmin,
self.ANTOINE_POLING_Tmax)
if self.CASRN in vapor_pressure.Psat_data_Perrys2_8.index:
methods.append(DIPPR_PERRY_8E)
C1, C2, C3, C4, C5, self.Perrys2_8_Tmin, self.Perrys2_8_Tmax = vapor_pressure.Psat_values_Perrys2_8[
vapor_pressure.Psat_data_Perrys2_8.index.get_loc(
self.CASRN)].tolist()
self.Perrys2_8_coeffs = [C1, C2, C3, C4, C5]
Tmins.append(self.Perrys2_8_Tmin)
Tmaxs.append(self.Perrys2_8_Tmax)
T_limits[DIPPR_PERRY_8E] = (self.Perrys2_8_Tmin,
self.Perrys2_8_Tmax)
if has_CoolProp() and self.CASRN in coolprop_dict:
methods.append(COOLPROP)
self.CP_f = coolprop_fluids[self.CASRN]
Tmins.append(self.CP_f.Tmin)
Tmaxs.append(self.CP_f.Tc)
T_limits[COOLPROP] = (self.CP_f.Tmin, self.CP_f.Tc)
if self.CASRN in miscdata.VDI_saturation_dict:
methods.append(VDI_TABULAR)
Ts, props = lookup_VDI_tabular_data(self.CASRN, 'P')
self.VDI_Tmin = Ts[0]
self.VDI_Tmax = Ts[-1]
self.tabular_data[VDI_TABULAR] = (Ts, props)
Tmins.append(self.VDI_Tmin)
Tmaxs.append(self.VDI_Tmax)
T_limits[VDI_TABULAR] = (self.VDI_Tmin, self.VDI_Tmax)
if self.CASRN in vapor_pressure.Psat_data_VDI_PPDS_3.index:
Tm, Tc, Pc, A, B, C, D = vapor_pressure.Psat_values_VDI_PPDS_3[
vapor_pressure.Psat_data_VDI_PPDS_3.index.get_loc(
self.CASRN)].tolist()
self.VDI_PPDS_coeffs = [A, B, C, D]
self.VDI_PPDS_Tc = Tc
self.VDI_PPDS_Tm = Tm
self.VDI_PPDS_Pc = Pc
methods.append(VDI_PPDS)
Tmins.append(self.VDI_PPDS_Tm)
Tmaxs.append(self.VDI_PPDS_Tc)
T_limits[VDI_PPDS] = (self.VDI_PPDS_Tm, self.VDI_PPDS_Tc)
if all((self.Tb, self.Tc, self.Pc)):
methods.append(BOILING_CRITICAL)
Tmins.append(0.01)
Tmaxs.append(self.Tc)
T_limits[BOILING_CRITICAL] = (0.01, self.Tc)
if all((self.Tc, self.Pc, self.omega)):
methods.append(LEE_KESLER_PSAT)
methods.append(AMBROSE_WALTON)
methods.append(SANJARI)
methods.append(EDALAT)
if self.eos:
methods.append(EOS)
T_limits[EOS] = (0.1 * self.Tc, self.Tc)
Tmins.append(0.01)
Tmaxs.append(self.Tc)
T_limits[LEE_KESLER_PSAT] = T_limits[AMBROSE_WALTON] = T_limits[
SANJARI] = T_limits[EDALAT] = (0.01, self.Tc)
self.all_methods = set(methods)
if Tmins and Tmaxs:
self.Tmin = min(Tmins)
self.Tmax = max(Tmaxs)
def load_all_methods(self, load_data=True):
r'''Method which picks out coefficients for the specified chemical
from the various dictionaries and DataFrames storing it. All data is
stored as attributes. This method also sets :obj:`Tmin`, :obj:`Tmax`,
and :obj:`all_methods` as a set of methods for which the data exists for.
Called on initialization only. See the source code for the variables at
which the coefficients are stored. The coefficients can safely be
altered once the class is initialized. This method can be called again
to reset the parameters.
'''
methods = []
self.T_limits = T_limits = {}
if load_data:
if has_CoolProp() and self.CASRN in coolprop_dict:
methods.append(COOLPROP)
self.CP_f = coolprop_fluids[self.CASRN]
T_limits[COOLPROP] = (self.CP_f.Tt, self.CP_f.Tc * .9999)
if self.CASRN in miscdata.VDI_saturation_dict:
methods.append(VDI_TABULAR)
Ts, props = lookup_VDI_tabular_data(self.CASRN, 'Hvap')
self.VDI_Tmin = Ts[0]
self.VDI_Tmax = Ts[-1]
self.tabular_data[VDI_TABULAR] = (Ts, props)
T_limits[VDI_TABULAR] = (self.VDI_Tmin, self.VDI_Tmax)
if self.CASRN in phase_change.phase_change_data_Alibakhshi_Cs.index and self.Tc is not None:
methods.append(ALIBAKHSHI)
self.Alibakhshi_C = float(
phase_change.phase_change_data_Alibakhshi_Cs.at[self.CASRN,
'C'])
T_limits[ALIBAKHSHI] = (self.Tc * .3, max(self.Tc - 100., 0))
if self.CASRN in phase_change.Hvap_data_CRC.index and not isnan(
phase_change.Hvap_data_CRC.at[self.CASRN, 'HvapTb']):
methods.append(CRC_HVAP_TB)
self.CRC_HVAP_TB_Tb = float(
phase_change.Hvap_data_CRC.at[self.CASRN, 'Tb'])
self.CRC_HVAP_TB_Hvap = float(
phase_change.Hvap_data_CRC.at[self.CASRN, 'HvapTb'])
if self.Tc is not None:
T_limits[CRC_HVAP_TB] = (self.Tc * .001, self.Tc)
else:
T_limits[CRC_HVAP_TB] = (self.CRC_HVAP_TB_Tb,
self.CRC_HVAP_TB_Tb)
if self.CASRN in phase_change.Hvap_data_CRC.index and not isnan(
phase_change.Hvap_data_CRC.at[self.CASRN, 'Hvap298']):
methods.append(CRC_HVAP_298)
self.CRC_HVAP_298 = float(
phase_change.Hvap_data_CRC.at[self.CASRN, 'Hvap298'])
if self.Tc is not None:
T_limits[CRC_HVAP_298] = (self.Tc * .001, self.Tc)
else:
T_limits[CRC_HVAP_298] = (298.15, 298.15)
if self.CASRN in phase_change.Hvap_data_Gharagheizi.index:
methods.append(GHARAGHEIZI_HVAP_298)
self.GHARAGHEIZI_HVAP_298_Hvap = float(
phase_change.Hvap_data_Gharagheizi.at[self.CASRN,
'Hvap298'])
if self.Tc is not None:
T_limits[GHARAGHEIZI_HVAP_298] = (self.Tc * .001, self.Tc)
else:
T_limits[GHARAGHEIZI_HVAP_298] = (298.15, 298.15)
if self.CASRN in phase_change.phase_change_data_Perrys2_150.index:
methods.append(DIPPR_PERRY_8E)
Tc, C1, C2, C3, C4, self.Perrys2_150_Tmin, self.Perrys2_150_Tmax = phase_change.phase_change_values_Perrys2_150[
phase_change.phase_change_data_Perrys2_150.index.get_loc(
self.CASRN)].tolist()
self.Perrys2_150_coeffs = [Tc, C1, C2, C3, C4]
T_limits[DIPPR_PERRY_8E] = (self.Perrys2_150_Tmin,
self.Perrys2_150_Tmax)
if self.CASRN in phase_change.phase_change_data_VDI_PPDS_4.index:
Tc, A, B, C, D, E = phase_change.phase_change_values_VDI_PPDS_4[
phase_change.phase_change_data_VDI_PPDS_4.index.get_loc(
self.CASRN)].tolist()
self.VDI_PPDS_coeffs = [A, B, C, D, E]
self.VDI_PPDS_Tc = Tc
methods.append(VDI_PPDS)
T_limits[VDI_PPDS] = (0.1 * self.VDI_PPDS_Tc, self.VDI_PPDS_Tc)
if all((self.Tc, self.omega)):
methods.extend(self.CSP_methods)
for m in self.CSP_methods:
T_limits[m] = (1e-4, self.Tc)
if all((self.Tc, self.Pc)):
methods.append(CLAPEYRON)
T_limits[CLAPEYRON] = (1e-4, self.Tc)
if all((self.Tb, self.Tc, self.Pc)):
methods.extend(self.boiling_methods)
for m in self.boiling_methods:
T_limits[m] = (1e-4, self.Tc)
self.all_methods = set(methods)
