@ccp-nc/crystvis-js 0.4.13

package/lib/data.js

@@ -0,0 +1,125 @@
+'use strict';
+
+import {
+    PeriodicTable as PeriodicTable
+} from 'mendeleev';
+
+import nmrData from './nmrdata.js';
+import { shiftCpkColor } from './utils.js';
+
+/**
+ * @fileoverview Various data arrays and structures storing useful information
+ * @private
+ */
+
+// Van der Waals radii by atomic number
+const vdwRadii = [1.77, // Z = 0 is used as the default
+    1.2, 1.4, 1.82, 1.7, 2.08,
+    1.95, 1.55, 1.7, 1.73, 1.54, 2.27, 1.73, 2.05,
+    2.1, 2.08, 2.0, 1.97, 1.88, 2.75, 1.973, 1.7,
+    1.7, 1.7, 1.7, 1.7, 1.7, 1.7, 1.63, 1.4, 1.39,
+    1.87, 1.7, 1.85, 1.9, 2.1, 2.02, 1.7, 1.7, 1.7,
+    1.7, 1.7, 1.7, 1.7, 1.7, 1.7, 1.63, 1.72, 1.58,
+    1.93, 2.17, 2.2, 2.06, 2.15, 2.16, 1.7, 1.7,
+    1.7, 1.7, 1.7, 1.7, 1.7, 1.7, 1.7, 1.7, 1.7,
+    1.7, 1.7, 1.7, 1.7, 1.7, 1.7, 1.7, 1.7, 1.7,
+    1.7, 1.7, 1.7, 1.72, 1.66, 1.55, 1.96, 2.02,
+    1.7, 1.7, 1.7, 1.7, 1.7, 1.7, 1.7, 1.7, 1.7,
+    1.86, 1.7, 1.7, 1.7, 1.7, 1.7, 1.7, 1.7, 1.7,
+    1.7, 1.7, 1.7
+];
+
+const cpkColors = [0xff1493, // Z = 0 is used as the default
+    0xffffff, 0xd9ffff, 0xcc80ff, 0xc2ff00, 0xffb5b5, 0x909090, 0x3050f8, 0xff0d0d,
+    0x90e050, 0xb3e3f5, 0xab5cf2, 0x8aff00, 0xbfa6a6, 0xf0c8a0, 0xff8000, 0xffff30,
+    0x1ff01f, 0x80d1e3, 0x8f40d4, 0x3dff00, 0xe6e6e6, 0xbfc2c7, 0xa6a6ab, 0x8a99c7,
+    0x9c7ac7, 0xe06633, 0xf090a0, 0x50d050, 0xc88033, 0x7d80b0, 0xc28f8f, 0x668f8f,
+    0xbd80e3, 0xffa100, 0xa62929, 0x5cb8d1, 0x702eb0, 0x00ff00, 0x94ffff, 0x94e0e0,
+    0x73c2c9, 0x54b5b5, 0x3b9e9e, 0x248f8f, 0x0a7d8c, 0x006985, 0xc0c0c0, 0xffd98f,
+    0xa67573, 0x668080, 0x9e63b5, 0xd47a00, 0x940094, 0x429eb0, 0x57178f, 0x00c900,
+    0x70d4ff, 0xffffc7, 0xd9ffc7, 0xc7ffc7, 0xa3ffc7, 0x8fffc7, 0x61ffc7, 0x45ffc7,
+    0x30ffc7, 0x1fffc7, 0x00ff9c, 0x00e675, 0x00d452, 0x00bf38, 0x00ab24, 0x4dc2ff,
+    0x4da6ff, 0x2194d6, 0x267dab, 0x266696, 0x175487, 0xd0d0e0, 0xffd123, 0xb8b8d0,
+    0xa6544d, 0x575961, 0x9e4fb5, 0xab5c00, 0x754f45, 0x428296, 0x420066, 0x007d00,
+    0x70abfa, 0x00baff, 0x00a1ff, 0x008fff, 0x0080ff, 0x006bff, 0x545cf2, 0x785ce3,
+    0x8a4fe3, 0xa136d4, 0xb31fd4, 0xb31fba, 0xb30da6, 0xbd0d87, 0xc70066, 0xcc0059,
+    0xd1004f, 0xd90045, 0xe00038, 0xe6002e, 0xeb0026
+];
+
+
+function getVdwRadius(symbol) {
+    var el = PeriodicTable.getElement(symbol);
+    var Z = (el ? el.number : 0);
+    return vdwRadii[Z];
+}
+
+function getCpkColor(symbol, isotope=null) {
+    var el = PeriodicTable.getElement(symbol);
+    var Z = (el ? el.number : 0);
+    var cpkc = cpkColors[Z];
+
+    if (isotope !== null) {
+        // We apply an isotope correction
+        var edata = nmrData[symbol];
+        if (isotope != edata.maxiso) {
+            // Then a correction is necessary
+            var isolist = getIsotopeList(symbol);
+            var imax = isolist.indexOf(edata.maxiso);
+            var ic = isolist.indexOf(isotope.toString());
+            var shift = (ic-imax)/isolist.length;
+            cpkc = shiftCpkColor(cpkc, shift);
+        }
+    }
+
+    return cpkc;
+}
+
+function getIsotopeList(symbol) {
+    const data = nmrData[symbol];
+    if (!data) {
+        return null;
+    }
+
+    // If we do have it though...
+    return Object.keys(data.isotopes).sort();
+}
+
+function getElementData(symbol) {
+    return nmrData[symbol];
+}
+
+function getIsotopeData(symbol, iso=null) {
+    const eldata = nmrData[symbol];
+
+    if (eldata == null) {
+        return null;
+    }
+
+    if (iso === null) {
+        // Make it the most common one
+        iso = eldata.maxiso;
+    }
+    else if (iso === 'nmr') {
+        iso = eldata.maxiso_NMR;
+    }
+    else if (iso === 'Q') {
+        iso = eldata.maxiso_Q;
+    }
+
+    if (iso === null) {
+        // No such isotope
+        return null;
+    }
+
+    return eldata.isotopes[iso];
+}
+
+export {
+    vdwRadii,
+    cpkColors,
+    getVdwRadius,
+    getCpkColor,
+    getIsotopeList,
+    getElementData,
+    getIsotopeData
+}

