1375 lines
46 KiB
Tcl
1375 lines
46 KiB
Tcl
##
|
|
# @file nxscripts_common_1.tcl
|
|
# @brief Defines functions to create and save a nexus datafile based on the hdb tree metadata
|
|
#
|
|
|
|
MakeNXScript
|
|
sicsdatafactory new nxscript_data
|
|
#mkVar name type access long_name nxsave klass control data
|
|
::utility::mkVar estart Text user start_time true entry false true
|
|
::utility::mkVar eend Text user end_time true entry false true
|
|
::utility::mkVar timestamp int user time_stamp true entry false true
|
|
::utility::mkVar data_run_number int user run_number true instrument false true
|
|
::utility::mkVar autosaveIndex int user autosaveIndex true instrument false true
|
|
::utility::mkVar save_count int user save_count true experiment true true
|
|
::utility::mkVar currpoint int user currpoint true experiment true true
|
|
::utility::mkVar nexus_datatype text user DataType true data false true
|
|
::utility::mkVar file_status text user file_status true experiment true true
|
|
::utility::mkVar file_set_list Text user file_set true experiment true true
|
|
sicslist setatt data_run_number mutable true
|
|
sicslist setatt timestamp mutable true
|
|
sicslist setatt timestamp units seconds
|
|
sicslist setatt nexus_datatype mutable false
|
|
|
|
namespace eval nexus {
|
|
nexus_datatype force "UNKNOWN"
|
|
set exports [list newfile closefile save data newfile_collection save_collection]
|
|
proc estartSetVal {} { estart force [sicstime] }
|
|
proc eendSetVal {} { eend force [sicstime] }
|
|
set FirstSaveList [list estartSetVal eendSetVal]
|
|
set LastSaveList {list eendSetVal}
|
|
eval namespace export $exports
|
|
if 0 {datafilename}
|
|
|
|
variable filetypes
|
|
set filetypes [list BEAM_MONITOR HISTOPERIOD_XYT TOTAL_HISTOGRAM_XY TOTAL_HISTOGRAM_XT TOTAL_HISTOGRAM_YT TOTAL_HISTOGRAM_X TOTAL_HISTOGRAM_Y TOTAL_HISTOGRAM_T ]
|
|
|
|
##
|
|
# @brief This is the nexus dictionary generated by the gen_nxdict function
|
|
variable nxdictionary
|
|
##
|
|
# @brief Records the current Nexus file state.
|
|
variable state
|
|
##
|
|
# @brief Sets the default naming convention for the NXentry group.
|
|
variable NXentry_nm_convention
|
|
array set NXentry_nm_convention {
|
|
"echidna" "simple"
|
|
"wombat" "simple"
|
|
"kowari" "simple"
|
|
"quokka" "fname"
|
|
"platypus" "simple"
|
|
"lyrebird" "simple"
|
|
"pelican" "simple"
|
|
"taipan" "simple"
|
|
"kookaburra" "simple"
|
|
"dingo" "simple"
|
|
"bilby" "simple"
|
|
"emu" "simple"
|
|
}
|
|
}
|
|
namespace eval ::nexus::histmem {}
|
|
namespace eval ::nexus::motor {}
|
|
namespace eval ::nexus::environment_controller {}
|
|
namespace eval ::nexus::sicsvariable {}
|
|
namespace eval ::nexus::singlecounter {}
|
|
namespace eval ::nexus::script {}
|
|
namespace eval ::histogram_memory {
|
|
variable histmem_axes
|
|
array set histmem_axes {
|
|
TOF /instrument/detector/time_of_flight
|
|
HOR /instrument/detector/x_pixel_offset
|
|
VER /instrument/detector/y_pixel_offset
|
|
PER /instrument/run_number
|
|
SVAR /instrument/run_number
|
|
}
|
|
}
|
|
|
|
|
|
##
|
|
# @brief Strips the output of a SICS command leaving only the value\n
|
|
# TODO Replace $cmd_output with [$cmd_output] so we can just pass the command name
|
|
#
|
|
# @param cmd_output The output from a command substitution
|
|
# @return The unadorned value returned by the SICS command which produced cmd_output
|
|
proc getVal {cmd_output} {
|
|
return [string trim [lindex [split $cmd_output =] 1 ] ]
|
|
}
|
|
|
|
##
|
|
# @brief Registers a list of procs/commands to call on the first save to a data file
|
|
proc ::nexus::OnFirstSave {args} {
|
|
lappend ::nexus::FirstSaveList $args
|
|
}
|
|
|
|
##
|
|
# @brief Registers a list of procs/commands to call on the last save to a data file
|
|
proc ::nexus::OnLastSave {args} {
|
|
lappend ::nexus::LastSaveList $args
|
|
}
|
|
|
|
##
|
|
# @brief Executes the list of procs registered with OnFirstSave
|
|
proc ::nexus::CallSSProcs {} {
|
|
foreach cmd $::nexus::FirstSaveList {
|
|
eval $cmd
|
|
}
|
|
}
|
|
|
|
##
|
|
# @brief Executes the list of procs registered with OnLastSave
|
|
proc ::nexus::CallESProcs {} {
|
|
foreach cmd $::nexus::LastSaveList {
|
|
eval $cmd
|
|
}
|
|
}
|
|
proc ::nexus::datapath {} {
|
|
return [SplitReply [sicsdatapath]]
|
|
}
|
|
##
|
|
# @brief Generate a filename from sicsdatanumber and sicsdatapath
|
|
#
|
|
# @param postfix This is the filename suffix, must be one of: nx.hdf, hdf, h5, nx5, xml
|
|
proc newFileName {idNum postfix} {
|
|
if [ catch {
|
|
array set inst_mnem {quokka QKK wombat WBT echidna ECH kowari KWR koala KOL taipan TPN platypus PLP pelican PLN lyrebird LBD kookaburra KKB dingo DNG bilby BBY emu EMU}
|
|
# set prefix [SplitReply [sicsdataprefix]]
|
|
set date_time_arr [split [sicstime] " "]
|
|
set isodate [lindex $date_time_arr 0]
|
|
set isotime [string map {: -} [lindex $date_time_arr 1]]
|
|
set fmtStr [format "%s/%s%07d.%s" [::nexus::datapath] $inst_mnem([instname]) $idNum $postfix]
|
|
} message ] {
|
|
return -code error "([info level 0]) $message"
|
|
}
|
|
return $fmtStr
|
|
}
|
|
|
|
##
|
|
# @brief Make a link in the nexus file
|
|
# With two arguments the target name = the link name
|
|
# With three arguments you can give the target a new name.
|
|
# two args: arg0 = target, arg1 = link
|
|
# three args: arg0 = target, arg1 = new name, arg2 = link
|
|
proc ::nexus::link {args} {
|
|
set nargs [llength $args]
|
|
switch $nargs {
|
|
2 { nxscript makelink [lindex $args 0] [lindex $args 1] }
|
|
3 { nxscript makenamedlink [lindex $args 0] [lindex $args 2] [lindex $args 1] }
|
|
}
|
|
}
|
|
proc ::nexus::process_filetype_policy {filetype} {
|
|
if [ catch {
|
|
if {$filetype == "BEAM_MONITOR"} {
|
|
::hdb::set_save / true
|
|
::hdb::set_save $::histogram_memory::HP_HMM false
|
|
set ::counter::HP_BM [getatt monitor_counts hdb_path]
|
|
if [sicslist exists monitor_counts linkname] {
|
|
hsetprop $::counter::HP_BM link data_set [getatt monitor_counts linkname]
|
|
} else {
|
|
hsetprop $::counter::HP_BM link data_set
|
|
}
|
|
hsetprop $::counter::HP_BM @signal 1
|
|
set nvars [SplitReply [bmonscan noscanvar]]
|
|
if {$nvars == 0} {
|
|
set axes "run_number"
|
|
} else {
|
|
for { set i 0 } { $i < $nvars } { incr i } {
|
|
set axis_name [lindex [split [lindex [split [bmonscan getvarpar $i]] 0] "."] 1]
|
|
set node_name [SplitReply [sicslist $axis_name hdb_path]]
|
|
if [sicslist exists $axis_name linkname] {
|
|
hsetprop $node_name link data_set [getatt $axis_name linkname]
|
|
} else {
|
|
hsetprop $node_name link data_set
|
|
}
|
|
lappend axes_list $axis_name
|
|
}
|
|
set axes [join $axes_list ":"]
|
|
}
|
|
hsetprop $::counter::HP_BM @axes $axes
|
|
} else {
|
|
::hdb::set_save / true
|
|
hsetprop $::histogram_memory::HP_HMM datatype_savelist $filetype
|
|
hsetprop $::histogram_memory::HP_HMM link data_set
|
|
::histogram_memory::set_axes $filetype
|
|
}
|
|
foreach sobj [sicslist link data_set] {
|
|
if [sicslist exists $sobj linkname] {
|
|
hsetprop [getatt $sobj hdb_path] link data_set [getatt $sobj linkname]
|
|
} else {
|
|
hsetprop [getatt $sobj hdb_path] link data_set
|
|
}
|
|
}
|
|
foreach sobj [sicslist link parameters_group] {
|
|
if [sicslist exists $sobj linkname] {
|
|
hsetprop [getatt $sobj hdb_path] link parameters_group [getatt $sobj linkname]
|
|
} else {
|
|
hsetprop [getatt $sobj hdb_path] link parameters_group
|
|
}
|
|
}
|
|
} message ] {
|
|
return -code error "([info level 0]) $message"
|
|
}
|
|
}
|
|
|
|
|
|
##
|
|
# @brief Initialise state variables
|
|
proc ::nexus::init {} {
|
|
variable state
|
|
variable nexusdic
|
|
variable currFilename
|
|
variable isNewFile
|
|
variable save_count_arr
|
|
variable start_seconds_array
|
|
variable file_states
|
|
|
|
array set state {
|
|
file,open "false"
|
|
file,namestyle "data"
|
|
file,format "hdf"
|
|
file,fileset "false"
|
|
file,incr_datnum "false"
|
|
file,labels @singlefile
|
|
}
|
|
|
|
set nexusdic "nexus.dic"
|
|
array set currFilename ""
|
|
array set isNewFile ""
|
|
array set save_count_arr ""
|
|
array set start_seconds_array ""
|
|
array set file_states {U "UNKNOWN" O "OPEN" C "CLOSED" S "SAVING"}
|
|
save_count force 0
|
|
currpoint force 0
|
|
file_status force UNKNOWN
|
|
}
|
|
|
|
proc ::nexus::ic_initialize {} {
|
|
}
|
|
|
|
proc getBaseName {fileName} {
|
|
set baseName [lindex [split [file tail $fileName] "."] 0]
|
|
return $baseName
|
|
}
|
|
##
|
|
# @brief Create a nexus file
|
|
# This first generates a nexus dictionary file from the hdb tree and then creates a new
|
|
# nexus file based on that dictionary.
|
|
proc ::nexus::createfile {FileName} {
|
|
variable nexusdic
|
|
variable state
|
|
|
|
if [ catch {
|
|
if {$state(file,open) == "true"} {
|
|
error "Can't create a new file because the current file is still open"
|
|
}
|
|
switch $state(file,format) {
|
|
"hdf" {set create_type create5}
|
|
"xml" {set create_type createxml}
|
|
default {
|
|
error "ERROR: Invalid file format $state(file,format)"
|
|
}
|
|
}
|
|
|
|
set nxdict_path [::nexus::gen_nxdict $nexusdic]
|
|
if {$state(file,incr_datnum) == true} {
|
|
sicsdatanumber incr
|
|
}
|
|
if [catch {nxscript $create_type $FileName $nxdict_path} message] {
|
|
error $message
|
|
}
|
|
set state(file,open) false
|
|
} message ] {
|
|
return -code error "([info level 0]) $message"
|
|
}
|
|
}
|
|
|
|
##
|
|
# @brief Checks if the given file type is defined.
|
|
#
|
|
# @return 1 on success, 0 on failure
|
|
proc ::nexus::isValidFileType {type} {
|
|
variable filetypes
|
|
if {[lsearch $filetypes $type] == -1} {
|
|
return 0
|
|
} else {
|
|
return 1
|
|
}
|
|
}
|
|
##
|
|
# @brief Setup file state info for writing a new file.
|
|
#
|
|
# @type data file type as defined in config/nexus/datafiletype.tcl or clear
|
|
# @param namestyle scratch or data, default=data\n
|
|
# If namestyle=data, the save command will create numbered files using the ANSTO
|
|
# file naming convention.\n
|
|
# If namestyle=scratch, the save command will create scratch files.
|
|
#
|
|
# postconditions:
|
|
# state(file,open) true
|
|
# /data/currentfiletype == UNKNOWN
|
|
proc ::nexus::newfile {type {namestyle data}} {
|
|
::nexus::newfile_collection -filetype $type -savetype $namestyle
|
|
}
|
|
|
|
##
|
|
# @brief Returns a list of paths matching the given property
|
|
#
|
|
# @param hpath, subtree path to search
|
|
# @param prop, name of property, can be 'abc*' but not 'a*c'
|
|
proc ::nexus::findHdbProps {hpath prop} {
|
|
if [ catch {
|
|
set hpList ""
|
|
foreach hp [hlist $hpath] {
|
|
if {$hpath == "/"} {
|
|
set subList [::nexus::findHdbProps /$hp $prop]
|
|
} else {
|
|
set subList [::nexus::findHdbProps $hpath/$hp $prop]
|
|
}
|
|
if {[llength $subList] > 0} {
|
|
lappend hpList [join $subList]
|
|
}
|
|
}
|
|
if {[string length [hfindprop $hpath $prop]] > 0 } {
|
|
lappend hpList $hpath
|
|
}
|
|
} message ] {
|
|
return -code error "([info level 0]) $message"
|
|
}
|
|
return [join $hpList]
|
|
}
|
|
|
|
##
|
|
# @brief Let's make a collection of files (ie a file-set) or just one.
|
|
#
|
|
# @param -labels L or {L1 L2 ..}, optional. A list of labels which identify a file-set
|
|
# If you don't specify a list of labels then only one file is created
|
|
proc ::nexus::newfile_collection {args} {
|
|
variable state
|
|
variable currFilename
|
|
variable isNewFile
|
|
variable save_count_arr
|
|
variable file_states
|
|
|
|
set valid_options [list "-labels" "-filetype" "-savetype"]
|
|
set required_options [list "-filetype" "-savetype"]
|
|
if [ catch {
|
|
::utility::check_valid_options $args $valid_options
|
|
::utility::check_required_options $args $required_options
|
|
array set param $args
|
|
set file_suffix [SplitReply [SicsDataPostFix]]
|
|
switch $file_suffix {
|
|
hdf - nx.hdf - h5 - nx5 {set state(file,format) hdf}
|
|
xml {set state(file,format) xml}
|
|
default { error "ERROR: Invalid file suffix $file_suffix" }
|
|
}
|
|
set state(file,namestyle) $param(-savetype)
|
|
array unset save_count_arr
|
|
array unset currFilename
|
|
array unset isNewFile
|
|
if {$param(-savetype) == "scratch"} {
|
|
set state(file,incr_datnum) false
|
|
} else {
|
|
set state(file,incr_datnum) true
|
|
}
|
|
set idNum [expr 1 + [SplitReply [sicsdatanumber]]]
|
|
if [info exists param(-labels)] {
|
|
set state(file,fileset) "true"
|
|
set state(file,labels) $param(-labels)
|
|
if {$param(-savetype) == "scratch"} {
|
|
foreach fid $state(file,labels) {
|
|
set save_count_arr($fid) 0
|
|
set isNewFile($fid) "true"
|
|
set currFilename($fid) [format "%s/scratch_%s.%s" [::nexus::datapath] $fid $file_suffix]
|
|
lappend files $currFilename($fid)
|
|
}
|
|
} else {
|
|
foreach fid $state(file,labels) {
|
|
set save_count_arr($fid) 0
|
|
set isNewFile($fid) "true"
|
|
set currFilename($fid) [newFileName $idNum $file_suffix]
|
|
incr idNum
|
|
lappend files $currFilename($fid)
|
|
}
|
|
}
|
|
file_set_list force [join $files ,]
|
|
} else {
|
|
set state(file,fileset) "false"
|
|
set state(file,labels) @singlefile
|
|
set save_count_arr(@singlefile) 0
|
|
set isNewFile(@singlefile) "true"
|
|
if {$param(-savetype) == "scratch"} {
|
|
set currFilename(@singlefile) [format "%s/scratch.%s" [::nexus::datapath] $file_suffix]
|
|
} else {
|
|
set currFilename(@singlefile) [newFileName $idNum $file_suffix]
|
|
}
|
|
}
|
|
save_count force 0
|
|
currpoint force 0
|
|
autosaveIndex force 0
|
|
file_status force $file_states(U)
|
|
if {$param(-filetype) == "clear"} {
|
|
::hdb::set_save / false
|
|
nexus_datatype force "UNKNOWN"
|
|
file_set_list force "UNKNOWN"
|
|
foreach l [array names isNewFile] {
|
|
set isNewFile($l) "false"
|
|
}
|
|
# dataFileName "UNKNOWN"
|
|
} else {
|
|
foreach hp [split [::nexus::findHdbProps / link]] {
|
|
hdelprop $hp link
|
|
}
|
|
foreach hp [::nexus::findHdbProps / @*] {
|
|
foreach {pname pval} [hfindprop $hp @*] {
|
|
hdelprop $hp $pname
|
|
}
|
|
}
|
|
::nexus::process_filetype_policy $param(-filetype)
|
|
nexus_datatype force $param(-filetype)
|
|
file_status force "NEWFILE"
|
|
}
|
|
} message ] {
|
|
return -code error "([info level 0]) $message"
|
|
} else {
|
|
return OK
|
|
}
|
|
}
|
|
|
|
##
|
|
# @brief Save data to the currently open file and then close it.
|
|
#
|
|
# @param point This is the array index for mutable data elements
|
|
#
|
|
# This function provides the top level call to the recursive ::nexus::savetree
|
|
# function, it should only be called by the ::nexus::save command.
|
|
#
|
|
# @see ::nexus::savetree
|
|
# @see ::nexus::save
|
|
proc ::nexus::save_data {point filestatus} {
|
|
set valid_caller "::nexus::save_collection"
|
|
|
|
debug_msg "save point $point in [dataFileName]"
|
|
if [ catch {
|
|
set caught_exception false
|
|
if {[info level]<2} {
|
|
error "ERROR: The [lindex [info level 0] 0] command is for internal use only"
|
|
}
|
|
set caller [namespace origin [lindex [info level -1] 0]]
|
|
if {$caller != $valid_caller} {
|
|
error "ERROR: [lindex [info level 0] 0] can only be called via the $valid_caller command, not by $caller"
|
|
}
|
|
} message ] {
|
|
set caught_exception true
|
|
}
|
|
foreach child [hlist /] {
|
|
if [ catch {
|
|
if {[hpropexists /$child data] && [hgetpropval /$child data] == "true"} {
|
|
::nexus::savetree $child $point $filestatus
|
|
}
|
|
} message ] {
|
|
lappend msglst $message
|
|
set caught_exception true
|
|
}
|
|
}
|
|
if {$caught_exception} {
|
|
return -code error "([info level 0]) $msglst"
|
|
}
|
|
}
|
|
|
|
##
|
|
# @brief save data collected by last data acquisition command.
|
|
#
|
|
# @param point experimental point number, this is the array index for mutable
|
|
# datasets in the nexus file. Optional, default = 0
|
|
#
|
|
# A new file will be created if the new file state has been set to true, or
|
|
# if the current data type doesn't match the current file type.
|
|
proc ::nexus::save {{point 0} {callType "normalsave"}} {
|
|
if [ catch {
|
|
::nexus::save_collection -index $point
|
|
} message ] {
|
|
return -code error "([info level 0]) $message"
|
|
}
|
|
if {$callType == "normalsave"} {
|
|
autosaveIndex force [expr [SplitReply [data_run_number]] + 1]
|
|
}
|
|
}
|
|
|
|
##
|
|
# @brief Save data in a file from a file-set
|
|
proc ::nexus::save_collection {args} {
|
|
variable state
|
|
variable start_seconds
|
|
variable start_seconds_array
|
|
variable currFilename
|
|
variable isNewFile
|
|
variable save_count_arr
|
|
variable file_states
|
|
|
|
set valid_options [list "-index" "-label"]
|
|
set required_options [list "-index"]
|
|
if [ catch {
|
|
set caught_exception false
|
|
::utility::check_valid_options $args $valid_options
|
|
::utility::check_required_options $args $required_options
|
|
array set param $args
|
|
set point $param(-index)
|
|
if {[string is integer $point] == 0} {
|
|
error_msg "save index must be an integer"
|
|
} elseif {$point < 0} {
|
|
error_msg "save index cannot be negative"
|
|
}
|
|
|
|
# ::data::gumtree_save -set run_number $point
|
|
data_run_number force $point
|
|
|
|
if [info exists param(-label)] {
|
|
if {[lsearch -exact $state(file,labels) $param(-label)] == -1} {
|
|
error "ERROR: The label must be one of $state(file,labels)"
|
|
}
|
|
set data_label $param(-label)
|
|
} else {
|
|
if {$state(file,fileset) == "true"} {
|
|
error "ERROR: You must set -label when saving to a file-set"
|
|
}
|
|
set data_label @singlefile
|
|
}
|
|
if {$isNewFile($data_label)} {
|
|
set isNewFile($data_label) "false"
|
|
::nexus::createfile $currFilename($data_label)
|
|
dataFileName force $currFilename($data_label)
|
|
|
|
::nexus::CallSSProcs
|
|
array unset start_seconds_array
|
|
set start_seconds [clock seconds]
|
|
# set start_seconds_array($data_label) $start_seconds
|
|
timestamp force 0
|
|
file_status force $file_states(O)
|
|
::nexus::nxreopenfile $currFilename($data_label)
|
|
file_status force $file_states(S)
|
|
set baseName [getBaseName $currFilename($data_label)]
|
|
set entryName [gen_NXentry_name $baseName]
|
|
nxscript updatedictvar pa_entryName $entryName
|
|
::nexus::save_data $point newfile
|
|
} else {
|
|
|
|
::nexus::CallESProcs
|
|
# timestamp force [expr {[clock seconds] - $start_seconds_array($data_label)}]
|
|
timestamp force [expr {[clock seconds] - $start_seconds}]
|
|
dataFileName force $currFilename($data_label)
|
|
file_status force $file_states(O)
|
|
::nexus::nxreopenfile $currFilename($data_label)
|
|
file_status force $file_states(S)
|
|
set baseName [getBaseName $currFilename($data_label)]
|
|
set entryName [gen_NXentry_name $baseName]
|
|
nxscript updatedictvar pa_entryName $entryName
|
|
::nexus::save_data $point oldfile
|
|
}
|
|
} message ] {
|
|
nxscript puttext data_save_error "([info level 0]) $message"
|
|
set caught_exception true
|
|
}
|
|
if {[info exists data_label] && [info exists currFilename($data_label)]} {
|
|
::nexus::nxclosefile $currFilename($data_label)
|
|
file_status force $file_states(C)
|
|
incr save_count_arr($data_label)
|
|
save_count force $save_count_arr($data_label)
|
|
currpoint force $point
|
|
} else {
|
|
set message "$message !! FAILED ASSERTION: data_lable and/or currFilename undefined !!"
|
|
}
|
|
if {$caught_exception} {
|
|
return -code error "([info level 0]) $message"
|
|
} else {
|
|
return
|
|
}
|
|
}
|
|
|
|
##
|
|
# @brief Reopen the current file, close it with nxclosefile
|
|
# this should only be called by the ::nexus::save command.
|
|
#
|
|
# @see nxclosefile
|
|
# @see ::nexus::save
|
|
proc ::nexus::nxreopenfile {filename} {
|
|
global cfPath
|
|
variable state
|
|
variable nexusdic
|
|
set valid_caller "::nexus::save_collection"
|
|
|
|
if [ catch {
|
|
if {[info level]<2} {
|
|
error "ERROR: The [lindex [info level 0] 0] command is for internal use only"
|
|
}
|
|
set caller [namespace origin [lindex [info level -1] 0]]
|
|
if {$caller != $valid_caller} {
|
|
error "ERROR: [lindex [info level 0] 0] can only be called via the $valid_caller command, not by $caller"
|
|
}
|
|
if {$state(file,open) == "false"} {
|
|
nxscript reopen $filename $cfPath(nexus)/$nexusdic
|
|
set state(file,open) true
|
|
}
|
|
} message ] {
|
|
return -code error "([info level 0]) $message"
|
|
}
|
|
}
|
|
|
|
##
|
|
# @brief Close the current file. You can reopen it with nxreopenfile
|
|
# this should only be called by the ::nexus::save command.
|
|
#
|
|
# @see nxreopenfile
|
|
# @see ::nexus::save
|
|
proc ::nexus::nxclosefile {filename} {
|
|
variable state
|
|
set valid_caller "::nexus::save_collection"
|
|
|
|
if [ catch {
|
|
if {[info level]<2} {
|
|
error "ERROR: The [lindex [info level 0] 0] command is for internal use only"
|
|
}
|
|
set caller [namespace origin [lindex [info level -1] 0]]
|
|
if {$caller != $valid_caller} {
|
|
error "ERROR: [lindex [info level 0] 0] can only be called via the $valid_caller command, not by $caller"
|
|
}
|
|
if {$state(file,open) == "true"} {
|
|
nxscript close
|
|
set state(file,open) false
|
|
set flist [split $filename "/"]
|
|
set fname [lindex $flist [expr [llength $flist] - 1] ]
|
|
clientput "$fname updated" "event"
|
|
}
|
|
} message ] {
|
|
return -code error "([info level 0]) $message"
|
|
}
|
|
}
|
|
|
|
##
|
|
# @brief Traverse the hdb subtree from the given path and save the data in the currently open file
|
|
#
|
|
# @param hpath path of subtree to save, must not be "/"
|
|
# @param pt Current array index for mutable data (optional default=0)
|
|
proc ::nexus::savetree {hpath pt filestatus} {
|
|
set caught_exception false
|
|
|
|
foreach child [hlist /$hpath] {
|
|
if [ catch {
|
|
array unset p_arr
|
|
array set p_arr [hlistprop /$hpath/$child tcllist]
|
|
if {([info exists p_arr(type)] == 0) || ($p_arr(type) != "nxvgroup")} {
|
|
set data_type [lindex [split [hinfo /$hpath/$child] , ] 0]
|
|
if {[info exists p_arr(data)] && ($p_arr(data) == true) && ($p_arr(nxsave) == true) } {
|
|
if {[info exists p_arr(nxalias)]} {
|
|
if {[info exists p_arr(savecmd)]} {
|
|
if {[info exists p_arr(mutable)] && ($p_arr(mutable) == "true") } {
|
|
$p_arr(savecmd) $p_arr(sicsdev) $p_arr(nxalias) /$hpath/$child $data_type $filestatus point $pt
|
|
} else {
|
|
$p_arr(savecmd) $p_arr(sicsdev) $p_arr(nxalias) /$hpath/$child $data_type $filestatus
|
|
}
|
|
} else {
|
|
if {[info exists p_arr(mutable)] && ($p_arr(mutable) == "true") } {
|
|
nxscript puthdb /$hpath/$child point $pt
|
|
} else {
|
|
nxscript puthdb /$hpath/$child
|
|
}
|
|
if {$filestatus == "newfile"} {
|
|
if {[info exists p_arr(link)] && ($p_arr(link) != "@none")} {
|
|
::nexus::link {*}$p_arr(link) $p_arr(nxalias)
|
|
}
|
|
if {[info exists p_arr(permlink)] && ($p_arr(permlink) != "@none")} {
|
|
::nexus::link {*}$p_arr(permlink) $p_arr(nxalias)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
::nexus::savetree $hpath/$child $pt $filestatus
|
|
}
|
|
}
|
|
} message ] {
|
|
lappend msglst $message
|
|
set caught_exception true
|
|
}
|
|
}
|
|
if {$caught_exception} {
|
|
return -code error "([info level 0]) $msglst"
|
|
}
|
|
}
|
|
|
|
##
|
|
# @brief Recursive portion of gen_nxdict function
|
|
#
|
|
# @param hpath hdb subtree path to generate dictionary fragment from, must not be "/"
|
|
# @param dictPath parent path for nexus dictionary fragment.
|
|
# @param name name for child dictionary path
|
|
# @param nxc Nexus class name
|
|
#
|
|
# If the klass name doesn't begin with NX then construct the SDS name by replacing '/' with '_' in the
|
|
# hdb path
|
|
#
|
|
# @see gen_nxdict
|
|
proc ::nexus::_gen_nxdict {hpath dictPath name nxc} {
|
|
variable nxdictionary
|
|
if [ catch {
|
|
if {[hpropexists /$hpath data] && [hgetpropval /$hpath data] == true} {
|
|
foreach child [hlist /$hpath] {
|
|
if {[hpropexists /$hpath/$child data] && [hgetpropval /$hpath/$child data] == true} {
|
|
set nxclass [hgetpropval /$hpath/$child klass]
|
|
if {$nxc == "NXentry"} {
|
|
::nexus::_gen_nxdict $hpath/$child $dictPath $child $nxclass
|
|
} else {
|
|
::nexus::_gen_nxdict $hpath/$child $dictPath/$name,$nxc $child $nxclass
|
|
}
|
|
}
|
|
}
|
|
array set p_arr [hlistprop /$hpath tcllist]
|
|
set data_type [lindex [split [hinfo /$hpath] , ] 0]
|
|
if {$data_type != "none" || $p_arr(type) == "nxvgroup"} {
|
|
#XXX Do we need to check data_type here. This would skip NXVGROUP nodes
|
|
if {$p_arr(data) == "true" && $p_arr(nxsave) == "true" && [info exists p_arr(nxalias)]} {
|
|
set alias $p_arr(nxalias)
|
|
if {[info exists p_arr(sdsinfo)]} {
|
|
if {[info exists p_arr(sdsname)]} {
|
|
set sdsName $p_arr(sdsname)
|
|
} else {
|
|
set sdsName $name
|
|
}
|
|
if {[info exists p_arr(mutable)] && $p_arr(mutable) == "true"} {
|
|
set isMutable "true"
|
|
} else {
|
|
set isMutable "false"
|
|
}
|
|
if {[info exists p_arr(savecmd)]} {
|
|
set SDSstr "[$p_arr(sdsinfo) $sdsName $data_type $p_arr(sicsdev) mutable $isMutable hpath /$hpath]"
|
|
} else {
|
|
set SDSstr "[$p_arr(sdsinfo) $sdsName $data_type mutable $isMutable hpath /$hpath]"
|
|
}
|
|
set nxdictionary($alias) "$dictPath/SDS $SDSstr"
|
|
} elseif {[info exists p_arr(type)] && $p_arr(type) == "nxvgroup"} {
|
|
set nxdictionary($alias) "$dictPath/NXVGROUP"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} message ] {
|
|
return -code error "([info level 0]) $message"
|
|
}
|
|
}
|
|
|
|
##
|
|
# @brief Generate the NXentry name
|
|
#
|
|
# @param baseName, this is the data file basename it is used as the entry name
|
|
# when the 'fname' naming convention is selected.
|
|
proc ::nexus::gen_NXentry_name {baseName} {
|
|
variable NXentry_nm_convention
|
|
|
|
set nm_conv $NXentry_nm_convention([instname])
|
|
switch $nm_conv {
|
|
"simple" {
|
|
return "entry1"
|
|
}
|
|
"fname" {
|
|
return "${baseName}"
|
|
}
|
|
default {
|
|
return -code error "ERROR: Unknown NXentry naming convention $nm_conv"
|
|
}
|
|
}
|
|
}
|
|
##
|
|
# @brief Generate a nexus dictionary file from the hdb tree
|
|
#
|
|
# An entry in the nexus dictionary is generated for each node in the
|
|
# hdb tree which has the following properties and values, data=true and nxsave=true
|
|
#
|
|
# @param baseName The base name of the file without suffix
|
|
# @param nexusdic Name of the nexus dictionary that will be created.
|
|
# @return Full path to the nexus dictionary.
|
|
proc ::nexus::gen_nxdict {nexusdic} {
|
|
global cfPath
|
|
variable nxdictionary
|
|
set catch_status [catch {
|
|
set nxdict_path $cfPath(nexus)/$nexusdic
|
|
array unset nxdictionary
|
|
foreach hp [hlist /] {
|
|
if {[hpropexists /$hp data] } {
|
|
if {[hgetpropval /$hp data] == true} {
|
|
if {[hpropexists /$hp klass] } {
|
|
set nxclass [hgetpropval /$hp klass]
|
|
} else {
|
|
error "/$hp does not have a 'klass' attribute"
|
|
}
|
|
::nexus::_gen_nxdict $hp /\$(pa_entryName),NXentry $hp $nxclass
|
|
}
|
|
} else {
|
|
error "/$hp does not have a 'data' attribute"
|
|
}
|
|
}
|
|
set fh [open $nxdict_path w]
|
|
puts $fh "##NXDICT-1.0"
|
|
puts $fh pa_entryName=entry1
|
|
puts $fh pa_hmmdimstr=-1,0
|
|
puts $fh pa_hmmrank=1
|
|
puts $fh pa_hmmdatname=hmm
|
|
puts $fh "data_save_error = /\$(pa_entryName),NXentry/SDS data_save_error -type NX_CHAR"
|
|
|
|
foreach {n v} [array get nxdictionary] {
|
|
puts $fh "$n = $v"
|
|
}
|
|
close $fh
|
|
} message ]
|
|
handle_exception $catch_status $message
|
|
return $nxdict_path
|
|
}
|
|
|
|
##
|
|
# @brief Set SICS object attributes which are required for creating nexus data files.
|
|
proc ::nexus::set_sobj_attributes {} {
|
|
if [ catch {
|
|
# SICS commands
|
|
sicslist setatt nxscript privilege internal
|
|
# SICS data objects
|
|
sicslist setatt nxscript_data privilege internal
|
|
|
|
foreach sobj [lrange [sicslist type motor] 1 end] {
|
|
sicslist setatt $sobj savecmd ::nexus::motor::save
|
|
sicslist setatt $sobj sdsinfo ::nexus::motor::sdsinfo
|
|
}
|
|
foreach sobj [sicslist type configurablevirtualmotor] {
|
|
sicslist setatt $sobj savecmd ::nexus::motor::save
|
|
sicslist setatt $sobj sdsinfo ::nexus::motor::sdsinfo
|
|
}
|
|
foreach sobj [sicslist type TasMot] {
|
|
sicslist setatt $sobj savecmd ::nexus::motor::save
|
|
sicslist setatt $sobj sdsinfo ::nexus::motor::sdsinfo
|
|
}
|
|
foreach sobj [sicslist type histmem] {
|
|
sicslist setatt $sobj savecmd ::nexus::histmem::save
|
|
sicslist setatt $sobj sdsinfo ::nexus::histmem::sdsinfo
|
|
}
|
|
foreach sobj [sicslist type sicsvariable] {
|
|
sicslist setatt $sobj savecmd ::nexus::sicsvariable::save
|
|
sicslist setatt $sobj sdsinfo ::nexus::sicsvariable::sdsinfo
|
|
}
|
|
foreach sobj [sicslist type singlecounter] {
|
|
sicslist setatt $sobj savecmd ::nexus::singlecounter::save
|
|
sicslist setatt $sobj sdsinfo ::nexus::singlecounter::sdsinfo
|
|
}
|
|
foreach sobj [sicslist type environment_controller] {
|
|
sicslist setatt $sobj savecmd ::nexus::environment_controller::save
|
|
sicslist setatt $sobj sdsinfo ::nexus::environment_controller::sdsinfo
|
|
}
|
|
foreach sobj [sicslist type chopperadapter] {
|
|
sicslist setatt $sobj savecmd ::nexus::chopperadapter::save
|
|
sicslist setatt $sobj sdsinfo ::nexus::chopperadapter::sdsinfo
|
|
}
|
|
foreach sobj [sicslist kind script] {
|
|
sicslist setatt $sobj savecmd ::nexus::script::save
|
|
sicslist setatt $sobj sdsinfo ::nexus::script::sdsinfo
|
|
}
|
|
foreach sobj [sicslist kind getset] {
|
|
sicslist setatt $sobj savecmd ::nexus::macro::getset_save
|
|
sicslist setatt $sobj sdsinfo ::nexus::macro::getset_sdsinfo
|
|
}
|
|
} message ] {
|
|
return -code error "([info level 0]) $message"
|
|
}
|
|
}
|
|
|
|
##
|
|
# @brief Convert the given hdb type to Nexus data type
|
|
#
|
|
# @param dtype hdb data type
|
|
# @return Nexus data type
|
|
proc ::nexus::hdb2nx_type {dtype} {
|
|
switch $dtype {
|
|
int {return NX_INT32}
|
|
intar {return NX_INT32}
|
|
intvarar {return NX_INT32}
|
|
float {return NX_FLOAT32}
|
|
floatar {return NX_FLOAT32}
|
|
floatvarar {return NX_FLOAT32}
|
|
text {return NX_CHAR}
|
|
default {error "ERROR: [info level -1]->hdb2nx_type, Unknown type $dtype"}
|
|
}
|
|
}
|
|
|
|
##
|
|
# @brief Save command for histogram memory data.
|
|
#
|
|
# The savecmd attribute of any histogram memory objects should be set to this function
|
|
#
|
|
# @see set_sobj_attributes
|
|
proc ::nexus::histmem::save {hm nxalias hpath data_type filestatus args} {
|
|
variable HMOBJ
|
|
|
|
if [catch {
|
|
set point [lindex $args 1]
|
|
array set pa [hlistprop $hpath tcllist]
|
|
foreach sdsname $pa(hmmdatname) rank $pa(hmmrank) dimstr $pa(hmmdimstr) hmmslabstart $pa(hmmslabstart) hmmslabend $pa(hmmslabend) hmmperiodsize $pa(hmmperiodsize) axes $pa(@axes) signal $pa(@signal) {
|
|
nxscript updatedictvar pa_hmmdatname $sdsname
|
|
if {$pa(mutable)} {
|
|
nxscript updatedictvar pa_hmmrank [expr {$rank+1}]
|
|
nxscript updatedictvar pa_hmmdimstr "-1,$dimstr"
|
|
} else {
|
|
nxscript updatedictvar pa_hmmrank [expr {$rank+1}]
|
|
nxscript updatedictvar pa_hmmdimstr "1,$dimstr"
|
|
}
|
|
set max_period [SplitReply [$HMOBJ configure maximum_period]]
|
|
set datsize $hmmperiodsize
|
|
if {$pa(save_periods) == "all_periods"} {
|
|
$HMOBJ configure read_data_period_number -1
|
|
set datsize [expr $hmmperiodsize * (1 + $max_period)]
|
|
} elseif { $max_period > 0} {
|
|
$HMOBJ configure read_data_period_number $point
|
|
}
|
|
::histogram_memory::hmm_set_read_type [hgetpropval $::histogram_memory::HP_HMM datatype_savelist]
|
|
nxscript putslab $nxalias [join [list $point $hmmslabstart ]] [join [list 1 $hmmslabend]] $HMOBJ 0 $datsize 1
|
|
#####
|
|
if {$filestatus == "newfile"} {
|
|
if [hpropexists $hpath link] {
|
|
set link [hgetpropval $hpath link]
|
|
::nexus::link {*}$link $nxalias
|
|
}
|
|
nxscript putattribute $nxalias axes $axes
|
|
nxscript putattribute $nxalias signal $signal
|
|
}
|
|
}
|
|
} message ] {
|
|
return -code error "([info level 0]) $message"
|
|
}
|
|
}
|
|
|
|
proc ::nexus::histmem::sdsinfo {sdsName data_type hm args} {
|
|
return "\$(pa_hmmdatname) -type NX_INT32 -LZW -rank \$(pa_hmmrank) -dim {\$(pa_hmmdimstr)}"
|
|
}
|
|
|
|
# The save commands are called with the sobj name and nxalias
|
|
# The sdsinfo commands provide the SDS description for an nxdic
|
|
|
|
proc ::nexus::motor::save {motor nxalias hpath data_type filestatus args} {
|
|
if [ catch {
|
|
if {[lindex $args 0] == "point"} {
|
|
set index [lindex $args 1]
|
|
nxscript_data clear
|
|
nxscript_data putfloat 0 [getVal [$motor] ]
|
|
nxscript putslab $nxalias [list $index] [list 1] nxscript_data
|
|
} else {
|
|
if {[getatt $motor type] == "motor"} {
|
|
nxscript putmot $nxalias $motor
|
|
} else {
|
|
nxscript putfloat $nxalias [SplitReply [$motor]]
|
|
}
|
|
}
|
|
if {$filestatus == "newfile"} {
|
|
if [hpropexists $hpath link] {
|
|
set link [hgetpropval $hpath link]
|
|
::nexus::link {*}$link $nxalias
|
|
}
|
|
foreach {propName propValue} [hfindprop $hpath @*] {
|
|
set attName [string range $propName 1 end]
|
|
nxscript putattribute $nxalias $attName $propValue
|
|
}
|
|
}
|
|
} message ] {
|
|
return -code error "([info level 0]) $message"
|
|
}
|
|
}
|
|
proc ::nexus::motor::sdsinfo {sdsName data_type motor args} {
|
|
if [ catch {
|
|
array set param $args
|
|
array set attribute [::utility::normalattlist $motor]
|
|
if {[info exists attribute(units)]} {
|
|
set units_att " -attr {units,$attribute(units)} "
|
|
} else {
|
|
set units_att " "
|
|
}
|
|
set dtype [::nexus::hdb2nx_type $data_type]
|
|
set name_att " -attr {long_name,$attribute(long_name)} "
|
|
if {$param(mutable) == true} {
|
|
set sdsStr "$sdsName -type $dtype -rank 1 -dim {-1} $units_att $name_att"
|
|
} else {
|
|
set sdsStr "$sdsName -type $dtype $units_att $name_att"
|
|
}
|
|
} message ] {
|
|
return -code error "([info level 0]) $message"
|
|
}
|
|
return $sdsStr
|
|
}
|
|
##
|
|
# @brief Save data from a 'getset macro'
|
|
#
|
|
# NOTE: Currently just saves floats
|
|
namespace eval ::nexus::macro {}
|
|
proc ::nexus::macro::getset_save {sobj nxalias hpath data_type filestatus args} {
|
|
if [ catch {
|
|
if {[lindex $args 0] == "point"} {
|
|
set index [lindex $args 1]
|
|
nxscript_data clear
|
|
set val [getVal [$sobj] ]
|
|
switch $data_type {
|
|
int {nxscript_data putint 0 $val}
|
|
float {nxscript_data putfloat 0 $val}
|
|
text {error "ERROR: [info level 0] Saving an array of text values is not implemented"}
|
|
default {error "ERROR: [info level 0] unknown type $data_type when saving $sobj"}
|
|
}
|
|
nxscript putslab $nxalias [list $index] [list 1] nxscript_data
|
|
} else {
|
|
switch $data_type {
|
|
int {nxscript putint $nxalias [SplitReply [$sobj]]}
|
|
float {nxscript putfloat $nxalias [SplitReply [$sobj]]}
|
|
text {nxscript puttext $nxalias [SplitReply [$sobj]]}
|
|
default {error "ERROR: [info level 0] Unknown data type $data_type when saving $sobj"}
|
|
}
|
|
}
|
|
if {$filestatus == "newfile"} {
|
|
if [hpropexists $hpath link] {
|
|
set link [hgetpropval $hpath link]
|
|
::nexus::link {*}$link $nxalias
|
|
}
|
|
foreach {propName propValue} [hfindprop $hpath @*] {
|
|
set attName [string range $propName 1 end]
|
|
nxscript putattribute $nxalias $attName $propValue
|
|
}
|
|
}
|
|
} message ] {
|
|
return -code error "([info level 0]) $message"
|
|
}
|
|
}
|
|
|
|
##
|
|
# @brief Define the scientific data set path for the nexus dictionary.
|
|
proc ::nexus::macro::getset_sdsinfo {sdsName data_type sobj args} {
|
|
if [ catch {
|
|
array set param $args
|
|
array set attribute [::utility::normalattlist $sobj]
|
|
set dtype [::nexus::hdb2nx_type $data_type]
|
|
if {[info exists attribute(units)]} {
|
|
set units_att " -attr {units,$attribute(units)} "
|
|
} else {
|
|
set units_att " "
|
|
}
|
|
set name_att " -attr {long_name,$attribute(long_name)} "
|
|
if {$param(mutable) == true} {
|
|
set sdsStr "$sdsName -type $dtype -rank 1 -dim {-1} $units_att $name_att"
|
|
} else {
|
|
set sdsStr "$sdsName -type $dtype $units_att $name_att"
|
|
}
|
|
} message ] {
|
|
return -code error "([info level 0]) $message"
|
|
}
|
|
return $sdsStr
|
|
}
|
|
####
|
|
proc ::nexus::environment_controller::save {evc nxalias hpath data_type filestatus args} {
|
|
if [ catch {
|
|
if {[lindex $args 0] == "point"} {
|
|
set index [lindex $args 1]
|
|
nxscript_data clear
|
|
nxscript_data putfloat 0 [getVal [$evc] ]
|
|
nxscript putslab $nxalias [list $index] [list 1] nxscript_data
|
|
} else {
|
|
nxscript putfloat $nxalias [SplitReply [$evc]]
|
|
}
|
|
if {$filestatus == "newfile"} {
|
|
if [hpropexists $hpath link] {
|
|
set link [hgetpropval $hpath link]
|
|
::nexus::link {*}$link $nxalias
|
|
}
|
|
foreach {propName propValue} [hfindprop $hpath @*] {
|
|
set attName [string range $propName 1 end]
|
|
nxscript putattribute $nxalias $attName $propValue
|
|
}
|
|
}
|
|
} message ] {
|
|
return -code error "([info level 0]) $message"
|
|
}
|
|
}
|
|
proc ::nexus::environment_controller::sdsinfo {sdsName data_type evc args} {
|
|
if [ catch {
|
|
array set param $args
|
|
array set attribute [::utility::normalattlist $evc]
|
|
set dtype [::nexus::hdb2nx_type $data_type]
|
|
if {[info exists attribute(units)]} {
|
|
set units_att " -attr {units,$attribute(units)} "
|
|
} else {
|
|
set units_att " "
|
|
}
|
|
set name_att " -attr {long_name,$attribute(long_name)} "
|
|
if {$param(mutable) == true} {
|
|
set sdsStr "$sdsName -type $dtype -rank 1 -dim {-1} $units_att $name_att"
|
|
} else {
|
|
set sdsStr "$sdsName -type $dtype $units_att $name_att"
|
|
}
|
|
} message ] {
|
|
return -code error "([info level 0]) $message"
|
|
}
|
|
return $sdsStr
|
|
}
|
|
|
|
namespace eval ::nexus {
|
|
}
|
|
|
|
proc ::nexus::sicsvariable::save {svar nxalias hpath data_type filestatus args} {
|
|
if [ catch {
|
|
set val [SplitReply [$svar]]
|
|
if {[lindex $args 0] == "point"} {
|
|
set index [lindex $args 1]
|
|
nxscript_data clear
|
|
switch $data_type {
|
|
int {nxscript_data putint 0 $val}
|
|
float {nxscript_data putfloat 0 $val}
|
|
default {error "ERROR: [info level -1]->::nexus::sicsvariable::save, unknown type $data_type"}
|
|
}
|
|
nxscript putslab $nxalias [list $index] [list 1] nxscript_data
|
|
} else {
|
|
switch $data_type {
|
|
int {nxscript putint $nxalias $val}
|
|
float {nxscript putfloat $nxalias $val}
|
|
text {nxscript puttext $nxalias $val}
|
|
default {error "ERROR: [info level -1]->::nexus::sicsvariable::save, unknown type $data_type"}
|
|
}
|
|
}
|
|
if {$filestatus == "newfile"} {
|
|
if [hpropexists $hpath link] {
|
|
set link [hgetpropval $hpath link]
|
|
::nexus::link {*}$link $nxalias
|
|
}
|
|
foreach {propName propValue} [hfindprop $hpath @*] {
|
|
set attName [string range $propName 1 end]
|
|
nxscript putattribute $nxalias $attName $propValue
|
|
}
|
|
}
|
|
} message ] {
|
|
return -code error "::nexus::sicsvariable::save, $message"
|
|
}
|
|
}
|
|
|
|
proc ::nexus::sicsvariable::sdsinfo {sdsName data_type sobj args} {
|
|
if [ catch {
|
|
array set param $args
|
|
set dtype [::nexus::hdb2nx_type $data_type]
|
|
array set attribute [::utility::normalattlist $sobj]
|
|
if {[info exists attribute(units)]} {
|
|
set units_att " -attr {units,$attribute(units)} "
|
|
} else {
|
|
set units_att " "
|
|
}
|
|
if {$param(mutable) == true} {
|
|
set sdsStr "$sdsName -type $dtype -rank 1 -dim {-1} $units_att"
|
|
} else {
|
|
set sdsStr "$sdsName -type $dtype $units_att"
|
|
}
|
|
} message ] {
|
|
return -code error "([info level 0]) $message"
|
|
}
|
|
return $sdsStr
|
|
}
|
|
|
|
namespace eval ::nexus::scobj {}
|
|
proc ::nexus::scobj::sdsinfo {sdsName data_type args} {
|
|
if [ catch {
|
|
array set param $args
|
|
set dtype [::nexus::hdb2nx_type $data_type]
|
|
if [hpropexists $param(hpath) "units"] {
|
|
set unitsval [hgetpropval $param(hpath) units]
|
|
set units_att " -attr {units,$unitsval} "
|
|
} else {
|
|
set units_att " "
|
|
}
|
|
switch $data_type {
|
|
text {
|
|
set dimdef [subst {-dim {[string length [hval $param(hpath)]]}}]
|
|
set sdsStr "$sdsName -type $dtype $dimdef"
|
|
}
|
|
default {
|
|
if {$param(mutable) == true} {
|
|
set sdsStr "$sdsName -type $dtype -rank 1 -dim {-1} $units_att"
|
|
} else {
|
|
set sdsStr "$sdsName -type $dtype $units_att"
|
|
}
|
|
}
|
|
}
|
|
} message ] {
|
|
return -code error "([info level 0]) $message"
|
|
}
|
|
return $sdsStr
|
|
}
|
|
|
|
namespace eval ::nexus::chopperadapter { }
|
|
proc ::nexus::chopperadapter::save {sobj nxalias hpath data_type filestatus args} {
|
|
if [ catch {
|
|
array set attribute [attlist $sobj]
|
|
set val [SplitReply [$sobj]]
|
|
if {[lindex $args 0] == "point"} {
|
|
set index [lindex $args 1]
|
|
nxscript_data clear
|
|
switch $data_type {
|
|
int {nxscript_data putint 0 $val}
|
|
float {nxscript_data putfloat 0 $val}
|
|
default {error "ERROR: [info level -1]->::nexus::chopperadapter::save, unknown type $data_type"}
|
|
}
|
|
nxscript putslab $nxalias [list $index] [list 1] nxscript_data
|
|
} else {
|
|
switch $data_type {
|
|
int {nxscript putint $nxalias $val}
|
|
float {nxscript putfloat $nxalias $val}
|
|
text {nxscript puttext $nxalias $val}
|
|
default {error "ERROR: [info level -1]->::nexus::chopperadapter::save, unknown type $data_type"}
|
|
}
|
|
}
|
|
if {$filestatus == "newfile"} {
|
|
if [hpropexists $hpath link] {
|
|
set link [hgetpropval $hpath link]
|
|
::nexus::link {*}$link $nxalias
|
|
}
|
|
foreach {propName propValue} [hfindprop $hpath @*] {
|
|
set attName [string range $propName 1 end]
|
|
nxscript putattribute $nxalias $attName $propValue
|
|
}
|
|
}
|
|
} message ] {
|
|
return -code error "([info level 0]) $message"
|
|
}
|
|
}
|
|
|
|
proc ::nexus::chopperadapter::sdsinfo {sdsName data_type sobj args} {
|
|
if [ catch {
|
|
array set param $args
|
|
set dtype [::nexus::hdb2nx_type $data_type]
|
|
array set attribute [::utility::normalattlist $sobj]
|
|
if {[info exists attribute(units)]} {
|
|
set units_att " -attr {units,$attribute(units)} "
|
|
} else {
|
|
set units_att " "
|
|
}
|
|
if {$param(mutable) == true} {
|
|
set sdsStr "$sdsName -type $dtype -rank 1 -dim {-1} $units_att"
|
|
} else {
|
|
set sdsStr "$sdsName -type $dtype $units_att"
|
|
}
|
|
} message ] {
|
|
return -code error "([info level 0]) $message"
|
|
}
|
|
return $sdsStr
|
|
}
|
|
proc ::nexus::singlecounter::save {counter nxalias hpath data_type filestatus args} {
|
|
todo_msg "Save counter: $counter"
|
|
}
|
|
proc ::nexus::singlecounter::sdsinfo {sdsName data_type counter args} {
|
|
todo_msg "Get sdsinfo for counter: $counter"
|
|
}
|
|
|
|
##
|
|
# @brief Save command for hdb nodes associated with a tcl macro
|
|
#
|
|
# The macro must return the name of a 1D associative array when called with -get_data_ref.
|
|
proc ::nexus::script::save {script nxalias hpath data_type filestatus args} {
|
|
if [ catch {
|
|
array set attribute [attlist $script]
|
|
if {$attribute(klass) == "sensor"} {
|
|
if {[lindex $args 0] == "point"} {
|
|
set index [lindex $args 1]
|
|
nxscript_data clear
|
|
nxscript_data putfloat 0 [$script]
|
|
nxscript putslab $nxalias [list $index] [list 1] nxscript_data
|
|
} else {
|
|
nxscript putfloat $nxalias [$script]
|
|
}
|
|
} else {
|
|
set darray [$script -get_data_ref]
|
|
set size [SplitReply [$darray used]]
|
|
if {[lindex $args 0] == "point"} {
|
|
set index [lindex $args 1]
|
|
nxscript putslab $nxalias [list $index 0] [list 1 $size] $darray
|
|
} else {
|
|
nxscript putslab $nxalias [list 0] [list $size] $darray
|
|
}
|
|
}
|
|
if {$filestatus == "newfile"} {
|
|
if [hpropexists $hpath link] {
|
|
set link [hgetpropval $hpath link]
|
|
::nexus::link {*}$link $nxalias
|
|
}
|
|
foreach {propName propValue} [hfindprop $hpath @*] {
|
|
set attName [string range $propName 1 end]
|
|
nxscript putattribute $nxalias $attName $propValue
|
|
}
|
|
}
|
|
} message ] {
|
|
return -code error "([info level 0]) $message"
|
|
}
|
|
}
|
|
|
|
proc ::nexus::script::sdsinfo {sdsName data_type sobj args} {
|
|
if [ catch {
|
|
array set param $args
|
|
set dtype [::nexus::hdb2nx_type $data_type]
|
|
array set attribute [::utility::normalattlist $sobj]
|
|
if {[info exists attribute(units)]} {
|
|
set units_att " -attr {units,$attribute(units)} "
|
|
} else {
|
|
set units_att " "
|
|
}
|
|
if {[getatt $sobj klass] == "sensor"} {
|
|
if {$param(mutable) == true} {
|
|
set sdsStr "$sdsName -type $dtype -rank 1 -dim {-1} $units_att"
|
|
} else {
|
|
set sdsStr "$sdsName -type $dtype $units_att"
|
|
}
|
|
} else {
|
|
set darray [$sobj -get_data_ref]
|
|
set size [SplitReply [$darray used]]
|
|
if {$param(mutable) == true} {
|
|
set sdsStr "$sdsName -type $dtype $units_att -rank 2 -dim {-1,$size}"
|
|
} else {
|
|
set sdsStr "$sdsName -type $dtype $units_att -rank 1 -dim {$size}"
|
|
}
|
|
}
|
|
} message ] {
|
|
#TODO CHECK ERROR: failed to open alias ::histogram_memory::y_bin etc.
|
|
return -code error "([info level 0]) $message"
|
|
}
|
|
return $sdsStr
|
|
}
|
|
namespace import ::nexus::*
|
|
foreach expt $::nexus::exports {
|
|
publish $expt user
|
|
sicslist setatt $expt privilege internal
|
|
}
|
|
|
|
# TODO Return filename from nxcreatefile and call nxreopen nxclose etc
|
|
|
|
# dictalias is a global hash which records the alias which the value of
|
|
# a sics object (eg motors) is written to. The has is indexed by the
|
|
# objects name. It is useful for making links to datasets.
|
|
# dim0 = vertical axis on detector
|
|
# dim1 = horizontal axis on detector
|
|
::utility::mkVar site_name Text manager site_name true entry true true
|
|
site_name [SplitReply [SICS_Site]]
|
|
site_name lock
|
|
::utility::mkVar program_branch Text manager program_branch true entry true true
|
|
program_branch [SplitReply [SICS_Version]]
|
|
program_branch lock
|
|
::utility::mkVar program_revision Text manager program_revision true entry true true
|
|
program_revision [SplitReply [SICS_Revision]]
|
|
program_revision lock
|
|
::utility::mkVar instrument_name Text manager name true instrument true true
|
|
instrument_name [SplitReply [Instrument]]
|
|
instrument_name lock
|
|
|
|
set tmpstr [string map {"$" ""} {$Revision: 1.51.2.14 $}]
|
|
set nx_content_revision_num [lindex $tmpstr [expr [llength $tmpstr] - 1]]
|
|
|
|
#namespace eval data {
|
|
# ##
|
|
# # @brief Nexus data save command for gumtree control interface
|
|
# #
|
|
# # @param run_number This is the run or scan point number, it serves as the array
|
|
# # index for nexus data sets which correspond to mutable data
|
|
# command gumtree_save {int: run_number} {
|
|
# ::nexus::save $run_number
|
|
# }
|
|
# sicslist setatt ::data::gumtree_save long_name save
|
|
# array set param [::data::gumtree_save -list param]
|
|
# ::utility::mkData $param(run_number) run_number instrument privilege READ_ONLY mutable true control false
|
|
# command gumtree_type {text:nx.hdf,xml type} {
|
|
# SicsDataPostFix $type
|
|
# }
|
|
# sicslist set ::data::gumtree_type long_name file_format
|
|
# ::data::gumtree_type -set type [SplitReply [SicsDataPostFix]]
|
|
#}
|
|
|
|
::nexus::init
|
|
publish ::nexus::data user
|