LegendDSP.jl

https://legend-exp.github.io/LegendDSP.jl/stable
Admin
LegendDSP.jl is a Julia package providing digital signal processing (DSP) algorithms and filters...
Tokens:19,294
Snippets:134
Trust Score:9.7
Update:4 months ago
Show doc for...
Tokens:
Raw
### DSPConfig Example

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

Demonstrates how to create a DSPConfig object using data from a LegendData object. This is useful for configuring DSP algorithms with specific file data.

```julia
using LegendDSP
using LegendDataManagement

l200 = LegendData(:l200)
filekey = start_filekey(l200, (:p03, :r000, :cal))
dsp_config = DSPConfig(dataprod_config(l200).dsp(filekey).default)
```

--------------------------------

### ModifiedSincFilter Example

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

Illustrates the creation and application of a ModifiedSincFilter. This filter is designed for signal processing tasks where a sinc-like response is desired.

```julia
using RadiationDetectorSignals
using Unitful

n = 600
noise = 1.
t = range(0u"μs", 20u"μs", 2*n)
signal = vcat(zeros(n), 10*ones(n)) .+ (noise*rand(2*n) .- noise/2)
wf = RDWaveform(t, signal)

# define filter parameters and filter
flt = ModifiedSincFilter(d=4, m=1u"μs")

```

--------------------------------

### Get Signal Tail Statistics

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

Calculates statistics on the logarithmic tail of a signal within a specified interval. This can be used to analyze the decay or behavior of the signal's tail.

```julia
tailstats(signal::AbstractSamples, start::Real, stop::Real)
tailstats(signal::RDWaveform, start::RealQuantity, stop::RealQuantity)
```

--------------------------------

### Get Compressed Quality Cut Classifier

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

Retrieves a compressed classifier for quality cuts, suitable for scenarios where efficiency is critical. It accepts waveforms and an evaluation function, with an optional configuration object.

```julia
get_qc_classifier_compressed(wvfs::ArrayOfRDWaveforms, f_evaluate_qc::Function)
get_qc_classifier_compressed(wvfs::ArrayOfRDWaveforms, f_evaluate_qc::Function, config::DSPConfig)
```

--------------------------------

### Get Threshold Statistics

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

Calculates the standard deviation of signal samples that fall within a specified minimum and maximum bound. Bounds can be applied individually or ignored if not provided.

```julia
thresholdstats(signal::AbstractSamples, min::Real, min::Real)
thresholdstats(signal::RDWaveform, min::RealQuantity, max::RealQuantity)
```

--------------------------------

### Get Signal Maximum via Interpolation

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

Finds the maximum value of a signal within a given interval using quadratic interpolation. This provides a more precise maximum than simple sample inspection.

```julia
get_wvf_maximum(signal::AbstractSamples, start::Real, stop::Real)
get_wvf_maximum(signal::RDWaveform, start::RealQuantity, stop::RealQuantity)
```

--------------------------------

### Get Signal Extrema Statistics

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

Retrieves the minimum, maximum, and their corresponding time positions within a specified interval of a signal. Supports both generic AbstractSamples and RDWaveform types.

```julia
extremestats(signal::AbstractSamples, start::Real, stop::Real)
extremestats(signal::RDWaveform, start::RealQuantity, stop::RealQuantity)
```

--------------------------------

### Get Quality Cut Classifier

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

Obtains a classifier for quality cuts using provided waveforms and an evaluation function. The evaluation function typically uses a predefined SVM model to assess waveform quality.

```julia
get_qc_classifier(wvfs::ArrayOfRDWaveforms, f_evaluate_qc::Function)
```

--------------------------------

### Create DSP Configuration from PropDict

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

Creates a DSPConfig object from a PropDict containing DSP metadata.

```julia
_create_dsp_config(dsp_metadata::PropDicts.PropDict)
```

--------------------------------

### dsp_sg_sipm_optimization_compressed

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

Calculates DSP grid to find optimal thresholds for SiPMs using compressed waveforms. Requires an array of RDWaveforms, DSP configuration, and optimization configuration.

```APIDOC
## dsp_sg_sipm_optimization_compressed

### Description
Calculates DSP grid to find optimal thresholds for SiPMs using compressed waveforms. Requires an array of RDWaveforms, DSP configuration, and optimization configuration.

### Method
Function

### Endpoint
LegendDSP.dsp_sg_sipm_optimization_compressed

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **wvfs** (ArrayOfRDWaveforms) - Array of RDWaveforms.
- **dsp_config** (PropDict) - Configuration parameters for the DSP.
- **optimization_config** (PropDict) - Configuration parameters for the optimization.

### Request Example
```json
{
  "wvfs": "[ArrayOfRDWaveforms object]",
  "dsp_config": {"threshold": 0.5, "window": 10},
  "optimization_config": {"step": 0.1, "max_iter": 100}
}
```

### Response
#### Success Response (200)
- **Table** - Table with the optimal thresholds for the SiPMs.

#### Response Example
```json
{
  "optimal_thresholds": [
    {"channel": 0, "threshold": 0.45},
    {"channel": 1, "threshold": 0.55}
  ]
}
```
```

--------------------------------

### _create_dsp_config

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

Creates a DSPConfig object from a PropDict containing DSP metadata.

