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


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.

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.

  • 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.

  • 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.

  • 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

  • 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.


  • event number


  • combination


  • 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.


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.

  • 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.


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.

  • 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.

  • 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.


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.


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.

  • 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.


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.

See also


See also


static variable PSX_GetKeyboardDirection(string psxGraph)

Get the keyboard direction stored in user data in the psx graph.

static variable PSX_SetKeyboardDirection(string psxGraph, variable direction)

Set the keyboard direction in user data in the psx graph.

static variable PSX_GetMoveDirection(string psxGraph)

Get the move direction as +/- 1 from the keyboard direction.

static wave PSX_SelectColor(variable state, wave acceptColors, wave rejectColors, wave undetColors)

Return the appropriate color wave for the given fit/event state.

static variable PSX_SelectMarker(variable state)

Return a marker for the given fit/event state.

static variable PSX_UpdateEventWaves(string win, variable val = defaultValue, variable index = defaultValue, variable toggle = defaultValue, WaveOrNull indizes = defaultValue, variable writeState = defaultValue, variable stateType = defaultValue, variable comboIndex = defaultValue)

Update all event related waves.

One of val or toggle has to be supplied.

If neither index nor indizes is supplied all event indizes are set.

  • win – window

  • val – [optional] new state, one of PSXStates

  • index – [optional] event index to set

  • toggle – [optional] switch event state from accepted <-> rejected

  • indizes – [optional] event indizes to set

  • writeState – [optional, defaults to true] set the event state itself

  • stateType – [optional, defaults to PSX_STATE_EVENT] one of PSXStateTypes

  • comboIndex – [optional, defaults to listbox selection] select/range combination to update the events for

static std::tuple<WAVE, WAVE, WAVE> PSX_GetEventColors()

Return RGBA waves with the colors for the three event states.

static string PSX_GenerateComboKey(string graph, wave selectData, wave range)

Generate the unique combination key made up from selectData and range

This is used in the results wave, the listbox for selection and is attached to the wave note of psxEvent.

static wave PSX_GetAllCombinationFolders(dfref workDFR)

Return a datafolder reference wave with all psx combination folders.

static wave PSX_GetEventContainer(string graph, string requestID = defaultValue)

Return the psxEvent container wave for the given graph.

static wave PSX_GetEventContainerFromResults(string id)

Return the psxEvent container from the results wave for the given id.

static wave PSX_FilterEventContainer(WaveRefWaveOrNull eventContainer, string refComboKey)
static string PSX_GetPSXGraph(string win)

Return the psx graph.

Searches all subwindows of win.

static string PSX_GetPSXStatsGraph(string win)

Return the name of the possibly non-existing stats subwindow.

static wave PSX_GetEventsInsideAxisRange(string win, string traceName, variable first, variable last, wave xCrds)
static string PSX_GetComboKeyFromDFR(dfref comboDFR)

Return the combo key from the combo datafolder.

static string PSX_GetIDFromDFR(dfref comboDFR)

Return the ID from the combo datafolder.

static wave PSX_GetSpecialEventPanelCheckboxes(string specialEventPanel)
static wave PSX_GetSpecialEventPanelPopups(string specialEventPanel)
static variable PSX_StoreGuiState(string win, string browser)

Store the PSX panel GUI state in the window user data of browser

static variable PSX_RestoreGuiState(string win)

Restore the PSX panel GUI state from the window user data of browser

static dfref PSX_GetCurrentComboFolder(string win)

Return the currently in the listbox selected combination folder.

static variable PSX_GetCurrentComboIndex(string win)

Return the current combo index as selected in the listbox.

static variable PSX_GetComboIndexForComboKey(string win, string comboKey)

Return the combo index for the given comboKey.

static variable PSX_GetComboIndexFromDFR(dfref comboDFR)

Return the combo index from the given comboDFR.

The combo folder is created by GetPSXFolderForCombo()

static variable PSX_MoveWavesToDataFolders(dfref workDFR, WaveRefWaveOrNull results, variable offset, variable numCombos)

Write all psx data from results in the combination folders.

Takes care of existing combination data due to other psx calls in the same code.


Number of combinations without event data

static string PSX_CheckForUniqueIDs(dfref workDFR)
static variable PSX_CreateSingleEventWaves(dfref comboDFR, wave psxEvent, wave sweepDataFiltOff)

Extract a single wave for each event from sweepDataFiltOff.

static string PSX_FormatSingleEventWaveName(variable i)

Generate a wave name for single event waves.

