class TestDiffusionLimited(unittest.TestCase): """ Contains unit tests of the DiffusionLimited class. """ def setUp(self): """ A function run before each unit test in this class. """ octyl_pri = Species( label="", thermo=NASA( polynomials=[ NASAPolynomial( coeffs=[-0.772759, 0.093255, -5.84447e-05, 1.8557e-08, -2.37127e-12, -3926.9, 37.6131], Tmin=(298, 'K'), Tmax=(1390, 'K')), NASAPolynomial( coeffs=[25.051, 0.036948, -1.25765e-05, 1.94628e-09, -1.12669e-13, -13330.1, -102.557], Tmin=(1390, 'K'), Tmax=(5000, 'K')) ], Tmin=(298, 'K'), Tmax=(5000, 'K'), Cp0=(33.2579, 'J/(mol*K)'), CpInf=(577.856, 'J/(mol*K)'), comment="""Thermo library: JetSurF0.2"""), molecule=[Molecule(smiles="[CH2]CCCCCCC")] ) octyl_sec = Species( label="", thermo=NASA( polynomials=[ NASAPolynomial( coeffs=[-0.304233, 0.0880077, -4.90743e-05, 1.21858e-08, -8.87773e-13, -5237.93, 36.6583], Tmin=(298, 'K'), Tmax=(1383, 'K')), NASAPolynomial( coeffs=[24.9044, 0.0366394, -1.2385e-05, 1.90835e-09, -1.10161e-13, -14713.5, -101.345], Tmin=(1383, 'K'), Tmax=(5000, 'K')) ], Tmin=(298, 'K'), Tmax=(5000, 'K'), Cp0=(33.2579, 'J/(mol*K)'), CpInf=(577.856, 'J/(mol*K)'), comment="""Thermo library: JetSurF0.2"""), molecule=[Molecule(smiles="CC[CH]CCCCC")] ) ethane = Species( label="", thermo=ThermoData( Tdata=([300, 400, 500, 600, 800, 1000, 1500], 'K'), Cpdata=([10.294, 12.643, 14.933, 16.932, 20.033, 22.438, 26.281], 'cal/(mol*K)'), H298=(12.549, 'kcal/mol'), S298=(52.379, 'cal/(mol*K)'), Cp0=(33.2579, 'J/(mol*K)'), CpInf=(133.032, 'J/(mol*K)'), comment="""Thermo library: CH"""), molecule=[Molecule(smiles="C=C")] ) decyl = Species( label="", thermo=NASA( polynomials=[ NASAPolynomial( coeffs=[-1.31358, 0.117973, -7.51843e-05, 2.43331e-08, -3.17523e-12, -9689.68, 43.501], Tmin=(298, 'K'), Tmax=(1390, 'K')), NASAPolynomial( coeffs=[31.5697, 0.0455818, -1.54995e-05, 2.39711e-09, -1.3871e-13, -21573.8, -134.709], Tmin=(1390, 'K'), Tmax=(5000, 'K')) ], Tmin=(298, 'K'), Tmax=(5000, 'K'), Cp0=(33.2579, 'J/(mol*K)'), CpInf=(719.202, 'J/(mol*K)'), comment="""Thermo library: JetSurF0.2"""), molecule=[Molecule(smiles="[CH2]CCCCCCCCC")] ) acetone = Species( label="", thermo=NASA( polynomials=[ NASAPolynomial( coeffs=[3.75568, 0.0264934, -6.55661e-05, 1.94971e-07, -1.82059e-10, -27905.3, 9.0162], Tmin=(10, 'K'), Tmax=(422.477, 'K')), NASAPolynomial( coeffs=[0.701289, 0.0344988, -1.9736e-05, 5.48052e-09, -5.92612e-13, -27460.6, 23.329], Tmin=(422.477, 'K'), Tmax=(3000, 'K')) ], Tmin=(10, 'K'), Tmax=(3000, 'K'), E0=(-232.025, 'kJ/mol'), Cp0=(33.2579, 'J/(mol*K)'), CpInf=(232.805, 'J/(mol*K)')), molecule=[Molecule(smiles="CC(=O)C")] ) peracetic_acid = Species( label="", thermo=NASA( polynomials=[ NASAPolynomial( coeffs=[3.81786, 0.016419, 3.32204e-05, -8.98403e-08, 6.63474e-11, -42057.8, 9.65245], Tmin=(10, 'K'), Tmax=(354.579, 'K')), NASAPolynomial( coeffs=[2.75993, 0.0283534, -1.72659e-05, 5.08158e-09, -5.77773e-13, -41982.8, 13.6595], Tmin=(354.579, 'K'), Tmax=(3000, 'K')) ], Tmin=(10, 'K'), Tmax=(3000, 'K'), E0=(-349.698, 'kJ/mol'), Cp0=(33.2579, 'J/(mol*K)'), CpInf=(199.547, 'J/(mol*K)')), molecule=[Molecule(smiles="CC(=O)OO")] ) acetic_acid = Species( label="", thermo=NASA( polynomials=[ NASAPolynomial( coeffs=[3.97665, 0.00159915, 8.5542e-05, -1.76486e-07, 1.20201e-10, -53911.5, 8.99309], Tmin=(10, 'K'), Tmax=(375.616, 'K')), NASAPolynomial( coeffs=[1.57088, 0.0272146, -1.67357e-05, 5.01453e-09, -5.82273e-13, -53730.7, 18.2442], Tmin=(375.616, 'K'), Tmax=(3000, 'K')) ], Tmin=(10, 'K'), Tmax=(3000, 'K'), E0=(-448.245, 'kJ/mol'), Cp0=(33.2579, 'J/(mol*K)'), CpInf=(182.918, 'J/(mol*K)')), molecule=[Molecule(smiles="CC(=O)O")] ) criegee = Species( label="", thermo=NASA( polynomials=[ NASAPolynomial( coeffs=[3.23876, 0.0679583, -3.35611e-05, 7.91519e-10, 3.13038e-12, -77986, 13.6438], Tmin=(10, 'K'), Tmax=(1053.46, 'K')), NASAPolynomial( coeffs=[9.84525, 0.0536795, -2.86165e-05, 7.39945e-09, -7.48482e-13, -79977.6, -21.4187], Tmin=(1053.46, 'K'), Tmax=(3000, 'K')) ], Tmin=(10, 'K'), Tmax=(3000, 'K'), E0=(-648.47, 'kJ/mol'), Cp0=(33.2579, 'J/(mol*K)'), CpInf=(457.296, 'J/(mol*K)')), molecule=[Molecule(smiles="CC(=O)OOC(C)(O)C")] ) self.database = SolvationDatabase() self.database.load(os.path.join(settings['database.directory'], 'solvation')) self.solvent = 'octane' diffusion_limiter.enable(self.database.get_solvent_data(self.solvent), self.database) self.T = 298 self.uni_reaction = Reaction(reactants=[octyl_pri], products=[octyl_sec]) self.uni_reaction.kinetics = Arrhenius(A=(2.0, '1/s'), n=0, Ea=(0, 'kJ/mol')) self.bi_uni_reaction = Reaction(reactants=[octyl_pri, ethane], products=[decyl]) self.bi_uni_reaction.kinetics = Arrhenius(A=(1.0E-22, 'cm^3/molecule/s'), n=0, Ea=(0, 'kJ/mol')) self.tri_bi_reaction = Reaction(reactants=[acetone, peracetic_acid, acetic_acid], products=[criegee, acetic_acid]) self.tri_bi_reaction.kinetics = Arrhenius(A=(1.07543e-11, 'cm^6/(mol^2*s)'), n=5.47295, Ea=(-38.5379, 'kJ/mol')) self.intrinsic_rates = { self.uni_reaction: self.uni_reaction.kinetics.get_rate_coefficient(self.T, P=100e5), self.bi_uni_reaction: self.bi_uni_reaction.kinetics.get_rate_coefficient(self.T, P=100e5), self.tri_bi_reaction: self.tri_bi_reaction.kinetics.get_rate_coefficient(self.T, P=100e5), } def tearDown(self): diffusion_limiter.disable() def test_get_effective_rate_unimolecular(self): """ Tests that the effective rate is the same as the intrinsic rate for unimiolecular reactions. """ effective_rate = diffusion_limiter.get_effective_rate(self.uni_reaction, self.T) self.assertEqual(effective_rate, self.intrinsic_rates[self.uni_reaction]) def test_get_effective_rate_2_to_1(self): """ Tests that the effective rate is limited in the forward direction for a 2 -> 1 reaction """ effective_rate = diffusion_limiter.get_effective_rate(self.bi_uni_reaction, self.T) self.assertTrue(effective_rate < self.intrinsic_rates[self.bi_uni_reaction]) self.assertTrue(effective_rate >= 0.2 * self.intrinsic_rates[self.bi_uni_reaction]) def test_get_effective_rate_3_to_2(self): """ Tests that the effective rate is limited for a 3 -> 2 reaction """ effective_rate = diffusion_limiter.get_effective_rate(self.tri_bi_reaction, self.T) self.assertTrue(effective_rate < self.intrinsic_rates[self.tri_bi_reaction]) self.assertTrue(effective_rate >= 0.2 * self.intrinsic_rates[self.tri_bi_reaction])
class TestSoluteDatabase(TestCase): def setUp(self): self.database = SolvationDatabase() self.database.load( os.path.join(settings['database.directory'], 'solvation')) def tearDown(self): """ Reset the database & liquid parameters for solution """ import rmgpy.data.rmg rmgpy.data.rmg.database = None def test_solute_library(self): """Test we can obtain solute parameters from a library""" species = Species(molecule=[ Molecule(smiles='COC=O') ]) # methyl formate - we know this is in the solute library library_data = self.database.get_solute_data_from_library( species, self.database.libraries['solute']) self.assertEqual(len(library_data), 3) solute_data = self.database.get_solute_data(species) self.assertTrue(isinstance(solute_data, SoluteData)) s = solute_data.S self.assertEqual(s, 0.68) self.assertTrue(solute_data.V is not None) def test_mcgowan(self): """Test we can calculate and set the McGowan volume for species containing H,C,O,N or S""" self.testCases = [ ['CCCCCCCC', 1.2358], # n-octane, in library ['C(CO)O', 0.5078], # ethylene glycol ['CC#N', 0.4042], # acetonitrile ['CCS', 0.5539] # ethanethiol ] for smiles, volume in self.testCases: species = Species(molecule=[Molecule(smiles=smiles)]) solute_data = self.database.get_solute_data(species) solute_data.set_mcgowan_volume( species) # even if it was found in library, recalculate self.assertIsNotNone( solute_data.V ) # so if it wasn't found in library, we should have calculated it self.assertAlmostEqual( solute_data.V, volume ) # the volume is what we expect given the atoms and bonds def test_diffusivity(self): """Test that for a given solvent viscosity and temperature we can calculate a solute's diffusivity""" species = Species(molecule=[Molecule(smiles='O')]) # water solute_data = self.database.get_solute_data(species) temperature = 298. solvent_viscosity = 0.00089 # water is about 8.9e-4 Pa.s d = solute_data.get_stokes_diffusivity(temperature, solvent_viscosity) # m2/s self.assertAlmostEqual((d * 1e9), 1.3, 1) # self-diffusivity of water is about 2e-9 m2/s def test_solvent_library(self): """Test we can obtain solvent parameters from a library""" solvent_data = self.database.get_solvent_data('water') self.assertIsNotNone(solvent_data) self.assertEqual(solvent_data.s_h, 2.836) self.assertRaises(DatabaseError, self.database.get_solvent_data, 'orange_juice') def test_viscosity(self): """Test we can calculate the solvent viscosity given a temperature and its A-E correlation parameters""" solvent_data = self.database.get_solvent_data('water') self.assertAlmostEqual(solvent_data.get_solvent_viscosity(298), 0.0009155) def test_solute_generation(self): """Test we can estimate Abraham solute parameters correctly using group contributions""" self.testCases = [ [ '1,2-ethanediol', 'C(CO)O', 0.823, 0.685, 0.327, 2.572, 0.693, None ], ] for name, smiles, S, B, E, L, A, V in self.testCases: species = Species(smiles=smiles) solute_data = self.database.get_solute_data_from_groups(species) self.assertAlmostEqual(solute_data.S, S, places=2) self.assertAlmostEqual(solute_data.B, B, places=2) self.assertAlmostEqual(solute_data.E, E, places=2) self.assertAlmostEqual(solute_data.L, L, places=2) self.assertAlmostEqual(solute_data.A, A, places=2) def test_solute_with_resonance_structures(self): """ Test we can estimate Abraham solute parameters correctly using group contributions for the solute species with resonance structures. """ smiles = "CC1=CC=CC=C1N" species = Species(smiles=smiles) species.generate_resonance_structures() solute_data = self.database.get_solute_data(species) solvent_data = self.database.get_solvent_data('water') solvation_correction = self.database.get_solvation_correction( solute_data, solvent_data) dGsolv_spc = solvation_correction.gibbs / 1000 for mol in species.molecule: spc = Species(molecule=[mol]) solute_data = self.database.get_solute_data_from_groups(spc) solvation_correction = self.database.get_solvation_correction( solute_data, solvent_data) dGsolv_mol = solvation_correction.gibbs / 1000 if mol == species.molecule[0]: self.assertEqual(dGsolv_spc, dGsolv_mol) else: self.assertNotAlmostEqual(dGsolv_spc, dGsolv_mol) def test_lone_pair_solute_generation(self): """Test we can obtain solute parameters via group additivity for a molecule with lone pairs""" molecule = Molecule().from_adjacency_list(""" CH2_singlet multiplicity 1 1 C u0 p1 c0 {2,S} {3,S} 2 H u0 p0 c0 {1,S} 3 H u0 p0 c0 {1,S} """) species = Species(molecule=[molecule]) solute_data = self.database.get_solute_data_from_groups(species) self.assertIsNotNone(solute_data) def test_solute_data_generation_ammonia(self): """Test we can obtain solute parameters via group additivity for ammonia""" molecule = Molecule().from_adjacency_list(""" 1 N u0 p1 c0 {2,S} {3,S} {4,S} 2 H u0 p0 c0 {1,S} 3 H u0 p0 c0 {1,S} 4 H u0 p0 c0 {1,S} """) species = Species(molecule=[molecule]) solute_data = self.database.get_solute_data_from_groups(species) self.assertIsNotNone(solute_data) def test_solute_data_generation_amide(self): """Test that we can obtain solute parameters via group additivity for an amide""" molecule = Molecule().from_adjacency_list(""" 1 N u0 p1 {2,S} {3,S} {4,S} 2 H u0 {1,S} 3 C u0 {1,S} {6,S} {7,S} {8,S} 4 C u0 {1,S} {5,D} {9,S} 5 O u0 p2 {4,D} 6 H u0 {3,S} 7 H u0 {3,S} 8 H u0 {3,S} 9 H u0 {4,S} """) species = Species(molecule=[molecule]) solute_data = self.database.get_solute_data_from_groups(species) self.assertIsNotNone(solute_data) def test_solute_data_generation_co(self): """Test that we can obtain solute parameters via group additivity for CO.""" molecule = Molecule().from_adjacency_list(""" 1 C u0 p1 c-1 {2,T} 2 O u0 p1 c+1 {1,T} """) species = Species(molecule=[molecule]) solute_data = self.database.get_solute_data_from_groups(species) self.assertIsNotNone(solute_data) def test_radical_and_lone_pair_generation(self): """ Test we can obtain solute parameters via group additivity for a molecule with both lone pairs and a radical """ molecule = Molecule().from_adjacency_list(""" [C]OH multiplicity 2 1 C u1 p1 c0 {2,S} 2 O u0 p2 c0 {1,S} {3,S} 3 H u0 p0 c0 {2,S} """) species = Species(molecule=[molecule]) solute_data = self.database.get_solute_data_from_groups(species) self.assertIsNotNone(solute_data) def test_radical_solute_group(self): """Test that the existing radical group is found for the radical species when using group additivity""" # First check whether the radical group is found for the radical species rad_species = Species(smiles='[OH]') rad_solute_data = self.database.get_solute_data_from_groups( rad_species) self.assertTrue('radical' in rad_solute_data.comment) # Then check that the radical and its saturated species give different solvation free energies saturated_struct = rad_species.molecule[0].copy(deep=True) saturated_struct.saturate_radicals() sat_species = Species(molecule=[saturated_struct]) sat_solute_data = self.database.get_solute_data_from_groups( sat_species) solvent_data = self.database.get_solvent_data('water') rad_solvation_correction = self.database.get_solvation_correction( rad_solute_data, solvent_data) sat_solvation_correction = self.database.get_solvation_correction( sat_solute_data, solvent_data) self.assertNotAlmostEqual(rad_solvation_correction.gibbs / 1000, sat_solvation_correction.gibbs / 1000) def test_correction_generation(self): """Test we can estimate solvation thermochemistry.""" self.testCases = [ # solventName, soluteName, soluteSMILES, Hsolv, Gsolv ['water', 'acetic acid', 'C(C)(=O)O', -56500, -6700 * 4.184], [ 'water', 'naphthalene', 'C1=CC=CC2=CC=CC=C12', -42800, -2390 * 4.184 ], ['1-octanol', 'octane', 'CCCCCCCC', -40080, -4180 * 4.184], ['1-octanol', 'tetrahydrofuran', 'C1CCOC1', -28320, -3930 * 4.184], ['benzene', 'toluene', 'C1(=CC=CC=C1)C', -37660, -5320 * 4.184], ['benzene', '1,4-dioxane', 'C1COCCO1', -39030, -5210 * 4.184] ] for solventName, soluteName, smiles, H, G in self.testCases: species = Species(molecule=[Molecule(smiles=smiles)]) solute_data = self.database.get_solute_data(species) solvent_data = self.database.get_solvent_data(solventName) solvation_correction = self.database.get_solvation_correction( solute_data, solvent_data) self.assertAlmostEqual( solvation_correction.enthalpy / 10000., H / 10000., 0, # 0 decimal place, in 10kJ. msg= "Solvation enthalpy discrepancy ({2:.0f}!={3:.0f}) for {0} in {1}" "".format(soluteName, solventName, solvation_correction.enthalpy, H)) self.assertAlmostEqual( solvation_correction.gibbs / 10000., G / 10000., 0, msg= "Solvation Gibbs free energy discrepancy ({2:.0f}!={3:.0f}) for {0} in {1}" "".format(soluteName, solventName, solvation_correction.gibbs, G)) def test_initial_species(self): """Test we can check whether the solvent is listed as one of the initial species in various scenarios""" # Case 1. when SMILES for solvent is available, the molecular structures of the initial species and the solvent # are compared to check whether the solvent is in the initial species list # Case 1-1: the solvent water is not in the initialSpecies list, so it raises Exception rmg = RMG() rmg.initial_species = [] solute = Species(label='n-octane', molecule=[Molecule().from_smiles('C(CCCCC)CC')]) rmg.initial_species.append(solute) rmg.solvent = 'water' solvent_structure = Species().from_smiles('O') self.assertRaises(Exception, self.database.check_solvent_in_initial_species, rmg, solvent_structure) # Case 1-2: the solvent is now octane and it is listed as the initialSpecies. Although the string # names of the solute and the solvent are different, because the solvent SMILES is provided, # it can identify the 'n-octane' as the solvent rmg.solvent = 'octane' solvent_structure = Species().from_smiles('CCCCCCCC') self.database.check_solvent_in_initial_species(rmg, solvent_structure) self.assertTrue(rmg.initial_species[0].is_solvent) # Case 2: the solvent SMILES is not provided. In this case, it can identify the species as the # solvent by looking at the string name. # Case 2-1: Since 'n-octane and 'octane' are not equal, it raises Exception solvent_structure = None self.assertRaises(Exception, self.database.check_solvent_in_initial_species, rmg, solvent_structure) # Case 2-2: The label 'n-ocatne' is corrected to 'octane', so it is identified as the solvent rmg.initial_species[0].label = 'octane' self.database.check_solvent_in_initial_species(rmg, solvent_structure) self.assertTrue(rmg.initial_species[0].is_solvent) def test_solvent_molecule(self): """Test that we can assign a proper solvent molecular structure when different formats are given""" # solventlibrary.entries['solvent_label'].item should be the instance of Species with the solvent's molecular # structure if the solvent database contains the solvent SMILES or adjacency list. If not, then item is None # Case 1: When the solventDatabase does not contain the solvent SMILES, the item attribute is None solventlibrary = SolventLibrary() solventlibrary.load_entry(index=1, label='water', solvent=None) self.assertTrue(solventlibrary.entries['water'].item is None) # Case 2: When the solventDatabase contains the correct solvent SMILES, the item attribute is the instance of # Species with the correct solvent molecular structure solventlibrary.load_entry(index=2, label='octane', solvent=None, molecule='CCCCCCCC') solvent_species = Species().from_smiles('C(CCCCC)CC') self.assertTrue( solvent_species.is_isomorphic( solventlibrary.entries['octane'].item[0])) # Case 3: When the solventDatabase contains the correct solvent adjacency list, the item attribute # is the instance of the species with the correct solvent molecular structure. # This will display the SMILES Parse Error message from the external function, but ignore it. solventlibrary.load_entry(index=3, label='ethanol', solvent=None, molecule=""" 1 C u0 p0 c0 {2,S} {4,S} {5,S} {6,S} 2 C u0 p0 c0 {1,S} {3,S} {7,S} {8,S} 3 O u0 p2 c0 {2,S} {9,S} 4 H u0 p0 c0 {1,S} 5 H u0 p0 c0 {1,S} 6 H u0 p0 c0 {1,S} 7 H u0 p0 c0 {2,S} 8 H u0 p0 c0 {2,S} 9 H u0 p0 c0 {3,S} """) solvent_species = Species().from_smiles('CCO') self.assertTrue( solvent_species.is_isomorphic( solventlibrary.entries['ethanol'].item[0])) # Case 4: when the solventDatabase contains incorrect values for the molecule attribute, it raises Exception # This will display the SMILES Parse Error message from the external function, but ignore it. self.assertRaises(Exception, solventlibrary.load_entry, index=4, label='benzene', solvent=None, molecule='ring') # Case 5: when the solventDatabase contains data for co-solvents. solventlibrary.load_entry(index=5, label='methanol_50_water_50', solvent=None, molecule=['CO', 'O']) solvent_species_list = [ Species().from_smiles('CO'), Species().from_smiles('O') ] self.assertEqual( len(solventlibrary.entries['methanol_50_water_50'].item), 2) for spc1 in solventlibrary.entries['methanol_50_water_50'].item: self.assertTrue( any([ spc1.is_isomorphic(spc2) for spc2 in solvent_species_list ]))
class TestSoluteDatabase(TestCase): def setUp(self): self.database = SolvationDatabase() self.database.load( os.path.join(settings['database.directory'], 'solvation')) def tearDown(self): """ Reset the database & liquid parameters for solution """ import rmgpy.data.rmg rmgpy.data.rmg.database = None def test_solute_library(self): """Test we can obtain solute parameters from a library""" species = Species(molecule=[ Molecule(smiles='COC=O') ]) # methyl formate - we know this is in the solute library library_data = self.database.get_solute_data_from_library( species, self.database.libraries['solute']) self.assertEqual(len(library_data), 3) solute_data = self.database.get_solute_data(species) self.assertTrue(isinstance(solute_data, SoluteData)) s = solute_data.S self.assertEqual(s, 0.68) self.assertTrue(solute_data.V is not None) def test_mcgowan(self): """Test we can calculate and set the McGowan volume for species containing H,C,O,N or S""" self.testCases = [ ['CCCCCCCC', 1.2358], # n-octane, in library ['C(CO)O', 0.5078], # ethylene glycol ['CC#N', 0.4042], # acetonitrile ['CCS', 0.5539] # ethanethiol ] for smiles, volume in self.testCases: species = Species(molecule=[Molecule(smiles=smiles)]) solute_data = self.database.get_solute_data(species) solute_data.set_mcgowan_volume( species) # even if it was found in library, recalculate self.assertIsNotNone( solute_data.V ) # so if it wasn't found in library, we should have calculated it self.assertAlmostEqual( solute_data.V, volume ) # the volume is what we expect given the atoms and bonds def test_diffusivity(self): """Test that for a given solvent viscosity and temperature we can calculate a solute's diffusivity""" species = Species(molecule=[Molecule(smiles='O')]) # water solute_data = self.database.get_solute_data(species) temperature = 298. solvent_viscosity = 0.00089 # water is about 8.9e-4 Pa.s d = solute_data.get_stokes_diffusivity(temperature, solvent_viscosity) # m2/s self.assertAlmostEqual((d * 1e9), 1.3, 1) # self-diffusivity of water is about 2e-9 m2/s def test_solvent_library(self): """Test we can obtain solvent parameters and data count from a library""" solvent_data = self.database.get_solvent_data('water') self.assertIsNotNone(solvent_data) self.assertEqual(solvent_data.s_h, -0.75922) self.assertRaises(DatabaseError, self.database.get_solvent_data, 'orange_juice') solvent_data = self.database.get_solvent_data('cyclohexane') self.assertEqual(solvent_data.name_in_coolprop, 'CycloHexane') solvent_data_count = self.database.get_solvent_data_count( 'dodecan-1-ol') self.assertEqual(solvent_data_count.dGsolvCount, 11) dHsolvMAE = (0.05, 'kcal/mol') self.assertTrue(solvent_data_count.dHsolvMAE == dHsolvMAE) def test_viscosity(self): """Test we can calculate the solvent viscosity given a temperature and its A-E correlation parameters""" solvent_data = self.database.get_solvent_data('water') self.assertAlmostEqual(solvent_data.get_solvent_viscosity(298), 0.0009155) def test_critical_temperature(self): """ Test we can calculate the solvent critical temperature given the solvent's name_in_coolprop and we can raise DatabaseError when the solvent's name_in_coolprop is None. """ solvent_data = self.database.get_solvent_data('water') self.assertAlmostEqual(solvent_data.get_solvent_critical_temperature(), 647.096) solvent_data = self.database.get_solvent_data('dibutylether') self.assertRaises(DatabaseError, solvent_data.get_solvent_critical_temperature) def test_find_solvent(self): """ Test we can find solvents from the solvent library using SMILES""" # Case 1: one solvent is matched solvent_smiles = "NC=O" match_list = self.database.find_solvent_from_smiles(solvent_smiles) self.assertEqual(len(match_list), 1) self.assertTrue(match_list[0][0] == 'formamide') # Case 2: two solvents are matched solvent_smiles = "ClC=CCl" match_list = self.database.find_solvent_from_smiles(solvent_smiles) self.assertEqual(len(match_list), 2) self.assertTrue(match_list[0][0] == 'cis-1,2-dichloroethene') self.assertTrue(match_list[1][0] == 'trans-1,2-dichloroethene') # Case 3: no solvent is matched solvent_smiles = "C(CCl)O" match_list = self.database.find_solvent_from_smiles(solvent_smiles) self.assertEqual(len(match_list), 0) def test_solute_groups(self): """Test we can correctly load the solute groups from the solvation group database""" solute_group = self.database.groups['group'].entries['Cds-N3dCbCb'] self.assertEqual(solute_group.data_count.S, 28) self.assertEqual(solute_group.data.B, 0.06652) solute_group = self.database.groups['ring'].entries['FourMember'] self.assertIsNone(solute_group.data_count) self.assertEqual(solute_group.data, 'Cyclobutane') def test_solute_generation(self): """Test we can estimate Abraham solute parameters correctly using group contributions""" self.testCases = [[ '1,2-ethanediol', 'C(CO)O', 0.809, 0.740, 0.393, 2.482, 0.584, 0.508 ]] for name, smiles, S, B, E, L, A, V in self.testCases: species = Species(smiles=smiles) solute_data = self.database.get_solute_data_from_groups(species) self.assertAlmostEqual(solute_data.S, S, places=2) self.assertAlmostEqual(solute_data.B, B, places=2) self.assertAlmostEqual(solute_data.E, E, places=2) self.assertAlmostEqual(solute_data.L, L, places=2) self.assertAlmostEqual(solute_data.A, A, places=2) def test_solute_with_resonance_structures(self): """ Test we can estimate Abraham solute parameters correctly using group contributions for the solute species with resonance structures. """ smiles = "CC1=CC=CC=C1N" species = Species(smiles=smiles) species.generate_resonance_structures() solute_data = self.database.get_solute_data(species) solvent_data = self.database.get_solvent_data('water') solvation_correction = self.database.get_solvation_correction( solute_data, solvent_data) dGsolv_spc = solvation_correction.gibbs / 1000 for mol in species.molecule: spc = Species(molecule=[mol]) solute_data = self.database.get_solute_data_from_groups(spc) solvation_correction = self.database.get_solvation_correction( solute_data, solvent_data) dGsolv_mol = solvation_correction.gibbs / 1000 if mol == species.molecule[0]: self.assertEqual(dGsolv_spc, dGsolv_mol) else: self.assertNotAlmostEqual(dGsolv_spc, dGsolv_mol) def test_lone_pair_solute_generation(self): """Test we can obtain solute parameters via group additivity for a molecule with lone pairs""" molecule = Molecule().from_adjacency_list(""" CH2_singlet multiplicity 1 1 C u0 p1 c0 {2,S} {3,S} 2 H u0 p0 c0 {1,S} 3 H u0 p0 c0 {1,S} """) species = Species(molecule=[molecule]) solute_data = self.database.get_solute_data_from_groups(species) self.assertIsNotNone(solute_data) def test_solute_data_generation_ammonia(self): """Test we can obtain solute parameters via group additivity for ammonia""" molecule = Molecule().from_adjacency_list(""" 1 N u0 p1 c0 {2,S} {3,S} {4,S} 2 H u0 p0 c0 {1,S} 3 H u0 p0 c0 {1,S} 4 H u0 p0 c0 {1,S} """) species = Species(molecule=[molecule]) solute_data = self.database.get_solute_data_from_groups(species) self.assertIsNotNone(solute_data) def test_solute_data_generation_amide(self): """Test that we can obtain solute parameters via group additivity for an amide""" molecule = Molecule().from_adjacency_list(""" 1 N u0 p1 {2,S} {3,S} {4,S} 2 H u0 {1,S} 3 C u0 {1,S} {6,S} {7,S} {8,S} 4 C u0 {1,S} {5,D} {9,S} 5 O u0 p2 {4,D} 6 H u0 {3,S} 7 H u0 {3,S} 8 H u0 {3,S} 9 H u0 {4,S} """) species = Species(molecule=[molecule]) solute_data = self.database.get_solute_data_from_groups(species) self.assertIsNotNone(solute_data) def test_solute_data_generation_co(self): """Test that we can obtain solute parameters via group additivity for CO.""" molecule = Molecule().from_adjacency_list(""" 1 C u0 p1 c-1 {2,T} 2 O u0 p1 c+1 {1,T} """) species = Species(molecule=[molecule]) solute_data = self.database.get_solute_data_from_groups(species) self.assertIsNotNone(solute_data) def test_radical_and_lone_pair_generation(self): """ Test we can obtain solute parameters via group additivity for a molecule with both lone pairs and a radical """ molecule = Molecule().from_adjacency_list(""" [C]OH multiplicity 2 1 C u1 p1 c0 {2,S} 2 O u0 p2 c0 {1,S} {3,S} 3 H u0 p0 c0 {2,S} """) species = Species(molecule=[molecule]) solute_data = self.database.get_solute_data_from_groups(species) self.assertIsNotNone(solute_data) def test_radical_solute_group(self): """Test that the existing radical group is found for the radical species when using group additivity""" # First check whether the radical group is found for the radical species rad_species = Species(smiles='[OH]') rad_solute_data = self.database.get_solute_data_from_groups( rad_species) self.assertTrue('radical' in rad_solute_data.comment) # Then check that the radical and its saturated species give different solvation free energies saturated_struct = rad_species.molecule[0].copy(deep=True) saturated_struct.saturate_radicals() sat_species = Species(molecule=[saturated_struct]) sat_solute_data = self.database.get_solute_data_from_groups( sat_species) solvent_data = self.database.get_solvent_data('water') rad_solvation_correction = self.database.get_solvation_correction( rad_solute_data, solvent_data) sat_solvation_correction = self.database.get_solvation_correction( sat_solute_data, solvent_data) self.assertNotAlmostEqual(rad_solvation_correction.gibbs / 1000, sat_solvation_correction.gibbs / 1000) def test_halogen_solute_group(self): """Test that the correct halogen groups can be found for the halogenated species using get_solute_data method""" # Check the species whose halogen-replaced form can be found from solute library species = Species().from_smiles('CCCCCCl') solute_data = self.database.get_solute_data(species) self.assertTrue("Solute library: n-pentane + halogen(Cl-(Cs-CsHH))" in solute_data.comment) # Check the species whose halogen-replaced form cannot be found from solute library species = Species().from_smiles('OCCCCCCC(Br)CCCCCO') solute_data = self.database.get_solute_data(species) self.assertTrue("+ group(Cs-Cs(Os-H)HH) + halogen(Br-(Cs-CsCsH))" in solute_data.comment) def test_radical_halogen_solute_group(self): """Test that the correct halogen and radical groups can be found for the halogenated radical species using get_solute_data method""" # Check the species whose saturated and halogenated form can be found from solute library species = Species().from_smiles('[O]CCCCl') solute_data = self.database.get_solute_data(species) self.assertTrue("Solute library: 3-Chloropropan-1-ol + radical(ROJ)" == solute_data.comment) # Check the species whose saturated and halogen-replaced form can be found from solute library species = Species().from_smiles('[O]CCCC(Br)(I)Cl') solute_data = self.database.get_solute_data(species) self.assertTrue("Solute library: butan-1-ol + halogen(I-(Cs-CsHH)) + halogen(Br-(Cs-CsFCl)) + halogen(Cl-(Cs-CsFBr)) + radical(ROJ)" \ == solute_data.comment) # Check the species whose saturated and halogen-replaced form cannot be found from solute library species = Species().from_smiles('[NH]C(=O)CCCl') solute_data = self.database.get_solute_data(species) self.assertTrue( "group(Cds-Od(N3s-HH)Cs) + halogen(Cl-(Cs-CsHH)) + radical(N3_amide_pri)" in solute_data.comment) # Check the species whose radical site is bonded to halogen species = Species().from_smiles('F[N]C(=O)CCCl') solute_data = self.database.get_solute_data(species) self.assertTrue( "group(Cds-Od(N3s-HH)Cs) + halogen(Cl-(Cs-CsHH)) + halogen(F-N3s) + radical(N3_amide_sec)" in solute_data.comment) def test_correction_generation(self): """Test we can estimate solvation thermochemistry.""" self.testCases = [ # solventName, soluteName, soluteSMILES, Hsolv, Gsolv in kJ/mol ['water', 'acetic acid', 'C(C)(=O)O', -48.48, -28.12], ['water', 'naphthalene', 'C1=CC=CC2=CC=CC=C12', -37.15, -11.21], ['1-octanol', 'octane', 'CCCCCCCC', -39.44, -16.83], ['1-octanol', 'tetrahydrofuran', 'C1CCOC1', -32.27, -17.81], ['benzene', 'toluene', 'C1(=CC=CC=C1)C', -39.33, -23.81], ['benzene', '1,4-dioxane', 'C1COCCO1', -39.15, -22.01] ] for solventName, soluteName, smiles, H, G in self.testCases: species = Species().from_smiles(smiles) species.generate_resonance_structures() solute_data = self.database.get_solute_data(species) solvent_data = self.database.get_solvent_data(solventName) solvation_correction = self.database.get_solvation_correction( solute_data, solvent_data) self.assertAlmostEqual( solvation_correction.enthalpy / 1000, H, 2, # 2 decimal places, in kJ. msg= "Solvation enthalpy discrepancy ({2:.2f}!={3:.2f}) for {0} in {1}" "".format(soluteName, solventName, solvation_correction.enthalpy / 1000, H)) self.assertAlmostEqual( solvation_correction.gibbs / 1000, G, 2, # 2 decimal places, in kJ. msg= "Solvation Gibbs free energy discrepancy ({2:.2f}!={3:.2f}) for {0} in {1}" "".format(soluteName, solventName, solvation_correction.gibbs / 1000, G)) def test_Kfactor_parameters(self): """Test we can calculate the parameters for K-factor relationships""" species = Species().from_smiles('CCC(C)=O') # 2-Butanone for a solute solute_data = self.database.get_solute_data(species) solvent_data = self.database.get_solvent_data('water') kfactor_parameters = self.database.get_Kfactor_parameters( solute_data, solvent_data) self.assertAlmostEqual(kfactor_parameters.lower_T[0], -9.780, 3) # check up to 3 decimal places self.assertAlmostEqual(kfactor_parameters.lower_T[1], 0.492, 3) self.assertAlmostEqual(kfactor_parameters.lower_T[2], 10.485, 3) self.assertAlmostEqual(kfactor_parameters.higher_T, 1.147, 3) self.assertAlmostEqual(kfactor_parameters.T_transition, 485.3, 1) # check that DatabaseError is raised when the solvent's name_in_coolprop is None solvent_data = self.database.get_solvent_data('chloroform') self.assertRaises(DatabaseError, self.database.get_Kfactor_parameters, solute_data, solvent_data) def test_Tdep_solvation_calculation(self): '''Test we can calculate the temperature dependent K-factor and solvation free energy''' species = Species().from_smiles('CCC1=CC=CC=C1') # ethylbenzene species.generate_resonance_structures() solute_data = self.database.get_solute_data(species) solvent_data = self.database.get_solvent_data('benzene') T = 500 # in K Kfactor = self.database.get_Kfactor(solute_data, solvent_data, T) delG = self.database.get_T_dep_solvation_energy( solute_data, solvent_data, T) / 1000 # in kJ/mol self.assertAlmostEqual(Kfactor, 0.403, 3) self.assertAlmostEqual(delG, -13.59, 2) # For temperature greater than or equal to the critical temperature of the solvent, # it should raise InputError T = 1000 self.assertRaises(InputError, self.database.get_T_dep_solvation_energy, solute_data, solvent_data, T) def test_initial_species(self): """Test we can check whether the solvent is listed as one of the initial species in various scenarios""" # Case 1. when SMILES for solvent is available, the molecular structures of the initial species and the solvent # are compared to check whether the solvent is in the initial species list # Case 1-1: the solvent water is not in the initialSpecies list, so it raises Exception rmg = RMG() rmg.initial_species = [] solute = Species(label='n-octane', molecule=[Molecule().from_smiles('C(CCCCC)CC')]) rmg.initial_species.append(solute) rmg.solvent = 'water' solvent_structure = Species().from_smiles('O') self.assertRaises(Exception, self.database.check_solvent_in_initial_species, rmg, solvent_structure) # Case 1-2: the solvent is now octane and it is listed as the initialSpecies. Although the string # names of the solute and the solvent are different, because the solvent SMILES is provided, # it can identify the 'n-octane' as the solvent rmg.solvent = 'octane' solvent_structure = Species().from_smiles('CCCCCCCC') self.database.check_solvent_in_initial_species(rmg, solvent_structure) self.assertTrue(rmg.initial_species[0].is_solvent) # Case 2: the solvent SMILES is not provided. In this case, it can identify the species as the # solvent by looking at the string name. # Case 2-1: Since 'n-octane and 'octane' are not equal, it raises Exception solvent_structure = None self.assertRaises(Exception, self.database.check_solvent_in_initial_species, rmg, solvent_structure) # Case 2-2: The label 'n-ocatne' is corrected to 'octane', so it is identified as the solvent rmg.initial_species[0].label = 'octane' self.database.check_solvent_in_initial_species(rmg, solvent_structure) self.assertTrue(rmg.initial_species[0].is_solvent) def test_solvent_molecule(self): """Test that we can assign a proper solvent molecular structure when different formats are given""" # solventlibrary.entries['solvent_label'].item should be the instance of Species with the solvent's molecular # structure if the solvent database contains the solvent SMILES or adjacency list. If not, then item is None # Case 1: When the solventDatabase does not contain the solvent SMILES, the item attribute is None solventlibrary = SolventLibrary() solventlibrary.load_entry(index=1, label='water', solvent=None) self.assertTrue(solventlibrary.entries['water'].item is None) # Case 2: When the solventDatabase contains the correct solvent SMILES, the item attribute is the instance of # Species with the correct solvent molecular structure solventlibrary.load_entry(index=2, label='octane', solvent=None, molecule='CCCCCCCC') solvent_species = Species().from_smiles('C(CCCCC)CC') self.assertTrue( solvent_species.is_isomorphic( solventlibrary.entries['octane'].item[0])) # Case 3: When the solventDatabase contains the correct solvent adjacency list, the item attribute # is the instance of the species with the correct solvent molecular structure. # This will display the SMILES Parse Error message from the external function, but ignore it. solventlibrary.load_entry(index=3, label='ethanol', solvent=None, molecule=""" 1 C u0 p0 c0 {2,S} {4,S} {5,S} {6,S} 2 C u0 p0 c0 {1,S} {3,S} {7,S} {8,S} 3 O u0 p2 c0 {2,S} {9,S} 4 H u0 p0 c0 {1,S} 5 H u0 p0 c0 {1,S} 6 H u0 p0 c0 {1,S} 7 H u0 p0 c0 {2,S} 8 H u0 p0 c0 {2,S} 9 H u0 p0 c0 {3,S} """) solvent_species = Species().from_smiles('CCO') self.assertTrue( solvent_species.is_isomorphic( solventlibrary.entries['ethanol'].item[0])) # Case 4: when the solventDatabase contains incorrect values for the molecule attribute, it raises Exception # This will display the SMILES Parse Error message from the external function, but ignore it. self.assertRaises(Exception, solventlibrary.load_entry, index=4, label='benzene', solvent=None, molecule='ring') # Case 5: when the solventDatabase contains data for co-solvents. solventlibrary.load_entry(index=5, label='methanol_50_water_50', solvent=None, molecule=['CO', 'O']) solvent_species_list = [ Species().from_smiles('CO'), Species().from_smiles('O') ] self.assertEqual( len(solventlibrary.entries['methanol_50_water_50'].item), 2) for spc1 in solventlibrary.entries['methanol_50_water_50'].item: self.assertTrue( any([ spc1.is_isomorphic(spc2) for spc2 in solvent_species_list ]))