```APIDOC
## Create DSP Configuration

### Description
Creates a `DSPConfig` from a `PropDict` of DSP metadata.

### Method
POST

### Endpoint
/_create_dsp_config

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **dsp_metadata** (PropDicts.PropDict) - Required - DSP metadata.

### Request Example
```json
{
  "dsp_metadata": { ... }
}
```

### Response
#### Success Response (200)
- **dsp_config** (DSPConfig) - The DSP configuration.

#### Response Example
```json
{
  "dsp_config": { ... }
}
```
```

--------------------------------

### DSP SiPM Optimization for Thresholds

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

Calculates a DSP grid to find optimal thresholds for SiPMs. Requires an array of RDWaveforms, DSP configuration, and optimization configuration. Returns a table of optimal SiPM thresholds.

```Julia
dsp_sg_sipm_optimization_compressed(wvfs::ArrayOfRDWaveforms, dsp_config::PropDict, optimization_config::PropDict)
```

--------------------------------

### Define and Apply Whittaker-Henderson Filter

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

Demonstrates how to define parameters for a Whittaker-Henderson filter and apply it to a waveform. Ensure necessary using statements are present.

```julia
using RadiationDetectorSignals
using Unitful

n = 600
noise = 1.
t = range(0u"μs", 20u"μs", length = 2 * n)
signal = vcat(zeros(n), 10 * ones(n)) + (noise * rand(2 * n) .- noise / 2)
wf = RDWaveform(t, signal)

# define filter parameters and filter
flt = WhittakerHendersonFilter(p=3, λ=4)

# apply filter to signal
wf_new = flt(wf)
```

--------------------------------

### dsp_zac_ft_optimization

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

Optimizes ZAC filter parameters by calculating energy grid values for given ZAC rise times while varying the flat-top time.

```APIDOC
## dsp_zac_ft_optimization

### Description
Calculates energy grid values for a given set of ZAC filter rise times, while systematically varying the flat-top time.

### Method
`dsp_zac_ft_optimization(wvfs::ArrayOfRDWaveforms, config::DSPConfig, τ::Quantity{T}, rt::Quantity{T}) where T<:Real`

### Returns
- `e_grid`: Array of energy values for the given ZAC rise time grid at a specific flat-top time.
```

--------------------------------

### dsp_sg_sipm_thresholds_compressed

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

Calculates baseline and inverted baseline of waveforms to determine thresholds for SiPMs using compressed data. Requires an array of RDWaveforms and configuration parameters.

```APIDOC
## dsp_sg_sipm_thresholds_compressed

### Description
Calculates baseline and inverted baseline of waveforms to determine thresholds for SiPMs using compressed data. Requires an array of RDWaveforms and configuration parameters.

### Method
Method

### Endpoint
LegendDSP.dsp_sg_sipm_thresholds_compressed

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **wvfs** (ArrayOfRDWaveforms) - Array of RDWaveforms.
- **config** (PropDict) - Configuration parameters.

### Request Example
```json
{
  "wvfs": "[ArrayOfRDWaveforms object]",
  "config": {"baseline_window": 50}
}
```

### Response
#### Success Response (200)
- **Table** - Table with the baseline of the waveforms and the baseline of the waveforms with the sign flipped.

#### Response Example
```json
{
  "baseline_stats": [
    {"channel": 0, "blmean": 0.1, "blmean_flipped": -0.09},
    {"channel": 1, "blmean": 0.11, "blmean_flipped": -0.10}
  ]
}
```
```

--------------------------------

### Get Waveform t0

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

Determines the t0 (time zero) for each waveform using a fast asymmetric trapezoidal filter. A fixed threshold is applied, and the filter is truncated to the expected Ge trigger range.

```julia
get_t0(wvfs_pz::ArrayOfRDWaveforms, t0_threshold::T) where T<:Real
```

--------------------------------

### makeIPlusLambdaDprimeD

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

Constructs a centro-symmetric banded matrix required for inversion, specifically I + λ*D'D, where D is a finite difference matrix.

```APIDOC
## makeIPlusLambdaDprimeD

### Description
Build the centro-symmetric banded matrix which needs to be inverted later: I + λ*D'D. D is the finite difference matrix of order `p`.

### Method
`makeIPlusLambdaDprimeD(λ::T, p::Int, N::Int) where {T}`

### Parameters
* `λ` (T): The scalar multiplier.
* `p` (Int): The order of the finite difference matrix D.
* `N` (Int): The size parameter for the matrix.

### Returns
The constructed centro-symmetric banded matrix.
```

--------------------------------

### Get Threshold Statistics using MAD

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

Computes the standard deviation of signal samples within specified bounds using the Median Absolute Deviation (MAD) method. This provides a robust measure of dispersion, less sensitive to outliers.

```julia
thresholdstats_mad(signal::AbstractSamples, min::Real, max::Real)
thresholdstats_mad(signal::RDWaveform, min::RealQuantity, max::RealQuantity)
```

--------------------------------

### dsp_zac_rt_optimization

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

Optimizes ZAC filter parameters by calculating ENC noise grid values for given ZAC rise times, with an optional flat-top time parameter.

```APIDOC
## dsp_zac_rt_optimization

### Description
Calculates Equivalent Noise Charge (ENC) noise grid values for a given set of ZAC rise times. Allows for an optional specification of the flat-top time.

### Method
`dsp_zac_rt_optimization(wvfs::ArrayOfRDWaveforms, config::DSPConfig, τ::Quantity{T},; ft::Quantity{T}=4.0u"µs") where T<:Real`

### Returns
- `enc_zac_grid`: Array of ENC noise values for the given ZAC rise time grid.
```

