Changeset 5029 for branches/uq/lang

Timestamp:

Feb 17, 2015, 5:49:36 PM (10 years ago)

Author:

mmh

Message:

puq integration snap

Location:

branches/uq/lang/tcl/scripts

Files:

• library.tcl (modified) (3 diffs)
• task.tcl (modified) (11 diffs)
• units.tcl (modified) (7 diffs)

branches/uq/lang/tcl/scripts/library.tcl

@@ -215 +215 @@
     public method remove {{path ""}}
     public method xml {{path ""}}
+    public method uq_make_template {}
 
     public method diff {libobj}
@@ -228 +229 @@
     private variable _root 0       ;# non-zero => this obj owns document
     private variable _document ""  ;# XML DOM tree
-    private variable _node ""      ;# node within 
+    private variable _node ""      ;# node within
 }
 
@@ -1038 +1039 @@
     return $rlist
 }
+
+
+# FIXME: get units convert. change varlist to have no units
+itcl::body Rappture::LibraryObj::uq_make_template {} {
+    set varlist ""
+    set n [$_node selectNodes /run/input//number]
+    foreach _n $n {
+        set x [$_n selectNodes current/text()]
+        set val [$x nodeValue]
+        if {[string equal -length 8 $val "uniform "] ||
+            [string equal -length 9 $val "gaussian "]} {
+            set unode [$_n selectNodes units/text()]
+            if {"" != $unode} {
+                set units [$unode nodeValue]
+                set val [Rappture::Units::mconvert $val \
+                -context $units -to $units -units off]
+            }
+            $x nodeValue @@[$_n getAttribute id]
+            lappend varlist [list [$_n getAttribute id] $val]
+        }
+    }
+    return $varlist
+}

branches/uq/lang/tcl/scripts/task.tcl

@@ -1 @@
-# -*- mode: tcl; indent-tabs-mode: nil -*- 
+# -*- mode: tcl; indent-tabs-mode: nil -*-
 # ----------------------------------------------------------------------
 #  COMPONENT: task - represents the executable part of a tool
@@ -57 +57 @@
     # default method for -jobstats control
     public proc MiddlewareTime {args}
+
+    public method get_params {varlist csvname uq_type args}
 }
 
