plasma-signal-processor

A comprehensive signal processing library for scientific instrumentation, plasma diagnostics, and experimental physics data analysis. Built from real-world experience in fusion energy research.


Version 0.1.0 - Initial release with core functionality

⚠️ Important Limitations (v0.1.0)

This is an early release focused on correctness and reliability:

- Savitzky-Golay filter: Only supports window size 5 (will throw error for other sizes)
- IFFT: Not yet implemented (throws error if called)
- Peak prominence: Uses a simplified approximation, not true topographic prominence
- FFT scaling: Returns raw DFT magnitudes (see documentation for conversion to amplitude/power spectrum)
- Median filter: O(n·w·log w) complexity - may be slow for large windows or real-time use

For production-critical applications, validate results against established tools (scipy, MATLAB, etc.).

Features

- Noise Analysis & Reduction: SNR calculation, outlier detection, wavelet denoising, baseline correction
- Digital Filtering: Moving average, Savitzky-Golay, Butterworth, median filters, and more
- Frequency Analysis: FFT, power spectral density, spectrograms, dominant frequency detection
- Signal Analysis: Peak detection, cross-correlation, zero-crossing detection, envelope calculation
- Statistical Tools: Comprehensive statistics, interpolation, window functions
- TypeScript: Full type definitions for excellent IDE support

Installation

``bash
npm install plasma-signal-processor
`

Or with yarn:

`bash
yarn add plasma-signal-processor
`

Quick Start

`typescript
import {
NoiseAnalysis,
DigitalFilters,
FrequencyAnalysis,
SignalAnalysis,
} from 'plasma-signal-processor';

// Your noisy signal data
const signal = [/ your data /];
const sampleRate = 10000; // Hz

// 1. Analyze noise characteristics
const noise = NoiseAnalysis.estimateNoise(signal, { method: 'mad' });
console.log('Noise level:', noise.stdDev);

// 2. Remove baseline drift
const corrected = NoiseAnalysis.removeBaseline(signal, 'median');

// 3. Apply smoothing filter
const filtered = DigitalFilters.savitzkyGolay(corrected, 5);

// 4. Calculate SNR
const snr = NoiseAnalysis.calculateSNR(filtered, noise.stdDev);
console.log('SNR:', snr, 'dB');

// 5. Find peaks
const peaks = SignalAnalysis.findPeaks(filtered, {
minHeight: 10,
minDistance: 50,
});

// 6. Frequency analysis
const fft = FrequencyAnalysis.computeFFT(filtered, sampleRate);
const dominant = FrequencyAnalysis.findDominantFrequency(filtered, sampleRate);
console.log('Dominant frequency:', dominant.frequency, 'Hz');
`

Core Modules

$3

Handle noisy scientific data with robust noise estimation and reduction techniques.

`typescript
import { NoiseAnalysis } from 'plasma-signal-processor';

// Estimate noise using MAD (robust to outliers)
const noise = NoiseAnalysis.estimateNoise(data, { method: 'mad' });

// Calculate Signal-to-Noise Ratio
const snr = NoiseAnalysis.calculateSNR(signal, noiseLevel);

// Detect and remove outliers
const outliers = NoiseAnalysis.detectOutliers(data, 1.5);
const cleaned = NoiseAnalysis.removeOutliers(data, 1.5);

// Noise gating (threshold below which signal is zeroed)
const gated = NoiseAnalysis.noiseGate(data, 0.1, {
relative: true,
smoothTransition: true,
});

// Baseline correction
const baselineCorrected = NoiseAnalysis.removeBaseline(data, 'rolling', 100);

// Wavelet denoising
const denoised = NoiseAnalysis.waveletDenoise(data, 1.0);
`

$3

Various filtering techniques optimized for scientific instrumentation.

`typescript
import { DigitalFilters } from 'plasma-signal-processor';

// Moving average (simple smoothing)
const smoothed = DigitalFilters.movingAverage(data, 10);

// Savitzky-Golay filter (preserves peak shapes)
const sgFiltered = DigitalFilters.savitzkyGolay(data, 5);

// Exponential moving average (good for real-time)
const ema = DigitalFilters.exponentialMovingAverage(data, 0.1);

// Lowpass filter (remove high-frequency noise)
const lowpassed = DigitalFilters.lowpass(data, {
cutoffFrequency: 1000,
sampleRate: 10000,
});

// Highpass filter (remove DC offset and drift)
const highpassed = DigitalFilters.highpass(data, {
cutoffFrequency: 100,
sampleRate: 10000,
});

// Bandpass filter
const bandpassed = DigitalFilters.bandpass(data, {
lowCutoff: 100,
highCutoff: 1000,
sampleRate: 10000,
});

// Median filter (excellent for spike removal)
const medianFiltered = DigitalFilters.median(data, 5);

// Butterworth filter (sharper rolloff)
const butterworth = DigitalFilters.butterworthLowpass(data, {
cutoffFrequency: 1000,
sampleRate: 10000,
});

// Multi-pass filtering for sharper response
const sharpFiltered = DigitalFilters.multipass(
data,
(d) => DigitalFilters.lowpass(d, { cutoffFrequency: 1000, sampleRate: 10000 }),
3 // number of passes
);
`

$3

Comprehensive Fourier analysis tools.

`typescript
import { FrequencyAnalysis } from 'plasma-signal-processor';

