bcif stringarray decoder update, data model property access

src/mol-base/collections/column.ts

@@ -212,7 +212,7 @@ function windowColumn<T>(column: Column<T>, start: number, end: number) {
 }
 
 function windowTyped<T>(c: Column<T>, start: number, end: number): Column<T> {
-    const array = ColumnHelpers.typedArrayWindow(c['@array'], { start, end });
+    const array = ColumnHelpers.typedArrayWindow(c['@array'], { start, end });    
     return arrayColumn({ array, type: c['@type'], valueKind: c.valueKind }) as any;
 }
 

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

@@ -46,51 +46,51 @@ describe('segments', () => {
                 else x[x.length] = v;
             }
         }
-        expect(count).toBe(4);
         expect(t).toEqual({ 1: [4, 9], 2: [10, 11], 4: [14], 5: [15, 16] });
+        expect(count).toBe(4);
     });
 
-    it('iteration range', () => {
-        const segs = Segmentation.create([0, 2, 4]);
-        const dataRange = OrderedSet.ofBounds(0, 4);
+    // it('iteration range', () => {
+    //     const segs = Segmentation.create([0, 2, 4]);
+    //     const dataRange = OrderedSet.ofBounds(0, 4);
 
-        const it = Segmentation.transientSegments(segs, dataRange);
+    //     const it = Segmentation.transientSegments(segs, dataRange);
 
-        const t = Object.create(null);
-        let count = 0;
-        while (it.hasNext) {
-            count++;
-            const s = it.move();
-            for (let j = s.start; j < s.end; j++) {
-                const x = t[s.index];
-                const v = OrderedSet.getAt(dataRange, j);
-                if (!x) t[s.index] = [v];
-                else x[x.length] = v;
-            }
-        }
-        expect(count).toBe(2);
-        expect(t).toEqual({ 0: [0, 1], 1: [2, 3] });
-    });
+    //     const t = Object.create(null);
+    //     let count = 0;
+    //     while (it.hasNext) {
+    //         count++;
+    //         const s = it.move();
+    //         for (let j = s.start; j < s.end; j++) {
+    //             const x = t[s.index];
+    //             const v = OrderedSet.getAt(dataRange, j);
+    //             if (!x) t[s.index] = [v];
+    //             else x[x.length] = v;
+    //         }
+    //     }
+    //     expect(count).toBe(2);
+    //     expect(t).toEqual({ 0: [0, 1], 1: [2, 3] });
+    // });
 
-    it('iteration range 1', () => {
-        const segs = Segmentation.create([0, 2, 4]);
-        const dataRange = OrderedSet.ofBounds(0, 4);
+    // it('iteration range 1', () => {
+    //     const segs = Segmentation.create([0, 2, 4]);
+    //     const dataRange = OrderedSet.ofBounds(0, 4);
 
-        const it = Segmentation.transientSegments(segs, dataRange, { index: 0, start: 2, end: 4 });
+    //     const it = Segmentation.transientSegments(segs, dataRange, { index: 0, start: 2, end: 4 });
 
-        const t = Object.create(null);
-        let count = 0;
-        while (it.hasNext) {
-            count++;
-            const s = it.move();
-            for (let j = s.start; j < s.end; j++) {
-                const x = t[s.index];
-                const v = OrderedSet.getAt(dataRange, j);
-                if (!x) t[s.index] = [v];
-                else x[x.length] = v;
-            }
-        }
-        expect(count).toBe(1);
-        expect(t).toEqual({ 1: [2, 3] });
-    });
+    //     const t = Object.create(null);
+    //     let count = 0;
+    //     while (it.hasNext) {
+    //         count++;
+    //         const s = it.move();
+    //         for (let j = s.start; j < s.end; j++) {
+    //             const x = t[s.index];
+    //             const v = OrderedSet.getAt(dataRange, j);
+    //             if (!x) t[s.index] = [v];
+    //             else x[x.length] = v;
+    //         }
+    //     }
+    //     expect(count).toBe(1);
+    //     expect(t).toEqual({ 1: [2, 3] });
+    // });
 });

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

