#!/bin/sh
# \
exec oagwish "$0" "$@"

# $Log: not supported by cvs2svn $
# Revision 1.17  2009/06/10 20:44:44  soliday
# Updated the limits for LTP and PTB dipole magnets.
#
# Revision 1.16  2007/11/01 20:21:59  soliday
# Made changes in injector studies.
#
# Revision 1.15  2007/10/24 19:01:02  soliday
# Improved the interface.
#
# Revision 1.14  2007/09/20 09:03:12  soliday
# Changed SR Zone R label to SR Entire Ring and changed it so that it
# is not selected by default.
#
# Revision 1.13  2007/09/20 08:51:36  soliday
# Reordered the power supply listings.
#
# Revision 1.12  2007/09/20 08:16:10  soliday
# Added test for L1:RG1:HTR and L1:RG2:HTR
#
# Revision 1.11  2007/09/19 22:04:13  soliday
# Updated with a lot of changes recommended by Thomas Fors
#
# Revision 1.10  2003/09/03 16:54:55  soliday
# Fixed issues with BLT.
#
# Revision 1.9  2002/06/10 17:25:56  soliday
# Added some changes requested by Phil
#
# Revision 1.8  2001/12/03 19:59:54  soliday
# Made changes to Skipline and Undulator tests.
#
# Revision 1.7  2001/10/23 15:08:16  soliday
# Again improved the setpoint selection.
#
# Revision 1.6  2001/10/22 22:19:51  soliday
# Improved the setpoint selections.
#
# Revision 1.5  2001/10/19 16:32:13  soliday
# Made some bug fixes.
#
# Revision 1.4  2001/09/17 21:16:39  soliday
# Improved the plotting.
#
# Revision 1.3  2001/09/17 15:55:03  soliday
# Changes from last shutdown.
#
# Revision 1.2  2001/07/23 20:39:10  soliday
# Updated durring shutdown period.
#
# Revision 1.1  2000/10/23 18:37:27  soliday
# First commited version.
#
#
# Input directory /home/helios/oagData/PSSCPDB/setpts/sr
# Input file /home/helios/oagData/PSGROUP/AnalogCheck.sdds
# Output directory /home/helios/oagData/PSGROUP/data

set auto_path [linsert $auto_path 0 /usr/local/oag/apps/lib/$env(HOST_ARCH)]
set auto_path [linsert $auto_path 0 /usr/local/oag/lib_patch/$env(HOST_ARCH)]

package require BLT

set CVSRevisionAuthor "\$Revision: 1.18 $ \$Author: soliday $"

proc APSExecLogMod { widget args } {
    global apsContextHelp
    set parent ""
    set noPack 0
    set packOption "-side top -fill x"
    set unixCommand ""
    set contextHelp ""
    set callback ""
    set abortCallback ""
    set cancelCallback ""
    set name "Unix Command Execution"
    set width 40
    set height 15
    set lineLimit 0
    APSStrictParseArguments {parent unixCommand noPack packOption contextHelp  callback name width height abortCallback cancelCallback   lineLimit}

    set windowExists [winfo exists $parent$widget]
    if {!$windowExists} {
	APSDialogBox $widget -parent $parent -name $name  -noPack $noPack -packOption $packOption  -contextHelp $contextHelp
	
	APSScrolledText .text -parent $parent$widget.userFrame -width $width  -height $height
    } else {
	wm title $parent$widget $name
    }

    set log $parent$widget.userFrame.text.text
    if {!$windowExists} {
	# Put in a null command until the process pipe is open
	APSDialogBoxAddButton .abort -parent $parent$widget -text Abort  -command ""  -contextHelp "Abort command execution, but leave window up."
	
	APSDialogBoxAddButton .print -parent $parent$widget -text Print  -command "APSPrint -textWidget $log -cmd enscript"  -contextHelp "Print contents of window using enscript command."

	APSButton .save -parent $parent$widget.buttonRow -text "Save As..." -command "APSSaveDialog .alertSave -textWidget $log"  -contextHelp "Save contents of window to a file."
	
    } else {
	APSDisableButton $parent$widget.buttonRow.ok.button
    }
    global apsExecLogLineCount  apsExecLogLineLimit
    set apsExecLogLineCount($log) 0
    set apsExecLogLineLimit($log) $lineLimit
    
#    set cmd1 "csh -f -c \"$unixCommand\" |& cat -u"
    set cmd1 "$unixCommand |& cat -u"
    # If at end now, then reset to end afterward
    if {[lindex [$log yview] 1] == 1} {
	set gotoend 1
    } else {
	set gotoend 0
    }
    if [catch {open |$cmd1 r} input] {
	$log insert end $input\n
	if {$gotoend} {$log see end}
	set pipePid -1
	return -1
    } else {
	set pipePid [pid $input]
	fileevent $input readable  [list APSExecLogCallback $parent$widget $input $log $callback]
	$log insert end $unixCommand\n
	if {$gotoend} {$log see end}
    }
    catch {$parent$widget.buttonRow.cancel.button configure -command  [list $cancelCallback]}
    catch {$parent$widget.buttonRow.abort.button configure  -command [list $abortCallback]}
    return [list $input $parent$widget $pipePid]
}

proc APSExecLogStopMod {args} {
    global execLogInfo
    foreach val $execLogInfo {
	catch "exec kill [lindex $val 2]"
	catch {close [lindex $val 0]}
    }
    foreach val $execLogInfo {
	destroy [lindex $val 1]
    }
    global abortNow
    set abortNow 1
}

proc APSExecLogAbortInternalMod {args} {
    global execLogInfo
    foreach val $execLogInfo {
	catch "exec kill [lindex $val 2]"
	catch {close [lindex $val 0]}
    }
    APSSetVarAndUpdate status "Aborted by user"
    global abortNow
    set abortNow 1
}






proc makeDir {pathname} {
    if {[file isdirectory $pathname]} {
	return $pathname
    } elseif {[file exists $pathname]} {
	APSSetVarAndUpdate 
	return -code error "Non-directory $pathname already exists"
    } else {
	if [catch {makeDir [file dirname $pathname]} result] {
	    return -code error $result
	}
	if [catch {exec mkdir $pathname} result] {
	    return -code error $result
	}
#	catch {exec chmod a+w $pathname}
	return $pathname
    }
}

proc DisableEnableButtons {args} {
    set state disabled
    APSStrictParseArguments {state}
    .userFrame.autoRun.button configure -state $state
    .userFrame.testbutton.button configure -state $state
    foreach name [winfo children .userFrame.supplySelection.frame] {
	$name configure -state $state
    }
    if {[winfo exists .userFrame.testSelection]} {
	foreach name [winfo children .userFrame.testSelection.frame] {
	    $name configure -state $state
	}
    }
    .menu.system configure -state $state
}

