File MIES_SweepFormula_PSX.ipf¶

PSX Sweep formula related code for PSP/PSC (-> PSX) detection and classification

GUI layout

///
/// +---+-----------+-----------+
/// |   | All event | Single    |
/// |   | graph     | event     |
/// |   |           | graph     |
/// |   |           |           |
/// +------+-------------------------------+
/// |      |  PSX graph                    |
/// |      |                               |
/// |      |-------------------------------|
/// |      |  PSX stats graph              |
/// |      |                               |
/// |      |-------------------------------|
/// |      | ...                           |
/// +------+-------------------------------+
///
///

Related functions:
- PSX_GetSpecialPanel()
- PSX_GetAllEventGraph()
- PSX_GetSingleEventGraph()
- PSX_GetPSXGraph()

To find the sweep/data browser use SFH_GetBrowserForFormulaGraph() and for the reverse direction use SFH_GetFormulaGraphForBrowser.

State types

static const string PSX_TUD_FIT_STATE_KEY = "Fit State"¶

static const string PSX_TUD_EVENT_STATE_KEY = "Event State"¶

Trace types

static const string PSX_TUD_TYPE_SINGLE = "single"¶

static const string PSX_TUD_TYPE_AVERAGE = "average"¶

Different ways to derive cache key from the parameters JSON

static const double PSX_CACHE_KEY_EVENTS = 0x1¶

static const double PSX_CACHE_KEY_ANALYZE_PEAKS = 0x3¶

Functions

static string PSX_GetUserDataForWorkingFolder()¶

static dfref PSX_GetWorkingFolder(string win)¶

Return the working folder for the psx operation.

Can be null in case the operation was not executed in this sweep formula panel

static string PSX_GetSpecialPanel(string win)¶

static string PSX_GetSingleEventGraph(string win)¶

static string PSX_GetAllEventGraph(string win)¶

static wave PSX_GetCheckboxStatesFromSpecialPanel(string win, string traceType)¶

Return a wave with the checkbox states, single or average, of the special event panel.

Can be indexed with the state as dimension label.

Parameters:

win – windows
traceType – One of AllEventGraphTraceType

static string PSX_GetStateTypeFromSpecialPanel(string win)¶

Return the state type (fit or event) state from the special event panel.

One of SpecialEventPanelEventTypes

static variable PSX_GetRestrictEventsToCurrentCombo(string win)¶

static wave PSX_FilterSweepData(WaveOrNull sweepDataOff, variable low, variable high)¶

Filter the sweep data.

Parameters:

sweepDataOff – data from a single sweep and channel without inserted TP already offsetted
high – high cutoff [Hz]
low – low cutoff [Hz]

static wave PSX_CreateHistogram(wave sweepData, variable bin_start = defaultValue, variable bin_end = defaultValue, variable bin_width = defaultValue)¶

Create a histogram of the sweep data.

Parameters:

sweepData – data from a single sweep and channel without inserted TP
bin_start – [optional, defaults to data’s minimum] first histogram bin
bin_end – [optional, defaults to data’s maximum] last histogram bin
bin_width – [optional, defaults to 0.1] width of a histogram bin

static std::tuple<WAVE, variable> PSX_OffsetSweepData(wave sweepData)¶

Offset sweepData by X.

X is calculated as the x coordinate of histogram’s maximum taken of sweepData.

The result is that the histogram maximum of the offsetted trace is at zero.

static wave PSX_DeconvoluteSweepData(wave sweepData, WaveComplex psxKernelFFT, wave deconvFilter)¶

Return the deconvoluted sweep data.

Parameters:

sweepData – data from a single sweep and channel without inserted TP
psxKernelFFT – FFT’ed kernel from PSX_CreatePSXKernel()
deconvFilter – deconvolution filter settings

static wave PSX_CreateHistogramOfDeconvSweepData(wave deconvSweepData)¶: Creates a histogram of the deconvoluted sweep data.

static std::tuple<WAVE, WAVE> PSX_FitHistogram(wave input)¶: Fit the given wave with a gaussian where K0, y offset, is fixed at zero.