@@ -75 +77 @@
 # ----------------------------------------------------------------------
 itcl::body Rappture::Task::constructor {xmlobj installdir args} {
+    puts "Task Init"
     if {![Rappture::library isvalid $xmlobj]} {
         error "bad value \"$xmlobj\": should be Rappture::Library"
@@ -138 +141 @@
 itcl::body Rappture::Task::run {args} {
     global env errorInfo
-
+    puts "task run $args"
     #
     # Make sure that we save the proper application name.
@@ -164 +167 @@
     foreach item {control output error} { set job($item) "" }
 
-    # write out the driver.xml file for the tool
-    set file "driver[pid].xml"
-    set status [catch {
-        set fid [open $file w]
-        puts $fid "<?xml version=\"1.0\"?>"
-        puts $fid [$_xmlobj xml]
-        close $fid
-    } result]
-
     # Set limits for cpu time
     set limit [$_xmlobj get tool.limits.cputime]
@@ -185 +179 @@
             set limit 10;               # lower bound is 10 seconds.
         }
-    } 
-    Rappture::rlimit set cputime $limit  
+    }
+    Rappture::rlimit set cputime $limit
+
+    # write out the driver.xml file for the tool
+    set file "driver[pid].xml"
+    set status [catch {
+        set fid [open $file w]
+        puts $fid "<?xml version=\"1.0\"?>"
+        puts $fid [$_xmlobj xml]
+        close $fid
+    } result]
+
+    # This will turn the driver xml into a template
+    # and return a list of the UQ variables and their PDFs.
+    set uq_varlist [$_xmlobj uq_make_template]
+
+    if {$uq_varlist != ""} {
+        # write out the template file for submit
+        set tfile "template[pid].xml"
+        set status [catch {
+            set fid [open $tfile w]
+            puts $fid "<?xml version=\"1.0\"?>"
+            puts $fid [$_xmlobj xml]
+            close $fid
+        } result]
+    }
+
+
     # execute the tool using the path from the tool description
     if {$status == 0} {
         set cmd [$_xmlobj get tool.command]
+        puts "1. cmd=$cmd"
         regsub -all @tool $cmd $_installdir cmd
-        regsub -all @driver $cmd $file cmd
-        regsub -all {\\} $cmd {\\\\} cmd
+
+        if {$uq_varlist == ""} {
+            regsub -all @driver $cmd $file cmd
+        } else {
+            regsub -all @driver $cmd $tfile cmd
+        }
         set cmd [string trimleft $cmd " "]
-        if { $cmd == "" } {
-            puts stderr "cmd is empty"
-            return [list 1 "Command is empty.\n\nThere is no command specified by\n\n <command>\n </command>\n\nin the tool.xml file."]
-        }
-
-        switch -glob -- [resources -jobprotocol] {
-            "submit*" {
-                # if job_protocol is "submit", then use use submit command
-                set cmd "submit --local $cmd"
-            }
-            "mx" {
-                # metachory submission
-                set cmd "mx $cmd"
-            }
-            "exec" {
-                # default -- nothing special
-            }
-        }
+        puts "2. cmd=$cmd"
+        if { $cmd == "" } {
+            puts stderr "cmd is empty"
+            return [list 1 "Command is empty.\n\nThere is no command specified by\n\n <command>\n </command>\n\nin the tool.xml file."]
+        }
+
+        if {$uq_varlist == ""} {
+            switch -glob -- [resources -jobprotocol] {
+                "submit*" {
+                    # if job_protocol is "submit", then use use submit command
+                    set cmd "submit --local $cmd"
+                }
+                "mx" {
+                    # metachory submission
+                    set cmd "mx $cmd"
+                }
+                "exec" {
+                    # default -- nothing special
+                }
+            }
+        } else {
+            puts "uq_varlist=$uq_varlist"
+            # FIXME. Default to Smolyak level 2, but allow more later.
+            file delete -force puq
+            set params_file [get_params $file $uq_varlist "smolyak" 2]
+            set cmd "submit --runName=puq -l -d $params_file python uq.py $cmd @:$tfile"
+        }
+
         $_xmlobj put tool.execute $cmd
 
-        # starting job...
-        _log run started
-        Rappture::rusage mark
-
-        if {0 == [string compare -nocase -length 5 $cmd "ECHO "] } {
-            set status 0;
-            set job(output) [string range $cmd 5 end] 
-        } else {
-            set status [catch {
-                set ::Rappture::Task::job(control) ""
-                eval blt::bgexec \
-                    ::Rappture::Task::job(control) \
-                    -keepnewline yes \
-                    -killsignal SIGTERM \
-                    -onoutput [list [itcl::code $this _output]] \
+    puts "cmd=$cmd"
+    # starting job...
+    _log run started
+    Rappture::rusage mark
+
+    if {0 == [string compare -nocase -length 5 $cmd "ECHO "] } {
+        set status 0;
+        set job(output) [string range $cmd 5 end]
+    } else {
+        set status [catch {
+            set ::Rappture::Task::job(control) ""
+            eval blt::bgexec \
+            ::Rappture::Task::job(control) \
+            -keepnewline yes \
+            -killsignal SIGTERM \
+            -onoutput [list [itcl::code $this _output]] \
                     -output ::Rappture::Task::job(output) \
                     -error ::Rappture::Task::job(error) \
                     $cmd
-            } result]
-
-            if { $status != 0 } {
-                # We're here because the exec-ed program failed 
-                set logmesg $result
-                if { $::Rappture::Task::job(control) ne "" } {
-                    foreach { token pid code mesg } \
-                        $::Rappture::Task::job(control) break
-                    if { $token == "EXITED" } {
-                        # This means that the program exited normally but
-                        # returned a non-zero exitcode.  Consider this an
-                        # invalid result from the program.  Append the stderr
-                        # from the program to the message.
-                        set logmesg "Program finished: exit code is $code"
-                        set result "$logmesg\n\n$::Rappture::Task::job(error)"
-                    } elseif { $token == "abort" }  {
-                        # The user pressed the abort button.
-                        set logmesg "Program terminated by user."
-                        set result "$logmesg\n\n$::Rappture::Task::job(output)"
-                    } else {
-                        # Abnormal termination
-                        set logmesg "Abnormal program termination: $mesg"
-                        set result "$logmesg\n\n$::Rappture::Task::job(output)"
-                    }
-                }
-                _log run failed [list $logmesg]
-                return [list $status $result]
-            }
-        }
-        # ...job is finished
-        array set times [Rappture::rusage measure]
-
-        if {[resources -jobprotocol] ne "submit"} {
-            set id [$_xmlobj get tool.id]
-            set vers [$_xmlobj get tool.version.application.revision]
-            set simulation simulation
-            if { $id ne "" && $vers ne "" } {
-                set pid [pid]
-                set simulation ${pid}_${id}_r${vers}
-            }
-
-            # need to save job info? then invoke the callback
-            if {[string length $jobstats] > 0} {
-                uplevel #0 $jobstats [list job [incr jobnum] \
-                    event $simulation start $times(start) \
-                    walltime $times(walltime) cputime $times(cputime) \
-                    status $status]
-            }
-
-            #
-            # Scan through stderr channel and look for statements that
-            # represent grid jobs that were executed.  The statements
-            # look like this:
-            #
-            # MiddlewareTime: job=1 event=simulation start=3.001094 ...
-            #
-            set subjobs 0
-            while {[regexp -indices {(^|\n)MiddlewareTime:( +[a-z]+=[^ \n]+)+(\n|$)} $job(error) match]} {
-                foreach {p0 p1} $match break
-                if {[string index $job(error) $p0] == "\n"} { incr p0 }
-
-                catch {unset data}
-                array set data {
-                    job 1
-                    event simulation
-                    start 0
-                    walltime 0
-                    cputime 0
-                    status 0
-                }
+        } result]
+
+        if { $status != 0 } {
+            # We're here because the exec-ed program failed
+            set logmesg $result
+            if { $::Rappture::Task::job(control) ne "" } {
+                foreach { token pid code mesg } \
+                $::Rappture::Task::job(control) break
+                if { $token == "EXITED" } {
+                   # This means that the program exited normally but
+                   # returned a non-zero exitcode.  Consider this an
+                   # invalid result from the program.  Append the stderr
+                   # from the program to the message.
+                   set logmesg "Program finished: exit code is $code"
+                   set result "$logmesg\n\n$::Rappture::Task::job(error)"
+                } elseif { $token == "abort" }  {
+                    # The user pressed the abort button.
+                    set logmesg "Program terminated by user."
+                    set result "$logmesg\n\n$::Rappture::Task::job(output)"
+                } else {
+                    # Abnormal termination
+                    set logmesg "Abnormal program termination: $mesg"
+                    set result "$logmesg\n\n$::Rappture::Task::job(output)"
+                }
+            }
+            _log run failed [list $logmesg]
+            return [list $status $result]
+        }
+    }
+    # ...job is finished
+    array set times [Rappture::rusage measure]
+
+    if {[resources -jobprotocol] ne "submit"} {
+        set id [$_xmlobj get tool.id]
+        set vers [$_xmlobj get tool.version.application.revision]
+        set simulation simulation
+        if { $id ne "" && $vers ne "" } {
+            set pid [pid]
+            set simulation ${pid}_${id}_r${vers}
+        }
+
+        # need to save job info? then invoke the callback
+        if {[string length $jobstats] > 0} {
+            uplevel #0 $jobstats [list job [incr jobnum] \
+            event $simulation start $times(start) \
+            walltime $times(walltime) cputime $times(cputime) \
+            status $status]
+        }
+
+        #
+        # Scan through stderr channel and look for statements that
+        # represent grid jobs that were executed.  The statements
+        # look like this:
+        #
+        # MiddlewareTime: job=1 event=simulation start=3.001094 ...
+        #
+        set subjobs 0
+        while {[regexp -indices {(^|\n)MiddlewareTime:( +[a-z]+=[^ \n]+)+(\n|$)} $job(error) match]} {
+            foreach {p0 p1} $match break
+            if {[string index $job(error) $p0] == "\n"} { incr p0 }
+
+            catch {unset data}
+            array set data {
+                job 1
+                event simulation
+                start 0
+                walltime 0
+                cputime 0
+                status 0
+            }
                 foreach arg [lrange [string range $job(error) $p0 $p1] 1 end] {
                     foreach {key val} [split $arg =] break
@@ -337 +373 @@
     }
     if {$status == 0} {
-        file delete -force -- $file
+        # file delete -force -- $file
     }
 
@@ -350 +386 @@
     # a reference to the run.xml file containing results.
     #
+
     if {$status == 0} {
         set result [string trim $job(output)]
+        puts "result=$result"
+        if {$uq_varlist != ""} {
+            file delete -force -- new.xml
+            exec puq_analyze.py puq_[pid].hdf5
+            append result "\n" "=RAPPTURE-RUN=>new.xml"
+        }
         if {[regexp {=RAPPTURE-RUN=>([^\n]+)} $result match file]} {
             set status [catch {Rappture::library $file} result]
+            puts "STATUS=$status"
             if {$status == 0} {
                 # add cputime info to run.xml file
@@ -381 +425 @@
             if {$status == 0 && $rdir ne ""} {
                 catch {
-                    file delete -force -- $file
+                    # file delete -force -- $file
                     if {![file exists $rdir]} {
                         _mkdir $rdir
@@ -393 +437 @@
             } else {
                 # don't keep the file
-                file delete -force -- $file
+                # file delete -force -- $file
             }
         } else {
@@ -518 +562 @@
     puts stderr $line
 }
+
+
+#
+# Send the list of parameters to a python program so it can call PUQ
+# and get a CSV file containing the parameter values to use for the runs.
+itcl::body Rappture::Task::get_params {dfile varlist uq_type args} {
+
+    # convert tcl list of variables to json so python can read it
+    proc varlist2py {inlist} {
+        set ovar "\["
+        set first 1
+        foreach a $inlist {
+            foreach {var val} $a break
+            if {$first == 1} {
+                append ovar \[\"$var\",
+                set first 0
+            } else {
+                append ovar \],\[\"$var\",
+            }
+            switch [lindex $val 0] {
+                gaussian {
+                    append ovar "\[\"gaussian\",[lindex $val 1],[lindex $val 2]\]"
+                }
+                uniform {
+                    append ovar "\[\"uniform\",[lindex $val 1],[lindex $val 2]\]"
+                }
+                default {
+                    append ovar $val
+                }
+            }
+        }
+        append ovar "\]\]"
+        return $ovar
+    }
+
+    puts "varlist=$varlist"
+    set varlist [varlist2py $varlist]
+    set pid [pid]
+    exec get_params.py $dfile $pid $varlist $uq_type $args
+    return params[pid].csv
+}

branches/uq/lang/tcl/scripts/units.tcl

@@ +1 @@
+# -*- mode: tcl; indent-tabs-mode: nil -*-
 # ----------------------------------------------------------------------
 #  COMPONENT: units - mechanism for converting numbers with units
@@ -60 +61 @@
 }
 
+
+# ----------------------------------------------------------------------
+# USAGE: mcheck_range value {min ""} {max ""}
+#
+# Checks a value or PDF to determine if is is in a required range.
+# Automatically does unit conversion if necessary.
+# Returns value if OK.  Error if out-of-range
+# Examples:
+#    [mcheck_range "gaussian 0C 1C" 200K 500K] returns 1
+#    [mcheck_range "uniform 100 200" 150 250] returns 0
+#    [mcheck_range 100 0 200] returns 1
+# ----------------------------------------------------------------------
+
+proc Rappture::Units::_check_range {value min max units} {
+    # make sure the value has units
+    if {$units != ""} {
+        set value [Rappture::Units::convert $value -context $units]
+        # for comparisons, remove units
+        set nv [Rappture::Units::convert $value -units off]
+        # get the units for the value
+        set newunits [Rappture::Units::Search::for $value]
+    } else {
+        set nv $value
+    }
+
+    if {"" != $min} {
+        if {"" != $units} {
+            # compute the minimum in the new units
+            set minv [Rappture::Units::convert $min -to $newunits -units off]
+            # same, but include units for printing
+            set convMinVal [Rappture::Units::convert $min -to $newunits]
+        } else {
+            set minv $min
+            set convMinVal $min
+        }
+        if {$nv < $minv} {
+            error "Minimum value allowed here is $convMinVal"
+        }
+    }
+    if {"" != $max} {
+        if {"" != $units} {
+            # compute the maximum in the new units
+            set maxv [Rappture::Units::convert $max -to $newunits -units off]
+            # same, but include units for printing
+            set convMaxVal [Rappture::Units::convert $max -to $newunits]
+        } else {
+            set maxv $max
+            set convMaxVal $max
+        }
+        if {$nv > $maxv} {
+            error "Maximum value allowed here is $convMaxVal"
+        }
+    }
+    return $value
+}
+
+proc Rappture::Units::mcheck_range {value {min ""} {max ""} {units ""}} {
+    puts "mcheck_range $value min=$min max=$max units=$units"
+
+    switch -- [lindex $value 0] {
+        normal -
+        gaussian {
+            # get the mean
+            set mean [_check_range [lindex $value 1] $min $max $units]
+            if {$units == ""} {
+                set dev [lindex $value 2]
+                set ndev $dev
+            } else {
+                set dev [Rappture::Units::convert [lindex $value 2] -context $units]
+                set ndev [Rappture::Units::convert $dev -units off]
+            }
+            if {$ndev <= 0} {
+                error "Deviation must be positive."
+            }
+            return [list gaussian $mean $dev]
+        }
+        uniform {
+            set min [_check_range [lindex $value 1] $min $max $units]
+            set max [_check_range [lindex $value 2] $min $max $units]
+            return [list uniform $min $max]
+        }
+        exact  {
+            return [_check_range [lindex $value 1] $min $max $units]
+        }
+        default {
+            return [_check_range [lindex $value 0] $min $max $units]
+        }
+    }
+}
+
+# ----------------------------------------------------------------------
+# USAGE: mconvert value ?-context units? ?-to units? ?-units on/off?
+#
+# This version of convert() converts multiple values.  Used when the
+# value could be a range or probability density function (PDF).
+# Examples:
+#    gaussian 100k 1k
+#    uniform 0eV 10eV
+#    42
+#    exact 42
+# ----------------------------------------------------------------------
+
+proc Rappture::Units::mconvert {value args} {
+    puts "mconvert $value : $args"
+    array set opts {
+        -context ""
+        -to ""
+        -units "on"
+    }
+
+    set value [split $value]
+
+    switch [lindex $value 0] {
+        normal -
+        gaussian {
+            set valtype gaussian
+            set vals [lrange $value 1 2]
+            set convtype {0 1}
+        }
+        uniform {
+            set valtype uniform
+            set vals [lrange $value 1 2]
+            set convtype {0 0}
+        }
+        exact  {
+            set valtype ""
+            set vals [lindex $value 1]
+            set convtype {0}
+        }
+        default {
+            set valtype ""
+            set vals $value
+            set convtype {0}
+        }
+    }
+
+    foreach {key val} $args {
+        if {![info exists opts($key)]} {
+            error "bad option \"$key\": should be [join [lsort [array names opts]] {, }]"
+        }
+        set opts($key) $val
+    }
+
+    set newval $valtype
+    foreach val $vals ctype $convtype {
+        if {$ctype == 1} {
+            # This code handles unit conversion for deltas (changes).
+            # For example, if we want a standard deviation of 10C converted
+            # to Kelvin, that is 10K, NOT a standard deviation of 283.15K.
+            set units [Rappture::Units::Search::for $val]
+            set base [eval Rappture::Units::convert 0$units $args -units off]
+            set new [eval Rappture::Units::convert $val $args -units off]
+            set delta [expr $new - $base]
+            set val $delta$opts(-to)
+        }
+        # tcl 8.5 allows us to do this:
+        # lappend newval [Rappture::Units::convert $val {*}$args]
+        # but we are using tcl8.4 so we use eval :^(
+        lappend newval [eval Rappture::Units::convert $val $args]
+    }
+    return $newval
+}
+
 # ----------------------------------------------------------------------
 # USAGE: convert value ?-context units? ?-to units? ?-units on/off?
@@ -69 +233 @@
 # current system.
 # ----------------------------------------------------------------------
-proc Rappture::Units::convert {value args} {
-    array set opts {
-        -context ""
-        -to ""
-        -units "on"
-    }
-    foreach {key val} $args {
-        if {![info exists opts($key)]} {
-            error "bad option \"$key\": should be [join [lsort [array names opts]] {, }]"
-        }
-        set opts($key) $val
-    }
-
-    #
-    # Parse the value into the number part and the units part.
-    #
-    set value [string trim $value]
-    if {![regexp {^([-+]?[0-9]+\.?([0-9]+)?([eEdD][-+]?[0-9]+)?) *(/?[a-zA-Z]+[0-9]*)?$} $value match number dummy1 dummy2 units]} {
-        set mesg "bad value \"$value\": should be real number with units"
-        if {$opts(-context) != ""} {
-            append mesg " of [Rappture::Units::description $opts(-context)]"
-        }
-        error $mesg
-    }
-    if {$units == ""} {
-        set units $opts(-context)
-    }
-
-    #
-    # Try to find the object representing the current system of units.
-    #
-    set units [Rappture::Units::System::regularize $units]
-    set oldsys [Rappture::Units::System::for $units]
-    if {$oldsys == ""} {
-        set mesg "value \"$value\" has unrecognized units"
-        if {$opts(-context) != ""} {
-            append mesg ".\nShould be units of [Rappture::Units::description $opts(-context)]"
-        }
-        error $mesg
-    }
-
-    #
-    # Convert the number to the new system of units.
-    #
-    if {$opts(-to) == ""} {
-        # no units -- return the number as is
-        return "$number$units"
-    }
-    return [$oldsys convert "$number$units" $opts(-to) $opts(-units)]
-}
+# proc Rappture::Units::convert {value args} {}
+# Actual implementation is in rappture/lang/tcl/src/RpUnitsTclInterface.cc.
+
 
 # ----------------------------------------------------------------------
@@ -127 +244 @@
 # along with a list of all compatible systems.
 # ----------------------------------------------------------------------
-proc Rappture::Units::description {units} {
-    set sys [Rappture::Units::System::for $units]
-    if {$sys == ""} {
-        return ""
-    }
-    set mesg [$sys cget -type]
-    set ulist [Rappture::Units::System::all $units]
-    if {"" != $ulist} {
-        append mesg " ([join $ulist {, }])"
-    }
-    return $mesg
-}
+# proc Rappture::Units::description {units} {}
+# Actual implementation is in rappture/lang/tcl/src/RpUnitsTclInterface.cc.
+
 
 # ----------------------------------------------------------------------
@@ -153 +261 @@
     private variable _system ""  ;# this system of units
 
-    public proc for {units}
-    public proc all {units}
+    # These are in rappture/lang/tcl/src/RpUnitsTclInterface.cc.
+    # public proc for {units}
+    # public proc all {units}
+
     public proc regularize {units}
 
@@ -360 +470 @@
 # if there is no system that matches the units string.
 # ----------------------------------------------------------------------
-itcl::body Rappture::Units::System::for {units} {
-    #
-    # See if the units are a recognized system.  If not, then try to
-    # extract any metric prefix and see if what's left is a recognized
-    # system.  If all else fails, see if we can find a system without
-    # the exact capitalization.  The user might say "25c" instead of
-    # "25C".  Try to allow that.
-    #
-    if {[info exists _base($units)]} {
-        return $_base($units)
-    } else {
-        set orig $units
-        if {[regexp {^(/?)[cCmMuUnNpPfFaAkKgGtT](.+)$} $units match slash tail]} {
-            set base "$slash$tail"
-            if {[info exists _base($base)]} {
-                set sys $_base($base)
-                if {[$sys cget -metric]} {
-                    return $sys
-                }
-            }
-
-            # check the base part for improper capitalization below...
-            set units $base
-        }
-
-        set matching ""
-        foreach u [array names _base] {
-            if {[string equal -nocase $u $units]} {
-                lappend matching $_base($u)
-            }
-        }
-        if {[llength $matching] == 1} {
-            set sys [lindex $matching 0]
-            #
-            # If we got rid of a metric prefix above, make sure
-            # that the system is metric.  If not, then we don't
-            # have a match.
-            #
-            if {[string equal $units $orig] || [$sys cget -metric]} {
-                return $sys
-            }
-        }
-    }
-    return ""
-}
+# itcl::body Rappture::Units::System::for {units} {}
+# Actual implementation is in rappture/lang/tcl/src/RpUnitsTclInterface.cc.
+
 
 # ----------------------------------------------------------------------
@@ -413 +481 @@
 # relationships that lead to the same base system.
 # ----------------------------------------------------------------------
-itcl::body Rappture::Units::System::all {units} {
-    set sys [Rappture::Units::System::for $units]
-    if {$sys == ""} {
-        return ""
-    }
-
-    if {"" != [$sys cget -basis]} {
-        set basis [lindex [$sys cget -basis] 0]
-    } else {
-        set basis $units
-    }
-
-    set ulist $basis
-    foreach u [array names _base] {
-        set obj $_base($u)
-        set b [lindex [$obj cget -basis] 0]
-        if {$b == $basis} {
-            lappend ulist $u
-        }
-    }
-    return $ulist
-}
+# itcl::body Rappture::Units::System::all {units} {}
+# Actual implementation is in rappture/lang/tcl/src/RpUnitsTclInterface.cc.
+
 
 # ----------------------------------------------------------------------