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')