--------------------------------

### makeFitWeights

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

Generates weights for a linear fit used in linear extrapolation at the right boundary.

```APIDOC
## makeFitWeights

### Description
Return the weights for the linear fit used for linear extrapolation at the right boundary.

### Method
`makeFitWeights(d::Int, m::Int) where {U}`

### Parameters
* `d` (Int): Parameter `d` for weight calculation.
* `m` (Int): Parameter `m` for weight calculation.

### Returns
The weights for the linear fit.
```

--------------------------------

### dsp_cusp_ft_optimization

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

Optimizes CUSP filter flat-top time for given rise times and returns energy grid values.

```APIDOC
## CUSP Filter Flat-Top Optimization

### Description
Gets energy grid values for given CUSP grid rise times while varying the flat-top time.

### Method
POST

### Endpoint
/dsp_cusp_ft_optimization

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **wvfs** (ArrayOfRDWaveforms) - Required - Array of waveforms.
- **config** (DSPConfig) - Required - DSP configuration.
- **τ** (Quantity{T}) - Required - Decay time.
- **rt** (Quantity{T}) - Required - Rise time.

### Request Example
```json
{
  "wvfs": [ ... ],
  "config": { ... },
  "τ": "1.0 us",
  "rt": "4.0 us"
}
```

### Response
#### Success Response (200)
- **e_grid** (Array) - Array of energy values for the given CUSP rise time grid at a given flat-top time grid.

#### Response Example
```json
{
  "e_grid": [ ... ]
}
```
```

--------------------------------

### DSP SiPM Threshold Calculation

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

Calculates baseline and inverted baseline for waveforms to determine SiPM thresholds. Takes an array of RDWaveforms and configuration parameters. Returns a table containing baseline and inverted baseline values.

```Julia
dsp_sg_sipm_thresholds_compressed(wvfs::ArrayOfRDWaveforms, config::PropDict)
```

--------------------------------

### Build Matrix for Inversion

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

Constructs a centro-symmetric banded matrix of the form I + λ*D'D, where D is a finite difference matrix. This matrix is required for subsequent inversion operations in numerical methods.

```julia
makeIPlusLambdaDprimeD(λ::T, p::Int, N::Int) where {T}
```

--------------------------------

### LegendDSP.DSPConfig

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

Configuration parameters for DSP algorithms. It includes fields for noise calculations, baseline and decay time extraction windows, and thresholds for various signal processing steps.

```APIDOC
## LegendDSP.DSPConfig

### Description
Configuration parameters for DSP algorithms. It includes fields for noise calculations, baseline and decay time extraction windows, and thresholds for various signal processing steps.

### Fields
* `enc_pickoff` (Quantity{<:T}) - pick-off time for ENC noise calculations
* `bl_window` (ClosedInterval{Quantity{<:T}}) - fit window for basline extraction
* `tail_window` (ClosedInterval{Quantity{<:T}}) - fit window for decay time extraction
* `inTraceCut_std_threshold` (T) - in-trace pile-up rejector threshold in standard deviations
* `t0_threshold` (T) - ADC threshold for t0 determination
* `e_grid_rt_trap` (StepRangeLen{Quantity{<:T}}) - rise time grid scan range for trapezoidal filter
* `e_grid_ft_trap` (StepRangeLen{Quantity{<:T}}) - flat-top time grid scan range for trapezoidal filter
* `e_grid_rt_zac` (StepRangeLen{Quantity{<:T}}) - rise time grid scan range for ZAC filter
* `e_grid_ft_zac` (StepRangeLen{Quantity{<:T}}) - flat-top time grid scan range for ZAC filter
* `e_grid_rt_cusp` (StepRangeLen{Quantity{<:T}}) - rise time grid scan range for CUSP filter
* `e_grid_ft_cusp` (StepRangeLen{Quantity{<:T}}) - flat-top time grid scan range for CUSP filter
* `a_grid_rt_sg` (StepRangeLen{Quantity{<:T}}) - window length grid scan range for SG filter

### Examples
```julia
using LegendDSP
using LegendDataManagement

l200 = LegendData(:l200)
filekey = start_filekey(l200, (:p03, :r000, :cal))
dsp_config = DSPConfig(dataprod_config(l200).dsp(filekey).default)
```
```

--------------------------------

### Apply Moving Window Multi Filter to Waveform

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

Applies a left and right moving average window to a signal. Ensure RadiationDetectorSignals and Unitful are imported.

```julia
using RadiationDetectorSignals
using Unitful

signal = rand(100)
t = range(0u"ms", 20u"ms", 100)

wf = RDWaveform(t, signal)
flt = MovingWindowMultiFilter(1u"ms")
wf_new = flt(wf)
```

--------------------------------

### Optimize CUSP Filter Flat-Top Time

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

Calculates energy grid values for CUSP filter rise times while varying the flat-top time. Returns an array of energy values.

```julia
dsp_cusp_ft_optimization(wvfs::ArrayOfRDWaveforms, config::DSPConfig, τ::Quantity{T}, rt::Quantity{T}) where T<:Real
```

