molstar
Version:
A comprehensive macromolecular library.
351 lines • 17.6 kB
JavaScript
"use strict";
/**
* Copyright (c) 2017-2019 mol* contributors, licensed under MIT, See LICENSE file for more info.
*
* @author David Sehnal <david.sehnal@gmail.com>
* @author Alexander Rose <alexander.rose@weirdbyte.de>
*/
Object.defineProperty(exports, "__esModule", { value: true });
exports.bondedAtomicPairs = exports.querySelection = exports.rings = exports.atoms = exports.chains = exports.residues = exports.all = exports.none = void 0;
var tslib_1 = require("tslib");
var generic_1 = require("../../../../mol-data/generic");
var int_1 = require("../../../../mol-data/int");
var structure_1 = require("../../structure");
var structure_2 = require("../../structure/structure");
var selection_1 = require("../selection");
var builders_1 = require("../utils/builders");
var structure_set_1 = require("../utils/structure-set");
var none = function (ctx) { return selection_1.StructureSelection.Sequence(ctx.inputStructure, []); };
exports.none = none;
var all = function (ctx) { return selection_1.StructureSelection.Singletons(ctx.inputStructure, ctx.inputStructure); };
exports.all = all;
function residues(params) { return atoms((0, tslib_1.__assign)((0, tslib_1.__assign)({}, params), { groupBy: function (ctx) { return structure_1.StructureProperties.residue.key(ctx.element); } })); }
exports.residues = residues;
function chains(params) { return atoms((0, tslib_1.__assign)((0, tslib_1.__assign)({}, params), { groupBy: function (ctx) { return structure_1.StructureProperties.chain.key(ctx.element); } })); }
exports.chains = chains;
function _true(ctx) { return true; }
function _zero(ctx) { return 0; }
function atoms(params) {
if (!params || (!params.atomTest && !params.residueTest && !params.chainTest && !params.entityTest && !params.unitTest && !params.groupBy))
return exports.all;
if (!!params.atomTest && !params.residueTest && !params.chainTest && !params.entityTest && !params.unitTest && !params.groupBy)
return atomGroupsLinear(params.atomTest);
var normalized = {
unitTest: params.unitTest || _true,
entityTest: params.entityTest || _true,
chainTest: params.chainTest || _true,
residueTest: params.residueTest || _true,
atomTest: params.atomTest || _true,
groupBy: params.groupBy || _zero,
};
if (!params.groupBy)
return atomGroupsSegmented(normalized);
return atomGroupsGrouped(normalized);
}
exports.atoms = atoms;
function atomGroupsLinear(atomTest) {
return function query_atomGroupsLinear(ctx) {
var inputStructure = ctx.inputStructure;
var units = inputStructure.units;
var l = ctx.pushCurrentElement();
var builder = inputStructure.subsetBuilder(true);
l.structure = inputStructure;
for (var _a = 0, units_1 = units; _a < units_1.length; _a++) {
var unit = units_1[_a];
l.unit = unit;
var elements = unit.elements;
builder.beginUnit(unit.id);
for (var j = 0, _j = elements.length; j < _j; j++) {
l.element = elements[j];
if (atomTest(ctx))
builder.addElement(l.element);
}
builder.commitUnit();
ctx.throwIfTimedOut();
}
ctx.popCurrentElement();
return selection_1.StructureSelection.Singletons(inputStructure, builder.getStructure());
};
}
function atomGroupsSegmented(_a) {
var unitTest = _a.unitTest, entityTest = _a.entityTest, chainTest = _a.chainTest, residueTest = _a.residueTest, atomTest = _a.atomTest;
return function query_atomGroupsSegmented(ctx) {
var inputStructure = ctx.inputStructure;
var units = inputStructure.units;
var l = ctx.pushCurrentElement();
var builder = inputStructure.subsetBuilder(true);
var chainLevel = residueTest === _true && atomTest === _true;
var residueLevel = atomTest === _true;
l.structure = inputStructure;
for (var _a = 0, units_2 = units; _a < units_2.length; _a++) {
var unit = units_2[_a];
l.unit = unit;
if (!unitTest(ctx))
continue;
var elements = unit.elements, model = unit.model;
builder.beginUnit(unit.id);
if (unit.kind === 0 /* Atomic */) {
var chainsIt = int_1.Segmentation.transientSegments(unit.model.atomicHierarchy.chainAtomSegments, elements);
var residuesIt = int_1.Segmentation.transientSegments(unit.model.atomicHierarchy.residueAtomSegments, elements);
while (chainsIt.hasNext) {
var chainSegment = chainsIt.move();
l.element = elements[chainSegment.start];
// test entity and chain
if (!entityTest(ctx) || !chainTest(ctx))
continue;
if (chainLevel) {
builder.addElementRange(elements, chainSegment.start, chainSegment.end);
continue;
}
residuesIt.setSegment(chainSegment);
while (residuesIt.hasNext) {
var residueSegment = residuesIt.move();
l.element = elements[residueSegment.start];
// test residue
if (!residueTest(ctx))
continue;
if (residueLevel) {
builder.addElementRange(elements, residueSegment.start, residueSegment.end);
continue;
}
for (var j = residueSegment.start, _j = residueSegment.end; j < _j; j++) {
l.element = elements[j];
// test atom
if (atomTest(ctx)) {
builder.addElement(l.element);
}
}
}
}
}
else {
var chainElementSegments = (1 /* Spheres */ ? model.coarseHierarchy.spheres : model.coarseHierarchy.gaussians).chainElementSegments;
var chainsIt = int_1.Segmentation.transientSegments(chainElementSegments, elements);
while (chainsIt.hasNext) {
var chainSegment = chainsIt.move();
l.element = elements[chainSegment.start];
// test entity and chain
if (!entityTest(ctx) || !chainTest(ctx))
continue;
if (chainLevel) {
builder.addElementRange(elements, chainSegment.start, chainSegment.end);
continue;
}
for (var j = chainSegment.start, _j = chainSegment.end; j < _j; j++) {
l.element = elements[j];
// test residue/coarse element
if (residueTest(ctx)) {
builder.addElement(l.element);
}
}
}
}
builder.commitUnit();
ctx.throwIfTimedOut();
}
ctx.popCurrentElement();
return selection_1.StructureSelection.Singletons(inputStructure, builder.getStructure());
};
}
function atomGroupsGrouped(_a) {
var unitTest = _a.unitTest, entityTest = _a.entityTest, chainTest = _a.chainTest, residueTest = _a.residueTest, atomTest = _a.atomTest, groupBy = _a.groupBy;
return function query_atomGroupsGrouped(ctx) {
var inputStructure = ctx.inputStructure;
var units = inputStructure.units;
var l = ctx.pushCurrentElement();
var builder = new builders_1.LinearGroupingBuilder(inputStructure);
l.structure = inputStructure;
for (var _a = 0, units_3 = units; _a < units_3.length; _a++) {
var unit = units_3[_a];
l.unit = unit;
if (!unitTest(ctx))
continue;
var elements = unit.elements, model = unit.model;
if (unit.kind === 0 /* Atomic */) {
var chainsIt = int_1.Segmentation.transientSegments(model.atomicHierarchy.chainAtomSegments, elements);
var residuesIt = int_1.Segmentation.transientSegments(model.atomicHierarchy.residueAtomSegments, elements);
while (chainsIt.hasNext) {
var chainSegment = chainsIt.move();
l.element = elements[chainSegment.start];
// test entity and chain
if (!entityTest(ctx) || !chainTest(ctx))
continue;
residuesIt.setSegment(chainSegment);
while (residuesIt.hasNext) {
var residueSegment = residuesIt.move();
l.element = elements[residueSegment.start];
// test residue
if (!residueTest(ctx))
continue;
for (var j = residueSegment.start, _j = residueSegment.end; j < _j; j++) {
l.element = elements[j];
// test atom
if (atomTest(ctx)) {
builder.add(groupBy(ctx), unit.id, l.element);
}
}
}
}
}
else {
var chainElementSegments = (1 /* Spheres */ ? model.coarseHierarchy.spheres : model.coarseHierarchy.gaussians).chainElementSegments;
var chainsIt = int_1.Segmentation.transientSegments(chainElementSegments, elements);
while (chainsIt.hasNext) {
var chainSegment = chainsIt.move();
l.element = elements[chainSegment.start];
// test entity and chain
if (!entityTest(ctx) || !chainTest(ctx))
continue;
for (var j = chainSegment.start, _j = chainSegment.end; j < _j; j++) {
l.element = elements[j];
// test residue/coarse element
if (residueTest(ctx)) {
builder.add(groupBy(ctx), unit.id, l.element);
}
}
}
}
ctx.throwIfTimedOut();
}
ctx.popCurrentElement();
return builder.getSelection();
};
}
function getRingStructure(unit, ring, inputStructure) {
var elements = new Int32Array(ring.length);
for (var i = 0, _i = ring.length; i < _i; i++)
elements[i] = unit.elements[ring[i]];
return structure_2.Structure.create([unit.getChild(int_1.SortedArray.ofSortedArray(elements))], { parent: inputStructure });
}
function rings(fingerprints, onlyAromatic) {
return function query_rings(ctx) {
var units = ctx.inputStructure.units;
var ret = selection_1.StructureSelection.LinearBuilder(ctx.inputStructure);
if (!fingerprints || fingerprints.length === 0) {
for (var _a = 0, units_4 = units; _a < units_4.length; _a++) {
var u = units_4[_a];
if (!structure_1.Unit.isAtomic(u))
continue;
if (onlyAromatic) {
for (var _b = 0, _c = u.rings.aromaticRings; _b < _c.length; _b++) {
var r = _c[_b];
ret.add(getRingStructure(u, u.rings.all[r], ctx.inputStructure));
}
}
else {
for (var _d = 0, _e = u.rings.all; _d < _e.length; _d++) {
var r = _e[_d];
ret.add(getRingStructure(u, r, ctx.inputStructure));
}
}
}
}
else {
var uniqueFps = generic_1.UniqueArray.create();
for (var i = 0; i < fingerprints.length; i++)
generic_1.UniqueArray.add(uniqueFps, fingerprints[i], fingerprints[i]);
for (var _f = 0, units_5 = units; _f < units_5.length; _f++) {
var u = units_5[_f];
if (!structure_1.Unit.isAtomic(u))
continue;
var rings_1 = u.rings;
for (var _g = 0, _h = uniqueFps.array; _g < _h.length; _g++) {
var fp = _h[_g];
if (!rings_1.byFingerprint.has(fp))
continue;
for (var _k = 0, _l = rings_1.byFingerprint.get(fp); _k < _l.length; _k++) {
var r = _l[_k];
if (onlyAromatic && !rings_1.aromaticRings.includes(r))
continue;
ret.add(getRingStructure(u, rings_1.all[r], ctx.inputStructure));
}
}
}
}
return ret.getSelection();
};
}
exports.rings = rings;
function querySelection(selection, query, inComplement) {
if (inComplement === void 0) { inComplement = false; }
return function query_querySelection(ctx) {
var targetSel = selection(ctx);
if (selection_1.StructureSelection.structureCount(targetSel) === 0)
return targetSel;
var target = inComplement
? (0, structure_set_1.structureSubtract)(ctx.inputStructure, selection_1.StructureSelection.unionStructure(targetSel))
: selection_1.StructureSelection.unionStructure(targetSel);
if (target.elementCount === 0)
return selection_1.StructureSelection.Empty(ctx.inputStructure);
ctx.throwIfTimedOut();
ctx.pushInputStructure(target);
var result = query(ctx);
ctx.popInputStructure();
return selection_1.StructureSelection.withInputStructure(result, ctx.inputStructure);
};
}
exports.querySelection = querySelection;
function bondedAtomicPairs(bondTest) {
return function query_bondedAtomicPairs(ctx) {
var structure = ctx.inputStructure;
var interBonds = structure.interUnitBonds;
// Note: each bond is called twice, that's why we need the unique builder.
var ret = selection_1.StructureSelection.UniqueBuilder(ctx.inputStructure);
ctx.pushCurrentBond();
var atomicBond = ctx.atomicBond;
atomicBond.setTestFn(bondTest);
atomicBond.setStructure(structure);
// Process intra unit bonds
for (var _a = 0, _b = structure.units; _a < _b.length; _a++) {
var unit = _b[_a];
if (unit.kind !== 0 /* Atomic */)
continue;
var _c = unit.bonds, intraBondOffset = _c.offset, intraBondB = _c.b, _d = _c.edgeProps, flags = _d.flags, order = _d.order;
atomicBond.a.unit = unit;
atomicBond.b.unit = unit;
for (var i = 0, _i = unit.elements.length; i < _i; i++) {
atomicBond.aIndex = i;
atomicBond.a.element = unit.elements[i];
// check intra unit bonds
for (var lI = intraBondOffset[i], _lI = intraBondOffset[i + 1]; lI < _lI; lI++) {
atomicBond.bIndex = intraBondB[lI];
atomicBond.b.element = unit.elements[intraBondB[lI]];
atomicBond.type = flags[lI];
atomicBond.order = order[lI];
// No need to "swap test" because each bond direction will be visited eventually.
if (atomicBond.test(ctx, false)) {
var b = structure.subsetBuilder(false);
b.beginUnit(unit.id);
b.addElement(atomicBond.a.element);
b.addElement(atomicBond.b.element);
b.commitUnit();
ret.add(b.getStructure());
}
}
}
}
// Process inter unit bonds
for (var _e = 0, _f = interBonds.edges; _e < _f.length; _e++) {
var bond = _f[_e];
atomicBond.a.unit = structure.unitMap.get(bond.unitA);
atomicBond.a.element = atomicBond.a.unit.elements[bond.indexA];
atomicBond.aIndex = bond.indexA;
atomicBond.b.unit = structure.unitMap.get(bond.unitA);
atomicBond.b.element = atomicBond.b.unit.elements[bond.indexB];
atomicBond.bIndex = bond.indexB;
atomicBond.order = bond.props.order;
atomicBond.type = bond.props.flag;
// No need to "swap test" because each bond direction will be visited eventually.
if (atomicBond.test(ctx, false)) {
var b = structure.subsetBuilder(false);
b.addToUnit(atomicBond.a.unit.id, atomicBond.a.element);
b.addToUnit(atomicBond.b.unit.id, atomicBond.b.element);
ret.add(b.getStructure());
}
}
ctx.popCurrentBond();
return ret.getSelection();
};
}
exports.bondedAtomicPairs = bondedAtomicPairs;
//# sourceMappingURL=generators.js.map