Merge branch 'master' into bond-repr

src/apps/structure-info/model.ts

@@ -50,7 +50,7 @@ export function residueLabel(model: Model, rI: number) {
 }
 
 export function printSecStructure(model: Model) {
-    console.log('Secondary Structure\n=============');
+    console.log('\nSecondary Structure\n=============');
     const { residues } = model.atomicHierarchy;
     const { type, key } = model.properties.secondaryStructure;
 
@@ -76,41 +76,32 @@ export function printBonds(structure: Structure) {
         if (!Unit.isAtomic(unit)) continue;
 
         const elements = unit.elements;
-        const { count, offset, neighbor } = unit.bonds;
+        const { a, b } = unit.bonds;
         const { model }  = unit;
 
-        if (!count) continue;
+        if (!a.length) continue;
 
-        for (let j = 0; j < offset.length - 1; ++j) {
-            const start = offset[j];
-            const end = offset[j + 1];
-
-            if (end <= start) continue;
-
-            const aI = elements[j];
-            for (let _bI = start; _bI < end; _bI++) {
-                const bI = elements[neighbor[_bI]];
-                console.log(`${atomLabel(model, aI)} -- ${atomLabel(model, bI)}`);
-            }
+        for (let bI = 0, _bI = a.length; bI < _bI; bI++) {
+            const x = a[bI], y = b[bI];
+            if (x >= y) continue;
+            console.log(`${atomLabel(model, elements[x])} -- ${atomLabel(model, elements[y])}`);
         }
     }
 }
 
 export function printSequence(model: Model) {
-    console.log('Sequence\n=============');
+    console.log('\nSequence\n=============');
     const { byEntityKey } = model.sequence;
     for (const key of Object.keys(byEntityKey)) {
         const seq = byEntityKey[+key];
-        console.log(`${seq.entityId} (${seq.num.value(0)}, ${seq.num.value(seq.num.rowCount - 1)}) (${seq.compId.value(0)}, ${seq.compId.value(seq.compId.rowCount - 1)})`);
-        // for (let i = 0; i < seq.compId.rowCount; i++) {
-        //     console.log(`${seq.entityId} ${seq.num.value(i)} ${seq.compId.value(i)}`);
-        // }
+        console.log(`${seq.entityId} (${seq.sequence.kind} ${seq.num.value(0)} (offset ${seq.sequence.offset}), ${seq.num.value(seq.num.rowCount - 1)}) (${seq.compId.value(0)}, ${seq.compId.value(seq.compId.rowCount - 1)})`);
+        console.log(`${seq.sequence.sequence}`);
     }
     console.log();
 }
 
 export function printUnits(structure: Structure) {
-    console.log('Units\n=============');
+    console.log('\nUnits\n=============');
     const l = Element.Location();
 
     for (const unit of structure.units) {
@@ -140,10 +131,9 @@ export function printUnits(structure: Structure) {
     }
 }
 
-
 export function printIHMModels(model: Model) {
     if (!model.coarseHierarchy.isDefined) return false;
-    console.log('IHM Models\n=============');
+    console.log('\nIHM Models\n=============');
     console.log(Table.formatToString(model.coarseHierarchy.models));
 }
 
@@ -151,10 +141,10 @@ async function run(mmcif: mmCIF_Database) {
     const models = await Model.create({ kind: 'mmCIF', data: mmcif }).run();
     const structure = Structure.ofModel(models[0]);
     printSequence(models[0]);
-    printIHMModels(models[0]);
+    //printIHMModels(models[0]);
     printUnits(structure);
-    // printBonds(structure);
-    printSecStructure(models[0]);
+    //printBonds(structure);
+    //printSecStructure(models[0]);
 }
 
 async function runDL(pdb: string) {

src/mol-data/db/column.ts

@@ -103,6 +103,15 @@ namespace Column {
         return lambdaColumn(spec);
     }
 
+    /** values [min, max] (i.e. include both values) */
+    export function range(min: number, max: number): Column<number> {
+        return ofLambda({
+            value: i => i + min,
+            rowCount: Math.max(max - min + 1, 0),
+            schema: Schema.int
+        });
+    }
+
     export function ofArray<T extends Column.Schema>(spec: Column.ArraySpec<T>): Column<T['T']> {
         return arrayColumn(spec);
     }

src/mol-math/graph.ts

@@ -0,0 +1,7 @@
+/**
+ * Copyright (c) 2018 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author David Sehnal <david.sehnal@gmail.com>
+ */
+
+export * from './graph/int/graph'

src/mol-math/graph/_spec/int-graph.spec.ts

@@ -0,0 +1,36 @@
+/**
+ * Copyright (c) 2017-2018 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author David Sehnal <david.sehnal@gmail.com>
+ */
+
+import { IntGraph } from '../int/graph';
+
+describe('IntGraph', () => {
+    const vc = 3;
+    const xs = [0, 1, 2];
+    const ys = [1, 2, 0];
+    const _prop = [10, 11, 12];
+
+    const builder = new IntGraph.EdgeBuilder(vc, xs, ys);
+    const prop: number[] = new Array(builder.slotCount);
+    for (let i = 0; i < builder.edgeCount; i++) {
+        builder.addNextEdge();
+        builder.assignProperty(prop, _prop[i]);
+    }
+    const graph = builder.createGraph({ prop });
+
+    it('triangle-edgeCount', () => expect(graph.edgeCount).toBe(3));
+    it('triangle-vertexEdgeCounts', () => {
+        expect(graph.getVertexEdgeCount(0)).toBe(2);
+        expect(graph.getVertexEdgeCount(1)).toBe(2);
+        expect(graph.getVertexEdgeCount(2)).toBe(2);
+    });
+
+    it('triangle-propAndEdgeIndex', () => {
+        const prop = graph.prop;
+        expect(prop[graph.getEdgeIndex(0, 1)]).toBe(10);
+        expect(prop[graph.getEdgeIndex(1, 2)]).toBe(11);
+        expect(prop[graph.getEdgeIndex(2, 0)]).toBe(12);
+    });
+});

src/mol-math/graph/graph.ts

@@ -1 +0,0 @@
-// TODO

src/mol-math/graph/int/graph.ts

@@ -0,0 +1,137 @@
+/**
+ * Copyright (c) 2018 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author David Sehnal <david.sehnal@gmail.com>
+ */
+
+/**
+ * Represent a graph using vertex adjacency list.
+ *
+ * Edges of the i-th vertex are stored in the arrays a and b
+ * for indices in the range [offset[i], offset[i+1]).
+ *
+ * Edge properties are indexed same as in the arrays a and b.
+ */
+type IntGraph<EdgeProperties extends object = { }> = {
+    readonly offset: ArrayLike<number>,
+    readonly a: ArrayLike<number>,
+    readonly b: ArrayLike<number>,
+    readonly vertexCount: number,
+    readonly edgeCount: number,
+
+    /**
+     * Get the edge index between i-th and j-th vertex.
+     * -1 if the edge does not exist.
+     *
+     * Because the a and b arrays contains each edge twice,
+     * this always returns the smaller of the indices.
+     */
+    getEdgeIndex(i: number, j: number): number,
+    getVertexEdgeCount(i: number): number
+} & EdgeProperties
+
+namespace IntGraph {
+    class Impl implements IntGraph<any> {
+        readonly vertexCount: number;
+
+        getEdgeIndex(i: number, j: number): number {
+            let a, b;
+            if (i < j) { a = i; b = j; }
+            else { a = j; b = i; }
+            for (let t = this.offset[a], _t = this.offset[a + 1]; t < _t; t++) {
+                if (this.b[t] === b) return t;
+            }
+            return -1;
+        }
+
+        getVertexEdgeCount(i: number): number {
+            return this.offset[i + 1] - this.offset[i];
+        }
+
+        constructor(public offset: ArrayLike<number>, public a: ArrayLike<number>, public b: ArrayLike<number>, public edgeCount: number, props?: any) {
+            this.vertexCount = offset.length - 1;
+            if (props) {
+                for (const p of Object.keys(props)) {
+                    (this as any)[p] = props[p];
+                }
+            }
+        }
+    }
+
+    export function create<EdgeProps extends object = { }>(offset: ArrayLike<number>, a: ArrayLike<number>, b: ArrayLike<number>, edgeCount: number, edgeProps?: EdgeProps): IntGraph<EdgeProps> {
+        return new Impl(offset, a, b, edgeCount, edgeProps) as IntGraph<EdgeProps>;
+    }
+
+    export class EdgeBuilder {
+        private bucketFill: Int32Array;
+        private current = 0;
+        private curA: number = 0;
+        private curB: number = 0;
+
+        offsets: Int32Array;
+        edgeCount: number;
+        /** the size of the A and B arrays */
+        slotCount: number;
+        a: Int32Array;
+        b: Int32Array;
+
+        createGraph<EdgeProps extends object = { }>(edgeProps?: EdgeProps) {
+            return create(this.offsets, this.a, this.b, this.edgeCount, edgeProps);
+        }
+
+        /**
+         * @example
+         *   const property = new Int32Array(builder.slotCount);
+         *   for (let i = 0; i < builder.edgeCount; i++) {
+         *     builder.addNextEdge();
+         *     builder.assignProperty(property, srcProp[i]);
+         *   }
+         * return builder.createGraph({ property });
+         */
+        addNextEdge() {
+            const a = this.xs[this.current], b = this.ys[this.current];
+
+            const oa = this.offsets[a] + this.bucketFill[a];
+            const ob = this.offsets[b] + this.bucketFill[b];
+
+            this.a[oa] = a;
+            this.b[oa] = b;
+            this.bucketFill[a]++;
+
+            this.a[ob] = b;
+            this.b[ob] = a;
+            this.bucketFill[b]++;
+
+            this.current++;
+            this.curA = oa;
+            this.curB = ob;
+        }
+
+        assignProperty<T>(prop: { [i: number]: T }, value: T) {
+            prop[this.curA] = value;
+            prop[this.curB] = value;
+        }
+
+        constructor(public vertexCount: number, public xs: ArrayLike<number>, public ys: ArrayLike<number>) {
+            this.edgeCount = xs.length;
+            this.offsets = new Int32Array(this.vertexCount + 1);
+            this.bucketFill = new Int32Array(this.vertexCount);
+
+            const bucketSizes = new Int32Array(this.vertexCount);
+            for (let i = 0, _i = this.xs.length; i < _i; i++) bucketSizes[this.xs[i]]++;
+            for (let i = 0, _i = this.ys.length; i < _i; i++) bucketSizes[this.ys[i]]++;
+
+            let offset = 0;
+            for (let i = 0; i < this.vertexCount; i++) {
+                this.offsets[i] = offset;
+                offset += bucketSizes[i];
+            }
+            this.offsets[this.vertexCount] = offset;
+            this.slotCount = offset;
+            this.a = new Int32Array(offset);
+            this.b = new Int32Array(offset);
+        }
+    }
+}
+
+export { IntGraph }

src/mol-model/sequence.ts

@@ -0,0 +1,7 @@
+/**
+ * Copyright (c) 2018 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author David Sehnal <david.sehnal@gmail.com>
+ */
+
+export * from './sequence/sequence'

src/mol-model/sequence/TODO

@@ -1,2 +0,0 @@
-- Support for FASTA etc..
-- Mapping/properties for 'structure'

src/mol-model/sequence/constants.ts

@@ -0,0 +1,71 @@
+/**
+ * Copyright (c) 2018 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author David Sehnal <david.sehnal@gmail.com>
+ */
+
+export type AminoAlphabet =
+    | 'H' | 'R' | 'K' | 'I' | 'F' | 'L' | 'W' | 'A' | 'M' | 'P' | 'C' | 'N' | 'V' | 'G' | 'S' | 'Q' | 'Y' | 'D' | 'E' | 'T' | 'U' | 'O'
+    | 'X' /** = Unknown */
+
+export type NuclecicAlphabet =
+    | 'A' | 'C' | 'G' | 'T' | 'U'
+    | 'X' /** = Unknown */
+
+// from NGL
+const ProteinOneLetterCodes: { [name: string]: AminoAlphabet }  = {
+    'HIS': 'H',
+    'ARG': 'R',
+    'LYS': 'K',
+    'ILE': 'I',
+    'PHE': 'F',
+    'LEU': 'L',
+    'TRP': 'W',
+    'ALA': 'A',
+    'MET': 'M',
+    'PRO': 'P',
+    'CYS': 'C',
+    'ASN': 'N',
+    'VAL': 'V',
+    'GLY': 'G',
+    'SER': 'S',
+    'GLN': 'Q',
+    'TYR': 'Y',
+    'ASP': 'D',
+    'GLU': 'E',
+    'THR': 'T',
+
+    'SEC': 'U',  // as per IUPAC definition
+    'PYL': 'O',  // as per IUPAC definition
+}
+
+const DnaOneLetterCodes: { [name: string]: NuclecicAlphabet } = {
+    'DA': 'A',
+    'DC': 'C',
+    'DG': 'G',
+    'DT': 'T',
+    'DU': 'U'
+}
+
+const RnaOneLetterCodes: { [name: string]: NuclecicAlphabet } = {
+    'A': 'A',
+    'C': 'C',
+    'G': 'G',
+    'T': 'T',
+    'U': 'U'
+}
+
+export function getProteinOneLetterCode(residueName: string): AminoAlphabet {
+    const code = ProteinOneLetterCodes[residueName];
+    return code || 'X';
+}
+
+export function getRnaOneLetterCode(residueName: string): NuclecicAlphabet {
+    const code = RnaOneLetterCodes[residueName];
+    return code || 'X';
+}
+
+export function getDnaOneLetterCode(residueName: string): NuclecicAlphabet {
+    const code = DnaOneLetterCodes[residueName];
+    return code || 'X';
+}

src/mol-model/sequence/sequence.ts

@@ -0,0 +1,103 @@
+/**
+ * Copyright (c) 2018 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author David Sehnal <david.sehnal@gmail.com>
+ */
+
+import { AminoAlphabet, NuclecicAlphabet, getProteinOneLetterCode, getRnaOneLetterCode, getDnaOneLetterCode } from './constants';
+import { Column } from 'mol-data/db'
+
+// TODO add mapping support to other sequence spaces, e.g. uniprot
+// TODO sequence alignment (take NGL code as starting point)
+
+type Sequence = Sequence.Protein | Sequence.DNA | Sequence.RNA | Sequence.Generic
+
+namespace Sequence {
+    export const enum Kind {
+        Protein = 'protein',
+        RNA = 'RNA',
+        DNA = 'DNA',
+        Generic = 'generic'
+    }
+
+    export interface Base<K extends Kind, Alphabet extends string> {
+        readonly kind: K,
+        readonly offset: number,
+        readonly sequence: ArrayLike<Alphabet>
+    }
+
+    export interface Protein extends Base<Kind.Protein, AminoAlphabet> { }
+    export interface RNA extends Base<Kind.RNA, NuclecicAlphabet> { }
+    export interface DNA extends Base<Kind.DNA, NuclecicAlphabet> { }
+    export interface Generic extends Base<Kind.Generic, 'X'> { }
+
+    export function create(kind: Kind, sequence: string, offset: number = 0): Sequence {
+        return { kind: kind as any, sequence: sequence as any, offset };
+    }
+
+    export function getSequenceString(seq: Sequence) {
+        return seq.sequence as string;
+    }
+
+    function determineKind(names: Column<string>) {
+        for (let i = 0, _i = Math.min(names.rowCount, 10); i < _i; i++) {
+            const name = names.value(i) || '';
+            if (getProteinOneLetterCode(name) !== 'X') return { kind: Kind.Protein, code: getProteinOneLetterCode };
+            if (getRnaOneLetterCode(name) !== 'X') return { kind: Kind.RNA, code: getRnaOneLetterCode };
+            if (getDnaOneLetterCode(name) !== 'X') return { kind: Kind.DNA, code: getDnaOneLetterCode };
+        }
+        return { kind: Kind.Generic, code: (v: string) => 'X' };
+    }
+
+    export function ofResidueNames(residueName: Column<string>, seqId: Column<number>): Sequence {
+        if (seqId.rowCount === 0) throw new Error('cannot be empty');
+
+        const { kind, code } = determineKind(residueName);
+        return new Impl(kind, residueName, seqId, code) as Sequence;
+    }
+
+    class Impl implements Base<any, any> {
+        private _offset = 0;
+        private _seq: string | undefined = void 0;
+
+        get offset() {
+            if (this._seq !== void 0) return this._offset;
+            this.create();
+            return this._offset;
+        }
+
+        get sequence(): any {
+            if (this._seq !== void 0) return this._seq;
+            this.create();
+            return this._seq;
+        }
+
+        private create() {
+            let maxSeqId = 0, minSeqId = Number.MAX_SAFE_INTEGER;
+            for (let i = 0, _i = this.seqId.rowCount; i < _i; i++) {
+                const id = this.seqId.value(i);
+                if (maxSeqId < id) maxSeqId = id;
+                if (id < minSeqId) minSeqId = id;
+            }
+
+            const count = maxSeqId - minSeqId + 1;
+            const sequenceArray = new Array(maxSeqId + 1);
+            for (let i = 0; i < count; i++) {
+                sequenceArray[i] = 'X';
+            }
+
+            for (let i = 0, _i = this.seqId.rowCount; i < _i; i++) {
+                sequenceArray[this.seqId.value(i) - minSeqId] = this.code(this.residueName.value(i) || '');
+            }
+
+            this._seq = sequenceArray.join('');
+            this._offset = minSeqId - 1;
+        }
+
+        constructor(public kind: Kind, private residueName: Column<string>, private seqId: Column<number>, private code: (name: string) => string) {
+
+        }
+    }
+}
+
+export { Sequence }

src/mol-model/structure/model/formats/mmcif/sequence.ts

@@ -5,10 +5,11 @@
  */
 
 import { mmCIF_Database as mmCIF } from 'mol-io/reader/cif/schema/mmcif'
-import Sequence from '../../properties/sequence'
+import StructureSequence from '../../properties/sequence'
 import { Column } from 'mol-data/db';
 import { AtomicHierarchy } from '../../properties/atomic';
 import { Entities } from '../../properties/common';
+import { Sequence } from '../../../../sequence';
 
 // TODO how to handle microheterogeneity
 //    see http://mmcif.wwpdb.org/dictionaries/mmcif_pdbx_v50.dic/Categories/entity_poly_seq.html
@@ -20,12 +21,12 @@ import { Entities } from '../../properties/common';
 // corresponding ATOM_SITE entries should reflect this
 // heterogeneity.
 
-export function getSequence(cif: mmCIF, entities: Entities, hierarchy: AtomicHierarchy): Sequence {
-    if (!cif.entity_poly_seq._rowCount) return Sequence.fromAtomicHierarchy(entities, hierarchy);
+export function getSequence(cif: mmCIF, entities: Entities, hierarchy: AtomicHierarchy): StructureSequence {
+    if (!cif.entity_poly_seq._rowCount) return StructureSequence.fromAtomicHierarchy(entities, hierarchy);
 
     const { entity_id, num, mon_id } = cif.entity_poly_seq;
 
-    const byEntityKey: Sequence['byEntityKey'] = {};
+    const byEntityKey: StructureSequence['byEntityKey'] = {};
     const count = entity_id.rowCount;
 
     let i = 0;
@@ -35,7 +36,15 @@ export function getSequence(cif: mmCIF, entities: Entities, hierarchy: AtomicHie
         i++;
 
         const id = entity_id.value(start);
-        byEntityKey[entities.getEntityIndex(id)] = { entityId: id, compId: Column.window(mon_id, start, i), num: Column.window(num, start, i)  }
+        const _compId = Column.window(mon_id, start, i);
+        const _num = Column.window(num, start, i);
+
+        byEntityKey[entities.getEntityIndex(id)] = {
+            entityId: id,
+            compId: _compId,
+            num: _num,
+            sequence: Sequence.ofResidueNames(_compId, _num)
+        };
     }
 
     return { byEntityKey };

src/mol-model/structure/model/model.ts

@@ -6,7 +6,7 @@
 
 import UUID from 'mol-util/uuid'
 import Format from './format'
-import Sequence from './properties/sequence'
+import StructureSequence from './properties/sequence'
 import { AtomicHierarchy, AtomicConformation } from './properties/atomic'
 import { ModelSymmetry } from './properties/symmetry'
 import { CoarseHierarchy, CoarseConformation } from './properties/coarse'
@@ -31,7 +31,7 @@ interface Model extends Readonly<{
 
     symmetry: ModelSymmetry,
     entities: Entities,
-    sequence: Sequence,
+    sequence: StructureSequence,
 
     atomicHierarchy: AtomicHierarchy,
     atomicConformation: AtomicConformation,

src/mol-model/structure/model/properties/sequence.ts

@@ -7,59 +7,55 @@
 import { Column } from 'mol-data/db'
 import { AtomicHierarchy } from './atomic/hierarchy';
 import { Entities } from './common';
+import { Sequence } from '../../../sequence';
 
-interface Sequence {
-    readonly byEntityKey: { [key: number]: Sequence.Entity }
+interface StructureSequence {
+    readonly byEntityKey: { [key: number]: StructureSequence.Entity }
 }
 
-// TODO lift to model/sequence/ folder
-// TODO add one letter code sequence string
-// TODO add mapping support to other sequence spaces, e.g. uniprot
-// TODO add sequence kind, e.g. protein, dna, rna (alphabets?)
-// TODO sequence alignment (take NGL code as starting point)
-
-namespace Sequence {
+namespace StructureSequence {
     export interface Entity {
         readonly entityId: string,
-        readonly num: Column<number>
-        // _entity_poly_seq.mon_id
-        readonly compId: Column<string>
+        readonly num: Column<number>,
+        // Corresponds to _entity_poly_seq.mon_id
+        readonly compId: Column<string>,
+        readonly sequence: Sequence
     }
 
-    export function fromAtomicHierarchy(entities: Entities, hierarchy: AtomicHierarchy): Sequence {
-        const { label_entity_id } = hierarchy.chains
+    export function fromAtomicHierarchy(entities: Entities, hierarchy: AtomicHierarchy): StructureSequence {
         const { label_comp_id, label_seq_id } = hierarchy.residues
         const { chainSegments, residueSegments } = hierarchy
 
-        const byEntityKey: Sequence['byEntityKey'] = {};
+        const byEntityKey: StructureSequence['byEntityKey'] = { };
 
-        // TODO get min/max of label_seq_id to handle missing residues at start and in between
-        //   note that this assumes label_seq_id is monotonically increasing
+        for (let cI = 0, _cI = hierarchy.chains._rowCount; cI < _cI; cI++) {
+            const entityKey = hierarchy.entityKey[cI];
+            // Only for polymers, trying to mirror _entity_poly_seq
+            if (byEntityKey[entityKey] !== void 0 || entities.data.type.value(entityKey) !== 'polymer') continue;
 
-        const chainCount = hierarchy.chains._rowCount
-        for (let i = 0; i < chainCount; ++i) {
-            const entityId = label_entity_id.value(i)
-            const entityIndex = entities.getEntityIndex(entityId)
-            // TODO only for polymers, mirroring _entity_poly_seq, ok???
-            if (entities.data.type.value(i) !== 'polymer') continue
+            let start = cI;
+            cI++;
+            while (cI < _cI && entityKey === hierarchy.entityKey[cI] && entities.data.type.value(entityKey) !== 'polymer') {
+                cI++;
+            }
+            cI--;
 
-            const entityKey = hierarchy.entityKey[entityIndex]
-            if (byEntityKey[entityKey] !== undefined) continue
+            const rStart = residueSegments.segmentMap[chainSegments.segments[start]];
+            const rEnd = residueSegments.segmentMap[chainSegments.segments[cI + 1]];
 
-            const start = residueSegments.segmentMap[chainSegments.segments[i]]
-            let end = residueSegments.segmentMap[chainSegments.segments[i + 1]]
-            // TODO better way to handle end???
-            if (end === undefined) end = hierarchy.residues._rowCount
+            const compId = Column.window(label_comp_id, rStart, rEnd);
+            const num = Column.window(label_seq_id, rStart, rEnd);
 
             byEntityKey[entityKey] = {
-                entityId,
-                compId: Column.window(label_comp_id, start, end),
-                num: Column.window(label_seq_id, start, end)
-            }
+                entityId: entities.data.id.value(entityKey),
+                compId,
+                num,
+                sequence: Sequence.ofResidueNames(compId, num)
+            };
         }
 
         return { byEntityKey }
     }
 }
 
-export default Sequence
+export default StructureSequence

src/mol-model/structure/structure/unit/bonds/intra-compute.ts

@@ -8,6 +8,7 @@ import { BondType, ElementSymbol } from '../../../model/types'
 import { IntraUnitBonds } from './intra-data'
 import { StructConn, ComponentBondInfo } from '../../../model/formats/mmcif/bonds'
 import Unit from '../../unit'
+import { IntGraph } from 'mol-math/graph';
 
 export interface BondComputationParameters {
     maxHbondLength: number,
@@ -62,48 +63,17 @@ function isHydrogen(i: number) {
     return i === H_ID;
 }
 
-function computePerAtomBonds(atomA: number[], atomB: number[], _order: number[], _flags: number[], atomCount: number) {
-    const bucketSizes = new Int32Array(atomCount);
-    const bucketOffsets = new Int32Array(atomCount + 1) as any as number[];
-    const bucketFill = new Int32Array(atomCount);
-
-    for (const i of atomA) bucketSizes[i]++;
-    for (const i of atomB) bucketSizes[i]++;
-
-    let offset = 0;
-    for (let i = 0; i < atomCount; i++) {
-        bucketOffsets[i] = offset;
-        offset += bucketSizes[i];
+function getGraph(atomA: number[], atomB: number[], _order: number[], _flags: number[], atomCount: number): IntraUnitBonds {
+    const builder = new IntGraph.EdgeBuilder(atomCount, atomA, atomB);
+    const flags = new Uint16Array(builder.slotCount);
+    const order = new Int8Array(builder.slotCount);
+    for (let i = 0, _i = builder.edgeCount; i < _i; i++) {
+        builder.addNextEdge();
+        builder.assignProperty(flags, _flags[i]);
+        builder.assignProperty(order, _order[i]);
     }
-    bucketOffsets[atomCount] = offset;
-
-    const neighbor = new Int32Array(offset) as any as number[];
-    const flags = new Uint16Array(offset) as any as number[];
-    const order = new Int8Array(offset) as any as number[];
-
-    for (let i = 0, _i = atomA.length; i < _i; i++) {
-        const a = atomA[i], b = atomB[i], f = _flags[i], o = _order[i];
-
-        const oa = bucketOffsets[a] + bucketFill[a];
-        const ob = bucketOffsets[b] + bucketFill[b];
 
-        neighbor[oa] = b;
-        flags[oa] = f;
-        order[oa] = o;
-        bucketFill[a]++;
-
-        neighbor[ob] = a;
-        flags[ob] = f;
-        order[ob] = o;
-        bucketFill[b]++;
-    }
-
-    return {
-        offsets: bucketOffsets,
-        neighbor,
-        flags,
-        order
-    };
+    return builder.createGraph({ flags, order });
 }
 
 function _computeBonds(unit: Unit.Atomic, params: BondComputationParameters): IntraUnitBonds {
@@ -231,15 +201,7 @@ function _computeBonds(unit: Unit.Atomic, params: BondComputationParameters): In
         }
     }
 
-    const bonds = computePerAtomBonds(atomA, atomB, order, flags, atomCount);
-
-    return {
-        offset: bonds.offsets,
-        neighbor: bonds.neighbor,
-        flags: bonds.flags,
-        order: bonds.order,
-        count: atomA.length
-    };
+    return getGraph(atomA, atomB, order, flags, atomCount);
 }
 
 function computeIntraUnitBonds(unit: Unit.Atomic, params?: Partial<BondComputationParameters>) {

src/mol-model/structure/structure/unit/bonds/intra-data.ts

@@ -6,24 +6,13 @@
  */
 
 import { BondType } from '../../../model/types'
+import { IntGraph } from 'mol-math/graph';
 
-interface IntraUnitBonds {
-    /**
-     * Where bonds for atom A start and end.
-     * Start offset at idx, end at idx + 1
-     */
-    offset: ArrayLike<number>,
-    neighbor: ArrayLike<number>,
-
-    order: ArrayLike<number>,
-    flags: ArrayLike<BondType.Flag>,
-
-    count: number
-}
+type IntraUnitBonds = IntGraph<{ readonly order: ArrayLike<number>, readonly flags: ArrayLike<BondType.Flag> }>
 
 namespace IntraUnitBonds {
     export function createEmpty(): IntraUnitBonds {
-        return { offset: [], neighbor: [], order: [], flags: [], count: 0 }
+        return IntGraph.create([], [], [], 0, { flags: [], order: [] });
     }
     export function isCovalent(flags: number) {
         return (flags & BondType.Flag.Covalent) !== 0;