@ccp-nc/crystvis-js 0.4.13

package/test/model.js

@@ -0,0 +1,368 @@
+'use strict';
+
+
+import chai from 'chai'
+import chaiAlmost from 'chai-almost'
+
+import _ from 'lodash';
+import fs from 'fs';
+import path from 'path';
+import {
+    fileURLToPath
+} from 'url';
+
+import {
+    Atoms as Atoms
+} from 'crystcif-parse';
+import {
+    Model,
+    AtomImage,
+    BondImage
+} from '../lib/model.js';
+import {
+    ModelView as ModelView
+} from '../lib/modelview.js';
+import {
+    Loader as Loader
+} from '../lib/loader.js';
+
+chai.use(chaiAlmost(1e-3));
+
+const expect = chai.expect
+const __dirname = path.dirname(fileURLToPath(
+    import.meta.url));
+
+// Load test files
+var cif = fs.readFileSync(path.join(__dirname, 'data', 'CHA.cif'), "utf8");
+var cha = Atoms.readCif(cif)['CHA'];
+var chamodel = new Model(cha);
+var chamodel3 = new Model(cha, {
+    supercell: [3, 3, 3]
+});
+
+cif = fs.readFileSync(path.join(__dirname, 'data', 'org.cif'), "utf8");
+var org = Atoms.readCif(cif)['1501936'];
+var orgmodel = new Model(org);
+
+var xyz = fs.readFileSync(path.join(__dirname, 'data', 'pyridine.xyz'), "utf8");
+var loader = new Loader();
+var pyr = loader.load(xyz, 'xyz')['xyz'];
+var pyrmodel = new Model(pyr);
+
+xyz = fs.readFileSync(path.join(__dirname, 'data', 'si8.xyz'), "utf8");
+var si = loader.load(xyz, 'xyz')['xyz'];
+var simodel = new Model(si);
+var simodel3 = new Model(si, {
+    supercell: [3, 3, 3]
+});
+
+xyz = fs.readFileSync(path.join(__dirname, 'data', 'H2O.xyz'), "utf8");
+var h2o = loader.load(xyz, 'xyz')['xyz'];
+var h2omodel = new Model(h2o);
+
+describe('#atomimage', function() {
+    it('should correctly compute the periodic copy position', function() {
+        var aim = new AtomImage(chamodel, 0, [1, 0, 0]);
+        [25.339775, 1.16060394, 1.8119109].forEach(function(v, i) {
+            expect(aim.xyz[i]).to.be.closeTo(v, 1e-5);
+        });
+
+        aim = new AtomImage(chamodel, 0, [-1, 1, 1]);
+        [-8.847725, 13.00350134, 16.5789109].forEach(function(v, i) {
+            expect(aim.xyz[i]).to.be.closeTo(v, 1e-5);
+        });
+    });
+    it('should correctly identify equalities', function() {
+        var ai0 = new AtomImage(chamodel, 0, [0, 0, 1]);
+        var ai1 = new AtomImage(chamodel, 0, [0, 0, 1]);
+        var ai2 = new AtomImage(chamodel, 0, [1, 0, 0]);
+        var ai3 = new AtomImage(simodel, 0, [0, 0, 1]);
+
+        expect(ai0.equals(ai1)).to.be.equal(true);
+        expect(ai0.equals(ai2)).to.be.equal(false);
+        expect(ai0.equals(ai3)).to.be.equal(false);
+    });
+    it('should correctly generate string IDs', function() {
+
+        var ai = new AtomImage(chamodel, 2, [3, -1, 2]);
+
+        expect(ai.id).to.equal('2_3_-1_2');
+    });
+    it('should correctly calculate its integer index', function() {
+
+        for (var i = 0; i < simodel3.atoms.length; ++i) {
+            var ai = simodel3.atoms[i];
+            expect(ai.imgIndex).to.equal(i);
+        }
+    });
+    it('should correctly identify the closest bonding neighbours', function() {
+
+        // This one relies on Model to compute the right bonds
+
+        var atoms = h2omodel.atoms;
+        var a = atoms[0];
+
+        expect(a.bondedAtoms).to.deep.equal([atoms[1], atoms[2]]);
+
+    });
+    it('should correctly retrieve a corresponding array value', function() {
+
+        simodel.setArray('test_arr', _.range(simodel.length));
+
+        for (var i = 0; i < simodel.length; ++i) {
+            expect(simodel.atoms[i].getArrayValue('test_arr'), i);
+        }
+
+    });
+});
+
+describe('#bondimage', function() {
+    it('should correctly compute the distance between atoms in the bond', function() {
+
+        var a1 = new AtomImage(h2omodel, 0, [0, 0, 0]);
+        var a2 = new AtomImage(h2omodel, 1, [0, 0, 0]);
+
+        var b = new BondImage(h2omodel, a1, a2);
+
+        expect(b.length).to.almost.equal(0.9686);
+    });
+});
+
+describe('#model', function() {
+
+    it('should generate the right atomic labels', function() {
+        expect(h2omodel._labels).to.deep.equal(['O_1', 'H_1', 'H_2', 'O_2', 'H_3', 'H_4']);
+    });
+
+    it('should correctly compute a supercell grid', function() {
+        expect(chamodel3.supercellGrid.length).to.be.equal(27);
+    });
+
+    it('should correctly compute the minimum supercell for given radii', function() {
+        expect(orgmodel.minimumSupercell(5)).to.deep.equal([3, 3, 3]);
+        expect(orgmodel.minimumSupercell(10)).to.deep.equal([5, 5, 3]);
+        expect(orgmodel.minimumSupercell(20)).to.deep.equal([7, 7, 5]);
+    });
+
+    it('should correctly return its various properties', function() {
+        expect(pyrmodel.length).to.equal(11);
+        expect(chamodel.periodic).to.be.true;
+        expect(pyrmodel.periodic).to.be.false;
+        expect(simodel.periodic).to.be.true;
+    });
+
+    it('should behave gracefully in case of non-periodic systems', function() {
+        expect(pyrmodel.cell).to.be.null;
+    });
+
+    it('should correctly query for atoms in various ways', function() {
+        // Here we only test the raw query functions, not meant for 
+        // public use
+
+        var found = pyrmodel._queryElements(['C']);
+        expect(found).to.deep.equal([0, 1, 2, 4, 5]);
+
+        // Cell
+        found = chamodel._queryCell([5, 5, 5]); // Beyond the supercell size
+        expect(found).to.deep.equal([]);
+
+        found = chamodel3._queryCell([1, 1, 1]);
+        expect(found.length).to.equal(chamodel.length);
+        expect(found[0]).to.equal(26 * chamodel.length);
+
+        // Box
+        found = pyrmodel._queryBox([-1, -0.5, -2.3], [0, 0.5, 1.7]);
+        found.sort();
+        expect(found).to.deep.equal([0, 3, 6]);
+
+        found = simodel._queryBox([-1.5, -1.5, -1.5], [1.5, 1.5, 1.5]);
+        expect(found).to.deep.equal([0, 1]);
+
+        // Bigger supercell
+        found = simodel3._queryBox([-1.5, -1.5, -1.5], [1.5, 1.5, 1.5]);
+        expect(found).to.deep.equal([11, 29, 79, 104, 105]);
+
+        found = simodel3._querySphere([0, 0, 0], 2.4);
+        expect(found).to.deep.equal([11, 29, 79, 104, 105]);
+
+        // Indices
+        found = simodel3._queryIndices(0);
+        expect(found).to.deep.equal(_.range(27).map((x) => {
+            return 8*x;
+        }));
+
+        // Using an atom as the centre
+        found = simodel._querySphere(simodel.atoms[0], 2.4);
+        expect(found).to.deep.equal([0, 1]);
+
+        // Bonds
+        found = h2omodel._queryBonded(h2omodel.atoms[0]);
+        expect(found).to.deep.equal([1, 2]);
+        found = h2omodel._queryBonded(h2omodel.atoms[0], 2);
+        expect(found).to.deep.equal([1, 2]);
+        found = h2omodel._queryBonded(h2omodel.atoms[0], 2, true);
+        expect(found.length).to.equal(0);
+        found = pyrmodel._queryBonded(pyrmodel.atoms[3], 2, true);
+        found.sort();
+        expect(found).to.deep.equal([1, 5, 8, 9]);
+
+        // Molecules
+        found = h2omodel._queryMolecule(h2omodel.atoms[0]);
+        found.sort();
+        expect(found).to.deep.equal([0, 1, 2]);
+        found = h2omodel._queryMolecule(h2omodel.atoms[3]); // Out of bounds
+        expect(found).to.deep.equal([3]);
+
+        // Test a more complex query
+        found = simodel3.find({
+            '$and': [{
+                'box': [
+                    [0, 0, 0],
+                    [2, 2, 2]
+                ]
+            }, {
+                'box': [
+                    [1, 1, 1],
+                    [3, 3, 3]
+                ]
+            }]
+        });
+
+        expect(found.length).to.equal(1);
+        expect(found.atoms[0].index).to.equal(1);
+
+    });
+
+    it('should identify the right bonds', function() {
+
+        var bonds = h2omodel._bondmat;
+
+        expect(bonds[0][1]).to.deep.equal([
+            [0, 0, 0]
+        ]);
+        expect(bonds[0][2]).to.deep.equal([
+            [0, 0, 0]
+        ]);
+        expect(bonds[3][4]).to.deep.equal([
+            [0, 0, -1]
+        ]);
+        expect(bonds[3][5]).to.deep.equal([
+            [0, -1, -1]
+        ]);
+
+    });
+
+    it('should identify the right molecules', function() {
+
+        expect(h2omodel._molinds).to.deep.equal([0, 0, 0, 1, 1, 1]);
+
+    });
+
+    it('should correctly load a model as molecular crystal', function() {
+
+        var h2omolcryst = new Model(h2o, {
+            molecularCrystal: true
+        });
+
+        for (let i = 0; i < h2omolcryst._molecules.length; ++i) {
+            let mol = h2omolcryst._molecules[i];
+            for (let j = 0; j < mol.length; ++j) {
+                expect(mol[j].cell).to.deep.equal([0, 0, 0]);
+            }
+        }
+
+        // Check that it didn't alter the original Atoms object
+        expect(h2omolcryst.positions).to.not.deep.equal(h2omodel.positions);
+
+    });
+
+    it('should correctly work with isotopes', function() {
+
+        var h2omodel = new Model(h2o, {
+            supercell: [2,1,1]
+        });
+
+        var a0 = h2omodel.find({indices: 0}).atoms;
+
+        expect(a0[0].isotope).to.equal(16);        
+        expect(a0[1].isotope).to.equal(16);        
+
+        // Now set them both
+        a0[0].isotopeGlobal = 17;
+        expect(a0[0].isotope).to.equal(17);
+        expect(a0[1].isotope).to.equal(17);
+
+        // Now only one
+        a0[1].isotope = 18;
+        expect(a0[0].isotope).to.equal(17);
+        expect(a0[1].isotope).to.equal(18);
+
+        // And attached data
+        expect(a0[0].isotopeData.gamma/1e7).to.almost.equal(-3.628);
+        expect(a0[1].isotopeData.gamma).to.equal(null); // No spin
+
+        // Load NMR active isotopes
+        h2omodel = new Model(h2o, {
+            supercell: [1,1,1],
+            useNMRActiveIsotopes: true
+        });
+
+        expect(h2omodel.atoms[0].isotope).to.equal(17);
+        expect(h2omodel.atoms[1].isotope).to.equal(1);
+    });
+});
+
+describe('#modelview', function() {
+
+    it('should correctly AND two successive queries', function() {
+
+        var mv1 = h2omodel.find({
+            'cell': [
+                [0, 0, 0]
+            ]
+        });
+        var mv2 = mv1.find({
+            'elements': 'O'
+        });
+        expect(mv2.indices).to.deep.equal([0, 3]);
+
+    });
+
+    it('should correctly perform boolean operations between views', function() {
+
+        var mv1 = h2omodel.find({
+            'elements': 'O'
+        });
+        var mv2 = h2omodel.find({
+            'elements': 'H'
+        });
+        var mv3 = h2omodel.find({
+            'sphere': [
+                [0, 0, 0], 1
+            ]
+        });
+
+        var mvAnd = mv1.and(mv2);
+        expect(mvAnd.length).to.equal(0);
+
+        var mvOr = mv1.or(mv2);
+        expect(mvOr.indices.sort()).to.deep.equal([0, 1, 2, 3, 4, 5]);
+
+        var mvXor = mv1.xor(mv3);
+        expect(mvXor.indices.sort()).to.deep.equal([1, 2, 3]);
+
+        var mvNot = mv3.not();
+        expect(mvNot.indices.sort()).to.deep.equal([3, 4, 5]);
+
+        // Throw exception
+        var mvSi = simodel.find({
+            'all': []
+        });
+
+        expect(function() {
+            mv1.and(mvSi);
+        }).to.throw('The two ModelViews do not refer to the same Model');
+
+    });
+
+});

