@ccp-nc/crystvis-js 0.6.1 → 0.7.1

package/test/loader.js

@@ -259,8 +259,122 @@ H 0.0 1.0 0.0`;
         expect(loader.error_message).to.equal('Invalid Magres file format: block opened without closing');
 
     });
-    it('should load properly a CELL file', function() {
 
+    it('should parse hyperfine tensors from magres_old block', function() {
+
+        var loader = new Loader();
+
+        // Test with the synthetic HF tensor test file (non-zero values)
+        var magres = fs.readFileSync(path.join(__dirname, 'data', 'hf_test.magres'), "utf8");
+        var a = loader.load(magres, 'magres')['magres'];
+
+        expect(loader.status).to.equal(Loader.STATUS_SUCCESS);
+        expect(a.length()).to.equal(2);
+
+        // hf array should exist
+        var hf = a.get_array('hf');
+        expect(hf).to.have.lengthOf(2);
+
+        // Each entry should be a TensorData object
+        expect(hf[0]).to.have.property('data');
+        expect(hf[1]).to.have.property('data');
+
+        // Check H 1 tensor matrix values
+        expect(hf[0].data).to.deep.almost.equal([
+            [ 1.2345, -0.5678,  0.1234],
+            [-0.5678,  2.3456,  0.4567],
+            [ 0.1234,  0.4567,  3.4567]
+        ]);
+
+        // Check C 1 tensor matrix values
+        expect(hf[1].data).to.deep.almost.equal([
+            [5.0, 1.0, 0.0],
+            [1.0, 5.0, 0.0],
+            [0.0, 0.0, 3.0]
+        ]);
+
+        // Check isotropic values (trace/3)
+        expect(hf[0].isotropy).to.almost.equal((1.2345 + 2.3456 + 3.4567) / 3);
+        expect(hf[1].isotropy).to.almost.equal((5.0 + 5.0 + 3.0) / 3);
+
+        // Check eigenvalues of C 1 (symmetric: known values 3, 4, 6)
+        var c_evals = hf[1].eigenvalues;
+        expect(c_evals).to.deep.almost.equal([3.0, 4.0, 6.0]);
+
+        // Check gamma ratios parsed from the synthetic file
+        var ratios = a.info['hf-gyromagnetic-ratios'];
+        expect(ratios).to.exist;
+        expect(ratios['H']).to.exist;
+        expect(ratios['H'].isotope).to.equal(1);
+        expect(ratios['H'].gamma).to.almost.equal(2.6752e8);
+        expect(ratios['C']).to.exist;
+        expect(ratios['C'].isotope).to.equal(13);
+        expect(ratios['C'].gamma).to.almost.equal(6.7283e7);
+
+        // Test with optimized_muon_65-hf.magres (real CASTEP output with non-zero HF tensors and H:Mu)
+        var muon_magres = fs.readFileSync(path.join(__dirname, 'data', 'optimized_muon_65-hf.magres'), "utf8");
+        var am = loader.load(muon_magres, 'magres')['magres'];
+
+        expect(am.length()).to.equal(69); // 16 H + 1 H:Mu + 28 C + 4 Fe + 2 N + 12 O + 4 S + 2 Br
+
+        var hf_m = am.get_array('hf');
+        expect(hf_m).to.have.lengthOf(69);
+
+        // All entries should be TensorData objects (not null)
+        hf_m.forEach(function(t) {
+            expect(t).to.have.property('data');
+            expect(t.data).to.have.lengthOf(3);
+        });
+
+        // H 1 tensor values are non-trivial
+        expect(hf_m[0].data).to.deep.almost.equal([
+            [-2.5897,  2.2293,  0.4459],
+            [ 2.2293,  0.8275, -0.5108],
+            [ 0.4459, -0.5108,  0.9140]
+        ]);
+
+        // H:Mu 1 is the last atom; check its isotropy
+        expect(hf_m[68].isotropy).to.almost.equal(-431.5713);
+
+        // Gamma ratios should include H:Mu as user-defined
+        var ratios_m = am.info['hf-gyromagnetic-ratios'];
+        expect(ratios_m['H:Mu'].isotope).to.equal(null);
+        expect(ratios_m['H:Mu'].gamma).to.almost.equal(8.5162e8);
+    });
+    it('should handle custom species (H:Mu) in magres files', function() {
+
+        var loader = new Loader();
+
+        var magres = fs.readFileSync(path.join(__dirname, 'data', 'hf_mu_test.magres'), "utf8");
+        var a = loader.load(magres, 'magres')['magres'];
+
+        expect(loader.status).to.equal(Loader.STATUS_SUCCESS);
+        expect(a.length()).to.equal(2);
+
+        // H:Mu should be stored as element H (colon-suffix stripped)
+        expect(a.get_chemical_symbols()).to.deep.equal(['H', 'H']);
+
+        // Both atoms should have HF tensors
+        var hf = a.get_array('hf');
+        expect(hf).to.have.lengthOf(2);
+        expect(hf[0]).to.have.property('data');
+        expect(hf[1]).to.have.property('data');
+
+        // H 1 tensor is diagonal [1,2,3]
+        expect(hf[0].eigenvalues).to.deep.almost.equal([1.0, 2.0, 3.0]);
+
+        // H:Mu 1 tensor was stored (check isotropy ~ -20)
+        expect(hf[1].isotropy).to.almost.equal((-10 - 20 - 30) / 3);
+
+        // Gamma ratios: standard H and user-defined H:Mu
+        var ratios = a.info['hf-gyromagnetic-ratios'];
+        expect(ratios['H'].isotope).to.equal(1);
+        expect(ratios['H'].gamma).to.almost.equal(2.6752e8);
+        expect(ratios['H:Mu'].isotope).to.equal(null);
+        expect(ratios['H:Mu'].gamma).to.almost.equal(8.5162e8);
+    });
+
+    it('should load properly a CELL file', function() {
         var loader = new Loader();
 
         var cell = fs.readFileSync(path.join(__dirname, 'data', 'ethanol.cell'), "utf8");

package/test/model.js

@@ -394,4 +394,122 @@ describe('#modelview', function() {
             expect(newMV.length).to.equal(1);
             expect(newMV._indices.sort()).to.deep.equal([72]);   
     });
+});
+
+// ---------------------------------------------------------------------------
+// Tests: ModelView serialisation (§6.1, §6.3) and Model reconstruction (§6.2, §6.3)
+// ---------------------------------------------------------------------------
+
+describe('ModelView#toIndices', function() {
+
+    it('returns a plain array equal to the view indices', function() {
+        var mv = h2omodel.find({ elements: ['O'] });
+        var result = mv.toIndices();
+        expect(result).to.deep.equal(mv.indices);
+    });
+
+    it('returns a copy — mutating it does not affect the view', function() {
+        var mv = h2omodel.find({ elements: ['O'] });
+        var result = mv.toIndices();
+        result.push(999);
+        expect(mv.indices.length).to.equal(result.length - 1);
+    });
+
+    it('returns an empty array for an empty view', function() {
+        var mv = h2omodel.view([]);
+        expect(mv.toIndices()).to.deep.equal([]);
+    });
+
+});
+
+describe('ModelView#toLabels', function() {
+
+    it('returns one crystLabel per atom in the view', function() {
+        var mv = h2omodel.find({ elements: ['O'] });
+        var labels = mv.toLabels();
+        expect(labels).to.be.an('array');
+        expect(labels.length).to.equal(mv.length);
+        labels.forEach(l => expect(l).to.be.a('string').and.have.length.above(0));
+    });
+
+    it('all labels contain the element symbol', function() {
+        var mv = h2omodel.find({ elements: ['H'] });
+        mv.toLabels().forEach(l => expect(l).to.match(/^H/));
+    });
+
+    it('returns an empty array for an empty view', function() {
+        var mv = h2omodel.view([]);
+        expect(mv.toLabels()).to.deep.equal([]);
+    });
+
+    it('round-trips: toLabels then viewFromLabels gives the same indices', function() {
+        // Use a multi-site structure for a meaningful round-trip
+        var mv = chamodel.find({ elements: ['O'] });
+        var labels = mv.toLabels();
+        var restored = chamodel.viewFromLabels(labels);
+        expect(restored.indices.sort((a,b)=>a-b))
+            .to.deep.equal(mv.indices.slice().sort((a,b)=>a-b));
+    });
+
+});
+
+describe('Model#viewFromIndices', function() {
+
+    it('produces a view with exactly the specified indices', function() {
+        var indices = [0, 2, 4];
+        var mv = h2omodel.viewFromIndices(indices);
+        expect(mv.indices).to.deep.equal(indices);
+    });
+
+    it('is equivalent to model.view(indices)', function() {
+        var indices = [1, 3];
+        var a = h2omodel.viewFromIndices(indices);
+        var b = h2omodel.view(indices);
+        expect(a.indices).to.deep.equal(b.indices);
+    });
+
+    it('defaults to an empty view when called with no arguments', function() {
+        var mv = h2omodel.viewFromIndices();
+        expect(mv.length).to.equal(0);
+    });
+
+    it('round-trips with toIndices()', function() {
+        var original = h2omodel.find({ elements: ['H'] });
+        var restored = h2omodel.viewFromIndices(original.toIndices());
+        expect(restored.indices).to.deep.equal(original.indices);
+    });
+
+});
+
+describe('Model#viewFromLabels', function() {
+
+    it('finds atoms matching the given labels', function() {
+        var mv = chamodel.find({ elements: ['Si'] });
+        var labels = mv.toLabels();
+        var restored = chamodel.viewFromLabels(labels);
+        expect(restored.length).to.equal(mv.length);
+    });
+
+    it('returns an empty view for an empty label array', function() {
+        var mv = chamodel.viewFromLabels([]);
+        expect(mv.length).to.equal(0);
+    });
+
+    it('ignores unknown labels', function() {
+        // Grab a real label dynamically, then mix it with a nonsense one
+        var validLabel = chamodel._atom_images[0].crystLabel;
+        var mv = chamodel.viewFromLabels([validLabel, 'DOES_NOT_EXIST']);
+        expect(mv.length).to.be.greaterThan(0);
+        mv.toLabels().forEach(l => expect(l).to.not.equal('DOES_NOT_EXIST'));
+    });
+
+    it('round-trips with toLabels() across a different supercell model', function() {
+        // Use the unit-cell model to get labels, then restore on the same model
+        var mv = chamodel.find({ elements: ['O'] });
+        var labels = mv.toLabels();
+        var restored = chamodel.viewFromLabels(labels);
+        expect(restored.indices.sort((a,b)=>a-b))
+            .to.deep.equal(mv.indices.slice().sort((a,b)=>a-b));
+    });
+
 });

package/test/setup-dom.cjs

@@ -0,0 +1,147 @@
+/**
+ * test/setup-dom.cjs
+ *
+ * Mocha --require hook (CommonJS) that installs a minimal jsdom window as
+ * global so that DOM-dependent ES modules (THREE.js texture loader, jQuery,
+ * etc.) can be imported in the Node.js test environment without crashing.
+ */
+
+'use strict';
+
+const { JSDOM } = require('jsdom');
+
+const dom = new JSDOM('<!DOCTYPE html><html><body><div id="crystvis"></div></body></html>', {
+    pretendToBeVisual: true,
+    resources: 'usable',
+});
+
+// Helper: set a global, falling back to Object.defineProperty for read-only
+// properties (e.g. navigator in Node.js 23+).
+function setGlobal(name, value) {
+    try {
+        global[name] = value;
+    } catch (_) {
+        Object.defineProperty(global, name, { value, writable: true, configurable: true });
+    }
+}
+
+// Expose browser globals expected by THREE.js, jQuery, etc.
+setGlobal('window',            dom.window);
+setGlobal('document',          dom.window.document);
+setGlobal('navigator',         dom.window.navigator);
+setGlobal('HTMLElement',       dom.window.HTMLElement);
+setGlobal('HTMLCanvasElement', dom.window.HTMLCanvasElement);
+setGlobal('Image',             dom.window.Image);
+setGlobal('ImageData',         dom.window.ImageData);
+setGlobal('XMLHttpRequest',    dom.window.XMLHttpRequest);
+setGlobal('requestAnimationFrame',  (cb) => setTimeout(cb, 16));
+setGlobal('cancelAnimationFrame',   (id) => clearTimeout(id));
+setGlobal('ResizeObserver', class ResizeObserver {
+    observe() {}
+    unobserve() {}
+    disconnect() {}
+});
+
+// Stub WebGL context so THREE.WebGLRenderer does not crash on getContext()
+const canvasProto = dom.window.HTMLCanvasElement.prototype;
+const _origGetContext = canvasProto.getContext;
+canvasProto.getContext = function (type, ...args) {
+    if (type === 'webgl' || type === 'webgl2' || type === 'experimental-webgl') {
+        // Return a minimal WebGL stub that THREE can interrogate without causing
+        // errors.  Only the methods referenced during renderer initialisation
+        // need to be present.
+        return {
+            canvas: this,
+            drawingBufferWidth: 300,
+            drawingBufferHeight: 150,
+            getExtension: () => null,
+            getParameter: () => null,
+            getShaderPrecisionFormat: () => ({ rangeMin: 127, rangeMax: 127, precision: 23 }),
+            createTexture: () => ({}),
+            bindTexture: () => {},
+            texParameteri: () => {},
+            pixelStorei: () => {},
+            enable: () => {},
+            disable: () => {},
+            blendEquation: () => {},
+            blendFunc: () => {},
+            depthFunc: () => {},
+            depthMask: () => {},
+            colorMask: () => {},
+            clearColor: () => {},
+            clearDepth: () => {},
+            clearStencil: () => {},
+            scissor: () => {},
+            viewport: () => {},
+            clear: () => {},
+            useProgram: () => {},
+            frontFace: () => {},
+            cullFace: () => {},
+            createBuffer: () => ({}),
+            bindBuffer: () => {},
+            bufferData: () => {},
+            createFramebuffer: () => ({}),
+            bindFramebuffer: () => {},
+            createRenderbuffer: () => ({}),
+            bindRenderbuffer: () => {},
+            renderbufferStorage: () => {},
+            framebufferRenderbuffer: () => {},
+            framebufferTexture2D: () => {},
+            createProgram: () => ({}),
+            createShader: () => ({}),
+            shaderSource: () => {},
+            compileShader: () => {},
+            attachShader: () => {},
+            linkProgram: () => {},
+            getProgramParameter: (p, pname) => {
+                // LINK_STATUS
+                if (pname === 35714) return true;
+                return null;
+            },
+            getShaderParameter: () => true,
+            getUniformLocation: () => ({}),
+            getAttribLocation: () => 0,
+            uniform1i: () => {},
+            uniform1f: () => {},
+            uniform2f: () => {},
+            uniform3f: () => {},
+            uniform4f: () => {},
+            uniformMatrix3fv: () => {},
+            uniformMatrix4fv: () => {},
+            vertexAttribPointer: () => {},
+            enableVertexAttribArray: () => {},
+            disableVertexAttribArray: () => {},
+            drawArrays: () => {},
+            drawElements: () => {},
+            deleteBuffer: () => {},
+            deleteTexture: () => {},
+            deleteProgram: () => {},
+            deleteShader: () => {},
+            deleteFramebuffer: () => {},
+            deleteRenderbuffer: () => {},
+            isContextLost: () => false,
+            getError: () => 0,
+            // WebGL2 extras
+            createVertexArray: () => ({}),
+            bindVertexArray: () => {},
+            deleteVertexArray: () => {},
+            texImage2D: () => {},
+            texImage3D: () => {},
+            texStorage2D: () => {},
+            texStorage3D: () => {},
+            blitFramebuffer: () => {},
+            readBuffer: () => {},
+            drawBuffers: () => {},
+            renderbufferStorageMultisample: () => {},
+            createSampler: () => ({}),
+            deleteSampler: () => {},
+            bindSampler: () => {},
+            samplerParameteri: () => {},
+            samplerParameterf: () => {},
+        };
+    }
+    if (_origGetContext) {
+        return _origGetContext.call(this, type, ...args);
+    }
+    return null;
+};