static std::tuple<WAVE, WAVE> PSX_Analysis(wave sweepData, wave psxKernelFFT, variable sweepFilterLow, variable sweepFilterHigh, wave deconvFilter)¶

Full analysis cycle:

filtering
offsetting
deconvolution
histogram of deconvolution
gaussian fit of histogram

static std::tuple<WaveDouble, WaveDouble> PSX_FindPeaks(wave sweepDataOffFiltDeconv, variable threshold, variable numPeaksMax = defaultValue, variable start = defaultValue, variable stop = defaultValue)¶

Searches for peaks in sweepData

Parameters:

sweepDataOffFiltDeconv – 1D wave
threshold – FindPeak parameter
numPeaksMax – maximum number of peaks to search
start – [optional, defaults first point] start x value
stop – [optional, defaults last point] end x value

Return values:

peakX – x-coordinates of peaks
peakY – y-coordinates of peaks

static std::tuple<WaveDouble, WaveDouble> PSX_FilterEventsKernelAmpSign(WaveOrNull peakXUnfiltered, WaveOrNull peakYUnfiltered, wave sweepDataOffFilt, variable kernelAmp, variable kernelRiseTau, variable kernelDecayTau, wave psxEvent)¶

static std::tuple<variable, variable> PSX_CalculateEventPeak(wave peakX, wave peakY, wave sweepDataOffFilt, variable kernelAmp, variable kernelRiseTau, variable kernelDecayTau, variable index)¶

static std::tuple<variable, variable> PSX_CalculateEventBaseline(wave sweepDataOffFilt, variable peak_t, variable kernelAmp, variable kernelRiseTau)¶

static std::tuple<variable, variable, variable, variable, variable> PSX_CalculateEventProperties(wave peakX, wave peakY, wave sweepDataOffFilt, variable kernelAmp, variable kernelRiseTau, variable kernelDecayTau, variable index)¶

static std::tuple<WaveDouble, WaveDouble> PSX_AnalyzePeaks(wave sweepDataOffFiltDeconv, wave sweepDataOffFilt, wave sweepData, WaveOrNull peakXUnfiltered, WaveOrNull peakYUnfiltered, variable maxTauFactor, variable kernelAmp, variable kernelRiseTau, variable kernelDecayTau, wave riseTimeParams, wave psxEvent, wave eventFit)¶: Analyze the peaks.

static variable PSX_GetGoodTau(wave psxEvent)¶

static variable PSX_GetGoodTauImpl(wave psxEvent)¶

static std::tuple<variable, variable> PSX_GetSingleEventRange(wave psxEvent, wave sweepDataOffFilt, variable index)¶: Return the x-axis range useful for displaying and extracting a single event.

static std::tuple<variable, variable> PSX_GetEventFitRange(wave sweepDataOffFilt, wave psxEvent, variable eventIndex)¶

Return the x-axis range for single event fitting.

x-zero is taken from sweepData

static variable PSX_FitEventDecay(wave sweepDataOffFilt, wave psxEvent, variable maxTauFactor, WaveRefWave eventFit, variable eventIndex)¶

Return the decay coefficient tau by fitting the filtered and offsetted sweep data with an offsetted exponential.

exp_XOffset: \(y = K0 + K1 \cdot exp(-(x - x0)/K2)\)

static wave PSX_CreateOverrideResults(variable numEvents, WaveText combos)¶

Create the override results 2D wave.

ROWS:

event number

COLS:

combination

LAYERS:

0: Fit result, see GetPSXEventWaveAsFree
1: Replacement tau, the default of NaN means don’t override
2: Override sign check in PSX_AnalyzePeaks (0 failing, 1 passing), the default of NaN means don’t override

static variable PSX_OperationSweepGathering(string graph, WaveRefWave psxKernelDataset, variable parameterJsonID, variable sweepFilterLow, variable sweepFilterHigh, wave deconvFilter, variable index, WaveRefWave output)¶

Returns:: 0 on success, 1 otherwise

static variable PSX_OperationImpl(string graph, variable parameterJSONID, string id, variable peakThresh, variable maxTauFactor, wave riseTimeParams, variable kernelAmp, variable kernelRiseTau, variable kernelDecayTau, variable index, WaveRefWave output)¶: Implementation of psx operation.

