def test_alignments(amine2, amine2_alt3, aldehyde3, aldehyde3_alt3): building_blocks = [amine2, amine2_alt3, aldehyde3, aldehyde3_alt3] for fg in range(3): v4 = stk.cage.FourPlusSix.vertices[3] four_plus_six = stk.cage.FourPlusSix( vertex_alignments={v4: v4.edges[fg]}, ) c = stk.ConstructedMolecule(building_blocks=building_blocks, topology_graph=four_plus_six, building_block_vertices={ amine2: four_plus_six.vertices[4:9], amine2_alt3: four_plus_six.vertices[9:], aldehyde3: four_plus_six.vertices[:3], aldehyde3_alt3: four_plus_six.vertices[3:4] }) c.write(join(test_dir, f'4p6_valignment_{fg}.mol')) v10 = stk.cage.FourPlusSix.vertices[9] four_plus_six = stk.cage.FourPlusSix(vertex_alignments={v10: v10.edges[1]}) c = stk.ConstructedMolecule(building_blocks=building_blocks, topology_graph=four_plus_six, building_block_vertices={ amine2: four_plus_six.vertices[4:9], amine2_alt3: four_plus_six.vertices[9:], aldehyde3: four_plus_six.vertices[:3], aldehyde3_alt3: four_plus_six.vertices[3:4] }) c.write(join(test_dir, f'4p6_edge_alignment.mol'))
def test_get_all(): """ Test iteration over all molecules. """ database_name = '_test_get_entries_constructed_molecule' client = pymongo.MongoClient() client.drop_database(database_name) key_maker = stk.Inchi() jsonizer = stk.ConstructedMoleculeJsonizer(key_makers=(key_maker, )) database = stk.ConstructedMoleculeMongoDb( mongo_client=client, database=database_name, jsonizer=jsonizer, put_lru_cache_size=0, get_lru_cache_size=0, ) molecules = [ stk.ConstructedMolecule(topology_graph=stk.polymer.Linear( building_blocks=(stk.BuildingBlock( smiles='BrCCCBr', functional_groups=[stk.BromoFactory()]), ), repeating_unit='A', num_repeating_units=3, ), ), stk.ConstructedMolecule(topology_graph=stk.polymer.Linear( building_blocks=( stk.BuildingBlock(smiles='BrCCBr', functional_groups=[stk.BromoFactory()]), stk.BuildingBlock(smiles='BrCNCBr', functional_groups=[stk.BromoFactory()]), ), repeating_unit='AB', num_repeating_units=2, ), ), ] molecules_by_key = { key_maker.get_key(molecule): molecule for molecule in molecules } for molecule in molecules: database.put(molecule) for i, retrieved in enumerate(database.get_all()): key = key_maker.get_key(retrieved) molecule = molecules_by_key[key] is_equivalent_constructed_molecule( molecule.with_canonical_atom_ordering(), retrieved.with_canonical_atom_ordering(), ) # Check number of molecules. assert i + 1 == len(molecules)
def __init__(self, num_repeating_units=2): lengths = [7, 12] repeating_unit = 'AB' def make_functional_group(n): return stk.GenericFunctionalGroup( atoms=tuple(stk.C(i) for i in range(n, n + 6)), bonders=(stk.C(n + 1), stk.C(n + 5)), deleters=tuple(stk.C(i) for i in range(n + 2, n + 5))) functional_groups = [make_functional_group(i) for i in (0, 6)] build_blocks = [ self.make_monomer(length).with_functional_groups(functional_groups) for length in lengths ] build_blocks[1] = build_blocks[1].with_rotation_about_axis( math.pi, build_blocks[1].get_direction(), build_blocks[1].get_centroid()) polymer = stk.ConstructedMolecule(topology_graph=stk.polymer.Linear( building_blocks=build_blocks, repeating_unit=repeating_unit, num_repeating_units=num_repeating_units, optimizer=stk.MCHammer(), )) # clean up the aromatic double bonds boundary_bonds = [ bond_info.get_bond() for bond_info in polymer.get_bond_infos() if bond_info.get_building_block_id() is None ] for bond in islice(boundary_bonds, 1, len(boundary_bonds), 2): bond._order = 2 self.polymer = ConstructedMoleculeTorsioned(polymer)
def build_complexes(hosts, guests): complexes = {} for host_name, guest_name in product(hosts, guests): print(f'>> building complex of {host_name} and {guest_name}') name = f'{host_name}_g{guest_name}' out_file = f'{name}_unopt.mol' host = hosts[host_name] guest = guests[guest_name] # pd_pd_vector = [0, 0, 0] # fg_fg_vector = [0, 0, 0] complex = stk.ConstructedMolecule( topology_graph=stk.host_guest.Complex( host=host, guest=guest, # guest_start=guest.get_direction(), # guest_target=pd_pd_vector, ), ) # Save file. complex.write(out_file) # Initialise as building block. complexes[name] = complex return complexes
def make_monomer(length): """make an alkyl chain with two phenyl end caps >>> length = 7 >>> ap_monomer = AlkylPhenylPolymer.make_monomer(length) >>> ap_monomer.get_num_atoms() == 6 * 2 + length True >>> display(Draw.MolToImage(mol_with_atom_index(ap_monomer.to_rdkit_mol()), ... size=(700, 300))) """ alkane = init_building_block(smiles='F' + 'C' * length + 'F', functional_groups=[stk.FluoroFactory()]) benzene = init_building_block(smiles='FC1=CC=CC=C1', functional_groups=[stk.FluoroFactory()]) alkyl_phenyl = stk.ConstructedMolecule( topology_graph=stk.polymer.Linear( building_blocks=(alkane, benzene), repeating_unit='BAB', num_repeating_units=1, optimizer=stk.MCHammer(), )) return stk.BuildingBlock.init_from_molecule(alkyl_phenyl)
def make_xor_monomer(self, position=0): # initialize building blocks benzene = self.init_building_block(smiles='C1=CC=CC=C1') acetaldehyde = self.init_building_block(smiles='CC=O') benzene = benzene.with_functional_groups([stk.SingleAtom(stk.C(position))]) acetaldehyde = acetaldehyde.with_functional_groups( [stk.SingleAtom(stk.C(1))]) # construct xor gate monomer xor_gate = stk.ConstructedMolecule( topology_graph=stk.polymer.Linear( building_blocks=(benzene, acetaldehyde), repeating_unit='AB', num_repeating_units=1 ) ) # construct functional groups for xor gate monomer # numbering starts at top and proceeds clockwise c_0, c_1, c_2, c_3, c_4, c_5 = stk.C(0), stk.C( 1), stk.C(2), stk.C(3), stk.C(4), stk.C(5) functional_groups = [stk.GenericFunctionalGroup(atoms=(c_0, c_1, c_2, c_3, c_4, c_5), bonders=(c_0, c_3), deleters=(c_4, c_5)), stk.GenericFunctionalGroup(atoms=(c_0, c_1, c_2, c_3, c_4, c_5), bonders=(c_1, c_2), deleters=())] return stk.BuildingBlock.init_from_molecule(xor_gate, functional_groups=functional_groups)
def test_put_caching(mongo_client): database_name = '_test_put_caching' mongo_client.drop_database(database_name) database = stk.ConstructedMoleculeMongoDb( mongo_client=mongo_client, database=database_name, ) molecule = stk.BuildingBlock('BrCCCBr', [stk.BromoFactory()]) polymer = stk.ConstructedMolecule(topology_graph=stk.polymer.Linear( building_blocks=(molecule, ), repeating_unit='A', num_repeating_units=3, ), ) database.put(polymer) database.put(polymer) cache_info = database._put.cache_info() assert cache_info.hits == 1 assert cache_info.misses == 1 database.put(molecule=polymer.with_position_matrix( position_matrix=np.zeros((polymer.get_num_atoms(), 3)), ), ) cache_info = database._put.cache_info() assert cache_info.hits == 1 assert cache_info.misses == 2
def main(): bb1 = stk.BuildingBlock('NCCNCCN', [stk.PrimaryAminoFactory()]) bb2 = stk.BuildingBlock('O=CCCC=O', [stk.AldehydeFactory()]) polymer = stk.ConstructedMolecule( stk.polymer.Linear(building_blocks=(bb1, bb2), repeating_unit="AB", orientations=[0, 0], num_repeating_units=1)) examples_output = 'output_directory' if os.path.exists(examples_output): shutil.rmtree(examples_output) os.mkdir(examples_output) # Run optimisations. uff = stko.UFF() polymer = uff.optimize(polymer) polymer.write(f'{examples_output}/poly_uff.mol') mmff = stko.MMFF() polymer = mmff.optimize(polymer) polymer.write(f'{examples_output}/poly_mmff.mol') etkdg = stko.ETKDG() polymer = etkdg.optimize(polymer) polymer.write(f'{examples_output}/poly_etkdg.mol')
def main(): bb1 = stk.BuildingBlock('NCCNCCN', [stk.PrimaryAminoFactory()]) bb2 = stk.BuildingBlock('O=CCCC=O', [stk.AldehydeFactory()]) polymer = stk.ConstructedMolecule( stk.polymer.Linear(building_blocks=(bb1, bb2), repeating_unit="AB", orientations=[0, 0], num_repeating_units=1)) # Run calculations for bb. bb1.write('output_directory/tors_test_bb1.mol') tors_calculator = stko.TorsionCalculator() tors_results = tors_calculator.get_results(bb1) print(tors_results.get_molecule()) for t, ang in tors_results.get_torsion_angles(): print(t, ang, t.get_atom_ids()) # Run calculations for constructed molecule. polymer.write('output_directory/tors_test_polymer.mol') tors_calculator = stko.ConstructedMoleculeTorsionCalculator() tors_results = tors_calculator.get_results(polymer) print(tors_results.get_molecule()) for t, ang in tors_results.get_torsion_angles(): print(t, ang, t.get_atom_ids()) for t in tors_results.get_torsion_infos(): print( 'c', t.get_torsion(), t.get_building_block(), t.get_building_block_id(), t.get_building_block_torsion(), ) print(tors_results.get_torsion_infos_by_building_block()) for t in tors_results.get_torsion_infos(): print(get_torsion_info_angles(polymer, t))
def test_get_caching(mongo_client): database_name = '_test_get_caching' mongo_client.drop_database(database_name) database = stk.ConstructedMoleculeMongoDb( mongo_client=mongo_client, database=database_name, ) molecule = stk.BuildingBlock('BrCCCBr', [stk.BromoFactory()]) polymer = stk.ConstructedMolecule(topology_graph=stk.polymer.Linear( building_blocks=(molecule, ), repeating_unit='A', num_repeating_units=3, ), ) database.put(polymer) database.get({ stk.InchiKey().get_key_name(): stk.InchiKey().get_key(polymer), }) database.get({ stk.InchiKey().get_key_name(): stk.InchiKey().get_key(polymer), }) cache_info = database._get.cache_info() assert cache_info.hits == 1 assert cache_info.misses == 1
def _get_cage() -> stk.ConstructedMolecule: return stk.ConstructedMolecule( topology_graph=stk.cage.FourPlusSix( building_blocks={ stk.BuildingBlock( smiles='BrC1=C(Br)[C+]=[C+]1', functional_groups=[stk.BromoFactory()], ): (4, 5, 6, 7, 8), stk.BuildingBlock( smiles='BrC1=C(Br)[C+]=N1', functional_groups=[stk.BromoFactory()], ): (9, ), stk.BuildingBlock( smiles=( 'Br[C+]1[C+2][C+](Br)[C+]2[C+][C+2]C2(' 'Br)[C+2]1' ), functional_groups=[stk.BromoFactory()], ): (0, 1, 2), stk.BuildingBlock( smiles=( 'Br[C+]1[C+2][C+](Br)[C+]2[C+](F)[C+2]' 'C2(Br)[C+2]1' ), functional_groups=[stk.BromoFactory()], ): (3, ), }, ), )
def main(): bb1 = stk.BuildingBlock('NCCN', [stk.PrimaryAminoFactory()]) bb2 = stk.BuildingBlock( smiles='O=CC(C=O)C=O', functional_groups=[stk.AldehydeFactory()], ) cage1 = stk.ConstructedMolecule(topology_graph=stk.cage.FourPlusSix( (bb1, bb2)), ) broken_bonds_by_id = [] disconnectors = [] for bi in cage1.get_bond_infos(): if bi.get_building_block() is None: a1id = bi.get_bond().get_atom1().get_id() a2id = bi.get_bond().get_atom2().get_id() broken_bonds_by_id.append(sorted((a1id, a2id))) disconnectors.extend((a1id, a2id)) print(broken_bonds_by_id) print(disconnectors) print('--') new_topology_graph = stko.TopologyExtractor() tg_info = new_topology_graph.extract_topology( molecule=cage1, broken_bonds_by_id=broken_bonds_by_id, disconnectors=set(disconnectors), ) print(tg_info.get_vertex_positions()) print(tg_info.get_connectivities()) print(tg_info.get_edge_pairs()) cage1.write(os.path.join('output_directory', 'tg_cage.mol')) tg_info.write(os.path.join('output_directory', 'tg_info.pdb'))
def get_palladium_cispbi_sqpl() -> stk.BuildingBlock: molecule = stk.ConstructedMolecule( topology_graph=stk.metal_complex.CisProtectedSquarePlanar( metals={get_pd_atom(): 0}, ligands={get_palladium_bi_1(): 0}, reaction_factory=stk.DativeReactionFactory( reaction_factory=stk.GenericReactionFactory(bond_orders={ frozenset({ stk.GenericFunctionalGroup, stk.SingleAtom, }): 9, }, ), ), ), ) return stk.BuildingBlock.init_from_molecule( molecule=molecule, functional_groups=[ stk.SmartsFunctionalGroupFactory( smarts='[Pd]~[#7]', bonders=(0, ), deleters=(), placers=(0, 1), ), ], )
def test_alignments(amine2_alt3, aldehyde4_alt1): num_expected_bbs = {amine2_alt3: 6 * 9, aldehyde4_alt1: 3 * 9} periodic_unreacted = {amine2_alt3: 0, aldehyde4_alt1: 0} island_unreacted = {amine2_alt3: 11, aldehyde4_alt1: 11} v0 = stk.cof.Kagome.vertices[0] vlast = stk.cof.Kagome.vertices[-1] for i in range(4): for periodic in (True, False): cof = stk.ConstructedMolecule( building_blocks=[amine2_alt3, aldehyde4_alt1], topology_graph=stk.cof.Kagome(lattice_size=(3, 3, 1), vertex_alignments={ v0: v0.edges[i], vlast: vlast.edges[i % 2] }, periodic=periodic)) kind = '_periodic' if periodic else '' cof.write(join(test_dir, f'aligning_{i}_{i%2}{kind}.mol')) num_unreacted_fgs = (periodic_unreacted if periodic else island_unreacted) _test_construction(cof=cof, num_expected_bbs=num_expected_bbs, num_unreacted_fgs=num_unreacted_fgs, periodic=periodic) _test_dump_and_load(test_dir, cof)
def _population_members(): bb1 = stk.BuildingBlock('NC(CCO)CN', ['amine']) bb2 = stk.BuildingBlock('[Br]CCCC[Br]', ['bromine']) bb3 = stk.BuildingBlock('[I]COCC[I]', ['iodine']) bb4 = stk.BuildingBlock('O=CC(C=O)CC=O', ['aldehyde']) c1 = stk.ConstructedMolecule(building_blocks=[bb2], topology_graph=stk.polymer.Linear('A', 3)) c2 = stk.ConstructedMolecule(building_blocks=[bb1, bb4], topology_graph=stk.cage.FourPlusSix()) c3 = stk.ConstructedMolecule(building_blocks=[bb1, bb4], topology_graph=stk.cage.EightPlusTwelve()) c4 = stk.ConstructedMolecule(building_blocks=[bb2, bb3], topology_graph=stk.polymer.Linear('AB', 3)) return bb1, bb2, bb3, bb4, c1, c2, c3, c4
def test_multi_bb(amine2, amine2_alt1, amine2_alt2, aldehyde3, aldehyde3_alt1, aldehyde3_alt2): building_blocks = [ amine2, amine2_alt1, amine2_alt2, aldehyde3, aldehyde3_alt1, aldehyde3_alt2 ] four_plus_six = stk.cage.FourPlusSix() c = stk.ConstructedMolecule(building_blocks=building_blocks, topology_graph=four_plus_six, building_block_vertices={ aldehyde3: four_plus_six.vertices[0:1], aldehyde3_alt1: four_plus_six.vertices[1:2], aldehyde3_alt2: four_plus_six.vertices[2:4], amine2: four_plus_six.vertices[4:6], amine2_alt1: four_plus_six.vertices[6:7], amine2_alt2: four_plus_six.vertices[7:] }) c.write(join(test_dir, 'multi_bb.mol')) num_expected_bbs = { amine2: 2, amine2_alt1: 1, amine2_alt2: 3, aldehyde3: 1, aldehyde3_alt1: 1, aldehyde3_alt2: 2 } _test_construction(c, num_expected_bbs) _test_dump_and_load(test_dir, c)
def add_constructed_molecules( client, database, key_makers, ): constructed_molecule_db = stk.ConstructedMoleculeMongoDb( mongo_client=client, database=database, molecule_collection='molecules', position_matrix_collection='position_matrices', jsonizer=stk.ConstructedMoleculeJsonizer(key_makers=key_makers, ), ) num_atoms_db = stk.ValueMongoDb( mongo_client=client, collection='numAtoms', database=database, key_makers=key_makers, ) for bb1, bb2 in zip( get_molecules(200, 5), get_molecules(200, 5), ): molecule = stk.ConstructedMolecule(topology_graph=stk.polymer.Linear( building_blocks=(bb1, bb2), repeating_unit='AB', num_repeating_units=1, ), ) constructed_molecule_db.put(molecule) num_atoms_db.put(molecule, molecule.get_num_atoms()) num_atoms_db.put(bb1, bb1.get_num_atoms())
def build_cage_complex(host, guest): """ Build cage complex with stk. """ complex = stk.ConstructedMolecule(building_blocks=[host, guest], topology_graph=stk.host_guest.Complex()) return complex
def build_cage(bb1, bb2, topology, bb_vert=None): """ Build cage with stk. """ cage = stk.ConstructedMolecule(building_blocks=[bb1, bb2], topology_graph=topology, building_block_vertices=bb_vert) return cage
def _get_macrocycle() -> stk.BuildingBlock: macrocycle = stk.ConstructedMolecule( topology_graph=stk.macrocycle.Macrocycle( building_blocks=(stk.BuildingBlock('BrCCCBr', [stk.BromoFactory()]), ), repeating_unit='A', num_repeating_units=5, ), ) return stk.BuildingBlock.init_from_molecule(macrocycle)
def tmp_one_plus_one(tmp_amine3, tmp_aldehyde3): topology_graph = stk.cage.OnePlusOne() return stk.ConstructedMolecule( building_blocks=[tmp_amine3, tmp_aldehyde3], topology_graph=topology_graph, building_block_vertices={ tmp_amine3: topology_graph.vertices[:1], tmp_aldehyde3: topology_graph.vertices[1:] } )
def tmp_four_plus_four(tmp_amine3, tmp_aldehyde3): topology_graph = stk.cage.FourPlusFour() return stk.ConstructedMolecule( building_blocks=[tmp_amine3, tmp_aldehyde3], topology_graph=topology_graph, building_block_vertices={ tmp_amine3: topology_graph.vertices[:4], tmp_aldehyde3: topology_graph.vertices[4:] } )
def tmp_two_plus_two(tmp_amine3, tmp_aldehyde3): topology_graph = stk.cage.TwoPlusTwo() return stk.ConstructedMolecule( building_blocks=[tmp_amine3, tmp_aldehyde3], topology_graph=topology_graph, building_block_vertices={ tmp_amine3: topology_graph.vertices[:2], tmp_aldehyde3: topology_graph.vertices[2:] } )
def _create_host(amine2, amine2_alt3, aldehyde3): four_plus_six = stk.cage.FourPlusSix() return stk.ConstructedMolecule( building_blocks=[amine2, amine2_alt3, aldehyde3], topology_graph=four_plus_six, building_block_vertices={ amine2: four_plus_six.vertices[5:], amine2_alt3: four_plus_six.vertices[4:5], aldehyde3: four_plus_six.vertices[:4] })
def test_construction(amine2, aldehyde2, boronic_acid2, diol2): repeat_units = 3 polymers = (stk.ConstructedMolecule(building_blocks=[amine2, aldehyde2], topology_graph=stk.polymer.Linear( repeating_unit='AB', orientations=[1, 1], num_repeating_units=repeat_units)), stk.ConstructedMolecule(building_blocks=[boronic_acid2, diol2], topology_graph=stk.polymer.Linear( repeating_unit='AB', num_repeating_units=repeat_units))) lost_bonds_per_join = (2, 4) polymer_data = zip(polymers, lost_bonds_per_join) for polymer, num_lost_bonds_per_join in polymer_data: _test_construction(polymer=polymer, repeat_units=repeat_units, num_lost_bonds_per_join=num_lost_bonds_per_join) _test_dump_and_load(test_dir, polymer)
def __init__( self, topology_graph, building_blocks, lattice_size, vertex_alignments, num_new_atoms, num_new_bonds, num_building_blocks, ): """ Initialize a :class:`.CofData` instance. Parameters ---------- topology_graph : :class:`type` A COF class. building_blocks : :class:`tuple` of :class:`.BuildingBlock` The building blocks of the COF. lattice_size : :class:`tuple` of :class:`int` The size of the lattice. vertex_alignments : :class:`dict` Passed to the `vertex_alignments` parameter of the COF initializer. num_new_atoms : :class:`int` The number of new atoms added by the construction process. num_new_bonds : :class:`int` The number of new bonds added by the construction process. num_building_blocks : :class:`dict` For each building block in `building_blocks`, maps its index to the number of times its used in the construction of the COF. """ self.constructed_molecule = stk.ConstructedMolecule( topology_graph=topology_graph( building_blocks=building_blocks, lattice_size=lattice_size, vertex_alignments=vertex_alignments, ) ) self.num_new_atoms = num_new_atoms self.num_new_bonds = num_new_bonds self.num_building_blocks = { building_blocks[index]: num for index, num in num_building_blocks.items() } self.building_blocks = building_blocks
def tmp_periodic_linkerless_honeycomb(tmp_amine3, tmp_aldehyde3): topology_graph = stk.cof.LinkerlessHoneycomb((3, 3, 1), True) num_verts = len(topology_graph.vertices) return stk.ConstructedMolecule( building_blocks=[tmp_amine3, tmp_aldehyde3], topology_graph=topology_graph, building_block_vertices={ tmp_amine3: topology_graph.vertices[:num_verts//2], tmp_aldehyde3: topology_graph.vertices[num_verts//2:] } )
def _get_cycle2() -> stk.BuildingBlock: molecule = stk.ConstructedMolecule( topology_graph=stk.macrocycle.Macrocycle( building_blocks=(stk.BuildingBlock( smiles='Br[C+]1[C+](Br)[C+]=[C+]1', functional_groups=[stk.BromoFactory()], ), ), repeating_unit='A', num_repeating_units=8, ), ) return stk.BuildingBlock.init_from_molecule(molecule)
def test_init(amine2, aldehyde2): polymer = stk.ConstructedMolecule(building_blocks=[amine2, aldehyde2], topology_graph=stk.polymer.Linear( 'AB', 3), use_cache=True) polymer2 = stk.ConstructedMolecule(building_blocks=[amine2, aldehyde2], topology_graph=stk.polymer.Linear( 'AB', 3), use_cache=True) assert polymer is polymer2 polymer3 = stk.ConstructedMolecule(building_blocks=[amine2, aldehyde2], topology_graph=stk.polymer.Linear( 'AB', 3), use_cache=False) assert polymer is not polymer3 polymer4 = stk.ConstructedMolecule(building_blocks=[amine2, aldehyde2], topology_graph=stk.polymer.Linear( 'AB', 3, (1, 0.5)), use_cache=True) assert polymer is not polymer4
def build_kagome( lattice_size: tuple[int, int, int], ) -> stk.ConstructedMolecule: bb1 = stk.BuildingBlock('BrCCBr', [stk.BromoFactory()]) bb2 = stk.BuildingBlock( smiles='BrC1C(Br)CC(Br)C(Br)C1', functional_groups=[stk.BromoFactory()], ) cof = stk.ConstructedMolecule(topology_graph=stk.cof.Kagome( building_blocks=(bb1, bb2), lattice_size=lattice_size, ), ) return cof