--------------------------------

### dsp_trap_ft_optimization

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

Optimizes trap filter parameters by calculating energy grid values for given trap rise times while varying the flat-top time.

```APIDOC
## dsp_trap_ft_optimization

### Description
Calculates energy grid values for a given set of trap filter rise times, while systematically varying the flat-top time.

### Method
`dsp_trap_ft_optimization(wvfs::ArrayOfRDWaveforms, config::DSPConfig, τ::Quantity{T}, rt::Quantity{T}) where T<:Real`

### Returns
- `e_grid`: Array of energy values for the given trap rise time grid at a specific flat-top time.
```

--------------------------------

### Estimate Q-Drift Parameter

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

Calculates the Q-drift parameter for multiple waveforms. It integrates each waveform with a gain of 1 and uses a polynomial signal estimator to determine the signal. Customizable parameters include polynomial order and estimator length.

```julia
get_qdrift(wvfs::ArrayOfRDWaveforms, t_start::Array{Unitful.Time{T}}, Δt::UnitRange{Unitful.Time{T}}; pol_power::Int=3, sign_est_length::Unitful.Time=100.0u"ns")
```

--------------------------------

### dsp_sipm_compressed

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

DSP routine for SiPM data. It processes waveform, baseline, timestamp, eventnumber, and daqenergy to produce filtered and analyzed output data, including baseline statistics and trigger information.

```APIDOC
## dsp_sipm_compressed

### Description
Processes SiPM data to extract detailed signal characteristics. This method requires threshold parameters from a threshold scan for the specific SiPM channel and discharge threshold parameters.

### Method
`dsp_sipm_compressed(data::Q, config::PropDict, pars_threshold::PropDict)`

### Input data
The input data is a table with the following columns:
  * `waveform`: waveform data
  * `baseline`: baseline data
  * `timestamp`: timestamp data
  * `eventnumber`: event number data
  * `daqenergy`: energy data

### Output data
The output data is a table with the following columns:
  * `blfc`: baseline from FADC
  * `timestamp`: timestamp
  * `eventID_fadc`: event number from FADC
  * `e_fc`: energy from FADC
  * `t_max`, `t_min`: time of waveform maximum/minimum
  * `t_max_lar`, `t_min_lar`: time of waveform maximum/minimum in LAr window
  * `e_max`, `e_min`: waveform maximum/minimum amplitude
  * `e_max_lar`, `e_min_lar`: waveform maximum/minimum amplitude in LAr window
  * `blmean`, `blsigma`, `blslope`, `bloffset`: baseline statistics
  * `wfmean`, `wfsigma`, `wfslope`, `wfoffset`: waveform statistics

### SG filter columns
  * `threshold` : SG trigger threshold
  * `threshold_DC`: SG discharge trigger threshold
  * `trig_pos`: SG trigger positions
  * `trig_max`: SG trigger maxima
  * `trig_pos_DC`: SG discharge trigger positions
  * `trig_max_DC`: SG discharge trigger maxima

### Trap filter columns
  * `threshold_trap` : trap trigger threshold
  * `threshold_DC_trap`: trap discharge trigger threshold
  * `trig_pos_trap`: trap trigger positions
  * `trig_pos_high_trap`: trap trigger high positions
  * `trig_pos_tot_trap`: trap trigger time-over-threshold positions
  * `trig_max_trap`: trap trigger maxima
  * `trig_pos_DC_trap`: trap discharge trigger positions
  * `trig_pos_high_DC_trap`: trap discharge trigger high positions
  * `trig_pos_tot_DC_trap`: trap discharge trigger time-over-threshold positions
  * `trig_max_DC_trap`: trap discharge trigger maxima
```

--------------------------------

### dsp_qc_flt_optimization_compressed

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

Optimizes filter parameters for Quality Control (QC) using a given compressed waveform set. Similar to `dsp_qc_flt_optimization`, it can optionally use an ML classification function.

```APIDOC
## dsp_qc_flt_optimization_compressed

### Description
Optimizes filter parameters for Quality Control (QC) using a given compressed waveform set. Similar to `dsp_qc_flt_optimization`, it can optionally use an ML classification function.

### Method
Method

### Endpoint
LegendDSP.dsp_qc_flt_optimization_compressed

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **wvfs** (ArrayOfRDWaveforms) - The set of waveforms to process.
- **config** (DSPConfig) - Configuration parameters for the DSP.
- **τ** (Unitful.Time) - Time unit for the filter optimization.
- **f_evaluate_qc** (Union{Function, Missing}) - Optional function to evaluate QC. If missing, ML classification is skipped.

### Request Example
```json
{
  "wvfs": "[ArrayOfRDWaveforms object]",
  "config": "[DSPConfig object]",
  "τ": "10 μs",
  "f_evaluate_qc": "[optional function]"
}
```

### Response
#### Success Response (200)
- **qc_label** (integer) - QC label (-1 if no ML model available).

#### Response Example
```json
{
  "qc_label": 1
}
```
```

--------------------------------

### dsp_qdrift_flt_optimization

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

Optimizes QDrift filter parameters for a given waveform set, requiring baseline mean values and DSP configuration.