proc SetAutoRunSelections {args} {
    set select ""
    set value 1
    APSStrictParseArguments {select value}
    if {$select == "injectors"} {
        global PC1Quad PC1Corr PC1SCCorr PC1BM PC1QE
        set PC1Quad [set PC1Corr [set PC1SCCorr [set PC1BM [set PC1QE $value]]]]
        global RG1Quad RG1Corr RG1Trim RG1Alpha RG1Heater
        set RG1Quad [set RG1Corr [set RG1Trim [set RG1Alpha [set RG1Heater $value]]]]
        global RG2Quad RG2Corr RG2Trim RG2Alpha RG2Heater
        set RG2Quad [set RG2Corr [set RG2Trim [set RG2Alpha [set RG2Heater $value]]]]
        global L1Quad L1Corr
        set L1Quad [set L1Corr $value]
        global LinacAM Linac12BitQM Linac14BitQM LinacSC LinacL3SC LinacSM LinacBM
        set LinacAM [set Linac12BitQM [set Linac14BitQM [set LinacSC [set LinacL3SC [set LinacSM [set LinacBM $value]]]]]]
        global LTPQuad LTPCorr LTPBM LTPBucking
        set LTPBucking [set LTPQuad [set LTPCorr [set LTPBM $value]]]
        global PARQuad PARSext PARCorr PARTrim PARBM
        set PARQuad [set PARSext [set PARCorr [set PARTrim [set PARBM $value]]]]
        global PTBQuad PTBCorr PTBBM PTBBucking
        set PTBBucking [set PTBQuad [set PTBCorr [set PTBBM $value]]]
        global BTSQuad BTSCorr BTSBM
        set BTSQuad [set BTSCorr [set BTSBM $value]]
    } elseif {$select == "leutl"} {
        global ParBypassQuad ParBypassCorr
        set ParBypassQuad [set ParBypassCorr $value]
        global BoosterBypassQuad BoosterBypassCorr BoosterBypassBM BoosterBypassTrip
        set BoosterBypassQuad [set BoosterBypassCorr [set BoosterBypassBM [set BoosterBypassTrip $value]]]
        global AlcoveQuad
        set AlcoveQuad $value
        global SkiplineQuad SkiplineCorrH SkiplineCorrV SkiplineBM
        set SkiplineQuad [set SkiplineCorrH [set SkiplineBM $value]]
        set SkiplineCorrV $value
        global UndulatorsQuad UndulatorsCorrH UndulatorsCorrV
        set UndulatorsQuad [set UndulatorsCorrH $value]
        set UndulatorsCorrV $value
    } elseif {$select == "sr"} {
        global SRQuadA SRQuadB SRQuadC SRQuadD SRQuadE SRQuadF SRQuadR
        set SRQuadA [set SRQuadB [set SRQuadC [set SRQuadD [set SRQuadE [set SRQuadF $value]]]]]
        set SRQuadR 0
        global SRSextA SRSextB SRSextC SRSextD SRSextE SRSextF SRSextR
        set SRSextA [set SRSextB [set SRSextC [set SRSextD [set SRSextE [set SRSextF $value]]]]]
        set SRSextR 0
        global SRCorrA SRCorrB SRCorrC SRCorrD SRCorrE SRCorrF SRCorrR
        set SRCorrA [set SRCorrB [set SRCorrC [set SRCorrD [set SRCorrE [set SRCorrF $value]]]]]
        set SRCorrR 0
        global SRSkewA SRSkewB SRSkewC SRSkewD SRSkewE SRSkewF SRSkewR
        set SRSkewA [set SRSkewB [set SRSkewC [set SRSkewD [set SRSkewE [set SRSkewF $value]]]]]
        set SRSkewR 0
        global SRTrimA SRTrimB SRTrimC SRTrimD SRTrimE SRTrimF SRTrimR
        set SRTrimA [set SRTrimB [set SRTrimC [set SRTrimD [set SRTrimE [set SRTrimF $value]]]]]
        set SRTrimR 0
        global SRBMA SRBMB SRBMC SRBMD SRBME SRBMF SRBMR
        set SRBMA [set SRBMB [set SRBMC [set SRBMD [set SRBME [set SRBMF $value]]]]]
        set SRBMR 0
    }
}

