molstar
Version:
A comprehensive macromolecular library.
160 lines (159 loc) • 8.63 kB
JavaScript
/**
* Copyright (c) 2020-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
*
* @author Alexander Rose <alexander.rose@weirdbyte.de>
*/
import { __awaiter, __generator } from "tslib";
import { Column, Table } from '../../mol-data/db';
import { Task } from '../../mol-task';
import { createModels } from './basic/parser';
import { BasicSchema, createBasic } from './basic/schema';
import { ComponentBuilder } from './common/component';
import { EntityBuilder } from './common/entity';
import { IndexPairBonds } from './property/bonds/index-pair';
import { AtomPartialCharge } from './property/partial-charge';
import { ArrayTrajectory } from '../../mol-model/structure';
import { guessElementSymbolString } from './util';
import { ModelSymmetry } from './property/symmetry';
import { Spacegroup, SpacegroupCell } from '../../mol-math/geometry';
import { Vec3 } from '../../mol-math/linear-algebra';
function getModels(mol2, ctx) {
return __awaiter(this, void 0, void 0, function () {
var models, i, il, _a, molecule, atoms, bonds, crysin, A, type_symbol, hasAtomType, i_1, i_2, atom_site, entityBuilder, componentBuilder, i_3, il_1, basic, _models, indexA, indexB, key, order, flag, pairBonds, first, symmetry;
return __generator(this, function (_b) {
switch (_b.label) {
case 0:
models = [];
i = 0, il = mol2.structures.length;
_b.label = 1;
case 1:
if (!(i < il)) return [3 /*break*/, 4];
_a = mol2.structures[i], molecule = _a.molecule, atoms = _a.atoms, bonds = _a.bonds, crysin = _a.crysin;
A = Column.ofConst('A', atoms.count, Column.Schema.str);
type_symbol = new Array(atoms.count);
hasAtomType = false;
for (i_1 = 0; i_1 < atoms.count; ++i_1) {
if (atoms.atom_type.value(i_1).includes('.')) {
hasAtomType = true;
break;
}
}
for (i_2 = 0; i_2 < atoms.count; ++i_2) {
type_symbol[i_2] = hasAtomType
? atoms.atom_type.value(i_2).split('.')[0].toUpperCase()
: guessElementSymbolString(atoms.atom_name.value(i_2), atoms.subst_name.value(i_2));
}
atom_site = Table.ofPartialColumns(BasicSchema.atom_site, {
auth_asym_id: A,
auth_atom_id: Column.asArrayColumn(atoms.atom_name),
auth_comp_id: atoms.subst_name,
auth_seq_id: atoms.subst_id,
Cartn_x: Column.asArrayColumn(atoms.x, Float32Array),
Cartn_y: Column.asArrayColumn(atoms.y, Float32Array),
Cartn_z: Column.asArrayColumn(atoms.z, Float32Array),
id: Column.asArrayColumn(atoms.atom_id),
label_asym_id: A,
label_atom_id: Column.asArrayColumn(atoms.atom_name),
label_comp_id: atoms.subst_name,
label_seq_id: atoms.subst_id,
label_entity_id: Column.ofConst('1', atoms.count, Column.Schema.str),
occupancy: Column.ofConst(1, atoms.count, Column.Schema.float),
type_symbol: Column.ofStringArray(type_symbol),
pdbx_PDB_model_num: Column.ofConst(i, atoms.count, Column.Schema.int),
}, atoms.count);
entityBuilder = new EntityBuilder();
entityBuilder.setNames([['MOL', molecule.mol_name || 'Unknown Entity']]);
entityBuilder.getEntityId('MOL', 0 /* MoleculeType.Unknown */, 'A');
componentBuilder = new ComponentBuilder(atoms.subst_id, atoms.atom_name);
for (i_3 = 0, il_1 = atoms.subst_name.rowCount; i_3 < il_1; ++i_3) {
componentBuilder.add(atoms.subst_name.value(i_3), i_3);
}
basic = createBasic({
entity: entityBuilder.getEntityTable(),
chem_comp: componentBuilder.getChemCompTable(),
atom_site: atom_site
});
return [4 /*yield*/, createModels(basic, Mol2Format.create(mol2), ctx)];
case 2:
_models = _b.sent();
if (_models.frameCount > 0) {
indexA = Column.ofIntArray(Column.mapToArray(bonds.origin_atom_id, function (x) { return x - 1; }, Int32Array));
indexB = Column.ofIntArray(Column.mapToArray(bonds.target_atom_id, function (x) { return x - 1; }, Int32Array));
key = bonds.bond_id;
order = Column.ofIntArray(Column.mapToArray(bonds.bond_type, function (x) {
switch (x) {
case 'ar': // aromatic
case 'am': // amide
case 'un': // unknown
return 1;
case 'du': // dummy
case 'nc': // not connected
return 0;
default:
return parseInt(x);
}
}, Int8Array));
flag = Column.ofIntArray(Column.mapToArray(bonds.bond_type, function (x) {
switch (x) {
case 'ar': // aromatic
case 'am': // amide
return 16 /* BondType.Flag.Aromatic */ | 1 /* BondType.Flag.Covalent */;
case 'du': // dummy
case 'nc': // not connected
return 0 /* BondType.Flag.None */;
case 'un': // unknown
default:
return 1 /* BondType.Flag.Covalent */;
}
}, Int8Array));
pairBonds = IndexPairBonds.fromData({ pairs: { key: key, indexA: indexA, indexB: indexB, order: order, flag: flag }, count: atoms.count }, { maxDistance: crysin ? -1 : Infinity });
first = _models.representative;
IndexPairBonds.Provider.set(first, pairBonds);
AtomPartialCharge.Provider.set(first, {
data: atoms.charge,
type: molecule.charge_type
});
if (crysin) {
symmetry = getSymmetry(crysin);
if (symmetry)
ModelSymmetry.Provider.set(first, symmetry);
}
models.push(first);
}
_b.label = 3;
case 3:
++i;
return [3 /*break*/, 1];
case 4: return [2 /*return*/, new ArrayTrajectory(models)];
}
});
});
}
function getSymmetry(crysin) {
// TODO handle `crysin.setting`
if (crysin.setting !== 1)
return;
var spaceCell = SpacegroupCell.create(crysin.spaceGroup, Vec3.create(crysin.a, crysin.b, crysin.c), Vec3.scale(Vec3(), Vec3.create(crysin.alpha, crysin.beta, crysin.gamma), Math.PI / 180));
return {
spacegroup: Spacegroup.create(spaceCell),
assemblies: [],
isNonStandardCrystalFrame: false,
ncsOperators: []
};
}
//
export { Mol2Format };
var Mol2Format;
(function (Mol2Format) {
function is(x) {
return (x === null || x === void 0 ? void 0 : x.kind) === 'mol2';
}
Mol2Format.is = is;
function create(mol2) {
return { kind: 'mol2', name: mol2.name, data: mol2 };
}
Mol2Format.create = create;
})(Mol2Format || (Mol2Format = {}));
export function trajectoryFromMol2(mol2) {
return Task.create('Parse MOL2', function (ctx) { return getModels(mol2, ctx); });
}