nmr-processing 8.0.0 → 8.1.0

package/src/signals/simulation/simulateXYPeaks.ts

@@ -0,0 +1,332 @@
+import binarySearch from 'binary-search';
+import { Matrix, EVD } from 'ml-matrix';
+import type { Matrix as MatrixClassType } from 'ml-matrix';
+import type { Shape1D } from 'ml-peak-shape-generator';
+import { SparseMatrix } from 'ml-sparse-matrix';
+
+import type { SpinSystem } from '../spinSystem';
+
+import getPauliMatrix from './getPauliMatrix';
+
+const smallValue = 1e-2;
+
+export interface Simulate1DOptions {
+  /**
+   * The linewidth of the output spectrum, expresed in Hz.
+   * @default 1
+   */
+  lineWidth?: number;
+  /**
+   * Maximum number of atoms on each cluster that can be considered to be simulated together. It affects the the quality and speed of the simulation.
+   * @default 8
+   */
+  maxClusterSize?: number;
+  /**
+   * The frequency in Mhz of the fake spectrometer that records the spectrum.
+   * @default 400
+   */
+  frequency?: number;
+  /**
+   * The low limit of the ordinate variable.
+   * @default 0
+   */
+  from?: number;
+  /**
+   * The upper limit of the ordinate variable.
+   * @default 10
+   */
+  to?: number;
+  /**
+   * Number of points of the output spectrum.
+   * @default 16K
+   */
+  nbPoints?: number;
+  /**
+   * Shape options
+   * @default {kind:'gaussian'}
+   */
+  shape?: Shape1D;
+}
+
+export function simulateXYPeaks(
+  /**
+   * The SpinSystem object to be simulated
+   */
+  spinSystem: SpinSystem,
+  options: Simulate1DOptions = {},
+) {
+  let {
+    lineWidth = 1,
+    maxClusterSize = 8,
+    frequency: frequencyMHz = 400,
+  } = options;
+
+  const chemicalShifts = spinSystem.chemicalShifts.slice();
+  for (let i = 0; i < chemicalShifts.length; i++) {
+    chemicalShifts[i] = chemicalShifts[i] * frequencyMHz;
+  }
+
+  const multiplicity = spinSystem.multiplicity;
+
+  const xyPeaks = [];
+  for (const cluster of spinSystem.clusters) {
+    let clusterFake = cluster.map((cluster) =>
+      cluster < 0 ? -cluster - 1 : cluster,
+    );
+
+    let weight = 1;
+    let sumI = 0;
+    let frequencies: number[] = [];
+    let intensities: number[] = [];
+    if (cluster.length > maxClusterSize) {
+      // This is a single spin, but the cluster exceeds the maxClusterSize criteria
+      // we use the simple multiplicity algorithm
+      // Add the central peak. It will be split with every single J coupling.
+      let index = 0;
+      while (cluster[index++] < 0);
+      index = cluster[index - 1];
+      frequencies.push(-chemicalShifts[index]);
+      for (let i = 0; i < cluster.length; i++) {
+        if (cluster[i] < 0) {
+          let jc = spinSystem.couplingConstants.get(index, clusterFake[i]) / 2;
+          let currentSize = frequencies.length;
+          for (let j = 0; j < currentSize; j++) {
+            frequencies.push(frequencies[j] + jc);
+            frequencies[j] -= jc;
+          }
+        }
+      }
+
+      frequencies.sort((a, b) => a - b);
+      sumI = frequencies.length;
+      weight = 1;
+
+      for (let i = 0; i < sumI; i++) {
+        intensities.push(1);
+      }
+    } else {
+      const hamiltonian = getHamiltonian(
+        chemicalShifts,
+        spinSystem.couplingConstants,
+        multiplicity,
+        spinSystem.connectivity,
+        clusterFake,
+      );
+      const hamSize = hamiltonian.rows;
+      // TODO: add support for sparse matrix in matrix types.
+      // @ts-expect-error sparse matrix not supported
+      const evd = new EVD(hamiltonian);
+      const V = evd.eigenvectorMatrix;
+      const diagB = evd.realEigenvalues;
+      const assignmentMatrix = new SparseMatrix(hamSize, hamSize);
+      const multLen = cluster.length;
+      weight = 0;
+      for (let n = 0; n < multLen; n++) {
+        const L = getPauliMatrix(multiplicity[clusterFake[n]]);
+
+        let temp = 1;
+        for (let j = 0; j < n; j++) {
+          temp *= multiplicity[clusterFake[j]];
+        }
+        const A = SparseMatrix.eye(temp);
+
+        temp = 1;
+        for (let j = n + 1; j < multLen; j++) {
+          temp *= multiplicity[clusterFake[j]];
+        }
+        const B = SparseMatrix.eye(temp);
+        const tempMat = A.kroneckerProduct(L.m).kroneckerProduct(B);
+        if (cluster[n] >= 0) {
+          assignmentMatrix.add(tempMat.mul(cluster[n] + 1));
+          weight++;
+        } else {
+          assignmentMatrix.add(tempMat.mul(cluster[n]));
+        }
+      }
+
+      let rhoip = Matrix.zeros(hamSize, hamSize);
+      assignmentMatrix.forEachNonZero((i, j, v) => {
+        if (v > 0) {
+          for (let k = 0; k < V.columns; k++) {
+            let element = V.get(j, k);
+            if (element !== 0) {
+              rhoip.set(i, k, rhoip.get(i, k) + element);
+            }
+          }
+        }
+        return v;
+      });
+
+      let rhoip2 = rhoip.clone();
+      assignmentMatrix.forEachNonZero((i: number, j: number, v: number) => {
+        if (v < 0) {
+          for (let k = 0; k < V.columns; k++) {
+            let element = V.get(j, k);
+            if (element !== 0) {
+              rhoip2.set(i, k, rhoip2.get(i, k) + element);
+            }
+          }
+        }
+        return v;
+      });
+      const tV = V.transpose();
+
+      rhoip = tV.mmul(rhoip);
+      const sparseRhoip = new SparseMatrix(rhoip.to2DArray(), {
+        threshold: smallValue,
+      });
+      triuTimesAbs(sparseRhoip, smallValue);
+
+      rhoip2 = tV.mmul(rhoip2);
+      const sparseRhoip2 = new SparseMatrix(rhoip2.to2DArray(), {
+        threshold: smallValue,
+      });
+      sparseRhoip2.forEachNonZero((i, j, v) => {
+        return v;
+      });
+      triuTimesAbs(sparseRhoip2, smallValue);
+      sparseRhoip2.forEachNonZero((i, j, v) => {
+        let val = rhoip.get(i, j);
+        val = Math.min(Math.abs(val), Math.abs(v));
+        val *= val;
+
+        sumI += val;
+        let valFreq = diagB[i] - diagB[j];
+        let insertIn = binarySearch(
+          frequencies,
+          valFreq,
+          (a: number, b: number) => a - b,
+        );
+        if (insertIn < 0) {
+          frequencies.splice(-1 - insertIn, 0, valFreq);
+          intensities.splice(-1 - insertIn, 0, val);
+        } else {
+          intensities[insertIn] += val;
+        }
+      });
+    }
+
+    const numFreq = frequencies.length;
+
+    if (numFreq > 0) {
+      weight /= sumI;
+      const diff = lineWidth / 64;
+      let valFreq = frequencies[0];
+      let inte = intensities[0];
+      let count = 1;
+      for (let i = 1; i < numFreq; i++) {
+        if (Math.abs(frequencies[i] - valFreq / count) < diff) {
+          inte += intensities[i];
+          valFreq += frequencies[i];
+          count++;
+        } else {
+          xyPeaks.push({
+            x: -valFreq / count / frequencyMHz,
+            y: inte * weight,
+          });
+          valFreq = frequencies[i];
+          inte = intensities[i];
+          count = 1;
+        }
+      }
+
+      xyPeaks.push({
+        x: -valFreq / count / frequencyMHz,
+        y: inte * weight,
+      });
+    }
+  }
+
+  return xyPeaks;
+}
+
+function triuTimesAbs(A: SparseMatrix, val: number) {
+  A.forEachNonZero((i, j, v) => {
+    if (i > j) return 0;
+    if (Math.abs(v) <= val) return 0;
+    return v;
+  });
+}
+/**
+ * Create a hamiltonian matrix for the given spinsystem
+ * @param {Array} chemicalShifts - An array containing the chemical shift in Hz
+ * @param {Array} couplingConstants - An array containing the coupling constants in Hz
+ * @param {Array} multiplicity - An array specifiying the multiplicities of each scalar coupling
+ * @param {Array} conMatrix - A one step connectivity matrix for the given spin system
+ * @param {Array} cluster - An binary array specifiying the spins to be considered for this hamiltonial
+ * @return {object}
+ */
+function getHamiltonian(
+  chemicalShifts: number[],
+  couplingConstants: MatrixClassType,
+  multiplicity: number[],
+  conMatrix: MatrixClassType,
+  cluster: number[],
+) {
+  let hamSize = 1;
+  for (const element of cluster) {
+    hamSize *= multiplicity[element];
+  }
+
+  const clusterHam = new SparseMatrix(hamSize, hamSize);
+
+  for (let pos = 0; pos < cluster.length; pos++) {
+    let n = cluster[pos];
+
+    const L = getPauliMatrix(multiplicity[n]);
+
+    let A1, B1;
+    let temp = 1;
+    for (let i = 0; i < pos; i++) {
+      temp *= multiplicity[cluster[i]];
+    }
+    A1 = SparseMatrix.eye(temp);
+
+    temp = 1;
+    for (let i = pos + 1; i < cluster.length; i++) {
+      temp *= multiplicity[cluster[i]];
+    }
+    B1 = SparseMatrix.eye(temp);
+
+    const alpha = chemicalShifts[n];
+    const kronProd = A1.kroneckerProduct(L.z).kroneckerProduct(B1);
+    clusterHam.add(kronProd.mul(alpha));
+    for (let pos2 = 0; pos2 < cluster.length; pos2++) {
+      const k = cluster[pos2];
+      if (conMatrix.get(n, k) === 1) {
+        const S = getPauliMatrix(multiplicity[k]);
+
+        let A2, B2;
+        let temp = 1;
+        for (let i = 0; i < pos2; i++) {
+          temp *= multiplicity[cluster[i]];
+        }
+        A2 = SparseMatrix.eye(temp);
+
+        temp = 1;
+        for (let i = pos2 + 1; i < cluster.length; i++) {
+          temp *= multiplicity[cluster[i]];
+        }
+        B2 = SparseMatrix.eye(temp);
+
+        const kron1 = A1.kroneckerProduct(L.x)
+          .kroneckerProduct(B1)
+          .mmul(A2.kroneckerProduct(S.x).kroneckerProduct(B2));
+        kron1.add(
+          A1.kroneckerProduct(L.y)
+            .kroneckerProduct(B1)
+            .mul(-1)
+            .mmul(A2.kroneckerProduct(S.y).kroneckerProduct(B2)),
+        );
+        kron1.add(
+          A1.kroneckerProduct(L.z)
+            .kroneckerProduct(B1)
+            .mmul(A2.kroneckerProduct(S.z).kroneckerProduct(B2)),
+        );
+
+        clusterHam.add(kron1.mul(couplingConstants.get(n, k) / 2));
+      }
+    }
+  }
+  return clusterHam;
+}

