nmr-processing 17.1.2 → 17.2.0

package/nmr-processing.d.ts

@@ -7,16 +7,16 @@ import type { DoubleArray } from 'cheminfo-types';
 import { ExponentialRegression } from 'ml-regression-exponential';
 import type { FilterXYType } from 'ml-signal-processing';
 import { FromTo } from 'cheminfo-types';
+import type { GenerateSpectrumOptions } from 'spectrum-generator';
 import type { GroupedDiaID } from 'openchemlib-utils';
 import type { GSDOptions } from 'ml-gsd';
 import { GSDPeakOptimized } from 'ml-gsd';
 import { GSDPeakOptimizedID } from 'ml-gsd';
 import type { JoinBroadPeaksOptions } from 'ml-gsd';
-import type { LightLogger } from 'cheminfo-types';
+import { LightLogger } from 'cheminfo-types';
 import type { Logger } from 'cheminfo-types';
 import { Matrix } from 'ml-matrix';
 import type { Molecule } from 'openchemlib/full';
-import type { Molecule as Molecule_2 } from 'openchemlib/minimal';
 import type { NmrData1D } from 'cheminfo-types';
 import type { NmrData2D } from 'cheminfo-types';
 import type { NmrData2DContent } from 'cheminfo-types';
@@ -28,7 +28,7 @@ import type { OptionsSG1D } from 'spectrum-generator';
 import type { Peak2D as Peak2D_2 } from 'ml-matrix-peaks-finder';
 import type { PeakXYWidth } from 'cheminfo-types';
 import { PointXY } from 'cheminfo-types';
-import { Shape1D } from 'ml-peak-shape-generator';
+import type { Shape1D } from 'ml-peak-shape-generator';
 import type { TopicMolecule } from 'openchemlib-utils';
 import type { XYEquallySpacedOptions } from 'ml-spectra-processing';
 import type { XYNumber } from 'spectrum-generator';
@@ -42,8 +42,6 @@ export declare interface AirplsOptions {
     tolerance: number;
 }
 
