diff --git a/src/mol-base/collections/column.ts b/src/mol-base/collections/column.ts
index 7118f96d01a9eb1fe7d14650b420e9cd1444831d..0a8ecf4cd5fae26b8408399239d2895e8dcfef12 100644
--- a/src/mol-base/collections/column.ts
+++ b/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;
}
diff --git a/src/mol-base/collections/integer/_spec/segmentation.spec.ts b/src/mol-base/collections/integer/_spec/segmentation.spec.ts
index b3a23202610e97f58116a192b7414164242eb748..8732383fa97d9b242cac13dd23de64f6c365c3b9 100644
--- a/src/mol-base/collections/integer/_spec/segmentation.spec.ts
+++ b/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] });
+ // });
});
diff --git a/src/mol-base/collections/integer/_spec/sorted-array.spec.ts b/src/mol-base/collections/integer/_spec/sorted-array.spec.ts
index c4d2231e7dfbe0a3f69311c33957894ba59a7537..679fca68ecc0675dbe810977d291789494c8e2c0 100644
--- a/src/mol-base/collections/integer/_spec/sorted-array.spec.ts
+++ b/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)))
});
\ No newline at end of file
diff --git a/src/mol-base/collections/integer/impl/interval.ts b/src/mol-base/collections/integer/impl/interval.ts
index 2f29f47e762c32c75ba83ff52a32392f58e943d5..00354c32edac05cfc6d65a8e4d971775059de110 100644
--- a/src/mol-base/collections/integer/impl/interval.ts
+++ b/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) {
diff --git a/src/mol-base/collections/integer/impl/segmentation.ts b/src/mol-base/collections/integer/impl/segmentation.ts
index 9c8acd16fa2cea174014765bfb3834e087941a8b..1da81db5d999b298122e8488d6e0f4425e80b425 100644
--- a/src/mol-base/collections/integer/impl/segmentation.ts
+++ b/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();
}
diff --git a/src/mol-base/collections/integer/impl/sorted-array.ts b/src/mol-base/collections/integer/impl/sorted-array.ts
index aeff30732b7d5950a6d2cc253813ac9cfa9ae17e..27debf6fcd395d2d23501207579360ff66a6c349 100644
--- a/src/mol-base/collections/integer/impl/sorted-array.ts
+++ b/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;
diff --git a/src/mol-base/collections/table.ts b/src/mol-base/collections/table.ts
index ec37c4db5ad7506371b4d69a2df8fea8e58ed87e..32a7b5379211a94f5ee7d64446718b6f57561f8f 100644
--- a/src/mol-base/collections/table.ts
+++ b/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);
diff --git a/src/mol-data/model/builders/mmcif.ts b/src/mol-data/model/builders/mmcif.ts
index db97525a75432b1681d870353c9607d2a15f0284..230b6af14435cf2aaee60d5e8bea3617cfe60884 100644
--- a/src/mol-data/model/builders/mmcif.ts
+++ b/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 }),
}
}
diff --git a/src/mol-data/model/properties/conformation.ts b/src/mol-data/model/properties/conformation.ts
index f563430e3c06094f6d76aef39e0318f597589165..f023ba707ba8ae69c7262ec6d3238cc3972263de 100644
--- a/src/mol-data/model/properties/conformation.ts
+++ b/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
\ No newline at end of file
diff --git a/src/mol-data/structure/property.ts b/src/mol-data/structure/property.ts
index 4e16db1292315f8981a2ae5d51447be56675fbbe..42b85e0b6d3ae64e55000ad42a8ac3c114ae27ed 100644
--- a/src/mol-data/structure/property.ts
+++ b/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; }
diff --git a/src/mol-data/structure/unit.ts b/src/mol-data/structure/unit.ts
index c23c5f6b0ced2ef09f67154393f406f874b6b513..f80a31c4da3d65dd9832246b1f60df567f6de1d8 100644
--- a/src/mol-data/structure/unit.ts
+++ b/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
+ };
}
}
diff --git a/src/mol-io/reader/cif/binary/decoder.ts b/src/mol-io/reader/cif/binary/decoder.ts
index 2e06613900110aa4b9f463be8764b1d9453e1c45..a9e43acbe6e57941ebf93be7aef03abc35c968f6 100644
--- a/src/mol-io/reader/cif/binary/decoder.ts
+++ b/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;
}
\ No newline at end of file
diff --git a/src/perf-tests/structure.ts b/src/perf-tests/structure.ts
index 36ec3c656f94e18411dce9c18194c740e9f34ee6..ec9a406c2532cff559844e024d8b6d868c85bac5 100644
--- a/src/perf-tests/structure.ts
+++ b/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)))