proc SelectAutoRun {args} {
    set select all
    APSStrictParseArguments {select}
    destroy .userFrame.testbutton .userFrame.supplySelection .userFrame.testSelection .userFrame.auto
    pack [frame .userFrame.auto]
    
    .userFrame.autoRun.button configure -state disabled
    .menu.system configure -state disabled

    if {$select == "none"} {
	set value 0
    } else {
	set value 1
    }

    pack [labelframe .userFrame.auto.injectors -text "Injector PS"] -anchor nw -padx 5
    pack [labelframe .userFrame.auto.leutl -text "LEUTL PS"] -anchor nw -padx 5 -pady 10
    pack [labelframe .userFrame.auto.sr -text "Storage Ring PS"] -anchor nw  -padx 5

    global PC1Quad PC1Corr PC1SCCorr PC1BM PC1QE
    set PC1Quad [set PC1Corr [set PC1SCCorr [set PC1BM [set PC1QE $value]]]]
    APSCheckButtonFrame .pc1 \
	-parent .userFrame.auto.injectors \
	-label "          PC1:" \
	-orientation horizontal \
	-buttonList "Quadrupole Corrector SC:Corrector Dipole QE" \
	-variableList "PC1Quad PC1Corr PC1SCCorr PC1BM PC1QE"

    global RG1Quad RG1Corr RG1Alpha RG1Trim RG1Heater
    set RG1Quad [set RG1Corr [set RG1Alpha [set RG1Trim [set RG1Heater $value]]]]
    set RG1Heater 0
    APSCheckButtonFrame .rfg1 \
	-parent .userFrame.auto.injectors \
	-label "          RG1:" \
	-orientation horizontal \
	-buttonList "Quadrupole Corrector Trim Alpha Heater" \
	-variableList "RG1Quad RG1Corr RG1Trim RG1Alpha RG1Heater"

    global RG2Quad RG2Corr RG2Alpha RG2Trim RG2Heater
    set RG2Quad [set RG2Corr [set RG2Alpha [set RG2Trim [set RG2Heater $value]]]]
    set RG2Heater 0
    APSCheckButtonFrame .rfg2 \
	-parent .userFrame.auto.injectors \
	-label "          RG2:" \
	-orientation horizontal \
	-buttonList "Quadrupole Corrector Trim Alpha Heater" \
	-variableList "RG2Quad RG2Corr RG2Trim RG2Alpha RG2Heater"

    global L1Quad L1Corr
    set L1Quad [set L1Corr $value]
    APSCheckButtonFrame .l1 \
	-parent .userFrame.auto.injectors \
	-label "           L1:" \
	-orientation horizontal \
	-buttonList "Quadrupole Corrector" \
	-variableList "L1Quad L1Corr"

    global LinacAM Linac12BitQM Linac14BitQM LinacSC LinacL3SC LinacSM LinacBM
    set LinacAM [set Linac12BitQM [set Linac14BitQM [set LinacSC [set LinacL3SC [set LinacSM [set LinacBM $value]]]]]]
    APSCheckButtonFrame .linac \
	-parent .userFrame.auto.injectors \
	-label "        Linac:" \
	-orientation horizontal \
	-buttonList "AM BM 12Bit:QM 14Bit:QM SC L3:SC SM" \
	-variableList "LinacAM LinacBM Linac12BitQM Linac14BitQM LinacSC LinacL3SC LinacSM"

    global LTPQuad LTPCorr LTPBM LTPBucking
    set LTPBucking [set LTPQuad [set LTPCorr [set LTPBM $value]]]
    set LTPBM 0
    APSCheckButtonFrame .ltp \
	-parent .userFrame.auto.injectors \
	-label "          LTP:" \
	-orientation horizontal \
	-buttonList "Quadrupole Corrector Dipole BuckingCoil" \
	-variableList "LTPQuad LTPCorr LTPBM LTPBucking"

    global PARQuad PARSext PARCorr PARTrim PARBM
    set PARQuad [set PARSext [set PARCorr [set PARTrim [set PARBM $value]]]]
    APSCheckButtonFrame .par \
	-parent .userFrame.auto.injectors \
	-label "          PAR:" \
	-orientation horizontal \
	-buttonList "Quadrupole Corrector Dipole Sextupole Trim" \
	-variableList "PARQuad PARCorr PARBM PARSext PARTrim"

    global PTBQuad PTBCorr PTBBM PTBBucking
    set PTBBucking [set PTBQuad [set PTBCorr [set PTBBM $value]]]
    APSCheckButtonFrame .ptb \
	-parent .userFrame.auto.injectors \
	-label "          PTB:" \
	-orientation horizontal \
	-buttonList "Quadrupole Corrector Dipole BuckingCoil" \
	-variableList "PTBQuad PTBCorr PTBBM PTBBucking"

    global BTSQuad BTSCorr BTSBM
    set BTSQuad [set BTSCorr [set BTSBM $value]]
    set BTSBM 0
    APSCheckButtonFrame .bts \
	-parent .userFrame.auto.injectors \
	-label "          BTS:" \
	-orientation horizontal \
	-buttonList "Quadrupole Corrector Dipole" \
	-variableList "BTSQuad BTSCorr BTSBM"

    APSButton .selectinjectors \
      -parent .userFrame.auto.injectors \
      -text "Select All" \
      -command "SetAutoRunSelections -select injectors"
    APSButton .unselectinjectors \
      -parent .userFrame.auto.injectors \
      -text "Un-Select All" \
      -command "SetAutoRunSelections -select injectors -value 0"

    global ParBypassQuad ParBypassCorr
    set ParBypassQuad [set ParBypassCorr $value]
    APSCheckButtonFrame .parbypass \
	-parent .userFrame.auto.leutl \
	-label "    ParBypass:" \
	-orientation horizontal \
	-buttonList "Quadrupole Corrector" \
	-variableList "ParBypassQuad ParBypassCorr"

    global BoosterBypassQuad BoosterBypassCorr BoosterBypassBM BoosterBypassTrip
    set BoosterBypassQuad [set BoosterBypassCorr [set BoosterBypassBM [set BoosterBypassTrip $value]]]
    APSCheckButtonFrame .bb \
	-parent .userFrame.auto.leutl \
	-label "BoosterBypass:" \
	-orientation horizontal \
	-buttonList "Quadrupole Corrector {Dump Dipole} {Beam Dipoles}" \
	-variableList "BoosterBypassQuad BoosterBypassCorr BoosterBypassBM BoosterBypassTrip"

    global AlcoveQuad
    set AlcoveQuad $value
    APSCheckButtonFrame .alcove \
	-parent .userFrame.auto.leutl \
	-label "       Alcove:" \
	-orientation horizontal \
	-buttonList "Quadrupole" \
	-variableList "AlcoveQuad"

    global SkiplineQuad SkiplineCorrH SkiplineCorrV SkiplineBM
    set SkiplineQuad [set SkiplineCorrH [set SkiplineBM $value]]
    set SkiplineCorrV 1
    APSCheckButtonFrame .skipline \
	-parent .userFrame.auto.leutl \
	-label "     Skipline:" \
	-orientation horizontal \
	-buttonList {Quadrupole "H-Corrector" "V-Corrector"} \
	-variableList "SkiplineQuad SkiplineCorrH SkiplineCorrV"

    global UndulatorsQuad UndulatorsCorrH UndulatorsCorrV
    set UndulatorsQuad [set UndulatorsCorrH $value]
    set UndulatorsCorrV 1
    APSCheckButtonFrame .undulators \
	-parent .userFrame.auto.leutl \
	-label "   Undulators:" \
	-orientation horizontal \
	-buttonList {Quadrupole "H-Corrector" "V-Corrector"} \
	-variableList "UndulatorsQuad UndulatorsCorrH UndulatorsCorrV"

    APSButton .selectleutl \
      -parent .userFrame.auto.leutl \
      -text "Select All" \
      -command "SetAutoRunSelections -select leutl"
    APSButton .unselectleutl \
      -parent .userFrame.auto.leutl \
      -text "Un-Select All" \
      -command "SetAutoRunSelections -select leutl -value 0"

    global SRQuadA SRQuadB SRQuadC SRQuadD SRQuadE SRQuadF SRQuadR
    set SRQuadA [set SRQuadB [set SRQuadC [set SRQuadD [set SRQuadE [set SRQuadF 0]]]]]
    set SRQuadR 0
    APSCheckButtonFrame .srQuad \
	-parent .userFrame.auto.sr \
	-label "SR Quadrupole:" \
	-orientation horizontal \
	-buttonList "{Zone A} {Zone B} {Zone C} {Zone D} {Zone E} {Zone F} {Entire Ring}" \
	-variableList "SRQuadA SRQuadB SRQuadC SRQuadD SRQuadE SRQuadF SRQuadR"

    global SRSextA SRSextB SRSextC SRSextD SRSextE SRSextF SRSextR
    set SRSextA [set SRSextB [set SRSextC [set SRSextD [set SRSextE [set SRSextF 0]]]]]
    set SRSextR 0
    APSCheckButtonFrame .srSext \
	-parent .userFrame.auto.sr \
	-label " SR Sextupole:" \
	-orientation horizontal \
	-buttonList "{Zone A} {Zone B} {Zone C} {Zone D} {Zone E} {Zone F} {Entire Ring}" \
	-variableList "SRSextA SRSextB SRSextC SRSextD SRSextE SRSextF SRSextR"

    global SRCorrA SRCorrB SRCorrC SRCorrD SRCorrE SRCorrF SRCorrR
    set SRCorrA [set SRCorrB [set SRCorrC [set SRCorrD [set SRCorrE [set SRCorrF 0]]]]]
    set SRCorrR 0
    APSCheckButtonFrame .srCorr \
	-parent .userFrame.auto.sr \
	-label " SR Corrector:" \
	-orientation horizontal \
	-buttonList "{Zone A} {Zone B} {Zone C} {Zone D} {Zone E} {Zone F} {Entire Ring}" \
	-variableList "SRCorrA SRCorrB SRCorrC SRCorrD SRCorrE SRCorrF SRCorrR"

    global SRSkewA SRSkewB SRSkewC SRSkewD SRSkewE SRSkewF SRSkewR
    set SRSkewA [set SRSkewB [set SRSkewC [set SRSkewD [set SRSkewE [set SRSkewF 0]]]]]
    set SRSkewR 0
    APSCheckButtonFrame .srSkew \
	-parent .userFrame.auto.sr \
	-label " SR Skew Quad:" \
	-orientation horizontal \
	-buttonList "{Zone A} {Zone B} {Zone C} {Zone D} {Zone E} {Zone F} {Entire Ring}" \
	-variableList "SRSkewA SRSkewB SRSkewC SRSkewD SRSkewE SRSkewF SRSkewR"

    global SRTrimA SRTrimB SRTrimC SRTrimD SRTrimE SRTrimF SRTrimR
    set SRTrimA [set SRTrimB [set SRTrimC [set SRTrimD [set SRTrimE [set SRTrimF 0]]]]]
    set SRTrimR 0
    APSCheckButtonFrame .srTrim \
	-parent .userFrame.auto.sr \
	-label " SR Trim Quad:" \
	-orientation horizontal \
	-buttonList "{Zone A} {Zone B} {Zone C} {Zone D} {Zone E} {Zone F} {Entire Ring}" \
	-variableList "SRTrimA SRTrimB SRTrimC SRTrimD SRTrimE SRTrimF SRTrimR"

    global SRBMA SRBMB SRBMC SRBMD SRBME SRBMF SRBMR
    set SRBMA [set SRBMB [set SRBMC [set SRBMD [set SRBME [set SRBMF 0]]]]]
    set SRBMR 0
    APSCheckButtonFrame .srBM \
	-parent .userFrame.auto.sr \
	-label "   SR BM Quad:" \
	-orientation horizontal \
	-buttonList "{Zone A} {Zone B} {Zone C} {Zone D} {Zone E} {Zone F} {Entire Ring}" \
	-variableList "SRBMA SRBMB SRBMC SRBMD SRBME SRBMF SRBMR"

    APSButton .selectsr \
      -parent .userFrame.auto.sr \
      -text "Select All" \
      -command "SetAutoRunSelections -select sr"
    APSButton .unselectsr \
      -parent .userFrame.auto.sr \
      -text "Un-Select All" \
      -command "SetAutoRunSelections -select sr -value 0"

    pack [frame .userFrame.auto.buttons]
    APSButton .autoRun \
	-parent .userFrame.auto.buttons \
	-text "Start" \
	-command "AutoRun"

    APSButton .cancel \
	-parent .userFrame.auto.buttons \
	-text "Cancel" \
	-command ".userFrame.autoRun.button configure -state normal ; .menu.system configure -state normal ; destroy .userFrame.auto"

    APSButton .selectall \
	-parent .userFrame.auto.buttons \
	-text "Default Selections" \
	-command "SelectAutoRun"

    APSButton .selectnone \
	-parent .userFrame.auto.buttons \
	-text "Un-Select All" \
	-command "SelectAutoRun -select none"
}

