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

# $Log: not supported by cvs2svn $
# Revision 1.16  2007/11/01 20:21:59  soliday
# Made changes in injector studies.
#
# Revision 1.15  2007/10/24 19:01:03  soliday
# Improved the interface.
#
# Revision 1.14  2007/09/21 18:30:33  soliday
# Fixed call to APSSetVarAndUpdate.
#
# Revision 1.13  2007/09/20 09:45:30  soliday
# Added plotting support.
#
# Revision 1.12  2007/09/20 09:03:11  soliday
# Changed SR Zone R label to SR Entire Ring and changed it so that it
# is not selected by default.
#
# Revision 1.11  2007/09/20 08:51:35  soliday
# Reordered the power supply listings.
#
# Revision 1.10  2007/09/20 08:16:11  soliday
# Added test for L1:RG1:HTR and L1:RG2:HTR
#
# Revision 1.9  2007/09/19 22:04:13  soliday
# Updated with a lot of changes recommended by Thomas Fors
#
# Revision 1.8  2003/09/03 16:56:17  soliday
# Fixed issues with BLT.
#
# Revision 1.7  2001/12/03 19:49:31  soliday
# Modified so the SkipLine and Undulator tests.
#
# Revision 1.6  2001/10/24 21:15:14  soliday
# It now displays the output directory for easy reference.
#
# Revision 1.5  2001/10/22 22:19:23  soliday
# Removed L2 section.
#
# Revision 1.4  2001/10/19 16:32:12  soliday
# Made some bug fixes.
#
# Revision 1.3  2001/09/17 15:55:02  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:28  soliday
# First commited version.
#
#
# Input directory /home/helios/oagData/PSGROUP/req
# Input directory /home/helios/oagData/PSSCPDB/req/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 debug 0