package/test/query.js

@@ -0,0 +1,135 @@
+'use strict';
+
+import chai from 'chai';
+
+import _ from 'lodash'
+import {
+    QueryParser as QueryParser
+} from '../lib/query.js';
+
+const expect = chai.expect;
+
+// Create a test object for queries
+var QuerySandbox = function(n) {
+    this._nums = _.range(0, n);
+}
+
+QuerySandbox.prototype = {
+    even: function() {
+        return _.filter(this._nums, function(x) {
+            return x % 2 == 0
+        });
+    },
+    odd: function() {
+        return _.filter(this._nums, function(x) {
+            return x % 2 == 1
+        });
+    },
+    all: function() {
+        return _.cloneDeep(this._nums);
+    },
+    greater: function(val) {
+        return _.filter(this._nums, function(x) {
+            return x > val;
+        });
+    },
+    lesser: function(val) {
+        return _.filter(this._nums, function(x) {
+            return x < val;
+        });
+    }
+};
+
+describe('#query', function() {
+    it('should correctly parse an individual query', function() {
+        var qs = new QuerySandbox(10);
+        var qp = new QueryParser({
+                'even': qs.even,
+                'odd': qs.odd
+            },
+            qs);
+
+        expect(qp.parse({
+            'even': []
+        })).to.deep.equal(_.range(0, 10, 2));
+        expect(qp.parse({
+            'odd': []
+        })).to.deep.equal(_.range(1, 10, 2));
+    });
+    it('should correctly parse a query with arguments', function() {
+        var qs = new QuerySandbox(10);
+        var qp = new QueryParser({
+                'greater': qs.greater
+            },
+            qs);
+
+        expect(qp.parse({
+            'greater': [2]
+        })).to.deep.equal(_.range(3, 10));
+    });
+    it('should correctly use the operator $and', function() {
+        var qs = new QuerySandbox(10);
+        var qp = new QueryParser({
+                'even': qs.even,
+                'greater': qs.greater
+            },
+            qs);
+
+        expect(qp.parse({
+            '$and': [{
+                'even': []
+            }, {
+                'greater': [2]
+            }]
+        })).to.deep.equal(_.range(4, 10, 2));
+    });
+    it('should correctly use the operator $or', function() {
+        var qs = new QuerySandbox(10);
+        var qp = new QueryParser({
+                'even': qs.even,
+                'odd': qs.odd
+            },
+            qs);
+
+        expect(qp.parse({
+            '$or': [{
+                'even': []
+            }, {
+                'odd': []
+            }]
+        }).sort()).to.deep.equal(_.range(0, 10));
+    });
+
+    it('should correctly use the operator $xor', function() {
+        var qs = new QuerySandbox(10);
+        var qp = new QueryParser({
+                'greater': qs.greater,
+                'lesser': qs.lesser
+            },
+            qs);
+
+        expect(qp.parse({
+            '$xor': [{
+                'greater': [0]
+            }, {
+                'lesser': [9]
+            }]
+        }).sort()).to.deep.equal([0, 9]);
+    });
+
+    it('should interpret a dictionary with multiple keys as $and queries', function() {
+
+        var qs = new QuerySandbox(10);
+        var qp = new QueryParser({
+            'greater': qs.greater,
+            'lesser': qs.lesser
+        }, qs);
+
+        expect(qp.parse({
+            'greater': 2,
+            'lesser': 6
+        }).sort()).to.deep.equal([3, 4, 5]);
+
+    });
+
+});