set autorun 0
proc AutoRun {} {
    global autorun autorunSetup autorunMeasure autorunFinish
    set systems "Alcove BoosterBypass BTS L1 LTP PTB Linac PAR PC1 ParBypass RG1 RG2 SR SR SR SR SR SR Skipline Undulators"
    set supplies "{Quad} {Quad Corr BM Trip} {Quad Corr BM} {Quad Corr} {Quad Corr BM Bucking} {Quad Corr BM Bucking} {AM BM 12BitQM 14BitQM SC L3SC SM} {Quad Sext Corr Trim BM} {Quad Corr SCCorr BM QE} {Quad Corr} {Quad Corr Trim Alpha Heater} {Quad Corr Trim Alpha Heater} {QuadA QuadB QuadC QuadD QuadE QuadF QuadR} {SextA SextB SextC SextD SextE SextF SextR} {CorrA CorrB CorrC CorrD CorrE CorrF CorrR} {SkewA SkewB SkewC SkewD SkewE SkewF SkewR} {TrimA TrimB TrimC TrimD TrimE TrimF TrimR} {BMA BMB BMC BMD BME BMF BMR} {Quad CorrH CorrV} {Quad CorrH CorrV}"
    global abortNow
    set abortNow 0
    set autorun 1
    foreach system $systems supplyList $supplies {
	foreach supply $supplyList {
	    global ${system}${supply} powerSupply
	    if {[set ${system}${supply}]} {
		SetupLSBCheck -system $system
		if {$system == "SR"} {
		    set zone [string range $supply end end]
		    set supply [string range $supply 0 [expr [string length $supply] - 2]]
		    global location
		    set location $zone
		}
		set powerSupply $supply
		update
		if {$abortNow} {
		    return
		}
#		after 2000
		.userFrame.testbutton.button flash
		.userFrame.testbutton.button invoke
	    }
	}
    }
    APSSetVarAndUpdate status "Waiting for sddsexperiment to finish"
    set autorun 0
}