proc makeDir {pathname} {
    if {[file isdirectory $pathname]} {
        return $pathname
    } elseif {[file exists $pathname]} {
        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 ConvertVMonitorOutputToMonitorOutput {args} {
    set fileName ""
    APSStrictParseArguments {fileName}
    if {[catch {sdds load $fileName sddsData} result]} {
	return -code error "problem reading $fileName (ConvertVMonitorOutputToMonitorOutput): $result"
    }
    foreach parameterName $sddsData(ParameterNames) {
	if {($parameterName == "Step") || ($parameterName == "CAerrors") ||
	    ($parameterName == "Time") || ($parameterName == "TimeOfDay") ||
	    ($parameterName == "DayOfMonth")} {
	    lappend sddsData2(ColumnNames) $parameterName
	    set sddsData2(ColumnInfo.$parameterName) "type SDDS_DOUBLE"
	    set sddsData2(Column.$parameterName) [list $sddsData(Parameter.$parameterName)]
	} else {
	    lappend sddsData2(ParameterNames) $parameterName
	    set sddsData2(Parameter.$parameterName) [list [lindex $sddsData(Parameter.$parameterName) 0]]
	}
    }
    foreach columnName $sddsData(ColumnNames) {
	if {($columnName != "Index") && ($columnName != "Rootname")} {
	    foreach rootnames $sddsData(Column.Rootname) values $sddsData(Column.$columnName) {
		foreach rootname $rootnames value $values {
		    lappend sddsData2(Column.${rootname}${columnName}) $value
		}
	    }
	    foreach rootname [lindex $sddsData(Column.Rootname) 0] {
		lappend sddsData2(ColumnNames) ${rootname}${columnName}
		set sddsData2(ColumnInfo.${rootname}${columnName}) "type SDDS_DOUBLE"
		set sddsData2(Column.${rootname}${columnName}) [list $sddsData2(Column.${rootname}${columnName})]
	    }
	}
    }
    set sddsData2(Layout.DataMode.Mode) binary
    if {[catch {sdds save $fileName sddsData2} result]} {
	return -code error "problem writing $fileName (ConvertVMonitorOutputToMonitorOutput): $result"
    }
}

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 Linac3AM Linac5AM LinacQM LinacSC LinacL3SC LinacSM LinacBM
        set Linac3AM [set Linac5AM [set LinacQM [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
    }
}

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 RG1Trim RG1Alpha RG1Heater
    set RG1Quad [set RG1Corr [set RG1Trim [set RG1Alpha [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 RG2Trim RG2Alpha RG2Heater
    set RG2Quad [set RG2Corr [set RG2Trim [set RG2Alpha [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 Linac3AM Linac5AM LinacQM LinacSC LinacL3SC LinacSM LinacBM
    set Linac3AM [set Linac5AM [set LinacQM [set LinacSC [set LinacL3SC [set LinacSM [set LinacBM $value]]]]]]
    APSCheckButtonFrame .linac \
      -parent .userFrame.auto.injectors \
      -label "        Linac:" \
      -orientation horizontal \
      -buttonList "L3:AM L5:AM BM QM SC L3:SC SM" \
      -variableList "Linac3AM Linac5AM LinacBM LinacQM 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 Sext 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" Dipole} \
      -variableList "SkiplineQuad SkiplineCorrH SkiplineCorrV SkiplineBM"

    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"

    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
set autorunSetup 0
proc AutoRun {} {
    global autorun autorunSetup autorunMeasure autorunFinish abortNow debug
    set abortNow 0
    set systems "Alcove BoosterBypass BTS L1 LTP PTB Linac PAR PC1 ParBypass RG1 RG2 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} {3AM 5AM BM QM 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} {Quad CorrH CorrV BM} {Quad CorrH CorrV}"
    
    set autorun 1
    foreach value "1 0" {
	set autorunSetup $value
	foreach system $systems supplyList $supplies {
	    foreach supply $supplyList {
		global ${system}${supply} powerSupply
		if {[set ${system}${supply}]} {
		    set testproc [SetupAnalogCheck -system $system]
		    DisableEnableButtons -state disabled
		    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
		    eval $testproc 
		}
	    }
	}
	if {$autorunSetup} {
	    #Wait for 20 minutes
	    APSSetVarAndUpdate status "Waiting 20 Minutes For temperature Stability"
	    APSSetVarAndUpdate status "[clock format [clock seconds]]"
	    .userFrame.abort.button configure -state normal
	    if {$debug} {
		APSWaitWithUpdate -waitSeconds 60 -abortVariable abortNow
	    } else {
		APSWaitWithUpdate -waitSeconds 1200 -abortVariable abortNow
	    }
	    .userFrame.abort.button configure -state disabled
	    if {$abortNow} {
		APSSetVarAndUpdate status "Aborted by user"
		DisableEnableButtons -state normal
		return
	    }
	}
    }
    DisableEnableButtons -state normal

    APSSetVarAndUpdate status "Waiting for sddsvmonitor to finish"
    set autorun 0
}

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

    global autorun autorunSetup
    global powerSupply abortNow debug
    set abortNow 0
    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}

    #Make the directory to store the data in
    if [catch {makeDir $dataDir} result] {
	APSSetVarAndUpdate status "$result"
	return
    }

    set timeString [clock format $seconds -format "%H%M%S"]
    
    set PVsuffix CurrentAO
    set PVnames ""
    #initialize all the needed variables
    set inputFileHome /home/helios/oagData/PSGROUP/req
    switch -exact -- $system {
	Alcove {
	    if {$supply=="Quad"} {
		set inputFile ${inputFileHome}/leutl/la_q_a_log.req
		set outputFile ${timeString}_la_q_a_log.sdds
	    }
	}
	BoosterBypass {
	    if {$supply=="Quad"} {
		set inputFile ${inputFileHome}/leutl/bb_q_a_log.req
		set outputFile ${timeString}_bb_q_a_log.sdds
	    }
	    if {$supply=="Corr"} {
		set inputFile ${inputFileHome}/leutl/bb_c_a_log.req
		set outputFile ${timeString}_bb_c_a_log.sdds
	    }
	    if {$supply=="BM"} {
		set inputFile ${inputFileHome}/leutl/bb_d_a_log.req
		set outputFile ${timeString}_bb_d_a_log.sdds
	    }
	    if {$supply=="Trip"} {
		set inputFile ${inputFileHome}/leutl/bb_t_a_log.req
		set outputFile ${timeString}_bb_t_a_log.sdds
	    }
	}
	BTS {
	    if {$supply=="Quad"} {
		set inputFile ${inputFileHome}/bts/bts_q_a_log.req
		set outputFile ${timeString}_bts_q_a_log.sdds
	    }
	    if {$supply=="Corr"} {
		set inputFile ${inputFileHome}/bts/bts_c_a_log.req
		set outputFile ${timeString}_bts_c_a_log.sdds
	    }
	    if {$supply=="BM"} {
		set inputFile ${inputFileHome}/bts/bts_d_a_log.req
		set outputFile ${timeString}_bts_d_a_log.sdds
	    }
	}
	L1 {
	    if {$supply=="Quad"} {
		set inputFile ${inputFileHome}/leutl/l1_q_a_log.req
		set outputFile ${timeString}_l1_q_a_log.sdds
	    }
	    if {$supply=="Corr"} {
		set inputFile ${inputFileHome}/leutl/l1_c_a_log.req
		set outputFile ${timeString}_l1_c_a_log.sdds
	    }
	}
	LTP {
	    if {$supply=="Quad"} {
		set inputFile ${inputFileHome}/ltp/ltp_q_a_log.req
		set outputFile ${timeString}_ltp_q_a_log.sdds
	    }
	    if {$supply=="Corr"} {
		set inputFile ${inputFileHome}/ltp/ltp_c_a_log.req
		set outputFile ${timeString}_ltp_c_a_log.sdds
	    }
	    if {$supply=="BM"} {
		set inputFile ${inputFileHome}/ltp/ltp_d_a_log.req
		set outputFile ${timeString}_ltp_d_a_log.sdds
	    }
	    if {$supply=="Bucking"} {
		set inputFile ${inputFileHome}/ltp/ltp_bc_a_log.req
		set outputFile ${timeString}_ltp_bc_a_log.sdds
	    }
	}
	PTB {
	    if {$supply=="Quad"} {
		set inputFile ${inputFileHome}/ptb/ptb_q_a_log.req
		set outputFile ${timeString}_ptb_q_a_log.sdds
	    }
	    if {$supply=="Corr"} {
		set inputFile ${inputFileHome}/ptb/ptb_c_a_log.req
		set outputFile ${timeString}_ptb_c_a_log.sdds
	    }
	    if {$supply=="BM"} {
		set inputFile ${inputFileHome}/ptb/ptb_d_a_log.req
		set outputFile ${timeString}_ptb_d_a_log.sdds
	    }
	    if {$supply=="Bucking"} {
		set inputFile ${inputFileHome}/ptb/ptb_bc_a_log.req
		set outputFile ${timeString}_ptb_bc_a_log.sdds
	    }
	}
	Linac {
	    if {$supply=="3AM"} {
		set PVsuffix CurrentAO
		set inputFile ${inputFileHome}/linac/AM_log.req
		set outputFile ${timeString}_linac_AM_a_log.sdds
	    }
	    if {$supply=="5AM"} {
		set PVsuffix setCurrentAO
		set inputFile ${inputFileHome}/linac/AM2_log.req
		set outputFile ${timeString}_linac_AM2_a_log.sdds
	    }
	    if {$supply=="BM"} {
		set PVsuffix CurrentAO
		set inputFile ${inputFileHome}/linac/BM_log.req
		set outputFile ${timeString}_linac_BM_a_log.sdds
	    }
	    if {$supply=="QM"} {
		set PVsuffix CurrentAO
		set inputFile ${inputFileHome}/linac/QM_log.req
		set outputFile ${timeString}_linac_QM_a_log.sdds
	    }
	    if {$supply=="SC"} {
		set PVsuffix setCurrentAO
		set inputFile ${inputFileHome}/linac/SC_log.req
		set outputFile ${timeString}_linac_SC_a_log.sdds
	    }
	    if {$supply=="L3SC"} {
		set PVsuffix CurrentAO
		set inputFile ${inputFileHome}/linac/L3SC_log.req
		set outputFile ${timeString}_linac_L3SC_a_log.sdds
	    }
	    if {$supply=="SM"} {
		set PVsuffix setCurrentAO
		set inputFile ${inputFileHome}/linac/SM_log.req
		set outputFile ${timeString}_linac_SM_a_log.sdds
	    }
	}
	PAR {
	    if {$supply=="Quad"} {
		set inputFile ${inputFileHome}/par/par_q_a_log.req
		set outputFile ${timeString}_par_q_a_log.sdds
	    }
	    if {$supply=="Sext"} {
		set inputFile ${inputFileHome}/par/par_s_a_log.req
		set outputFile ${timeString}_par_s_a_log.sdds
	    }
	    if {$supply=="Corr"} {
		set inputFile ${inputFileHome}/par/par_c_a_log.req
		set outputFile ${timeString}_par_c_a_log.sdds
	    }
	    if {$supply=="Trim"} {
		set inputFile ${inputFileHome}/par/par_bmt_a_log.req
		set outputFile ${timeString}_par_bmt_a_log.sdds
	    }
	    if {$supply=="BM"} {
		set inputFile ${inputFileHome}/par/par_d_a_log.req
		set outputFile ${timeString}_par_c_d_log.sdds
	    }
	}
	PC1 {
	    if {$supply=="Corr"} {
		set inputFile ${inputFileHome}/leutl/pc1_c_a_log.req
		set outputFile ${timeString}_pc1_c_a_log.sdds
	    }
	    if {$supply=="SCCorr"} {
		set inputFile ${inputFileHome}/leutl/pc1_scc_a_log.req
		set outputFile ${timeString}_pc1_scc_a_log.sdds
	    }
	    if {$supply=="Quad"} {
		set inputFile ${inputFileHome}/leutl/pc1_q_a_log.req
		set outputFile ${timeString}_pc1_q_a_log.sdds
	    }
	    if {$supply=="BM"} {
		set inputFile ${inputFileHome}/leutl/pc1_d_a_log.req
		set outputFile ${timeString}_pc1_d_a_log.sdds
	    }
	    if {$supply=="QE"} {
		set inputFile ${inputFileHome}/leutl/pc1_qe_a_log.req
		set outputFile ${timeString}_pc1_qe_a_log.sdds
	    }
	}
	ParBypass {
	    if {$supply=="Quad"} {
		set inputFile ${inputFileHome}/leutl/pb_q_a_log.req
		set outputFile ${timeString}_pb_q_a_log.sdds
	    }
	    if {$supply=="Corr"} {
		set inputFile ${inputFileHome}/leutl/pb_c_a_log.req
		set outputFile ${timeString}_pb_c_a_log.sdds
	    }
	}
	RG1 {
	    if {$supply=="Quad"} {
		set inputFile ${inputFileHome}/leutl/rfg1_q_a_log.req
		set outputFile ${timeString}_rfg1_q_a_log.sdds
	    }
	    if {$supply=="Corr"} {
		set inputFile ${inputFileHome}/leutl/rfg1_c_a_log.req
		set outputFile ${timeString}_rfg1_c_a_log.sdds
	    }
	    if {$supply=="Trim"} {
		set inputFile ${inputFileHome}/leutl/rfg1_t_a_log.req
		set outputFile ${timeString}_rfg1_t_a_log.sdds
	    }
	    if {$supply=="Alpha"} {
		set inputFile ${inputFileHome}/leutl/rfg1_a_a_log.req
		set outputFile ${timeString}_rfg1_a_a_log.sdds
	    }
	    if {$supply=="Heater"} {
		set inputFile ${inputFileHome}/leutl/rfg1_h_a_log.req
		set outputFile ${timeString}_rfg1_h_a_log.sdds
	    }
	}
	RG2 {
	    if {$supply=="Quad"} {
		set inputFile ${inputFileHome}/leutl/rfg2_q_a_log.req
		set outputFile ${timeString}_rfg2_q_a_log.sdds
	    }
	    if {$supply=="Corr"} {
		set inputFile ${inputFileHome}/leutl/rfg2_c_a_log.req
		set outputFile ${timeString}_rfg2_c_a_log.sdds
	    }
	    if {$supply=="Trim"} {
		set inputFile ${inputFileHome}/leutl/rfg2_t_a_log.req
		set outputFile ${timeString}_rfg2_t_a_log.sdds
	    }
	    if {$supply=="Alpha"} {
		set inputFile ${inputFileHome}/leutl/rfg2_a_a_log.req
		set outputFile ${timeString}_rfg2_a_a_log.sdds
	    }
	    if {$supply=="Heater"} {
		set inputFile ${inputFileHome}/leutl/rfg2_h_a_log.req
		set outputFile ${timeString}_rfg2_h_a_log.sdds
	    }
	}
	Skipline {
	    if {$supply=="Quad"} {
		set inputFile ${inputFileHome}/leutl/sk_q_a_log.req
		set outputFile ${timeString}_sk_q_a_log.sdds
	    }
	    if {$supply=="CorrH"} {
		set inputFile ${inputFileHome}/leutl/sk_c_h_a_log.req
		set outputFile ${timeString}_sk_c_h_a_log.sdds
	    }
	    if {$supply=="CorrV"} {
		set inputFile ${inputFileHome}/leutl/sk_c_v_a_log.req
		set outputFile ${timeString}_sk_c_v_a_log.sdds
	    }
	    if {$supply=="BM"} {
		set inputFile ${inputFileHome}/leutl/sk_d_a_log.req
		set outputFile ${timeString}_sk_d_a_log.sdds
	    }
	}
	Undulators {
	    set PVsuffix SetCurrAO
	    if {$supply=="Quad"} {
		set inputFile ${inputFileHome}/leutl/un_q_a_log.req
		set outputFile ${timeString}_un_q_a_log.sdds
	    }
	    if {$supply=="CorrH"} {
		set inputFile ${inputFileHome}/leutl/un_c_h_a_log.req
		set outputFile ${timeString}_un_c_h_a_log.sdds
	    }
	    if {$supply=="CorrV"} {
		set inputFile ${inputFileHome}/leutl/un_c_v_a_log.req
		set outputFile ${timeString}_un_c_v_a_log.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 PVvalues [lindex $sddsData(Column.SetPoint) $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
	}
    }
    set names ""
    set values ""
    foreach name $PVnames value $PVvalues {
	if {[set $name]} {
	    lappend names $name
	    lappend values $value
	}
    }
    set PVnames $names
    set PVvalues $values

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

    set names ""
    foreach name $PVnames {
	lappend names ${name}${PVsuffix}
    }

    if {(!$autorun) || ($autorunSetup)} {
	#Ramp the needed power supplies to 90 % of full power
	APSSetVarAndUpdate status "Ramping $system $supply to 90 % of full power"
	eval global $names
	if {[pv linkw $names $names]} {
	    APSSetVarAndUpdate status "unable to connect to PVs"
	    bell
	    return
	}
	foreach name $names value $PVvalues {
	    set $name $value
	}
	if {[pv putw $names]} {
	    global errorCode
	    APSSetVarAndUpdate status "unable to put values to PVs: $errorCode"
	    return
	}
	if {($autorunSetup)} {
	    return
	}
    }
    if {(!$autorun)} {
	global debug
	#Wait for 20 minutes
	APSSetVarAndUpdate status "Waiting 20 Minutes For temperature Stability"
	APSSetVarAndUpdate status "[clock format [clock seconds]]"
	.userFrame.abort.button configure -state normal
	if {$debug} {
	    APSWaitWithUpdate -waitSeconds 60 -abortVariable abortNow
	} else {
	    APSWaitWithUpdate -waitSeconds 1200 -abortVariable abortNow
	}
	.userFrame.abort.button configure -state disabled
	if {$abortNow} {
	    APSSetVarAndUpdate status "Aborted by user"
	    return
	}
    }

    #Modify input file so that only the needed supplies are included
    if [catch {sdds load $inputFile sddsData} result] {
	APSSetVarAndUpdate status "error reading file: $inputFile : $result"
	return	
    }
    if {[lsearch $sddsData(ColumnNames) ListData] == -1} {
	APSSetVarAndUpdate status "invalid input file for sddsvmonitor: missing ListData column"
	return
    }
    set sddsData(Column.ListData) [lreplace $sddsData(Column.ListData) 0 0 $PVnames]
    set tempFile [APSTmpDir]/[APSTmpString]
    if [catch {sdds save $tempFile sddsData} result] {
	APSSetVarAndUpdate status "error writing file: $tempFile : $result"
	return	
    }
    
    if {$debug} {
	set monitorSec 60
    } else {
	set monitorSec 300
    }
    #Collect data
    APSSetVarAndUpdate status "Collecting Data on $system $supply"
    APSExec -unixCommand "sddsvmonitor $tempFile ${dataDir}/${outputFile} -time=$monitorSec,seconds -interval=2,seconds" \
      -callback "FinishCheck -names \"$names\" -system $system -supply $supply -dataDir $dataDir -outputFile $outputFile -tempFile $tempFile"
}

proc GetPlotCommand {args} {
    set system ""
    set filename ""
    APSStrictParseArguments {system filename}
    global supply
    if {[info exists supply]} {
	set plotCommand "\"-topl=$system $supply Analog Check Data\" "
    } else {
	set plotCommand "\"-topl=$system Analog Check 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]) ||
            ([string match *:measCurrentAI $column])} {
	    lappend aiColumns $column
	} elseif {([string match *:CurrentAO $column]) ||
		  ([string match *:Setpoint $column]) ||
		  ([string match *:SetCurrAO $column]) ||
                  ([string match *:setCurrentAO $column])} {
	    lappend aoColumns $column
	} elseif {([string match *:DacAI $column]) ||
		  ([string match *:DacAO $column])} {
	    lappend dacColumns $column
	}
    }
    if {([llength $aiColumns] && [llength $aoColumns] && [llength $dacColumns]) && 
        ([llength $aiColumns] == [llength $aoColumns]) &&
	([llength $dacColumns] == [llength $aoColumns])} {
	append plotCommand "-sep=3 "
	foreach ai $aiColumns ao $aoColumns dac $dacColumns {
	    append plotCommand "-col=Time,(${ao}) -graph=line,type=1,connect -col=Time,(${ai}) -col=Time,(${dac}) "   
	}
    } else {
	append plotCommand "-sep=2 "
	if {([llength $aiColumns] == [llength $aoColumns])} {
	    foreach ai $aiColumns ao $aoColumns {
		append plotCommand "-col=Time,(${ao}) -graph=line,type=1,connect -col=Time,(${ai}) "   
	    }
	}
	if {([llength $dacColumns] == [llength $aoColumns])} {
	    foreach dac $dacColumns ao $aoColumns {
		append plotCommand "-col=Time,(${ao}) -graph=line,type=1,connect -col=Time,(${dac}) "   
	    }
	}
    }
    return $plotCommand
}

proc FinishCheck {args} {
    set names ""
    set system ""
    set supply ""
    set dataDir ""
    set outputFile ""
    set tempFile ""
    APSStrictParseArguments {names system supply dataDir outputFile tempFile}
    file delete $tempFile
    if {[catch {ConvertVMonitorOutputToMonitorOutput -fileName ${dataDir}/${outputFile}} result]} {
	APSSetVarAndUpdate status $result
	return
    }

    APSSetVarAndUpdate status "Data written to\n${dataDir}/${outputFile}\nDone Collecting data on $system $supply\nRamping down power supplies to 0A..."
    eval global $names
    if {[pv linkw $names $names]} {
	APSSetVarAndUpdate status "unable to connect to PVs : $system $supply (FinishCheck)"
	return
    }
    #Set used power supplies to zero
    foreach name $names {
	set $name 0
    }
    if {[pv putw $names]} {
	global errorCode
	APSSetVarAndUpdate status "unable to put values to PVs : $system $supply (FinishCheck) : $errorCode"
    }

    set plotCommand [GetPlotCommand -system $system -filename ${dataDir}/$outputFile]
    if [catch {eval exec sddsplot -ticks=xtime ${dataDir}/$outputFile \
		 -group=request \
		 -graph=symbol,vary \
		 -leg \
		 -title=@TimeStamp \
		 $plotCommand &} result] {
	APSSetVarAndUpdate status "problem running sddsplot : $result"
	return
    }


    #    APSSetVarAndUpdate status "Done\n"
}

proc FinishSRCheck {args} {
    set names ""
    set supply ""
    set zone ""
    set outputFile ""
    set tempFile ""
    set tolerance ""
    set currentSetpoint ""
    set currentTolerance ""
    set magnetType ""
    APSStrictParseArguments {names supply zone outputFile tempFile tolerance currentSetpoint currentTolerance magnetType}

    file delete $tempFile
    APSSetVarAndUpdate status "Data written to\n$outputFile"

    set rampdown 1
    if {$supply == "Quad"} {
	set rampdown 0
	global SRQuadQ1Finished SRQuadQ2Finished SRQuadQ5Finished
	set SRQuad${magnetType}Finished 1
	if {($SRQuadQ1Finished == 1) && ($SRQuadQ2Finished == 1) && ($SRQuadQ5Finished == 1)} {
	    set rampdown 1
	}
    }
    
    if {$rampdown} {
	APSSetVarAndUpdate status "Ramping down power supplies to 0A..."
	eval global $names
	if {[pv linkw $names $names]} {
	    APSSetVarAndUpdate status "unable to connect to PVs : SR $supply $zone (FinishSRCheck)"
	    return
	}
	foreach name $names {
	    set $name 0
	}
	if {[pv putw $names]} {
	    global errorCode
	    APSSetVarAndUpdate status "unable to put values to PVs : SR $supply $zone (FinishSRCheck) : $errorCode"
	    return
	}
    }

    if {[file exists $outputFile]} {
	set reportName [string range $outputFile 0 [expr [string length $outputFile] - 9]]report.txt
	APSSetVarAndUpdate status "Generating reports...\n$reportName"
	if {[catch {
	    exec /home/helios/PSSCPDB/bin/rtest \
              $outputFile $reportName \
              $tolerance $currentSetpoint $currentTolerance $magnetType
	    if {[catch {ConvertVMonitorOutputToMonitorOutput \
                          -fileName $outputFile} result]} {
		APSSetVarAndUpdate status $result
		return
	    }
	} result2]} {
	    APSSetVarAndUpdate status $result2
	    return
	}
	exec dtpad $reportName &

	set plotCommand [GetPlotCommand -system $system -filename $outputFile]
	if [catch {eval exec sddsplot -ticks=xtime $outputFile \
		     -group=request \
		     -graph=symbol,vary \
		     -leg \
		     -title=@TimeStamp \
		     $plotCommand &} result] {
	    APSSetVarAndUpdate status "problem running sddsplot : $result"
	    return
	}

    }
    APSSetVarAndUpdate status "Done\n"
}

set SRQuadQ1Finished 1
set SRQuadQ2Finished 1
set SRQuadQ5Finished 1

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

    global autorun autorunSetup powerSupply location abortNow debug
    set abortNow 0
    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] "
	    append PVvalues "[lindex $sddsData(Column.SetPoint) $count] "
	    set found 1
	    if {$zone != "R"} {
		break
	    }
	}
	incr count
    }
    if {!$found} {
	APSSetVarAndUpdate status "Invalid supply and/or zone specified"
	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
	}
    }
    set names ""
    set values ""
    foreach name $PVnames value $PVvalues {
	if {[set $name]} {
	    lappend names $name
	    lappend values $value
	}
    }
    set PVnames $names
    set PVvalues $values

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

    #Ramp the needed power supplies to 90 % of full power
    set names ""
    set PVsuffix CurrentAO
    foreach name $PVnames {
	lappend names ${name}${PVsuffix}
    }
    eval global $names
    if {[pv linkw $names $names]} {
	APSSetVarAndUpdate status "unable to connect to PVs"
	return
    }
    
    if {(!$autorun) || ($autorunSetup)} {
	APSSetVarAndUpdate status "Ramping $system $supply to 90 % of full power"
	foreach name $names value $PVvalues {
	    set $name $value
	}
	if {[pv putw $names]} {
	    global errorCode
	    APSSetVarAndUpdate status "unable to put values to PVs : $errorCode"
	    return
	}
	if {($autorunSetup)} {
	    return
	}
    }
    if {(!$autorun)} {
	#Wait for 20 minutes
	global debug
	APSSetVarAndUpdate status "Waiting 20 Minutes For temperature Stability"
	APSSetVarAndUpdate status "[clock format [clock seconds]]"
	.userFrame.abort.button configure -state normal
	if {$debug} {
	    APSWaitWithUpdate -waitSeconds 60 -abortVariable abortNow
	} else {
	    APSWaitWithUpdate -waitSeconds 1200 -abortVariable abortNow
	}
	.userFrame.abort.button configure -state disabled
	if {$abortNow} {
	    APSSetVarAndUpdate status "Aborted by user"
	    return
	}
    }
    APSSetVarAndUpdate status "Collecting data..."
    if {$supply == "Quad"} {
	global SRQuadQ1Finished SRQuadQ2Finished SRQuadQ5Finished
	set SRQuadQ1Finished [set SRQuadQ2Finished [set SRQuadQ5Finished 0]]
	foreach num "134 2 5" {
	    #Modify input file so that only the needed supplies are included
	    if [catch {sdds load /home/helios/oagData/PSSCPDB/req/sr/b/sr_${zone}_q_${num}_log.req sddsData} result] {
		APSSetVarAndUpdate status "error reading file: /home/helios/oagData/PSSCPDB/req/sr/b/sr_${zone}_q_${num}_log.req : $result"
		return	
	    }
	    if {[lsearch $sddsData(ColumnNames) ListData] == -1} {
		APSSetVarAndUpdate status "invalid input file for sddsvmonitor: missing ListData column"
		return
	    }
	    set SRPVnames [lindex $sddsData(Column.ListData) 0]
	    set foundPVNames ""
	    foreach name $PVnames {
		if {[lsearch $SRPVnames $name] != -1} {
		    lappend foundPVNames $name
		}
	    }
	    if {[llength $foundPVNames]} {
		set sddsData(Column.ListData) [lreplace $sddsData(Column.ListData) 0 0 $foundPVNames]
		set tempFile [APSTmpDir]/[APSTmpString]
		if [catch {sdds save $tempFile sddsData} result] {
		    APSSetVarAndUpdate status "error writing file: $tempFile : $result"
		    return	
		}
		
		if {$num == 134} {
		    set magnetType Q1
		} elseif {$num == 2} {
		    set magnetType Q2
		} elseif {$num == 5} {
		    set magnetType Q5
		}
		APSExec -unixCommand "sddsvmonitor $tempFile ${dataDir}/${timeString}_sr_${zone}_q_${num}_log.sdds -step=1" \
                  -callback "FinishSRCheck -names \"$names\" -supply $supply -zone $zone -outputFile ${dataDir}/${timeString}_sr_${zone}_q_${num}_log.sdds -tempFile $tempFile -tolerance .30 -currentSetpoint 400 -currentTolerance .01 -magnetType $magnetType"
	    } else {
		if {$num == 134} {
		    set SRQuadQ1Finished 1
		} elseif {$num == 2} {
		    set SRQuadQ2Finished 1
		} elseif {$num == 5} {
		    set SRQuadQ5Finished 1
		}
	    }
	}
    }
    if {$supply == "Sext"} {
	#Modify input file so that only the needed supplies are included
	if [catch {sdds load /home/helios/oagData/PSSCPDB/req/sr/b/sr_${zone}_s_a_log.req sddsData} result] {
	    APSSetVarAndUpdate status "error reading file: /home/helios/oagData/PSSCPDB/req/sr/b/sr_${zone}_s_a_log.req : $result"
	    return	
	}
	if {[lsearch $sddsData(ColumnNames) ListData] == -1} {
	    APSSetVarAndUpdate status "invalid input file for sddsvmonitor: missing ListData column"
	    return
	}
	set sddsData(Column.ListData) [lreplace $sddsData(Column.ListData) 0 0 $PVnames]
	set tempFile [APSTmpDir]/[APSTmpString]
	if [catch {sdds save $tempFile sddsData} result] {
	    APSSetVarAndUpdate status "error writing file: $tempFile : $result"
	    return	
	}
	APSExec -unixCommand "sddsvmonitor $tempFile ${dataDir}/${timeString}_sr_${zone}_s_a_log.sdds -step=1" \
          -callback "FinishSRCheck -names \"$names\" -supply $supply -zone $zone -outputFile ${dataDir}/${timeString}_sr_${zone}_s_a_log.sdds -tempFile $tempFile -tolerance .30 -currentSetpoint 220 -currentTolerance .01 -magnetType S"
    }
    if {$supply == "Corr"} {
	#Modify input file so that only the needed supplies are included
	if [catch {sdds load /home/helios/oagData/PSSCPDB/req/sr/b/sr_${zone}_c_a_log.req sddsData} result] {
	    APSSetVarAndUpdate status "error reading file: /home/helios/oagData/PSSCPDB/req/sr/b/sr_${zone}_c_a_log.req : $result"
	    return	
	}
	if {[lsearch $sddsData(ColumnNames) ListData] == -1} {
	    APSSetVarAndUpdate status "invalid input file for sddsvmonitor: missing ListData column"
	    return
	}
	set sddsData(Column.ListData) [lreplace $sddsData(Column.ListData) 0 0 $PVnames]
	set tempFile [APSTmpDir]/[APSTmpString]
	if [catch {sdds save $tempFile sddsData} result] {
	    APSSetVarAndUpdate status "error writing file: $tempFile : $result"
	    return	
	}
	if [catch {
	    blt::bgexec abortVariable sddsvmonitor \
              $tempFile \
              ${dataDir}/${timeString}_sr_${zone}_c_p_a_log.sdds \
              -step=1
	} result] {
	    APSSetVarAndUpdate status "problem running sddsvmonitor : $result"
	    file delete $tempFile
	    return
	}
	APSSetVarAndUpdate status "Data written to\n${dataDir}/${timeString}_sr_${zone}_c_p_a_log.sdds"

	APSSetVarAndUpdate status "Running all v-corrs & h-corrs to -130A..."
	foreach name $names value $values {
	    set $name [expr {$value * -1}]
	}
	if {[pv putw $names]} {
	    global errorCode
	    APSSetVarAndUpdate status "unable to put values to PVs : $errorCode"
	    file delete $tempFile
	    return
	}
	APSSetVarAndUpdate status "Waiting 4 Minutes For temperature Stability"
	APSSetVarAndUpdate status "[clock format [clock seconds]]"
	.userFrame.abort.button configure -state normal
	global debug
	if {$debug} {
	    APSWaitWithUpdate -waitSeconds 60 -abortVariable abortNow
	} else {
	    APSWaitWithUpdate -waitSeconds 240 -abortVariable abortNow
	}
	.userFrame.abort.button configure -state disabled
	if {$abortNow} {
	    APSSetVarAndUpdate status "Aborted by user"
	    return
	}


	APSSetVarAndUpdate status "Collecting data..."
	APSExec -unixCommand "sddsvmonitor $tempFile ${dataDir}/${timeString}_sr_${zone}_c_n_a_log.sdds -step=1" \
          -callback "FinishSRCheck -names \"$names\" -supply $supply -zone $zone -outputFile ${dataDir}/${timeString}_sr_${zone}_c_n_a_log.sdds -tempFile $tempFile -tolerance .30 -currentSetpoint -130 -currentTolerance .01 -magnetType C"
    }
    if {$supply == "Skew"} {
	#Modify input file so that only the needed supplies are included
	if [catch {sdds load /home/helios/oagData/PSSCPDB/req/sr/b/sr_${zone}_sk_a_log.req sddsData} result] {
	    APSSetVarAndUpdate status "error reading file: /home/helios/oagData/PSSCPDB/req/sr/b/sr_${zone}_sk_a_log.req : $result"
	    return	
	}
	if {[lsearch $sddsData(ColumnNames) ListData] == -1} {
	    APSSetVarAndUpdate status "invalid input file for sddsvmonitor: missing ListData column"
	    return
	}
	set sddsData(Column.ListData) [lreplace $sddsData(Column.ListData) 0 0 $PVnames]
	set tempFile [APSTmpDir]/[APSTmpString]
	if [catch {sdds save $tempFile sddsData} result] {
	    APSSetVarAndUpdate status "error writing file: $tempFile : $result"
	    return	
	}
	APSExec -unixCommand "sddsvmonitor $tempFile ${dataDir}/${timeString}_sr_${zone}_sk_a_log.sdds -step=1" \
          -callback "FinishSRCheck -names \"$names\" -supply $supply -zone $zone -outputFile ${dataDir}/${timeString}_sr_${zone}_sk_a_log.sdds -tempFile $tempFile -tolerance .30 -currentSetpoint 05 -currentTolerance .01 -magnetType SK"
    }

    if [catch {
	if {[file exists ${dataDir}/${timeString}_sr_${zone}_c_p_a_log.sdds]} {
	    exec /home/helios/PSSCPDB/bin/rtest \
              ${dataDir}/${timeString}_sr_${zone}_c_p_a_log.sdds \
              ${dataDir}/${timeString}_sr_${zone}_c_p_report.txt \
              .30 130 .01 C
	    if {[catch {ConvertVMonitorOutputToMonitorOutput \
                          -fileName ${dataDir}/${timeString}_sr_${zone}_c_p_a_log.sdds} result]} {
		APSSetVarAndUpdate status $result
		return
	    }
	}
	if {[file exists ${dataDir}/${timeString}_sr_${zone}_r_a_log.sdds]} {
	    exec /home/helios/PSSCPDB/bin/rtest \
              ${dataDir}/${timeString}_sr_${zone}_r_a_log.sdds \
              ${dataDir}/${timeString}_sr_${zone}_r_report.txt \
              .30 0 0 R
	    if {[catch {ConvertVMonitorOutputToMonitorOutput \
                          -fileName ${dataDir}/${timeString}_sr_${zone}_r_a_log.sdds} result]} {
		APSSetVarAndUpdate status $result
		return
	    }
	}
    } result] {
	APSSetVarAndUpdate status "problem generating reports : $result"
	return
    }
}

proc SetupAnalogCheck {args} {
    set system SR
    APSStrictParseArguments {system}
    destroy .userFrame.testbutton .userFrame.supplySelection .userFrame.testSelection .userFrame.auto
    
    wm title . "$system Analog Check"
    set label "Select Supply"
    set testproc test
    set valueList2 ""
    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 {3AM 5AM BM QM SC L3SC SM}
	    set buttonList {"L3:AM" "L5:AM" "BM" "QM" "SC" "L3:SC" "SM"}
	    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 valueList {Quad Sext Corr Skew}
	    set buttonList {"Quadrupole" "Sextupole" "Corrector" "Skew Quadrupole"}
	    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 BM}
	    set buttonList {"Quadrupole" "Corrector H" "Corrector V" "Dipole"}
	    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 chosen"
    return "$testproc -system $system -subdir $subdir"

}

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

APSApplication . -name "Analog Check"

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 "SetupAnalogCheck -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 "SetupAnalogCheck -system $system"
}
.menu.system.menu add separator
set systems "SR"
foreach system $systems {
    .menu.system.menu add command \
      -label $system \
      -command "SetupAnalogCheck -system $system"
}

set status "This test assumes that the selected supplies are turned on."
APSScrolledStatus .status -parent .userFrame -packOption "-side top" \
  -textVariable status -width 80 -height 8
set status "Output directory /home/helios/oagData/PSGROUP/data/\[year\]\[month\]/\[day\]/"

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

APSButton .abort \
  -parent .userFrame \
  -text "Abort" \
  -command "set abortNow 1" \
  -packOption "-side top"
.userFrame.abort.button configure -state disable
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: OAGAnalogCheck \[-system <string>\]\n[join [split $CVSRevisionAuthor $] ""]"
	exit 1
    }
}

#SetupAnalogCheck -system $system

