A comprehensive signal processing library for scientific instrumentation, plasma diagnostics, and experimental physics data analysis
npm install plasma-signal-processorA 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
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.).
- 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
``bash`
npm install plasma-signal-processor
Or with yarn:
`bash`
yarn add plasma-signal-processor
`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');
`
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);
`
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
);
`
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
);
`
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);
`
`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);
`
`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);
`
`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
});
`
`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');
`
Full API documentation is available in the TypeScript definitions. Your IDE will provide autocomplete and inline documentation.
See the examples/ directory for complete working examples:
- thomson-scattering.ts - Processing Thomson scattering diagnostic data
- More examples coming soon!
`bashInstall dependencies
npm install
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.
Contributions are welcome! Please feel free to submit a Pull Request.
Apache License 2.0 – see the LICENSE file for details.
Developed from scientific instrumentation workflows in experimental physics research.
Built from techniques used in plasma physics research and diagnostic systems for fusion energy experiments.