// Compute FFT with full spectral information
const fft = FrequencyAnalysis.computeFFT(data, sampleRate);
// Returns: { frequencies, magnitudes, phases, powerSpectrum, real, imaginary }

// Power spectral density
const psd = FrequencyAnalysis.powerSpectralDensity(data, sampleRate);

// Spectrogram (time-frequency analysis)
const spectrogram = FrequencyAnalysis.spectrogram(data, sampleRate, {
windowSize: 256,
hopSize: 128,
windowFunction: 'hanning',
});

// Find dominant frequency
const dominant = FrequencyAnalysis.findDominantFrequency(data, sampleRate);
console.log(dominant.frequency, dominant.magnitude);

// Total harmonic distortion
const thd = FrequencyAnalysis.totalHarmonicDistortion(
data,
sampleRate,
fundamentalFrequency
);
`

$3

Advanced signal processing and feature extraction.

`typescript
import { SignalAnalysis } from 'plasma-signal-processor';

// Peak detection with prominence
const peaks = SignalAnalysis.findPeaks(data, {
minHeight: 10,
minDistance: 50,
threshold: 2, // minimum prominence
});

// Cross-correlation between signals
const correlation = SignalAnalysis.crossCorrelation(signal1, signal2, {
normalize: true,
maxLag: 100,
});

// Auto-correlation
const autoCorr = SignalAnalysis.autoCorrelation(signal);

// Zero crossing detection
const crossings = SignalAnalysis.findZeroCrossings(data, 'rising');

// Signal envelope
const envelope = SignalAnalysis.envelope(data, 'rms', 50);

// Derivative and integral
const derivative = SignalAnalysis.derivative(data, sampleRate);
const integral = SignalAnalysis.integrate(data, sampleRate);

// Edge detection
const edges = SignalAnalysis.detectEdges(data, 0.5, 'both');

// Phase shift between signals
const phaseShift = SignalAnalysis.phaseShift(signal1, signal2);
`

$3

`typescript
import { Statistics, WindowFunctions, Interpolation } from 'plasma-signal-processor';

// Comprehensive statistics
const stats = Statistics.summary(data);
// Returns: { mean, median, stdDev, variance, min, max, range, skewness, kurtosis }

// Individual metrics
const mean = Statistics.mean(data);
const median = Statistics.median(data);
const stdDev = Statistics.stdDev(data);
const rms = Statistics.rms(data);
const percentile95 = Statistics.percentile(data, 95);

// Window functions
const windowed = WindowFunctions.applyWindow(data, 'hanning');

// Interpolation
const interpolated = Interpolation.linear(xValues, yValues, newX);
`

Real-World Use Cases

$3

`typescript
// Process Thomson scattering data from plasma diagnostic
const raw = loadDiagnosticData();

// Remove baseline
const corrected = NoiseAnalysis.removeBaseline(raw, 'median');

// Smooth while preserving peak shape
const filtered = DigitalFilters.savitzkyGolay(corrected, 5);

// Find scattering peaks
const peaks = SignalAnalysis.findPeaks(filtered, {
minHeight: threshold,
minDistance: 100,
});

// Calculate electron temperature from peak width
const temperature = calculateTemperature(peaks);
`

$3

`typescript
// Analyze X-ray/UV spectroscopy data
const spectrum = loadXUVData();

// Noise reduction
const denoised = NoiseAnalysis.waveletDenoise(spectrum, 2.0);

// Baseline subtraction (rolling window for varying background)
const baselineRemoved = NoiseAnalysis.removeBaseline(denoised, 'rolling', 200);

// Peak detection for spectral lines
const spectralLines = SignalAnalysis.findPeaks(baselineRemoved, {
minHeight: 100,
threshold: 5, // prominence
});
`

$3

`typescript
// Analyze plasma instabilities over time
const timeSeries = loadTimeSeriesData();
const sampleRate = 100000; // 100 kHz

// Compute spectrogram to see frequency evolution
const spectrogram = FrequencyAnalysis.spectrogram(timeSeries, sampleRate, {
windowSize: 1024,
hopSize: 256,
windowFunction: 'hamming',
});

// Detect mode transitions
const edges = SignalAnalysis.detectEdges(timeSeries, 0.1, 'both');
`

API Reference

Full API documentation is available in the TypeScript definitions. Your IDE will provide autocomplete and inline documentation.

Examples

See the examples/ directory for complete working examples:

- thomson-scattering.ts - Processing Thomson scattering diagnostic data
- More examples coming soon!

Development

`bash


Install dependencies

npm install

Build

npm run build

Run tests

npm test

Run tests in watch mode

npm run test:watch

Generate coverage report

npm run test:coverage

Lint

npm run lint

Format code

npm run format
``

Background

This library was developed from scientific instrumentation workflows, with particular focus on plasma diagnostics for fusion energy research. It incorporates techniques commonly used in:

- Plasma diagnostics (Thomson scattering, XUV spectroscopy, polarimetry)
- High-noise experimental environments
- Real-time data acquisition systems
- Scientific instrumentation

Note: While the algorithms are grounded in physics research, this is a general-purpose DSP library suitable for any scientific signal processing application.

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

License

Apache License 2.0 – see the LICENSE file for details.

Author

Developed from scientific instrumentation workflows in experimental physics research.

Acknowledgments

Built from techniques used in plasma physics research and diagnostic systems for fusion energy experiments.