M4L6 Tetrahedron

class M4L6Tetrahedron(building_blocks, vertex_alignments=None, reaction_factory=GenericReactionFactory(), num_processes=1, optimizer=<stk.molecular.topology_graphs.topology_graph.optimizers.null.NullOptimizer object>)[source]

Bases: Cage

Represents a cage topology graph.

MCHammer optimized construction

This topology directly connects the vertices of the tetrahedron.

Building blocks with three functional groups are required for this topology.

When using a dict for the building_blocks parameter, as in Examples: Multi-Building Block Cage Construction, a BuildingBlock, with the following number of functional groups, needs to be assigned to each of the following vertex ids:

3-functional groups: 0 to 3

Examples

Building a Metal-Organic Tetrahedron

Many metal-organic cages are built using a process called subcomponent self-assembly, which is a complex chemical process that occurs in solution. Here, we provide an example of an alchemical approach to building these types of cages. It is alchemical because the bonds formed during construction are not the same as the experimental reaction. Instead of forming bonds at the metal centre, we create bonds between disconnected ligands. Firstly, we define the disconnected linker molecule, where we have added a bromine atom at the disconnection to perform the cage reaction.

import stk

# Define coordinating ligand with dummy bromine groups and
# metal coordinating functional groups.
bb1 = stk.BuildingBlock(
    smiles='C1=NC(C=NBr)=CC=C1',
    functional_groups=[
        stk.SmartsFunctionalGroupFactory(
            smarts='[#6]~[#7X2]~[#35]',
            bonders=(1, ),
            deleters=(),
        ),
        stk.SmartsFunctionalGroupFactory(
            smarts='[#6]~[#7X2]~[#6]',
            bonders=(1, ),
            deleters=(),
        ),
    ],
)

We then build the desired metal complex with this linker. This process completes all metal-ligand reactions performed during the subcomponent self-assembly process.

# Produce a Fe+2 atom with 6 functional groups.
iron_atom = stk.BuildingBlock(
    smiles='[Fe+2]',
    functional_groups=(
        stk.SingleAtom(stk.Fe(0, charge=2))
        for i in range(6)
    ),
    position_matrix=[[0, 0, 0]],
)

# Build iron complex with delta stereochemistry.
iron_oct_delta = stk.ConstructedMolecule(
    topology_graph=stk.metal_complex.OctahedralDelta(
        metals=iron_atom,
        ligands=bb1,
    ),
)

We then redefine the metal complex building block based on its bromine functional groups, which becomes the metal-based building block of any cage formed by this process.

# Assign Bromo functional groups to the metal complex.
iron_oct_delta = stk.BuildingBlock.init_from_molecule(
    molecule=iron_oct_delta,
    functional_groups=[stk.BromoFactory()],
)

Finally, we build the M4L6Tetrahedron cage using this building block.

# Build an M4L6 Tetrahedron.
cage2 = stk.ConstructedMolecule(
    topology_graph=stk.cage.M4L6Tetrahedron(
        building_blocks=(iron_oct_delta, ),
    ),
)

Importantly, in the case that the linker cannot be disconnected in a symmetrical fashion, we have provided the M4L6TetrahedronSpacer topology, which has a spacer vertex between the metal vertices on the tetrahedron. See M4L6TetrahedronSpacer for an example of its usage.

See Cage for more details and examples.

Methods

`clone`()	Return a clone.
`construct`()	Construct a `ConstructedMolecule`.
`get_building_blocks`()	Yield the building blocks.
`get_num_building_block`(building_block)	Get the number of times building_block is present.
`with_building_blocks`(building_block_map)	Return a clone holding different building blocks.

__init__(building_blocks, vertex_alignments=None, reaction_factory=GenericReactionFactory(), num_processes=1, optimizer=<stk.molecular.topology_graphs.topology_graph.optimizers.null.NullOptimizer object>)

Initialize a Cage.

Parameters:

building_blocks (Union[Iterable[BuildingBlock], dict[BuildingBlock, tuple[int, ...]]]) –
Can be a iterable of BuildingBlock instances, which should be placed on the topology graph.

Can also be a dict which maps the BuildingBlock instances to the ids of the vertices it should be placed on. A dict is required when there are multiple building blocks with the same number of functional groups, because in this case the desired placement is ambiguous.
vertex_alignments (Optional[dict[int, int]]) – A mapping from the id of a Vertex to an Edge connected to it. The Edge is used to align the first FunctionalGroup of a BuildingBlock placed on that vertex. Only vertices which need to have their default edge changed need to be present in the dict. If None then the default edge is used for each vertex. Changing which Edge is used will mean that the topology graph represents different structural isomers. The edge is referred to by a number between 0 (inclusive) and the number of edges the vertex is connected to (exclusive).
reaction_factory (ReactionFactory) – The reaction factory to use for creating bonds between building blocks.
num_processes (int) – The number of parallel processes to create during construct().
optimizer (Optimizer) – Used to optimize the structure of the constructed molecule.

Raises:

AssertionError – If the any building block does not have a valid number of functional groups.
ValueError – If the there are multiple building blocks with the same number of functional_groups in building_blocks, and they are not explicitly assigned to vertices. The desired placement of building blocks is ambiguous in this case.
UnoccupiedVertexError – If a vertex of the cage topology graph does not have a building block placed on it.
OverlyOccupiedVertexError – If a vertex of the cage topology graph has more than one building block placed on it.

clone()

Return a clone.

Return type:: Cage
Returns:: The clone.

construct()

Construct a ConstructedMolecule.

Return type:: ConstructionResult
Returns:: The data describing the ConstructedMolecule.

get_building_blocks()

Yield the building blocks.

Building blocks are yielded in an order based on their position in the topology graph. For two equivalent topology graphs, but with different building blocks, equivalently positioned building blocks will be yielded at the same time.

Yields:: A building block of the topology graph.
Return type:: Iterator[BuildingBlock]

get_num_building_block(building_block)

Get the number of times building_block is present.

Parameters:: building_block (BuildingBlock) – The building block whose frequency in the topology graph is desired.
Return type:: int
Returns:: The number of times building_block is present in the topology graph.

with_building_blocks(building_block_map)

Return a clone holding different building blocks.

Parameters:: building_block_map (dict[BuildingBlock, BuildingBlock]) – Maps a building block in the current topology graph to the building block which should replace it in the clone. If a building block should be not replaced in the clone, it can be omitted from the map.
Return type:: Cage
Returns:: The clone.