```APIDOC
## dsp_qdrift_flt_optimization

### Description
Optimizes QDrift filter parameters for a given waveform set, requiring baseline mean values and DSP configuration.

### Method
Method

### Endpoint
LegendDSP.dsp_qdrift_flt_optimization

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **wvfs** (ArrayOfRDWaveforms) - The set of waveforms to process.
- **blmean** (Vector{<:Real}) - Vector of baseline mean values.
- **config** (DSPConfig) - Configuration parameters for the DSP.
- **τ** (Unitful.Time) - Time unit for the filter optimization.

### Request Example
```json
{
  "wvfs": "[ArrayOfRDWaveforms object]",
  "blmean": [0.1, 0.11, 0.09],
  "config": "[DSPConfig object]",
  "τ": "10 μs"
}
```

### Response
#### Success Response (200)
None explicitly documented.

#### Response Example
None explicitly documented.
```

--------------------------------

### dsp_sg_optimization_compressed

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

Optimizes Savitzky-Golay filter parameters for a given compressed waveform set. It requires windowed and pre-processed waveforms, DSP configuration, time quantity, and filter parameters. An optional ML QC evaluation function can be provided.

```APIDOC
## dsp_sg_optimization_compressed

### Description
Optimizes the Savitzky-Golay filter parameters for a given compressed waveform set. It requires windowed and pre-processed waveforms, DSP configuration, time quantity, and filter parameters. An optional ML QC evaluation function can be provided.

### Method
Method

### Endpoint
LegendDSP.dsp_sg_optimization_compressed

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **wvfs_wdw** (ArrayOfRDWaveforms) - Windowed waveforms.
- **wvfs_pre** (ArrayOfRDWaveforms) - Pre-processed waveforms.
- **config** (DSPConfig) - Configuration parameters for the DSP.
- **τ** (Quantity{T}) - Time quantity for the filter optimization.
- **pars_filter** (PropDict) - Filter parameters.
- **presum_rate** (Real) - Presum rate. Defaults to T(8).
- **f_evaluate_qc** (Union{Function, Missing}) - Optional ML QC evaluation function. Defaults to missing.

### Request Example
```json
{
  "wvfs_wdw": "[ArrayOfRDWaveforms object]",
  "wvfs_pre": "[ArrayOfRDWaveforms object]",
  "config": "[DSPConfig object]",
  "τ": "10 μs",
  "pars_filter": {"window_length": 5, "polyorder": 2},
  "presum_rate": 8,
  "f_evaluate_qc": "[optional function]"
}
```

### Response
#### Success Response (200)
- **aoe** (Array) - Array of efficiency values.
- **energy** (Array) - Array of energy values.
- **blmean** (float) - Baseline mean value.
- **blslope** (float) - Baseline slope value.
- **qc_label** (integer) - QC labels (-1 if no ML model available).

#### Response Example
```json
{
  "aoe": [0.9, 0.91, 0.89],
  "energy": [1000.5, 1010.2, 995.8],
  "blmean": 0.1,
  "blslope": 0.001,
  "qc_label": 1
}
```
```

--------------------------------

### Trap Filter Optimization for Rise Time

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

Calculates energy grid values for a given trap filter rise time grid, varying the flat-top time. This is useful for optimizing trap filter parameters.

```Julia
dsp_trap_ft_optimization(wvfs::ArrayOfRDWaveforms, config::DSPConfig, τ::Quantity{T}, rt::Quantity{T}) where T<:Real
```

--------------------------------

### DSP QDrift Filter Optimization

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

Performs Quality Drift (QDrift) filter parameter optimization for a given set of waveforms, requiring baseline mean values and DSP configuration.

```Julia
dsp_qdrift_flt_optimization(wvfs::ArrayOfRDWaveforms, blmean::Vector{<:Real}, config::DSPConfig, τ::Unitful.Time{<:Real})
```

--------------------------------

### ZAC Filter Optimization for Rise Time

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

Calculates energy grid values for a given ZAC filter rise time grid, varying the flat-top time. This function is used for optimizing ZAC filter parameters.

```Julia
dsp_zac_ft_optimization(wvfs::ArrayOfRDWaveforms, config::DSPConfig, τ::Quantity{T}, rt::Quantity{T}) where T<:Real
```

--------------------------------

### get_qdrift

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

Calculates the Q-drift parameter for multiple waveforms using polynomial signal estimation.

```APIDOC
## get_qdrift

### Description
Get the Q-drift parameter for each waveform in `wvfs` by integrating the waveform with gain = 1 and using a polynomial signal estimator.

### Method
`get_qdrift(wvfs::ArrayOfRDWaveforms, t_start::Array{Unitful.Time{T}}, Δt::UnitRange{Unitful.Time{T}}; pol_power::Int=3, sign_est_length::Unitful.Time=100u"ns")`

### Parameters
* `wvfs` (ArrayOfRDWaveforms): The array of waveforms.
* `t_start` (Array{Unitful.Time{T}}): Array of start times for integration.
* `Δt` (UnitRange{Unitful.Time{T}}): Time range for integration.
* `pol_power` (Int, optional): The order of the polynomial signal estimator (default: 3).
* `sign_est_length` (Unitful.Time, optional): The length of the signal estimator (default: 100 ns).

### Returns
The Q-drift parameter for each waveform.
```

--------------------------------

### get_intracePileUp

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

Identifies in-trace pile-up events by detecting intersections of the reversed derivative signal with a threshold.

