molstar
Version:
A comprehensive macromolecular library.
253 lines (252 loc) • 11.5 kB
JavaScript
;
/**
* Copyright (c) 2018 mol* contributors, licensed under MIT, See LICENSE file for more info.
*
* @author Alexander Rose <alexander.rose@weirdbyte.de>
* @author David Sehnal <david.sehnal@gmail.com>
*/
Object.defineProperty(exports, "__esModule", { value: true });
exports.readCifFile = readCifFile;
exports.atomLabel = atomLabel;
exports.residueLabel = residueLabel;
exports.printSecStructure = printSecStructure;
exports.printBonds = printBonds;
exports.printSequence = printSequence;
exports.printRings = printRings;
exports.printUnits = printUnits;
exports.printSymmetryInfo = printSymmetryInfo;
exports.printModelStats = printModelStats;
exports.getModelsAndStructure = getModelsAndStructure;
const tslib_1 = require("tslib");
const argparse = tslib_1.__importStar(require("argparse"));
require('util.promisify').shim();
const structure_1 = require("../../mol-model/structure");
// import { Run, Progress } from '../../mol-task'
const int_1 = require("../../mol-data/int");
const helpers_1 = require("./helpers");
const linear_algebra_1 = require("../../mol-math/linear-algebra");
const mmcif_1 = require("../../mol-model-formats/structure/mmcif");
const sequence_1 = require("../../mol-model/sequence");
const secondary_structure_1 = require("../../mol-model-formats/structure/property/secondary-structure");
const symmetry_1 = require("../../mol-model-formats/structure/property/symmetry");
const mol_task_1 = require("../../mol-task");
async function downloadFromPdb(pdb) {
// `https://files.rcsb.org/download/${pdb}.cif`
const parsed = await (0, helpers_1.downloadCif)(`http://www.ebi.ac.uk/pdbe/static/entry/${pdb}_updated.cif`, false);
return parsed.blocks[0];
}
async function readCifFile(path) {
const parsed = await (0, helpers_1.openCif)(path);
return parsed.blocks[0];
}
function atomLabel(model, aI) {
const { atoms, residues, chains, residueAtomSegments, chainAtomSegments } = model.atomicHierarchy;
const { label_atom_id, label_comp_id } = atoms;
const { label_seq_id } = residues;
const { label_asym_id } = chains;
const rI = residueAtomSegments.index[aI];
const cI = chainAtomSegments.index[aI];
return `${label_asym_id.value(cI)} ${label_comp_id.value(aI)} ${label_seq_id.value(rI)} ${label_atom_id.value(aI)}`;
}
function residueLabel(model, rI) {
const { atoms, residues, chains, residueAtomSegments, chainAtomSegments } = model.atomicHierarchy;
const { label_comp_id } = atoms;
const { label_seq_id } = residues;
const { label_asym_id } = chains;
const aI = residueAtomSegments.offsets[rI];
const cI = chainAtomSegments.index[aI];
return `${label_asym_id.value(cI)} ${label_comp_id.value(aI)} ${label_seq_id.value(rI)}`;
}
function printSecStructure(model) {
console.log('\nSecondary Structure\n=============');
const { residues } = model.atomicHierarchy;
const secondaryStructure = secondary_structure_1.ModelSecondaryStructure.Provider.get(model);
if (!secondaryStructure)
return;
const { key, elements } = secondaryStructure;
const count = residues._rowCount;
let rI = 0;
while (rI < count) {
const start = rI;
while (rI < count && key[start] === key[rI])
rI++;
rI--;
const e = elements[key[start]];
if (e.kind !== 'none')
console.log(`${e.kind}: ${residueLabel(model, start)} - ${residueLabel(model, rI)}`);
rI++;
}
}
function printBonds(structure, showIntra, showInter) {
if (showIntra) {
console.log('\nIntra Unit Bonds\n=============');
for (const unit of structure.units) {
if (!structure_1.Unit.isAtomic(unit))
continue;
const elements = unit.elements;
const { a, b, edgeCount } = unit.bonds;
const { model } = unit;
if (!edgeCount)
continue;
for (let bI = 0, _bI = edgeCount * 2; bI < _bI; bI++) {
const x = a[bI], y = b[bI];
if (x >= y)
continue;
console.log(`${atomLabel(model, elements[x])} -- ${atomLabel(model, elements[y])}`);
}
}
}
if (showInter) {
console.log('\nInter Unit Bonds\n=============');
const bonds = structure.interUnitBonds;
for (const unit of structure.units) {
if (!structure_1.Unit.isAtomic(unit))
continue;
for (const pairBonds of bonds.getConnectedUnits(unit.id)) {
if (!pairBonds.areUnitsOrdered || pairBonds.edgeCount === 0)
continue;
const { unitA, unitB, edgeCount } = pairBonds;
const uA = structure.unitMap.get(unitA);
const uB = structure.unitMap.get(unitB);
console.log(`${unitA} - ${unitB}: ${edgeCount} bond(s)`);
for (const aI of pairBonds.connectedIndices) {
for (const bond of pairBonds.getEdges(aI)) {
console.log(`${atomLabel(uA.model, uA.elements[aI])} -- ${atomLabel(uB.model, uB.elements[bond.indexB])}`);
}
}
}
}
}
}
function printSequence(model) {
console.log('\nSequence\n=============');
const { byEntityKey } = model.sequence;
for (const key of Object.keys(byEntityKey)) {
const { sequence, entityId } = byEntityKey[+key];
const { seqId, compId } = sequence;
console.log(`${entityId} (${sequence.kind} ${seqId.value(0)}, ${seqId.value(seqId.rowCount - 1)}) (${compId.value(0)}, ${compId.value(compId.rowCount - 1)})`);
console.log(`${sequence_1.Sequence.getSequenceString(sequence)}`);
}
console.log();
}
function printRings(structure) {
console.log('\nRings\n=============');
for (const unit of structure.units) {
if (!structure_1.Unit.isAtomic(unit))
continue;
const { all, byFingerprint } = unit.rings;
const fps = [];
for (let i = 0, _i = Math.min(5, all.length); i < _i; i++) {
fps[fps.length] = structure_1.UnitRing.fingerprint(unit, all[i]);
}
if (all.length > 5)
fps.push('...');
console.log(`Unit ${unit.id}, ${all.length} ring(s), ${byFingerprint.size} different fingerprint(s).\n ${fps.join(', ')}`);
}
console.log();
}
function printUnits(structure) {
console.log('\nUnits\n=============');
const l = structure_1.StructureElement.Location.create(structure);
for (const unit of structure.units) {
l.unit = unit;
const elements = unit.elements;
const size = int_1.OrderedSet.size(elements);
if (structure_1.Unit.isAtomic(l.unit)) {
console.log(`Atomic unit ${unit.id} ${unit.conformation.operator.name}: ${size} elements`);
}
else if (structure_1.Unit.isCoarse(l.unit)) {
console.log(`Coarse unit ${unit.id} ${unit.conformation.operator.name} (${structure_1.Unit.isSpheres(l.unit) ? 'spheres' : 'gaussians'}): ${size} elements.`);
const props = structure_1.StructureProperties.coarse;
const modelSeq = l.unit.model.sequence;
for (let j = 0, _j = Math.min(size, 3); j < _j; j++) {
l.element = int_1.OrderedSet.getAt(elements, j);
const residues = [];
const start = props.seq_id_begin(l), end = props.seq_id_end(l);
const compId = modelSeq.byEntityKey[props.entityKey(l)].sequence.compId.value;
for (let e = start; e <= end; e++)
residues.push(compId(e));
console.log(`${props.asym_id(l)}:${start}-${end} (${residues.join('-')}) ${props.asym_id(l)} [${props.x(l).toFixed(2)}, ${props.y(l).toFixed(2)}, ${props.z(l).toFixed(2)}]`);
}
if (size > 3)
console.log(`...`);
}
}
}
function printSymmetryInfo(model) {
console.log('\nSymmetry Info\n=============');
const symmetry = symmetry_1.ModelSymmetry.Provider.get(model);
if (!symmetry)
return;
const { size, anglesInRadians } = symmetry.spacegroup.cell;
console.log(`Spacegroup: ${symmetry.spacegroup.name} size: ${linear_algebra_1.Vec3.toString(size)} angles: ${linear_algebra_1.Vec3.toString(anglesInRadians)}`);
console.log(`Assembly names: ${symmetry.assemblies.map(a => a.id).join(', ')}`);
// NCS example: 1auy
console.log(`NCS operators: ${symmetry.ncsOperators && symmetry.ncsOperators.map(a => a.name).join(', ')}`);
}
async function printModelStats(models) {
console.log('\nModels\n=============');
for (let i = 0; i < models.frameCount; i++) {
const m = await mol_task_1.Task.resolveInContext(models.getFrameAtIndex(i));
if (m.coarseHierarchy.isDefined) {
console.log(`${m.label} ${m.modelNum}: ${m.atomicHierarchy.atoms._rowCount} atom(s), ${m.coarseHierarchy.spheres.count} sphere(s), ${m.coarseHierarchy.gaussians.count} gaussian(s)`);
}
else {
console.log(`${m.label} ${m.modelNum}: ${m.atomicHierarchy.atoms._rowCount} atom(s)`);
}
}
console.log();
}
async function getModelsAndStructure(frame) {
const models = await (0, mmcif_1.trajectoryFromMmCIF)(frame).run();
const structure = structure_1.Structure.ofModel(models.representative);
return { models, structure };
}
async function run(frame, args) {
const { models, structure } = await getModelsAndStructure(frame);
if (args.models)
printModelStats(models);
if (args.seq)
printSequence(models.representative);
if (args.units)
printUnits(structure);
if (args.sym)
printSymmetryInfo(models.representative);
if (args.rings)
printRings(structure);
if (args.intraBonds)
printBonds(structure, true, false);
if (args.interBonds)
printBonds(structure, false, true);
if (args.sec)
printSecStructure(models.representative);
}
async function runDL(pdb, args) {
const mmcif = await downloadFromPdb(pdb);
run(mmcif, args);
}
async function runFile(filename, args) {
const mmcif = await readCifFile(filename);
run(mmcif, args);
}
const parser = new argparse.ArgumentParser({
add_help: true,
description: 'Print info about a structure, mainly to test and showcase the mol-model module'
});
parser.add_argument('--download', '-d', { help: 'Pdb entry id' });
parser.add_argument('--file', '-f', { help: 'filename' });
parser.add_argument('--models', { help: 'print models info', action: 'store_true' });
parser.add_argument('--seq', { help: 'print sequence', action: 'store_true' });
parser.add_argument('--units', { help: 'print units', action: 'store_true' });
parser.add_argument('--sym', { help: 'print symmetry', action: 'store_true' });
parser.add_argument('--rings', { help: 'print rings', action: 'store_true' });
parser.add_argument('--intraBonds', { help: 'print intra unit bonds', action: 'store_true' });
parser.add_argument('--interBonds', { help: 'print inter unit bonds', action: 'store_true' });
parser.add_argument('--mod', { help: 'print modified residues', action: 'store_true' });
parser.add_argument('--sec', { help: 'print secoundary structure', action: 'store_true' });
const args = parser.parse_args();
if (args.download)
runDL(args.download, args);
else if (args.file)
runFile(args.file, args);