molstar 3.3.1 → 3.6.0

package/lib/mol-io/reader/prmtop/parser.js

@@ -0,0 +1,168 @@
+/**
+ * Copyright (c) 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 { Task } from '../../../mol-task';
+import { Tokenizer, TokenBuilder } from '../common/text/tokenizer';
+import { ReaderResult as Result } from '../result';
+import { TokenColumnProvider as TokenColumn } from '../common/text/column/token';
+import { Column } from '../../../mol-data/db';
+// http://ambermd.org/prmtop.pdf
+// https://ambermd.org/FileFormats.php#topology
+var Pointers = {
+    'NATOM': '', 'NTYPES': '', 'NBONH': '', 'MBONA': '', 'NTHETH': '', 'MTHETA': '',
+    'NPHIH': '', 'MPHIA': '', 'NHPARM': '', 'NPARM': '', 'NNB': '', 'NRES': '',
+    'NBONA': '', 'NTHETA': '', 'NPHIA': '', 'NUMBND': '', 'NUMANG': '', 'NPTRA': '',
+    'NATYP': '', 'NPHB': '', 'IFPERT': '', 'NBPER': '', 'NGPER': '', 'NDPER': '',
+    'MBPER': '', 'MGPER': '', 'MDPER': '', 'IFBOX': '', 'NMXRS': '', 'IFCAP': '',
+    'NUMEXTRA': '', 'NCOPY': '',
+};
+var PointersNames = Object.keys(Pointers);
+var readLine = Tokenizer.readLine, markLine = Tokenizer.markLine, trim = Tokenizer.trim;
+function State(tokenizer, runtimeCtx) {
+    return {
+        tokenizer: tokenizer,
+        runtimeCtx: runtimeCtx,
+    };
+}
+function handleTitle(state) {
+    var tokenizer = state.tokenizer;
+    var title = [];
+    while (tokenizer.tokenEnd < tokenizer.length) {
+        if (tokenizer.data[tokenizer.position] === '%')
+            break;
+        var line = readLine(tokenizer).trim();
+        if (line)
+            title.push(line);
+    }
+    return title;
+}
+function handlePointers(state) {
+    var tokenizer = state.tokenizer;
+    var pointers = Object.create(null);
+    PointersNames.forEach(function (name) { pointers[name] = 0; });
+    var curIdx = 0;
+    while (tokenizer.tokenEnd < tokenizer.length) {
+        if (tokenizer.data[tokenizer.position] === '%')
+            break;
+        var line = readLine(tokenizer);
+        var n = Math.min(curIdx + 10, 32);
+        for (var i = 0; curIdx < n; ++i, ++curIdx) {
+            pointers[PointersNames[curIdx]] = parseInt(line.substring(i * 8, i * 8 + 8).trim());
+        }
+    }
+    return pointers;
+}
+function handleTokens(state, count, countPerLine, itemSize) {
+    var tokenizer = state.tokenizer;
+    var tokens = TokenBuilder.create(tokenizer.data, count * 2);
+    var curIdx = 0;
+    while (tokenizer.tokenEnd < tokenizer.length) {
+        if (tokenizer.data[tokenizer.position] === '%')
+            break;
+        tokenizer.tokenStart = tokenizer.position;
+        var n = Math.min(curIdx + countPerLine, count);
+        for (var i = 0; curIdx < n; ++i, ++curIdx) {
+            var p = tokenizer.position;
+            trim(tokenizer, tokenizer.position, tokenizer.position + itemSize);
+            TokenBuilder.addUnchecked(tokens, tokenizer.tokenStart, tokenizer.tokenEnd);
+            tokenizer.position = p + itemSize;
+        }
+        markLine(tokenizer);
+    }
+    return tokens;
+}
+function parseInternal(data, ctx) {
+    return __awaiter(this, void 0, void 0, function () {
+        var t, state, result, prevPosition, line, flag, formatLine, tokens, tokens, tokens, tokens, tokens, tokens, tokens, tokens;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    t = Tokenizer(data);
+                    state = State(t, ctx);
+                    result = Object.create(null);
+                    prevPosition = 0;
+                    _a.label = 1;
+                case 1:
+                    if (!(t.tokenEnd < t.length)) return [3 /*break*/, 4];
+                    if (!(t.position - prevPosition > 100000 && ctx.shouldUpdate)) return [3 /*break*/, 3];
+                    prevPosition = t.position;
+                    return [4 /*yield*/, ctx.update({ current: t.position, max: t.length })];
+                case 2:
+                    _a.sent();
+                    _a.label = 3;
+                case 3:
+                    line = readLine(state.tokenizer).trim();
+                    if (line.startsWith('%VERSION')) {
+                        result.version = line.substring(8).trim();
+                    }
+                    else if (line.startsWith('%FLAG')) {
+                        flag = line.substring(5).trim();
+                        formatLine = readLine(state.tokenizer).trim();
+                        if (!formatLine.startsWith('%FORMAT'))
+                            throw new Error('expected %FORMAT');
+                        if (flag === 'TITLE') {
+                            result.title = handleTitle(state);
+                        }
+                        else if (flag === 'POINTERS') {
+                            result.pointers = handlePointers(state);
+                        }
+                        else if (flag === 'ATOM_NAME') {
+                            tokens = handleTokens(state, result.pointers['NATOM'], 20, 4);
+                            result.atomName = TokenColumn(tokens)(Column.Schema.str);
+                        }
+                        else if (flag === 'CHARGE') {
+                            tokens = handleTokens(state, result.pointers['NATOM'], 5, 16);
+                            result.charge = TokenColumn(tokens)(Column.Schema.float);
+                        }
+                        else if (flag === 'MASS') {
+                            tokens = handleTokens(state, result.pointers['NATOM'], 5, 16);
+                            result.mass = TokenColumn(tokens)(Column.Schema.float);
+                        }
+                        else if (flag === 'RESIDUE_LABEL') {
+                            tokens = handleTokens(state, result.pointers['NRES'], 20, 4);
+                            result.residueLabel = TokenColumn(tokens)(Column.Schema.str);
+                        }
+                        else if (flag === 'RESIDUE_POINTER') {
+                            tokens = handleTokens(state, result.pointers['NRES'], 10, 8);
+                            result.residuePointer = TokenColumn(tokens)(Column.Schema.int);
+                        }
+                        else if (flag === 'BONDS_INC_HYDROGEN') {
+                            tokens = handleTokens(state, result.pointers['NBONH'] * 3, 10, 8);
+                            result.bondsIncHydrogen = TokenColumn(tokens)(Column.Schema.int);
+                        }
+                        else if (flag === 'BONDS_WITHOUT_HYDROGEN') {
+                            tokens = handleTokens(state, result.pointers['NBONA'] * 3, 10, 8);
+                            result.bondsWithoutHydrogen = TokenColumn(tokens)(Column.Schema.int);
+                        }
+                        else if (flag === 'RADII') {
+                            tokens = handleTokens(state, result.pointers['NATOM'], 5, 16);
+                            result.radii = TokenColumn(tokens)(Column.Schema.float);
+                        }
+                        else {
+                            while (t.tokenEnd < t.length) {
+                                if (t.data[t.position] === '%')
+                                    break;
+                                markLine(t);
+                            }
+                        }
+                    }
+                    return [3 /*break*/, 1];
+                case 4: return [2 /*return*/, Result.success(result)];
+            }
+        });
+    });
+}
+export function parsePrmtop(data) {
+    var _this = this;
+    return Task.create('Parse PRMTOP', function (ctx) { return __awaiter(_this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, parseInternal(data, ctx)];
+                case 1: return [2 /*return*/, _a.sent()];
+            }
+        });
+    }); });
+}

