@ccp-nc/crystvis-js 0.4.13

package/lib/tensor.js

@@ -0,0 +1,227 @@
+'use strict';
+
+/**
+ * @fileoverview TensorData class to store tensors like NMR data and such.
+ * @module
+ */
+
+import _ from 'lodash';
+import * as mjs from 'mathjs';
+import * as THREE from 'three';
+
+const efg2hz = 234964.77815245767;
+const isc2hz = 1.6784031762379067e-16;    // hbar/(2*pi)*1e19
+
+class TensorData {
+
+    /**
+     * Create a TensorData object, to store whole tensors, 
+     * diagonalise their symmetric part and return derived quantities
+     * 
+     * @param {Array | mathjs.Matrix | TensorData} M     Tensor in 3x3 matrix form
+     * 
+     */
+    constructor(M) {
+
+        if (M instanceof TensorData)
+            M = M._M;
+        else if (M instanceof Array)
+            M = mjs.matrix(M);
+
+        this._M = M;
+
+        var MT = mjs.transpose(M);
+        this._Msymm = mjs.divide(mjs.add(M, MT), 2.0);
+        this._Masymm = mjs.subtract(M, this._Msymm);
+
+        // Diagonalize
+        var eigs = mjs.eigs(this._Msymm);
+        // Sort by eigenvalue magnitude
+        var evecs = mjs.transpose(eigs.vectors._data);
+        eigs = _.zip(eigs.values._data, evecs);
+        eigs = _.sortBy(eigs, function(x) {
+            return x[0];
+        });
+        eigs = _.unzip(eigs);
+
+        this._evals = eigs[0];
+
+        // Make it right-handed
+        evecs = eigs[1];
+        evecs[2] = mjs.cross(evecs[0], evecs[1]);
+        this._evecs = mjs.transpose(evecs);
+
+        // Isotropy
+        this._iso = mjs.mean(this._evals);
+
+        // Haeberlen order
+        var iso = this._iso;
+        var haeb = _.zip(_.range(3), this._evals);
+        haeb = _.sortBy(haeb, function(x) {
+            return Math.abs(x[1] - iso);
+        });
+
+        this._haeb_evals = [
+            this._evals[haeb[1][0]],
+            this._evals[haeb[0][0]],
+            this._evals[haeb[2][0]]
+        ];
+
+        this._haeb_evecs = mjs.transpose([
+            evecs[haeb[1][0]],
+            evecs[haeb[0][0]],
+            mjs.cross(evecs[haeb[1][0]], evecs[haeb[0][0]])
+        ]);
+
+    }
+
+    get data() {
+        return JSON.parse(JSON.stringify(this._M._data));
+    }
+
+    get symmetric() {
+        return JSON.parse(JSON.stringify(this._Msymm._data));
+    }
+
+    get asymmetric() {
+        return JSON.parse(JSON.stringify(this._Masymm._data));
+    }
+
+    get eigenvalues() {
+        return Array.from(this._evals);
+    }
+
+    get eigenvectors() {
+        return JSON.parse(JSON.stringify(this._evecs));
+    }
+
+    get haeberlen_eigenvalues() {
+        return Array.from(this._haeb_evals);
+    }
+
+    get haeberlen_eigenvectors() {
+        return JSON.parse(JSON.stringify(this._haeb_evecs));
+    }
+
+    get isotropy() {
+        return this._iso;
+    }
+
+    get anisotropy() {
+        return this._haeb_evals[2] - (this._haeb_evals[0] + this._haeb_evals[1]) / 2.0;
+    }
+
+    get reduced_anisotropy() {
+        return this._haeb_evals[2] - this._iso;
+    }
+
+    get asymmetry() {
+        var ra = this.reduced_anisotropy;
+        return (this._haeb_evals[1] - this._haeb_evals[0]) / ra;
+    }
+
+    get span() {
+        return this._evals[2] - this._evals[0];
+    }
+
+    get skew() {
+        var s = this.span;
+        return 3 * (this._evals[1] - this._iso) / s;
+    }
+
+    /**
+     * Rotate the TensorData by a given basis, either as passive or active
+     * transformation. Returns the rotated TensorData (does not modify this in
+     * place). Default is passive. The convention is such that for a symmetric
+     * tensor,
+     *
+     * T.rotate(T.eigenvectors)
+     *
+     * returns the diagonalised tensor.
+     * 
+     * @param  {Array | mathjs.Matrix | TensorData}  basis  Basis to rotate into
+     * @param  {Boolean}                             active If true, make it an active transformation (default is false)
+     * 
+     * @return {TensorData}                                 Rotated tensor
+     */
+    rotate(basis, active = false) {
+        // Rotate the tensor by the given basis of vectors
+        if (basis instanceof mjs.Matrix)
+            basis = basis._data;
+        if (basis instanceof TensorData)
+            basis = basis._M._data;
+
+        var bR = basis;
+        var bL = mjs.transpose(basis);
+
+        if (active) {
+            bR = bL;
+            bL = basis;
+        }
+        var rdata = mjs.multiply(bL, this._M._data, bR);
+
+        return new TensorData(rdata);
+    }
+
+
+    /**
+     * Convert this TensorData to return a clone that has been converted from
+     * atomic units to Hertz, assuming it's an Electric Field Gradient tensor.
+     * 
+     * @param  {Number} Q       Quadrupolar moment of the given nucleus (barn)
+     * 
+     * @return {TensorData}     Converted tensor
+     */
+    efgAtomicToHz(Q) {
+
+        // Clone self, then multiply all the necessary quantities
+        var clone = _.clone(this);
+
+        var k = efg2hz*Q;
+
+        clone._M = mjs.multiply(this._M, k);
+        clone._Msymm = mjs.multiply(this._Msymm, k);
+        clone._Masymm = mjs.multiply(this._Masymm, k);
+
+        clone._iso = this._iso*k;
+
+        clone._evals = mjs.multiply(this._evals, k);
+        clone._haeb_evals = mjs.multiply(this._haeb_evals, k);
+
+        return clone;
+    }
+
+    /**
+     * Convert this TensorData to return a clone that has been converted from
+     * atomic units to Hertz, assuming it's an Indirect Spin-spin Coupling 
+     * tensor.
+     * 
+     * @param  {Number} g1  Gyromagnetic ratio of the first atom
+     * @param  {Number} g2  Gyromagnetic ratio of the second atom
+     * 
+     * @return {TensorData}     Converted tensor
+     */
+    iscAtomicToHz(g1, g2) {
+
+        // Clone self, then multiply all the necessary quantities
+        var clone = _.clone(this);
+
+        var k = isc2hz*g1*g2;
+
+        clone._M = mjs.multiply(this._M, k);
+        clone._Msymm = mjs.multiply(this._Msymm, k);
+        clone._Masymm = mjs.multiply(this._Masymm, k);
+
+        clone._iso = this._iso*k;
+
+        clone._evals = mjs.multiply(this._evals, k);
+        clone._haeb_evals = mjs.multiply(this._haeb_evals, k);
+
+        return clone;        
+    }
+
+}
+
+export {
+    TensorData
+}

