molstar
Version:
A comprehensive macromolecular library.
125 lines (124 loc) • 5.65 kB
JavaScript
/**
* Copyright (c) 2019-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
*
* @author Alexander Rose <alexander.rose@weirdbyte.de>
*/
import { __awaiter, __generator } from "tslib";
import { Task } from '../../mol-task';
import { Column, Table } from '../../mol-data/db';
import { guessElementSymbolString } from './util';
import { getMoleculeType } from '../../mol-model/structure/model/types';
import { ComponentBuilder } from './common/component';
import { getChainId } from './common/util';
import { EntityBuilder } from './common/entity';
import { BasicSchema, createBasic } from './basic/schema';
import { createModels } from './basic/parser';
import { ArrayTrajectory } from '../../mol-model/structure/trajectory';
function getBasic(atoms, modelNum) {
var auth_atom_id = atoms.atomName;
var auth_comp_id = atoms.residueName;
var entityIds = new Array(atoms.count);
var asymIds = new Array(atoms.count);
var seqIds = new Uint32Array(atoms.count);
var ids = new Uint32Array(atoms.count);
var typeSymbol = new Array(atoms.count);
var entityBuilder = new EntityBuilder();
var componentBuilder = new ComponentBuilder(atoms.residueNumber, atoms.atomName);
var currentEntityId = '';
var currentAsymIndex = 0;
var currentAsymId = '';
var currentSeqId = 0;
var prevMoleculeType = 0 /* MoleculeType.Unknown */;
var prevResidueNumber = -1;
for (var i = 0, il = atoms.count; i < il; ++i) {
var residueNumber = atoms.residueNumber.value(i);
if (residueNumber !== prevResidueNumber) {
var compId = atoms.residueName.value(i);
var moleculeType = getMoleculeType(componentBuilder.add(compId, i).type, compId);
if (moleculeType !== prevMoleculeType || (residueNumber !== prevResidueNumber + 1 && !(
// gro format allows only for 5 character residueNumbers, handle overflow here
prevResidueNumber === 99999 && residueNumber === 0))) {
currentAsymId = getChainId(currentAsymIndex);
currentAsymIndex += 1;
currentSeqId = 0;
}
currentEntityId = entityBuilder.getEntityId(compId, moleculeType, currentAsymId);
currentSeqId += 1;
prevResidueNumber = residueNumber;
prevMoleculeType = moleculeType;
}
entityIds[i] = currentEntityId;
asymIds[i] = currentAsymId;
seqIds[i] = currentSeqId;
ids[i] = i;
typeSymbol[i] = guessElementSymbolString(atoms.atomName.value(i), atoms.residueName.value(i));
}
var auth_asym_id = Column.ofStringArray(asymIds);
var atom_site = Table.ofPartialColumns(BasicSchema.atom_site, {
auth_asym_id: auth_asym_id,
auth_atom_id: auth_atom_id,
auth_comp_id: auth_comp_id,
auth_seq_id: atoms.residueNumber,
Cartn_x: Column.ofFloatArray(Column.mapToArray(atoms.x, function (x) { return x * 10; }, Float32Array)),
Cartn_y: Column.ofFloatArray(Column.mapToArray(atoms.y, function (y) { return y * 10; }, Float32Array)),
Cartn_z: Column.ofFloatArray(Column.mapToArray(atoms.z, function (z) { return z * 10; }, Float32Array)),
id: Column.ofIntArray(ids),
label_asym_id: auth_asym_id,
label_atom_id: auth_atom_id,
label_comp_id: auth_comp_id,
label_seq_id: Column.ofIntArray(seqIds),
label_entity_id: Column.ofStringArray(entityIds),
occupancy: Column.ofConst(1, atoms.count, Column.Schema.float),
type_symbol: Column.ofStringArray(typeSymbol),
pdbx_PDB_model_num: Column.ofConst(modelNum, atoms.count, Column.Schema.int),
}, atoms.count);
return createBasic({
entity: entityBuilder.getEntityTable(),
chem_comp: componentBuilder.getChemCompTable(),
atom_site: atom_site
});
}
//
export { GroFormat };
var GroFormat;
(function (GroFormat) {
function is(x) {
return (x === null || x === void 0 ? void 0 : x.kind) === 'gro';
}
GroFormat.is = is;
function fromGro(gro) {
return { kind: 'gro', name: gro.structures[0].header.title, data: gro };
}
GroFormat.fromGro = fromGro;
})(GroFormat || (GroFormat = {}));
// TODO reuse static model parts when hierarchy is identical
// need to pass all gro.structures as one table into createModels
export function trajectoryFromGRO(gro) {
var _this = this;
return Task.create('Parse GRO', function (ctx) { return __awaiter(_this, void 0, void 0, function () {
var format, models, i, il, basic, m;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
format = GroFormat.fromGro(gro);
models = [];
i = 0, il = gro.structures.length;
_a.label = 1;
case 1:
if (!(i < il)) return [3 /*break*/, 4];
basic = getBasic(gro.structures[i].atoms, i + 1);
return [4 /*yield*/, createModels(basic, format, ctx)];
case 2:
m = _a.sent();
if (m.frameCount === 1) {
models.push(m.representative);
}
_a.label = 3;
case 3:
++i;
return [3 /*break*/, 1];
case 4: return [2 /*return*/, new ArrayTrajectory(models)];
}
});
}); });
}