static string PSX_GenerateKey(string name, variable index)¶

Generate the dimension label for the output wave reference waves.

Used for psx and psxKernel as both hold #PSX_KERNEL_OUTPUTWAVES_PER_ENTRY and #PSX_OPERATION_OUTPUT_WAVES_PER_ENTRY entries per input range/sweep combination.

static wave PSX_GetPSXKernel(variable riseTau, variable decayTau, variable amp, variable numPoints, variable dt, wave range)¶: Return the PSX kernel from the cache or create it.

static std::tuple<WAVE, WAVE> PSX_CreatePSXKernel(variable riseTau, variable decayTau, variable amp, variable numPoints, variable dt)¶

Create the psx_kernel waves

from Ken Burke’s deconvolution code

The time units are abitrary but fixed for all three components.

Parameters:

riseTau – time constant
decayTau – time constant
amp – amplitude [no unit]
numPoints – number of data points
dt – time constant for normalisation

static std::tuple<WaveDouble, WAVE, WAVE, WaveText> PSX_GetStatsResults(WaveRefWave allEvents, variable state, string prop)¶: Return the data/index/marker/comboKeys of the events matching the given state and property.

static string PSX_BuildSweepEquivKey(variable chanType, variable chanNr)¶: Build the dimension label used for the sweep equivalence wave.

static std::tuple<variable, variable, variable, variable> PSX_GetSweepEquivKeyAndValue(WaveText sweepEquiv, variable channelNumberType, variable sweepIndex)¶: Return the quartett of channel number, channel type, sweep number and map index from the sweep equivalence wave located in the given channelNumberType and column coordinates.

static string PSX_BuildSweepEquivValue(variable sweepNo, variable mapIndex)¶: Build the column data used for the sweep equivalence wave.

static wave PSX_GenerateSweepEquiv(wave selectData)¶

Generate the equivalence classes of selectData.

All selections which have the same channel number and type are in one equivalence class.

The returned 2D wave has row labels from PSX_BuildSweepEquivKey() for the channel type/number and the sweep numbers in the columns.

static variable PSX_CheckResolvedRanges(wave allResolvedRanges)¶: Check that the 2xN wave allResolvedRanges has only non-intersecting ranges.

static wave PSX_OperationStatsImpl(string graph, string id, WaveRefWave ranges, wave selectData, string prop, string stateAsStr, string postProc)¶: Helper function of the psxStats operation.

static variable PSX_CalculateRiseTime(wave sweepDataOffFilt, wave psxEvent, variable kernelAmp, variable lowerThreshold, variable upperThreshold, variable index)¶

static variable PSX_CalculateOnsetTime(wave sweepDataDiff, wave psxEvent, variable kernelAmp, variable diffThreshPerc, variable index)¶

static wave PSX_GetStates(variable withAllState = defaultValue)¶

Return all possible fit/event states.

Parameters:: withAllState – [optional, defaults to false] choose to include PSX_ALL (true) or not (false)

static variable PSX_ParseState(string state)¶

string PSX_StateToString(variable state)¶

string PSX_FitResultToString(variable fitResult)¶

static variable PSX_UpdateAllEventGraph(string win, variable forceSingleEventUpdate = defaultValue, variable forceAverageUpdate = defaultValue, variable forceBlockIndexUpdate = defaultValue, variable forceSingleEventOffsetUpdate = defaultValue)¶

static variable PSX_UpdateSingleEventGraph(string win, variable index)¶

Update the single event graph.

The passed event index is from the current combo.

static variable PSX_UpdateDisplayedFit(dfref comboDFR, variable index)¶: Update the displayed fit in the single event graph.

static variable PSX_UpdateOffsetInAllEventGraph(string win)¶

static variable PSX_AdaptColorsInAllEventGraph(string win, variable forceAverageUpdate = defaultValue, variable forceSingleEventUpdate = defaultValue)¶

Update trace colors in all event graph.

This needs to be done every time an event changes its state.

Parameters:

win – window
forceAverageUpdate – [optional, defaults to false] perform an average wave update regardless if required or not.
forceSingleEventUpdate – [optional, defaults to false] update every single event trace regardless of its old state