proc test {args} {
    set system ""
    set subdir ""
    APSStrictParseArguments {system subdir}

    global autorun powerSupply lower upper
    set supply $powerSupply
    set archiveDir /home/helios/oagData/PSGROUP/data
#    set archiveDir /home/helios/PSGROUP/data

    set seconds [clock seconds]
    set dateString [clock format $seconds -format "%y%m"]
    set dayString [clock format $seconds -format "%d"]
    set dataDir ${archiveDir}/${dateString}/${dayString}/${subdir}
    
    if [catch {makeDir $dataDir} result] {
	APSSetVarAndUpdate status "$result"
	return
    }
    
    set timeString [clock format $seconds -format "%H%M%S"]
    
    set plot 1
    set controlNameSuffix1 CurrentAI
    set columnNameSuffix1 CurrentAI
    set controlNameSuffix2 DacAI
    set columnNameSuffix2 DacAI
    set controlNameSuffix3 CurrentAO
    set columnNameSuffix3 CurrentAO
    set initialSetpoint 0
    set bits 16
    switch -exact -- $system {
	Alcove {
	    if {$supply=="Quad"} {
		set outputFile ${timeString}_AL_Q_LSB.sdds
	    }
	}
	BoosterBypass {
	    if {$supply=="Quad"} {
		set outputFile ${timeString}_BB_Q_LSB.sdds
	    }
	    if {$supply=="Corr"} {
		set outputFile ${timeString}_BB_C_LSB.sdds
	    }
	    if {$supply=="BM"} {
		set outputFile ${timeString}_BB_BDD_LSB.sdds
	    }
	    if {$supply=="Trip"} {
		set outputFile ${timeString}_BB_VBT_LSB.sdds
	    }
	}
	BTS {
	    if {$supply=="Quad"} {
		set outputFile ${timeString}_bts_Q_LSB.sdds
		#set initialSetpoint 30
	    }
	    if {$supply=="Corr"} {
		set outputFile ${timeString}_bts_C_LSB.sdds
		set bits 12
	    }
	    if {$supply=="BM"} {
		set outputFile ${timeString}_bts_BM_LSB.sdds
		set initialSetpoint 30
	    }
	}
	L1 {
	    if {$supply=="Quad"} {
		set outputFile ${timeString}_L1_Q_LSB.sdds
	    }
	    if {$supply=="Corr"} {
		set outputFile ${timeString}_L1_C_LSB.sdds
	    }
	}
	LTP {
	    if {$supply=="Quad"} {
		set outputFile ${timeString}_ltp_Q_LSB.sdds
	    }
	    if {$supply=="Corr"} {
		set outputFile ${timeString}_ltp_C_LSB.sdds
	    }
	    if {$supply=="BM"} {
		set outputFile ${timeString}_ltp_BM_LSB.sdds
		set initialSetpoint 50
	    }
	    if {$supply=="Bucking"} {
		set outputFile ${timeString}_ltp_Bucking_LSB.sdds
	    }
	}
	PTB {
	    if {$supply=="Quad"} {
		set outputFile ${timeString}_ptb_Q_LSB.sdds
	    }
	    if {$supply=="Corr"} {
		set outputFile ${timeString}_ptb_C_LSB.sdds
	    }
	    if {$supply=="BM"} {
		set outputFile ${timeString}_ptb_BM_LSB.sdds
		set initialSetpoint 50
	    }
	    if {$supply=="Bucking"} {
		set outputFile ${timeString}_ptb_Bucking_LSB.sdds
	    }
	}
	Linac {
	    if {$supply=="ALL"} {
		foreach name "AM BM 12BitQM 14BitQM SC L3SC SM" {
		    set supply $name
		    test -system Linac -subdir $subdir
		}
		set supply ALL
		return
	    }
	    set controlNameSuffix1 measCurrentAI
	    set columnNameSuffix1 MeasuredCurrent
	    set controlNameSuffix2 measVoltageAI
	    set columnNameSuffix2 MeasuredVoltage
	    set controlNameSuffix3 setCurrentAO
	    set columnNameSuffix3 Setpoint
	    if {$supply=="AM"} {
		set outputFile ${timeString}_linac_AM_LSB.sdds
		set bits 12
	    }
	    if {$supply=="BM"} {
		set outputFile ${timeString}_linac_BM_LSB.sdds
		set controlNameSuffix1 CurrentAI
		set columnNameSuffix1 CurrentAI
		set controlNameSuffix2 DacAO
		set columnNameSuffix2 DacAO
		set controlNameSuffix3 CurrentAO
		set columnNameSuffix3 CurrentAO
		set bits 12
	    }
	    if {$supply=="12BitQM"} {
		set outputFile ${timeString}_linac_12BitQM_LSB.sdds
		set controlNameSuffix1 CurrentAI
		set columnNameSuffix1 CurrentAI
		set controlNameSuffix2 DacAO
		set columnNameSuffix2 DacAO
		set controlNameSuffix3 CurrentAO
		set columnNameSuffix3 CurrentAO
		set bits 12
	    }
	    if {$supply=="14BitQM"} {
		set outputFile ${timeString}_linac_14BitQM_LSB.sdds
		set controlNameSuffix1 CurrentAI
		set columnNameSuffix1 CurrentAI
		set controlNameSuffix2 DacAO
		set columnNameSuffix2 DacAO
		set controlNameSuffix3 CurrentAO
		set columnNameSuffix3 CurrentAO
		set bits 14
	    }
	    if {$supply=="SC"} {
		set outputFile ${timeString}_linac_SC_LSB.sdds
		set bits 12
	    }
	    if {$supply=="L3SC"} {
		set outputFile ${timeString}_linac_L3SC_LSB.sdds
		set controlNameSuffix1 CurrentAI
		set columnNameSuffix1 CurrentAI
		set controlNameSuffix2 DacAO
		set columnNameSuffix2 DacAO
		set controlNameSuffix3 CurrentAO
		set columnNameSuffix3 CurrentAO
		set bits 12
	    }
	    if {$supply=="SM"} {
		set outputFile ${timeString}_linac_SM_LSB.sdds
		set bits 12
		set controlNameSuffix1 measCurrAI
		set columnNameSuffix1 measCurrAI
		set controlNameSuffix2 measVoltAI
		set columnNameSuffix2 measVoltAI
		set controlNameSuffix3 setCurrentAO
		set columnNameSuffix3 setCurrentAO
	    }
	}
	PAR {
	    if {$supply=="Quad"} {
		set outputFile ${timeString}_par_Q_LSB.sdds
	    }
	    if {$supply=="Sext"} {
		set outputFile ${timeString}_par_S_LSB.sdds
	    }
	    if {$supply=="Corr"} {
		set outputFile ${timeString}_par_C_LSB.sdds
	    }
	    if {$supply=="Trim"} {
		set outputFile ${timeString}_par_BMT_LSB.sdds
	    }
	    if {$supply=="BM"} {
		set outputFile ${timeString}_par_BM_LSB.sdds
	    }
	}
	PC1 {
	    if {$supply=="Corr"} {
		set outputFile ${timeString}_pc1_C_LSB.sdds
	    }
	    if {$supply=="SCCorr"} {
                set bits 12
                set controlNameSuffix2 DacAO
                set columnNameSuffix2 DacAO
		set outputFile ${timeString}_pc1_SCC_LSB.sdds
	    }
	    if {$supply=="Quad"} {
                set bits 12
                set controlNameSuffix2 DacAO
                set columnNameSuffix2 DacAO
		set outputFile ${timeString}_pc1_Q_LSB.sdds
	    }
	    if {$supply=="QE"} {
                set controlNameSuffix2 CurrentSettingAI
                set columnNameSuffix2 CurrentSettingAI
		set outputFile ${timeString}_pc1_QE_LSB.sdds
	    }
	    if {$supply=="BM"} {
		set outputFile ${timeString}_pc1_BM_LSB.sdds
	    }
	}
	ParBypass {
	    if {$supply=="Quad"} {
		set outputFile ${timeString}_PB_Q_LSB.sdds
	    }
	    if {$supply=="Corr"} {
		set outputFile ${timeString}_PB_C_LSB.sdds
	    }
	}
	RG1 {
	    if {$supply=="Quad"} {
		set outputFile ${timeString}_rfg_Q_LSB.sdds
	    }
	    if {$supply=="Corr"} {
		set outputFile ${timeString}_rfg_C_LSB.sdds
	    }
	    if {$supply=="Trim"} {
		set outputFile ${timeString}_rfg_Trim_LSB.sdds
	    }
	    if {$supply=="Alpha"} {
		set outputFile ${timeString}_rfg_Alpha_LSB.sdds
	    }
	    if {$supply=="Heater"} {
		set controlNameSuffix1 VoltageAI
		set columnNameSuffix1 VoltageAI
		set controlNameSuffix2 DacAI
		set columnNameSuffix2 DacAI
		set controlNameSuffix3 VoltageAO
		set columnNameSuffix3 VoltageAO
		
		set outputFile ${timeString}_rfg_Heater_LSB.sdds
	    }
	}
	RG2 {
	    if {$supply=="Quad"} {
		set outputFile ${timeString}_rfg2_Q_LSB.sdds
	    }
	    if {$supply=="Corr"} {
		set outputFile ${timeString}_rfg2_C_LSB.sdds
	    }
	    if {$supply=="Trim"} {
		set outputFile ${timeString}_rfg2_Trim_LSB.sdds
	    }
	    if {$supply=="Alpha"} {
		set outputFile ${timeString}_rfg2_Alpha_LSB.sdds
	    }
	    if {$supply=="Heater"} {
		set controlNameSuffix1 VoltageAI
		set columnNameSuffix1 VoltageAI
		set controlNameSuffix2 DacAI
		set columnNameSuffix2 DacAI
		set controlNameSuffix3 VoltageAO
		set columnNameSuffix3 VoltageAO
		
		set outputFile ${timeString}_rfg2_Heater_LSB.sdds
	    }
	}
	Skipline {
	    if {$supply=="Quad"} {
		set outputFile ${timeString}_SK_Q_LSB.sdds
	    }
	    if {$supply=="CorrH"} {
		set outputFile ${timeString}_SK_C_H_LSB.sdds
	    }
	    if {$supply=="CorrV"} {
		set outputFile ${timeString}_SK_C_V_LSB.sdds
	    }
	}
	Undulators {
	    set controlNameSuffix1 MeasCurrAI
	    set columnNameSuffix1 MeasCurrAI
	    set controlNameSuffix2 DacAO
	    set columnNameSuffix2 DacAO
	    set controlNameSuffix3 SetCurrAO
	    set columnNameSuffix3 SetCurrAO
	    set bits 12
	    if {$supply=="Quad"} {
		set outputFile ${timeString}_UN_Q_LSB.sdds
	    }
	    if {$supply=="CorrH"} {
		set outputFile ${timeString}_UN_C_H_LSB.sdds
	    }
	    if {$supply=="CorrV"} {
		set outputFile ${timeString}_UN_C_V_LSB.sdds
	    }
	}
	default {
	    return
	}
    }

    if [catch {sdds load /home/helios/oagData/PSGROUP/AnalogCheck.sdds sddsData} result] {
	APSSetVarAndUpdate status "error reading file: /home/helios/oagData/PSGROUP/AnalogCheck.sdds : $result"
	return	
    }
    set count 0
    set found 0
    foreach sys $sddsData(Parameter.System) sup $sddsData(Parameter.Supply) {
	if {($sys == $system) && ($sup == $supply)} {
	    set PVnames [lindex $sddsData(Column.ControlName) $count]
	    set found 1
	    break
	}
	incr count
    }
    if {!$found} {
	APSSetVarAndUpdate status "Invalid supply specified : $supply"
	return
    }

    #Ask user which power supplies are going to be tested
    eval global $PVnames
    foreach name $PVnames {
	set $name 1
    }
    
    global done
    if {[winfo exists .info]} {
	APSSetVarAndUpdate status "Supply already selected"
	bell
	raise .info
	return
    }

    if {!$autorun} {
	set done 0
	APSDialogBox .info \
	    -name "Select Power Supplies" \
	    -okCommand {set done OK} \
	    -cancelCommand {set done CANCEL}
	
	wm  protocol .info WM_DELETE_WINDOW {set done CANCEL;destroy .info}
	
	global globalPVNames
	set globalPVNames $PVnames
	
	APSDialogBoxAddButton .all \
	    -parent .info \
	    -text "Select All" \
	    -command {
		global globalPVNames
		eval global $globalPVNames
		foreach name $globalPVNames {
		    set $name 1
		}
	    }
	
	APSDialogBoxAddButton .none \
	    -parent .info \
	    -text "Un-Select All" \
	    -command {
		global globalPVNames
		eval global $globalPVNames
		foreach name $globalPVNames {
		    set $name 0
		}
	    }
	
	APSCheckButtonFrame .cbf \
	    -parent .info.userFrame \
	    -buttonList $PVnames \
	    -variableList $PVnames \
	    -label "Select which power supplies to check" \
	    -limitPerRow 10
	
	tkwait variable done
	if {$done != "OK"} {
	    APSSetVarAndUpdate status "Operation canceled"
	    return
	}
    }

    if {![llength $PVnames]} {
	APSSetVarAndUpdate status "No supply chosen"
	return
    }

    set outputData "SDDS1\n\n"
    foreach name $PVnames {
	if {[set $name]} {
	    if {$name == "L3:AM1:"} {
		set cns1 CurrentAI
		set cns2 OutVoltageAI
	    } elseif {$name == "L3:AM1T:"} {
		set cns1 CurrentAI
		set cns2 OutVoltageAI
	    } else {
		set cns1 ${controlNameSuffix1}
		set cns2 ${controlNameSuffix2}		    
	    }
	    append outputData "&measurement    control_name = \"${name}${cns1}\",\n"
	    append outputData "                column_name = \"${name}${columnNameSuffix1}\",\n"
	    append outputData "                units = \"Amps Read\",\n"
	    append outputData "&end\n\n"
	    append outputData "&measurement    control_name = \"${name}${cns2}\",\n"
	    append outputData "                column_name = \"${name}${columnNameSuffix2}\",\n"
	    append outputData "                units = \"Amps Read\",\n"
	    append outputData "&end\n\n"
	}
    }
    foreach name $PVnames {
	if {[set $name]} {
	    if {$name == "L3:AM1:"} {
		set cns3 CurrentAO
	    } elseif {$name == "L3:AM1T:"} {
		set cns3 CurrentAO
	    } else {
		set cns3 ${controlNameSuffix3}
	    }
            if [pv linkw "lower upper" "${name}${cns3}.EGUL ${name}${cns3}.EGUF"] {
		APSSetVarAndUpdate status "No supply chosen"
		return
	    }
            if {($name == "LTP:B1:") || ($name == "PTB:B1:") || ($name == "PTB:B2:")} {
                set lower 0.0
                set upper 350.0
            }
            if {($name == "L1:PC1:QE1:") || ($name == "L1:PC1:QE2:")} {
                set lower 0.0
                set upper 30.0
            }
            if {($name == "LTP:B1:BC:") || ($name == "PTB:B1:BC:") || ($name == "PTB:B2:BC:")} {
                set lower 0.0
                set upper 10.0
            }
	    if {$lower > $upper} {
		set tmp $lower
		set lower $upper
		set upper $tmp
	    }
            #2^16 = 65536, 65536/2 = 32768, 2^8 = 256
            #2^12 = 4096, 4096/2 = 2048, 2^6 = 64
            set fullrange [expr {pow(2,$bits)}]
            set halfrange [expr {$fullrange / 2.0}]
            set numsteps [expr {pow(2,$bits / 2)}]
            set interval [expr {($upper - $lower) / $fullrange}]
            if {($initialSetpoint >= $lower) && ([expr {($interval * $numsteps) + $initialSetpoint}] <= $upper)} {
                set setpoint $initialSetpoint
            } else {
                set setpoint [expr {$interval *  $halfrange + $lower}]
            }
            set data(ColumnNames) "SetPoints"
            set data(Column.SetPoints) ""
            set data(ColumnInfo.SetPoints) "type SDDS_DOUBLE"
            for {set i 0} {$i < $numsteps} {incr i} {
                append data(Column.SetPoints) " $setpoint"
                set setpoint [expr {$setpoint + $interval}]
            }
            set data(Column.SetPoints) [list $data(Column.SetPoints)]
            set valuesFile [APSTmpDir]/[APSTmpString]
            APSAddToTempFileList $valuesFile
            if [catch {sdds save $valuesFile data} result] {
                APSSetVarAndUpdate status "error writing file: $valuesFile :$result"
                return	
            }
	    append outputData "&variable       control_name = \"${name}${cns3}\",\n"
	    append outputData "                column_name = \"${name}${columnNameSuffix3}\",\n"
	    append outputData "                units = \"Amps Set\",\n"
	    append outputData "                values_file = \"${valuesFile}\",\n"
	    append outputData "                values_file_column = \"SetPoints\",\n"
	    append outputData "&end\n\n"
	}
    }
    append outputData "&execute        post_change_pause = 2,\n"
    append outputData "                rollover_pause = 35,\n"
    append outputData "&end"
    
    set inputFile [APSTmpDir]/[APSTmpString]
    if {[catch {open $inputFile w} fID]} {
	APSSetVarAndUpdate status "error: problem opening $inputFile : $fID"
	return
    }
    puts $fID $outputData
    catch {close $fID}
    APSSetVarAndUpdate status "Collecting Data on $system $supply"
    global ${system}${supply}done
    set ${system}${supply}done 0
    global execLogInfo

    lappend execLogInfo [APSExecLogMod .lsbWindow \
			     -name "LSB Test" \
			     -width 70 \
			     -unixCommand "sddsexperiment $inputFile ${dataDir}/$outputFile -verbose=very" \
			     -callback "FinishCheck -system $system -supply $supply -plot $plot -outputFile ${dataDir}/$outputFile -inputFile $inputFile" \
			     -cancelCallback "APSExecLogStopMod" \
			     -abortCallback "APSExecLogAbortInternalMod"]
    #    tkwait variable ${system}${supply}done
}

