nmr-processing 16.0.1 → 17.1.0

package/nmr-processing.d.ts

@@ -1,16 +1,18 @@
 import { AnalizeMultipletOptions } from 'multiplet-analysis';
 import { BaseRegression } from 'ml-regression-base';
+import { DataReIm } from 'ml-spectra-processing';
 import { DataXReIm } from 'ml-spectra-processing';
 import { DataXY } from 'cheminfo-types';
 import { DoubleArray } from 'cheminfo-types';
 import { ExponentialRegression } from 'ml-regression-exponential';
 import type { FilterXYType } from 'ml-signal-processing';
 import { FromTo } from 'cheminfo-types';
+import { GroupedDiaID } from 'openchemlib-utils';
 import { GSDOptions } from 'ml-gsd';
 import { GSDPeakOptimized } from 'ml-gsd';
 import { GSDPeakOptimizedID } from 'ml-gsd';
 import { JoinBroadPeaksOptions } from 'ml-gsd';
-import type { LightLogger } from 'cheminfo-types';
+import { LightLogger } from 'cheminfo-types';
 import { Logger } from 'cheminfo-types';
 import { Matrix } from 'ml-matrix';
 import * as matrixPeakFinders from 'ml-matrix-peaks-finder';
@@ -28,7 +30,6 @@ import type { Peak2D as Peak2D_2 } from 'ml-matrix-peaks-finder';
 import { PeakXYWidth } from 'cheminfo-types';
 import { PointXY } from 'cheminfo-types';
 import { Shape1D } from 'ml-peak-shape-generator';
-import { Spectrum2D } from 'spectrum-generator';
 import { TopicMolecule } from 'openchemlib-utils';
 import { XYEquallySpacedOptions } from 'ml-spectra-processing';
 import type { XYNumber } from 'spectrum-generator';