static variable PSX_EventGraphSuppressUpdate(string win)
string PSX_GetEventStateNames()
string PSX_GetAverageFitAcceptNames()
static string PSX_GetUIControlHelp()
static variable PSX_CreatePSXGraphAndSubwindows(string win, string graph, SF_PlotMetaData *plotMetaData)

Create the PSX graph together with all subwindows (all event graph, single event graph)

This is only called for the very first psx operation output, subsequent psx operation outputs are just added as additional combos.

static variable PSX_MarkGraphForPSX(string win)

Mark win as being an psx graph.

static variable PSX_ApplySpecialPlotProperties(string win, wave eventLocationTicks, wave eventLocationLabels)

Apply plot properties which have to be reapplied on every combo index change.

static variable PSX_AddLegend(string win, WaveRefWave results)

Read the user JWN from results and create a legend from all operation parameters.

static std::tuple<variable, variable, variable> PSX_GetEventIndexAndComboIndex(string win, variable direction = defaultValue)

Return the event, wave and combo index.

Direction is taken into account.

  • win – window, can be an psx/psxStats graph

  • direction – [optional, defaults to 0] offset from the current position

Return values:
  • eventIndex – event index

  • waveIndex – index into the y wave of the cursor

  • comboIndex – combination index

variable PSX_PlotInteractionHook(WMWinHookStruct *s)

Window hook responsible for keyboard and mouse support.

Works with psx and psxStats graphs.

variable PSX_AllEventGraphHook(WMWinHookStruct *s)
static variable PSX_GetDirectionFromKeyCode(string psxGraph, variable keyCode)
static variable PSX_MoveMouseForKeyPress(string win, variable keyCode, variable comboIndex, variable eventIndex)
static variable PSX_ReactToKeyPressWithoutMouse(string win, variable keyCode, variable comboIndex, variable eventIndex)
wave PSX_CreateCombinationsListBoxWaveAsFree(dfref workDFR)

Return a free text wave with all combo keys.

static variable PSX_GetNumberOfCombinations(WaveRefWave results)
variable PSX_Plot(string win, string graph, WaveRefWaveOrNull results, SF_PlotMetaData *plotMetaData)

High-level function responsible for psx data and plot management.

variable PSX_PostPlot(string win)

Init the psx plot after filling it with data.

wave PSX_Operation(variable jsonId, string jsonPath, string graph)

Implementation of the psx operation.

wave PSX_OperationKernel(variable jsonId, string jsonPath, string graph)

Implementation of the psxKernel operation.

wave PSX_OperationRiseTime(variable jsonId, string jsonPath, string graph)
wave PSX_OperationDeconvFilter(variable jsonId, string jsonPath, string graph)
wave PSX_OperationStats(variable jsonId, string jsonPath, string graph)
wave PSX_OperationPrep(variable jsonId, string jsonPath, string graph)
static std::tuple<WAVE, WAVE, variable, string> PSX_CalculatePeakThreshold(WaveRefWave results, variable numCombos, variable numSDs)
variable PSX_MouseEventSelection(variable newState, variable stateType)

Menu item for selecting event inside a marquee and changing their state.

static variable PSX_GetIndexOrientation(string axisLbl)
static wave PSX_GetEventsInsideMarqueeForStatsPlot(string win, variable indexOrient, variable left, variable top, variable right, variable bottom)

Returns a 2D wave reference wave with event indices/comboKey entries in each column.


  • Result for each trace


  • 0 (eventIndizes): Indizes of events which are in range

  • 1 (comboIndex) Combo index for the events in column 0 Always only one element!

variable PSX_JumpToEvents()

Make the events inside the marquee visible in the psx plot.

static variable PSX_SetCombo(string win, variable comboIndex)

Change the current combination to comboIndex

static string PSX_GetID(string graph)
variable PSX_ButtonProc_StoreEvents(WMButtonAction *ba)
variable PSX_ButtonProc_LoadEvents(WMButtonAction *ba)
static wave PSX_GetPSXEventForComboKey(WaveRefWave eventContainer, string refComboKey)
variable PSX_ButtonProcJumpFirstUndet(WMButtonAction *ba)
variable PSX_ListBoxSelectCombo(WMListBoxAction *lba)
variable PSX_CopyHelpToClipboard(WMButtonAction *ba)
variable PSX_CheckboxProcSuppressUpdate(WMCheckboxAction *cba)
variable PSX_PopupMenuState(WMPopupAction *cba)
variable PSX_CheckboxProcAllEventPlotUpdate(WMCheckboxAction *cba)
variable PSX_CheckboxProcChangeRestrictCurrentCombo(WMCheckboxAction *cba)
variable PSX_CheckboxProcFitAcceptAverage(WMCheckboxAction *cba)
variable PSX_PopupMenuBlockNumber(WMPopupAction *cba)
variable PSX_SetVarBlockSize(WMSetVariableAction *sva)
variable PSX_PopupFitAcceptAverageFunc(WMPopupAction *cba)
variable PSX_PlotStartupSettings()
variable PSX_ApplyMacroToExistingPanel(string win, string mac)