```APIDOC
## get_intracePileUp

### Description
Get position and multiplicity of in-trace pile-up as intersect of reversed derivative signal with threshold as multiple of std. The `wvfs` have to be a current signal.

### Method
`get_intracePileUp(wvfs::ArrayOfRDWaveforms, sigma_threshold::Real, bl_window::ClosedInterval{<:Unitful.Time{<:Real}}; mintot::Unitful.Time=100.0u"ns")`

### Parameters
* `wvfs` (ArrayOfRDWaveforms): The array of waveforms to analyze.
* `sigma_threshold` (Real): The threshold multiplier for standard deviation.
* `bl_window` (ClosedInterval{<:Unitful.Time{<:Real}}): The baseline window.
* `mintot` (Unitful.Time): Minimum total time for pile-up detection (default: 100.0 ns).

### Returns
* Information about in-trace pile-up events.
```

--------------------------------

### dsp_cusp_rt_optimization

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

Optimizes CUSP filter rise time and returns ENC noise grid values.

```APIDOC
## CUSP Filter Rise Time Optimization

### Description
Gets ENC noise grid values for given CUSP grid rise times.

### Method
POST

### Endpoint
/dsp_cusp_rt_optimization

### Parameters
#### Path Parameters
None

#### Query Parameters
- **ft** (Quantity{T}) - Optional - Flat-top time. Defaults to 4.0 µs.

#### Request Body
- **wvfs** (ArrayOfRDWaveforms) - Required - Array of waveforms.
- **config** (DSPConfig) - Required - DSP configuration.
- **τ** (Quantity{T}) - Required - Decay time.

### Request Example
```json
{
  "wvfs": [ ... ],
  "config": { ... },
  "τ": "1.0 us"
}
```

### Response
#### Success Response (200)
- **enc_cusp_grid** (Array) - Array of ENC noise values for the given CUSP rise time grid.

#### Response Example
```json
{
  "enc_cusp_grid": [ ... ]
}
```
```

--------------------------------

### ZAC Filter Optimization for Flat-Top Time

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

Calculates ENC noise grid values for a given ZAC filter rise time grid, with an optional flat-top time. This function aids in optimizing ZAC filter noise performance.

```Julia
dsp_zac_rt_optimization(wvfs::ArrayOfRDWaveforms, config::DSPConfig, τ::Quantity{T},; ft::Quantity{T}=4.0u"µs") where T<:Real
```

--------------------------------

### DSP SiPM Data Processing

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

A DSP routine for processing SiPM data, requiring threshold parameters from a threshold scan and discharge threshold parameters. Input data includes waveform, baseline, and timestamp.

```Julia
dsp_sipm(data::Q, config::PropDict, pars_threshold::PropDict)
```

--------------------------------

### Trap Filter Optimization for Flat-Top Time

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

Calculates ENC noise grid values for a given trap filter rise time grid, with an optional flat-top time. This helps in determining optimal noise performance.

```Julia
dsp_trap_rt_optimization(wvfs::ArrayOfRDWaveforms, config::DSPConfig, τ::Quantity{T},; ft::Quantity{T}=4.0u"µs") where T<:Real
```

--------------------------------

### DSP Routine for SiPM Data

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

Applies DSP to SiPM data, requiring threshold parameters from a scan and discharge threshold parameters. It processes input data including waveforms and baselines to produce output data with various signal characteristics.

```Julia
dsp_sipm_compressed(data::Q, config::PropDict, pars_threshold::PropDict)
```

--------------------------------

### Compressed DSP Savitzky-Golay Filter Optimization

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

Optimizes Savitzky-Golay filter parameters for a compressed waveform set, using both windowed and pre-processed waveforms. Includes optional presum rate and QC evaluation function. Returns efficiency, energy, baseline statistics, and QC labels.

```Julia
dsp_sg_optimization_compressed(wvfs_wdw::ArrayOfRDWaveforms, wvfs_pre::ArrayOfRDWaveforms, config::DSPConfig, τ::Quantity{T}, pars_filter::PropDict; presum_rate::Real=T(8), f_evaluate_qc::Union{Function, Missing}=missing) where T<:Real
```

--------------------------------

### extremestats

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

Retrieves the minimum and maximum values along with their time positions within a specified interval of a signal.

```APIDOC
## extremestats

### Description
Get the extrema and their time positions on `signal` in the interval (`start`,`stop`).

### Method
`extremestats(signal::AbstractSamples, start::Real, stop::Real)`
`extremestats(signal::RDWaveform, start::RealQuantity, stop::RealQuantity)`

### Parameters
* `signal` (AbstractSamples or RDWaveform): The input signal.
* `start` (Real or RealQuantity): The start of the interval.
* `stop` (Real or RealQuantity): The end of the interval.

### Returns
* `(min, max, tmin, tmax)`: A tuple containing the minimum value, maximum value, time of minimum, and time of maximum.
```

--------------------------------

### get_qc_ml_func

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

Creates a function that predicts signal properties using discrete wavelet transforms, labels, and hyperparameters.

```APIDOC
## get_qc_ml_func

### Description
Create a function that takes a signal and returns the prediction using the given hyperparameters and discrete wavelet transforms.

### Method
`get_qc_ml_func(dwts_norm::Matrix{<:Real}, dc_labels::Vector{<:Real}, hyperparams::PropDict)`

### Parameters
* `dwts_norm` (Matrix{<:Real}): Normalized discrete wavelet transforms.
* `dc_labels` (Vector{<:Real}): Discrete cosine labels.
* `hyperparams` (PropDict): Hyperparameters for the model.

### Returns
A function that takes a signal and returns a prediction.
```

