structure data model

src/mol-base/collections/_spec/segmentation.spec.ts

@@ -7,17 +7,26 @@
 import OrderedSet from '../integer/ordered-set'
 import Interval from '../integer/interval'
 import Segmentation from '../integer/segmentation'
-import SortedArray from '../integer/sorted-array'
 
 describe('segments', () => {
     const data = OrderedSet.ofSortedArray([4, 9, 10, 11, 14, 15, 16]);
-    const segs = Segmentation.create(SortedArray.ofSortedArray([0, 4, 10, 12, 13, 15, 25]), [])
+    const segs = Segmentation.create([0, 4, 10, 12, 13, 15, 25]);
+
+    it('size', () => expect(Segmentation.count(segs)).toBe(6));
 
     it('project', () => {
         const p = Segmentation.projectValue(segs, data, 4);
         expect(p).toBe(Interval.ofBounds(0, 2))
     });
 
+    it('map', () => {
+        const segs = Segmentation.create([1, 2, 3]);
+        expect(segs.segmentMap).toEqual(new Int32Array([0, 1]));
+        expect(segs.offset).toEqual(1);
+        expect(Segmentation.getSegment(segs, 1)).toBe(0);
+        expect(Segmentation.getSegment(segs, 2)).toBe(1);
+    })
+
     it('iteration', () => {
         const it = Segmentation.segments(segs, data);
 

src/mol-base/collections/_spec/sorted-array.spec.ts

@@ -37,7 +37,7 @@ describe('sortedArray', () => {
     test('getAt', SortedArray.getAt(a2468, 1), 4);
 
     test('areEqual', SortedArray.areEqual(a2468, a2468), true);
-    test('areEqual1', SortedArray.areEqual(a2468, SortedArray.create([4, 2, 8, 6])), true);
+    test('areEqual1', SortedArray.areEqual(a2468, SortedArray.ofUnsortedArray([4, 2, 8, 6])), true);
     test('areEqual2', SortedArray.areEqual(a1234, a2468), false);
 
     test('predIndex1', SortedArray.findPredecessorIndex(a1234, 5), 4);

src/mol-base/collections/column.ts

@@ -35,6 +35,7 @@ export interface Column<T> {
 }
 
 export function UndefinedColumn<T extends ColumnType>(rowCount: number, type: T): Column<T['@type']> {
+    const v = type.isString ? '' : 0;
     const value: Column<T['@type']>['value'] = type.isString ? row => '' : row => 0;
     return {
         '@type': type,
@@ -44,7 +45,7 @@ export function UndefinedColumn<T extends ColumnType>(rowCount: number, type: T)
         isValueDefined: row => false,
         toArray: params => {
             const { array } = createArray(rowCount, params);
-            for (let i = 0, _i = array.length; i < _i; i++) array[i] = value(0)
+            for (let i = 0, _i = array.length; i < _i; i++) array[i] = v;
             return array;
         },
         stringEquals: (row, value) => !value,
@@ -52,6 +53,28 @@ export function UndefinedColumn<T extends ColumnType>(rowCount: number, type: T)
     }
 }
 
+export function SingleValueColumn<T extends ColumnType>(v: T['@type'], rowCount: number, type: T): Column<T['@type']> {
+    const value: Column<T['@type']>['value'] = row => v;
+    return {
+        '@type': type,
+        isDefined: true,
+        rowCount,
+        value,
+        isValueDefined: row => false,
+        toArray: params => {
+            const { array } = createArray(rowCount, params);
+            for (let i = 0, _i = array.length; i < _i; i++) array[i] = v;
+            return array;
+        },
+        stringEquals: type.isString
+            ? (row, value) => value === v
+            : type.isScalar
+            ? (row, value) => +value === v
+            : (row, value) => false,
+        areValuesEqual: (rowA, rowB) => true
+    }
+}
+
 export interface ArrayColumnSpec<T extends ColumnType> {
     array: ArrayLike<T['@type']>,
     type: T,

src/mol-base/collections/integer/impl/segmentation.ts

@@ -10,15 +10,22 @@ import Interval from '../interval'
 import SortedArray from '../sorted-array'
 import Segs from '../segmentation'
 
-type Segmentation = { segments: OrderedSet, segmentIndex: ArrayLike<number> }
+type Segmentation = { segments: SortedArray, segmentMap: ArrayLike<number>, offset: number, count: number }
 
-export function create(segments: SortedArray, segmentIndex: ArrayLike<number>): Segmentation {
-    return { segments, segmentIndex };
+export function create(values: ArrayLike<number>): Segmentation {
+    const segments = SortedArray.ofSortedArray(values);
+    const min = SortedArray.min(segments), max = SortedArray.max(segments);
+    const segmentMap = new Int32Array(max - min);
+    for (let i = 0, _i = values.length - 1; i < _i; i++) {
+        for (let j = values[i] - min, _j = values[i + 1] - min; j < _j; j++) {
+            segmentMap[j] = i;
+        }
+    }
+    return { segments, segmentMap, offset: min, count: values.length - 1 };
 }
 
-export function getSegment({ segmentIndex }: Segmentation, value: number) {
-    return segmentIndex[value];
-}
+export function count({ count }: Segmentation) { return count; }
+export function getSegment({ segmentMap, offset }: Segmentation, value: number) { return segmentMap[value - offset]; }
 
 export function projectValue({ segments }: Segmentation, set: OrderedSet, value: number): Interval {
     const last = OrderedSet.max(segments);

src/mol-base/collections/integer/segmentation.ts

@@ -7,20 +7,25 @@
 import Iterator from '../iterator'
 import Interval from './interval'
 import OrderedSet from './ordered-set'
-import SortedArray from './sorted-array'
 import * as Impl from './impl/segmentation'
 
 namespace Segmentation {
     export interface Segment { index: number, start: number, end: number }
 
-    export const create: (segs: SortedArray, segIndex: ArrayLike<number>) => Segmentation = Impl.create as any;
+    export const create: (segs: ArrayLike<number>) => Segmentation = Impl.create as any;
 
+    export const count: (segs: Segmentation) => number = Impl.count as any;
     export const getSegment: (segs: Segmentation, value: number) => number = Impl.getSegment as any;
     export const projectValue: (segs: Segmentation, set: OrderedSet, value: number) => Interval = Impl.projectValue as any;
 
     export const segments: (segs: Segmentation, set: OrderedSet, range?: Interval) => Iterator<Segment> = Impl.segments as any;
 }
 
-interface Segmentation { '@type': 'segmentation' }
+interface Segmentation {
+    '@type': 'segmentation',
+    readonly segmentMap: ArrayLike<number>,
+    readonly offset: number,
+    readonly count: number
+}
 
 export default Segmentation

src/mol-base/collections/integer/sorted-array.ts

@@ -8,9 +8,7 @@ import * as Impl from './impl/sorted-array'
 import Interval from './interval'
 
 namespace SortedArray {
-    /** Create interval [min, max] */
-    export const create: (xs: ArrayLike<number>) => SortedArray = Impl.ofUnsortedArray as any;
-    /** Create interval [min, max) */
+    export const ofUnsortedArray: (xs: ArrayLike<number>) => SortedArray = Impl.ofUnsortedArray as any;
     export const ofSortedArray: (xs: ArrayLike<number>) => SortedArray = Impl.ofSortedArray as any;
     export const is: (v: any) => v is Interval = Impl.is as any;
 

src/mol-data/_spec/atom-set.spec.ts

@@ -4,15 +4,15 @@
  * @author David Sehnal <david.sehnal@gmail.com>
  */
 
-import IntTuple from '../../mol-base/collections/integer/tuple'
 import OrderedSet from '../../mol-base/collections/integer/ordered-set'
 import AtomSet from '../atom-set'
+import Atom from '../atom'
 
 describe('atom set', () => {
-    const p = (i: number, j: number) => IntTuple.create(i, j);
+    const p = (i: number, j: number) => Atom.create(i, j);
 
-    function setToPairs(set: AtomSet): ArrayLike<IntTuple> {
-        const ret: IntTuple[] = [];
+    function setToPairs(set: AtomSet): ArrayLike<Atom> {
+        const ret: Atom[] = [];
         const it = AtomSet.atoms(set);
         while (it.hasNext) {
             ret[ret.length] = it.move();
@@ -23,9 +23,9 @@ describe('atom set', () => {
     it('singleton pair', () => {
         const set = AtomSet.create(p(10, 11));
         expect(setToPairs(set)).toEqual([p(10, 11)]);
-        expect(AtomSet.hasAtom(set, p(10, 11))).toBe(true);
-        expect(AtomSet.hasAtom(set, p(11, 11))).toBe(false);
-        expect(AtomSet.getAtomAt(set, 0)).toBe(p(10, 11));
+        expect(AtomSet.atomHas(set, p(10, 11))).toBe(true);
+        expect(AtomSet.atomHas(set, p(11, 11))).toBe(false);
+        expect(AtomSet.atomGetAt(set, 0)).toBe(p(10, 11));
         expect(AtomSet.atomCount(set)).toBe(1);
     });
 
@@ -42,16 +42,16 @@ describe('atom set', () => {
         const ret = [p(1, 4), p(1, 6), p(1, 7), p(3, 0), p(3, 1)];
         expect(AtomSet.atomCount(set)).toBe(ret.length);
         expect(setToPairs(set)).toEqual([p(1, 4), p(1, 6), p(1, 7), p(3, 0), p(3, 1)]);
-        expect(AtomSet.hasAtom(set, p(10, 11))).toBe(false);
-        expect(AtomSet.hasAtom(set, p(3, 0))).toBe(true);
-        expect(AtomSet.hasAtom(set, p(1, 7))).toBe(true);
+        expect(AtomSet.atomHas(set, p(10, 11))).toBe(false);
+        expect(AtomSet.atomHas(set, p(3, 0))).toBe(true);
+        expect(AtomSet.atomHas(set, p(1, 7))).toBe(true);
         for (let i = 0; i < AtomSet.atomCount(set); i++) {
-            expect(IntTuple.areEqual(AtomSet.getAtomAt(set, i), ret[i])).toBe(true);
+            expect(Atom.areEqual(AtomSet.atomGetAt(set, i), ret[i])).toBe(true);
         }
     });
 
     it('element at / index of', () => {
-        const control: IntTuple[] = [];
+        const control: Atom[] = [];
         const sets = Object.create(null);
         for (let i = 1; i < 10; i++) {
             const set = [];
@@ -63,11 +63,11 @@ describe('atom set', () => {
         }
         const ms = AtomSet.create(sets);
         for (let i = 0; i < control.length; i++) {
-            expect(IntTuple.areEqual(AtomSet.getAtomAt(ms, i), control[i])).toBe(true);
+            expect(Atom.areEqual(AtomSet.atomGetAt(ms, i), control[i])).toBe(true);
         }
 
         for (let i = 0; i < control.length; i++) {
-            expect(AtomSet.indexOfAtom(ms, control[i])).toBe(i);
+            expect(AtomSet.atomIndexOf(ms, control[i])).toBe(i);
         }
     });
 
@@ -129,6 +129,7 @@ describe('atom set', () => {
         const b = AtomSet.create([p(10, 3), p(0, 1), p(0, 6), p(4, 2)]);
         const c = AtomSet.create([p(1, 3)]);
         const d = AtomSet.create([p(2, 3)]);
+        const e = AtomSet.create([p(0, 2)]);
         expect(setToPairs(AtomSet.subtract(a, a))).toEqual([]);
         expect(setToPairs(AtomSet.subtract(a, a1))).toEqual([]);
         expect(setToPairs(AtomSet.subtract(a, b))).toEqual([p(0, 2), p(1, 3)]);
@@ -136,6 +137,7 @@ describe('atom set', () => {
         expect(setToPairs(AtomSet.subtract(a, c))).toEqual([p(0, 1), p(0, 2), p(0, 6)]);
         expect(setToPairs(AtomSet.subtract(c, a))).toEqual([]);
         expect(setToPairs(AtomSet.subtract(d, a))).toEqual([p(2, 3)]);
+        expect(setToPairs(AtomSet.subtract(a, e))).toEqual([p(0, 1), p(0, 6), p(1, 3)]);
     });
 
     it('union', () => {

src/mol-data/atom-set.ts

@@ -6,7 +6,7 @@
 
 import OrderedSet from '../mol-base/collections/integer/ordered-set'
 import Iterator from '../mol-base/collections/iterator'
-import Tuple from '../mol-base/collections/integer/tuple'
+import Atom from './atom'
 import * as Base from './atom-set/base'
 import createBuilder from './atom-set/builder'
 
@@ -14,22 +14,21 @@ import createBuilder from './atom-set/builder'
 namespace AtomSet {
     export const Empty: AtomSet = Base.Empty as any;
 
-    export const create: (data: Tuple | ArrayLike<Tuple> | Tuple | { [id: number]: OrderedSet }) => AtomSet = Base.create as any;
+    export const create: (data: Atom | ArrayLike<Atom> | { [unitId: number]: OrderedSet }) => AtomSet = Base.create as any;
 
-    export const units: (set: AtomSet) => OrderedSet = Base.getKeys as any;
     export const unitCount: (set: AtomSet) => number = Base.keyCount as any;
-    export const hasUnit: (set: AtomSet, id: number) => boolean = Base.hasKey as any;
-    export const getUnitId: (set: AtomSet, i: number) => number = Base.getKey as any;
+    export const unitIds: (set: AtomSet) => OrderedSet = Base.getKeys as any;
+    export const unitHas: (set: AtomSet, id: number) => boolean = Base.hasKey as any;
+    export const unitGetId: (set: AtomSet, i: number) => number = Base.getKey as any;
 
-    export const getByKey: (set: AtomSet, key: number) => OrderedSet = Base.getByKey as any;
-    export const getByIndex: (set: AtomSet, i: number) => OrderedSet = Base.getByIndex as any;
-
-    export const hasAtom: (set: AtomSet, x: Tuple) => boolean = Base.hasTuple as any;
-    export const indexOfAtom: (set: AtomSet, x: Tuple) => number = Base.indexOf as any;
-    export const getAtomAt: (set: AtomSet, i: number) => Tuple = Base.getAt as any;
-    export const atoms: (set: AtomSet) => Iterator<Tuple> = Base.values as any;
+    export const unitGetById: (set: AtomSet, key: number) => OrderedSet = Base.getByKey as any;
+    export const unitGetByIndex: (set: AtomSet, i: number) => OrderedSet = Base.getByIndex as any;
 
     export const atomCount: (set: AtomSet) => number = Base.size as any;
+    export const atomHas: (set: AtomSet, x: Atom) => boolean = Base.hasAtom as any;
+    export const atomIndexOf: (set: AtomSet, x: Atom) => number = Base.indexOf as any;
+    export const atomGetAt: (set: AtomSet, i: number) => Atom = Base.getAt as any;
+    export const atoms: (set: AtomSet) => Iterator<Atom> = Base.values as any;
 
     export const hashCode: (set: AtomSet) => number = Base.hashCode as any;
     export const areEqual: (a: AtomSet, b: AtomSet) => boolean = Base.areEqual as any;

src/mol-data/atom-set/base.ts

@@ -6,21 +6,21 @@
 
 import OrderedSet from '../../mol-base/collections/integer/ordered-set'
 import Iterator from '../../mol-base/collections/iterator'
-import Tuple from '../../mol-base/collections/integer/tuple'
 import Interval from '../../mol-base/collections/integer/interval'
 import { sortArray } from '../../mol-base/collections/sort'
 import { hash1 } from '../../mol-base/collections/hash-functions'
+import Atom from '../atom'
 
 /** Long and painful implementation starts here */
 
 export interface AtomSetElements { [id: number]: OrderedSet, offsets: number[], hashCode: number, keys: OrderedSet }
-export type AtomSetImpl = Tuple | AtomSetElements
+export type AtomSetImpl = Atom | AtomSetElements
 
 export const Empty: AtomSetImpl = { offsets: [0], hashCode: 0, keys: OrderedSet.Empty };
 
-export function create(data: Tuple | ArrayLike<Tuple> | { [id: number]: OrderedSet }): AtomSetImpl {
-    if (typeof data === 'number' || Tuple.is(data)) return data;
-    if (isArrayLike(data)) return ofTuples(data);
+export function create(data: Atom | ArrayLike<Atom> | { [id: number]: OrderedSet }): AtomSetImpl {
+    if (typeof data === 'number' || Atom.is(data)) return data;
+    if (isArrayLike(data)) return ofAtoms(data);
     return ofObject(data as { [id: number]: OrderedSet });
 }
 
@@ -39,42 +39,42 @@ export function keyCount(set: AtomSetImpl): number {
 }
 
 export function hasKey(set: AtomSetImpl, key: number): boolean {
-    if (typeof set === 'number') return Tuple.fst(set) === key;
+    if (typeof set === 'number') return Atom.unit(set) === key;
     return OrderedSet.has((set as AtomSetElements).keys, key);
 }
 
 export function getKey(set: AtomSetImpl, index: number): number {
-    if (typeof set === 'number') return Tuple.fst(set);
+    if (typeof set === 'number') return Atom.unit(set);
     return OrderedSet.getAt((set as AtomSetElements).keys, index);
 }
 
-export function hasTuple(set: AtomSetImpl, t: Tuple): boolean {
-    if (typeof set === 'number') return Tuple.areEqual(t, set);
-    const unit = Tuple.fst(t);
+export function hasAtom(set: AtomSetImpl, t: Atom): boolean {
+    if (typeof set === 'number') return Atom.areEqual(t, set);
+    const unit = Atom.unit(t);
     return OrderedSet.has((set as AtomSetElements).keys, unit)
-        ? OrderedSet.has((set as AtomSetElements)[unit], Tuple.snd(t)) : false;
+        ? OrderedSet.has((set as AtomSetElements)[unit], Atom.index(t)) : false;
 }
 
 export function getByKey(set: AtomSetImpl, key: number): OrderedSet {
     if (typeof set === 'number') {
-        return Tuple.fst(set) === key ? OrderedSet.ofSingleton(Tuple.snd(set)) : OrderedSet.Empty;
+        return Atom.unit(set) === key ? OrderedSet.ofSingleton(Atom.index(set)) : OrderedSet.Empty;
     }
     return OrderedSet.has((set as AtomSetElements).keys, key) ? (set as AtomSetElements)[key] : OrderedSet.Empty;
 }
 
 export function getByIndex(set: AtomSetImpl, index: number): OrderedSet {
-    if (typeof set === 'number') return index === 0 ? OrderedSet.ofSingleton(Tuple.snd(set)) : OrderedSet.Empty;
+    if (typeof set === 'number') return index === 0 ? OrderedSet.ofSingleton(Atom.index(set)) : OrderedSet.Empty;
     const key = OrderedSet.getAt((set as AtomSetElements).keys, index);
     return (set as AtomSetElements)[key] || OrderedSet.Empty;
 }
 
-export function getAt(set: AtomSetImpl, i: number): Tuple {
+export function getAt(set: AtomSetImpl, i: number): Atom {
     if (typeof set === 'number') return set;
     return getAtE(set as AtomSetElements, i);
 }
 
-export function indexOf(set: AtomSetImpl, t: Tuple) {
-    if (typeof set === 'number') return Tuple.areEqual(set, t) ? 0 : -1;
+export function indexOf(set: AtomSetImpl, t: Atom) {
+    if (typeof set === 'number') return Atom.areEqual(set, t) ? 0 : -1;
     return indexOfE(set as AtomSetElements, t);
 }
 
@@ -85,14 +85,14 @@ export function size(set: AtomSetImpl) {
 }
 
 export function hashCode(set: AtomSetImpl) {
-    if (typeof set === 'number') return Tuple.hashCode(set);
+    if (typeof set === 'number') return Atom.hashCode(set);
     if ((set as AtomSetElements).hashCode !== -1) return (set as AtomSetElements).hashCode;
     return computeHash((set as AtomSetElements));
 }
 
 export function areEqual(a: AtomSetImpl, b: AtomSetImpl) {
     if (typeof a === 'number') {
-        if (typeof b === 'number') return Tuple.areEqual(a, b);
+        if (typeof b === 'number') return Atom.areEqual(a, b);
         return false;
     }
     if (typeof b === 'number') return false;
@@ -101,7 +101,7 @@ export function areEqual(a: AtomSetImpl, b: AtomSetImpl) {
 
 export function areIntersecting(a: AtomSetImpl, b: AtomSetImpl) {
     if (typeof a === 'number') {
-        if (typeof b === 'number') return Tuple.areEqual(a, b);
+        if (typeof b === 'number') return Atom.areEqual(a, b);
         return areIntersectingNE(a, b as AtomSetElements);
     }
     if (typeof b === 'number') return areIntersectingNE(b, a as AtomSetElements);
@@ -110,7 +110,7 @@ export function areIntersecting(a: AtomSetImpl, b: AtomSetImpl) {
 
 export function intersect(a: AtomSetImpl, b: AtomSetImpl) {
     if (typeof a === 'number') {
-        if (typeof b === 'number') return Tuple.areEqual(a, b) ? a : Empty;
+        if (typeof b === 'number') return Atom.areEqual(a, b) ? a : Empty;
         return intersectNE(a, b as AtomSetElements);
     }
     if (typeof b === 'number') return intersectNE(b, a as AtomSetElements);
@@ -119,7 +119,7 @@ export function intersect(a: AtomSetImpl, b: AtomSetImpl) {
 
 export function subtract(a: AtomSetImpl, b: AtomSetImpl) {
     if (typeof a === 'number') {
-        if (typeof b === 'number') return Tuple.areEqual(a, b) ? Empty : a;
+        if (typeof b === 'number') return Atom.areEqual(a, b) ? Empty : a;
         return subtractNE(a, b as AtomSetElements);
     }
     if (typeof b === 'number') return subtractEN(a as AtomSetElements, b);
@@ -134,7 +134,7 @@ export function unionMany(sets: ArrayLike<AtomSetImpl>) {
     return findUnion(sets);
 }
 
-class ElementsIterator implements Iterator<Tuple> {
+class ElementsIterator implements Iterator<Atom> {
     private unit: number = 0;
     private keyCount: number;
     private setIndex = -1;
@@ -145,8 +145,8 @@ class ElementsIterator implements Iterator<Tuple> {
     hasNext: boolean = false;
 
     move() {
-        if (!this.hasNext) return Tuple.Zero;
-        const ret = Tuple.create(this.unit, OrderedSet.getAt(this.currentSet, this.currentIndex++));
+        if (!this.hasNext) return Atom.Zero;
+        const ret = Atom.create(this.unit, OrderedSet.getAt(this.currentSet, this.currentIndex++));
         if (this.currentIndex >= this.currentSize) this.advance();
         return ret;
     }
@@ -170,12 +170,12 @@ class ElementsIterator implements Iterator<Tuple> {
     }
 }
 
-export function values(set: AtomSetImpl): Iterator<Tuple> {
-    if (typeof set === 'number') return Iterator.Value(set as Tuple);
+export function values(set: AtomSetImpl): Iterator<Atom> {
+    if (typeof set === 'number') return Iterator.Value(set as Atom);
     return new ElementsIterator(set as AtomSetElements);
 }
 
-function isArrayLike(x: any): x is ArrayLike<Tuple> {
+function isArrayLike(x: any): x is ArrayLike<Atom> {
     return x && (typeof x.length === 'number' && (x instanceof Array || !!x.buffer));
 }
 
@@ -188,7 +188,7 @@ function ofObject(data: { [id: number]: OrderedSet }) {
     if (!keys.length) return Empty;
     if (keys.length === 1) {
         const set = data[keys[0]];
-        if (OrderedSet.size(set) === 1) return Tuple.create(keys[0], OrderedSet.getAt(set, 0));
+        if (OrderedSet.size(set) === 1) return Atom.create(keys[0], OrderedSet.getAt(set, 0));
     }
     return ofObject1(keys, data);
 }
@@ -197,7 +197,7 @@ function ofObject1(keys: number[], data: { [id: number]: OrderedSet }) {
     if (keys.length === 1) {
         const k = keys[0];
         const set = data[k];
-        if (OrderedSet.size(set) === 1) return Tuple.create(k, OrderedSet.getAt(set, 0));
+        if (OrderedSet.size(set) === 1) return Atom.create(k, OrderedSet.getAt(set, 0));
     }
     sortArray(keys);
     return _createObjectOrdered(OrderedSet.ofSortedArray(keys), data);
@@ -207,7 +207,7 @@ function ofObjectOrdered(keys: OrderedSet, data: { [id: number]: OrderedSet }) {
     if (OrderedSet.size(keys) === 1) {
         const k = OrderedSet.getAt(keys, 0);
         const set = data[k];
-        if (OrderedSet.size(set) === 1) return Tuple.create(k, OrderedSet.getAt(set, 0));
+        if (OrderedSet.size(set) === 1) return Atom.create(k, OrderedSet.getAt(set, 0));
     }
     return _createObjectOrdered(keys, data);
 }
@@ -251,12 +251,12 @@ function normalizeArray(xs: number[]) {
     return xs;
 }
 
-function ofTuples(xs: ArrayLike<Tuple>) {
+function ofAtoms(xs: ArrayLike<Atom>) {
     if (xs.length === 0) return Empty;
     const sets: { [key: number]: number[] } = Object.create(null);
     for (let i = 0, _i = xs.length; i < _i; i++) {
         const x = xs[i];
-        const u = Tuple.fst(x), v = Tuple.snd(x);
+        const u = Atom.unit(x), v = Atom.index(x);
         const set = sets[u];
         if (set) set[set.length] = v;
         else sets[u] = [v];
@@ -286,21 +286,21 @@ function getOffsetIndex(xs: ArrayLike<number>, value: number) {
     return value < xs[min] ? min - 1 : min;
 }
 
-function getAtE(set: AtomSetElements, i: number): Tuple {
+function getAtE(set: AtomSetElements, i: number): Atom {
     const { offsets, keys } = set;
     const o = getOffsetIndex(offsets, i);
     if (o >= offsets.length - 1) return 0 as any;
     const k = OrderedSet.getAt(keys, o);
     const e = OrderedSet.getAt(set[k], i - offsets[o]);
-    return Tuple.create(k, e);
+    return Atom.create(k, e);
 }
 
-function indexOfE(set: AtomSetElements, t: Tuple) {
+function indexOfE(set: AtomSetElements, t: Atom) {
     const { keys } = set;
-    const u = Tuple.fst(t);
+    const u = Atom.unit(t);
     const setIdx = OrderedSet.indexOf(keys, u);
     if (setIdx < 0) return -1;
-    const o = OrderedSet.indexOf(set[u], Tuple.snd(t));
+    const o = OrderedSet.indexOf(set[u], Atom.index(t));
     if (o < 0) return -1;
     return set.offsets[setIdx] + o;
 }
@@ -332,9 +332,9 @@ function areEqualEE(a: AtomSetElements, b: AtomSetElements) {
     return true;
 }
 
-function areIntersectingNE(a: Tuple, b: AtomSetElements) {
-    const u = Tuple.fst(a);
-    return OrderedSet.has(b.keys, u) && OrderedSet.has(b[u], Tuple.snd(a));
+function areIntersectingNE(a: Atom, b: AtomSetElements) {
+    const u = Atom.unit(a);
+    return OrderedSet.has(b.keys, u) && OrderedSet.has(b[u], Atom.index(a));
 }
 
 function areIntersectingEE(a: AtomSetElements, b: AtomSetElements) {
@@ -350,9 +350,9 @@ function areIntersectingEE(a: AtomSetElements, b: AtomSetElements) {
     return false;
 }
 
-function intersectNE(a: Tuple, b: AtomSetElements) {
-    const u = Tuple.fst(a);
-    return OrderedSet.has(b.keys, u) && OrderedSet.has(b[u], Tuple.snd(a)) ? a : Empty;
+function intersectNE(a: Atom, b: AtomSetElements) {
+    const u = Atom.unit(a);
+    return OrderedSet.has(b.keys, u) && OrderedSet.has(b[u], Atom.index(a)) ? a : Empty;
 }
 
 function intersectEE(a: AtomSetElements, b: AtomSetElements) {
@@ -377,14 +377,14 @@ function intersectEE(a: AtomSetElements, b: AtomSetElements) {
     return ofObjectOrdered(OrderedSet.ofSortedArray(keys), ret);
 }
 
-function subtractNE(a: Tuple, b: AtomSetElements) {
-    const u = Tuple.fst(a);
-    return OrderedSet.has(b.keys, u) && OrderedSet.has(b[u], Tuple.snd(a)) ? Empty : a;
+function subtractNE(a: Atom, b: AtomSetElements) {
+    const u = Atom.unit(a);
+    return OrderedSet.has(b.keys, u) && OrderedSet.has(b[u], Atom.index(a)) ? Empty : a;
 }
 
-function subtractEN(a: AtomSetElements, b: Tuple): AtomSetImpl {
+function subtractEN(a: AtomSetElements, b: Atom): AtomSetImpl {
     const aKeys =  a.keys;
-    const u = Tuple.fst(b), v = Tuple.snd(b);
+    const u = Atom.unit(b), v = Atom.index(b);
     if (!OrderedSet.has(aKeys, u) || !OrderedSet.has(a[u], v)) return a;
     const set = a[u];
     if (OrderedSet.size(set) === 1) {
@@ -465,14 +465,14 @@ function unionN(sets: ArrayLike<AtomSetImpl>, eCount: { count: number }) {
     }
     eCount.count = countE;
     if (!countN) return Empty;
-    if (countN === sets.length) return ofTuples(sets as ArrayLike<Tuple>);
+    if (countN === sets.length) return ofAtoms(sets as ArrayLike<Atom>);
     const packed = new Float64Array(countN);
     let offset = 0;
     for (let i = 0, _i = sets.length; i < _i; i++) {
         const s = sets[i];
         if (typeof s === 'number') packed[offset++] = s;
     }
-    return ofTuples(packed as any);
+    return ofAtoms(packed as any);
 }
 
 function unionInto(data: { [key: number]: OrderedSet }, a: AtomSetElements) {
@@ -485,12 +485,12 @@ function unionInto(data: { [key: number]: OrderedSet }, a: AtomSetElements) {
     }
 }
 
-function unionIntoN(data: { [key: number]: OrderedSet }, a: Tuple) {
-    const u = Tuple.fst(a);
+function unionIntoN(data: { [key: number]: OrderedSet }, a: Atom) {
+    const u = Atom.unit(a);
     const set = data[u];
     if (set) {
-        data[u] = OrderedSet.union(set, OrderedSet.ofSingleton(Tuple.snd(a)));
+        data[u] = OrderedSet.union(set, OrderedSet.ofSingleton(Atom.index(a)));
     } else {
-        data[u] = OrderedSet.ofSingleton(Tuple.snd(a));
+        data[u] = OrderedSet.ofSingleton(Atom.index(a));
     }
 }

src/mol-data/atom-set/builder.ts

@@ -40,7 +40,7 @@ class Builder {
                 sets[k] = OrderedSet.ofSingleton(unit[0]);
             } else {
                 const set = OrderedSet.ofSortedArray(unit);
-                const parentSet = AtomSet.getByKey(this.parent, k);
+                const parentSet = AtomSet.unitGetById(this.parent, k);
                 sets[k] = OrderedSet.areEqual(set, parentSet) ? parentSet : set;
             }
         }

src/mol-data/atom-set/properties.ts

@@ -0,0 +1,6 @@
+/**
+ * Copyright (c) 2017 molio contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author David Sehnal <david.sehnal@gmail.com>
+ */
+

src/mol-data/atom.ts

@@ -0,0 +1,21 @@
+/**
+ * Copyright (c) 2017 molio contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author David Sehnal <david.sehnal@gmail.com>
+ */
+
+import Tuple from '../mol-base/collections/integer/tuple'
+
+interface Atom { '@type': Tuple['@type'] }
+
+namespace Atom {
+    export const Zero: Atom = Tuple.Zero;
+    export const create: (unit: number, index: number) => Atom = Tuple.create;
+    export const is: (x: any) => x is Atom = Tuple.is;
+    export const unit: (a: Atom) => number = Tuple.fst;
+    export const index: (a: Atom) => number = Tuple.snd;
+    export const areEqual: (a: Atom, b: Atom) => boolean = Tuple.areEqual;
+    export const hashCode: (a: Atom) => number = Tuple.hashCode;
+}
+
+export default Atom

src/mol-data/model/formats.ts

@@ -4,5 +4,7 @@
  * @author David Sehnal <david.sehnal@gmail.com>
  */
 
+import mmCIF from '../../mol-io/reader/cif/schema/mmcif'
 
-export type RawData = {}
+export type RawData =
+    | { source: 'mmCIF', data: mmCIF }

src/mol-data/model/formats/mmcif.ts

@@ -4,4 +4,72 @@
  * @author David Sehnal <david.sehnal@gmail.com>
  */
 
-// TODO: implement interfaces for mmCIF source data format
+import { RawData } from '../formats'
+import mmCIF from '../../../mol-io/reader/cif/schema/mmcif'
+import Model from '../../model'
+import Interval from '../../../mol-base/collections/integer/interval'
+import Segmentation from '../../../mol-base/collections/integer/segmentation'
+
+function findModelBounds(data: mmCIF, startIndex: number) {
+    const num = data.atom_site.pdbx_PDB_model_num;
+    const atomCount = num.rowCount;
+    if (!num.isDefined) return Interval.ofBounds(startIndex, atomCount);
+    let endIndex = startIndex + 1;
+    while (endIndex < atomCount && num.areValuesEqual(startIndex, endIndex)) endIndex++;
+    return Interval.ofBounds(startIndex, endIndex);
+}
+
+function segment(data: mmCIF, bounds: Interval) {
+    const start = Interval.start(bounds), end = Interval.end(bounds);
+    const residues = [start], chains = [start];
+
+    const { label_entity_id, auth_asym_id, auth_seq_id, pdbx_PDB_ins_code } = data.atom_site;
+
+    for (let i = start + 1; i < end; i++) {
+        const newEntity = !label_entity_id.areValuesEqual(i - 1, i);
+        const newChain = newEntity || !auth_asym_id.areValuesEqual(i - 1, i);
+        const newResidue = newChain
+            || !auth_seq_id.areValuesEqual(i - 1, i)
+            || !pdbx_PDB_ins_code.areValuesEqual(i - 1, i);
+
+        if (newResidue) residues[residues.length] = i;
+        if (newChain) chains[chains.length] = i;
+    }
+
+    residues[residues.length] = end;
+    chains[chains.length] = end;
+
+    return { residues: Segmentation.create(residues), chains: Segmentation.create(chains) };
+}
+
+function createModel(raw: RawData, data: mmCIF, bounds: Interval): Model {
+    const segments = segment(data, bounds);
+    return {
+        data: raw,
+        common: 0 as any,
+        macromolecule: 0 as any,
+        residues: segments.residues,
+        chains: segments.chains
+    };
+}
+
+function getModels(data: mmCIF): ArrayLike<Model> {
+    const raw: RawData = { source: 'mmCIF', data };
+    const models: Model[] = [];
+    const atomCount = data.atom_site._rowCount;
+    let modelStart = 0;
+    while (modelStart < atomCount) {
+        const bounds = findModelBounds(data, modelStart);
+        const model = createModel(raw, data, bounds);
+        models.push(model);
+        modelStart = Interval.end(bounds);
+    }
+    return models;
+}
+
+export default getModels;
+
+// function createStructure() {
+
+// }
+

src/mol-data/structure/data.ts

@@ -1,65 +0,0 @@
-/**
- * Copyright (c) 2017 molio contributors, licensed under MIT, See LICENSE file for more info.
- *
- * @author David Sehnal <david.sehnal@gmail.com>
- */
-
-export type Table<Data> = { rowCount: number } & { [E in keyof Data]: ArrayLike<Data[E]> }
-export type DataTable<Data> = { data: any } & Table<Data & { dataIndex: number }>
-
-export interface Position { x: number, y: number, z: number }
-export interface Positions extends Table<Position> {}
-
-export interface Atom {
-    name: string,
-    elementSymbol: string,
-    altLoc: string | null,
-}
-export interface Atoms extends DataTable<Atom> { }
-
-export interface Residue {
-    key: number,
-    name: string,
-    seqNumber: number,
-    insCode: string | null,
-    isHet: number
-}
-export interface Residues extends DataTable<Residue> { }
-
-export interface Chain { key: number, id: string }
-export interface Chains extends DataTable<Chain> { }
-
-export interface Entity { key: number, id: string }
-export interface Entities extends DataTable<Entity> { }
-
-export interface Bonds extends Readonly<{
-    /**
-     * Where bonds for atom A start and end.
-     * Start at idx, end at idx + 1
-     */
-    offset: ArrayLike<number>,
-    neighbor: ArrayLike<number>,
-
-    order: ArrayLike<number>,
-    flags: ArrayLike<number>,
-
-    count: number
-}> { }
-
-export type SourceData =
-    | { kind: 'mmCIF', data: any  } // TODO
-    | { kind: 'custom', data: any  } // TODO
-
-export interface Structure {
-    atoms: Atoms,
-    residues: Residues,
-    chains: Chains,
-    entities: Entities
-}
-
-export interface SecondaryStructure {
-
-}
-export interface SecondaryStructures extends Table<SecondaryStructure> {
-
-}

src/mol-data/structure/selectors/common.ts

@@ -1,47 +0,0 @@
-// /**
-//  * Copyright (c) 2017 molio contributors, licensed under MIT, See LICENSE file for more info.
-//  *
-//  * @author David Sehnal <david.sehnal@gmail.com>
-//  */
-
-// import { Selector } from '../model'
-// //import * as Data from '../data'
-// //import { Vec3 } from '../../utils/linear-algebra'
-
-// export const atom = {
-//     name: Selector((m, u) => {
-//         const unit = m.units[u].structure;
-//         const atoms = unit.atoms;
-//         const name = unit.data.atoms.name;
-//         return a => name[atoms[a]];
-//     }),
-//     // position: Selector<Vec3>((m, u) => {
-//     //     const unit = m.units[u].structure;
-//     //     const atoms = unit.atoms;
-//     //     const { positions: { x, y, z } } = m.conformation[u];
-//     //     const { operator: { transform } } = unit;
-//     //     return (atom, position) => {
-//     //         const a = atoms[atom];
-//     //         const p = position || Vec3.zero();
-//     //         Vec3.set(p, x[a], y[a], z[a]);
-//     //         return Vec3.transformMat4(p, p, transform);
-//     //     };
-//     // }),
-//     // inversePosition: Selector<Vec3>((m, u) => {
-//     //     const unit = m.structure[u];
-//     //     const atoms = unit.atoms;
-//     //     const { positions: { x, y, z } } = m.conformation[u];
-//     //     const { operator: { inverse } } = unit;
-
-//     //     return (atom, position) => {
-//     //         const a = atoms[atom];
-//     //         const p = position || Vec3.zero();
-//     //         Vec3.set(p, x[a], y[a], z[a]);
-//     //         return Vec3.transformMat4(p, p, inverse);
-//     //     };
-//     // })
-// }
-
-// export const residue = {
-
-// }

src/mol-data/structure/selectors/mmcif.ts

@@ -1,34 +0,0 @@
-// /**
-//  * Copyright (c) 2017 molio contributors, licensed under MIT, See LICENSE file for more info.
-//  *
-//  * @author David Sehnal <david.sehnal@gmail.com>
-//  */
-
-// import { Model, Unit, PropertyGetterProvider } from '../model'
-// import * as Data from '../data'
-// //import { Vec3 } from '../../utils/linear-algebra'
-
-// // function provider<T>(p: (model: Model) => Property<T>): PropertyProvider<T> {
-// //     return p;
-// // }
-
-// function atomPropertyProvider<T>(property: (ps: Model['structure']['properties']) => ArrayLike<T>): PropertyGetterProvider<T> {
-//     return m => {
-//         const a = m.structure.properties.atoms;
-//         const p = property(m.structure.properties);
-//         return ({ unit, atom }) => p[a[unit][atom]];
-//     };
-// }
-
-// function unitStructureProvider<T>(p: (structure: Unit.Structure, data: Data.Structure, atom: number) => T): PropertyGetterProvider<T> {
-//     return m => {
-//         const units = m.structure.units;
-//         const data = m.structure.properties.data;
-//         return ({ unit, atom }) => p(units[unit], data[unit], atom);
-//     };
-// }
-
-// export const atom_site = {
-//     label_atom_id: atomPropertyProvider(ps => ps.),
-//     label_comp_id: unitStructureProvider((u, d, a) => d.residues.name[u.atomResidue[a]])
-// }

src/mol-data/structure/topology/secondary-structure.ts

@@ -1,128 +0,0 @@
-/**
- * Copyright (c) 2017 molio contributors, licensed under MIT, See LICENSE file for more info.
- *
- * @author Alexander Rose <alexander.rose@weirdbyte.de>
- */
-
-const enum SSF {
-    None = 0x0,
-
-    // category
-    DoubleHelix = 0x1,
-    Helix = 0x2,
-    Beta = 0x4,
-    Turn = 0x8,
-
-    // category variant
-    LeftHanded = 0x10,  // helix
-    RightHanded = 0x20,
-
-    ClassicTurn = 0x40,  // turn
-    InverseTurn = 0x80,
-
-    // sub-category
-    HelixOther = 0x100,  // protein
-    Helix27 = 0x200,
-    Helix3Ten = 0x400,
-    HelixAlpha = 0x800,
-    HelixGamma = 0x1000,
-    HelixOmega = 0x2000,
-    HelixPi = 0x4000,
-    HelixPolyproline = 0x8000,
-
-    DoubleHelixOther = 0x10000,  // nucleic
-    DoubleHelixZ = 0x20000,
-    DoubleHelixA = 0x40000,
-    DoubleHelixB = 0x80000,
-
-    BetaOther = 0x100000,  // protein
-    BetaStrand = 0x200000,  // single strand
-    BetaSheet = 0x400000,  // multiple hydrogen bonded strands
-    BetaBarell = 0x800000,  // closed series of sheets
-
-    TurnOther = 0x1000000,  // protein
-    Turn1 = 0x2000000,
-    Turn2 = 0x4000000,
-    Turn3 = 0x8000000,
-
-    NA = 0x10000000,  // not applicable/available
-}
-export { SSF as SecondaryStructureFlag }
-
-export const SecondaryStructureMmcif: { [value: string]: number } = {
-    HELX_LH_27_P: SSF.Helix | SSF.LeftHanded | SSF.Helix27,  // left-handed 2-7 helix (protein)
-    HELX_LH_3T_P: SSF.Helix | SSF.LeftHanded | SSF.Helix3Ten,  // left-handed 3-10 helix (protein)
-    HELX_LH_AL_P: SSF.Helix | SSF.LeftHanded | SSF.HelixAlpha,  // left-handed alpha helix (protein)
-    HELX_LH_A_N: SSF.DoubleHelix | SSF.LeftHanded | SSF.DoubleHelixA,  // left-handed A helix (nucleic acid)
-    HELX_LH_B_N: SSF.DoubleHelix | SSF.LeftHanded | SSF.DoubleHelixB,  // left-handed B helix (nucleic acid)
-    HELX_LH_GA_P: SSF.Helix | SSF.LeftHanded | SSF.HelixGamma,  // left-handed gamma helix (protein)
-    HELX_LH_N: SSF.DoubleHelix | SSF.LeftHanded,  // left-handed helix with type not specified (nucleic acid)
-    HELX_LH_OM_P: SSF.Helix | SSF.LeftHanded | SSF.HelixOmega,  // left-handed omega helix (protein)
-    HELX_LH_OT_N: SSF.DoubleHelix | SSF.LeftHanded | SSF.DoubleHelixOther,  // left-handed helix with type that does not conform to an accepted category (nucleic acid)
-    HELX_LH_OT_P: SSF.Helix | SSF.LeftHanded | SSF.HelixOther,  // left-handed helix with type that does not conform to an accepted category (protein)
-    HELX_LH_P: SSF.Helix | SSF.LeftHanded,  // left-handed helix with type not specified (protein)
-    HELX_LH_PI_P: SSF.Helix | SSF.LeftHanded | SSF.HelixPi,  // left-handed pi helix (protein)
-    HELX_LH_PP_P: SSF.Helix | SSF.LeftHanded | SSF.HelixPolyproline,  // left-handed polyproline helix (protein)
-    HELX_LH_Z_N: SSF.DoubleHelix | SSF.LeftHanded | SSF.DoubleHelixZ,  // left-handed Z helix (nucleic acid)
-    HELX_N: SSF.DoubleHelix,  // helix with handedness and type not specified (nucleic acid)
-    HELX_OT_N: SSF.DoubleHelix,  // helix with handedness and type that do not conform to an accepted category (nucleic acid)
-    HELX_OT_P: SSF.Helix,  // helix with handedness and type that do not conform to an accepted category (protein)
-    HELX_P: SSF.Helix,  // helix with handedness and type not specified (protein)
-    HELX_RH_27_P: SSF.Helix | SSF.RightHanded | SSF.Helix27,  // right-handed 2-7 helix (protein)
-    HELX_RH_3T_P: SSF.Helix | SSF.RightHanded | SSF.Helix3Ten,  // right-handed 3-10 helix (protein)
-    HELX_RH_AL_P: SSF.Helix | SSF.RightHanded | SSF.HelixAlpha,  // right-handed alpha helix (protein)
-    HELX_RH_A_N: SSF.DoubleHelix | SSF.RightHanded | SSF.DoubleHelixA,  // right-handed A helix (nucleic acid)
-    HELX_RH_B_N: SSF.DoubleHelix | SSF.RightHanded | SSF.DoubleHelixB,  // right-handed B helix (nucleic acid)
-    HELX_RH_GA_P: SSF.Helix | SSF.RightHanded | SSF.HelixGamma,  // right-handed gamma helix (protein)
-    HELX_RH_N: SSF.DoubleHelix | SSF.RightHanded,  // right-handed helix with type not specified (nucleic acid)
-    HELX_RH_OM_P: SSF.Helix | SSF.RightHanded | SSF.HelixOmega,  // right-handed omega helix (protein)
-    HELX_RH_OT_N: SSF.DoubleHelix | SSF.RightHanded | SSF.DoubleHelixOther,  // right-handed helix with type that does not conform to an accepted category (nucleic acid)
-    HELX_RH_OT_P: SSF.Helix | SSF.RightHanded | SSF.HelixOther,  // right-handed helix with type that does not conform to an accepted category (protein)
-    HELX_RH_P: SSF.Helix | SSF.RightHanded,  // right-handed helix with type not specified (protein)
-    HELX_RH_PI_P: SSF.Helix | SSF.RightHanded | SSF.HelixPi,  // right-handed pi helix (protein)
-    HELX_RH_PP_P: SSF.Helix | SSF.RightHanded | SSF.HelixPolyproline,  // right-handed polyproline helix (protein)
-    HELX_RH_Z_N: SSF.DoubleHelix | SSF.RightHanded | SSF.DoubleHelixZ,  // right-handed Z helix (nucleic acid)
-    STRN: SSF.Beta | SSF.BetaStrand,  // beta strand (protein)
-    TURN_OT_P: SSF.Turn | SSF.TurnOther,  // turn with type that does not conform to an accepted category (protein)
-    TURN_P: SSF.Turn,  // turn with type not specified (protein)
-    TURN_TY1P_P: SSF.Turn | SSF.InverseTurn | SSF.Turn1,  // type I prime turn (protein)
-    TURN_TY1_P: SSF.Turn | SSF.ClassicTurn | SSF.Turn1,  // type I turn (protein)
-    TURN_TY2P_P: SSF.Turn | SSF.InverseTurn | SSF.Turn2,  // type II prime turn (protein)
-    TURN_TY2_P: SSF.Turn | SSF.ClassicTurn | SSF.Turn2,  // type II turn (protein)
-    TURN_TY3P_P: SSF.Turn | SSF.InverseTurn | SSF.Turn3,  // type III prime turn (protein)
-    TURN_TY3_P: SSF.Turn | SSF.ClassicTurn | SSF.Turn3,  // type III turn (protein)
-}
-
-export const SecondaryStructurePdb: { [value: string]: number } = {
-    1: SSF.Helix | SSF.RightHanded | SSF.HelixAlpha,  // Right-handed alpha (default)
-    2: SSF.Helix | SSF.RightHanded | SSF.HelixOmega,  // Right-handed omega
-    3: SSF.Helix | SSF.RightHanded | SSF.HelixPi,  // Right-handed pi
-    4: SSF.Helix | SSF.RightHanded | SSF.HelixGamma,  // Right-handed gamma
-    5: SSF.Helix | SSF.RightHanded | SSF.Helix3Ten,  // Right-handed 310
-    6: SSF.Helix | SSF.LeftHanded | SSF.HelixAlpha,  // Left-handed alpha
-    7: SSF.Helix | SSF.LeftHanded | SSF.HelixOmega,  // Left-handed omega
-    8: SSF.Helix | SSF.LeftHanded | SSF.HelixGamma,  // Left-handed gamma
-    9: SSF.Helix | SSF.Helix27,  // 27 ribbon/helix
-    10: SSF.Helix | SSF.HelixPolyproline,  // Polyproline
-}
-
-export const SecondaryStructureStride: { [value: string]: number } = {
-    H: SSF.Helix | SSF.HelixAlpha,  // Alpha helix
-    G: SSF.Helix | SSF.Helix3Ten,  // 3-10 helix
-    I: SSF.Helix | SSF.HelixPi,  // PI-helix
-    E: SSF.Beta | SSF.BetaSheet,  // Extended conformation
-    B: SSF.Beta | SSF.BetaStrand,  // Isolated bridge
-    b: SSF.Beta | SSF.BetaStrand,  // Isolated bridge
-    T: SSF.Turn,  // Turn
-    C: SSF.NA,  // Coil (none of the above)
-}
-
-export const SecondaryStructureDssp: { [value: string]: number } = {
-    H: SSF.Helix | SSF.HelixAlpha,  // alpha-helix
-    B: SSF.Beta | SSF.BetaStrand,  // residue in isolated beta-bridge
-    E: SSF.Beta | SSF.BetaSheet,  // extended strand, participates in beta ladder
-    G: SSF.Helix | SSF.Helix3Ten,  // 3-helix (310 helix)
-    I: SSF.Helix | SSF.HelixPi,  // 5 helix (pi-helix)
-    T: SSF.Turn,  // hydrogen bonded turn
-    S: SSF.Turn,  // bend
-}

src/mol-io/reader/cif/index.ts → src/mol-io/reader/cif.ts

@@ -4,11 +4,11 @@
  * @author David Sehnal <david.sehnal@gmail.com>
  */
 
-import parseText from './text/parser'
-import parseBinary from './binary/parser'
-import { Block } from './data-model'
-import { toTypedFrame as applySchema } from './schema'
-import mmCIF from './schema/mmcif'
+import parseText from './cif/text/parser'
+import parseBinary from './cif/binary/parser'
+import { Block } from './cif/data-model'
+import { toTypedFrame as applySchema } from './cif/schema'
+import mmCIF from './cif/schema/mmcif'
 
 export default {
     parseText,
@@ -19,4 +19,4 @@ export default {
     }
 }
 
-export * from './data-model'
+export * from './cif/data-model'

src/perf-tests/sets.ts

@@ -3,7 +3,6 @@ import Tuple from '../mol-base/collections/integer/tuple'
 import OrdSet from '../mol-base/collections/integer/ordered-set'
 import AtomSet from '../mol-data/atom-set'
 import Segmentation from '../mol-base/collections/integer/segmentation'
-import SortedArray from '../mol-base/collections/integer/sorted-array'
 
 export namespace Iteration {
     const U = 1000, V = 2500;
@@ -38,15 +37,15 @@ export namespace Iteration {
 
     export function elementAt() {
         let s = 0;
-        for (let i = 0, _i = AtomSet.atomCount(ms); i < _i; i++) s += Tuple.snd(AtomSet.getAtomAt(ms, i));
+        for (let i = 0, _i = AtomSet.atomCount(ms); i < _i; i++) s += Tuple.snd(AtomSet.atomGetAt(ms, i));
         return s;
     }
 
     export function manual() {
         let s = 0;
-        const keys = AtomSet.units(ms);
+        const keys = AtomSet.unitIds(ms);
         for (let i = 0, _i = OrdSet.size(keys); i < _i; i++) {
-            const set = AtomSet.getByKey(ms, OrdSet.getAt(keys, i));
+            const set = AtomSet.unitGetById(ms, OrdSet.getAt(keys, i));
             for (let j = 0, _j = OrdSet.size(set); j < _j; j++) {
                 s += OrdSet.getAt(set, j);
             }
@@ -57,7 +56,7 @@ export namespace Iteration {
     export function manual1() {
         let s = 0;
         for (let i = 0, _i = AtomSet.unitCount(ms); i < _i; i++) {
-            const set = AtomSet.getByIndex(ms, i);
+            const set = AtomSet.unitGetByIndex(ms, i);
             for (let j = 0, _j = OrdSet.size(set); j < _j; j++) {
                 s += OrdSet.getAt(set, j);
             }
@@ -274,7 +273,7 @@ export namespace Tuples {
 
 export function testSegments() {
     const data = OrdSet.ofSortedArray([4, 9, 10, 11, 14, 15, 16]);
-    const segs = Segmentation.create(SortedArray.ofSortedArray([0, 4, 10, 12, 13, 15, 25]), []);
+    const segs = Segmentation.create([0, 4, 10, 12, 13, 15, 25]);
     const it = Segmentation.segments(segs, data);
 
     while (it.hasNext) {

src/script.ts

@@ -13,10 +13,12 @@ const readFileAsync = util.promisify(fs.readFile);
 const writeFileAsync = util.promisify(fs.writeFile);
 
 import Gro from './mol-io/reader/gro/parser'
-import CIF from './mol-io/reader/cif/index'
+import CIF from './mol-io/reader/cif'
 
 import Computation from './mol-base/computation'
 
+import createModels from './mol-data/model/formats/mmcif'
+
 // import { toTypedFrame as applySchema } from './reader/cif/schema'
 import { generateSchema } from './mol-io/reader/cif/schema/utils'
 
@@ -112,6 +114,11 @@ async function runCIF(input: string | Uint8Array) {
     console.log(mmcif.entity.type.toArray());
     console.log(mmcif.pdbx_struct_oper_list.matrix.value(0));
 
+    console.time('createModels');
+    const models = createModels(mmcif);
+    console.timeEnd('createModels');
+    console.log(models[0].common);
+
     // const schema = await _dic()
     // if (schema) {
     //     const mmcif2 = applySchema(schema, data)