package/lib/formats/cell.js

@@ -0,0 +1,114 @@
+'use strict';
+
+/**
+ * @fileoverview Function for loading CASTEP's Cell files
+ * @module
+ */
+
+import _ from 'lodash';
+import {
+    Atoms
+} from 'crystcif-parse';
+
+function cellBlocks(lines, units={}) {
+    const block_re = /%BLOCK\s+([A-Z_]+)/;
+    const endblock_re = /%ENDBLOCK\s+([A-Z_]+)/;
+
+    let blocks = {};
+    _.forEach(lines, (l, i) => {
+
+        let lu = l.toUpperCase();
+        let ms = block_re.exec(lu);
+        let me = endblock_re.exec(lu);
+
+        if (ms) {
+            let name = ms[1].toUpperCase();
+            if (name in blocks) {
+                throw Error('Duplicated ' + name + ' block found');
+            }
+            blocks[name] = {start: i};
+        } else if (me) {
+            let name = me[1].toUpperCase();
+            if (!(name in blocks)) {
+                throw Error('Block ' + name + ' ends without starting');
+            }
+
+            blocks[name]['end'] = i;
+            // Assign the contents
+            let i0 = blocks[name].start;
+            // Identify any units
+            let ul = lines[i0+1].trim().toLowerCase();
+            if (units[name] && (ul === units[name] || units[name].includes(ul))) {
+                i0 += 1;
+                blocks[name]['units'] = ul;
+            }
+            blocks[name]['lines'] = lines.slice(i0+1, i);
+        }
+    });
+
+    return blocks;
+}
+
+function load(contents, filename='cell') {
+
+    // Split the file into lines
+    let lines = _.split(contents, '\n');
+
+    // Admissible units
+    const units = {
+        'LATTICE_CART': ['ang'],
+        'POSITIONS_ABS': ['ang']
+    };
+
+    // Find blocks
+    let blocks = cellBlocks(lines, units);
+
+    let pabs = ('POSITIONS_ABS' in blocks);
+    let pfrac = ('POSITIONS_FRAC' in blocks);
+    let ccart = ('LATTICE_CART' in blocks);
+    let cabc = ('LATTICE_ABC' in blocks);
+
+    switch(pabs+pfrac) {
+        case 0:
+            throw Error('No positions block found');
+        case 2:
+            throw Error('Duplicated positions blocks found');
+        default:
+            break;
+    }
+
+    switch(ccart+cabc) {
+        case 0:
+            throw Error('No lattice block found');
+        case 2:
+            throw Error('Duplicated lattice blocks found');
+        default:
+            break;
+    }
+
+    // Parse the cell
+    let cell = ccart? blocks['LATTICE_CART'].lines : blocks['LATTICE_ABC'].lines;
+    cell = cell.map((l) => (_.trim(l).split(/\s+/).map(parseFloat)));
+
+    let elems = [];
+    let positions = [];
+
+    let pblock = pabs? blocks['POSITIONS_ABS'].lines : blocks['POSITIONS_FRAC'].lines;
+
+    pblock.forEach((l) => {
+        l = _.trim(l).split(/\s+/);
+        if (l.length < 4) 
+            throw Error('Incomplete line in positions block');
+        elems.push(l[0]);
+        positions.push(l.slice(1,4).map(parseFloat));
+    });
+    
+    var a = new Atoms(elems, positions, cell, {}, pfrac);
+
+    var structs = {};
+    structs[filename] = a;
+
+    return structs;
+}
+
+export { load };