proc FinishCheck {args} {
    set system ""
    set supply ""
    set plot 1
    set outputFile ""
    set inputFile ""
    APSStrictParseArguments {system supply plot outputFile inputFile}

    file delete $inputFile
    if {$plot} {
	set plotCommand [GetPlotCommand -system $system -filename $outputFile]
	if [catch {eval exec sddsplot $outputFile \
		       -group=request \
		       -graph=symbol,vary \
		       -leg \
		       -title=@TimeStamp \
		       $plotCommand &} result] {
	    APSSetVarAndUpdate status "problem running sddsplot : $result"
	    return
	}
    }
    APSSetVarAndUpdate status "$system $supply output:\n$outputFile\nDone Collecting data on $system $supply"
#    global ${system}${supply}done
#    set ${system}${supply}done 1
}

proc testSR {args} {
    set subdir ""
    set system SR
    APSStrictParseArguments {subdir system}

    global autorun powerSupply location
    set supply $powerSupply
    set zone $location
    set archiveDir /home/helios/oagData/PSGROUP/data
#    set archiveDir /home/helios/PSGROUP/data

    set seconds [clock seconds]
    set dateString [clock format $seconds -format "%y%m"]
    set dayString [clock format $seconds -format "%d"]
    set dataDir ${archiveDir}/${dateString}/${dayString}/${subdir}
    
    if [catch {makeDir $dataDir} result] {
	APSSetVarAndUpdate status "$result"
	return
    }
    
    set timeString [clock format $seconds -format "%H%M%S"]   

    if [catch {sdds load /home/helios/oagData/PSGROUP/AnalogCheck.sdds sddsData} result] {
	APSSetVarAndUpdate status "error reading file: /home/helios/oagData/PSGROUP/AnalogCheck.sdds : $result"
	return	
    }
    set count 0
    set found 0
    foreach sys $sddsData(Parameter.System) sup $sddsData(Parameter.Supply) z $sddsData(Parameter.Zone) {
	if {($sys == $system) && ($sup == $supply) && (($z == $zone) || ($zone == "R"))} {
	    append PVnames "[lindex $sddsData(Column.ControlName) $count] "
	    set found 1
	    if {$zone != "R"} {
		break
	    }
	}
	incr count
    }
    if {!$found} {
	APSSetVarAndUpdate status "Invalid supply specified : $supply"
	return
    }

    #Ask user which power supplies are going to be tested
    eval global $PVnames
    foreach name $PVnames {
	set $name 1
    }
    
    global done
    if {[winfo exists .info]} {
	APSSetVarAndUpdate status "Supply already selected"
	bell
	raise .info
	return
    }

    if {!$autorun} {
	set done 0
	if {$zone == "R"} {
	    option add *font -adobe-courier-medium-r-normal-*-11-*-*-*-*-*-*-*
	    set limitPerRow 42
	} else {
	    option add *font -adobe-courier-medium-r-normal-*-14-*-*-*-*-*-*-*
	    set limitPerRow 30
	}
	APSDialogBox .info \
	    -name "Select Power Supplies" \
	    -okCommand {set done OK} \
	    -cancelCommand {set done CANCEL}
	
	wm  protocol .info WM_DELETE_WINDOW {set done CANCEL;destroy .info}
	
	global globalPVNames
	set globalPVNames $PVnames
	
	APSDialogBoxAddButton .all \
	    -parent .info \
	    -text "Select All" \
	    -command {
		global globalPVNames
		eval global $globalPVNames
		foreach name $globalPVNames {
		    set $name 1
		}
	    }
	
	APSDialogBoxAddButton .none \
	    -parent .info \
	    -text "Un-Select All" \
	    -command {
		global globalPVNames
		eval global $globalPVNames
		foreach name $globalPVNames {
		    set $name 0
		}
	    }
	
	APSCheckButtonFrame .cbf \
	    -parent .info.userFrame \
	    -buttonList $PVnames \
	    -variableList $PVnames \
	    -label "Select which power supplies to check" \
	    -limitPerRow $limitPerRow
	
	tkwait variable done
	if {$done != "OK"} {
	    APSSetVarAndUpdate status "Operation canceled"
	    return
	}
    }

    if {![llength $PVnames]} {
	APSSetVarAndUpdate status "No supply chosen"
	return
    }


    APSSetVarAndUpdate status "Collecting Data on Zone ${zone}'s $supply for Ring"

    set controlNameSuffix1 CurrentAI
    set columnNameSuffix1 CurrentAI
    set controlNameSuffix2 DacAI
    set columnNameSuffix2 DacAI
    set controlNameSuffix3 CurrentAO
    set columnNameSuffix3 CurrentAO
    set waitVar ""
    foreach num "1 2 3 4 5" {
	if {$supply == "Quad"} {
	    if {$zone=="R"} {	    
		set outputFile ${dataDir}/${timeString}_sr_R_q_${num}_LSB.sdds
		set valuesFile /home/helios/oagData/PSSCPDB/setpts/sr/Q${num}_bitcheck.sps
	    }
	    if {($zone=="A") || ($zone=="B") || 
		($zone=="C") || ($zone=="D") || 
		($zone=="E") || ($zone=="F")} {
		set outputFile ${dataDir}/${timeString}_sr_${zone}_q_${num}_LSB.sdds
		set valuesFile /home/helios/oagData/PSSCPDB/setpts/sr/Q${num}_bitcheck.sps
	    }
	}
	if {$supply == "Sext"} {
	    if {$num > 4} { continue }
	    if {$zone=="R"} {
		set outputFile ${dataDir}/${timeString}_sr_R_s_${num}_LSB.sdds
		set valuesFile /home/helios/oagData/PSSCPDB/setpts/sr/S${num}_bitcheck.sps
	    }
	    if {($zone=="A") || ($zone=="B") || 
		($zone=="C") ||  ($zone=="D") || 
		($zone=="E") ||  ($zone=="F")} {
		set outputFile ${dataDir}/${timeString}_sr_${zone}_s_${num}_LSB.sdds
		set valuesFile /home/helios/oagData/PSSCPDB/setpts/sr/S${num}_bitcheck.sps
	    }

	}
	if {$supply == "Corr"} {
	    if {$zone=="R"} {
		if {$num > 4} { continue }
		set outputFile ${dataDir}/${timeString}_sr_R_c_${num}_LSB.sdds
		set valuesFile /home/helios/oagData/PSSCPDB/setpts/sr/corr_bitcheck.sps
	    }
	    if {($zone=="A") || ($zone=="B") || 
		($zone=="C") || ($zone=="D") || 
		($zone=="E") || ($zone=="F")} {
		if {$num > 4} { continue }
		set outputFile ${dataDir}/${timeString}_sr_${zone}_c_${num}_LSB.sdds
		set valuesFile /home/helios/oagData/PSSCPDB/setpts/sr/corr_bitcheck.sps
	    }
	}
	if {$supply=="Skew"} {
	    APSSetVarAndUpdate status "Selected Test Currently Not Complete"
	    return
	}
	if {$supply=="Trim"} {
	    APSSetVarAndUpdate status "Selected Test Currently Not Complete"
	    return
	}
	if {$supply=="BM"} {
	    if {$num > 1} { continue }
	    set outputFile ${dataDir}/${timeString}_bm_lsb.sdds
	    set valuesFile /home/helios/oagData/PSSCPDB/setpts/sr/bm_lsb.sps
	    APSSetVarAndUpdate status "Selected Test Currently Not Complete"
	    return
	} 


	set outputData "SDDS1\n\n"
	foreach name $PVnames {
	    if {[set $name]} {
		if {[string index [string trim $name :] end] != $num} {
		    continue
		}
		append outputData "&measurement    control_name = \"${name}${controlNameSuffix1}\",\n"
		append outputData "                column_name = \"${name}${columnNameSuffix1}\",\n"
		append outputData "                units = \"Amps Read\",\n"
		append outputData "&end\n\n"
		append outputData "&measurement    control_name = \"${name}${controlNameSuffix2}\",\n"
		append outputData "                column_name = \"${name}${columnNameSuffix2}\",\n"
		append outputData "                units = \"Amps Read\",\n"
		append outputData "&end\n\n"
	    }
	}
	foreach name $PVnames {
	    if {[set $name]} {
		if {[string index [string trim $name :] end] != $num} {
		    continue
		}
		append outputData "&variable       control_name = \"${name}${controlNameSuffix3}\",\n"
		append outputData "                column_name = \"${name}${columnNameSuffix3}\",\n"
		append outputData "                units = \"Amps Set\",\n"
		append outputData "                values_file = \"${valuesFile}\",\n"
		append outputData "                values_file_column = \"SetPoints\",\n"
		append outputData "&end\n\n"
	    }
	}

	append outputData "&execute        post_change_pause = 1,\n"
	append outputData "                rollover_pause = 35,\n"
	append outputData "&end"
	
	set inputFile [APSTmpDir]/[APSTmpString]
	if {[catch {open $inputFile w} fID]} {
	    APSSetVarAndUpdate status "error: problem opening $inputFile : $fID"
	    return
	}
	puts $fID $outputData
	catch {close $fID}
	
	global ${system}${supply}${zone}${num}done
	set ${system}${supply}${zone}${num}done 0
	global execLogInfo
	lappend execLogInfo [APSExecLogMod .lsbWindow \
				 -name "LSB Test" \
				 -width 70 \
				 -unixCommand "sddsexperiment $inputFile $outputFile -verbose=very" \
				 -callback "FinishSRCheck -system $system -supply $supply -zone $zone -num $num -outputFile $outputFile -inputFile $inputFile" \
				 -cancelCallback "APSExecLogStopMod" \
				 -abortCallback "APSExecLogAbortInternalMod"]
	lappend waitVar ${system}${supply}${zone}${num}done
	#tkwait variable ${system}${supply}${zone}${num}done
    }
#    foreach waitVariable $waitVar {
#	tkwait variable $waitVariable
#    }
}