@@ -42,6 +43,8 @@ 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 {
@@ -127,6 +130,11 @@ export declare interface ApplyWindowOptions {
     output?: DoubleArray;
 }
 
+export declare interface AtomMapping {
+    label: string;
+    atom: number;
+}
+
 declare type AtomTypes = 'H' | 'C';
 
 export declare interface AutoPhaseCorrection2D {
@@ -294,24 +302,20 @@ export declare const carbonImpurities: DatabaseNMREntry[];
  */
 export declare function checkIntegralKind(integral: Integral): boolean;
 
-/**
- * check if the input string corresponds to a multiplet (pattern), it could has a common name, acs or one letter abbreviation.
- * @param string - pattern name or abbreviation.
- * @param rejected - list of patterns that should not match with the input pattern. e.g 'massive' as input will return false if rejected = ['m'].
- */
-export declare function checkMultiplet(string: string, rejected?: string[]): boolean | undefined;
-
-/**
- * check the input string corresponds to a composed pattern like dt or dd. it splits into indivitual patterns and use checkMultiplet function.
- * @param multiplicity - pattern name or abbreviation.
- * @param rejected - list of patterns that should not match with any pattern. e.g 'dt' as input will return false if rejected = ['t'].
- */
-export declare function checkMultiplicity(multiplicity: string, rejected?: string[]): boolean;
+export declare function checkMultiplicity(multiplicity: string, rejected?: OneLetterMultiplet[]): boolean;
 
 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 {
@@ -323,9 +327,25 @@ 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[];
 
-export declare const couplingPatterns: string[];
+declare interface CouplingConstant {
+    Coupling: string;
+    Shift1: string;
+    Shift2: string;
+}
+
+export declare const couplingPatterns: OneLetterMultiplet[];
 
 export declare function createApodizationWindowData(options: {
     windowOptions: {
@@ -355,6 +375,27 @@ 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;
@@ -362,8 +403,8 @@ export declare function ctParser(sdf: string, csv: string, options: {
     logger?: LightLogger;
 }): {
     molecules: ParsedMolecule[];
-    sections: Record<string, any>;
-    groups: any[];
+    sections: ReturnType<typeof ctCSVParser>;
+    groups: GroupData[];
 };
 
 export declare type DataBaseLevelEntry = number | [number] | [number, number, number, number | null, number] | undefined | NMRSignalStatistics;
@@ -644,7 +685,21 @@ export { Filters2DManager }
  * Look for a multiplet based on the pattern name or abbreviation.
  * @param name - pattern name or abbreviation.
  */
-export declare function findMultiplet(name: string): MultipletDefinition | undefined;
+export declare function findMultiplet(name: string): MatchingMultiplicity | undefined;
+
+/**
+ * Finds a peak that can serve as a pivot point within specified boundaries.
+ * The pivot is selected based on its y-value being above a threshold and its position
+ * being closest to either boundary (minX or maxX).
+ *
+ * @param peaks - Array of points containing x and y coordinates
+ * @param options - Configuration object for finding the pivot
+ *
+ * @returns The peak that serves as pivot point
+ *
+ * @throws {Error} If peaks array is empty
+ */
+export declare function findPivot(peaks: PointXY[], options: XYObjectSidePointOptions): PointXY;
 
 declare type FordwardLPDimension1 = FilterFactory<Entry2D, Partial<BackwardLPOptions>> & Pick<FordwardLPDimension1Options, 'name'>;
 
@@ -894,6 +949,19 @@ 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[];
+}
+
 export declare const impurities: SolventImpurities;
 
 export declare type Impurity = Record<string, ImpuritySignal[]>;
@@ -1131,7 +1199,19 @@ export declare function mapZones(zones: Zone[], datum: Entry2D, options?: MapOpt
     assignment?: string;
 }[];
 
-export declare function markSolventPeaks<T extends NMRRange>(input: T[], solventSignals: NMRSignal1D[], options?: any): T[];
+export declare function markSolventPeaks<T extends NMRRange>(input: T[], solventSignals: NMRSignal1D[], options?: MarkSolventPeaksOptions): T[];
+
+declare interface MarkSolventPeaksOptions {
+    /** The NMR spectrometer frequency in MHz
+     * @default 400
+     */
+    frequency?: number;
+}
+
+export declare type MatchingMultiplicity = MultipletDefinition & {
+    match: string;
+    isBroad: boolean;
+};
 
 declare interface MatrixFilter {
     name: FilterXYType['name'];
@@ -1193,9 +1273,19 @@ declare interface MatrixToStocsyOptions {
     colors?: string[];
 }
 
+declare interface MinMaxContent {
+    z: Float64Array[];
+    minX: number;
+    maxX: number;
+    minY: number;
+    maxY: number;
+    minZ: number;
+    maxZ: number;
+}
+
 export declare interface MultipletDefinition {
     label: string;
-    value: string;
+    value: OneLetterMultiplet;
     acs?: string;
     names: string[];
     multiplicity: number | null;
@@ -1330,12 +1420,6 @@ export declare interface ObservedNucleusData {
     frequency: number;
 }
 
-/**
- * This function will generate an object compatible with NMR-ium
- *
- * @param molecule
- * @param options
- */
 declare interface OneDOptions {
     proton: FromTo;
     carbon: FromTo;
@@ -1343,6 +1427,8 @@ declare interface OneDOptions {
     lineWidth: number;
 }
 
+export declare type OneLetterMultiplet = 's' | 'd' | 't' | 'q' | 'i' | 'h' | 'p' | 'o' | 'n' | 'm';
+
 export declare function optimizeSignals(data: DataXY, signals: Signal[], options: OptimizeSignalsOptions): {
     delta: number;
     js: Jcoupling[];
@@ -1535,6 +1621,8 @@ declare interface ParsedMolecule {
     id: string;
 }
 
+declare type ParsedRow = Record<string, string>;
+
 export declare interface Peak1D extends Omit<NMRPeak1D, 'id'>, BasePeak {
     originalX?: number;
 }
@@ -1564,7 +1652,12 @@ export declare interface Peaks {
 }
 
 /**
- * Try to remove peaks of impurities.
+ * Filters impurities from a list of NMR peaks based on the specified options.
+ *
+ * @template T - The type of NMR peaks.
+ * @param {T[]} peakList - The list of NMR peaks to be filtered.
+ * @param {OptionsPeaksFilterImpurities} [options={}] - The options for filtering impurities.
+ * @returns {T[]} The filtered list of NMR peaks.
  */
 export declare function peaksFilterImpurities<T extends NMRPeak1D>(peakList: T[], options?: OptionsPeaksFilterImpurities): T[];
 
@@ -1768,22 +1861,58 @@ declare interface PredictCOSYOptions {
 export declare interface Predicted {
     molfile: string;
     molfileWithH: string;
-    hoses: any[];
-    diaIDs: any[] | undefined;
-    groupedDiaIDs: any[];
+    hoses: string[];
+    diaIDs: string[] | undefined;
+    groupedDiaIDs: GroupedDiaID[];
     moleculeWithHydrogens: Molecule;
-    distanceMatrix: any[];
+    distanceMatrix: NumberArray[];
     spectra: PredictedSpectra;
 }
 
-export declare interface PredictedSpectra {
+export declare interface Predicted1DSpectra {
     proton?: PredictionBase1D;
     carbon?: PredictionBase1D;
+}
+
+export declare interface Predicted2DSpectra {
     cosy?: PredictionBase2D;
     hsqc?: PredictionBase2D;
     hmbc?: PredictionBase2D;
 }
 
+export declare interface PredictedSpectra extends Predicted1DSpectra, Predicted2DSpectra {
+}
+
+declare interface PredictedSpectrum1D {
+    data: {
+        x: NumberArray;
+        re: NumberArray;
+        im: null;
+    };
+    info: Spectrum1DInfo;
+    ranges: {
+        values: Array<{
+            from: number;
+            to: number;
+        }>;
+    };
+}
+
+declare interface PredictedSpectrum2D {
+    data: {
+        rr: MinMaxContent & {
+            noise: number;
+        };
+    };
+    info: Spectrum2DInfo;
+    zones: {
+        values: Array<{
+            x: FromTo;
+            y: FromTo;
+        }>;
+    };
+}
+
 /**
  * Generate the correlation bidimensional nmr peaks based on the number of bonds between a pair of atoms
  * @returns {Promise<object>} - object with molfile, diaIDs, 2D signals joined signals and zones.
@@ -1911,12 +2040,14 @@ export declare interface PredictProtonOptions {
     cache?: PredictionCacheFn;
 }
 
-export declare function predictSpectra(molecule: Molecule, options?: PredictAllSpectraOptions): Promise<{
-    spectra: any[];
-    molecules: {
+export declare function predictSpectra(molecule: Molecule, options?: PredictAllSpectraOptions): Promise<PredictSpectraResult>;
+
+declare interface PredictSpectraResult {
+    spectra: Array<PredictedSpectrum1D | PredictedSpectrum2D>;
+    molecules: Array<{
         molfile: string;
-    }[];
-}>;
+    }>;
+}
 
 declare type Properties = ListField | SelectField | StringField | NumberField | BooleanField | LabelField;
 
@@ -2074,6 +2205,11 @@ declare function reapplyFilters_2(datum: Entry2D, options?: {
     logger?: Logger;
 }): void;
 
+export declare function reimComplexBackwardLinearPrediction(data: DataReIm, options: BackwardLPOptions): {
+    re: Float64Array<ArrayBuffer>;
+    im: Float64Array<ArrayBuffer>;
+};
+
 declare function resetDiaIDs(range: Range_2): void;
 
 declare interface RestrictionByCS {
@@ -2094,6 +2230,13 @@ 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[];
@@ -2246,7 +2389,15 @@ declare interface SignalProcessingFilter extends BaseFilter {
     value: MatrixOptions;
 }
 
-export declare function signals2DToZ(signals: NMRSignal2D[], options?: Signals2DToZOptions): Spectrum2D;
+export declare function signals2DToZ(signals: NMRSignal2D[], options?: Signals2DToZOptions): {
+    minX: number;
+    maxX: number;
+    minY: number;
+    maxY: number;
+    minZ: number;
+    maxZ: number;
+    z: Float64Array<ArrayBufferLike>[];
+};
 
 declare interface Signals2DToZOptions {
     /**
@@ -2398,6 +2549,12 @@ declare interface Simulate1DOptions {
     shape?: Shape1D;
 }
 
+/**
+ * This function will generate an object compatible with NMR-ium
+ *
+ * @param molecule
+ * @param options
+ */
 declare interface SimulationOptions {
     frequency: number;
     oneD?: Partial<OneDOptions>;
@@ -2461,6 +2618,25 @@ export declare interface SpectraData2DWithIds extends Omit<SpectraData2D, 'zones
 
 export declare type SpectraDataWithIds = SpectraData1DWithIds | SpectraData2DWithIds;
 
+declare interface Spectrum1DInfo {
+    nucleus: string;
+    dimension: number;
+    isComplex: boolean;
+    originFrequency: number;
+    baseFrequency: number;
+    pulseSequence: string;
+    experiment: string;
+    isFt: boolean;
+}
+
+declare interface Spectrum2DInfo {
+    nucleus: string[];
+    originFrequency: string;
+    baseFrequency: string | number;
+    pulseSequence: string;
+    experiment: string;
+}
+
 export declare interface SpinSystem {
     /**
      * isolated clusters from a similarity/connectivity matrix
@@ -2485,11 +2661,11 @@ export declare interface SpinSystem {
 }
 
 /**
- * split a composed pattern like dt or ddt into ['d','t'] and ['d','d','t']
+ * split a composed pattern like dt or ddt into an array of objects
  * @param multiplet - pattern or abbreviation.
  * @returns
  */
-export declare function splitPatterns(multiplet: string): string[];
+export declare function splitPatterns(multiplet: string): MatchingMultiplicity[];
 
 export declare interface SplitSpinSystemOptions {
     /**
@@ -2664,12 +2840,23 @@ declare function unlink(range: Range_2, options?: UnlinkOptions): Range_2;
      regression: T1Regression;
  };
 
+ export declare function xyGetPivot(data: DataXY<Float64Array>, options?: {
+     thresholdFactor?: number;
+     frequency?: number;
+ }): PointXY;
+
  export declare function xyKineticFirstOrder(data: DataXY): {
      regression: ExponentialRegression;
      rateConstant: number;
      initialConcentration: number;
  };
 
+ declare interface XYObjectSidePointOptions {
+     minX: number;
+     maxX: number;
+     thresholdFactor?: number;
+ }
+
  export declare function xyPeaksOptimization<T extends PeakXYWidth>(data: DataXY, peaks: T[], options: XYPeaksOptimizationOptions): (T extends {
      id: string;
  } ? GSDPeakOptimizedID : GSDPeakOptimized)[];