package/lib/formats/cif.js

@@ -0,0 +1,22 @@
+'use strict';
+
+/**
+ * @fileoverview Function for loading CIF files (wrapper)
+ * @module
+ */
+
+import _ from 'lodash';
+import { Atoms } from 'crystcif-parse';
+
+function load(contents, filename) {
+
+    let structs = Atoms.readCif(contents);
+
+    if (filename) {
+        structs = _.mapKeys(structs, (v, k) => (filename + '_' + k));
+    }
+
+    return structs;
+}
+
+export { load };

package/lib/formats/magres.js

@@ -0,0 +1,337 @@
+'use strict';
+
+/**
+ * @fileoverview Function for loading Magres files
+ * @module
+ */
+
+import _ from 'lodash';
+import {
+    Atoms
+} from 'crystcif-parse';
+import {
+    TensorData
+} from '../tensor.js';
+
+const MagresUnits = {
+    length: {
+        ang: 1.0,
+        Angstrom: 1.0
+    },
+    sus: {
+        '10^-6.cm^3.mol^-1': 1.0
+    },
+    ms: {
+        ppm: 1.0
+    },
+    efg: {
+        au: 1.0
+    },
+    isc: {
+        '10^19.T^2.J^-1': 1.0
+    }
+};
+
+// Magres parsing utility functions
+function parseNoAtomLine(line, units) {
+    // Assumed to be just nine numbers, a full 3x3 matrix.
+    // Used for susceptibility
+    let tens = [];
+    for (let i = 0; i < 3; ++i) {
+        tens.push([]);
+        for (let j = 0; j < 3; ++j) {
+            tens[i].push(parseFloat(line[3 * i + j]) * units);
+        }
+    }
+
+    return new TensorData(tens);
+}
+
+function parseOneAtomLine(line, units, labels) {
+    // Species label + index, then nine numbers
+    let sp = line[0];
+    let sp_i = parseInt(line[1]);
+    let i = _.findIndex(labels, function(x) {
+        return (x[0] == sp) && (x[1] == sp_i);
+    });
+    let ltrim = Array.from(line).splice(2);
+
+    let ans = {
+        i: i,
+        tens: parseNoAtomLine(ltrim, units)
+    }
+
+    return ans;
+}
+
+function parseTwoAtomLine(line, units, labels) {
+    let sp1 = line[0]
+    let sp1_i = parseInt(line[1]);
+    let i1 = _.findIndex(labels, function(x) {
+        return (x[0] == sp1) && (x[1] == sp1_i);
+    });
+    let ltrim = Array.from(line).splice(2);
+
+    let ans = parseOneAtomLine(ltrim, units, labels);
+
+    ans = {
+        i1: i1,
+        i2: ans.i,
+        tens: ans.tens
+    };
+
+    return ans;
+}
+
+const MagresParsers = {
+    sus: parseNoAtomLine,
+    ms: parseOneAtomLine,
+    efg: parseOneAtomLine,
+    isc: parseTwoAtomLine
+};
+
+function load(contents, filename='magres') {
+
+    const known_blocks = ['atoms', 'magres'];
+
+    let lines = _.split(contents, '\n');
+
+    // First line contains version
+    let v_re = /#\$magres-abinitio-v([0-9]+\.[0-9]+)/;
+    let v_match = lines[0].match(v_re);
+
+    if (!v_match) {
+        throw Error('Invalid Magres file format: no version line');
+    }
+    let version = v_match[1];
+
+    // Start by identifying blocks
+    let blocks = {};
+    let b_re = /\[(\/)?([a-zA-Z_]+)\]/;
+    let b_alt_re = /<(\/)?([a-zA-Z_]+)>/;   // Alternative version (old magres tags)
+    let mtagtype_detected = false;          // Have we found out which type of tags are used?
+    let block_name = null;
+    let block_lines = [];
+
+    for (let i = 1; i < lines.length; ++i) {
+
+        let b_match = lines[i].match(b_re);
+
+        if (!mtagtype_detected) {
+            let b_alt_match = lines[i].match(b_alt_re);
+            if (b_alt_match) {
+                mtagtype_detected = true;
+                b_re = b_alt_re;
+                b_match = b_alt_match;
+            }
+            else if (b_match) {
+                mtagtype_detected = true;
+            }
+        }
+
+        if (b_match) {
+            // Start or end?
+            if (b_match[1] == '/') {
+                if (b_match[2] == block_name) {
+                    // End block
+                    blocks[block_name] = block_lines;
+                    block_name = null;
+                    block_lines = [];
+                } else {
+                    throw Error('Invalid Magres file format: block closed without opening');
+                }
+            } else {
+                if (block_name) {
+                    throw Error('Invalid Magres file format: block opened without closing');
+                }
+                block_name = b_match[2];
+            }
+        } else if (block_name) {
+            block_lines.push(lines[i]);
+        }
+    }
+
+    // Process each block
+    for (let bname in blocks) {
+        let block = blocks[bname];
+
+        if (!known_blocks.includes(bname)) {
+            // We don't know this block
+            blocks[bname] = _.join(block, '\n');
+            continue;
+        }
+
+        let data = {};
+
+        for (let i = 0; i < block.length; ++i) {
+            let l = block[i];
+            let lspl = _.trim(l).split(/\s+/);
+            // Is it a 'units' line?
+            if (lspl[0] === 'units') {
+                let tag = lspl[1];
+                if (tag in data && data[tag].lines.length > 0) {
+                    // We're being forgiving only of the case where a unit definition is duplicated
+                    throw Error('Invalid Magres file format: units specified after tag ' + tag + ' has been used');
+                }
+                data[tag] = {
+                    'units': lspl[2],
+                    'lines': []
+                };
+            } else if (lspl[0] !== '') {
+                let tag = lspl[0];
+                if (!(tag in data)) {
+                    data[tag] = {
+                        'units': null,
+                        'lines': []
+                    };
+                }
+                data[tag].lines.push(lspl.splice(1));
+            }
+        }
+
+        blocks[bname] = data;
+
+    }
+
+    // Now on to read the blocks themselves
+
+    let ablock = blocks.atoms;
+
+    if (!ablock) {
+        throw Error('Invalid Magres file format: does not contain atoms block');
+    }
+
+    // Read in the cell, if present
+    let cell = null;
+    if ('lattice' in ablock) {
+        let u = 1.0;
+        let uname = ablock.lattice.units;
+        if (uname) {
+            u = MagresUnits.length[uname];
+            if (!u) {
+                throw Error('Invalid Magres file format: invalid units for cell');
+            }
+        }
+        cell = [];
+        let line = Array.from(ablock.lattice.lines[0]);
+        for (let i = 0; i < 3; ++i) {
+            cell.push(_.map(line.splice(0, 3), function(x) {
+                return parseFloat(x) * u;
+            }));
+        }
+    }
+
+    // Read in the atom positions and species
+    let elems = [];
+    let pos = [];
+    let mlabels = [];
+    let labels = [];
+
+    if ('atom' in ablock) {
+        let u = 1.0;
+        let uname = ablock.atom.units;
+        if (uname) {
+            u = MagresUnits.length[uname];
+            if (!u) {
+                throw Error('Invalid Magres file format: invalid units for atom');
+            }
+        }
+
+        for (let i = 0; i < ablock.atom.lines.length; ++i) {
+            let l = ablock.atom.lines[i];
+
+            elems.push(l[0]);
+            mlabels.push([l[1], parseInt(l[2])]);
+            labels.push(l[1]);
+
+            pos.push(_.map(l.splice(3), function(x) {
+                return parseFloat(x) * u;
+            }));
+        }
+
+    } else {
+        throw Error('Invalid Magres file format: no atom position data found');
+    }
+
+    // Create atoms object
+    let atoms = new Atoms(elems, pos, cell, {
+        'magres-blocks': blocks,
+        'magres-version': version,
+    });
+    // Add array
+    atoms.set_array('labels', labels);
+    atoms.set_array('magres-labels', mlabels);
+
+    let N = elems.length;
+
+    // Now for the magres stuff
+    let mblock = blocks.magres;
+
+    if (mblock) {
+
+        for (let tag in mblock) {
+            let tag_type = tag.split('_')[0];
+
+            let u = 1.0;
+            let uname = mblock[tag].units;
+            if (uname) {
+                u = MagresUnits[tag_type][uname];
+                if (!u) {
+                    throw Error('Invalid Magres file format: invalid units for ' + tag);
+                }
+            }
+
+            // Initialise as dictionary
+            let tag_dimension;
+            let tag_data;
+            switch (MagresParsers[tag_type]) {
+                case parseNoAtomLine:
+                    tag_dimension = 0;
+                    break;
+                case parseOneAtomLine:
+                    tag_dimension = 1;
+                    tag_data = new Array(N);
+                    break;
+                case parseTwoAtomLine:
+                    tag_dimension = 2;
+                    tag_data = _.times(N, function() {
+                        return new Array(N);
+                    });
+            }
+
+            for (let i = 0; i < mblock[tag].lines.length; ++i) {
+                let l = mblock[tag].lines[i];
+                let data = MagresParsers[tag_type](l, u, mlabels);
+                switch (tag_dimension) {
+                    case 0:
+                        tag_data = data;
+                        break;
+                    case 1:
+                        tag_data[data.i] = data.tens;
+                        break;
+                    case 2:
+                        tag_data[data.i1][data.i2] = data.tens;
+                        tag_data[data.i2][data.i1] = data.tens;
+                        break;
+                }
+            }
+
+            if (tag_dimension == 0) {
+                atoms.info[tag] = tag_data;
+            } else {
+                atoms.set_array(tag, tag_data);
+            }
+
+        }
+
+    }
+
+    let structs = {};
+    structs[filename] = atoms;
+
+    return structs;
+}
+
+export {
+    load
+};