pdbe-molstar 3.6.0 → 3.7.0

package/build/pdbe-molstar-plugin.js.LICENSE.txt

@@ -1,6 +1,6 @@
 /**
  * pdbe-molstar
- * @version 3.6.0
+ * @version 3.7.0
  * @link https://github.com/PDBeurope/pdbe-molstar
  * @license Apache 2.0
  */

package/build/pdbe-molstar.css

@@ -1,6 +1,6 @@
 /**
  * pdbe-molstar
- * @version 3.6.0
+ * @version 3.7.0
  * @link https://github.com/PDBeurope/pdbe-molstar
  * @license Apache 2.0
  */

package/lib/alphafold-transparency.js

@@ -13,7 +13,8 @@ const compiler_1 = require("molstar/lib/mol-script/runtime/query/compiler");
 const mol_state_1 = require("molstar/lib/mol-state");
 const transparency_1 = require("molstar/lib/mol-theme/transparency");
 const TransparencyManagerTag = 'transparency-controls';
-function getLociByPLDDT(score, contextData) {
+/** Select part of the structure with pLDDT <= score. */
+function getLociBelowPLDDT(score, contextData) {
     const queryExp = builder_1.MolScriptBuilder.struct.modifier.union([
         builder_1.MolScriptBuilder.struct.modifier.wholeResidues([
             builder_1.MolScriptBuilder.struct.modifier.union([
@@ -28,13 +29,11 @@ function getLociByPLDDT(score, contextData) {
     const sel = query(new structure_1.QueryContext(contextData));
     return structure_1.StructureSelection.toLociWithSourceUnits(sel);
 }
-function applyAFTransparency(plugin_1, structure_2, transparency_2) {
-    return tslib_1.__awaiter(this, arguments, void 0, function* (plugin, structure, transparency, pLDDT = 70) {
-        return plugin.dataTransaction((ctx) => tslib_1.__awaiter(this, void 0, void 0, function* () {
-            const loci = getLociByPLDDT(pLDDT, structure.cell.obj.data);
-            yield setStructureTransparency(plugin, structure.components, transparency, loci);
-        }), { canUndo: 'Apply Transparency' });
-    });
+function applyAFTransparency(plugin, structure, transparency, pLDDT = 70) {
+    return plugin.dataTransaction((ctx) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const loci = getLociBelowPLDDT(pLDDT, structure.cell.obj.data);
+        yield setStructureTransparency(plugin, structure.components, transparency, loci);
+    }), { canUndo: 'Apply Transparency' });
 }
 function setStructureTransparency(plugin, components, value, loci, types) {
     return tslib_1.__awaiter(this, void 0, void 0, function* () {

package/lib/extensions/complexes/coloring.d.ts

@@ -9,6 +9,13 @@ export declare function colorComponents(viewer: PDBeMolstarPlugin, params: {
     coreColor?: string;
     componentColors?: string[];
 }): Promise<void>;
+/**
+Coloring - subcomplexes:
+- base common -> by entity, lighter
+- base additional -> gray, lighter
+- sub common -> by entity, darker
+- sub additional -> gray, darker (these are all unmapped components, includes antibodies and ligands)
+*/
 export declare function colorSubcomplex(viewer: PDBeMolstarPlugin, params: {
     baseStructId?: string;
     otherStructId?: string;
@@ -23,6 +30,14 @@ export declare function colorSubcomplex(viewer: PDBeMolstarPlugin, params: {
     coreColor?: string;
     componentColors?: string[];
 }): Promise<void>;
+/**
+Coloring - supercomplexes:
+- base common -> gray, lighter
+- base additional -> unmapped color, lighter (these are all unmapped components, includes antibodies and ligands)
+- super common -> gray, darker
+- super additional mapped -> by entity, darker
+- super additional unmapped -> unmapped color, darker
+*/
 export declare function colorSupercomplex(viewer: PDBeMolstarPlugin, params: {
     baseStructId?: string;
     otherStructId?: string;

package/lib/extensions/complexes/coloring.js

@@ -7,18 +7,14 @@ const tslib_1 = require("tslib");
 const color_1 = require("molstar/lib/mol-util/color");
 const helpers_1 = require("../../helpers");
 const DEFAULT_CORE_COLOR = '#d8d8d8';
-const DEFAULT_UNMAPPED_COLOR = '#222222';
+const DEFAULT_UNMAPPED_COLOR = '#f000f0';
 const DEFAULT_COMPONENT_COLORS = [
-    '#1b9e77', '#d95f02', '#7570b3', '#e7298a', '#66a61e', '#e6ab02', '#a6761d', // Dark-2
-    '#7f3c8d', '#11a579', '#3969ac', '#f2b701', '#e73f74', '#80ba5a', '#e68310', '#008695', '#cf1c90', '#f97b72', // Bold
-    '#66c5cc', '#f6cf71', '#f89c74', '#dcb0f2', '#87c55f', '#9eb9f3', '#fe88b1', '#c9db74', '#8be0a4', '#b497e7', // Pastel
-    '#e5c494', '#66c2a5', '#fc8d62', '#8da0cb', '#e78ac3', '#a6d854', // Set-2
+    '#1b9e77', '#d95f02', '#7570b3', '#66a61e', '#e6ab02', '#a6761d', // Dark-2 without gray and magenta
+    '#1f77b4', '#2ca02c', '#d62728', '#927ba7', '#8c564b', '#e377c2', '#bcbd22', '#17becf', // More non-conflicting colors from other palettes
+    '#fc8d62', '#9eb9f3', '#ff9da7', '#ffff33', '#8be0a4', '#e15759', '#c69fbb', '#76b7b2', // More non-conflicting colors from other palettes
 ];
-// TODO compare color variants:
-// http://127.0.0.1:1339/complexes-demo.html?complexId=PDB-CPX-159519&unmappedColor=%23222222
-// http://127.0.0.1:1339/complexes-demo.html?complexId=PDB-CPX-159519&unmappedColor=%23ff0000
 /** How much lighter/darker colors should be for the base/other complex */
-const COLOR_ADJUSTMENT_STRENGTH = 0.75;
+const COLOR_ADJUSTMENT_STRENGTH = 0.8;
 function colorComponents(viewer, params) {
     return tslib_1.__awaiter(this, void 0, void 0, function* () {
         const { coreColor = DEFAULT_CORE_COLOR, componentColors = DEFAULT_COMPONENT_COLORS, components, mappings = {} } = params;
@@ -34,6 +30,13 @@ function colorComponents(viewer, params) {
         yield viewer.visual.tooltips({ data: tooltipData, structureId: params.structId });
     });
 }
+/**
+Coloring - subcomplexes:
+- base common -> by entity, lighter
+- base additional -> gray, lighter
+- sub common -> by entity, darker
+- sub additional -> gray, darker (these are all unmapped components, includes antibodies and ligands)
+*/
 function colorSubcomplex(viewer, params) {
     return tslib_1.__awaiter(this, void 0, void 0, function* () {
         const { coreColor = DEFAULT_CORE_COLOR, componentColors = DEFAULT_COMPONENT_COLORS, baseComponents, baseMappings = {}, otherMappings = {} } = params;
@@ -65,6 +68,14 @@ function colorSubcomplex(viewer, params) {
         }
     });
 }
+/**
+Coloring - supercomplexes:
+- base common -> gray, lighter
+- base additional -> unmapped color, lighter (these are all unmapped components, includes antibodies and ligands)
+- super common -> gray, darker
+- super additional mapped -> by entity, darker
+- super additional unmapped -> unmapped color, darker
+*/
 function colorSupercomplex(viewer, params) {
     return tslib_1.__awaiter(this, void 0, void 0, function* () {
         const { coreColor = DEFAULT_CORE_COLOR, unmappedColor = DEFAULT_UNMAPPED_COLOR, componentColors = DEFAULT_COMPONENT_COLORS, baseMappings = {}, otherMappings = {} } = params;

package/lib/extensions/complexes/index.d.ts

@@ -1,9 +1,9 @@
 /** Helper functions to allow superposition of complexes */
-import { Structure } from 'molstar/lib/mol-model/structure';
+import { MinimizeRmsd } from 'molstar/lib/mol-math/linear-algebra/3d/minimize-rmsd';
 import { PDBeMolstarPlugin } from '../..';
 import { QueryParam } from '../../helpers';
-import { SuperpositionResult } from './superpose-by-biggest-chain';
 export * as Coloring from './coloring';
+/** Parameters to `loadComplexSuperposition` */
 export interface LoadComplexSuperpositionParams {
     /** PDB identifier of complex structure */
     pdbId: string;
@@ -27,29 +27,44 @@ export interface LoadComplexSuperpositionParams {
     unmappedColor?: string;
     /** List of colors for coloring unique entities. */
     componentColors?: string[];
-    /** Optional specification of which parts of the base complex structure belong to individual Uniprot/Rfam accessions (will be inferred from mmCIF atom_site if not provided) */
+    /** Optional specification of which parts of the base complex structure belong to individual Uniprot/Rfam accessions (will be inferred from mmCIF atom_site if not provided).
+     * It is recommended to provide this for nucleic acids as they don't have mapping in atom_site. */
     baseMappings?: {
         [accession: string]: QueryParam[];
     };
-    /** Optional specification of which parts of the other complex structure belong to individual Uniprot/Rfam accessions (will be inferred from mmCIF atom_site if not provided) */
+    /** Optional specification of which parts of the other complex structure belong to individual Uniprot/Rfam accessions (will be inferred from mmCIF atom_site if not provided).
+     * It is recommended to provide this for nucleic acids as they don't have mapping in atom_site. */
     otherMappings?: {
         [accession: string]: QueryParam[];
     };
-    /** Superposition method */
-    method?: 'biggest-matched-chain' | 'molstar-builtin';
 }
-/** Load a structure, superpose onto the main structure based on Uniprot residue numbers, and optionally apply coloring to show common/additional components. */
-export declare function loadComplexSuperposition(viewer: PDBeMolstarPlugin, params: LoadComplexSuperpositionParams): Promise<{
+/** Result type of `loadComplexSuperposition` */
+export interface LoadComplexSuperpositionResult {
     /** Structure identifier of the newly loaded complex structure, to refer to this structure later */
     id: string;
-    /** Status of pairwise superposition ('success' / 'zero-overlap' / 'failed') */
-    status: "success" | "zero-overlap" | "failed";
-    /** Superposition RMSD and tranform (if status is 'success') */
-    superposition: (import("molstar/lib/mol-math/linear-algebra/3d/minimize-rmsd").MinimizeRmsd.Result & {
-        nAlignedElements: number;
-    }) | undefined;
+    /** Superposition RMSD, number of aligned residues, and tranform; if superposition was successful */
+    superposition: SuperpositionResult | undefined;
     /** Function that deletes the newly loaded complex structure */
     delete: () => Promise<void>;
-}>;
-/** Superpose mobile structure onto static structure, based on Uniprot residue numbers. */
-export declare function superposeStructuresByMolstarDefault(staticStruct: Structure, mobileStruct: Structure): SuperpositionResult;
+}
+/** Temporary type until `nAlignedElements` gets into `MinimizeRmsd.Result` in core Molstar */
+export interface SuperpositionResult extends MinimizeRmsd.Result {
+    nAlignedElements: number;
+    method: 'uniprot-numbering' | 'sequence-alignment';
+    accession: string;
+}
+/** Load a structure, superpose onto the main structure based on Uniprot residue numbers (or seq alignment if numbers not available),
+ * and optionally apply coloring to show common/additional components.
+ *
+ * **Superposition method:**
+ * Complexes are superposed based on the largest common component (measured the by number of residues) with a UniProt mapping (taken from atom_site mmCIF category).
+ * In case there are no common components with Uniprot mapping, the largest common component with an Rfam mapping is used (taken from `baseMappings` and `otherMappings` parameters).
+ * Residue-residue correspondence is determined by UniProt residue numbers (for UniProt mappings) or by sequence alignment (for Rfam mappings).
+ *
+ * **Coloring - subcomplexes:**
+ * Common components are colored by entity; additional components are gray. Components in the subcomplex are slightly darkened.
+ *
+ * **Coloring - supercomplexes:**
+ * Common components are gray; mapped additional components are colored by entity; unmapped additional components are magenta. Components in the supercomplex are slightly darkened.
+ */
+export declare function loadComplexSuperposition(viewer: PDBeMolstarPlugin, params: LoadComplexSuperpositionParams): Promise<LoadComplexSuperpositionResult>;

package/lib/extensions/complexes/index.js

@@ -3,9 +3,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Coloring = void 0;
 exports.loadComplexSuperposition = loadComplexSuperposition;
-exports.superposeStructuresByMolstarDefault = superposeStructuresByMolstarDefault;
 const tslib_1 = require("tslib");
-const superposition_sifts_mapping_1 = require("molstar/lib/mol-model/structure/structure/util/superposition-sifts-mapping");
 const commands_1 = require("molstar/lib/mol-plugin/commands");
 const sleep_1 = require("molstar/lib/mol-util/sleep");
 const __1 = require("../..");
@@ -13,12 +11,26 @@ const helpers_1 = require("../../helpers");
 const superposition_1 = require("../../superposition");
 const Coloring = tslib_1.__importStar(require("./coloring"));
 const superpose_by_biggest_chain_1 = require("./superpose-by-biggest-chain");
+const superpose_by_sequence_alignment_1 = require("./superpose-by-sequence-alignment");
 exports.Coloring = tslib_1.__importStar(require("./coloring"));
-/** Load a structure, superpose onto the main structure based on Uniprot residue numbers, and optionally apply coloring to show common/additional components. */
+/** Load a structure, superpose onto the main structure based on Uniprot residue numbers (or seq alignment if numbers not available),
+ * and optionally apply coloring to show common/additional components.
+ *
+ * **Superposition method:**
+ * Complexes are superposed based on the largest common component (measured the by number of residues) with a UniProt mapping (taken from atom_site mmCIF category).
+ * In case there are no common components with Uniprot mapping, the largest common component with an Rfam mapping is used (taken from `baseMappings` and `otherMappings` parameters).
+ * Residue-residue correspondence is determined by UniProt residue numbers (for UniProt mappings) or by sequence alignment (for Rfam mappings).
+ *
+ * **Coloring - subcomplexes:**
+ * Common components are colored by entity; additional components are gray. Components in the subcomplex are slightly darkened.
+ *
+ * **Coloring - supercomplexes:**
+ * Common components are gray; mapped additional components are colored by entity; unmapped additional components are magenta. Components in the supercomplex are slightly darkened.
+ */
 function loadComplexSuperposition(viewer, params) {
     return tslib_1.__awaiter(this, void 0, void 0, function* () {
         var _a, _b, _c, _d, _e, _f, _g;
-        const { pdbId, assemblyId, animationDuration = 250, coloring, baseComponents, otherComponents, baseMappings, otherMappings, coreColor, unmappedColor, componentColors, method = 'biggest-matched-chain' } = params;
+        const { pdbId, assemblyId, animationDuration = 250, coloring, baseComponents, otherComponents, baseMappings, otherMappings, coreColor, unmappedColor, componentColors } = params;
         const baseStructId = __1.PDBeMolstarPlugin.MAIN_STRUCTURE_ID;
         const otherStructId = (_a = params.id) !== null && _a !== void 0 ? _a : `${pdbId}_${assemblyId}`;
         // Apply coloring to base structure
@@ -45,12 +57,17 @@ function loadComplexSuperposition(viewer, params) {
         if (!otherStruct)
             throw new Error('Mobile structure not loaded');
         // Superpose other structure on base structure
-        const { status, superposition } = method === 'biggest-matched-chain' ?
-            (0, superpose_by_biggest_chain_1.superposeStructuresByBiggestCommonChain)(baseStruct, otherStruct, baseComponents, otherComponents)
-            : superposeStructuresByMolstarDefault(baseStruct, otherStruct);
+        let superposition = (0, superpose_by_biggest_chain_1.superposeByBiggestCommonChain)(baseStruct, otherStruct, baseComponents, otherComponents);
+        if (!superposition) {
+            console.log(`UniProt-based superposition method failed, trying sequence alignment superposition (RNAs)`);
+            superposition = (0, superpose_by_sequence_alignment_1.superposeBySequenceAlignment)(baseStruct, otherStruct, baseMappings !== null && baseMappings !== void 0 ? baseMappings : {}, otherMappings !== null && otherMappings !== void 0 ? otherMappings : {});
+        }
         if (superposition) {
             yield (0, superposition_1.transform)(viewer.plugin, viewer.getStructure(otherStructId).cell, superposition.bTransform);
         }
+        else {
+            console.log(`Sequence alignment superposition method failed, leaving unsuperposed`);
+        }
         // Apply coloring to other structure
         if (coloring === 'subcomplex') {
             yield Coloring.colorSubcomplex(viewer, { otherStructId, baseComponents: baseComponents, otherComponents: otherComponents, baseMappings, otherMappings, coreColor, componentColors });
@@ -74,50 +91,9 @@ function loadComplexSuperposition(viewer, params) {
         // Reveal new structure
         yield viewer.visual.structureVisibility(otherStructId, true);
         return {
-            /** Structure identifier of the newly loaded complex structure, to refer to this structure later */
             id: otherStructId,
-            /** Status of pairwise superposition ('success' / 'zero-overlap' / 'failed') */
-            status,
-            /** Superposition RMSD and tranform (if status is 'success') */
             superposition,
-            /** Function that deletes the newly loaded complex structure */
             delete: () => viewer.deleteStructure(otherStructId),
         };
     });
 }
-/** Superpose mobile structure onto static structure, based on Uniprot residue numbers. */
-function superposeStructuresByMolstarDefault(staticStruct, mobileStruct) {
-    var _a;
-    const aln = (0, superposition_sifts_mapping_1.alignAndSuperposeWithSIFTSMapping)([staticStruct, mobileStruct], { traceOnly: true });
-    const superposition = (_a = aln.entries.find(e => e.pivot === 0 && e.other === 1)) === null || _a === void 0 ? void 0 : _a.transform;
-    if (superposition) {
-        return { status: 'success', superposition: Object.assign(Object.assign({}, superposition), { nAlignedElements: Number.NaN }) };
-    }
-    else if (aln.zeroOverlapPairs.find(e => e[0] === 0 && e[1] === 1)) {
-        return { status: 'zero-overlap', superposition: undefined };
-    }
-    else {
-        return { status: 'failed', superposition: undefined };
-    }
-}
-/*
-Coloring - subcomplexes:
-- base common -> by entity, lighter
-- base additional -> gray, lighter
-- sub common -> by entity, darker
-- sub additional -> gray, darker (these are all unmapped components, includes antibodies and ligands)
-
--> Colors can be assigned based on base complex and applied to subcomplex
-
-Coloring - supercomplexes:
-- base common -> gray, lighter
-- base additional -> unmapped color, lighter (these are all unmapped components, includes antibodies and ligands)
-- super common -> gray, darker
-- super additional mapped -> by entity, darker
-- super additional unmapped -> unmapped color, darker
-
--> Colors can be assigned based on supercomplex complex, consistency between supercomplexes is probably not necessary
-
--> For both subcomplexes and supercomplexes, colors could be assigned based on UniprotID hash -> database-wide consistency but complexes with similar-color components will occur
-
-*/

package/lib/extensions/complexes/superpose-by-biggest-chain.d.ts

@@ -1,17 +1,15 @@
-import { MinimizeRmsd } from 'molstar/lib/mol-math/linear-algebra/3d/minimize-rmsd';
 import { Structure } from 'molstar/lib/mol-model/structure';
-export type SuperpositionResult = {
-    status: 'success';
-    superposition: MinimizeRmsd.Result & {
-        nAlignedElements: number;
+import { SuperpositionResult } from './index';
+/** Superpose structures based on the largest common component (measured the by number of residues) with a UniProt mapping (taken from atom_site mmCIF category).
+ * Residue-residue correspondence is determined by UniProt residue numbers.
+ * This differs from UniProt-based superposition in core Molstar (`alignAndSuperposeWithSIFTSMapping`) which takes all components (regardless of their spacial arrangement). */
+export declare function superposeByBiggestCommonChain(structA: Structure, structB: Structure, allowedComponentsA: string[] | undefined, allowedComponentsB: string[] | undefined): SuperpositionResult | undefined;
+export interface SortedAccessionsAndUnits<T extends object = object> {
+    accessions: string[];
+    units: {
+        [accession: string]: ({
+            unitId: string;
+            size: number;
+        } & T)[];
     };
-} | {
-    status: 'zero-overlap';
-    superposition: undefined;
-} | {
-    status: 'failed';
-    superposition: undefined;
-};
-/** Status of pairwise superposition (success = superposed, zero-overlap = failed to superpose because the two structures have no matchable elements, failed = failed to superpose for other reasons) */
-export type SuperpositionStatus = SuperpositionResult['status'];
-export declare function superposeStructuresByBiggestCommonChain(structA: Structure, structB: Structure, allowedComponentsA: string[] | undefined, allowedComponentsB: string[] | undefined): SuperpositionResult;
+}

package/lib/extensions/complexes/superpose-by-biggest-chain.js

@@ -1,8 +1,47 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.superposeStructuresByBiggestCommonChain = superposeStructuresByBiggestCommonChain;
+exports.superposeByBiggestCommonChain = superposeByBiggestCommonChain;
 const minimize_rmsd_1 = require("molstar/lib/mol-math/linear-algebra/3d/minimize-rmsd");
 const mmcif_1 = require("molstar/lib/mol-model-formats/structure/mmcif");
+/** Superpose structures based on the largest common component (measured the by number of residues) with a UniProt mapping (taken from atom_site mmCIF category).
+ * Residue-residue correspondence is determined by UniProt residue numbers.
+ * This differs from UniProt-based superposition in core Molstar (`alignAndSuperposeWithSIFTSMapping`) which takes all components (regardless of their spacial arrangement). */
+function superposeByBiggestCommonChain(structA, structB, allowedComponentsA, allowedComponentsB) {
+    const indexA = extractUniprotIndex(structA, allowedComponentsA);
+    const indexB = extractUniprotIndex(structB, allowedComponentsB);
+    const bestMatch = bestUniprotMatch(indexA, indexB);
+    if (!bestMatch) {
+        return undefined;
+    }
+    const unitA = structA.unitMap.get(Number(bestMatch.unitA));
+    const unitB = structB.unitMap.get(Number(bestMatch.unitB));
+    const unitIndexA = indexA[bestMatch.accession][bestMatch.unitA];
+    const unitIndexB = indexB[bestMatch.accession][bestMatch.unitB];
+    const positionsA = minimize_rmsd_1.MinimizeRmsd.Positions.empty(bestMatch.nMatchedElements);
+    const positionsB = minimize_rmsd_1.MinimizeRmsd.Positions.empty(bestMatch.nMatchedElements);
+    let i = 0;
+    for (const unpNum in unitIndexA.atomMap) {
+        const iAtomB = unitIndexB.atomMap[unpNum];
+        if (iAtomB === undefined)
+            continue;
+        const iAtomA = unitIndexA.atomMap[unpNum];
+        positionsA.x[i] = unitA.conformation.coordinates.x[iAtomA];
+        positionsA.y[i] = unitA.conformation.coordinates.y[iAtomA];
+        positionsA.z[i] = unitA.conformation.coordinates.z[iAtomA];
+        positionsB.x[i] = unitB.conformation.coordinates.x[iAtomB];
+        positionsB.y[i] = unitB.conformation.coordinates.y[iAtomB];
+        positionsB.z[i] = unitB.conformation.coordinates.z[iAtomB];
+        i++;
+    }
+    const superposition = minimize_rmsd_1.MinimizeRmsd.compute({ a: positionsA, b: positionsB });
+    if (!isNaN(superposition.rmsd)) {
+        return Object.assign(Object.assign({}, superposition), { nAlignedElements: bestMatch.nMatchedElements, method: 'uniprot-numbering', accession: bestMatch.accession });
+        // TODO remove explicit nAlignedElements, once in core Molstar
+    }
+    else {
+        return undefined;
+    }
+}
 function extractUniprotIndex(structure, allowedAccessions) {
     var _a, _b, _c;
     var _d, _e;
@@ -42,9 +81,29 @@ function extractUniprotIndex(structure, allowedAccessions) {
     }
     return out;
 }
+/** Sort units for each accession by decreasing size and sort accessions by decreasing biggest unit size. */
+function sortAccessionsAndUnits(uniprotIndex) {
+    const unitsByAccession = {};
+    for (const accession in uniprotIndex) {
+        const unitIds = uniprotIndex[accession];
+        const units = [];
+        for (const unitId in unitIds) {
+            const size = Object.keys(unitIds[unitId].atomMap).length;
+            units.push({ unitId, size });
+        }
+        units.sort((a, b) => b.size - a.size);
+        unitsByAccession[accession] = units;
+    }
+    return {
+        /** Accessions sorted by decreasing biggest unit size */
+        accessions: Object.keys(unitsByAccession).sort((a, b) => unitsByAccession[b][0].size - unitsByAccession[a][0].size),
+        /** Units per accession, sorted by decreasing unit size */
+        units: unitsByAccession,
+    };
+}
 function bestUniprotMatch(a, b) {
-    const sortedA = sortAccessionAndChains(a);
-    const sortedB = sortAccessionAndChains(b);
+    const sortedA = sortAccessionsAndUnits(a);
+    const sortedB = sortAccessionsAndUnits(b);
     let bestMatch = undefined;
     let bestScore = 0;
     for (const accession of sortedA.accessions) {
@@ -70,26 +129,6 @@ function bestUniprotMatch(a, b) {
     }
     return bestMatch;
 }
-/** Sort units for each accession by decreasing size and sort accessions by decreasing biggest unit size. */
-function sortAccessionAndChains(uniprotIndex) {
-    const unitsByAccession = {};
-    for (const accession in uniprotIndex) {
-        const unitIds = uniprotIndex[accession];
-        const units = [];
-        for (const unitId in unitIds) {
-            const size = Object.keys(unitIds[unitId].atomMap).length;
-            units.push({ unitId, size });
-        }
-        units.sort((a, b) => b.size - a.size);
-        unitsByAccession[accession] = units;
-    }
-    return {
-        /** Accessions sorted by decreasing biggest unit size */
-        accessions: Object.keys(unitsByAccession).sort((a, b) => unitsByAccession[b][0].size - unitsByAccession[a][0].size),
-        /** Units per accession, sorted by decreasing unit size */
-        units: unitsByAccession,
-    };
-}
 /** Return number of keys common to objects `a` and `b` */
 function objectKeyOverlap(a, b) {
     let overlap = 0;
@@ -100,36 +139,3 @@ function objectKeyOverlap(a, b) {
     }
     return overlap;
 }
-function superposeStructuresByBiggestCommonChain(structA, structB, allowedComponentsA, allowedComponentsB) {
-    const indexA = extractUniprotIndex(structA, allowedComponentsA);
-    const indexB = extractUniprotIndex(structB, allowedComponentsB);
-    const bestMatch = bestUniprotMatch(indexA, indexB);
-    if (!bestMatch) {
-        return { status: 'zero-overlap', superposition: undefined };
-    }
-    const unitA = structA.unitMap.get(Number(bestMatch.unitA));
-    const unitB = structB.unitMap.get(Number(bestMatch.unitB));
-    const unitIndexA = indexA[bestMatch.accession][bestMatch.unitA];
-    const unitIndexB = indexB[bestMatch.accession][bestMatch.unitB];
-    const positionsA = minimize_rmsd_1.MinimizeRmsd.Positions.empty(bestMatch.nMatchedElements);
-    const positionsB = minimize_rmsd_1.MinimizeRmsd.Positions.empty(bestMatch.nMatchedElements);
-    let i = 0;
-    for (const unpNum in unitIndexA.atomMap) {
-        const iAtomB = unitIndexB.atomMap[unpNum];
-        if (iAtomB === undefined)
-            continue;
-        const iAtomA = unitIndexA.atomMap[unpNum];
-        positionsA.x[i] = unitA.conformation.coordinates.x[iAtomA];
-        positionsA.y[i] = unitA.conformation.coordinates.y[iAtomA];
-        positionsA.z[i] = unitA.conformation.coordinates.z[iAtomA];
-        positionsB.x[i] = unitB.conformation.coordinates.x[iAtomB];
-        positionsB.y[i] = unitB.conformation.coordinates.y[iAtomB];
-        positionsB.z[i] = unitB.conformation.coordinates.z[iAtomB];
-        i++;
-    }
-    const superposition = minimize_rmsd_1.MinimizeRmsd.compute({ a: positionsA, b: positionsB });
-    if (isNaN(superposition.rmsd)) {
-        return { status: 'failed', superposition: undefined };
-    }
-    return { status: 'success', superposition: Object.assign(Object.assign({}, superposition), { nAlignedElements: bestMatch.nMatchedElements }) };
-}

package/lib/extensions/complexes/superpose-by-sequence-alignment.d.ts

@@ -0,0 +1,10 @@
+import { Structure } from 'molstar/lib/mol-model/structure';
+import { QueryParam } from '../../helpers';
+import { SuperpositionResult } from './index';
+/** Superpose structures based on the largest common component (measured the by number of residues), components being defined by `mappingsA` and `mappingsB`.
+ * Residue-residue correspondence is determined by sequence alignment. */
+export declare function superposeBySequenceAlignment(structA: Structure, structB: Structure, mappingsA: {
+    [accession: string]: QueryParam[];
+}, mappingsB: {
+    [accession: string]: QueryParam[];
+}): SuperpositionResult | undefined;