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_RISETIME = 0x2¶

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(wave sweepData, variable low, variable high)¶

Filter the sweep data.

Parameters:

sweepData – data from a single sweep and channel without inserted TP
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 sweepDataFiltOffDeconv, variable threshold, variable numPeaksMax = defaultValue, variable start = defaultValue, variable stop = defaultValue)¶

Searches for peaks in sweepData

Parameters:

sweepDataFiltOffDeconv – 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 variable PSX_AnalyzePeaks(wave sweepDataFiltOffDeconv, wave sweepDataFiltOff, wave peakX, wave peakY, variable maxTauFactor, variable kernelAmp, wave psxEvent, wave eventFit)¶: Analyze the peaks.

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

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

Return the x-axis range for single event fitting.

x-zero is taken from sweepData

static variable PSX_FitEventDecay(wave sweepDataFiltOff, 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 use

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

static variable PSX_OperationImpl(string graph, variable parameterJSONID, string id, variable peakThresh, variable maxTauFactor, wave riseTimeParams, variable kernelAmp, variable index, WaveRefWave output)¶

Implementation of psx operation.

Returns:: 0 on success, 1 on failure

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> PSX_GetSweepEquivKeyAndSweep(wave sweepEquiv, variable channelNumberType, variable sweepIndex)¶: Return the triplett channel number, channel type and sweep number from the sweep equivalence wave located in the given channelNumberType and sweepIndex coordinates.

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.

variable PSX_CollectResolvedRanges(string graph, wave range, wave singleSelectData, wave allResolvedRanges, WaveText allSelectHashes)¶: Collect all resolved ranges in allResolvedRanges together with a hash of the select data.

static variable PSX_CheckResolvedRanges(wave allResolvedRanges, WaveText allSelectHashes)¶: Check that the 2xN wave allResolvedRanges has only non-intersecting ranges for the same select data hash.

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

static wave PSX_CalculateRiseTime(wave psxEvent, wave sweepDataFiltOff, variable parameterJsonID, variable kernelAmp, variable lowerThreshold, variable upperThreshold)¶

static variable PSX_CalculateRiseTimeImpl(wave psxEvent, wave sweepDataFiltOff, variable kernelAmp, variable index, variable lowerThreshold, variable upperThreshold)¶

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 eventStartTime, 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