Apply the macro mac onto the panel win


static const double PSX_DEFAULT_FILTER_HIGH = 0
static const double PSX_DEFAULT_FILTER_LOW = 550
static const double PSX_COLOR_ACCEPT_R = 0
static const double PSX_COLOR_ACCEPT_G = 65535
static const double PSX_COLOR_ACCEPT_B = 0
static const double PSX_COLOR_REJECT_R = 65535
static const double PSX_COLOR_REJECT_G = 0
static const double PSX_COLOR_REJECT_B = 0
static const double PSX_COLOR_UNDET_R = 48059
static const double PSX_COLOR_UNDET_G = 48059
static const double PSX_COLOR_UNDET_B = 48059
static const double PSX_KEYBOARD_DIR_RL = 0
static const double PSX_KEYBOARD_DIR_LR = 1
static const double PSX_NUMBER_OF_SDS_DEFAULT = 2.5
static const double PSX_NUM_PEAKS_MAX = 2000
static const double PSX_PLOT_DEFAULT_X_RANGE = 200
static const double PSX_DEFAULT_X_START_OFFSET = 2
static const string USER_DATA_KEYBOARD_DIR = "keyboard_direction"
static const string PSX_USER_DATA_WORKING_FOLDER = "psxFolder"
static const string PSX_X_DATA_UNIT = "X_DATA_UNIT"
static const string PSX_Y_DATA_UNIT = "Y_DATA_UNIT"
static const string PSX_EVENT_DIMENSION_LABELS = "sweepData;sweepDataFiltOff;sweepDataFiltOffDeconv;peakX;peakY;psxEvent;eventFit"
static const double PSX_KERNEL_OUTPUTWAVES_PER_ENTRY = 3
static const string PSX_SPECIAL_EVENT_PANEL = "SpecialEventPanel"
static const string PSX_SINGLE_EVENT_SUB_GRAPH = "Single"
static const string PSX_ALL_EVENT_SUB_GRAPH = "All"
static const string PSX_CURSOR_TRACE = "peakY"
static const string PSX_USER_DATA_TYPE = "type"
static const string PSX_USER_DATA_PSX = "PSX"
static const string PSX_JWN_COMBO_KEYS_NAME = "ComboKeys"
static const string PSX_JWN_PARAMETERS = "Parameters"
static const string PSX_JWN_STATS_POST_PROC = "PostProcessing"
static const string PSX_TUD_EVENT_INDEX_KEY = "eventIndex"
static const string PSX_UD_NUM_BLOCKS = "NumberOfBlocks"
static const string PSX_TUD_TRACE_HIDDEN_KEY = "traceHidden"
static const string PSX_TUD_TYPE_KEY = "type"
static const string PSX_TUD_COMBO_KEY = "comboKey"
static const string PSX_TUD_COMBO_INDEX = "comboIndex"
static const string PSX_TUD_BLOCK_INDEX = "blockIndex"
static const double PSX_GUI_SETTINGS_VERSION = 1
static const string PSX_GUI_SETTINGS_PSX = "GuiSettingsPSX"
static const double PSX_MAX_NUM_EVENTS = 1e6
static const string PSX_GLOBAL_AVERAGE_SUFFIX = "_global"
static const string PSX_TUD_AVERAGE_ALL_COMBO_KEY = "allCombos"
static const double PSX_TUD_AVERAGE_ALL_COMBO_INDEX = NaN
static const string PSX_AVERAGE_FIT_RESULT_DEFAULT_HELP = "No fit results available for average accept"
static const double PSX_DEFAULT_PEAK_SEARCH_RANGE_MS = 5
static const double PSX_STATS_TAU_FACTOR = 10
static const double PSX_STATS_AMP_FACTOR = 100
static const double PSX_DEFAULT_MAX_TAU_FACTOR = 10
static const string PSX_PANEL_MACRO = "PSXPanel"
static const double EVENT_INDEX_HORIZONTAL = 0x1
static const double EVENT_INDEX_VERTICAL = 0x2