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