package/lib/mol-io/reader/top/parser.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Copyright (c) 2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+import { Task } from '../../../mol-task';
+import { ReaderResult as Result } from '../result';
+import { Column, Table } from '../../../mol-data/db';
+declare const AtomsSchema: {
+    nr: Column.Schema.Int;
+    type: Column.Schema.Str;
+    resnr: Column.Schema.Int;
+    residu: Column.Schema.Str;
+    atom: Column.Schema.Str;
+    cgnr: Column.Schema.Int;
+    charge: Column.Schema.Float;
+    mass: Column.Schema.Float;
+};
+declare const BondsSchema: {
+    ai: Column.Schema.Int;
+    aj: Column.Schema.Int;
+};
+declare const MoleculesSchema: {
+    compound: Column.Schema.Str;
+    molCount: Column.Schema.Int;
+};
+declare type Compound = {
+    atoms: Table<typeof AtomsSchema>;
+    bonds?: Table<typeof BondsSchema>;
+};
+export interface TopFile {
+    readonly system: string;
+    readonly molecules: Table<typeof MoleculesSchema>;
+    readonly compounds: Record<string, Compound>;
+}
+export declare function parseTop(data: string): Task<Result<TopFile>>;
+export {};

package/lib/mol-io/reader/top/parser.js