proc FinishSRCheck {args} {
    set system ""
    set supply ""
    set zone ""
    set plot 1
    set outputFile ""
    set inputFile ""
    set num 1
    APSStrictParseArguments {system supply zone plot outputFile inputFile num}
    file delete $inputFile
    if {$plot} {
	set plotCommand [GetPlotCommand -system $system -filename $outputFile]
#	if [catch {eval exec sddsplot $outputFile -group=request -sep=2 -graph=line,vary,connect -leg -title=@TimeStamp $plotCommand &} result] {
#	    APSSetVarAndUpdate status "problem running sddsplot : $result"
#	    return
#	}
	
	if [catch {eval exec sddsplot $outputFile \
		       -group=request \
		       -graph=symbol,vary \
		       -leg \
		       -title=@TimeStamp \
		       $plotCommand &} result] {
	    APSSetVarAndUpdate status "problem running sddsplot : $result"
	    return
	}
    }
#    global ${system}${supply}${zone}${num}done
#    set ${system}${supply}${zone}${num}done 1
    APSSetVarAndUpdate status "Zone ${zone}'s ${supply} output:\n$outputFile\nDone Collecting data on Zone ${zone}'s ${supply}"
    
    set status "Done"
}


proc SetupLSBCheck {args} {
    set system SR
    APSStrictParseArguments {system}
    destroy .userFrame.testbutton .userFrame.supplySelection .userFrame.testSelection .userFrame.auto
    
    wm title . "$system LSB Check"
    set label "Select Supply"
    set valueList2 ""
    set testproc test
    switch -exact -- $system {
	Alcove {
	    set valueList {Quad}
	    set buttonList {Quadrupole}
	    set subdir leutl
	}
	BoosterBypass {
	    set valueList {Quad Corr BM Trip}
	    set buttonList {"Quadrupole" "Corrector" "Dump Dipole" "Beam Dipoles"}
	    set subdir leutl
	}
	BTS {
	    set valueList {Quad Corr BM}
	    set buttonList {"Quadrupole" "Corrector" "Dipole"}
	    set subdir bts
	}
	L1 {
	    set valueList {Quad Corr}
	    set buttonList {"Quadrupole" "Corrector"}
	    set subdir leutl
	}
	LTP {
	    set valueList {Quad Corr BM Bucking}
	    set buttonList {"Quadrupole" "Corrector" "Dipole" "BuckingCoil"}
	    set subdir ltp
	}
	PTB {
	    set valueList {Quad Corr BM Bucking}
	    set buttonList {"Quadrupole" "Corrector" "Dipole" "BuckingCoil"}
	    set subdir ptb
	}
	Linac {
	    set valueList {AM BM 12BitQM 14BitQM SC L3SC SM ALL}
	    set buttonList {"AM" "BM" "12Bit:QM" "14Bit:QM" "SC" "L3:SC" "SM" "ALL"}
	    set subdir linac
	}
	PAR {
	    set valueList {Quad Sext Corr Trim BM}
	    set buttonList {"Quadrupole" "Sextupole" "Corrector" "Trim Dipole" "Dipole"}
	    set subdir par
	}
	PC1 {
	    set valueList {Quad Corr SCCorr BM QE}
	    set buttonList {"Quadrupole" "Corrector" "SC:Corrector" "Dipole" "QE"}
	    set subdir leutl
	}
	ParBypass {
	    set valueList {Quad Corr}
	    set buttonList {"Quadrupole" "Corrector"}
	    set subdir leutl
	}
	RG1 {
	    set valueList {Quad Corr Trim Alpha Heater}
	    set buttonList {"Quadrupole" "Corrector" "Trim" "Alpha" "Heater"}
	    set subdir leutl
	}
	RG2 {
	    set valueList {Quad Corr Trim Alpha Heater}
	    set buttonList {"Quadrupole" "Corrector" "Trim" "Alpha" "Heater"}
	    set subdir leutl
	}
	SR {
	    set valueList {Quad Sext Corr Skew Trim BM}
	    set buttonList {"Quadrupole" "Sextupole" "Corrector" "Skew Quadrupole" "Trim Dipole" "Dipole"}
	    set valueList2 {A B C D E F R}
	    set buttonList2 {"Zone A" "Zone B" "Zone C" "Zone D" "Zone E" "Zone F" "Entire Ring"}
	    set subdir sr
	    set testproc testSR
	}
	Skipline {
	    set valueList {Quad CorrH CorrV}
	    set buttonList {"Quadrupole" "Corrector H" "Corrector V"}
	    set subdir leutl
	}
	Undulators {
	    set valueList {Quad CorrH CorrV}
	    set buttonList {"Quadrupole" "Corrector H" "Corrector V"}
	    set subdir leutl
	}
	default {
	    return
	}
    }
	
    APSRadioButtonFrame .supplySelection \
	-parent .userFrame \
	-orientation vertical \
	-label $label \
	-variable powerSupply \
	-packOption "-side top" \
	-valueList $valueList \
	-buttonList $buttonList \
	-contextHelp "Select location for the test to run."
    
    if {[llength $valueList2]} {
	APSRadioButtonFrame .testSelection \
	    -parent .userFrame \
	    -orientation vertical \
	    -label "Select Zone" \
	    -variable location \
	    -packOption "-side top" \
	    -valueList $valueList2 \
	    -buttonList $buttonList2 \
	    -contextHelp "Select location for the test to run."
    }

    APSButton .testbutton \
	-parent .userFrame \
	-text "Start Test" \
	-packOption "-side top" \
	-command "DisableEnableButtons -state disabled;$testproc -system $system -subdir $subdir;DisableEnableButtons -state normal" \
	-contextHelp "Starts Test in Specified area."

    APSSetVarAndUpdate status "$system system choosen"

}

