@rcsb/rcsb-saguaro-3d/lib/RcsbFvStructure/StructureViewers/MolstarViewer/TrajectoryPresetProvider/FlexibleAlignmentBuiltIn.js

RCSB Molstar/Saguaro Web App

import { __awaiter } from "tslib";
import { PluginStateObject as PSO, PluginStateTransform } from "molstar/lib/mol-plugin-state/objects";
import { ParamDefinition as PD } from "molstar/lib/mol-util/param-definition";
import { Structure, StructureElement, StructureProperties as SP, StructureSelection } from "molstar/lib/mol-model/structure";
import { MolScriptBuilder as MS } from "molstar/lib/mol-script/language/builder";
import { StructureQueryHelper } from "molstar/lib/mol-plugin-state/helpers/structure-query";
import { RootStructureDefinition } from "molstar/lib/mol-plugin-state/helpers/root-structure";
import { Task } from "molstar/lib/mol-task";
export const FlexibleAlignmentBuiltIn = PluginStateTransform.BuiltIn({
    name: "Flexible Alignment",
    display: "Flexible Alignment",
    from: PSO.Molecule.Model,
    to: PSO.Molecule.Structure,
    params: {
        pdb: PD.Value(undefined),
        transform: PD.Value(undefined)
    }
})({
    apply({ a, params }, plugin) {
        return Task.create('Build Flexible Chain', (ctx) => __awaiter(this, void 0, void 0, function* () {
            var _a, _b, _c, _d;
            const base = yield RootStructureDefinition.create(plugin, ctx, a.data);
            const structure = base.data;
            const entityId = params.pdb && "entityId" in params.pdb ? (_a = params.pdb) === null || _a === void 0 ? void 0 : _a.entityId : undefined;
            const instanceId = params.pdb && "instanceId" in params.pdb ? (_b = params.pdb) === null || _b === void 0 ? void 0 : _b.instanceId : undefined;
            const l = StructureElement.Location.create(structure);
            let alignedAsymId;
            let alignedOperatorName;
            let alignedType;
            for (const unit of structure.units) {
                StructureElement.Location.set(l, structure, unit, unit.elements[0]);
                if (SP.chain.label_entity_id(l) == entityId || SP.chain.label_asym_id(l) == instanceId) {
                    alignedAsymId = SP.chain.label_asym_id(l);
                    alignedOperatorName = SP.unit.operator_name(l);
                    alignedType = SP.entity.type(l);
                    const alignedOperators = SP.unit.pdbx_struct_oper_list_ids(l);
                    if (alignedOperators.length == 0)
                        alignedOperators.push("0");
                    if (alignedType != "polymer")
                        throw new Error("");
                    const builder = Structure.Builder({ label: structure.label });
                    builder.beginChainGroup();
                    for (const trans of (_c = params.transform) !== null && _c !== void 0 ? _c : []) {
                        const residues = [];
                        for (const r of (_d = trans.regions) !== null && _d !== void 0 ? _d : []) {
                            residues.push(toRange(r[0], r[1]));
                        }
                        const expression = MS.struct.generator.atomGroups({
                            'chain-test': MS.core.logic.and([
                                MS.core.rel.eq([MS.ammp('label_asym_id'), alignedAsymId]),
                                MS.core.rel.eq([MS.acp('operatorName'), alignedOperatorName])
                            ]),
                            'residue-test': MS.core.logic.or((residues.flat()).map(p => MS.struct.atomProperty.ihm.hasSeqId([p])))
                        });
                        const { selection } = StructureQueryHelper.createAndRun(structure, expression);
                        const s = StructureSelection.unionStructure(selection);
                        const ts = Structure.transform(s, trans.transform);
                        const u = ts.units[0];
                        builder.addUnit(u.kind, u.model, u.conformation.operator, u.elements, u.traits, u.invariantId);
                    }
                    builder.endChainGroup();
                    const blockStructure = builder.getStructure();
                    return new PSO.Molecule.Structure(blockStructure, { label: structure.label });
                }
            }
            throw new Error("");
        }));
    },
    dispose({ b }) {
        b === null || b === void 0 ? void 0 : b.data.customPropertyDescriptors.dispose();
    }
});
function toRange(start, end) {
    if (!end)
        return [start];
    const b = start < end ? start : end;
    const e = start < end ? end : start;
    return [...Array(e - b + 1)].map((_, i) => b + i);
}
//# sourceMappingURL=FlexibleAlignmentBuiltIn.js.map