package/lib/utils.js

@@ -0,0 +1,168 @@
+'use strict';
+
+/** 
+ * @fileoverview Utility functions
+ * @module
+ */
+
+import _ from 'lodash';
+import * as THREE from 'three';
+
+/**
+ * Compute a full list of indices of all cells for 
+ * a supercell of given size
+ * @param {Array} scell        Size of the requested supercell 
+ */
+function supercellGrid(scell) {
+    var bounds = _.map(scell, function(x) {
+        var lb = Math.ceil(-x / 2)+(1-x%2); // This makes it so that for even supercells we skew on the positive side
+        if (Object.is(lb, -0)) {
+            lb = 0; // Avoids -0
+        }
+        var ub = Math.ceil(x / 2)+(1-x%2);
+        return [lb, ub];
+    });
+    var grid = [];
+
+    for (var i = bounds[0][0]; i < bounds[0][1]; ++i) {
+        for (var j = bounds[1][0]; j < bounds[1][1]; ++j) {
+            for (var k = bounds[2][0]; k < bounds[2][1]; ++k) {
+                grid.push([i, j, k]);
+            }
+        }
+    }
+
+    return grid;
+}
+
+/**
+ * Reduce a tuple of atomic index + i,j,k cell indices to a single integer
+ * @param  {int}    i       Atomic index
+ * @param  {Array}  ijk     Cell indices
+ * @param  {Array}  scell   Supercell size
+ * @param  {int}    n       Number of atoms in the model
+ * 
+ * @return {int}            Overall index
+ */
+function supercellIndex(i, ijk, scell, n) {
+
+    ijk = _.map(ijk, function(x, i) {
+        return x + Math.floor((scell[i]-1)/2); // Important (depends on the convention in supercellGrid)
+    });
+
+    // If any of these is smaller than 0, we're sure to be out
+    if (ijk[0] < 0 || ijk[1] < 0 || ijk[2] < 0) {
+        return -1;
+    }
+    if (ijk[0] >= scell[0] || ijk[1] >= scell[1] || ijk[2] >= scell[2]) {
+        return -1;
+    }
+
+    var itot = ijk[2] + ijk[1] * scell[2] + ijk[0] * scell[2] * scell[1];
+    itot = i + itot*n;
+
+    return itot;
+}
+
+/**
+ * Turn a unit cell expressed as Array of Arrays into a THREE.Matrix3 object
+ * @param {Array}   cell    Cell in Array form
+ *
+ * @return {THREE.Matrix3}  Cell in THREE.Matrix3 form
+ */
+function cellMatrix3(cell) {
+    var lc = cell;
+    cell = new THREE.Matrix3();
+    cell.set(lc[0][0], lc[1][0], lc[2][0],
+        lc[0][1], lc[1][1], lc[2][1],
+        lc[0][2], lc[1][2], lc[2][2]);
+
+    return cell;
+}
+
+/** Add a static variable to a class definition, old style (will become 
+ * obsolete once the static keyword is widely accepted in ES) 
+ * @param {Object}  cls      Class 
+ * @param {String}  name     Name of the variable to define
+ * @param {any}     value    Value to assign to it
+ */
+function addStaticVar(cls, name, value) {
+    Object.defineProperty(cls, name, {
+        value: value,
+        writable: false
+    });
+}
+
+/** Shift a CPK Color to be more distinct (used for isotopes) 
+ *
+ * @param {int}    basec    Base color to modify. Can be anything accepted
+ *                             by the THREE.Color constructor, but by default
+ *                             we assume it's an hex integer.
+ * @param {float}  shift    Shift to apply. Should range from -1 to 1.
+ *
+ * @return  {int}           Shifted color, returned as hex code.
+ * 
+ * */
+function shiftCpkColor(basec, shift=0) {
+    let c = new THREE.Color(basec);
+    let hsl = {};
+    c.getHSL(hsl);
+    // Here the goal is to choose a color that's still similar enough
+    // to the original, but also contrasts to it.
+    // We shift it more in hue if it's not very saturated/bright, and
+    // also shift its lightness towards 0.5 and saturation towards 1,
+    // so the hue becomes more evident
+
+    /*
+    let f = ((1.0-hsl.s)/2 + Math.abs(hsl.l-0.5))*0.7 + 0.3;
+    hsl.h = (hsl.h+shift*f*0.5)%1;
+
+    f *= 0.4;
+    hsl.s = f+(1-f)*hsl.s;
+    f *= 0.5;
+    hsl.l = f/2.0+(1-f)*hsl.l;
+    */
+   
+    // How close to white/black is the color?
+    let bw = Math.abs(hsl.l-0.5)/0.5;
+
+    if (Math.abs(bw-1) < 1e-2) {
+        // By convention we set the hue as blue
+        hsl.h = 0.6666;
+    }
+
+    // Reduce/increase luminance most for blacks and whites
+    hsl.l = (hsl.l-0.5)*(1-0.05*bw)+0.5;
+    // Increase saturation most for blacks and whites
+    hsl.s = hsl.s + 0.8*bw;
+    // Rotate hue least for vivid colors
+    hsl.h = (hsl.h+0.1*(0.5+bw)*shift);
+
+    c.setHSL(hsl.h, hsl.s, hsl.l);
+
+    return c.getHex();
+}
+
+/** Produce a low-collision hash code from a string argument. The algorithm
+ * is inspired by Java's .hashCode() method.
+ * 
+ * @param {String} arg    The string to hash
+ * 
+ * @return {int}          Hash code
+ */
+function hashCode(arg) {
+    arg = arg.toString(); // For sanity
+    let hash = 0;
+
+    for (let i = 0; i < arg.length; ++i) {
+        let char = arg.charCodeAt(i);
+        hash = ((hash<<5)-hash)+char;
+        hash = hash & hash; // Convert to 32bit integer
+    }
+
+    return hash;
+}
+
+export {
+    supercellGrid, supercellIndex, cellMatrix3, addStaticVar, shiftCpkColor, hashCode
+}