TmMolStar/src/extensions/tmdet/symmetry.ts

/**
 * Copyright (C) 2022, Protein Bioinformatics Research Group, RCNS
 *
 * Licensed under CC BY-NC 4.0, see LICENSE file for more info.
 *
 * @author Gabor Tusnady <tusnady.gabor@ttk.hu>
 * @author Csongor Gerdan <gerdan.csongor@ttk.hu>
 */

import { MmcifFormat } from '../../mol-model-formats/structure/mmcif';
import { Column, Table } from '../../mol-data/db';
import { mmCIF_Schema } from '../../mol-io/reader/cif/schema/mmcif';
import { Model } from '../../mol-model/structure';
import { ModelSymmetry } from '../../mol-model-formats/structure/property/symmetry';
import { PDBTMDescriptor } from './types';
import { DebugUtil } from './debug-utils';


export function registerTmDetSymmetry(pdbtmDescriptor: PDBTMDescriptor) {
    ModelSymmetry.Provider.formatRegistry.remove('mmCIF');
    const excludedChains = constructChainListFromOperations(pdbtmDescriptor);
    ModelSymmetry.Provider.formatRegistry.add('mmCIF',  function(model: Model) {
        return tmDetSymmetryFromMmCif(model, excludedChains);
    });
}

function constructChainListFromOperations(pdbtmDescriptor: PDBTMDescriptor): string[] {
    const excludedChains: string[] = [];
    // add chain deletes
    const biomatrix = pdbtmDescriptor.additional_entry_annotations.biomatrix;
    if (biomatrix?.chain_deletes) {
        biomatrix.chain_deletes.forEach(
            chainId => excludedChains.push(chainId)
        );
    }
    // exclude result of transformations
    if (biomatrix?.matrix_list) {
        biomatrix.matrix_list.forEach(
            matrix => matrix.apply_to_chain_list.forEach(
                applyItem => excludedChains.push(applyItem.new_chain_id)
            )
        );
    }

    return excludedChains;
}

function tmDetSymmetryFromMmCif(model: Model, excludedChains: string[]) {
    if (!MmcifFormat.is(model.sourceData)) return;

    let data = model.sourceData.data.db;
    let asymIdColumnData: string[][] = [];
    // update chains (asym) for each author_defined_assemly
    // NOTE: We assume that the first assembly is an author defined assembly.
    const currentAssemblyId: string = data.pdbx_struct_assembly_gen.assembly_id.value(0);
    excludedChains = union(
        excludedChains,
        Array.from(data.pdbx_nonpoly_scheme.asym_id.toArray())
    );
    const result: string[][] = createAsymIdColumnData(
        data.pdbx_struct_assembly_gen, currentAssemblyId, excludedChains
    );
    asymIdColumnData = asymIdColumnData.concat(result);

    const asym_id_list_column = Column.ofStringListArray(asymIdColumnData);
    // create table with new column
    let updated_pdbx_struct_assembly_gen = Table.ofColumns(
        data.pdbx_struct_assembly_gen._schema,
        {
            assembly_id: data.pdbx_struct_assembly_gen.assembly_id,
            asym_id_list: asym_id_list_column,
            //oper_expression: data.pdbx_struct_assembly_gen.oper_expression
            // NOTE: we expect here pdbx_struct_assembly_gen has only one row
            oper_expression: Column.ofStringArray([ '1' ])
        }
    );
    DebugUtil.log('Orig. assembly_gen', Table.formatToString(data.pdbx_struct_assembly_gen));
    DebugUtil.log('Updated assembly_gen', Table.formatToString(updated_pdbx_struct_assembly_gen));

    DebugUtil.log('Oper expression:', data.pdbx_struct_assembly_gen.oper_expression.toArray());
    DebugUtil.log('Non-poly entities:', Table.formatToString(data.pdbx_entity_nonpoly));
    DebugUtil.log('Non-poly chains:', data.pdbx_nonpoly_scheme.asym_id.toArray());

    DebugUtil.log('Excluded chains:', excludedChains);
    DebugUtil.log('Included chains:', result);

    DebugUtil.log('oper_list table: original:', Table.formatToString(data.pdbx_struct_oper_list));
    const only_identity_operation = Table.ofRows(
        data.pdbx_struct_oper_list._schema, [ Table.getRow(data.pdbx_struct_oper_list, 0) ]
    );
    DebugUtil.log('oper_list table: first row', Table.formatToString(only_identity_operation));

    return ModelSymmetry.fromData({
        symmetry: data.symmetry,
        cell: data.cell,
        struct_ncs_oper: data.struct_ncs_oper,
        atom_sites: data.atom_sites,
        pdbx_struct_assembly: data.pdbx_struct_assembly,
        pdbx_struct_assembly_gen: updated_pdbx_struct_assembly_gen,
        pdbx_struct_oper_list: only_identity_operation
    });
}

function createAsymIdColumnData(pdbx_struct_assembly_gen: Table<mmCIF_Schema['pdbx_struct_assembly_gen']>, assemblyId: string, chains: string[]) {

    const asym_id_list: string[][] = [];
    for (let i = 0; i < pdbx_struct_assembly_gen._rowCount; i++) {
        const currentAsymIdList = pdbx_struct_assembly_gen.asym_id_list.value(i);
        asym_id_list.push(
            (assemblyId == pdbx_struct_assembly_gen.assembly_id.value(i))
                ? minus(currentAsymIdList, chains)
                : currentAsymIdList
        );
    }
    return asym_id_list;
}

// difference of two string arrays (interpreted as sets)
function minus(a: string[], b: string[]): string[] {
    const b_set = new Set(b);
    return a.filter(x => !b_set.has(x));
}

// union of two string arrays (interpreted as sets)
function union(a: string[], b: string[]): string[] {
    const a_set = new Set(a);
    b.forEach(item => a_set.add(item));
    return Array.from(a_set.values());
}