Description Usage Arguments Value Author(s) References Examples

Reexported from `lowpassFilter`

. Creates lowpass filters.

1 | ```
lowpassFilter(type = c("bessel"), param, sr = 1, len = NULL, shift = 0.5)
``` |

`type` |
a string specifying the type of the filter, currently only Bessel filters are supported |

`param` |
a |

`sr` |
a single numeric giving the sampling rate |

`len` |
a single integer giving the filter length of the truncated and digitised filter, see Value for more details. By default ( |

`shift` |
a single numeric between |

An object of `class`

`lowpassFilter`

, i.e. a `list`

that contains

`"type"`

,`"param"`

,`"sr"`

,`"len"`

the corresponding arguments

`"kernfun"`

the kernel function of the filter, obtained as the Laplace transform of the corresponding transfer function

`"stepfun"`

the step-response of the filter, i.e. the antiderivative of the filter kernel

`"acfun"`

the autocorrelation function, i.e. the convolution of the filter kernel with itself

`"acAntiderivative"`

the antiderivative of the autocorrelation function

`"truncatedKernfun"`

the kernel function of the at

`len / sr`

truncated filter, i.e.`kernfun`

truncated and rescaled such that the new kernel still integrates to`1`

`"truncatedStepfun"`

the step-response of the at

`len / sr`

truncated filter, i.e. the antiderivative of the kernel of the truncated filter`"truncatedAcfun"`

the autocorrelation function of the at

`len / sr`

truncated filter, i.e. the convolution of the kernel of the truncated filter with itself`"truncatedAcAntiderivative"`

the antiderivative of the autocorrelation function of the at

`len / sr`

truncated filter`"kern"`

the digitised filter kernel normalised to one, i.e.

`kernfun((0:len + shift) / sr) / sum(kernfun((0:len + shift) / sr))`

`"step"`

the digitised step-response of the filter, i.e.

`stepfun((0:len + shift) / sr)`

`"acf"`

the discrete autocorrelation, i.e.

`acfun(0:len / sr)`

`"jump"`

the last index of the left half of the filter, i.e.

`min(which(ret$step >= 0.5)) - 1L`

, it indicates how much a jump is shifted in time by a convolution of the signal with the digitised kernel of the lowpassfilter; if all values are below`0.5`

,`len`

is returned with a`warning`

`"number"`

for developers; an integer indicating the type of the filter

`"list"`

for developers; a list containing precomputed quantities to recreate the filter in C++

This function is a modified and extended version of `dfilter`

written by Thomas Hotz. New code is written by Florian Pein and Inder Tecuapetla-Gómez.

Pein, F., Bartsch, A., Steinem, C., Munk, A. (2020) Heterogeneous Idealization of Ion Channel Recordings - Open Channel Noise. *arXiv*:2008.02658.

Pein, F., Tecuapetla-Gómez, I., Schütte, O., Steinem, C., Munk, A. (2018) Fully-automatic multiresolution idealization for filtered ion channel recordings: flickering event detection. IEEE Trans. Nanobioscience, 17(3):300-320.

Pein, F. (2017) Heterogeneous Multiscale Change-Point Inference and its Application to Ion Channel Recordings. PhD thesis, Georg-August-Universität Göttingen. http://hdl.handle.net/11858/00-1735-0000-002E-E34A-7.

Hotz, T., Schütte, O., Sieling, H., Polupanow, T., Diederichsen, U., Steinem, C., and Munk, A. (2013) Idealizing ion channel recordings by a jump segmentation multiresolution filter. IEEE Trans. Nanobioscience, 12(4):376-386.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 | ```
# the filter used for the gramicidin A recordings given by gramA
filter <- lowpassFilter(type = "bessel", param = list(pole = 4L, cutoff = 1e3 / 1e4),
sr = 1e4)
# filter kernel, truncated version
plot(filter$kernfun, xlim = c(0, 20 / filter$sr))
t <- seq(0, 20 / filter$sr, 0.01 / filter$sr)
# truncated version looks very similar
lines(t, filter$truncatedKernfun(t), col = "red")
# filter$len (== 11) is chosen such that filter$acf < 1e-3 for it and all larger lags
plot(filter$acfun, xlim = c(0, 20 / filter$sr), ylim = c(-0.003, 0.003))
abline(h = 0.001, lty = "22")
abline(h = -0.001, lty = "22")
abline(v = (filter$len - 1L) / filter$sr, col = "grey")
abline(v = filter$len / filter$sr, col = "red")
## zoom into a single jump of the idealisation
## we suggest to do this for every new measurement setup once
## to control whether the correct filter is assumed
# idealisation by JULES (might take some time if not called somewhere before,
# please see its documentation for more details)
idealisation <- jules(gramA, filter = filter, startTime = 9, messages = 100)
## zoom into a single jump
plot(9 + seq(along = gramA) / filter$sr, gramA, pch = 16, col = "grey30",
ylim = c(20, 50), xlim = c(9.6476, 9.6496), ylab = "Conductance in pS",
xlab = "Time in s")
# idealisation
lines(idealisation, col = "red", lwd = 3)
# idealisation convolved with the filter
ind <- seq(9.647, 9.65, 1e-6)
convolvedSignal <- lowpassFilter::getConvolution(ind, idealisation, filter)
lines(ind, convolvedSignal, col = "blue", lwd = 3)
# idealisation with a wrong filter
# does not fit the recorded data points appropriately
wrongFilter <- lowpassFilter(type = "bessel",
param = list(pole = 6L, cutoff = 0.2),
sr = 1e4)
# the needed Monte-Carlo simulation depends on the number of observations and the filter
# hence a new simulation is required (if called for the first time)
idealisationWrong <- jules(gramA, filter = wrongFilter, startTime = 9, messages = 100)
# idealisation
lines(idealisationWrong, col = "orange", lwd = 3)
# idealisation convolved with the filter
ind <- seq(9.647, 9.65, 1e-6)
convolvedSignal <- lowpassFilter::getConvolution(ind, idealisationWrong, filter)
lines(ind, convolvedSignal, col = "darkgreen", lwd = 3)
# filter with sr == 1
filter <- lowpassFilter(type = "bessel", param = list(pole = 4L, cutoff = 1e3 / 1e4))
# filter kernel and its truncated version
plot(filter$kernfun, xlim = c(0, 20 / filter$sr))
t <- seq(0, 20 / filter$sr, 0.01 / filter$sr)
# truncated version, looks very similar
lines(t, filter$truncatedKernfun(t), col = "red")
# digitised filter
points((0:filter$len + 0.5) / filter$sr, filter$kern, col = "red", pch = 16)
# without a shift
filter <- lowpassFilter(type = "bessel", param = list(pole = 4L, cutoff = 1e3 / 1e4),
shift = 0)
# filter$kern starts with zero
points(0:filter$len / filter$sr, filter$kern, col = "blue", pch = 16)
# much shorter filter
filter <- lowpassFilter(type = "bessel", param = list(pole = 4L, cutoff = 1e3 / 1e4),
len = 4L)
points((0:filter$len + 0.5) / filter$sr, filter$kern, col = "darkgreen", pch = 16)
``` |

Embedding an R snippet on your website

Add the following code to your website.

For more information on customizing the embed code, read Embedding Snippets.