proc GetPlotCommand {args} {
    set system ""
    set filename ""
    APSStrictParseArguments {system filename}
    global supply
    if {[info exists supply]} {
	set plotCommand "\"-topl=$system $supply LSB Data\" "
    } else {
	set plotCommand "\"-topl=$system LSB Data\" "
    }
    if {[catch {exec sddsquery $filename -columnlist} columns]} {
	catch {puts $columns}
	return
    }
    set columns [lsort $columns]
    set aiColumns ""
    set aoColumns ""
    set dacColumns ""
    foreach column $columns {
	if {([string match *:CurrentAI $column]) ||
	    ([string match *:MeasuredCurrent $column]) ||
	    ([string match *:measCurrAI $column]) ||
	    ([string match *:MeasCurrAI $column])} {
	    lappend aiColumns $column
	} elseif {([string match *:CurrentAO $column]) ||
		  ([string match *:Setpoint $column]) ||
		  ([string match *:setCurrentAO $column]) ||
		  ([string match *:SetCurrAO $column])} {
	    lappend aoColumns $column
	} elseif {([string match *:DacAI $column]) ||
		  ([string match *:DacAO $column])} {
	    lappend dacColumns $column
	}
    }
    if {([llength $aiColumns] == [llength $aoColumns]) &&
	([llength $dacColumns] == [llength $aoColumns])} {
	append plotCommand "-sep=2 "
	foreach ai $aiColumns ao $aoColumns dac $dacColumns {
	    append plotCommand "-col=${ao},${ai} -col=${ao},${dac} -graph=line,type=1,connect "   
	}
    } else {
	append plotCommand "-sep=1 "
	if {([llength $aiColumns] == [llength $aoColumns])} {
	    foreach ai $aiColumns ao $aoColumns {
		append plotCommand "-col=${ao},${ai} "   
	    }
	}
	if {([llength $dacColumns] == [llength $aoColumns])} {
	    foreach dac $dacColumns ao $aoColumns {
		append plotCommand "-col=${ao},${dac} "   
	    }
	}
    }
    return $plotCommand
}

######## Main #######

APSApplication . -name "LSB Tests" \
	-version $CVSRevisionAuthor \
	-overview "Template Application" -contextHelp "Help for Template Application"

APSMenubarAddMenu .system -parent .menu -text System
set systems "PC1 RG1 RG2 L1 Linac LTP PAR PTB BTS"
foreach system $systems {
    .menu.system.menu add command \
        -label $system \
        -command "SetupLSBCheck -system $system"
}
.menu.system.menu add separator
set systems "ParBypass BoosterBypass Alcove Skipline Undulators"
foreach system $systems {
    .menu.system.menu add command \
        -label $system \
        -command "SetupLSBCheck -system $system"
}
.menu.system.menu add separator
set systems "SR"
foreach system $systems {
    .menu.system.menu add command \
        -label $system \
        -command "SetupLSBCheck -system $system"
}

set status "Ready"
APSScrolledStatus .status -parent .userFrame -packOption "-side top" \
	-textVariable status -width 70 -height 8

APSButton .autoRun \
    -parent .userFrame \
    -text "Select systems and supplies to run automatically" \
    -command "SelectAutoRun" \
    -packOption "-side top"


set args $argv
set system SR

if {[llength [APSParseArguments {system}]]} {
    if {[lsearch $systems [lindex $args 0]] != -1} {
	set system [lindex $args 0]
    } else {
	puts stderr "usage: OAGLSBCheck \[-system <string>\]\n[join [split $CVSRevisionAuthor $] ""]"
	exit 1
    }
}

#SetupLSBCheck -system $system

