M6L4-TT + M6L4-SP

Covers a system containing two types of M6L4 cage: TT (Truncated Tetrahedron) and SP (Square Planar). Subassemblies are enumerated from each template separately, deduplicated and merged, then MX capping is applied.

Templates

M, L, and X components are shared between both templates.

from nasap_net import Assembly, Bond, Component, enumerate_assemblies

M = Component(kind='M', sites=[0, 1])
L = Component(kind='L', sites=[0, 1, 2])
X = Component(kind='X', sites=[0])

M6L4-SP (Square Planar):

M6L4_SP = Assembly(
    components={
        'M0': M, 'M1': M, 'M2': M, 'M3': M, 'M4': M, 'M5': M,
        'L0': L, 'L1': L, 'L2': L, 'L3': L,
    },
    bonds=[
        Bond('M0', 0, 'L0', 0), Bond('M0', 1, 'L3', 0),
        Bond('M2', 0, 'L2', 0), Bond('M2', 1, 'L1', 0),
        Bond('M1', 0, 'L0', 1), Bond('M1', 1, 'L1', 1),
        Bond('M3', 0, 'L2', 1), Bond('M3', 1, 'L3', 1),
        Bond('M4', 0, 'L0', 2), Bond('M4', 1, 'L1', 2),
        Bond('M5', 0, 'L2', 2), Bond('M5', 1, 'L3', 2),
    ],
)

M6L4-TT (Truncated Tetrahedron): see M6L4-TT for the structural diagram.

M6L4TT = Assembly(
    components={
        'M0': M, 'M1': M, 'M2': M, 'M3': M, 'M4': M, 'M5': M,
        'L0': L, 'L1': L, 'L2': L, 'L3': L,
    },
    bonds=[
        Bond('M0', 0, 'L0', 1), Bond('M1', 0, 'L0', 2),
        Bond('M2', 0, 'L2', 1), Bond('M3', 0, 'L2', 2),
        Bond('M4', 0, 'L0', 0), Bond('M4', 1, 'L2', 0),
        Bond('M0', 1, 'L3', 1), Bond('M1', 1, 'L1', 2),
        Bond('M2', 1, 'L1', 1), Bond('M3', 1, 'L3', 2),
        Bond('M5', 0, 'L1', 0), Bond('M5', 1, 'L3', 0),
    ],
)

Subassembly enumeration

Enumerate from each template separately, then deduplicate and merge.

from nasap_net import extract_unique_assemblies

tt_assemblies = list(enumerate_assemblies(
    template=M6L4TT,
    leaving_ligand=X,
    metal_kinds='M',
))

sp_assemblies = list(enumerate_assemblies(
    template=M6L4_SP,
    leaving_ligand=X,
    metal_kinds='M',
))

unique_assemblies = extract_unique_assemblies(tt_assemblies + sp_assemblies)

56 assemblies from TT and 66 from SP; 85 remain after deduplication.

MX capping

Apply MX capping to the merged assemblies.

from nasap_net import BindingSite, enumerate_assemblies_capped_with_assembly

MX = Assembly(
    components={'M': M, 'X': X},
    bonds=[Bond('M', 1, 'X', 0)],
)

capped_assemblies = enumerate_assemblies_capped_with_assembly(
    assemblies=unique_assemblies,
    component_kind='L',
    capping_assembly=MX,
    capping_assembly_site=BindingSite('M', 0),
)

Saving

Combine the TT/SP subassemblies and the capped assemblies.

import os
from nasap_net import save_assemblies

all_assemblies = extract_unique_assemblies(
    set(tt_assemblies) | set(sp_assemblies) | capped_assemblies
)

os.makedirs('output', exist_ok=True)
save_assemblies(tt_assemblies, 'output/tt_assemblies.yaml', overwrite=True)
save_assemblies(sp_assemblies, 'output/sp_assemblies.yaml', overwrite=True)
save_assemblies(capped_assemblies, 'output/capped_assemblies.yaml', overwrite=True)
save_assemblies(all_assemblies, 'output/all_assemblies.yaml', overwrite=True)

93 capped assemblies are produced; after deduplication with the TT/SP subassemblies, the total is 112.