static variable PSX_UpdateAverageTraces(string win, WaveText eventIndexFromTraces, WaveText comboIndizesFromTraces, wave stateNew, wave indexMapper, WaveDoublef comboFolders)¶: Update the contents of the average waves for the all event graph.

static variable PSX_UpdateAverageWave(WaveRefWave sourceWaves, variable numFilledSourceWaves, dfref averageDFR, variable state)¶: Helper function to update the average waves for the all event graph.

static dfref PSX_GetAverageFolder(string win)¶

static variable PSX_FitAcceptAverage(string win, dfref averageDFR, wave eventStopTime)¶

static variable PSX_StoreIntoResultsWave(string browser, variable resultType, wave data, string name)¶

static string PSX_GetPSXParameters(variable jsonID, variable cacheKeyType)¶

static variable PSX_StoreEventsIntoCache(wave psxEvent)¶

static wave PSX_LoadEventsFromCache(string comboKey, string psxParameters)¶

static std::tuple<WaveText, WaveText> PSX_GetTraceSelectionWaves(string win, string traceType, variable respectBlock = defaultValue)¶

Return the trace user data keys/values wave for the given trace type.

Parameters:

win – Window
traceType – One of AllEventGraphTraceType
respectBlock – [optional, defaults to true] Restrict the traces to the currently selected block

static variable PSX_UpdateHideStateInAllEventGraph(string win)¶: Update the hide state of all traces in the all event graph.

static variable PSX_UpdateHideStateInAllEventGraphImpl(string win, string traceType)¶

static variable PSX_UpdateBlockIndizes(string win)¶

static variable PSX_WriteBlockNumberAsUserData(string win, variable numBlocks)¶

static variable PSX_CalculateNumberOfBlocks(string win)¶

string PSX_GetAllEventBlockNumbers(string win)¶

static variable PSX_GetStateMatchPattern(wave active)¶

Return a bit pattern to match fit/event state.

Parameters:: active – Wave with at least 3 entries denoting which states are active

static variable PSX_AppendTracesToAllEventGraph(string win)¶

Add the total number of required traces to the all event graph.

The number of average waves is 4 due to the number of different states, see PSXStates.

Single event traces for all combinations
4 average waves for each combination
4 average waves for the global average across all combinations

static string PSX_GetAverageTraceName(variable idx, string basename, variable comboIndex, string traceSuffix)¶

static variable PSX_AppendAverageTraces(string extAllGraph, dfref averageDFR, string traceSuffix, variable idx, string comboKey, variable comboIndex, wave traceUserDataKeys, wave states, wave acceptColors, wave rejectColors, wave undetColors)¶: Helper function to append the average traces to the all event graph.

static variable PSX_GetCurrentEventIndex(string win)¶

Return the event index where cursor A is currently placed in the psx plot.

Returns:: event index of the current combination or NaN if there is no psx plot or valid cursor position

static variable PSX_UpdateSingleEventTextbox(string win, variable eventIndex = defaultValue)¶: Update the textbox in the single event graph.

static string PSX_GetCursorInfo(string psxGraph)¶

Return the cursor info of cursor A from the psxGraph.

Checks also that the cursor is on the expected trace

static variable PSX_CenterCursor(string win, variable leftIndex, variable constantWidth, variable rightIndex = defaultValue)¶

Adjust the axis ranges of the psx graph so that the cursor is visible.

Parameters:

win – window
leftIndex – event index to bring in axis range
constantWidth – determine if the covered x-axis range should stay constant or not
rightIndex – [optional, defaults to none] additional event index to bring in x-axis range

static variable PSX_MoveCursor(string win, string trace, variable index, variable direction)¶

Move the cursor A to the event index + direction

The window win can either be the psx graph or one of the psxStats graphs. The function wraps around on both ends and selects the previous/next combo if required.

Returns:: event index (clipped)

variable PSX_MoveCursorHelper(string win, string trace, variable index)¶

static variable PSX_MoveAndCenterCursor(string win, variable index, variable direction = defaultValue, variable constantWidth = defaultValue)¶

Move and center cursor.

File MIES_SweepFormula_PSX.ipf¶

Table of Contents

Previous topic

Next topic