--------------------------------

### Compressed DSP QC Filter Optimization

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

Optimizes Quality Control (QC) DSP filter parameters for a compressed waveform set. Similar to the non-compressed version, it can skip ML classification if an evaluation function is missing.

```Julia
dsp_qc_flt_optimization_compressed(wvfs::ArrayOfRDWaveforms, config::DSPConfig, τ::Unitful.Time{<:Real}, f_evaluate_qc::Union{Function, Missing})
```

--------------------------------

### get_qc_classifier_compressed

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

Generates a compressed quality cut classifier for waveforms, with an optional configuration parameter.

```APIDOC
## get_qc_classifier_compressed

### Description
Get a classifier for quality cuts using the given waveforms and evaluation function which evaluates a predefined SVM model.

### Method
`get_qc_classifier_compressed(wvfs::ArrayOfRDWaveforms, f_evaluate_qc::Function)`
`get_qc_classifier_compressed(wvfs::ArrayOfRDWaveforms, f_evaluate_qc::Function, config::DSPConfig)`

### Parameters
* `wvfs` (ArrayOfRDWaveforms): The array of waveforms.
* `f_evaluate_qc` (Function): The function to evaluate the quality cuts.
* `config` (DSPConfig, optional): The DSP configuration.

### Returns
A compressed classifier for quality cuts.
```

--------------------------------

### extrema3points

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

Calculates the extrema of a parabola defined by three input points. This is a low-level method for parabolic fitting.

```APIDOC
## extrema3points

### Description
Calculate the extrema of a parabola defined by three points.

### Method
`extrema3points(y1::T, y2::T, y3::T)::T where {T<:AbstractFloat}`

### Parameters
* `y1` (T): The first y-coordinate.
* `y2` (T): The second y-coordinate.
* `y3` (T): The third y-coordinate.

### Returns
* `T`: The calculated extremum value.
```

--------------------------------

### Optimize CUSP Filter Rise Time

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

Calculates ENC noise grid values for CUSP filter rise times. Allows specifying a fixed flat-top time. Returns an array of ENC noise values.

```julia
dsp_cusp_rt_optimization(wvfs::ArrayOfRDWaveforms, config::DSPConfig, τ::Quantity{T},; ft::Quantity{T}=4.0u"µs") where T<:Real
```

--------------------------------

### dsp_trap_rt_optimization

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

Optimizes trap filter parameters by calculating ENC noise grid values for given trap rise times, with an optional flat-top time parameter.

```APIDOC
## dsp_trap_rt_optimization

### Description
Calculates Equivalent Noise Charge (ENC) noise grid values for a given set of trap filter rise times. Allows for an optional specification of the flat-top time.

### Method
`dsp_trap_rt_optimization(wvfs::ArrayOfRDWaveforms, config::DSPConfig, τ::Quantity{T},; ft::Quantity{T}=4.0u"µs") where T<:Real`

### Returns
- `enc_trap_grid`: Array of ENC noise values for the given trap rise time grid.
```

--------------------------------

### Generate Linear Fit Weights

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

Returns weights for a linear fit, used for linear extrapolation at the right boundary. This is a utility function for fitting operations.

```julia
makeFitWeights(d::Int, m::Int) where {U}
```

--------------------------------

### choleskyL!

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

Performs an in-place Cholesky decomposition of a banded symmetric matrix.

```APIDOC
## In-place Cholesky Decomposition

### Description
Performs an in-place Cholesky decomposition of a banded symmetric matrix. `b[1, i]` contains the diagonal elements, `b[2, i]` the elements of the first subdiagonal and so on.

### Method
POST

### Endpoint
/choleskyL

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **b** (AbstractMatrix{T}) - Required - The banded symmetric matrix to decompose.

### Request Example
```json
{
  "b": [ ... ]
}
```

### Response
#### Success Response (200)
- **b** (AbstractMatrix{T}) - The matrix after Cholesky decomposition.

#### Response Example
```json
{
  "b": [ ... ]
}
```
```

--------------------------------

### Calculate Decay Times from Waveforms

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

Computes statistics on the logarithm of the tail of waveforms within specified time windows. Returns the decay time in microseconds.

```julia
dsp_decay_times(wvfs::ArrayOfRDWaveforms, bl_window::ClosedInterval{<:Unitful.Time{<:T}}, tail_window::ClosedInterval{<:Unitful.Time{<:T}})
```

```julia
dsp_decay_times(wvfs::ArrayOfRDWaveforms, config::DSPConfig)
```

--------------------------------

### tailstats

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

Calculates statistics on the logarithm of the tail of a signal within a specified interval, optionally by fitting a linear function.

```APIDOC
## tailstats

### Description
Get statistics on the logarithmic of the tail of a `signal` in the interval (`start`,`stop`).

### Method
`tailstats(signal::AbstractSamples, start::Real, stop::Real)`
`tailstats(signal::RDWaveform, start::RealQuantity, stop::RealQuantity)`

### Parameters
* `signal` (AbstractSamples or RDWaveform): The input signal.
* `start` (Real or RealQuantity): The start of the interval.
* `stop` (Real or RealQuantity): The end of the interval.

### Returns
Statistics on the logarithmic tail of the signal.
```