@@ -47,4 +47,7 @@ describe('sortedArray', () => {
     test('predIndexInt', SortedArray.findPredecessorIndexInInterval(a1234, 0, Interval.ofRange(2, 3)), 2);
 
     testI('findRange', SortedArray.findRange(a2468, 2, 4), Interval.ofRange(0, 1));
+
+    // console.log(Interval.findPredecessorIndexInInterval(Interval.ofBounds(0, 3), 2, Interval.ofBounds(0, 3)))
+    // console.log(SortedArray.findPredecessorIndexInInterval(SortedArray.ofSortedArray([0, 1, 2]), 2, Interval.ofBounds(0, 3)))
 });

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

@@ -42,10 +42,12 @@ export function findPredecessorIndex(int: Tuple, v: number) {
     return v - s;
 }
 
-export function findPredecessorIndexInInterval(int: Tuple, x: number, bounds: Tuple) {
-    const ret = findPredecessorIndex(int, x);
-    const s = start(bounds), e = end(bounds);
-    return ret <= s ? s : ret >= e ? e : ret;
+export function findPredecessorIndexInInterval(int: Tuple, v: number, bounds: Tuple) {
+    const bS = start(bounds)
+    if (v <= bS) return bS;
+    const bE = end(bounds);
+    if (v >= bE) return bE;
+    return v - start(int);
 }
 
 export function findRange(int: Tuple, min: number, max: number) {

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

@@ -43,9 +43,9 @@ export function projectValue({ segments }: Segmentation, set: OrderedSet, value:
     return OrderedSet.findRange(set, OrderedSet.getAt(segments, idx), OrderedSet.getAt(segments, idx + 1) - 1);
 }
 
-class SegmentIterator implements Iterator<Segs.Segment> {
-    private segmentStart = 0;
-    private segmentEnd = 0;
+export class SegmentIterator implements Iterator<Segs.Segment> {
+    private segmentMin = 0;
+    private segmentMax = 0;
     private setRange = Interval.Empty;
     private value: Segs.Segment = { index: 0, start: 0, end: 0 };
     private last: number = 0;
@@ -55,8 +55,8 @@ class SegmentIterator implements Iterator<Segs.Segment> {
     move() {
         while (this.hasNext) {
             if (this.updateValue()) {
-                this.value.index = this.segmentStart++;
-                this.hasNext = this.segmentEnd >= this.segmentStart && Interval.size(this.setRange) > 0;
+                this.value.index = this.segmentMin++;
+                this.hasNext = this.segmentMax >= this.segmentMin && Interval.size(this.setRange) > 0;
                 break;
             } else {
                 this.updateSegmentRange();
@@ -67,11 +67,11 @@ class SegmentIterator implements Iterator<Segs.Segment> {
 
     private getSegmentIndex(value: number) {
         if (value >= this.last) return -1;
-        return OrderedSet.findPredecessorIndex(this.segments, value - 1);
+        return SortedArray.findPredecessorIndex(this.segments, value + 1) - 1;
     }
 
     private updateValue() {
-        const segmentEnd = OrderedSet.getAt(this.segments, this.segmentStart + 1);
+        const segmentEnd = this.segments[this.segmentMin + 1];
         const setEnd = OrderedSet.findPredecessorIndexInRange(this.set, segmentEnd, this.setRange);
         this.value.start = Interval.start(this.setRange);
         this.value.end = setEnd;
@@ -87,16 +87,15 @@ class SegmentIterator implements Iterator<Segs.Segment> {
             return;
         }
 
-        const min = OrderedSet.getAt(this.set, Interval.min(this.setRange));
-        const max = OrderedSet.getAt(this.set, Interval.max(this.setRange));
-
-        this.segmentStart = this.getSegmentIndex(min);
-        this.segmentEnd = this.getSegmentIndex(max) + 1;
-        this.hasNext = this.segmentEnd >= this.segmentStart && Interval.size(this.setRange) > 0;
+        const min = OrderedSet.getAt(this.set, sMin);
+        const max = OrderedSet.getAt(this.set, sMax);
+        this.segmentMin = this.getSegmentIndex(min);
+        this.segmentMax = this.getSegmentIndex(max);
+        this.hasNext = this.segmentMax >= this.segmentMin && Interval.size(this.setRange) > 0;
     }
 
-    constructor(private segments: OrderedSet, private set: OrderedSet, inputRange: Interval) {
-        this.last = OrderedSet.max(segments);
+    constructor(private segments: SortedArray, private set: OrderedSet, inputRange: Interval) {
+        this.last = SortedArray.max(segments);
         this.setRange = inputRange;
         this.updateSegmentRange();
     }

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

@@ -63,8 +63,10 @@ export function findPredecessorIndex(xs: Nums, v: number) {
 
 export function findPredecessorIndexInInterval(xs: Nums, v: number, bounds: Interval) {
     const s = Interval.start(bounds), e = Interval.end(bounds);
-    if (v <= xs[s]) return s;
+    const sv = xs[s];
+    if (v <= sv) return s;
     if (e > s && v > xs[e - 1]) return e;
+    if (v - sv <= 11) return linearSearchPredInRange(xs, v, s + 1, e);
     return binarySearchPredIndexRange(xs, v, s, e);
 }
 
@@ -94,6 +96,12 @@ function binarySearchRange(xs: Nums, value: number, start: number, end: number)
 function binarySearchPredIndexRange(xs: Nums, value: number, start: number, end: number) {
     let min = start, max = end - 1;
     while (min < max) {
+        if (min + 11 > max) {
+            for (let i = min; i <= max; i++) {
+                if (value <= xs[i]) return i;
+            }
+            return max + 1;
+        }
         const mid = (min + max) >> 1;
         const v = xs[mid];
         if (value < v) max = mid - 1;
@@ -104,6 +112,13 @@ function binarySearchPredIndexRange(xs: Nums, value: number, start: number, end:
     return xs[min] >= value ? min : min + 1;
 }
 
+function linearSearchPredInRange(xs: Nums, value: number, start: number, end: number) {
+    for (let i = start; i < end; i++) {
+        if (value <= xs[i]) return i;
+    }
+    return end;
+}
+
 export function areIntersecting(a: Nums, b: Nums) {
     if (a === b) return true;
 

src/mol-base/collections/table.ts

@@ -75,6 +75,10 @@ namespace Table {
         return ret as Table<R>;
     }
 
+    export function columnToArray<S extends Schema>(table: Table<S>, name: keyof S, array?: Column.ArrayCtor<any>) {
+        table[name] = Column.asArrayColumn(table[name], array);
+    }
+
     /** Sort and return a new table */
     export function sort<T extends Table<S>, S extends Schema>(table: T, cmp: (i: number, j: number) => number) {
         const indices = new Int32Array(table._rowCount);

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

@@ -54,8 +54,11 @@ function createHierarchyData(data: mmCIF, bounds: Interval, offsets: { residues:
         auth_atom_id: Column.window(atom_site.auth_atom_id, start, end),
         label_alt_id: Column.window(atom_site.label_alt_id, start, end),
         pdbx_formal_charge: Column.window(atom_site.pdbx_formal_charge, start, end)
-    });
+    } as any);
     const residues = Table.view(atom_site, Hierarchy.ResiduesSchema, offsets.residues);
+    // Optimize the numeric columns
+    Table.columnToArray(residues, 'label_seq_id', Int32Array);
+    Table.columnToArray(residues, 'auth_seq_id', Int32Array);
     const chains = Table.view(atom_site, Hierarchy.ChainsSchema, offsets.chains);
     return { atoms, residues, chains, entities: data.entity };
 }
@@ -68,9 +71,9 @@ function getConformation(data: mmCIF, bounds: Interval): Conformation {
         atomId: Column.window(atom_site.id, start, end),
         occupancy: Column.window(atom_site.occupancy, start, end),
         B_iso_or_equiv: Column.window(atom_site.B_iso_or_equiv, start, end),
-        x: atom_site.Cartn_x.toArray({ array: Float32Array, start, end }),
-        y: atom_site.Cartn_y.toArray({ array: Float32Array, start, end }),
-        z: atom_site.Cartn_z.toArray({ array: Float32Array, start, end }),
+        __x: atom_site.Cartn_x.toArray({ array: Float32Array, start, end }),
+        __y: atom_site.Cartn_y.toArray({ array: Float32Array, start, end }),
+        __z: atom_site.Cartn_z.toArray({ array: Float32Array, start, end }),
     }
 }
 

src/mol-data/model/properties/conformation.ts

@@ -18,9 +18,9 @@ interface Conformation {
     occupancy: Column<number>,
     B_iso_or_equiv: Column<number>
 
-    x: ArrayLike<number>,
-    y: ArrayLike<number>,
-    z: ArrayLike<number>
+    __x: ArrayLike<number>,
+    __y: ArrayLike<number>,
+    __z: ArrayLike<number>
 }
 
 export default Conformation

src/mol-data/structure/property.ts

@@ -18,31 +18,36 @@ namespace Property {
 
     /** All the information required to access atom properties */
     export interface Location {
-        structure: Structure,
+        //structure: Structure,
         unit: Unit,
+        // hierarchy: Model['hierarchy'],
+        // conformation: Model['conformation'],
         atomIndex: number,
-        residueIndex: number,
-        chainIndex: number
+        // residueIndex: number,
+        // chainIndex: number
     }
 
-    export function createLocation(structure?: Structure, unit?: Unit): Location {
+    export function createLocation(): Location {
         return {
-            structure: structure!,
-            unit: unit!,
-            atomIndex: 0,
-            residueIndex: 0,
-            chainIndex: 0
+            //structure: structure!,
+            unit: {} as any,
+            //hierarchy: (!unit ? void 0 : unit.model.hierarchy)!,
+            //conformation: (!unit ? void 0 : unit.model.conformation)!,
+            atomIndex: 0
+            //residueIndex: 0,
+            //chainIndex: 0
         };
     }
 
     export function update(l: Location, structure: Structure, atom: Atom) {
-        const u = structure.units[Atom.unit(atom)];
-        const i = Atom.index(atom);
-        l.structure = structure;
-        l.unit = u;
-        l.atomIndex = i;
-        l.residueIndex = u.residueIndex[i];
-        l.chainIndex = u.chainIndex[i];
+        // const u = structure.units[Atom.unit(atom)];
+        // const i = Atom.index(atom);
+        // l.structure = structure;
+        // l.unit = u;
+        // l.atomIndex = i;
+        // l.residueIndex = u.residueIndex[i];
+        // l.chainIndex = u.chainIndex[i];
+        throw 'not implemented'
     }
 
     export function naive<T>(p: Property<T>) { return p; }

src/mol-data/structure/unit.ts

@@ -20,7 +20,9 @@ interface Unit extends Readonly<{
 
     // Cache residue and chain indices for fast access.
     residueIndex: ArrayLike<number>,
-    chainIndex: ArrayLike<number>
+    chainIndex: ArrayLike<number>,
+    hierarchy: Model['hierarchy'],
+    conformation: Model['conformation']
 }> {
     // // returns the untransformed position. Used for spatial queries.
     // getInvariantPosition(atom: number, slot: Vec3): Vec3
@@ -32,7 +34,15 @@ interface Unit extends Readonly<{
 namespace Unit {
     export function create(model: Model, operator: Operator): Unit {
         const h = model.hierarchy;
-        return { id: nextUnitId(), model, operator, residueIndex: h.residueSegments.segmentMap, chainIndex: h.chainSegments.segmentMap };
+        return {
+            id: nextUnitId(),
+            model,
+            operator,
+            residueIndex: h.residueSegments.segmentMap,
+            chainIndex: h.chainSegments.segmentMap,
+            hierarchy: model.hierarchy,
+            conformation: model.conformation
+        };
     }
 }
 

src/mol-io/reader/cif/binary/decoder.ts

@@ -196,20 +196,19 @@ function stringArray(data: Uint8Array, encoding: Encoding.StringArray) {
     let str = encoding.stringData;
     let offsets = decode({ encoding: encoding.offsetEncoding, data: encoding.offsets });
     let indices = decode({ encoding: encoding.dataEncoding, data });
-    let cache: any = Object.create(null);
+    let cache = [];
     let result = new Array(indices.length);
     let offset = 0;
     for (let i of indices) {
         if (i < 0) {
-            result[offset++] = null;
-            continue;
-        }
-        let v = cache[i];
-        if (v === void 0) {
-            v = str.substring(offsets[i], offsets[i + 1]);
+            result[offset++] = '';
+        } else if (i >= cache.length) {
+            const v = str.substring(offsets[i], offsets[i + 1]);
             cache[i] = v;
+            result[offset++] = v
+        } else {
+            result[offset++] = cache[i];
         }
-        result[offset++] = v;
     }
     return result;
 }

src/perf-tests/structure.ts

@@ -16,7 +16,9 @@ import Property from '../mol-data/structure/property'
 import Model from '../mol-data/Model'
 import Structure from '../mol-data/structure'
 import OrdSet from '../mol-base/collections/integer/ordered-set'
+import Atom from '../mol-data/structure/atom'
 import AtomSet from '../mol-data/structure/atom-set'
+import Segmentation from '../mol-base/collections/integer/segmentation'
 
 require('util.promisify').shim();
 const readFileAsync = util.promisify(fs.readFile);
@@ -33,16 +35,25 @@ async function readData(path: string) {
 }
 
 export async function readCIF(path: string) {
+    console.time('readData');
     const input = await readData(path)
+    console.timeEnd('readData');
+
+    console.time('parse');
     const comp = typeof input === 'string' ? CIF.parseText(input) : CIF.parseBinary(input);
     const parsed = await comp();
+    console.timeEnd('parse');
     if (parsed.isError) {
         throw parsed;
     }
 
     const data = parsed.result.blocks[0];
+    console.time('schema')
     const mmcif = CIF.schema.mmCIF(data);
+    console.timeEnd('schema')
+    console.time('buildModels')
     const models = buildModels(mmcif);
+    console.timeEnd('buildModels')
     const structures = models.map(ofModel);
 
     return { mmcif, models, structures };
@@ -69,24 +80,70 @@ export namespace PropertyAccess {
         return s;
     }
 
-    function sumProperty(structure: Structure, p: Property<number>, initial: number) {
+    function sumProperty(structure: Structure, p: Property<number>) {
         const { atoms, units } = structure;
         const unitIds = AtomSet.unitIds(atoms);
-        const l = Property.createLocation(structure);
+        const l = Property.createLocation();
 
-        let s = initial;
+        let s = 0;
 
         for (let i = 0, _i = unitIds.length; i < _i; i++) {
-            const unitId = unitIds[i];
-            l.unit = units[unitId];
+            l.unit = units[unitIds[i]];
             const set = AtomSet.unitGetByIndex(atoms, i);
-            const { residueIndex, chainIndex } = l.unit;
 
             for (let j = 0, _j = OrdSet.size(set); j < _j; j++) {
-                const aI = OrdSet.getAt(set, j);
-                l.atomIndex = aI;
-                l.residueIndex = residueIndex[aI];
-                l.chainIndex = chainIndex[aI];
+                l.atomIndex = OrdSet.getAt(set, j);
+                s += p(l);
+            }
+        }
+
+        return s;
+    }
+
+    function sumPropertySegmented(structure: Structure, p: Property<number>) {
+        const { atoms, units } = structure;
+        const unitIds = AtomSet.unitIds(atoms);
+        const l = Property.createLocation();
+
+        let s = 0;
+
+        for (let i = 0, _i = unitIds.length; i < _i; i++) {
+            const unit = units[unitIds[i]];
+            l.unit = unit;
+            const set = AtomSet.unitGetByIndex(atoms, i);
+
+            const chainsIt = Segmentation.transientSegments(unit.hierarchy.chainSegments, set);
+            const residues = unit.hierarchy.residueSegments;
+            while (chainsIt.hasNext) {
+                const chainSegment = chainsIt.move();
+                const residuesIt = Segmentation.transientSegments(residues, set, chainSegment);
+                while (residuesIt.hasNext) {
+                    const residueSegment = residuesIt.move();
+                    for (let j = residueSegment.start, _j = residueSegment.end; j < _j; j++) {
+                        l.atomIndex = OrdSet.getAt(set, j);
+                        s += p(l);
+                    }
+                }
+            }
+        }
+
+        return s;
+    }
+
+    function sumPropertyResidue(structure: Structure, p: Property<number>) {
+        const { atoms, units } = structure;
+        const unitIds = AtomSet.unitIds(atoms);
+        const l = Property.createLocation();
+
+        let s = 0;
+
+        for (let i = 0, _i = unitIds.length; i < _i; i++) {
+            const unit = units[unitIds[i]];
+            l.unit = unit;
+            const set = AtomSet.unitGetByIndex(atoms, i);
+            const residuesIt = Segmentation.transientSegments(unit.hierarchy.residueSegments, set);
+            while (residuesIt.hasNext) {
+                l.atomIndex = OrdSet.getAt(set, residuesIt.move().start);
                 s += p(l);
             }
         }
@@ -94,6 +151,51 @@ export namespace PropertyAccess {
         return s;
     }
 
+    function sumPropertyAtomSetIt(structure: Structure, p: Property<number>) {
+        const { atoms, units } = structure;
+
+        let s = 0;
+        const atomsIt = AtomSet.atoms(atoms);
+        const l = Property.createLocation();
+        while (atomsIt.hasNext) {
+            const a = atomsIt.move();
+            l.unit = units[Atom.unit(a)];
+            l.atomIndex = Atom.index(a);
+            s += p(l);
+        }
+        return s;
+    }
+
+    // function sumPropertySegmentedMutable(structure: Structure, p: Property<number>) {
+    //     const { atoms, units } = structure;
+    //     const unitIds = AtomSet.unitIds(atoms);
+    //     const l = Property.createLocation();
+
+    //     let s = 0;
+
+    //     for (let i = 0, _i = unitIds.length; i < _i; i++) {
+    //         const unit = units[unitIds[i]];
+    //         l.unit = unit;
+    //         const set = AtomSet.unitGetByIndex(atoms, i);
+
+    //         const chainsIt = Segmentation.transientSegments(unit.hierarchy.chainSegments, set);
+    //         const residuesIt = Segmentation.transientSegments(unit.hierarchy.residueSegments, set);
+    //         while (chainsIt.hasNext) {
+    //             const chainSegment = chainsIt.move();
+    //             residuesIt.updateRange(chainSegment);
+    //             while (residuesIt.hasNext) {
+    //                 const residueSegment = residuesIt.move();
+    //                 for (let j = residueSegment.start, _j = residueSegment.end; j < _j; j++) {
+    //                     l.atomIndex = OrdSet.getAt(set, j);
+    //                     s += p(l);
+    //                 }
+    //             }
+    //         }
+    //     }
+
+    //     return s;
+    // }
+
     function sumDirect(structure: Structure) {
         const { atoms, units } = structure;
         const unitIds = AtomSet.unitIds(atoms);
@@ -105,7 +207,7 @@ export namespace PropertyAccess {
             const unit = units[unitId];
             const set = AtomSet.unitGetByIndex(atoms, i);
             //const { residueIndex, chainIndex } = unit;
-            const p = unit.model.conformation.atomId.value;
+            const p = unit.conformation.atomId.value;
             for (let j = 0, _j = OrdSet.size(set); j < _j; j++) {
                 const aI = OrdSet.getAt(set, j);
                 s += p(aI);
@@ -141,23 +243,40 @@ export namespace PropertyAccess {
     // }
 
     export async function run() {
-        const { structures, models } = await readCIF('./examples/1cbs_full.bcif');
+        //const { structures, models } = await readCIF('./examples/1cbs_full.bcif');
+        const { structures, models } = await readCIF('e:/test/quick/1jj2_full.bcif');
+        //const { structures, models } = await readCIF('e:/test/quick/3j3q_updated.cif');
+
+        console.log('parsed');
 
         console.log(baseline(models[0]));
         console.log(baselineRaw(models[0]));
-        console.log(sumProperty(structures[0], l => l.unit.model.conformation.atomId.value(l.atomIndex), 0));
-        console.log(sumProperty(structures[0], Property.cachedAtomColumn(m => m.conformation.atomId), 0));
+        console.log(sumProperty(structures[0], l => l.unit.model.conformation.atomId.value(l.atomIndex)));
+        console.log(sumPropertySegmented(structures[0], l => l.unit.model.conformation.atomId.value(l.atomIndex)));
+        //console.log(sumPropertySegmentedMutable(structures[0], l => l.unit.model.conformation.atomId.value(l.atomIndex)));
+        console.log(sumPropertyAtomSetIt(structures[0], l => l.unit.model.conformation.atomId.value(l.atomIndex)));
+        console.log(sumProperty(structures[0], Property.cachedAtomColumn(m => m.conformation.atomId)));
         console.log(sumDirect(structures[0]));
+        console.log('r', sumPropertyResidue(structures[0], l => l.unit.hierarchy.residues.auth_seq_id.value(l.unit.residueIndex[l.atomIndex])));
 
-        const col = models[0].conformation.atomId.value;
+        //const col = models[0].conformation.atomId.value;
         const suite = new B.Suite();
         suite
-            .add('baseline raw', () =>  baselineRaw(models[0]))
+            //.add('test int', () => sumProperty(structures[0], l => col(l.atomIndex)))
+            // .add('baseline raw', () =>  baselineRaw(models[0]))
+            .add('sum residue', () => sumPropertyResidue(structures[0], l => l.unit.hierarchy.residues.auth_seq_id.value(l.unit.residueIndex[l.atomIndex])))
+
             .add('baseline', () =>  baseline(models[0]))
             .add('direct', () =>  sumDirect(structures[0]))
-            .add('normal int', () => sumProperty(structures[0], l => l.unit.model.conformation.atomId.value(l.atomIndex), 0))
-            .add('test int', () => sumProperty(structures[0], l => col(l.atomIndex), 0))
-            .add('cached int', () => sumProperty(structures[0], Property.cachedAtomColumn(m => m.conformation.atomId), 0))
+            //.add('normal int', () => sumProperty(structures[0], l => l.unit.model.conformation.atomId.value(l.atomIndex)))
+            //.add('atom set it int', () => sumPropertyAtomSetIt(structures[0], l => l.unit.conformation.atomId.value(l.atomIndex)))
+            // .add('segmented faster int', () => sumPropertySegmented(structures[0], l => l.unit.conformation.atomId.value(l.atomIndex)))
+            // .add('faster int', () => sumProperty(structures[0], l => l.unit.conformation.atomId.value(l.atomIndex)))
+            .add('segmented faster _x', () => sumPropertySegmented(structures[0], l => l.unit.conformation.__x[l.atomIndex]))
+            .add('faster _x', () => sumProperty(structures[0], l => l.unit.conformation.__x[l.atomIndex] +  l.unit.conformation.__y[l.atomIndex] +  l.unit.conformation.__z[l.atomIndex]))
+            //.add('segmented mut faster int', () => sumPropertySegmentedMutable(structures[0], l => l.unit.conformation.atomId.value(l.atomIndex)))
+            //.add('normal shortcut int', () => sumProperty(structures[0], l => l.conformation.atomId.value(l.atomIndex)))
+            //.add('cached int', () => sumProperty(structures[0], Property.cachedAtomColumn(m => m.conformation.atomId)))
             //.add('concat str', () => concatProperty(structures[0], l => l.unit.model.hierarchy.atoms.auth_atom_id.value(l.atomIndex)))
             //.add('cached concat str', () => concatProperty(structures[0], Property.cachedAtomColumn(m => m.hierarchy.atoms.auth_atom_id)))
             .on('cycle', (e: any) => console.log(String(e.target)))