def test_multiconformer(tmp_amine2, tmp_aldehyde3): top = stk.FourPlusSix() amine_fg_count = 2 amine_count = 6 aldehyde_count = 4 c = stk.Cage([tmp_amine2, tmp_aldehyde3], stk.FourPlusSix(), bb_conformers=[0, 0]) c.add_conformer([1, 0]) c.add_conformer([0, 1]) c.add_conformer([1, 1]) c.write(join(test_dir, 'FourPlusSix_conf1.mol'), 0) c.write(join(test_dir, 'FourPlusSix_conf2.mol'), 1) c.write(join(test_dir, 'FourPlusSix_conf3.mol'), 2) c.write(join(test_dir, 'FourPlusSix_conf4.mol'), 3) assert c.bonds_made == amine_fg_count * amine_count assert (c.mol.GetNumAtoms() == tmp_amine2.mol.GetNumAtoms() * amine_count + tmp_aldehyde3.mol.GetNumAtoms() * aldehyde_count - c.bonds_made * 3) assert (c.mol.GetNumBonds() == tmp_amine2.mol.GetNumBonds() * amine_count + tmp_aldehyde3.mol.GetNumBonds() * aldehyde_count - c.bonds_made * 2) assert c.topology == top assert c.bb_counter[tmp_amine2] == amine_count assert c.bb_counter[tmp_aldehyde3] == aldehyde_count
def test_alignments(amine2, amine2_alt3, aldehyde3, aldehyde3_alt3): # Regular cage topology. bb_positions = { amine2: [0, 1, 2, 3, 4], amine2_alt3: [5], aldehyde3: [0, 1, 2], aldehyde3_alt3: [3] } bbs = [amine2, amine2_alt3, aldehyde3, aldehyde3_alt3] for fg in range(3): top = stk.FourPlusSix(bb_positions=bb_positions, A_alignments=[0, 0, 0, fg], B_alignments=[1, 1, 1, 1, 1, 1]) c = stk.Cage(bbs, top) c.write(join(test_dir, f'4p6_valignment_{fg}.mol')) top = stk.FourPlusSix(bb_positions=bb_positions, A_alignments=[0, 0, 0, 0], B_alignments=[1, 1, 1, 1, 1, -1]) c = stk.Cage(bbs, top) c.write(join(test_dir, f'4p6_edge_alignment.mol')) # No linker topology. bbs = [aldehyde3, aldehyde3_alt3] bb_positions = {aldehyde3: [1, 2, 3], aldehyde3_alt3: [0]} for fg in range(3): top = stk.TwoPlusTwo(bb_positions=bb_positions, alignments=[fg, 0, 0, 0]) c = stk.Cage(bbs, top) c.write(join(test_dir, f'2p2_valignment_{fg}.mol'))
def test_mol1(): bb1 = stk.StructUnit2.smiles_init('N') bb2 = stk.StructUnit3.smiles_init('NN') # Make sure calling build does nothing. top = stk.FourPlusSix() top.build = lambda x:... test_mol = TestMol([bb1, bb2], top, 'test_mol1') test_mol.mol = rdkit.Mol(bb1.mol) test_mol.bonds_made = 2 return test_mol
def test_multiconformer(tmp_amine2, tmp_aldehyde3): top = stk.FourPlusSix() amine_fg_count = 2 amine_count = 6 aldehyde_count = 4 # Add conformers. tmp_amine2.mol.AddConformer(tmp_amine2.mol.GetConformer(), True) tmp_aldehyde3.mol.AddConformer(tmp_aldehyde3.mol.GetConformer(), True) # Give conformers distinct geometries. tmp_amine2.set_position_from_matrix( pos_mat=tmp_amine2.mol.GetConformer().GetPositions().T * 4, conformer=1) tmp_aldehyde3.set_position_from_matrix( pos_mat=tmp_aldehyde3.mol.GetConformer().GetPositions().T * 4, conformer=1) c = stk.Cage([tmp_amine2, tmp_aldehyde3], stk.FourPlusSix(), bb_conformers=[0, 0]) c.add_conformer([1, 0]) c.add_conformer([0, 1]) c.add_conformer([1, 1]) c.write(join(test_dir, 'FourPlusSix_conf1.mol'), 0) c.write(join(test_dir, 'FourPlusSix_conf2.mol'), 1) c.write(join(test_dir, 'FourPlusSix_conf3.mol'), 2) c.write(join(test_dir, 'FourPlusSix_conf4.mol'), 3) assert c.bonds_made == amine_fg_count * amine_count assert (c.mol.GetNumAtoms() == tmp_amine2.mol.GetNumAtoms() * amine_count + tmp_aldehyde3.mol.GetNumAtoms() * aldehyde_count - c.bonds_made * 3) assert (c.mol.GetNumBonds() == tmp_amine2.mol.GetNumBonds() * amine_count + tmp_aldehyde3.mol.GetNumBonds() * aldehyde_count - c.bonds_made * 2) assert c.topology == top assert c.bb_counter[tmp_amine2] == amine_count assert c.bb_counter[tmp_aldehyde3] == aldehyde_count
def inner(cache=False, offset=False): """ Returns a population of subpopulations and direct members. """ stk.OPTIONS['cache'] = cache # Generate a bunch of cages. if offset: mols = [ TestMol([struct_units2[i], struct_units3[i + 1]], stk.FourPlusSix(), f'test_mol_{i}') for i in range(10) ] else: mols = [ TestMol([struct_units2[i], struct_units3[i]], stk.FourPlusSix(), f'test_mol_{i}') for i in range(10) ] # Generate a couple of # populations to be used as subpopulations. sub1 = stk.Population(*mols[:2]) sub2 = stk.Population(*mols[2:4]) sub3 = stk.Population(*mols[4:6]) sub4 = stk.Population(*mols[6:8]) # Place subpopulations into one another. sub1.populations.append(sub3) sub2.populations.append(sub4) # Initialize final population of subpopulations and cages. p = stk.Population(sub1, sub2, *mols[8:]) p.assign_names_from(0, True) stk.OPTIONS['cache'] = False return p
def test_cage_complex(amine2, amine2_alt1, aldehyde3, chained_c60): c = stk.Cage( [amine2, amine2_alt1, aldehyde3], stk.FourPlusSix(bb_positions={ amine2: [5], amine2_alt1: [0, 1, 2, 3, 4], aldehyde3: [0, 1, 2, 3] })) n = 3 for i in range(n): cage_complex = stk.CageComplex([c, chained_c60], stk.CageWithGuest( axis=[1, 0, 0], angle=2 * np.pi * i / n, displacement=[2 * i, 0, 0])) cage_complex.write(join(test_dir, f'cage_with_guest_{i}.mol'))
def test_FourPlusSix(amine2, aldehyde3): top = stk.FourPlusSix() amine_fg_count = 2 amine_count = 6 aldehyde_count = 4 c = stk.Cage([amine2, aldehyde3], top) c.write(join(test_dir, 'FourPlusSix.mol')) assert c.bonds_made == amine_fg_count * amine_count assert (c.mol.GetNumAtoms() == amine2.mol.GetNumAtoms() * amine_count + aldehyde3.mol.GetNumAtoms() * aldehyde_count - c.bonds_made * 3) assert (c.mol.GetNumBonds() == amine2.mol.GetNumBonds() * amine_count + aldehyde3.mol.GetNumBonds() * aldehyde_count - c.bonds_made * 2) assert c.topology == top assert c.bb_counter[amine2] == amine_count assert c.bb_counter[aldehyde3] == aldehyde_count
def test_multiFourPlusSix(amine2, amine2_alt1, amine2_alt2, aldehyde3, aldehyde3_alt1, aldehyde3_alt2): top = stk.FourPlusSix(bb_positions={ 0: [0, 1], 1: [2, 3, 4], 2: [5], 3: [0], 4: [1, 2], 5: [3] }) amine_fg_count = 2 bbs = [ amine2, amine2_alt1, amine2_alt2, aldehyde3, aldehyde3_alt1, aldehyde3_alt2 ] c = stk.Cage(bbs, top) c.write(join(test_dir, 'multi_FourPlusSix.mol')) assert c.bonds_made == amine_fg_count * 6 assert c.topology == top assert c.bb_counter[amine2] == 2 assert c.bb_counter[amine2_alt1] == 3 assert c.bb_counter[amine2_alt2] == 1 assert c.bb_counter[aldehyde3] == 1 assert c.bb_counter[aldehyde3_alt1] == 2 assert c.bb_counter[aldehyde3_alt2] == 1 assert (c.mol.GetNumAtoms() == amine2.mol.GetNumAtoms() * 2 + amine2_alt1.mol.GetNumAtoms() * 3 + amine2_alt2.mol.GetNumAtoms() * 1 + aldehyde3.mol.GetNumAtoms() * 1 + aldehyde3_alt1.mol.GetNumAtoms() * 2 + aldehyde3_alt2.mol.GetNumAtoms() * 1 - c.bonds_made * 3) assert (c.mol.GetNumBonds() == amine2.mol.GetNumBonds() * 2 + amine2_alt1.mol.GetNumBonds() * 3 + amine2_alt2.mol.GetNumBonds() * 1 + aldehyde3.mol.GetNumBonds() * 1 + aldehyde3_alt1.mol.GetNumBonds() * 2 + aldehyde3_alt2.mol.GetNumBonds() * 1 - c.bonds_made * 2)
def tmp_cage(amine2, aldehyde3): return stk.Cage([amine2, aldehyde3], stk.FourPlusSix(), 'tmp_cage')
def main(): db = 'structs' diol_db = '' bbs = { 'amine/2': iglob(join(db, 'amine2', '*')), 'amine2/2': iglob(join(db, 'amine2', '*')), 'aldehyde/2': iglob(join(db, 'aldehyde2', '*')), 'terminal_alkene/2': iglob(join(db, 'terminal_alkene2', '*')), 'alkyne/2': iglob(join(db, 'alkyne2', '*')), 'alkyne2/2': iglob(join(db, 'alkyne2', '*')), 'boronic_acid/2': iglob(join(db, 'boronic_acid2', '*')), 'carboxylic_acid/2': iglob(join(db, 'carboxylic_acid2', '*')), 'diol/2': iglob(join(diol_db, 'diol2', '*')), 'thiol/2': iglob(join(db, 'thiol2', '*')), 'amine/3': iglob(join(db, 'amine3', '*')), 'amine2/3': iglob(join(db, 'amine3', '*')), 'aldehyde/3': iglob(join(db, 'aldehyde3', '*')), 'terminal_alkene/3': iglob(join(db, 'terminal_alkene3', '*')), 'alkyne/3': iglob(join(db, 'alkyne3', '*')), 'alkyne2/3': iglob(join(db, 'alkyne3', '*')), 'boronic_acid/3': iglob(join(db, 'boronic_acid3', '*')), 'carboxylic_acid/3': iglob(join(db, 'carboxylic_acid3', '*')), 'diol/3': iglob(join(diol_db, 'diol3', '*')), 'thiol/3': iglob(join(db, 'thiol3', '*')), 'amine/4': iglob(join(db, 'amine4', '*')), 'amine2/4': iglob(join(db, 'amine4', '*')), 'aldehyde/4': iglob(join(db, 'aldehyde4', '*')), 'terminal_alkene/4': iglob(join(db, 'terminal_alkene4', '*')), 'alkyne/4': iglob(join(db, 'alkyne', '*')), 'alkyne2/4': iglob(join(db, 'alkyne', '*')), 'boronic_acid/4': iglob(join(db, 'boronic_acid4', '*')), 'carboxylic_acid/4': iglob(join(db, 'carboxylic_acid4', '*')), 'diol/4': iglob(join(diol_db, 'diol4', '*')), 'thiol/4': iglob(join(db, 'thiol4', '*')) } bb_positions = {0: [0, 3, 5, 6], 1: [1, 2, 4, 7]} # labelling is ('fgname/nfgs', ...) reactions = { 1: ('amine/2', 'aldehyde/3', [stk.FourPlusSix(), stk.EightPlusTwelve()]), 2: ('aldehyde/2', 'amine/3', [stk.FourPlusSix(), stk.EightPlusTwelve()]), 3: ('terminal_alkene/2', 'terminal_alkene/3', [stk.FourPlusSix()]), 4: ('alkyne/2', 'alkyne/3', [stk.FourPlusSix()]), 5: ('alkyne2/2', 'alkyne2/3', [stk.FourPlusSix()]), 6: ('carboxylic_acid/2', 'amine2/3', [stk.FourPlusSix()]), 7: ('amine2/2', 'carboxylic_acid/3', [stk.FourPlusSix()]), 8: ('thiol/2', 'thiol/3', [stk.FourPlusSix()]), 9: ('boronic_acid/2', 'diol/3', [stk.FourPlusSix()]), 10: ('diol/2', 'boronic_acid/3', [stk.FourPlusSix()]), 11: ('amine/3', 'aldehyde/3', [stk.FourPlusFour(bb_positions=bb_positions)]), 12: ('amine2/3', 'carboxylic_acid/3', [stk.FourPlusFour(bb_positions=bb_positions)]), 13: ('terminal_alkene/3', 'terminal_alkene/3', [stk.FourPlusFour(bb_positions=bb_positions)]), 14: ('alkyne/3', 'alkyne/3', [stk.FourPlusFour(bb_positions=bb_positions)]), 15: ('alkyne2/3', 'alkyne2/3', [stk.FourPlusFour(bb_positions=bb_positions)]), 16: ('boronic_acid/3', 'diol/3', [stk.FourPlusFour(bb_positions=bb_positions)]), 17: ('thiol/3', 'thiol/3', [stk.FourPlusFour(bb_positions=bb_positions)]), 18: ('amine/4', 'aldehyde/2', [stk.SixPlusTwelve()]), 19: ('aldehyde/4', 'amine/2', [stk.SixPlusTwelve()]), 20: ('terminal_alkene/4', 'terminal_alkene/2', [stk.SixPlusTwelve()]), 21: ('alkyne/4', 'alkyne/2', [stk.SixPlusTwelve()]), 22: ('alkyne2/4', 'alkyne2/2', [stk.SixPlusTwelve()]), 23: ('thiol/4', 'thiol/2', [stk.SixPlusTwelve()]), 24: ('amine2/4', 'carboxylic_acid/2', [stk.SixPlusTwelve()]), 25: ('carboxylic_acid/4', 'amine2/2', [stk.SixPlusTwelve()]), 26: ('amine/4', 'aldehyde/3', [stk.SixPlusEight()]), 27: ('aldehyde/4', 'amine/3', [stk.SixPlusEight()]), 28: ('terminal_alkene/4', 'terminal_alkene/3', [stk.SixPlusEight()]), 29: ('alkyne/4', 'alkyne/3', [stk.SixPlusEight()]), 30: ('alkyne2/4', 'alkyne2/3', [stk.SixPlusEight()]), 31: ('amine2/4', 'carboxylic_acid/3', [stk.SixPlusEight()]), 32: ('carboxylic_acid/4', 'amine2/3', [stk.SixPlusEight()]), 33: ('thiol/4', 'thiol/3', [stk.SixPlusEight()]), } bb_cls = {'2': stk.StructUnit2, '3': stk.StructUnit3, '4': stk.StructUnit3} parser = argparse.ArgumentParser() parser.add_argument('reaction', type=int, nargs='+') args = parser.parse_args() bb_mols = {} # For each selected reaction. Check which databases it involves. # For each involved database, load all the StructUnit instances for r in args.reaction: *dbs, topologies = reactions[r] for db in dbs: if db not in bb_mols: fg, nfgs = db.split('/') cls = bb_cls[nfgs] bb_mols[db] = [cls(p, [fg]) for p in bbs[db]] for r in args.reaction: stk.Cage.cache = {} db1, db2, topologies = reactions[r] pop = stk.Population.init_all(stk.Cage, [bb_mols[db1], bb_mols[db2]], topologies) pop.assign_names_from(0, True) db1_name = db1.replace('amine2', 'amine').replace('/', '') db2_name = db2.replace('amine2', 'amine').replace('/', '') pop.dump(db1_name + db2_name + '.json')