matthias muntwiler
17036e1daa
- find attributes of region scans in angle-scan panel - more detailed description of reduced import with regions
1431 lines
45 KiB
Igor
1431 lines
45 KiB
Igor
#pragma rtGlobals=3 // Use modern global access method and strict wave access.
|
|
#pragma version = 1.7
|
|
#pragma IgorVersion = 6.2
|
|
#pragma ModuleName = PearlAnglescanPanel
|
|
#include "pearl-anglescan-process"
|
|
#include "pearl-pmsco-import"
|
|
|
|
// copyright (c) 2018 Paul Scherrer Institut
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
// http:///www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Please acknowledge the use of this code.
|
|
|
|
/// @file
|
|
/// @brief interactive processing of angle scanned XPD data.
|
|
/// @ingroup ArpesPackage
|
|
///
|
|
/// steps to process a hemispherical scan into a diffractogram:
|
|
/// 1. load the scan file in data reduction mode.
|
|
/// 2. open the angle scan panel by calling asp_show_panel().
|
|
/// 3. select the dataset.
|
|
/// 4. set the processing parameters.
|
|
/// 5. start the processing and display the result.
|
|
/// 6. refine parameters and repeat steps 4-5.
|
|
/// 7. export the result in the desired form.
|
|
///
|
|
/// @author matthias muntwiler, matthias.muntwiler@psi.ch
|
|
///
|
|
/// @copyright 2018 Paul Scherrer Institut @n
|
|
/// Licensed under the Apache License, Version 2.0 (the "License"); @n
|
|
/// you may not use this file except in compliance with the License. @n
|
|
/// You may obtain a copy of the License at
|
|
/// http://www.apache.org/licenses/LICENSE-2.0
|
|
///
|
|
|
|
/// @namespace PearlAnglescanPanel
|
|
/// @brief interactive processing of angle scanned XPD data.
|
|
///
|
|
/// PearlAnglescanPanel is declared in @ref pearl-anglescan-panel.ipf.
|
|
|
|
/// package name is used as data folder name
|
|
static strconstant package_name = "pearl_anglescan_panel"
|
|
/// data folder path
|
|
static strconstant package_path = "root:packages:pearl_anglescan_panel:"
|
|
/// semicolon-separated list of persistent variable, string, and wave names
|
|
static strconstant prefs_objects = "theta_offset;tilt_offset;phi_offset;alpha_offset;crop_alpha_enable;crop_alpha_value;norm_alpha_enable;norm_alpha_mode;norm_alpha_smoothing;norm_phi_enable;norm_phi_mode;norm_phi_thetarange;norm_theta_enable;norm_theta_mode;norm_theta_smoothing;norm_thetaphi_enable;norm_thetaphi_mode;norm_theta_smoothing;output_folding;output_horizon;graph_mode;graph_projection;graph_colortable;graph_contrast;"
|
|
|
|
/// initialize package data once when the procedure is first loaded
|
|
static function AfterCompiledHook()
|
|
|
|
dfref savedf = GetDataFolderDFR()
|
|
variable do_init = 1
|
|
if (DataFolderExists(package_path))
|
|
setdatafolder $(package_path)
|
|
nvar /z init_done
|
|
if (nvar_exists(init_done))
|
|
if (init_done)
|
|
do_init = 0
|
|
endif
|
|
endif
|
|
endif
|
|
|
|
if (do_init)
|
|
init_package()
|
|
load_prefs()
|
|
setdatafolder $(package_path)
|
|
variable /g init_done = 1
|
|
endif
|
|
|
|
setdatafolder savedf
|
|
return 0
|
|
end
|
|
|
|
static function init_package()
|
|
dfref savedf = getdatafolderdfr()
|
|
setdatafolder root:
|
|
newdatafolder /o/s packages
|
|
newdatafolder /o/s $package_name
|
|
|
|
// configuration (persistent)
|
|
string /g graphname = "graph_anglescan_panel"
|
|
|
|
// recently used (persistent)
|
|
variable /g theta_offset = 0
|
|
variable /g tilt_offset = 0
|
|
variable /g phi_offset = 0
|
|
variable /g alpha_offset = 0
|
|
variable /g crop_alpha_enable = 0
|
|
variable /g crop_alpha_value = 25
|
|
variable /g norm_alpha_enable = 0
|
|
variable /g norm_alpha_mode = 4
|
|
variable /g norm_alpha_smoothing = 0.25
|
|
variable /g norm_theta_enable = 0
|
|
variable /g norm_theta_mode = 4
|
|
variable /g norm_theta_smoothing = 0.25
|
|
variable /g norm_thetaphi_enable = 0
|
|
variable /g norm_thetaphi_mode = 4
|
|
variable /g norm_thetaphi_smoothing = 0.25
|
|
variable /g norm_phi_enable = 0
|
|
variable /g norm_phi_mode = 4
|
|
variable /g norm_phi_thetarange = 20
|
|
string /g output_name = "holo1"
|
|
variable /g output_folding = 1
|
|
variable /g output_horizon = 88
|
|
variable /g graph_mode = 1
|
|
variable /g graph_projection = kProjStereo
|
|
string /g graph_colortable = "grays"
|
|
variable /g graph_contrast = 2
|
|
|
|
// recently used (volatile)
|
|
string /g source_path = ""
|
|
string /g export_folderpath = "root:"
|
|
variable /g export_format = 1
|
|
|
|
// administrative data (volatile)
|
|
string /g panel_name = ""
|
|
string /g preview_graphname = ""
|
|
string /g dist_x_graphname = ""
|
|
string /g dist_y_graphname = ""
|
|
string /g output_graphname = ""
|
|
|
|
// data (volatile)
|
|
make /n=(10,10) /o raw_data, process_data
|
|
make /o dist_x, dist_x_smoo
|
|
make /o dist_y, dist_y_smoo
|
|
|
|
setdatafolder savedf
|
|
end
|
|
|
|
/// save persistent package data to the preferences file.
|
|
///
|
|
/// this function is called when the user clicks the corresponding button.
|
|
///
|
|
static function save_prefs()
|
|
dfref saveDF = GetDataFolderDFR()
|
|
|
|
string fullPath = SpecialDirPath("Packages", 0, 0, 0)
|
|
fullPath += package_name
|
|
NewPath/O/C/Q tempPackagePrefsPath, fullPath
|
|
fullPath += ":preferences.pxp"
|
|
|
|
SetDataFolder root:packages
|
|
SetDataFolder $package_name
|
|
SaveData /O /Q /J=prefs_objects fullPath
|
|
|
|
KillPath/Z tempPackagePrefsPath
|
|
|
|
SetDataFolder saveDF
|
|
end
|
|
|
|
/// load persistent package data from the preferences file.
|
|
///
|
|
/// the preferences file is an Igor packed experiment file in a special preferences folder.
|
|
///
|
|
/// this function is called automatically when the procedure is first compiled,
|
|
/// or whenever the user clicks the corresponding button.
|
|
///
|
|
static function load_prefs()
|
|
dfref saveDF = GetDataFolderDFR()
|
|
|
|
variable result = -1
|
|
setdatafolder root:
|
|
NewDataFolder /O/S packages
|
|
NewDataFolder /O/S $package_name
|
|
string fullPath = SpecialDirPath("Packages", 0, 0, 0)
|
|
fullPath += package_name
|
|
|
|
GetFileFolderInfo /Q /Z fullPath
|
|
if (V_Flag == 0) // Disk directory exists?
|
|
fullPath += ":preferences.pxp"
|
|
GetFileFolderInfo /Q /Z fullPath
|
|
if (V_Flag == 0) // Preference file exist?
|
|
LoadData /O /R /Q fullPath
|
|
result = 0
|
|
endif
|
|
endif
|
|
|
|
SetDataFolder saveDF
|
|
return result
|
|
end
|
|
|
|
/// import raw data
|
|
///
|
|
/// the raw data are copied into the package data folder,
|
|
/// and the process waves are initialized.
|
|
///
|
|
/// @param raw_data 2D intensity distribution.
|
|
/// the x dimension is the detection angle.
|
|
/// the y dimension is an arbitrary sequence of manipulator scan positions.
|
|
/// ManipulatorTheta, ManipulatorPilt and ManipulatorPhi waves
|
|
/// that indicate the manipulator angles for each y position
|
|
/// must be present in the :attr sub-folder next to the raw data wave.
|
|
///
|
|
function asp_import_raw(raw_data)
|
|
wave raw_data
|
|
|
|
dfref saveDF = GetDataFolderDFR()
|
|
dfref datadf = GetWavesDataFolderDFR(raw_data)
|
|
dfref attrdf = datadf:attr
|
|
if (!DataFolderRefStatus(attrdf))
|
|
setdatafolder datadf
|
|
setdatafolder ::
|
|
dfref parentdf = GetDataFolderDFR()
|
|
dfref attrdf = parentdf:attr
|
|
endif
|
|
setdatafolder $(package_path)
|
|
|
|
// todo : check dimensions and scales
|
|
|
|
svar source_path
|
|
source_path = GetWavesDataFolder(raw_data, 2)
|
|
|
|
duplicate /o raw_data, raw, process_data
|
|
|
|
wave /sdfr=attrdf /z ManipulatorTheta
|
|
wave /sdfr=attrdf /z ManipulatorTilt
|
|
wave /sdfr=attrdf /z ManipulatorPhi
|
|
if (WaveExists(ManipulatorTheta) && WaveExists(ManipulatorTilt) && WaveExists(ManipulatorPhi))
|
|
duplicate /o attrdf:ManipulatorTheta, raw_theta, process_theta
|
|
duplicate /o attrdf:ManipulatorTilt, raw_tilt, process_tilt
|
|
duplicate /o attrdf:ManipulatorPhi, raw_phi, process_phi
|
|
else
|
|
DoAlert 0, "Can't find manipulator angle waves.\rCheck that the attr folder exists, or provide values in the following table."
|
|
make /n=(dimsize(raw_data, 1)) /o raw_theta, raw_tilt, raw_phi
|
|
make /n=(dimsize(raw_data, 1)) /o process_theta, process_tilt, process_phi
|
|
edit /k=1 raw_theta, raw_tilt, raw_phi
|
|
endif
|
|
|
|
make /o /n=(dimsize(raw_data, 0)) dist_x, dist_x_smoo
|
|
make /o /n=(dimsize(raw_data, 1)) dist_y, dist_y_smoo
|
|
|
|
SetDataFolder saveDF
|
|
end
|
|
|
|
/// display a graph window of the processed data.
|
|
///
|
|
/// if the window exists, it is updated and brought to the front of the window stack.
|
|
///
|
|
function asp_display_previews()
|
|
dfref df = $(package_path)
|
|
wave /sdfr=df process_data
|
|
svar /sdfr=df preview_graphname
|
|
|
|
if (strlen(preview_graphname) && (wintype(preview_graphname) == 1))
|
|
ad_update_profiles(process_data)
|
|
DoWindow /F $preview_graphname
|
|
else
|
|
preview_graphname = ad_display_profiles(process_data)
|
|
endif
|
|
|
|
nvar /sdfr=df graph_contrast
|
|
svar /sdfr=df graph_colortable
|
|
set_contrast(graph_contrast, graph_contrast, graphname=preview_graphname, colortable=graph_colortable)
|
|
end
|
|
|
|
/// display a graph window of the distribution checks.
|
|
///
|
|
/// if the window exists, it is updated and brought to the front of the window stack.
|
|
///
|
|
/// @param xdist 1: display the x-distribution; 0: don't.
|
|
/// @param ydist 1: display the y-distribution; 0: don't.
|
|
///
|
|
function asp_display_dist_check(xdist, ydist)
|
|
variable xdist, ydist
|
|
|
|
dfref df = $(package_path)
|
|
wave /sdfr=df dist_x
|
|
wave /sdfr=df dist_y
|
|
wave /sdfr=df dist_x_smoo
|
|
wave /sdfr=df dist_y_smoo
|
|
svar /sdfr=df dist_x_graphname
|
|
svar /sdfr=df dist_y_graphname
|
|
|
|
if (xdist)
|
|
if (strlen(dist_x_graphname) && (wintype(dist_x_graphname) == 1))
|
|
DoWindow /F $dist_x_graphname
|
|
else
|
|
display /k=1 /n=graph_asp_dist_x dist_x, dist_x_smoo
|
|
dist_x_graphname = s_name
|
|
ModifyGraph /w=$dist_x_graphname mode(dist_x)=2
|
|
ModifyGraph /w=$dist_x_graphname lsize(dist_x)=2
|
|
ModifyGraph /w=$dist_x_graphname rgb(dist_x)=(0,0,0)
|
|
endif
|
|
endif
|
|
|
|
if (ydist)
|
|
if (strlen(dist_y_graphname) && (wintype(dist_y_graphname) == 1))
|
|
DoWindow /F $dist_y_graphname
|
|
else
|
|
display /k=1 /n=graph_asp_dist_y dist_y, dist_y_smoo
|
|
dist_y_graphname = s_name
|
|
ModifyGraph /w=$dist_y_graphname mode(dist_y)=2
|
|
ModifyGraph /w=$dist_y_graphname lsize(dist_y)=2
|
|
ModifyGraph /w=$dist_y_graphname rgb(dist_y)=(0,0,0)
|
|
endif
|
|
endif
|
|
end
|
|
|
|
/// initialize the process data with a copy of the raw data.
|
|
///
|
|
/// applies the angle offsets.
|
|
///
|
|
/// @param[in] check select which output to generate (currently not used).
|
|
/// @arg 0 (default) process data, don't calculate check waves.
|
|
/// @arg 1 process data and calculate check waves.
|
|
/// @arg 2 calculate check waves only, do not calculate process data.
|
|
///
|
|
static function do_init_process(check)
|
|
variable check
|
|
|
|
dfref df = $(package_path)
|
|
wave /sdfr=df raw
|
|
wave /sdfr=df raw_theta
|
|
wave /sdfr=df raw_tilt
|
|
wave /sdfr=df raw_phi
|
|
nvar /sdfr=df theta_offset
|
|
nvar /sdfr=df tilt_offset
|
|
nvar /sdfr=df phi_offset
|
|
nvar /sdfr=df alpha_offset
|
|
|
|
duplicate /o raw, df:process_data
|
|
duplicate /o raw_theta, df:process_theta
|
|
duplicate /o raw_tilt, df:process_tilt
|
|
duplicate /o raw_phi, df:process_phi
|
|
|
|
wave /sdfr=df process_data
|
|
wave /sdfr=df process_theta
|
|
wave /sdfr=df process_tilt
|
|
wave /sdfr=df process_phi
|
|
|
|
process_theta = raw_theta - theta_offset
|
|
process_tilt = raw_tilt - tilt_offset
|
|
process_phi = raw_phi - phi_offset
|
|
setscale /p x dimoffset(raw, 0) - alpha_offset, dimdelta(raw, 0), waveunits(raw, 0), process_data
|
|
end
|
|
|
|
/// alpha-crop the process data.
|
|
///
|
|
/// @param[in] check select which output to generate (currently not used).
|
|
/// @arg 0 (default) process data, don't calculate check waves.
|
|
/// @arg 1 process data and calculate check waves.
|
|
/// @arg 2 calculate check waves only, do not calculate process data.
|
|
///
|
|
/// @param[in] force override the global enable flag.
|
|
/// @arg 0 (default) apply this filter only if its global enable flag is set.
|
|
/// @arg 1 apply this filter even if it is not enabled.
|
|
///
|
|
static function do_crop_alpha(check, [force])
|
|
variable check
|
|
variable force
|
|
|
|
if (ParamIsDefault(force))
|
|
force = 0
|
|
endif
|
|
|
|
dfref df = $(package_path)
|
|
wave /sdfr=df process_data
|
|
nvar /sdfr=df crop_alpha_enable
|
|
nvar /sdfr=df crop_alpha_value
|
|
|
|
if ((force || crop_alpha_enable) && (crop_alpha_value > abs(dimdelta(process_data, 0))))
|
|
crop_strip(process_data, -crop_alpha_value, +crop_alpha_value)
|
|
endif
|
|
end
|
|
|
|
/// alpha-normalize the process data.
|
|
///
|
|
/// @param[in] check select which output to generate.
|
|
/// @arg 0 (default) process data, don't calculate check waves.
|
|
/// @arg 1 process data and calculate check waves.
|
|
/// @arg 2 calculate check waves only, do not calculate process data.
|
|
///
|
|
/// @param[in] force override the global enable flag.
|
|
/// @arg 0 (default) apply this filter only if its global enable flag is set.
|
|
/// @arg 1 apply this filter even if it is not enabled.
|
|
///
|
|
static function do_norm_alpha(check, [force])
|
|
variable check
|
|
variable force
|
|
|
|
if (ParamIsDefault(force))
|
|
force = 0
|
|
endif
|
|
|
|
dfref saveDF = GetDataFolderDFR()
|
|
dfref df = $(package_path)
|
|
wave /sdfr=df process_data
|
|
nvar /sdfr=df norm_alpha_enable
|
|
nvar /sdfr=df norm_alpha_mode
|
|
nvar /sdfr=df norm_alpha_smoothing
|
|
|
|
if (force || norm_alpha_enable)
|
|
dfref temp_df = newfreedatafolder()
|
|
setdatafolder temp_df
|
|
normalize_strip_x(process_data, smooth_method=norm_alpha_mode, smooth_factor=norm_alpha_smoothing, check=check)
|
|
if (check)
|
|
wave check_dist
|
|
wave check_smoo
|
|
duplicate /o check_dist, df:dist_x
|
|
duplicate /o check_smoo, df:dist_x_smoo
|
|
endif
|
|
endif
|
|
|
|
SetDataFolder saveDF
|
|
end
|
|
|
|
/// phi-normalize the process data.
|
|
///
|
|
/// @param[in] check select which output to generate.
|
|
/// @arg 0 (default) process data, don't calculate check waves.
|
|
/// @arg 1 process data and calculate check waves.
|
|
/// @arg 2 calculate check waves only, do not calculate process data.
|
|
///
|
|
/// @param[in] force override the global enable flag.
|
|
/// @arg 0 (default) apply this filter only if its global enable flag is set.
|
|
/// @arg 1 apply this filter even if it is not enabled.
|
|
///
|
|
static function do_norm_phi(check, [force])
|
|
variable check
|
|
variable force
|
|
|
|
if (ParamIsDefault(force))
|
|
force = 0
|
|
endif
|
|
|
|
dfref saveDF = GetDataFolderDFR()
|
|
dfref df = $(package_path)
|
|
wave /sdfr=df process_data
|
|
wave /sdfr=df process_theta
|
|
wave /sdfr=df process_phi
|
|
nvar /sdfr=df norm_phi_enable
|
|
nvar /sdfr=df norm_phi_mode
|
|
nvar /sdfr=df norm_phi_thetarange
|
|
|
|
if (force || norm_phi_enable)
|
|
dfref temp_df = newfreedatafolder()
|
|
setdatafolder temp_df
|
|
normalize_strip_phi(process_data, process_theta, process_phi, theta_range=norm_phi_thetarange, check=check)
|
|
if (check)
|
|
wave check_dist
|
|
wave check_smoo
|
|
duplicate /o check_dist, df:dist_y
|
|
duplicate /o check_smoo, df:dist_y_smoo
|
|
endif
|
|
endif
|
|
|
|
SetDataFolder saveDF
|
|
end
|
|
|
|
/// theta-normalize the process data.
|
|
///
|
|
/// @param[in] check select which output to generate.
|
|
/// @arg 0 (default) process data, don't calculate check waves.
|
|
/// @arg 1 process data and calculate check waves.
|
|
/// @arg 2 calculate check waves only, do not calculate process data.
|
|
///
|
|
/// @param[in] force override the global enable flag.
|
|
/// @arg 0 (default) apply this filter only if its global enable flag is set.
|
|
/// @arg 1 apply this filter even if it is not enabled.
|
|
///
|
|
static function do_norm_theta(check, [force])
|
|
variable check
|
|
variable force
|
|
|
|
if (ParamIsDefault(force))
|
|
force = 0
|
|
endif
|
|
|
|
dfref saveDF = GetDataFolderDFR()
|
|
dfref df = $(package_path)
|
|
wave /sdfr=df process_data
|
|
wave /sdfr=df process_theta
|
|
nvar /sdfr=df norm_theta_enable
|
|
nvar /sdfr=df norm_theta_mode
|
|
nvar /sdfr=df norm_theta_smoothing
|
|
|
|
if (force || norm_theta_enable)
|
|
dfref temp_df = newfreedatafolder()
|
|
setdatafolder temp_df
|
|
normalize_strip_theta(process_data, process_theta, smooth_method=norm_theta_mode, smooth_factor=norm_theta_smoothing, check=check)
|
|
if (check)
|
|
wave check_dist
|
|
wave check_smoo
|
|
duplicate /o check_dist, df:dist_y
|
|
duplicate /o check_smoo, df:dist_y_smoo
|
|
endif
|
|
endif
|
|
|
|
SetDataFolder saveDF
|
|
end
|
|
|
|
/// theta,phi-normalize the process data.
|
|
///
|
|
/// @param[in] check select which output to generate.
|
|
/// @arg 0 (default) process data, don't calculate check waves.
|
|
/// @arg 1 process data and calculate check waves.
|
|
/// @arg 2 calculate check waves only, do not calculate process data.
|
|
///
|
|
/// @param[in] force override the global enable flag.
|
|
/// @arg 0 (default) apply this filter only if its global enable flag is set.
|
|
/// @arg 1 apply this filter even if it is not enabled.
|
|
///
|
|
static function do_norm_thetaphi(check, [force])
|
|
variable check
|
|
variable force
|
|
|
|
if (ParamIsDefault(force))
|
|
force = 0
|
|
endif
|
|
|
|
dfref saveDF = GetDataFolderDFR()
|
|
dfref df = $(package_path)
|
|
wave /sdfr=df process_data
|
|
wave /sdfr=df process_theta
|
|
wave /sdfr=df process_phi
|
|
nvar /sdfr=df norm_thetaphi_enable
|
|
nvar /sdfr=df norm_thetaphi_mode
|
|
nvar /sdfr=df norm_thetaphi_smoothing
|
|
|
|
if (force || norm_thetaphi_enable)
|
|
dfref temp_df = newfreedatafolder()
|
|
setdatafolder temp_df
|
|
normalize_strip_thetaphi(process_data, process_theta, process_phi, smooth_method=norm_thetaphi_mode, smooth_factor=norm_thetaphi_smoothing, check=check)
|
|
if (check)
|
|
wave check_dist
|
|
wave check_smoo
|
|
duplicate /o check_dist, df:dist_y
|
|
duplicate /o check_smoo, df:dist_y_smoo
|
|
endif
|
|
endif
|
|
|
|
SetDataFolder saveDF
|
|
end
|
|
|
|
/// calculate the output using all enabled processing filters.
|
|
///
|
|
/// the diffractogram is calculated, to display the graph, call @ref asp_display_graph.
|
|
///
|
|
function asp_calculate_output()
|
|
dfref saveDF = GetDataFolderDFR()
|
|
setdatafolder $(package_path)
|
|
|
|
svar output_name
|
|
|
|
wave process_data
|
|
wave process_theta
|
|
wave process_tilt
|
|
wave process_phi
|
|
|
|
nvar folding=output_folding
|
|
nvar horizon=output_horizon
|
|
|
|
do_init_process(0)
|
|
do_crop_alpha(0)
|
|
do_norm_alpha(0)
|
|
do_norm_phi(0)
|
|
do_norm_theta(0)
|
|
do_norm_thetaphi(0)
|
|
|
|
pizza_service_2(process_data, output_name, process_theta, process_tilt, process_phi, folding=folding, nograph=1)
|
|
|
|
setdatafolder $output_name
|
|
wave values
|
|
wave pol
|
|
if (horizon > 0)
|
|
values = pol <= horizon ? values : nan
|
|
endif
|
|
|
|
SetDataFolder saveDF
|
|
end
|
|
|
|
/// display the output diffractogram in a new graph
|
|
///
|
|
function asp_display_output()
|
|
dfref df = $(package_path)
|
|
|
|
svar /sdfr=df output_name
|
|
svar /sdfr=df output_graphname
|
|
nvar /sdfr=df graph_projection
|
|
nvar /sdfr=df graph_mode
|
|
|
|
dfref saveDF = GetDataFolderDFR()
|
|
setdatafolder $(package_path)
|
|
output_graphname = output_name
|
|
output_graphname = display_hemi_scan(output_name, projection=graph_projection, graphtype=graph_mode, graphname=output_graphname)
|
|
SetDataFolder saveDF
|
|
asp_update_graph()
|
|
end
|
|
|
|
/// update graphs with new color table or contrast
|
|
///
|
|
/// applies to the preview graph and the diffractogram.
|
|
///
|
|
function asp_update_graph()
|
|
dfref df = $(package_path)
|
|
|
|
svar /sdfr=df preview_graphname
|
|
svar /sdfr=df output_graphname
|
|
svar /sdfr=df graph_colortable
|
|
nvar /sdfr=df graph_contrast
|
|
|
|
if (strlen(preview_graphname) && (wintype(preview_graphname) == 1))
|
|
set_contrast(graph_contrast, graph_contrast, graphname=preview_graphname, colortable=graph_colortable)
|
|
endif
|
|
if (strlen(output_graphname) && (wintype(output_graphname) == 1))
|
|
set_contrast(graph_contrast, graph_contrast, graphname=output_graphname, colortable=graph_colortable)
|
|
endif
|
|
end
|
|
|
|
/// close all graphs created by the angle scan panel
|
|
///
|
|
function asp_close_graphs()
|
|
dfref df = $(package_path)
|
|
|
|
svar /sdfr=df preview_graphname
|
|
svar /sdfr=df output_graphname
|
|
svar /sdfr=df dist_x_graphname
|
|
svar /sdfr=df dist_y_graphname
|
|
|
|
if (strlen(preview_graphname) && (wintype(preview_graphname) == 1))
|
|
killwindow $preview_graphname
|
|
endif
|
|
if (strlen(output_graphname) && (wintype(output_graphname) == 1))
|
|
killwindow $output_graphname
|
|
endif
|
|
if (strlen(dist_x_graphname) && (wintype(dist_x_graphname) == 1))
|
|
killwindow $dist_x_graphname
|
|
endif
|
|
if (strlen(dist_y_graphname) && (wintype(dist_y_graphname) == 1))
|
|
killwindow $dist_y_graphname
|
|
endif
|
|
|
|
preview_graphname = ""
|
|
output_graphname = ""
|
|
dist_x_graphname = ""
|
|
dist_y_graphname = ""
|
|
end
|
|
|
|
/// copy the output data to a new folder
|
|
///
|
|
/// @param dest_name name of destination folder.
|
|
/// can contain a relative (starting with a colon) or absolute (starting with "root:") path.
|
|
/// folders in the path must exist except for the last one.
|
|
/// the destination folder does not need to exist.
|
|
/// existing data in the destination folder is overwritten.
|
|
///
|
|
function asp_duplicate_output(dest_name)
|
|
string dest_name
|
|
|
|
dfref df = $(package_path)
|
|
svar /sdfr=df source_path
|
|
svar /sdfr=df output_name
|
|
svar /sdfr=df output_graphname
|
|
wave raw_data = $source_path
|
|
|
|
dfref saveDF = GetDataFolderDFR()
|
|
dfref dest_df = GetWavesDataFolderDFR(raw_data)
|
|
setdatafolder dest_df
|
|
newdatafolder /o /s $dest_name
|
|
dfref dest_df = GetDataFolderDFR()
|
|
setdatafolder df
|
|
duplicate_hemi_scan(output_name, dest_df, "")
|
|
|
|
SetDataFolder saveDF
|
|
end
|
|
|
|
/// save the output diffractogram to an igor text file
|
|
///
|
|
function asp_save_output_itx()
|
|
dfref df = $(package_path)
|
|
svar /sdfr=df output_name
|
|
|
|
dfref saveDF = GetDataFolderDFR()
|
|
setdatafolder df
|
|
save_hemi_scan(output_name, "", "")
|
|
|
|
SetDataFolder saveDF
|
|
end
|
|
|
|
/// save the output diffractogram to a PMSCO ETPI file
|
|
///
|
|
/// @param ekin kinetic energy in eV
|
|
///
|
|
function asp_save_output_etpi(ekin)
|
|
variable ekin
|
|
|
|
dfref df = $(package_path)
|
|
svar /sdfr=df output_name
|
|
wave /sdfr=df process_data
|
|
|
|
dfref saveDF = GetDataFolderDFR()
|
|
setdatafolder df
|
|
string s_prefix = ""
|
|
string s_int = "values"
|
|
dfref data_df = find_hemi_data(output_name, s_prefix, s_int)
|
|
string s_polar = s_prefix + "pol"
|
|
string s_azim = s_prefix + "az"
|
|
|
|
pmsco_save_scan("", "", num2str(ekin), s_polar, s_azim, "", s_int, "", sdfr=data_df)
|
|
|
|
SetDataFolder saveDF
|
|
end
|
|
|
|
static function check_norm_alpha()
|
|
do_init_process(0)
|
|
do_crop_alpha(0)
|
|
do_norm_alpha(2, force=1)
|
|
asp_display_dist_check(1, 0)
|
|
end
|
|
|
|
static function check_norm_phi()
|
|
do_init_process(0)
|
|
do_crop_alpha(0)
|
|
do_norm_phi(2, force=1)
|
|
asp_display_dist_check(0, 1)
|
|
end
|
|
|
|
static function check_norm_theta()
|
|
do_init_process(0)
|
|
do_crop_alpha(0)
|
|
do_norm_theta(2, force=1)
|
|
asp_display_dist_check(0, 1)
|
|
end
|
|
|
|
static function check_norm_thetaphi()
|
|
do_init_process(0)
|
|
do_crop_alpha(0)
|
|
do_norm_thetaphi(2, force=1)
|
|
asp_display_dist_check(0, 1)
|
|
end
|
|
|
|
static function preview_crop_alpha()
|
|
do_init_process(0)
|
|
do_crop_alpha(0, force=1)
|
|
asp_display_previews()
|
|
end
|
|
|
|
static function preview_norm_alpha()
|
|
do_init_process(0)
|
|
do_crop_alpha(0)
|
|
do_norm_alpha(1, force=1)
|
|
asp_display_previews()
|
|
end
|
|
|
|
static function preview_norm_phi()
|
|
do_init_process(0)
|
|
do_crop_alpha(0)
|
|
do_norm_phi(1, force=1)
|
|
asp_display_previews()
|
|
end
|
|
|
|
static function preview_norm_theta()
|
|
do_init_process(0)
|
|
do_crop_alpha(0)
|
|
do_norm_theta(1, force=1)
|
|
asp_display_previews()
|
|
end
|
|
|
|
static function preview_norm_thetaphi()
|
|
do_init_process(0)
|
|
do_crop_alpha(0)
|
|
do_norm_thetaphi(1, force=1)
|
|
asp_display_previews()
|
|
end
|
|
|
|
/// create the angle scan processing panel
|
|
///
|
|
function asp_show_panel()
|
|
dfref df = $(package_path)
|
|
svar /sdfr=df panel_name
|
|
|
|
if (strlen(panel_name) && (wintype(panel_name) == 7))
|
|
DoWindow /F $panel_name
|
|
return 0
|
|
endif
|
|
|
|
NewPanel /K=1 /N=anglescan_panel /W=(200,100,479,1027) as "angle scan processing"
|
|
panel_name = s_name
|
|
|
|
GroupBox gb_source, title="data source"
|
|
Button b_source_select, size={50,20},proc=PearlAnglescanPanel#bp_source_select,title="select..."
|
|
Button b_source_select, help={"select the source wave, e.g. ReducedData1. it must be in the original scan data folder along with the attr folder and the manipulator positions."}
|
|
TitleBox tb_source_path, size={240,21}
|
|
TitleBox tb_source_path,variable= root:packages:pearl_anglescan_panel:source_path
|
|
|
|
GroupBox gb_offsets, title="offsets"
|
|
SetVariable sv_theta_offset, size={88,16},bodyWidth=60,title="theta"
|
|
SetVariable sv_theta_offset,value= root:packages:pearl_anglescan_panel:theta_offset
|
|
SetVariable sv_theta_offset, help={"manipulator theta value that corresponds to normal emission."}
|
|
SetVariable sv_tilt_offset, size={74,16},bodyWidth=60,title="tilt"
|
|
SetVariable sv_tilt_offset,value= root:packages:pearl_anglescan_panel:tilt_offset
|
|
SetVariable sv_tilt_offset, help={"manipulator tilt value that corresponds to normal emission."}
|
|
SetVariable sv_phi_offset, size={78,16},bodyWidth=60,title="phi"
|
|
SetVariable sv_phi_offset,value= root:packages:pearl_anglescan_panel:phi_offset
|
|
SetVariable sv_phi_offset, help={"manipulator phi value that should map to the 3 o'clock angle."}
|
|
SetVariable sv_alpha_offset, size={90,16},bodyWidth=60,title="alpha"
|
|
SetVariable sv_alpha_offset,value= root:packages:pearl_anglescan_panel:alpha_offset
|
|
SetVariable sv_alpha_offset, help={"alpha value that corresponds to normal emission (if the sample normal is properly aligned)."}
|
|
|
|
GroupBox gb_crop_alpha, title="crop alpha"
|
|
CheckBox cb_crop_alpha_enable, size={50,14}, title="enable"
|
|
CheckBox cb_crop_alpha_enable, help={"enable cropping at +/- alpha"}
|
|
CheckBox cb_crop_alpha_enable,variable= root:packages:pearl_anglescan_panel:crop_alpha_enable
|
|
SetVariable sv_crop_alpha_value, size={90,16},bodyWidth=60,title="angle"
|
|
SetVariable sv_crop_alpha_value,limits={0,30,1},value= root:packages:pearl_anglescan_panel:crop_alpha_value
|
|
SetVariable sv_crop_alpha_value, help={"alpha (detection angle) cropping angle"}
|
|
Button b_crop_alpha_preview, size={80,20},proc=PearlAnglescanPanel#bp_crop_alpha_preview,title="preview"
|
|
Button b_crop_alpha_preview, help={"show a preview of the cropped dataset."}
|
|
|
|
GroupBox gb_norm_alpha, title="normalize alpha"
|
|
CheckBox cb_norm_alpha_enable, size={50,14}, title="enable"
|
|
CheckBox cb_norm_alpha_enable,variable= root:packages:pearl_anglescan_panel:norm_alpha_enable
|
|
CheckBox cb_norm_alpha_enable, help={"enable normalization of the alpha distribution"}
|
|
PopupMenu pm_norm_alpha_mode, size={138,21}, bodyWidth=100, proc=PearlAnglescanPanel#pmp_norm_alpha_mode,title="method"
|
|
PopupMenu pm_norm_alpha_mode, mode=5, popvalue="loess", value= #"\"none;binomial;boxcar;scienta;loess;\""
|
|
PopupMenu pm_norm_alpha_mode, help={"alpha normalization method. recommended: loess"}
|
|
SetVariable sv_norm_alpha_smoothing, size={112,16}, bodyWidth=60, title="smoothing"
|
|
SetVariable sv_norm_alpha_smoothing, limits={0,1,0.05}, value= root:packages:pearl_anglescan_panel:norm_alpha_smoothing
|
|
SetVariable sv_norm_alpha_smoothing, help={"smoothing parameter (depends on the normalization method)."}
|
|
Button b_norm_alpha_check, size={80,20}, proc=PearlAnglescanPanel#bp_norm_alpha_check,title="check"
|
|
Button b_norm_alpha_check, help={"show a graph of the normalization function"}
|
|
Button b_norm_alpha_preview, size={80,20}, proc=PearlAnglescanPanel#bp_norm_alpha_preview,title="preview"
|
|
Button b_norm_alpha_preview, help={"show a preview of the normalized dataset (without other normalizations)."}
|
|
|
|
GroupBox gb_norm_phi, title="normalize phi"
|
|
CheckBox cb_norm_phi_enable, size={50,14}, title="enable"
|
|
CheckBox cb_norm_phi_enable,variable= root:packages:pearl_anglescan_panel:norm_phi_enable
|
|
CheckBox cb_norm_phi_enable, help={"enable normalization of the phi distribution to reduce the effect of wobble"}
|
|
SetVariable sv_norm_phi_range, size={118,16}, bodyWidth=60, title="theta range"
|
|
SetVariable sv_norm_phi_range, limits={0,90,1}, value= root:packages:pearl_anglescan_panel:norm_phi_thetarange
|
|
SetVariable sv_norm_phi_range, help={"theta range (from normal) to factor into the normalization function"}
|
|
Button b_norm_phi_check, size={80,20}, proc=PearlAnglescanPanel#bp_norm_phi_check, title="check"
|
|
Button b_norm_phi_check, help={"show a graph of the normalization function"}
|
|
Button b_norm_phi_preview, size={80,20}, proc=PearlAnglescanPanel#bp_norm_phi_preview, title="preview"
|
|
Button b_norm_phi_preview, help={"show a preview of the normalized dataset (without other normalizations)."}
|
|
|
|
GroupBox gb_norm_theta, title="normalize theta"
|
|
CheckBox cb_norm_theta_enable, size={50,14},title="enable"
|
|
CheckBox cb_norm_theta_enable, variable= root:packages:pearl_anglescan_panel:norm_theta_enable
|
|
CheckBox cb_norm_theta_enable, help={"enable normalization of the theta distribution (integrated over phi)"}
|
|
PopupMenu pm_norm_theta_mode, size={138,21},bodyWidth=100,proc=PearlAnglescanPanel#pmp_norm_theta_mode,title="method"
|
|
PopupMenu pm_norm_theta_mode,mode=5,popvalue="loess",value= #"\"none;binomial;boxcar;polynomial;loess;\""
|
|
PopupMenu pm_norm_theta_mode, help={"theta normalization method. recommended: loess"}
|
|
SetVariable sv_norm_theta_smoothing, size={112,16}, bodyWidth=60, title="smoothing"
|
|
SetVariable sv_norm_theta_smoothing, limits={0,1,0.05}, value= root:packages:pearl_anglescan_panel:norm_theta_smoothing
|
|
SetVariable sv_norm_theta_smoothing, help={"smoothing parameter (depends on the normalization method)."}
|
|
Button b_norm_theta_check, size={80,20}, proc=PearlAnglescanPanel#bp_norm_theta_check, title="check"
|
|
Button b_norm_theta_check, help={"show a graph of the normalization function"}
|
|
Button b_norm_theta_preview, size={80,20}, proc=PearlAnglescanPanel#bp_norm_theta_preview, title="preview"
|
|
Button b_norm_theta_preview, help={"show a preview of the normalized dataset (without other normalizations)."}
|
|
|
|
GroupBox gb_norm_thetaphi, size={272,97},title="normalize (theta,phi)"
|
|
CheckBox cb_norm_thetaphi_enable, size={50,14},title="enable"
|
|
CheckBox cb_norm_thetaphi_enable, variable= root:packages:pearl_anglescan_panel:norm_thetaphi_enable
|
|
CheckBox cb_norm_thetaphi_enable, help={"enable normalization of the (theta, phi) distribution."}
|
|
PopupMenu pm_norm_thetaphi_mode, size={138,21}, bodyWidth=100, proc=PearlAnglescanPanel#pmp_norm_thetaphi_mode,title="method"
|
|
PopupMenu pm_norm_thetaphi_mode, mode=5, popvalue="loess", value= #"\"none;none;none;none;loess;\""
|
|
PopupMenu pm_norm_thetaphi_mode, help={"theta normalization method. recommended: loess"}
|
|
SetVariable sv_norm_thetaphi_smoothing, size={112,16}, bodyWidth=60, title="smoothing"
|
|
SetVariable sv_norm_thetaphi_smoothing, limits={0,1,0.05}, value= root:packages:pearl_anglescan_panel:norm_thetaphi_smoothing
|
|
SetVariable sv_norm_thetaphi_smoothing, help={"smoothing parameter (depends on the normalization method)."}
|
|
Button b_norm_thetaphi_check, size={80,20}, proc=PearlAnglescanPanel#bp_norm_thetaphi_check, title="check"
|
|
Button b_norm_thetaphi_check, help={"show a graph of the normalization function"}
|
|
Button b_norm_thetaphi_preview, size={80,20}, proc=PearlAnglescanPanel#bp_norm_thetaphi_preview, title="preview"
|
|
Button b_norm_thetaphi_preview, help={"show a preview of the normalized dataset (without other normalizations)."}
|
|
|
|
GroupBox gb_output, title="output"
|
|
SetVariable sv_output_folding, size={95,16}, bodyWidth=60, title="folding"
|
|
SetVariable sv_output_folding, limits={1,20,1}, value= root:packages:pearl_anglescan_panel:output_folding
|
|
SetVariable sv_output_folding, help={"n-fold rotational average. 1=no averaging."}
|
|
SetVariable sv_output_horizon, size={98,16}, bodyWidth=60, title="horizon"
|
|
SetVariable sv_output_horizon, limits={1,90,1}, value= root:packages:pearl_anglescan_panel:output_horizon
|
|
SetVariable sv_output_horizon, help={"highest theta to display"}
|
|
PopupMenu pm_graph_projection, size={149,21}, bodyWidth=100, proc=PearlAnglescanPanel#pmp_graph_projection, title="projection"
|
|
PopupMenu pm_graph_projection, mode=2, popvalue="stereographic", value= #"\"equidistant;stereographic;equal area;gnomonic;orthographic;\""
|
|
PopupMenu pm_graph_projection, help={"projection (theta mapping) mode"}
|
|
PopupMenu pm_graph_mode, size={129,21}, bodyWidth=100, proc=PearlAnglescanPanel#pmp_graph_mode,title="mode"
|
|
PopupMenu pm_graph_mode, mode=2, popvalue="polar plot", value= #"\"none;polar plot;none;image;\""
|
|
PopupMenu pm_graph_mode, help={"graph mode"}
|
|
Button b_output_calc, size={80,20}, proc=PearlAnglescanPanel#bp_output_calc, title="calc + display"
|
|
Button b_output_calc, help={"execute data processing with the enabled filters and display the diffractogram."}
|
|
Button b_output_duplicate, size={80,20}, proc=PearlAnglescanPanel#bp_output_duplicate, title="duplicate ..."
|
|
Button b_output_duplicate, help={"copy the result to an arbitrary data folder."}
|
|
Button b_output_itx, size={80,20}, proc=PearlAnglescanPanel#bp_output_itx, title="save ITX ..."
|
|
Button b_output_itx, help={"save the result to an igor text file (itx)."}
|
|
Button b_output_etpi, size={80,20}, proc=PearlAnglescanPanel#bp_output_etpi, title="save ETPI ..."
|
|
Button b_output_etpi, help={"save the result to a pmsco angle scan file (etpi)."}
|
|
|
|
GroupBox gb_graph, title="graph"
|
|
PopupMenu pm_graph_colortable, size={152,21}, bodyWidth=100, proc=PearlAnglescanPanel#pmp_graph_colortable, title="color table"
|
|
PopupMenu pm_graph_colortable, mode=0, value= #"\"*COLORTABLEPOPNONAMES*\""
|
|
PopupMenu pm_graph_colortable, help={"color table to use in pseudocolor graphs."}
|
|
SetVariable sv_graph_contrast, size={119,16}, bodyWidth=60, title="contrast (%)"
|
|
SetVariable sv_graph_contrast, limits={0,25,1}, value= root:packages:pearl_anglescan_panel:graph_contrast
|
|
SetVariable sv_graph_contrast, help={"contrast value (percentile)."}
|
|
Button b_graph_update, size={80,20}, proc=PearlAnglescanPanel#bp_graph_update, title="update"
|
|
Button b_graph_update, help={"update the existing graph."}
|
|
Button b_graph_png, size={80,20}, proc=PearlAnglescanPanel#bp_graph_png, title="save PNG ..."
|
|
Button b_graph_png, help={"save the graph in png format."}
|
|
|
|
arrange_controls()
|
|
update_menus()
|
|
end
|
|
|
|
static function arrange_controls()
|
|
dfref df = $(package_path)
|
|
svar /sdfr=df panel_name
|
|
|
|
variable gb_space = 2
|
|
variable gb_internal_top = 20
|
|
variable gb_internal_bot = 8
|
|
variable line_space = 26
|
|
|
|
variable cb_adj = 2
|
|
variable sv_adj = 2
|
|
variable pm_adj = 0
|
|
variable b_adj = 0
|
|
variable tb_adj = 0
|
|
|
|
variable gb_top = 4
|
|
variable gb_ht = 0
|
|
|
|
// ht = line + 30
|
|
// gb = gb + ht + 2
|
|
// cb = gb + 18
|
|
// pm = gb + 38
|
|
// line += 26
|
|
// sv = line + 2
|
|
|
|
GroupBox gb_source,pos={4,gb_top}
|
|
gb_ht = gb_internal_top
|
|
Button b_source_select,pos={17, gb_top + gb_ht + b_adj},size={50,20}
|
|
gb_ht += line_space
|
|
TitleBox tb_source_path,pos={18, gb_top + gb_ht + tb_adj},size={240,21}
|
|
gb_ht += line_space
|
|
gb_ht += gb_internal_bot
|
|
GroupBox gb_source, size={272,gb_ht}
|
|
|
|
gb_top += gb_ht + gb_space
|
|
GroupBox gb_offsets,pos={4,gb_top}
|
|
gb_ht = gb_internal_top
|
|
SetVariable sv_theta_offset,pos={46, gb_top + gb_ht + sv_adj},size={88,16}
|
|
gb_ht += line_space
|
|
SetVariable sv_tilt_offset,pos={60, gb_top + gb_ht + sv_adj},size={74,16}
|
|
gb_ht += line_space
|
|
SetVariable sv_phi_offset,pos={56, gb_top + gb_ht + sv_adj},size={78,16}
|
|
gb_ht += line_space
|
|
SetVariable sv_alpha_offset,pos={44, gb_top + gb_ht + sv_adj},size={90,16}
|
|
gb_ht += line_space
|
|
gb_ht += gb_internal_bot
|
|
GroupBox gb_offsets, size={272,gb_ht}
|
|
|
|
gb_top += gb_ht + gb_space
|
|
GroupBox gb_crop_alpha,pos={4,gb_top}
|
|
gb_ht = gb_internal_top
|
|
CheckBox cb_crop_alpha_enable,pos={73, gb_top + gb_ht + cb_adj},size={50,14}
|
|
gb_ht += line_space
|
|
SetVariable sv_crop_alpha_value,pos={44, gb_top + gb_ht + sv_adj},size={90,16}
|
|
Button b_crop_alpha_preview,pos={186, gb_top + gb_ht + b_adj},size={80,20}
|
|
gb_ht += line_space
|
|
gb_ht += gb_internal_bot
|
|
GroupBox gb_crop_alpha, size={272,gb_ht}
|
|
|
|
gb_top += gb_ht + gb_space
|
|
GroupBox gb_norm_alpha,pos={4,gb_top}
|
|
gb_ht = gb_internal_top
|
|
CheckBox cb_norm_alpha_enable,pos={73, gb_top + gb_ht + cb_adj},size={50,14}
|
|
gb_ht += line_space
|
|
PopupMenu pm_norm_alpha_mode,pos={36, gb_top + gb_ht + pm_adj},size={138,21}
|
|
Button b_norm_alpha_check,pos={186, gb_top + gb_ht + b_adj},size={80,20}
|
|
gb_ht += line_space
|
|
SetVariable sv_norm_alpha_smoothing,pos={22, gb_top + gb_ht + sv_adj},size={112,16}
|
|
Button b_norm_alpha_preview,pos={186, gb_top + gb_ht + b_adj},size={80,20}
|
|
gb_ht += line_space
|
|
gb_ht += gb_internal_bot
|
|
GroupBox gb_norm_alpha, size={272,gb_ht}
|
|
|
|
gb_top += gb_ht + gb_space
|
|
GroupBox gb_norm_phi,pos={4,gb_top}
|
|
gb_ht = gb_internal_top
|
|
CheckBox cb_norm_phi_enable,pos={73, gb_top + gb_ht + cb_adj},size={50,14}
|
|
Button b_norm_phi_check,pos={186, gb_top + gb_ht + b_adj},size={80,20}
|
|
gb_ht += line_space
|
|
SetVariable sv_norm_phi_range,pos={15, gb_top + gb_ht + sv_adj},size={118,16}
|
|
Button b_norm_phi_preview,pos={186, gb_top + gb_ht + b_adj},size={80,20}
|
|
gb_ht += line_space
|
|
gb_ht += gb_internal_bot
|
|
GroupBox gb_norm_phi, size={272,gb_ht}
|
|
|
|
gb_top += gb_ht + gb_space
|
|
GroupBox gb_norm_theta,pos={4,gb_top}
|
|
gb_ht = gb_internal_top
|
|
CheckBox cb_norm_theta_enable,pos={73, gb_top + gb_ht + cb_adj},size={50,14}
|
|
gb_ht += line_space
|
|
PopupMenu pm_norm_theta_mode,pos={35, gb_top + gb_ht + pm_adj},size={138,21}
|
|
Button b_norm_theta_check,pos={186, gb_top + gb_ht + b_adj},size={80,20}
|
|
gb_ht += line_space
|
|
SetVariable sv_norm_theta_smoothing,pos={21, gb_top + gb_ht + sv_adj},size={112,16}
|
|
Button b_norm_theta_preview,pos={186, gb_top + gb_ht + b_adj},size={80,20}
|
|
gb_ht += line_space
|
|
gb_ht += gb_internal_bot
|
|
GroupBox gb_norm_theta, size={272,gb_ht}
|
|
|
|
gb_top += gb_ht + gb_space
|
|
GroupBox gb_norm_thetaphi,pos={4,gb_top}
|
|
gb_ht = gb_internal_top
|
|
CheckBox cb_norm_thetaphi_enable,pos={73, gb_top + gb_ht + cb_adj},size={50,14}
|
|
gb_ht += line_space
|
|
PopupMenu pm_norm_thetaphi_mode,pos={35, gb_top + gb_ht + pm_adj},size={138,21}
|
|
Button b_norm_thetaphi_check,pos={186, gb_top + gb_ht + b_adj},size={80,20}
|
|
gb_ht += line_space
|
|
SetVariable sv_norm_thetaphi_smoothing,pos={21, gb_top + gb_ht + sv_adj},size={112,16}
|
|
Button b_norm_thetaphi_preview,pos={186, gb_top + gb_ht + b_adj},size={80,20}
|
|
gb_ht += line_space
|
|
gb_ht += gb_internal_bot
|
|
GroupBox gb_norm_thetaphi, size={272,gb_ht}
|
|
|
|
gb_top += gb_ht + gb_space
|
|
GroupBox gb_output,pos={4,gb_top}
|
|
gb_ht = gb_internal_top
|
|
SetVariable sv_output_folding,pos={38, gb_top + gb_ht + sv_adj},size={95,16}
|
|
Button b_output_calc,pos={186, gb_top + gb_ht + b_adj},size={80,20}
|
|
gb_ht += line_space
|
|
SetVariable sv_output_horizon,pos={35, gb_top + gb_ht + sv_adj},size={98,16}
|
|
Button b_output_duplicate,pos={186, gb_top + gb_ht + b_adj},size={80,20}
|
|
gb_ht += line_space
|
|
PopupMenu pm_graph_projection,pos={24, gb_top + gb_ht + pm_adj},size={149,21}
|
|
Button b_output_itx,pos={186, gb_top + gb_ht + b_adj},size={80,20}
|
|
gb_ht += line_space
|
|
PopupMenu pm_graph_mode,pos={44, gb_top + gb_ht + pm_adj},size={129,21}
|
|
Button b_output_etpi,pos={186, gb_top + gb_ht + b_adj},size={80,20}
|
|
gb_ht += line_space
|
|
gb_ht += gb_internal_bot
|
|
GroupBox gb_output, size={272,gb_ht}
|
|
|
|
gb_top += gb_ht + gb_space
|
|
GroupBox gb_graph,pos={4,gb_top}
|
|
gb_ht = gb_internal_top
|
|
PopupMenu pm_graph_colortable,pos={21, gb_top + gb_ht + pm_adj},size={152,21}
|
|
Button b_graph_update,pos={186, gb_top + gb_ht + b_adj},size={80,20}
|
|
gb_ht += line_space
|
|
SetVariable sv_graph_contrast,pos={14, gb_top + gb_ht + sv_adj},size={119,16}
|
|
Button b_graph_png,pos={186, gb_top + gb_ht + b_adj},size={80,20}
|
|
gb_ht += line_space
|
|
gb_ht += gb_internal_bot
|
|
GroupBox gb_graph, size={272,gb_ht}
|
|
end
|
|
|
|
/// update the popup menus to reflect the values of the global variables
|
|
///
|
|
static function update_menus()
|
|
dfref df = $(package_path)
|
|
svar /sdfr=df panel_name
|
|
if (wintype(panel_name) == 7)
|
|
variable m
|
|
nvar /sdfr=df norm_alpha_mode
|
|
m = norm_alpha_mode + 1
|
|
PopupMenu pm_norm_alpha_mode win=$panel_name, mode=m
|
|
nvar /sdfr=df norm_theta_mode
|
|
m = norm_theta_mode + 1
|
|
PopupMenu pm_norm_theta_mode win=$panel_name, mode=m
|
|
nvar /sdfr=df norm_thetaphi_mode
|
|
m = norm_thetaphi_mode + 1
|
|
PopupMenu pm_norm_thetaphi_mode win=$panel_name, mode=m
|
|
nvar /sdfr=df graph_mode
|
|
m = graph_mode + 1
|
|
PopupMenu pm_graph_mode win=$panel_name, mode=m
|
|
nvar /sdfr=df graph_projection
|
|
m = graph_projection + 1
|
|
PopupMenu pm_graph_projection win=$panel_name, mode=m
|
|
svar /sdfr=df graph_colortable
|
|
m = 1 + WhichListItem(graph_colortable, CTabList())
|
|
PopupMenu pm_graph_colortable win=$panel_name, mode=m
|
|
endif
|
|
end
|
|
|
|
static function bp_source_select(ba) : ButtonControl
|
|
STRUCT WMButtonAction &ba
|
|
|
|
switch( ba.eventCode )
|
|
case 2: // mouse up
|
|
dfref dfBefore = GetDataFolderDFR()
|
|
Execute /q/z "CreateBrowser prompt=\"Select 2D holo scan wave\", showWaves=1, showVars=0, showStrs=0"
|
|
dfref dfAfter = GetDataFolderDFR()
|
|
SetDataFolder dfBefore
|
|
|
|
SVAR list = S_BrowserList
|
|
NVAR flag = V_Flag
|
|
if ((flag != 0) && (ItemsInList(list) >= 1))
|
|
string wname = StringFromList(0, list)
|
|
wave w = $wname
|
|
asp_import_raw(w)
|
|
endif
|
|
|
|
break
|
|
case -1: // control being killed
|
|
break
|
|
endswitch
|
|
|
|
return 0
|
|
End
|
|
|
|
static function bp_norm_alpha_check(ba) : ButtonControl
|
|
STRUCT WMButtonAction &ba
|
|
|
|
switch( ba.eventCode )
|
|
case 2: // mouse up
|
|
check_norm_alpha()
|
|
break
|
|
case -1: // control being killed
|
|
break
|
|
endswitch
|
|
|
|
return 0
|
|
End
|
|
|
|
static function bp_norm_theta_check(ba) : ButtonControl
|
|
STRUCT WMButtonAction &ba
|
|
|
|
switch( ba.eventCode )
|
|
case 2: // mouse up
|
|
check_norm_theta()
|
|
break
|
|
case -1: // control being killed
|
|
break
|
|
endswitch
|
|
|
|
return 0
|
|
End
|
|
|
|
static function bp_norm_phi_check(ba) : ButtonControl
|
|
STRUCT WMButtonAction &ba
|
|
|
|
switch( ba.eventCode )
|
|
case 2: // mouse up
|
|
check_norm_phi()
|
|
break
|
|
case -1: // control being killed
|
|
break
|
|
endswitch
|
|
|
|
return 0
|
|
End
|
|
|
|
static function bp_norm_thetaphi_check(ba) : ButtonControl
|
|
STRUCT WMButtonAction &ba
|
|
|
|
switch( ba.eventCode )
|
|
case 2: // mouse up
|
|
check_norm_thetaphi()
|
|
break
|
|
case -1: // control being killed
|
|
break
|
|
endswitch
|
|
|
|
return 0
|
|
End
|
|
|
|
static function bp_crop_alpha_preview(ba) : ButtonControl
|
|
STRUCT WMButtonAction &ba
|
|
|
|
switch( ba.eventCode )
|
|
case 2: // mouse up
|
|
preview_crop_alpha()
|
|
break
|
|
case -1: // control being killed
|
|
break
|
|
endswitch
|
|
|
|
return 0
|
|
End
|
|
|
|
static function bp_norm_alpha_preview(ba) : ButtonControl
|
|
STRUCT WMButtonAction &ba
|
|
|
|
switch( ba.eventCode )
|
|
case 2: // mouse up
|
|
preview_norm_alpha()
|
|
break
|
|
case -1: // control being killed
|
|
break
|
|
endswitch
|
|
|
|
return 0
|
|
End
|
|
|
|
static function bp_norm_phi_preview(ba) : ButtonControl
|
|
STRUCT WMButtonAction &ba
|
|
|
|
switch( ba.eventCode )
|
|
case 2: // mouse up
|
|
preview_norm_phi()
|
|
break
|
|
case -1: // control being killed
|
|
break
|
|
endswitch
|
|
|
|
return 0
|
|
End
|
|
|
|
static function bp_norm_theta_preview(ba) : ButtonControl
|
|
STRUCT WMButtonAction &ba
|
|
|
|
switch( ba.eventCode )
|
|
case 2: // mouse up
|
|
preview_norm_theta()
|
|
break
|
|
case -1: // control being killed
|
|
break
|
|
endswitch
|
|
|
|
return 0
|
|
End
|
|
|
|
static function bp_norm_thetaphi_preview(ba) : ButtonControl
|
|
STRUCT WMButtonAction &ba
|
|
|
|
switch( ba.eventCode )
|
|
case 2: // mouse up
|
|
preview_norm_thetaphi()
|
|
break
|
|
case -1: // control being killed
|
|
break
|
|
endswitch
|
|
|
|
return 0
|
|
End
|
|
|
|
static function bp_output_calc(ba) : ButtonControl
|
|
STRUCT WMButtonAction &ba
|
|
|
|
switch( ba.eventCode )
|
|
case 2: // mouse up
|
|
asp_calculate_output()
|
|
asp_display_output()
|
|
break
|
|
case -1: // control being killed
|
|
break
|
|
endswitch
|
|
|
|
return 0
|
|
End
|
|
|
|
static function bp_output_duplicate(ba) : ButtonControl
|
|
STRUCT WMButtonAction &ba
|
|
|
|
switch( ba.eventCode )
|
|
case 2: // mouse up
|
|
string dest_folder
|
|
prompt dest_folder, "destination folder name (relative to data source)"
|
|
doprompt "duplicate", dest_folder
|
|
if (!v_flag)
|
|
asp_duplicate_output(dest_folder)
|
|
endif
|
|
break
|
|
case -1: // control being killed
|
|
break
|
|
endswitch
|
|
|
|
return 0
|
|
End
|
|
|
|
static function bp_output_etpi(ba) : ButtonControl
|
|
STRUCT WMButtonAction &ba
|
|
|
|
switch( ba.eventCode )
|
|
case 2: // mouse up
|
|
dfref df = $(package_path)
|
|
wave /sdfr=df process_data
|
|
variable ekin
|
|
ekin = NumberByKey("KineticEnergy", note(process_data), "=", "\r")
|
|
prompt ekin, "kinetic energy"
|
|
doprompt "save etpi", ekin
|
|
if (!v_flag)
|
|
asp_save_output_etpi(ekin)
|
|
endif
|
|
break
|
|
case -1: // control being killed
|
|
break
|
|
endswitch
|
|
|
|
return 0
|
|
End
|
|
|
|
static function bp_output_itx(ba) : ButtonControl
|
|
STRUCT WMButtonAction &ba
|
|
|
|
switch( ba.eventCode )
|
|
case 2: // mouse up
|
|
asp_save_output_itx()
|
|
break
|
|
case -1: // control being killed
|
|
break
|
|
endswitch
|
|
|
|
return 0
|
|
End
|
|
|
|
static function bp_graph_update(ba) : ButtonControl
|
|
STRUCT WMButtonAction &ba
|
|
|
|
switch( ba.eventCode )
|
|
case 2: // mouse up
|
|
asp_update_graph()
|
|
break
|
|
case -1: // control being killed
|
|
break
|
|
endswitch
|
|
|
|
return 0
|
|
End
|
|
|
|
static function bp_graph_png(ba) : ButtonControl
|
|
STRUCT WMButtonAction &ba
|
|
|
|
switch( ba.eventCode )
|
|
case 2: // mouse up
|
|
dfref df = $(package_path)
|
|
svar /sdfr=df source_path
|
|
svar /sdfr=df output_graphname
|
|
if (WinType(output_graphname) == 1)
|
|
SavePICT /WIN=$output_graphname /E=-5 /B=144 /TRAN=0
|
|
endif
|
|
break
|
|
case -1: // control being killed
|
|
break
|
|
endswitch
|
|
|
|
return 0
|
|
End
|
|
|
|
static function pmp_norm_alpha_mode(pa) : PopupMenuControl
|
|
STRUCT WMPopupAction &pa
|
|
|
|
switch( pa.eventCode )
|
|
case 2: // mouse up
|
|
dfref df = $(package_path)
|
|
nvar /sdfr=df norm_alpha_mode
|
|
norm_alpha_mode = pa.popNum - 1
|
|
break
|
|
case -1: // control being killed
|
|
break
|
|
endswitch
|
|
|
|
return 0
|
|
End
|
|
|
|
static function pmp_norm_theta_mode(pa) : PopupMenuControl
|
|
STRUCT WMPopupAction &pa
|
|
|
|
switch( pa.eventCode )
|
|
case 2: // mouse up
|
|
dfref df = $(package_path)
|
|
nvar /sdfr=df norm_theta_mode
|
|
norm_theta_mode = pa.popNum - 1
|
|
break
|
|
case -1: // control being killed
|
|
break
|
|
endswitch
|
|
|
|
return 0
|
|
End
|
|
|
|
static function pmp_norm_thetaphi_mode(pa) : PopupMenuControl
|
|
STRUCT WMPopupAction &pa
|
|
|
|
switch( pa.eventCode )
|
|
case 2: // mouse up
|
|
dfref df = $(package_path)
|
|
nvar /sdfr=df norm_thetaphi_mode
|
|
norm_thetaphi_mode = pa.popNum - 1
|
|
break
|
|
case -1: // control being killed
|
|
break
|
|
endswitch
|
|
|
|
return 0
|
|
End
|
|
|
|
static function pmp_graph_mode(pa) : PopupMenuControl
|
|
STRUCT WMPopupAction &pa
|
|
|
|
switch( pa.eventCode )
|
|
case 2: // mouse up
|
|
dfref df = $(package_path)
|
|
nvar /sdfr=df graph_mode
|
|
graph_mode = pa.popNum - 1
|
|
break
|
|
case -1: // control being killed
|
|
break
|
|
endswitch
|
|
|
|
return 0
|
|
End
|
|
|
|
static function pmp_graph_projection(pa) : PopupMenuControl
|
|
STRUCT WMPopupAction &pa
|
|
|
|
switch( pa.eventCode )
|
|
case 2: // mouse up
|
|
dfref df = $(package_path)
|
|
nvar /sdfr=df graph_projection
|
|
graph_projection = pa.popNum - 1
|
|
break
|
|
case -1: // control being killed
|
|
break
|
|
endswitch
|
|
|
|
return 0
|
|
End
|
|
|
|
static function pmp_graph_colortable(pa) : PopupMenuControl
|
|
STRUCT WMPopupAction &pa
|
|
|
|
switch( pa.eventCode )
|
|
case 2: // mouse up
|
|
dfref df = $(package_path)
|
|
svar /sdfr=df graph_colortable
|
|
graph_colortable = StringFromList(pa.popNum - 1, CTabList())
|
|
asp_update_graph()
|
|
break
|
|
case -1: // control being killed
|
|
break
|
|
endswitch
|
|
|
|
return 0
|
|
End
|