package/src/utilities/getFrequency.ts

@@ -1,4 +1,4 @@
-import { gyromagneticRatio, Nuclei } from '../constants/gyromagneticRatio';
+import { gyromagneticRatio, Nuclei } from 'gyromagnetic-ratio';
 
 export interface ObjervedNucleusData {
   /**

package/lib/constants/gyromagneticRatio.d.ts

@@ -1,6 +0,0 @@
-export declare type Nuclei = '1H' | '2H' | '3H' | '3He' | '7Li' | '13C' | '14N' | '15N' | '17O' | '19F' | '23Na' | '27Al' | '29Si' | '31P' | '57Fe' | '63Cu' | '67Zn' | '129Xe';
-declare type GyromagneticRatio = {
-    [key in Nuclei]: number;
-};
-export declare const gyromagneticRatio: GyromagneticRatio;
-export {};

package/lib/constants/gyromagneticRatio.js

@@ -1,26 +0,0 @@
-"use strict";
-// sources:
-// https://en.wikipedia.org/wiki/Gyromagnetic_ratio
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.gyromagneticRatio = void 0;
-exports.gyromagneticRatio = {
-    '1H': 267.52218744e6,
-    '2H': 41.065e6,
-    '3H': 285.3508e6,
-    '3He': -203.789e6,
-    '7Li': 103.962e6,
-    '13C': 67.28284e6,
-    '14N': 19.331e6,
-    '15N': -27.116e6,
-    '17O': -36.264e6,
-    '19F': 251.662e6,
-    '23Na': 70.761e6,
-    '27Al': 69.763e6,
-    '29Si': -53.19e6,
-    '31P': 108.291e6,
-    '57Fe': 8.681e6,
-    '63Cu': 71.118e6,
-    '67Zn': 16.767e6,
-    '129Xe': -73.997e6,
-};
-//# sourceMappingURL=gyromagneticRatio.js.map

package/lib/constants/gyromagneticRatio.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"gyromagneticRatio.js","sourceRoot":"","sources":["../../src/constants/gyromagneticRatio.ts"],"names":[],"mappings":";AAAA,WAAW;AACX,mDAAmD;;;AA4BtC,QAAA,iBAAiB,GAAsB;IAClD,IAAI,EAAE,cAAc;IACpB,IAAI,EAAE,QAAQ;IACd,IAAI,EAAE,UAAU;IAChB,KAAK,EAAE,CAAC,SAAS;IACjB,KAAK,EAAE,SAAS;IAChB,KAAK,EAAE,UAAU;IACjB,KAAK,EAAE,QAAQ;IACf,KAAK,EAAE,CAAC,QAAQ;IAChB,KAAK,EAAE,CAAC,QAAQ;IAChB,KAAK,EAAE,SAAS;IAChB,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,CAAC,OAAO;IAChB,KAAK,EAAE,SAAS;IAChB,MAAM,EAAE,OAAO;IACf,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,QAAQ;IAChB,OAAO,EAAE,CAAC,QAAQ;CACnB,CAAC"}

package/lib-esm/constants/gyromagneticRatio.js

@@ -1,23 +0,0 @@
-// sources:
-// https://en.wikipedia.org/wiki/Gyromagnetic_ratio
-export const gyromagneticRatio = {
-    '1H': 267.52218744e6,
-    '2H': 41.065e6,
-    '3H': 285.3508e6,
-    '3He': -203.789e6,
-    '7Li': 103.962e6,
-    '13C': 67.28284e6,
-    '14N': 19.331e6,
-    '15N': -27.116e6,
-    '17O': -36.264e6,
-    '19F': 251.662e6,
-    '23Na': 70.761e6,
-    '27Al': 69.763e6,
-    '29Si': -53.19e6,
-    '31P': 108.291e6,
-    '57Fe': 8.681e6,
-    '63Cu': 71.118e6,
-    '67Zn': 16.767e6,
-    '129Xe': -73.997e6,
-};
-//# sourceMappingURL=gyromagneticRatio.js.map

package/lib-esm/constants/gyromagneticRatio.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"gyromagneticRatio.js","sourceRoot":"","sources":["../../src/constants/gyromagneticRatio.ts"],"names":[],"mappings":"AAAA,WAAW;AACX,mDAAmD;AA4BnD,MAAM,CAAC,MAAM,iBAAiB,GAAsB;IAClD,IAAI,EAAE,cAAc;IACpB,IAAI,EAAE,QAAQ;IACd,IAAI,EAAE,UAAU;IAChB,KAAK,EAAE,CAAC,SAAS;IACjB,KAAK,EAAE,SAAS;IAChB,KAAK,EAAE,UAAU;IACjB,KAAK,EAAE,QAAQ;IACf,KAAK,EAAE,CAAC,QAAQ;IAChB,KAAK,EAAE,CAAC,QAAQ;IAChB,KAAK,EAAE,SAAS;IAChB,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,CAAC,OAAO;IAChB,KAAK,EAAE,SAAS;IAChB,MAAM,EAAE,OAAO;IACf,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,QAAQ;IAChB,OAAO,EAAE,CAAC,QAAQ;CACnB,CAAC"}

package/src/constants/gyromagneticRatio.ts

@@ -1,49 +0,0 @@
-// sources:
-// https://en.wikipedia.org/wiki/Gyromagnetic_ratio
-
-// TODO: #13 can we have a better source and more digits ? @jwist
-
-export type Nuclei =
-  | '1H'
-  | '2H'
-  | '3H'
-  | '3He'
-  | '7Li'
-  | '13C'
-  | '14N'
-  | '15N'
-  | '17O'
-  | '19F'
-  | '23Na'
-  | '27Al'
-  | '29Si'
-  | '31P'
-  | '57Fe'
-  | '63Cu'
-  | '67Zn'
-  | '129Xe';
-
-type GyromagneticRatio = {
-  [key in Nuclei]: number;
-};
-
-export const gyromagneticRatio: GyromagneticRatio = {
-  '1H': 267.52218744e6,
-  '2H': 41.065e6,
-  '3H': 285.3508e6,
-  '3He': -203.789e6,
-  '7Li': 103.962e6,
-  '13C': 67.28284e6,
-  '14N': 19.331e6,
-  '15N': -27.116e6,
-  '17O': -36.264e6,
-  '19F': 251.662e6,
-  '23Na': 70.761e6,
-  '27Al': 69.763e6,
-  '29Si': -53.19e6,
-  '31P': 108.291e6,
-  '57Fe': 8.681e6,
-  '63Cu': 71.118e6,
-  '67Zn': 16.767e6,
-  '129Xe': -73.997e6,
-};