--------------------------------

### dsp_decay_times

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

Calculates decay time statistics from waveform tails.

```APIDOC
## Decay Time Statistics

### Description
Gets statistics on the logarithm of the tail of the `wvfs` in the interval `tail_window`.

### Method
POST

### Endpoint
/dsp_decay_times

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **wvfs** (ArrayOfRDWaveforms) - Required - Array of waveforms.
- **bl_window** (ClosedInterval{<:Unitful.Time{<:T}}) - Required - Baseline window.
- **tail_window** (ClosedInterval{<:Unitful.Time{<:T}}) - Required - Tail window.

### Request Example
```json
{
  "wvfs": [ ... ],
  "bl_window": ["0 us", "1 us"],
  "tail_window": ["5 us", "10 us"]
}
```

### Response
#### Success Response (200)
- **τ** (Quantity) - Decay time in µs.

#### Response Example
```json
{
  "τ": "2.5 us"
}
```

## Overload
### dsp_decay_times(wvfs::ArrayOfRDWaveforms, config::DSPConfig)

#### Description
Gets statistics on the logarithm of the tail of the `wvfs` using a `DSPConfig`.

#### Parameters
- **wvfs** (ArrayOfRDWaveforms) - Required - Array of waveforms.
- **config** (DSPConfig) - Required - DSP configuration.

#### Request Example
```json
{
  "wvfs": [ ... ],
  "config": { ... }
}
```

#### Response Example
```json
{
  "τ": "2.5 us"
}
```
```

--------------------------------

### dsp_sipm

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

DSP routine for SiPM data. It processes waveform, baseline, and timestamp data, requiring threshold parameters from a threshold scan and discharge threshold parameters for the specific SiPM channel.

```APIDOC
## dsp_sipm

### Description
DSP routine for SiPM data. It processes waveform, baseline, and timestamp data, requiring threshold parameters from a threshold scan and discharge threshold parameters for the specific SiPM channel.

### Method
Method

### Endpoint
LegendDSP.dsp_sipm

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **data** (Table) - Input data with columns: `waveform`, `baseline`, `timestamp`.
- **config** (PropDict) - Configuration parameters, including threshold parameters.
- **pars_threshold** (PropDict) - Threshold parameters from a threshold scan.

### Request Example
```json
{
  "data": {
    "waveform": "[waveform data]",
    "baseline": "[baseline data]",
    "timestamp": "[timestamp data]"
  },
  "config": {"discharge_threshold": 0.2},
  "pars_threshold": {"channel_0": {"threshold": 0.5}}
}
```

### Response
#### Success Response (200)
None explicitly documented.

#### Response Example
None explicitly documented.
```

--------------------------------

### DSP Savitzky-Golay Filter Optimization

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

Optimizes Savitzky-Golay filter parameters for a waveform set. Accepts waveform data, DSP configuration, time constant, filter parameters, and an optional QC evaluation function. Returns efficiency, energy, baseline statistics, and QC labels.

```Julia
dsp_sg_optimization(wvfs::ArrayOfRDWaveforms, config::DSPConfig, τ::Quantity{T}, pars_filter::PropDict; f_evaluate_qc::Union{Function, Missing}=missing) where T<:Real
```

--------------------------------

### DerivativeFilter Usage

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

Shows how to apply a DerivativeFilter to a RDWaveform. This filter is used for calculating the derivative of a signal.

```julia
using LegendDSP
using Unitful

signal = rand(100)
t = range(0u"ms", 20u"ms", 100)

wf = RDWaveform(t, signal)
flt = DerivativeFilter()
wf_new = flt(wf)
```

--------------------------------

### get_wvf_maximum

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

Finds the maximum value of a signal within a specified interval using quadratic interpolation.

```APIDOC
## get_wvf_maximum

### Description
Get the maximum of a `signal` in the interval (`start`,`stop`) by quadratic interpolation.

### Method
`get_wvf_maximum(signal::AbstractSamples, start::Real, stop::Real)`
`get_wvf_maximum(signal::RDWaveform, start::RealQuantity, stop::RealQuantity)`

### Parameters
* `signal` (AbstractSamples or RDWaveform): The input signal.
* `start` (Real or RealQuantity): The start of the interval.
* `stop` (Real or RealQuantity): The end of the interval.

### Returns
The maximum value within the specified interval.
```

--------------------------------

### MovingWindowMultiFilter

Source: https://legend-exp.github.io/LegendDSP.jl/stable/api

Applies left and right moving average windows to a signal. The filter is constructed with a specified length and can be applied to a waveform object.

```APIDOC
## MovingWindowMultiFilter

### Description
Applies left and right moving average windows to a signal.

### Constructor
`MovingWindowMultiFilter(; length::Union{Real, Unitful.AbstractQuantity{<:Real}})`

### Fields
* `length::Union{Real, Unitful.AbstractQuantity{<:Real}}`: size of the moving average window

### Usage Example
```julia
using RadiationDetectorSignals
using Unitful

signal = rand(100)
t = range(0u"ms", 20u"ms", 100)

wf = RDWaveform(t, signal)
flt = MovingWindowMultiFilter(1u"ms")
wf_new = flt(wf)
```
```
Tokens:
Raw