package/test/tensor.js

@@ -0,0 +1,133 @@
+'use strict';
+
+
+import chai from 'chai'
+import chaiAlmost from 'chai-almost'
+
+import * as mjs from 'mathjs'
+
+import {
+    TensorData
+} from '../lib/tensor.js'
+
+import {
+    getIsotopeData
+} from '../lib/data.js'
+
+chai.use(chaiAlmost(1e-3));
+
+const expect = chai.expect;
+
+describe('#tensordata', function() {
+
+    it('should properly separate the symmetric part of a tensor', function() {
+        var td = new TensorData([
+            [0, 2, 1],
+            [0, 0, 1],
+            [1, 1, 0]
+        ]);
+
+        expect(td.symmetric).to.deep.equal([
+            [0, 1, 1],
+            [1, 0, 1],
+            [1, 1, 0]
+        ]);
+
+        expect(td.asymmetric).to.deep.equal([
+            [0, 1, 0],
+            [-1, 0, 0],
+            [0, 0, 0]
+        ]);
+    });
+
+    it('should compute and order eigenvalues properly', function() {
+
+        var td = new TensorData([
+            [1, 2, 3],
+            [2, 3, 4],
+            [3, 4, 5]
+        ]);
+
+        expect(td.eigenvalues).to.deep.almost.equal([-6.234754e-01, 0,
+            9.623475e+00
+        ]);
+
+        // Reconstruct the matrix
+        var ev = td.eigenvectors;
+        var D = mjs.diag(td.eigenvalues);
+        var evT = mjs.transpose(ev);
+        expect(mjs.multiply(ev, mjs.multiply(D, evT))).to.deep.almost.equal(td.symmetric);
+    });
+
+    it('should change bases properly', function() {
+
+        var td0 = new TensorData([
+            [15, 2, 2],
+            [ 2, 3, 6],
+            [ 2, 6, 9]
+        ]);
+
+        var td1 = td0.rotate(td0.eigenvectors);
+        expect(td1.symmetric).to.deep.almost.equal(mjs.diag(td0.eigenvalues));
+
+        // And vice versa...
+        var td2 = td1.rotate(td0.eigenvectors, true);
+        expect(td2.symmetric).to.deep.almost.equal(td0.symmetric);
+    });
+
+    it('should order eigenvalues properly following the Haeberlen convention', function() {
+
+        var td = new TensorData([
+            [1,0,0],
+            [0,2,0],
+            [0,0,-6]
+        ]);
+
+        // Haeberlen order:
+        // e_x = 2 
+        // e_y = 1
+        // e_z = -6
+
+        expect(td.isotropy).to.equal(-1);
+        expect(td.haeberlen_eigenvalues).to.deep.equal([2, 1, -6]);
+        expect(td.anisotropy).to.equal(-7.5);
+        expect(td.reduced_anisotropy).to.equal(-5);
+        expect(td.asymmetry).to.equal(0.2);
+        expect(td.span).to.equal(8);
+        expect(td.skew).to.almost.equal(0.75);
+
+    });
+
+    it ('should convert properly an EFG tensor to Hz', function() {
+
+        var efg = new TensorData([
+            [ 1.05124449e-01,  1.42197546e-01,  1.53489044e+00],
+            [ 1.42197546e-01,  2.40599479e-02, -9.03880151e-01],
+            [ 1.53489044e+00, -9.03880151e-01, -1.29184397e-01]
+        ]);
+
+        // Convert to Hz
+        var Q = getIsotopeData('O', 17).Q;
+        efg = efg.efgAtomicToHz(Q);
+
+        // Comparison in kHz
+        expect(efg.haeberlen_eigenvalues[2]/1e3).to.almost.equal(11233.854188);
+    });
+
+    it ('should convert properly an ISC tensor to Hz', function() {
+
+        var isc = new TensorData([
+            [1.8373758951855776, -0.6444912603875048, 0.03379154211567881], 
+            [-0.6738855911039692, 0.72064084469826, -0.4004091413405982], 
+            [0.014472208799926917, -0.3990514190555465, 0.3282668712885049]
+        ]);
+
+        // Convert to Hz
+        var g1 = getIsotopeData('C', 13).gamma;
+        var g2 = getIsotopeData('H', 1).gamma;
+        isc = isc.iscAtomicToHz(g1, g2);
+
+        // Comparison in kHz
+        expect(isc.haeberlen_eigenvalues[2]).to.almost.equal(6.53565087);
+    });
+});