@@ -0,0 +1,299 @@
+/**
+ * Copyright (c) 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 { Task } from '../../../mol-task';
+import { Tokenizer, TokenBuilder } from '../common/text/tokenizer';
+import { ReaderResult as Result } from '../result';
+import { TokenColumnProvider as TokenColumn } from '../common/text/column/token';
+import { Column, Table } from '../../../mol-data/db';
+// https://manual.gromacs.org/2021-current/reference-manual/file-formats.html#top
+var AtomsSchema = {
+    nr: Column.Schema.Int(),
+    type: Column.Schema.Str(),
+    resnr: Column.Schema.Int(),
+    residu: Column.Schema.Str(),
+    atom: Column.Schema.Str(),
+    cgnr: Column.Schema.Int(),
+    charge: Column.Schema.Float(),
+    mass: Column.Schema.Float(),
+};
+var BondsSchema = {
+    ai: Column.Schema.Int(),
+    aj: Column.Schema.Int(),
+};
+var MoleculesSchema = {
+    compound: Column.Schema.Str(),
+    molCount: Column.Schema.Int(),
+};
+var readLine = Tokenizer.readLine, markLine = Tokenizer.markLine, skipWhitespace = Tokenizer.skipWhitespace, markStart = Tokenizer.markStart, eatValue = Tokenizer.eatValue, eatLine = Tokenizer.eatLine;
+function State(tokenizer, runtimeCtx) {
+    return {
+        tokenizer: tokenizer,
+        runtimeCtx: runtimeCtx,
+    };
+}
+var reField = /\[ (.+) \]/;
+var reWhitespace = /\s+/;
+function handleMoleculetype(state) {
+    var tokenizer = state.tokenizer;
+    var molName = undefined;
+    while (tokenizer.tokenEnd < tokenizer.length) {
+        skipWhitespace(tokenizer);
+        var c = tokenizer.data[tokenizer.position];
+        if (c === '[')
+            break;
+        if (c === ';' || c === '*') {
+            markLine(tokenizer);
+            continue;
+        }
+        if (molName !== undefined)
+            throw new Error('more than one molName');
+        var line = readLine(tokenizer);
+        molName = line.split(reWhitespace)[0];
+    }
+    if (molName === undefined)
+        throw new Error('missing molName');
+    return molName;
+}
+function handleAtoms(state) {
+    var tokenizer = state.tokenizer;
+    var nr = TokenBuilder.create(tokenizer.data, 64);
+    var type = TokenBuilder.create(tokenizer.data, 64);
+    var resnr = TokenBuilder.create(tokenizer.data, 64);
+    var residu = TokenBuilder.create(tokenizer.data, 64);
+    var atom = TokenBuilder.create(tokenizer.data, 64);
+    var cgnr = TokenBuilder.create(tokenizer.data, 64);
+    var charge = TokenBuilder.create(tokenizer.data, 64);
+    var mass = TokenBuilder.create(tokenizer.data, 64);
+    while (tokenizer.tokenEnd < tokenizer.length) {
+        skipWhitespace(tokenizer);
+        var c = tokenizer.data[tokenizer.position];
+        if (c === '[')
+            break;
+        if (c === ';' || c === '*') {
+            markLine(tokenizer);
+            continue;
+        }
+        for (var j = 0; j < 8; ++j) {
+            skipWhitespace(tokenizer);
+            markStart(tokenizer);
+            eatValue(tokenizer);
+            switch (j) {
+                case 0:
+                    TokenBuilder.add(nr, tokenizer.tokenStart, tokenizer.tokenEnd);
+                    break;
+                case 1:
+                    TokenBuilder.add(type, tokenizer.tokenStart, tokenizer.tokenEnd);
+                    break;
+                case 2:
+                    TokenBuilder.add(resnr, tokenizer.tokenStart, tokenizer.tokenEnd);
+                    break;
+                case 3:
+                    TokenBuilder.add(residu, tokenizer.tokenStart, tokenizer.tokenEnd);
+                    break;
+                case 4:
+                    TokenBuilder.add(atom, tokenizer.tokenStart, tokenizer.tokenEnd);
+                    break;
+                case 5:
+                    TokenBuilder.add(cgnr, tokenizer.tokenStart, tokenizer.tokenEnd);
+                    break;
+                case 6:
+                    TokenBuilder.add(charge, tokenizer.tokenStart, tokenizer.tokenEnd);
+                    break;
+                case 7:
+                    TokenBuilder.add(mass, tokenizer.tokenStart, tokenizer.tokenEnd);
+                    break;
+            }
+        }
+        // ignore any extra columns
+        markLine(tokenizer);
+    }
+    return Table.ofColumns(AtomsSchema, {
+        nr: TokenColumn(nr)(Column.Schema.int),
+        type: TokenColumn(type)(Column.Schema.str),
+        resnr: TokenColumn(resnr)(Column.Schema.int),
+        residu: TokenColumn(residu)(Column.Schema.str),
+        atom: TokenColumn(atom)(Column.Schema.str),
+        cgnr: TokenColumn(cgnr)(Column.Schema.int),
+        charge: TokenColumn(charge)(Column.Schema.float),
+        mass: TokenColumn(mass)(Column.Schema.float),
+    });
+}
+function handleBonds(state) {
+    var tokenizer = state.tokenizer;
+    var ai = TokenBuilder.create(tokenizer.data, 64);
+    var aj = TokenBuilder.create(tokenizer.data, 64);
+    while (tokenizer.tokenEnd < tokenizer.length) {
+        skipWhitespace(tokenizer);
+        var c = tokenizer.data[tokenizer.position];
+        if (c === '[')
+            break;
+        if (c === ';' || c === '*') {
+            markLine(tokenizer);
+            continue;
+        }
+        for (var j = 0; j < 2; ++j) {
+            skipWhitespace(tokenizer);
+            markStart(tokenizer);
+            eatValue(tokenizer);
+            switch (j) {
+                case 0:
+                    TokenBuilder.add(ai, tokenizer.tokenStart, tokenizer.tokenEnd);
+                    break;
+                case 1:
+                    TokenBuilder.add(aj, tokenizer.tokenStart, tokenizer.tokenEnd);
+                    break;
+            }
+        }
+        // ignore any extra columns
+        markLine(tokenizer);
+    }
+    return Table.ofColumns(BondsSchema, {
+        ai: TokenColumn(ai)(Column.Schema.int),
+        aj: TokenColumn(aj)(Column.Schema.int),
+    });
+}
+function handleSystem(state) {
+    var tokenizer = state.tokenizer;
+    var system = undefined;
+    while (tokenizer.tokenEnd < tokenizer.length) {
+        skipWhitespace(tokenizer);
+        var c = tokenizer.data[tokenizer.position];
+        if (c === '[')
+            break;
+        if (c === ';' || c === '*') {
+            markLine(tokenizer);
+            continue;
+        }
+        if (system !== undefined)
+            throw new Error('more than one system');
+        system = readLine(tokenizer).trim();
+    }
+    if (system === undefined)
+        throw new Error('missing system');
+    return system;
+}
+function handleMolecules(state) {
+    var tokenizer = state.tokenizer;
+    var compound = TokenBuilder.create(tokenizer.data, 64);
+    var molCount = TokenBuilder.create(tokenizer.data, 64);
+    while (tokenizer.tokenEnd < tokenizer.length) {
+        skipWhitespace(tokenizer);
+        if (tokenizer.position >= tokenizer.length)
+            break;
+        var c = tokenizer.data[tokenizer.position];
+        if (c === '[')
+            break;
+        if (c === ';' || c === '*') {
+            markLine(tokenizer);
+            continue;
+        }
+        for (var j = 0; j < 2; ++j) {
+            skipWhitespace(tokenizer);
+            markStart(tokenizer);
+            eatValue(tokenizer);
+            switch (j) {
+                case 0:
+                    TokenBuilder.add(compound, tokenizer.tokenStart, tokenizer.tokenEnd);
+                    break;
+                case 1:
+                    TokenBuilder.add(molCount, tokenizer.tokenStart, tokenizer.tokenEnd);
+                    break;
+            }
+        }
+        // ignore any extra columns
+        eatLine(tokenizer);
+        markStart(tokenizer);
+    }
+    return Table.ofColumns(MoleculesSchema, {
+        compound: TokenColumn(compound)(Column.Schema.str),
+        molCount: TokenColumn(molCount)(Column.Schema.int),
+    });
+}
+function parseInternal(data, ctx) {
+    return __awaiter(this, void 0, void 0, function () {
+        function addMol() {
+            if (currentMolName && currentCompound.atoms) {
+                result.compounds[currentMolName] = currentCompound;
+                currentCompound = {};
+                currentMolName = '';
+            }
+        }
+        var t, state, result, prevPosition, currentCompound, currentMolName, line, fieldMatch, fieldName;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    t = Tokenizer(data);
+                    state = State(t, ctx);
+                    result = Object.create(null);
+                    prevPosition = 0;
+                    result.compounds = {};
+                    currentCompound = {};
+                    currentMolName = '';
+                    _a.label = 1;
+                case 1:
+                    if (!(t.tokenEnd < t.length)) return [3 /*break*/, 4];
+                    if (!(t.position - prevPosition > 100000 && ctx.shouldUpdate)) return [3 /*break*/, 3];
+                    prevPosition = t.position;
+                    return [4 /*yield*/, ctx.update({ current: t.position, max: t.length })];
+                case 2:
+                    _a.sent();
+                    _a.label = 3;
+                case 3:
+                    line = readLine(state.tokenizer).trim();
+                    if (!line || line[0] === '*' || line[0] === ';') {
+                        return [3 /*break*/, 1];
+                    }
+                    if (line.startsWith('#include')) {
+                        throw new Error('#include statements not allowed');
+                    }
+                    if (line.startsWith('[')) {
+                        fieldMatch = line.match(reField);
+                        if (fieldMatch === null)
+                            throw new Error('expected field name');
+                        fieldName = fieldMatch[1];
+                        if (fieldName === 'moleculetype') {
+                            addMol();
+                            currentMolName = handleMoleculetype(state);
+                        }
+                        else if (fieldName === 'atoms') {
+                            currentCompound.atoms = handleAtoms(state);
+                        }
+                        else if (fieldName === 'bonds') {
+                            currentCompound.bonds = handleBonds(state);
+                        }
+                        else if (fieldName === 'system') {
+                            result.system = handleSystem(state);
+                        }
+                        else if (fieldName === 'molecules') {
+                            addMol(); // add the last compound
+                            result.molecules = handleMolecules(state);
+                        }
+                        else {
+                            while (t.tokenEnd < t.length) {
+                                if (t.data[t.position] === '[')
+                                    break;
+                                markLine(t);
+                            }
+                        }
+                    }
+                    return [3 /*break*/, 1];
+                case 4: return [2 /*return*/, Result.success(result)];
+            }
+        });
+    });
+}
+export function parseTop(data) {
+    var _this = this;
+    return Task.create('Parse TOP', function (ctx) { return __awaiter(_this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, parseInternal(data, ctx)];
+                case 1: return [2 /*return*/, _a.sent()];
+            }
+        });
+    }); });
+}