-declare type AnalysisInfoSection = Record<string, string>;
-
 declare type Apodization1D = FilterFactory<Entry1D, Apodization2DOptions> & Pick<Apodization1DFilterOptions, 'name'>;
 
 declare interface Apodization1DFilterOptions extends BaseFilter {
@@ -128,11 +126,58 @@ export declare interface ApplyWindowOptions {
     output?: DoubleArray;
 }
 
-export declare interface AtomMapping {
+declare type Atom = ReturnType<typeof getAtoms>[0];
+
+declare interface AtomInput {
+    id: ID;
+    pid: ID;
+    n: string;
+    r: string;
+    nc: number;
+    crcan: number;
+    crrd: number;
+    crnmr: number;
+    o: number;
+    rs: number[];
+    sf: number[];
+    fc: number;
+    c: number;
+    c2d: [number, number, number];
+    c3d: [number, number, number];
+    p2d: string | null;
+    s: ID | null;
+}
+
+/**
+ * Interface for atom mapping information
+ */
+declare interface AtomMapping {
     label: string;
     atom: number;
 }
 
+declare interface AtomOutput {
+    id: ID;
+    parentID: ID;
+    name: string;
+    remarks: string;
+    nucleusType: NucleusType;
+    cipRank: {
+        canonical: number;
+        rd: number;
+        nmr: number;
+    };
+    ordinal: number;
+    stereochemistryFlags: number[];
+    spinSystemFlags: number[];
+    formalcharge: number;
+    partialCharge: number;
+    coordinates2D: [number, number, number];
+    coordinates3D: [number, number, number];
+    parent2D: string | null;
+    shift: ID | null;
+}
+
 declare type AtomTypes = 'H' | 'C';
 
 export declare interface AutoPhaseCorrection2D {
@@ -266,6 +311,14 @@ declare interface BasePeak {
     id: string;
 }
 
+declare interface BondInput {
+    id: ID;
+    b: number;
+    rs: number[];
+    sf: number[];
+    a: [ID, ID];
+}
+
 declare interface BooleanField extends Field<boolean> {
     type: 'boolean';
 }
@@ -306,14 +359,6 @@ declare function checkRangeKind(range: Range_2): boolean;
 
 declare function checkSignalKinds(range: Range_2, kinds: string[]): boolean;
 
-export declare interface ChemicalShift {
-    Element: string;
-    Shift: string;
-    Spincount: string;
-    Nucleicount: string;
-    Name: string;
-}
-
 declare type CommonField = SelectField | StringField | NumberField | BooleanField | LabelField;
 
 declare interface CompilePatternOptions {
@@ -325,22 +370,27 @@ declare interface CompilePatternOptions {
     };
 }
 
-export declare interface Coupling {
-    atomFrom: number;
-    atomTo: number;
-    atomLabelTo: string;
-    value: number;
-    key: string;
-    toDiaID: number;
-    pathLength: number;
-}
-
 export declare const couplingACSPatterns: string[];
 
-declare interface CouplingConstant {
-    Coupling: string;
-    Shift1: string;
-    Shift2: string;
+declare interface CouplingGroupInput {
+    id: string;
+    parentID: string;
+    name: string;
+    remarks: string;
+    v: number;
+    vl: number;
+    vh: number;
+    sf: number[];
+    t: string;
+}
+
+declare interface CouplingInput {
+    id: ID;
+    pid: ID;
+    n: string;
+    r: string;
+    cg: ID;
+    s: [ID, ID];
 }
 
 export declare const couplingPatterns: OneLetterMultiplet[];
@@ -373,39 +423,36 @@ export declare interface CreateSignals2DOptions {
     maxX: number;
 }
 
-/**
- * CT results are stored in a CSV file with a specific format and a SDF file.
- * This function will parse the CSV and return an object with the different sections.
- * @param csv
- * @returns
- */
-declare function ctCSVParser(csv: string, options: {
-    logger: LightLogger;
-}): CtCSVParserResult;
-
-declare interface CtCSVParserResult {
-    'ANALYSIS INFO'?: AnalysisInfoSection;
-    SCORES?: ScoreEntry[];
-    SPINSYSTEMS?: ParsedRow[];
-    'CHEMICAL SHIFTS (ppm)'?: ParsedRow[];
-    'COUPLING CONSTANTS (Hz)'?: ParsedRow[];
-    LINESHAPES?: ParsedRow[];
-    QMGI?: ParsedRow[];
-    [key: string]: SectionData | undefined;
-}
-
-export declare function ctParser(sdf: string, csv: string, options: {
-    OCL: {
-        Molecule: typeof Molecule_2;
-    };
-    logger?: LightLogger;
-}): {
-    molecules: ParsedMolecule[];
-    sections: ReturnType<typeof ctCSVParser>;
-    groups: GroupData[];
-};
+declare interface CTJSONInput {
+    v: number;
+    vl: number;
+    vh: number;
+    f: number;
+    bi: number;
+    il: number;
+    sf: number[];
+    sst: number;
+    at: number;
+    ik: string;
+    p: PopulationInput[];
+    l: LineShapeData[];
+    sg: ShiftGroupEntry[];
+    s: ShiftInput[];
+    cg: CouplingGroupInput[];
+    c: CouplingInput[];
+    a: AtomInput[];
+    b: BondInput[];
+}
+
+declare interface CTSignal {
+    delta: number;
+    diaIDs: string[];
+    js: Jcoupling[];
+    nbAtoms: number;
+    atoms: number[];
+}
 
-export declare type DataBaseLevelEntry = number | [number] | [number, number, number, number | null, number] | undefined | NMRSignalStatistics;
+export declare type DataBaseLevelEntry = number | [number] | [number, number, number, number | null, number] | undefined | HOSEPredictionStatistics;
 
 export declare type DataBaseLevelStructure = Record<string, DataBaseLevelEntry>;
 
@@ -867,10 +914,12 @@ export declare interface GetAssignmentsOptions {
      * correlation options
      */
     correlation?: {
-        tolerance?: number;
+        tolerance?: Record<string, number>;
     };
 }
 
+declare function getAtoms(a: AtomInput[]): AtomOutput[];
+
 export declare interface GetAutoAssignmentInput {
     spectra: SpectraData[];
     /**
@@ -948,19 +997,36 @@ export declare interface GetPeakListOptions extends GSDOptions, OptimizePeaksOpt
 
 export declare function getShiftX(spectrum: Entry1D): number;
 
-export declare interface GroupData {
-    id: string;
-    molfile: string;
-    spinSystem: {
-        SSType: string;
-    };
-    couplingConstants: CouplingConstant[];
-    chemicalShifts: ChemicalShift[];
-    atomsMapping: AtomMapping[];
-    atomsMappingLookup: Record<string, number>;
-    signals?: NMRSignal1D[];
+declare interface HOSEPrediction {
+    /**
+     * In case the prediction is based on HOSE codes, this is the sphere
+     * used to make the prediction.
+     */
+    sphere: number;
+    /**
+     * If the prediction is based on a database of HOSE codes, those
+     * are the statistics for this specific HOSE code used for the prediction.
+     */
+    statistics: HOSEPredictionStatistics;
+}
+
+/**
+ * When predicted signals we obtain in some case statistics about the signals.
+ * This allows to determine what are the expected range of chemical shifts to expect.
+ */
+export declare interface HOSEPredictionStatistics {
+    mean: number;
+    min: number;
+    q1?: number;
+    median: number;
+    q3?: number;
+    max: number;
+    sd?: number;
+    nb: number;
 }
 
+declare type ID = string;
+
 export declare const impurities: SolventImpurities;
 
 export declare type Impurity = Record<string, ImpuritySignal[]>;
@@ -1077,6 +1143,24 @@ declare interface LabelField extends BaseField {
     type: 'label';
 }
 
+declare interface LineShapeData {
+    id: string;
+    pid: string;
+    n: string;
+    r: string;
+    sf: number[];
+    l: {
+        v: number;
+        low: number;
+        high: number;
+    };
+    g: {
+        v: number;
+        low: number;
+        high: number;
+    };
+}
+
 declare interface ListField extends Field<string[]> {
     type: 'list';
     properties: Record<string, CommonField>;
@@ -1104,44 +1188,7 @@ declare interface MapOptions {
 
 export declare function mapPeaks(peaks: Peak1D[], spectrum: Entry1D, options?: MapOptions): Peak1D[];
 
-export declare function mapRanges(ranges: Range_2[] | NMRRange[], spectrum: Entry1D, options?: MapOptions): {
-    absolute: number;
-    signals: {
-        originalDelta: number | undefined;
-        delta: number;
-        multiplicity: string;
-        js: Jcoupling[];
-        nbAtoms?: number | undefined;
-        atoms?: number[] | undefined;
-        assignment?: string | undefined;
-        diaIDs?: string[] | undefined;
-        integration?: number | undefined;
-        statistics?: NMRSignalStatistics | undefined;
-        kind: string;
-        id: string;
-        peaks: {
-            originalX: number;
-            x: number;
-            id: string;
-            kind?: string;
-            shape?: Shape1D;
-            y: number;
-            width: number;
-        }[];
-    }[];
-    originalFrom: number | undefined;
-    originalTo: number | undefined;
-    from: number;
-    to: number;
-    id: string;
-    kind: string;
-    integration: number;
-    nbAtoms?: number;
-    multiplicity?: string | undefined;
-    assignment?: string | undefined;
-    diaIDs?: string[] | undefined;
-    pubIntegral?: number | undefined;
-}[];
+export declare function mapRanges(ranges: Range_2[] | NMRRange[], spectrum: Entry1D, options?: MapOptions): Range_2[];
 
 export declare function mapZones(zones: Zone[], datum: Entry2D, options?: MapOptions): {
     signals: {
@@ -1339,7 +1386,7 @@ export declare interface NMRSignal1D {
     nbAtoms?: number;
     integration?: number;
     peaks?: NMRPeak1D[];
-    statistics?: NMRSignalStatistics;
+    prediction?: Prediction;
 }
 
 export declare type NMRSignal1DWithAtomsAndDiaIDs = MakeMandatory<NMRSignal1D, 'atoms' | 'diaIDs' | 'nbAtoms'>;
@@ -1361,21 +1408,6 @@ export declare type NMRSignal2DWithID<T extends Peak2D_2 = Peak2D_2> = MakeManda
 
 export declare type NMRSignal2DWithId = MakeMandatory<NMRSignal2D, 'id'>;
 
-/**
- * When predicted signals we obtain in some case statistics about the signals.
- * This allows to determine what are the expected range of chemical shifts to expect.
- */
-export declare interface NMRSignalStatistics {
-    mean: number;
-    min: number;
-    q1?: number;
-    median: number;
-    q3?: number;
-    max: number;
-    sd?: number;
-    nb: number;
-}
-
 export declare interface NMRZone {
     x: FromTo;
     y: FromTo;
@@ -1396,10 +1428,17 @@ declare interface NMRZoneWithIds extends Omit<NMRZone, 'signals' | 'id'> {
  */
 export declare function normalizeNucleus(nucleus: string): string;
 
+declare interface NucleusType {
+    atomicNumber: number;
+    isotope: number;
+}
+
 declare interface NumberField extends Field<number> {
     type: 'number';
 }
 
+declare type NumToNumFn = (x: number) => number;
+
 declare type NUSDimension2 = FilterFactory<Entry2D, IndirectDimensionOptions> & Pick<NUSDimension2Options, 'name'>;
 
 declare interface NUSDimension2Options extends BaseFilter {
@@ -1525,7 +1564,7 @@ declare interface OptionsPeaksToRanges {
     symRatio?: number;
 }
 
-export declare interface OptionsSignalsToXY {
+export declare interface OptionsSignalsToXY extends Partial<Simulate1DOptions> {
     frequency?: number;
     /**
      * The low limit of the ordinate variable.
@@ -1611,17 +1650,35 @@ declare type ParametersFromOptions = Record<Parameter, Record<string, number | (
 
 declare type ParametersFromSignal = Record<string, Record<string, number>>;
 
-declare interface ParsedMolecule {
-    atomsMapping: Array<{
-        atom: number;
-        label: string;
-    }>;
+export declare function parseCT(json: CTJSONInput, molfile: string, options: {
+    logger?: LightLogger;
+    atomicNumber?: number;
+}): {
+    signals: CTSignal[];
+    atomsMapping: Array<AtomMapping>;
     atomsMappingLookup: Record<string, number>;
     molfile: string;
     id: string;
+    shifts: ParsedShift[];
+    couplings: ParsedCoupling[];
+};
+
+/**
+ * Interface for coupling data between atoms
+ */
+declare interface ParsedCoupling {
+    from: Atom[];
+    to: Atom[];
+    value: number;
 }
 
-declare type ParsedRow = Record<string, string>;
+/**
+ * Interface for chemical shift data
+ */
+declare interface ParsedShift {
+    atoms: Atom[];
+    value: number;
+}
 
 export declare interface Peak1D extends Omit<NMRPeak1D, 'id'>, BasePeak {
     originalX?: number;
@@ -1766,6 +1823,17 @@ export declare interface PolynomialOptions {
     degree: number;
 }
 
+declare interface PopulationInput {
+    id: ID;
+    pid: ID;
+    n: string;
+    r: string;
+    v: number;
+    vl: number;
+    vh: number;
+    sf: number[];
+}
+
 /**
  * Generate the 2D correlation nmr peaks based on the number of bonds between a pair of atoms
  * @param molecule
@@ -1980,6 +2048,10 @@ declare interface PredictHSQCOptions {
     };
 }
 
+declare interface Prediction {
+    hose?: HOSEPrediction;
+}
+
 export declare interface Prediction1D extends PredictionBase1D {
     molfile: string;
     diaIDs: string[];
@@ -2229,13 +2301,6 @@ export declare interface ResurrectOptions {
     logger?: Logger;
 }
 
-declare interface ScoreEntry {
-    key: string;
-    value: string;
-}
-
-declare type SectionData = AnalysisInfoSection | ScoreEntry[] | ParsedRow[];
-
 declare interface SelectField extends Field<any> {
     type: 'select';
     choices: any[];
@@ -2282,6 +2347,38 @@ declare interface Shift2DYOptions {
     shift: number;
 }
 
+declare interface ShiftGroupEntry {
+    id: string;
+    pid: string;
+    n: string;
+    r: string;
+    v: number;
+    vl: number;
+    vh: number;
+    s: number;
+    c: number;
+    ex: boolean;
+    sf: number[];
+    g: number;
+    iw: number;
+    rs: {
+        v: number;
+        vl: number;
+        vh: number;
+        sf: number[];
+    };
+    p: ID;
+    l: ID;
+}
+
+declare interface ShiftInput {
+    id: ID;
+    pid: ID;
+    n: string;
+    r: string;
+    sg: ID;
+}
+
 declare type ShiftTarget = 'origin' | 'current';
 
 declare type ShiftX = FilterFactory<Entry1D, ShiftXOptions> & Pick<ShiftXFilterOptions, 'name'>;
@@ -2342,7 +2439,7 @@ declare interface SignalAxis {
 }
 
 /**
- * Join couplings smaller than a define tolerance.
+ * Join couplings smaller than a defined tolerance.
  * The resulting coupling should be an average of the existing one.
  * If pathLength is specified and is not always the same this property will be removed.
  * @param signal
@@ -2352,7 +2449,7 @@ export declare function signalJoinCouplings(signal: NMRSignal1D, options?: Signa
 
 export declare interface SignalJoinCouplingsOptions {
     /**
-     * if it is true the coupling pattens will normalized to ACS suggested values
+     * if it is true the coupling patterns will be normalized to ACS suggested values
      * @default false
      */
     acsFormat?: boolean;
@@ -2523,22 +2620,7 @@ export declare function signalsToXY(signals: NMRSignal1D[], options?: OptionsSig
  */
 export declare function simulate1D(spinSystemInput: SpinSystem, options?: Simulate1DOptions): DataXY<Float64Array<ArrayBufferLike>>;
 
-declare 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;
+export declare interface Simulate1DOptions extends SimulateXYPeaksOptions {
     /**
      * The low limit of the ordinate variable.
      * @default 0
@@ -2559,6 +2641,32 @@ declare interface Simulate1DOptions {
      * @default {kind:'gaussian'}
      */
     shape?: Shape1D;
+    /**
+     * Function to generate or add a baseline
+     */
+    baseline?: NumToNumFn;
+    /**
+     * Options to add noise to the spectrum
+     */
+    noise?: Extract<GenerateSpectrumOptions, 'noise'>;
+}
+
+declare interface SimulateXYPeaksOptions {
+    /**
+     * The frequency in Mhz of the fake spectrometer that records the spectrum.
+     * @default 400
+     */
+    frequency?: number;
+    /**
+     * 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;
 }
 
 /**
@@ -2606,7 +2714,7 @@ export declare type SpectraData = SpectraData1D | SpectraData2D;
 export declare interface SpectraData1D {
     id?: string;
     ranges: NMRRange[];
-    info: any;
+    info: Info1D;
 }
 
 export declare interface SpectraData1DWithIds extends Omit<SpectraData1D, 'ranges'> {
@@ -2620,7 +2728,7 @@ export declare interface SpectraData2D {
      * object with information about the spectrum, it is mandatory at the moment
      * to generate correlations.
      */
-    info: any;
+    info: Info2D;
 }
 
 export declare interface SpectraData2DWithIds extends Omit<SpectraData2D, 'zones'> {