package/lib/mol-io/reader/trr/parser.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Copyright (c) 2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * Adapted from NGL.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+import { Task } from '../../../mol-task';
+import { ReaderResult as Result } from '../result';
+export interface TrrFile {
+    frames: {
+        count: number;
+        x: Float32Array;
+        y: Float32Array;
+        z: Float32Array;
+    }[];
+    boxes: number[][];
+    times: number[];
+    timeOffset: number;
+    deltaTime: number;
+}
+export declare function parseTrr(data: Uint8Array): Task<Result<TrrFile>>;

package/lib/mol-io/reader/trr/parser.js

@@ -0,0 +1,142 @@
+/**
+ * Copyright (c) 2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * Adapted from NGL.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+import { __awaiter, __generator } from "tslib";
+import { Task } from '../../../mol-task';
+import { ReaderResult as Result } from '../result';
+function parseInternal(data) {
+    return __awaiter(this, void 0, void 0, function () {
+        var dv, f, coordinates, boxes, times, offset, versionSize, boxSize, virSize, presSize, coordSize, velocitySize, forceSize, natoms, floatSize, natoms3, box, i, i, x, y, z, i, tmp, i, value, frameCoords, i;
+        return __generator(this, function (_a) {
+            dv = new DataView(data.buffer);
+            f = {
+                frames: [],
+                boxes: [],
+                times: [],
+                timeOffset: 0,
+                deltaTime: 0
+            };
+            coordinates = f.frames;
+            boxes = f.boxes;
+            times = f.times;
+            offset = 0;
+            while (true) {
+                // const magicnum = dv.getInt32(offset)
+                // const i1 = dv.getFloat32(offset + 4)
+                offset += 8;
+                versionSize = dv.getInt32(offset);
+                offset += 4;
+                offset += versionSize;
+                boxSize = dv.getInt32(offset + 8);
+                virSize = dv.getInt32(offset + 12);
+                presSize = dv.getInt32(offset + 16);
+                coordSize = dv.getInt32(offset + 28);
+                velocitySize = dv.getInt32(offset + 32);
+                forceSize = dv.getInt32(offset + 36);
+                natoms = dv.getInt32(offset + 40);
+                // const step = dv.getInt32(offset + 44)
+                // const nre = dv.getInt32(offset + 48)
+                offset += 52;
+                floatSize = boxSize / 9;
+                natoms3 = natoms * 3;
+                // let lambda
+                if (floatSize === 8) {
+                    times.push(dv.getFloat64(offset));
+                    // lambda = dv.getFloat64(offset + 8)
+                }
+                else {
+                    times.push(dv.getFloat32(offset));
+                    // lambda = dv.getFloat32(offset + 4)
+                }
+                offset += 2 * floatSize;
+                if (boxSize) {
+                    box = new Float32Array(9);
+                    if (floatSize === 8) {
+                        for (i = 0; i < 9; ++i) {
+                            box[i] = dv.getFloat64(offset) * 10;
+                            offset += 8;
+                        }
+                    }
+                    else {
+                        for (i = 0; i < 9; ++i) {
+                            box[i] = dv.getFloat32(offset) * 10;
+                            offset += 4;
+                        }
+                    }
+                    boxes.push(box);
+                }
+                // ignore, unused
+                offset += virSize;
+                // ignore, unused
+                offset += presSize;
+                if (coordSize) {
+                    x = new Float32Array(natoms);
+                    y = new Float32Array(natoms);
+                    z = new Float32Array(natoms);
+                    if (floatSize === 8) {
+                        for (i = 0; i < natoms; ++i) {
+                            x[i] = dv.getFloat64(offset) * 10;
+                            y[i] = dv.getFloat64(offset + 8) * 10;
+                            z[i] = dv.getFloat64(offset + 16) * 10;
+                            offset += 24;
+                        }
+                    }
+                    else {
+                        tmp = new Uint32Array(data.buffer, offset, natoms3);
+                        for (i = 0; i < natoms3; ++i) {
+                            value = tmp[i];
+                            tmp[i] = (((value & 0xFF) << 24) | ((value & 0xFF00) << 8) |
+                                ((value >> 8) & 0xFF00) | ((value >> 24) & 0xFF));
+                        }
+                        frameCoords = new Float32Array(data.buffer, offset, natoms3);
+                        for (i = 0; i < natoms; ++i) {
+                            x[i] = frameCoords[i * 3] * 10;
+                            y[i] = frameCoords[i * 3 + 1] * 10;
+                            z[i] = frameCoords[i * 3 + 2] * 10;
+                            offset += 12;
+                        }
+                    }
+                    coordinates.push({ count: natoms, x: x, y: y, z: z });
+                }
+                // ignore, unused
+                offset += velocitySize;
+                // ignore, unused
+                offset += forceSize;
+                if (offset >= data.byteLength)
+                    break;
+            }
+            if (times.length >= 1) {
+                f.timeOffset = times[0];
+            }
+            if (times.length >= 2) {
+                f.deltaTime = times[1] - times[0];
+            }
+            return [2 /*return*/, f];
+        });
+    });
+}
+export function parseTrr(data) {
+    var _this = this;
+    return Task.create('Parse TRR', function (ctx) { return __awaiter(_this, void 0, void 0, function () {
+        var file, e_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 2, , 3]);
+                    ctx.update({ canAbort: true, message: 'Parsing trajectory...' });
+                    return [4 /*yield*/, parseInternal(data)];
+                case 1:
+                    file = _a.sent();
+                    return [2 /*return*/, Result.success(file)];
+                case 2:
+                    e_1 = _a.sent();
+                    return [2 /*return*/, Result.error('' + e_1)];
+                case 3: return [2 /*return*/];
+            }
+        });
+    }); });
+}

package/lib/mol-io/writer/cif/encoder.js

@@ -7,6 +7,7 @@
 import { __spreadArray } from "tslib";
 import { Iterator } from '../../../mol-data/iterator';
 import { ArrayEncoding } from '../../common/binary-cif';
+import { assertUnreachable } from '../../../mol-util/type-helpers';
 export var Field;
 (function (Field) {
     function str(name, value, params) {
@@ -259,7 +260,7 @@ function cifFieldsFromTableSchema(schema) {
             fields.push.apply(fields, getTensorDefinitions(k, t.space));
         }
         else {
-            throw new Error("Unknown valueType ".concat(t.valueType));
+            assertUnreachable(t.valueType);
         }
     }
     return fields;