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

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)]
APSStandardSetup

set CVSRevisionAuthor "\$Revision: 1.12 $ \$Author: shang $"

set lastPing 0
set runControlPV B:EnergySaveModeRC


proc PingRunControl {args} {
    global lastPing runControlPV abort
    set sec [clock seconds]
    if {[expr $lastPing + 2] > $sec} {
        return
    } else {
        set lastPing $sec
    }
    
    catch {APSRunControlPing} status
    switch $status {
        RUNCONTROL_OK {}
        RUNCONTROL_ABORT {
	    ResumeRampAfterAbort
            return -code error "Auto-correction was aborted."
        }
        RUNCONTROL_TIMEOUT -
        RUNCONTROL_ERROR {
	    ResumeRampAfterAbort
            return -code error "Unable to ping runcontrol record of $runControlPV: $status."
        }
    }
}

set abort 0
proc Abort {args} {
    global runControlPV abort
    set abort 1
    if [catch {APSAbortSRControllaw -runControlPV $runControlPV} result] {
	return -code error $result
    }
    ResumeRampAfterAbort
}

set logDir /home/helios/oagData/booster/ramps/rampTest/log
proc SetStatus {text} {
    global status logDir logFileID
    set status "[exec date] $text"
    update
    return
    set logFile $logDir/[clock format [clock seconds] -format %Y-%j-%m%d].log
    if ![file exist $logFile] {
        if [info exist logFileID] {
            close $logFileID
        }
        set logFileID [open $logFile "w"]
    } else {
        if ![info exist logFileID] {
            set logFileID [open $logFile "a+"]
        }
    }
    puts $logFileID "$text (at [clock format [clock seconds]])"
    flush $logFileID
}

proc PlotData {args} {
    global outputDir rootname rmsPV

    set oldDir [pwd]
    cd $outputDir
    set files [lsort [glob boosterRamp-*.sdds.*]]
    eval exec sddsplot -col=Time,$rmsPV -tick=xtime $files &
    eval exec sddsplot -col=Time,It:Bs:QfVafgTrigAO.VAL -tick=xtime $files &
    eval exec sddsplot -col=Time,B:BM:VoltageRT.GAIN -tick=xtime $files &
    after 4000
    cd $oldDir
}

proc WakeUp {args} {
    set cycle ""
    set topup 1
    APSParseArguments {cycle topup}
    
    global outputDir rootname  cycles waveformMon monFile index sleepTime waitTime correctCycles wakeTime
    global correct monID waveID1 waveID2 wakeToInj voltageWaveformMon currentWaveformMon wakeupLoadSafety
    global corrWaitTime injWaitTime enable disable measMagnet lastWakeupTime logWaveform wakeToInj IRamp rmsPV
    global varList errorCode
    eval global $varList
    
    set outputDir [APSGoToDailyDirectory -subdirectory BRampEnergySave]
    if [catch {PingRunControl} result] {
	return -code error $result
    }
    SetStatus "enable BM ramp."
    if {$corrWaitTime<5} {
        SetStatus "Ramp auto correction can not be less than 5 seconds, reset it to 5."
        set corrWaitTime 5
    }
    set rampEnable 1
    if [pv putw rampEnable] {
        return -code error "Error enable ramp: $errorCode"
    }
    
    set lastWakeupTime [clock seconds]
    set timenow [clock seconds]
    if {$topup} {
        set time [expr $wakeToInj - 1]
    } else {
        set time [expr $wakeTime * 60 - 5]
    }
    
    set timeout [expr [clock seconds] + $corrWaitTime]
    set timeoutInj [expr [clock seconds] + $injWaitTime]
    
    if $measMagnet {
        set file $outputDir/bmon-[clock format [clock seconds] -format %Y-%m%d:%H%M%S].sdds
        SetStatus "run BIrampWaveformMon $file"
        if  [catch {exec BIRampWaveformMon -filename $file} result] {
            return -code error "Error reading booster Iramp waveforms: $result"
        }
        SetStatus "process $file..."
        exec sddsprocess $file -nowarnings -redefine=par,LastWakeupTime,$lastWakeupTime
        set startMon [clock seconds]
    }
    while {1} {
        SetStatus "ping runcontrol..."
	if [catch {PingRunControl} result] {
	    return -code error $result
	}
        SetStatus "Read BMDeltaRms ..."
        if [pv getw BMDeltaIRms] {
            return -code error "Error reading BM delta rms: $errorCode"
        }
        if {$BMDeltaIRms < 0.100 } {
            break 
	}
        if {$measMagnet && [clock seconds]>[expr $startMon + 10]} {
            set file $outputDir/bmon-[clock format [clock seconds] -format %Y-%m%d:%H%M%S].sdds
            SetStatus "Run BIrampWaveformMon $file"
            if  [catch {exec BIRampWaveformMon -filename $file} result] {
                return -code error "Error reading booster Iramp waveforms: $result"
            }
            SetStatus "process $file..."
            exec sddsprocess $file -nowarnings -redefine=par,LastWakeupTime,$lastWakeupTime
            set startMon [clock seconds]
        }
        after 1000
    }
    SetStatus "ping runcontrol..."
    if [catch {PingRunControl} result] {
	return -code error $result
    }
    SetStatus "Turn on injection ..."
    if [catch {TurnOnInjection -topup $topup -timeout $timeoutInj -measMagnet $measMagnet} result] {
        return -code error $result
    }
    SetStatus "Ping runcontrol..."
    if [catch {PingRunControl} result] {
	return -code error $result
    }
    if $wakeupLoadSafety {
	SetStatus "load safety when wake up."
        LoadSafetyWhenWakeup
    }
    set first 1
    set endTime [expr [clock seconds] + $time]
    incr correct
    return
}

proc TurnOnInjection {args} {
    set topup ""
    set timeout ""
    set measMagnet 0
    APSParseArguments {topup timeout measMagnet}

    global outputDir
    set startMon 0
    if [catch {PingRunControl} result] {
	return -code error $result
    }
    while { [clock seconds] < $timeout} {
        after 1000
	if [catch {PingRunControl} result] {
	    return -code error $result
	}
        if {$measMagnet && [clock seconds]>[expr $startMon + 10]} {
            set file $outputDir/bmon-[clock format [clock seconds] -format %Y-%m%d:%H%M%S].sdds
            exec  BIRampWaveformMon -filename $file
            exec sddsprocess $file -nowarnings -redefine=par,LastWakeupTime,$lastWakeupTime
            set startMon [clock seconds]
        }
        update 
    }
    #### turn on injection
    if !$topup {
        SetStatus "enable beam..."
        EnableDisableBeam -enable 1
    }
    if [catch {PingRunControl} result] {
	return -code error $result
    }
}

proc EnableDisableBeam {args} {
    set enable 1
    APSParseArguments {enable}
    global disableEnableBeam beamEnable1 beamEnable2 errorCode
    if !$disableEnableBeam {
        #do nothing (to avoid toggling the RFG gun kicker)
        return
    }
    if $enable {
        set beamEnable1 1
	if [pv putw beamEnable1] {
            return -code error "Error enabling beam (L1:RG1:KIK:chargeTrigC): $errorCode"
        }
        set beamEnable2 1
	if [pv putw beamEnable2] {
            return -code error "Error enabling beam (L1:RG2:KIK:chargeTrigC): $errorCode"
        }
	TogglePulsedMagnetEnables -location GuntoBoosterExt
    } else {
	SetPulsedMagnetEnables -location GuntoBoosterExt -state 0 
    }
}

proc ResumeRampAfterAbort {args} {
    global rampEnable errorCode
    set rampEnable 1
    if [pv putw rampEnable] {
        SetStatus "Error in turn on ramp: $errorcode"
        return -code error "Error in turn on ramp: $errorcode"
    }
}

#BM ramp start PV: It:Ddg4chan0.GATE
set index 0
set pingTimeout 20
proc Start {args} {
    global outputDir rootname  cycles waveformMon monFile index sleepTime waitTime correctCycles wakeTime wakeToInj
    global correct monID waveID1 waveID2 sleepLoadSafety runControlPV pingTimeout topup
    global corrWaitTime injWaitTime enable disable measure measMagnet lastWakeupTime logWaveform abort errorCode
    global varList runNonTopUp cycle
    eval global $varList 

    if !$runNonTopUp {
        if [pv getw topupState] {
            return -code error "Error reading topup state: $errorCode"
        }
        if {$topupState=="Disable"} {
            SetStatus "Nontopup state, energy saver is not requested to run."
            return
        }
    }
    if [catch {APScavput -list=$runControlPV.CLR=1 -pend=20} result] {
        SetStatus $result
        return
    }
    if [catch {APSRunControlInit -pv $runControlPV \
		   -description "Booster Energy Saver" \
		   -timeout [expr $pingTimeout * 1000] } result] {
        SetStatus "Unable to initialize runcontrol for booster energy saver mode, the runcontrol record may not be cleared, press the clear button on the medm screen to clear the record and restart: $result"
        return
    }
    if [catch {PingRunControl} result] {
	SetStatus "$result"
	return
    }
    if {$corrWaitTime<5} {
        SetStatus "Ramp auto correction can not be less than 5 seconds, reset it to 5."
        set corrWaitTime 5
    }
    set waveFile $outputDir/${rootname}-[format %04d $index].sdds.0.waveform
    while {1} {
        if ![file exist $waveFile] {
            break
        }
        incr index
        set waveFile $outputDir/${rootname}-[format %04d $index].sdds.0.waveform
    }

    set autocorrect 0
    set cycle 0
    while {1} {
	if [catch {PingRunControl} result] {
	    SetStatus "$result"
	    break
	}
        if $abort {
            break
        }
        SetStatus "run cycle $cycle..."
        set correct 0
        if [pv getw topupState] {
            ResumeRampAfterAbort
            return -code error "Error reading topup state: $errorCode"
        }
        switch $topupState {
            Enable {
                incr cycle
                if [catch {RunEnergySaverDuringTopUp} result] {
                    SetStatus "Error1: $result"
                    break
                }
            }
            Disable {
                if !$runNonTopUp {
                    ResumeRampAfterAbort
                    SetStatus "Entering non topup state from topup state, resume BM ramp and wait for topup state..."
                    while {1} {
                        #wait for switching back to topup state
                        if $abort {
                            break
                        }
                        if [catch {PingRunControl} result] {
                            SetStatus "$result"
                            return
                        }
                        if [pv getw topupState] {
                            ResumeRampAfterAbort
                            return -code error "Error reading topup state: $errorCode"
                        }
                        update
                        if {$topupState=="Enable"} {
                            break
                        }
                        after 1000
                    }
                } else {
                    incr cycle
                    if [catch {RunEnergySaverDuringNonTopUp} result] {
                        SetStatus "Error2: $result"
                        break
                    }
                }
            }
        }
        after 1000
    }
    set abort 0
    set rampEnable 1
    if [pv putw rampEnable] {
        SetStatus "Error in enabling BM ramp: $result"
    }
    ResumeRampAfterAbort
    SetStatus "done."
    incr index
}

set safetyDir /home/helios/oagData/booster/ramps/safety
foreach magnet {BM QF QD SF SD} {
    set sleep${magnet}Load 0
}
set sleepBMLoad 1
set  sleepQDLoad  0
proc LoadSafetyWhenSleeping {args} {
    global safetyDir sleepBMLoad sleepQFLoad sleepQDLoad sleepSFLoad sleepSDLoad IRamp
    set ramp ""
    foreach magnet {BM QF QD SF SD} {
        if [set sleep${magnet}Load] {
            lappend ramp $magnet
        }
    }
    if [llength $ramp] {
        SetStatus "loading safety ramps for [join $ramp ,] when sleeping..."
        if [catch {APSBoosterLoadSafetyRamp -BM $sleepBMLoad -QF $sleepQFLoad \
                     -QD $sleepQDLoad -SF $sleepSFLoad -SD $sleepSDLoad -IRamp 1 \
                     -statusCallback SetStatus -description "load safety ramps when sleep from energy saver" } result] {
            return -code error $result
        }
        SetStatus "done."
    }
    return
}

set slopeLimit 0.1
proc LoadSafetyWhenWakeup {args} {
    global safetyDir slopeLimit
    SetStatus "loading BM safety ramp after wakeup..."
    if [catch {APSBoosterLoadSafetyRamp -BM 1 -QF 0 \
                 -QD 0 -SF 0 -SD 0 -IRamp 1 \
                 -statusCallback SetStatus -description "load safety ramps when wakeup from energy saver" } result] {
        return -code error $result
    }
    SetStatus "done."
}

proc Info {args} {
    global runControlPV
    exec medm -x -attach -macro "RCPV=$runControlPV" ./sr/psApp/APSRunControlSingle.adl &
}

proc RunEnergySaverDuringTopUp {args} {
    global outputDir rootname  cycles waveformMon monFile index sleepTime waitTime correctCycles wakeTime wakeToInj
    global correct monID waveID1 waveID2 sleepLoadSafety runControlPV pingTimeout topup
    global corrWaitTime injWaitTime enable disable measure measMagnet lastWakeupTime logWaveform abort errorCode abort
    global varList runNonTopUp cycle
    eval global $varList 
    
    if [pv getw topupState] {
        return -code error "Error reading topup state: $errorCode"
    }
    if {$topupState=="Disable"} {
        ResumeRampAfterAbort
        SetStatus "No-topup state, resume BM ramp and exit topup energy saver."
        return
    }
    SetStatus "Entering topup energy saver state..."
    #in topup mode 
    while {1} {
        set firstSleep 1
        set firstWake 1
        if [pv getw topupState] {
            return -code error "Error reading topup state: $errorCode"
        }
        if {$topupState=="Disable"} {
            ResumeRampAfterAbort
            SetStatus "No-topup state, resume BM ramp and exit topup energy saver."
            return
        }
        if [catch {PingRunControl} result] {
            SetStatus "$result"
            ResumeRampAfterAbort
            return -code error "Error ping runcontrol: $result"
        }
        #check the injection time
        if [pv getw injTime] {
            ResumeRampAfterAbort
            return -code error "Error reading injection time: $errorCode"
        }
        set inj [format %.0f $injTime]
        if {$inj==120 || $inj==240} {
            set inj 119
        } else {
            set inj [expr $inj % 120]
        }
        if {$inj>$wakeToInj} {
            if $firstSleep {
                set firstSleep 0
                SetStatus "disable BM ramp."
                set rampEnable 0
                if [pv putw rampEnable] {
                    ResumeRampAfterAbort
                    SetStatus "Error in disabling BM ramp: $result"
                    return -code error "Error disableding BM ramp: $result"
                }
                if [catch {PingRunControl} result] {
                    SetStatus "$result"
                    ResumeRampAfterAbort
                    return -code error "Runcontrol error: $result"
                }
                SetStatus "sleeping..."
                if [catch {LoadSafetyWhenSleeping} result] {
                    SetStatus "Error loading safety ramp while sleeping: $result"
                    ResumeRampAfterAbort
                    return -code error "Error loading safety ramp while sleeping: $result"
                }
            }
            if [pv getw injTime] {
                ResumeRampAfterAbort
                return -code error "Error reading injection time: $errorCode"
            }
            set inj [format %.0f $injTime]
            if {$inj==120 || $inj==240} {
                set inj 119
            } else {
                set inj [expr $inj % 120]
            }
            if {$inj<=$wakeToInj} {
                break
            } else {
                set timeout [expr $inj - $wakeToInj + [clock seconds]]
                while {[clock seconds]<$timeout} {
                    if [catch {PingRunControl} result] {
                        ResumeRampAfterAbort
                        SetStatus "$result"
                        return -code error "Energy control error: $result."
                    }
                    if [pv getw topupState] {
                        return -code error "Error reading topup state: $errorCode"
                    }
                    if {$topupState=="Disable"} {
                        ResumeRampAfterAbort
                        SetStatus "No-topup state, resume BM ramp and exit topup energy saver."
                        return
                    }
                    
                    after 1000
                    update
                }
                if [catch {PingRunControl} result] {
                    ResumeRampAfterAbort
                    SetStatus "$result"
                    return -code error "runcontrol error: $result"
                }
            }
        } else {
            if {$firstSleep && $inj<[expr $wakeToInj -10]} {
                #skip it if there is not enough wake time for the first cycle
                after 1000
                continue
            }
            if [catch {PingRunControl} result] {
                ResumeRampAfterAbort
                SetStatus "$result"
                return -code error "runcontrol error: $result"
            }
            if $firstWake {
                set firstWake 0
                if [catch {WakeUp -cycle $cycle -topup 1} result] {
                    SetStatus "Error in WakeUp: $result"
                    ResumeRampAfterAbort
                    return -code error "Error in wakeup: $result"
                }
                SetStatus "after wakeup."
                if [pv getw injTime] {
                    ResumeRampAfterAbort
                    return -code error "Error reading injection time: $errorCode"
                }
                set inj [format %.0f $injTime]
                if [catch {PingRunControl} result] {
                    SetStatus "$result"
                    return -code error "runcontrol error: $result"
                }
                if {$inj==120 || $inj==240} {
                    set inj 119
                } else {
                    set inj [expr $inj % 120]
                }
                if {$inj>$wakeToInj} {
                    break
                }
                set timeout [expr [clock seconds] + $inj]
                SetStatus "waiting $inj seconds..."
                set startMon [clock seconds]
                while {[clock seconds]<$timeout} {
                    if [catch {PingRunControl} result] {
                        ResumeRampAfterAbort
                        SetStatus "$result"
                        return -code error "runcontrol error: $result"
                    }
                    if [pv getw topupState] {
                        return -code error "Error reading topup state: $errorCode"
                    }
                    if {$topupState=="Disable"} {
                        ResumeRampAfterAbort
                        SetStatus "No-topup state, resume BM ramp and exit topup energy saver."
                        return
                    }
                    
                    if {$measMagnet && [clock seconds]>[expr $startMon + 10]} {
                        set file $outputDir/bmon-[clock format [clock seconds] -format %Y-%m%d:%H%M%S].sdds
                        catch {exec  BIRampWaveformMon -filename $file
                            exec sddsprocess $file -nowarnings -redefine=par,LastWakeupTime,$lastWakeupTime }
                        set startMon [clock seconds]
                    }
                    after 1000
                    update
                }
                if [catch {PingRunControl} result] {
                    ResumeRampAfterAbort
                    SetStatus "$result"
                    return -code error "Error reading topup state: $errorCode"
                }
            }
        }
        if {!$firstSleep && !$firstWake} {
            break
        } else {
            if [catch {PingRunControl} result] {
                ResumeRampAfterAbort
                SetStatus "$result"
                return -code error "Error reading topup state: $errorCode"
            }
            after 1000
            continue
        }
        if [catch {PingRunControl} result] {
            ResumeRampAfterAbort
            SetStatus "$result"
            return -code error "Error reading topup state: $errorCode"
        }
    }
}

proc RunEnergySaverDuringNonTopUp {args} {
    global outputDir rootname  cycles waveformMon monFile index sleepTime waitTime correctCycles wakeTime wakeToInj
    global correct monID waveID1 waveID2 sleepLoadSafety runControlPV pingTimeout 
    global corrWaitTime injWaitTime enable disable measure measMagnet lastWakeupTime logWaveform abort errorCode
    global varList runNonTopUp cycle
    
    eval global $varList 

    if [pv getw topupState] {
        return -code error "Error reading topup state: $errorCode"
    }
    if {$topupState=="Enable"} {
        ResumeRampAfterAbort
        SetStatus "Topup state, resume BM ramp and exit non-topup energy saver."
        return
    }
    if !$runNonTopUp {
        if {$topupState=="Disable"} {
            ResumeRampAfterAbort
            SetStatus "Nontopup state, resume BM ramp and skip."
            return
        }
    }
    SetStatus "Entering non-topup energy saver state..."
    set endTime [expr [clock seconds] + $wakeTime * 60]
    if [catch {WakeUp -cycle $cycle -topup 0} result] {
        ResumeRampAfterAbort
        SetStatus "$result"
        return -code error "Error in wakeup: $result"
    }
    set startMon [clock seconds]
    SetStatus "Waiting ..."
    while {[clock seconds]<$endTime} {
        if [catch {PingRunControl} result] {
            ResumeRampAfterAbort
            SetStatus "$result"
            return -code error "runcontrol error: $result"
        }
        if [pv getw topupState] {
            return -code error "Error reading topup state: $errorCode"
        }
        if {$topupState=="Enable"} {
            ResumeRampAfterAbort
            SetStatus "Topup state, resume BM ramp and exist non-topup energy saver."
            return
        }
        
        if {$measMagnet && [clock seconds]>[expr $startMon + 10]} {
            set file $outputDir/bmon-[clock format [clock seconds] -format %Y-%m%d:%H%M%S].sdds
            catch { exec  BIRampWaveformMon -filename $file
                exec sddsprocess $file -nowarnings -redefine=par,LastWakeupTime,$lastWakeupTime }
            set startMon [clock seconds]
        }
        ### disable beam at end of wake time
        set disable 1
        after 500
        update    
    }
    if [catch {PingRunControl} result] {
        ResumeRampAfterAbort
        SetStatus "$result"
        return -code error "runcontrol error: $result"
    }
        
    SetStatus "Load safety when sleeping."
    if [catch {LoadSafetyWhenSleeping} result] {
        return -code error "Error loading safety ramp: $result"
    }
    
    set endTime [expr [clock seconds] + $sleepTime * 60]
    SetStatus "disable BM ramp."
    set rampEnable 0
    if [pv putw rampEnable] {
        ResumeRampAfterAbort
        SetStatus "Error in disabling BM ramp: $result"
        return -code error "Error in disabling BM ramp: $result"
    }
    if [catch {PingRunControl} result] {
        SetStatus "$result"
        ResumeRampAfterAbort
        return -code error "runcontrol error: $result"
    }
    SetStatus "Sleeping $sleepTime minutes..."
    set disable 1
    ### disable beam while sleeping
    EnableDisableBeam -enable 0
    set first 1
    while {[clock seconds]<$endTime} {
        if [catch {PingRunControl} result] {
            ResumeRampAfterAbort
            SetStatus "$result"
            return -code error "runcontrol error: $result"
        }
        if [pv getw topupState] {
            return -code error "Error reading topup state: $errorCode"
        }
        if {$topupState=="Enable"} {
            ResumeRampAfterAbort
            SetStatus "Topup state, resume BM ramp and exist non-topup energy saver."
            return
        }
        after 500
        update
    }
}
    
         
set monFile /home/helios/oagData/booster/ramps/rampTest/rampTest.mon
set voltageWaveformMon /home/helios/oagData/booster/ramps/rampTest/voltage.wmon
set currentWaveformMon /home/helios/oagData/booster/ramps/rampTest/current.wmon
set outputDir [APSGoToDailyDirectory -subdirectory rampTest]
APSApplication . -name "Booster Energy Save" -version $CVSRevisionAuthor \
  -overview "scan par kickers and setup par kicker timing."

set status "Ready."
set sleepTime 1
set wakeTime 1
set correctCycles 1
set waitTime 30
set cycles 5
 #in minutes units
set wakeToInj 60
set rmsPV B:BM:DeltaIrmsAO 
set rootname boosterIRamp
APSScrolledStatus .status -parent .userFrame -textVariable status \
    -width 70 -height 8


APSLabeledEntry .dir -parent .userFrame -width 70 \
  -label "Output dir: " -textVariable outputDir \
  -contextHelp \
  "Enter a directory in which the output files will be written."
APSButton .dialy -parent .userFrame.dir -text "daily" -size small \
  -command {set outputDir [APSGoToDailyDirectory -subdirectory rampTest]} \
  -packOption "-side right" \
  -contextHelp "Set the output dir to APS daily directory"

APSLabeledEntry .rootname -parent .userFrame -width 70 \
  -label "Output rootname: " -textVariable rootname \
  -contextHelp \
  "Enter a rootname for generation of the output filenames."

set width 21
set steps 5
set BM 1
set QF 0
set QD 0
set enable 0
set disable 0
set sleepLoadSafety 0
set wakeupLoadSafety 0
set corrWaitTime 25
set injWaitTime 30 
set logWaveform 0
#set logFile /home/helios/oagData/booster/ramps/rampTest/rampTest.log
#set rampLogFileID [open $logFile "a+"]

#APSLabeledEntry .cycles -parent .userFrame -width $width -label "Number of cycles for each ramp auto correction:" \
#  -textVariable correctCycles 
APSLabeledEntry .steps -parent .userFrame -width $width -label "Number to cycles to test:" -textVariable cycles
APSFrameGrid .grid -parent .userFrame -xList {x1 x2}
set w1 .userFrame.grid.x1
set w2 .userFrame.grid.x2
APSFrame .f -parent $w1 -label "Non-topup parameters"
APSLabeledEntry .interval -parent $w1.f.frame -width $width -label "Ramp sleep time (minutes):" \
    -textVariable sleepTime
APSLabeledEntry .wake -parent $w1.f.frame -width $width -label "Ramp wake time (minutes):" \
    -textVariable wakeTime
APSFrame .f -parent $w2 -label "Topup parameters"
APSLabeledEntry .inj -parent $w2.f.frame -label "Wakeup to injection time (seconds):" -textVariable wakeToInj \
  -width $width -contextHelp "define the wakeup time, i.e., wake up when the time to injection is less than the given number."


#APSCheckButtonFrame .sleep -parent .userFrame -label "Load safety ramp when sleep for selected magnet:" \
#  -buttonList {BM QF QD SF SD} -variableList {sleepBMLoad sleepQFLoad sleepQDLoad sleepSFLoad sleepSDLoad} \
#  -orientation horizontal -allNone 1

APSCheckButtonFrame .sleep -parent .userFrame -label "Load safety ramp when sleep for selected magnet:" \
  -buttonList {BM QF QD} -variableList {sleepBMLoad sleepQFLoad sleepQDLoad} \
  -orientation horizontal -allNone 1

APSRadioButtonFrame .wake -parent .userFrame -label "Load safety ramp when wakeup?" \
  -buttonList {Yes No} -variable wakeupLoadSafety -valueList {1 0} -orientation horizontal
APSLabeledEntry .wait -parent .userFrame -label "Wait time for ramp correction after wakeup:" -width 15 \
    -textVariable corrWaitTime
APSLabeledEntry .waitInj -parent .userFrame -label "Wait time for turning on injection:" -width 15 \
  -textVariable injWaitTime
APSCheckButtonFrame .ramp -parent .userFrame -buttonList {BM QF QD} -variableList {BM QF QD} -label "select supplies for on/off toggling:" \
  -allNone 1 -orientation horizontal
set measMagnet 0
APSRadioButtonFrame .mag -parent .userFrame -label "Measurement magnetic parameters?" -buttonList {Yes No} \
  -valueList {1 0} -variable measMagnet -orientation horizontal
APSRadioButtonFrame .wav -parent .userFrame -label "Log Waveform file?" -buttonList {Yes No} \
  -valueList {1 0} -variable logWaveform -orientation horizontal
set disableEnableBeam 0
APSRadioButtonFrame .beam -parent .userFrame -label "Disable/Enable beam at non-topup mode?" \
  -variable disableEnableBeam -buttonList {Yes No} -valueList {1 0} \
  -orientation horizontal -contextHelp "choose wether to enable/disable beam when turn on/off BM at non-topup mode."
set runNonTopUp 0
APSRadioButtonFrame .nontopup -parent .userFrame -label "Run energy saver at non topup?" -buttonList {Yes No} \
    -variable runNonTopUp -valueList {1 0} -orientation horizontal

APSButton .start -parent .userFrame -text "Start" -command "Start"
APSButton .abort -parent .userFrame -text "Abort" -command "Abort"
APSButton .plot -parent .userFrame -text "Plot" -command "PlotData"
APSButton .enable -parent .userFrame -text "Enable BTS beam" -command "set enable 1;APScavput -list=L1:RG1:KIK:chargeTrigC=1,L1:RG2:KIK:chargeTrigC=1;TogglePulsedMagnetEnables -location GuntoBoosterExt"
APSButton .disable -parent .userFrame -text "Disable BTS beam" -command "set disable 1;SetPulsedMagnetEnables -location BoosterExt"
APSButton .info -parent .userFrame -text "Info" -command "Info"

#do not consider VRamp anymore -- IRamp is in operation

set pvList {It:Ddg4chan0.GATE Mt:TopUpAutoEnableC.VAL Mt:TopUpTime2Inject.VAL B:BM:DeltaIrmsAO L1:RG1:KIK:chargeTrigC L1:RG2:KIK:chargeTrigC }
set varList {rampEnable topupState injTime BMDeltaIRms beamEnable1 beamEnable2 }
if [pv linkw $varList $pvList] {
    puts stderr "Error linking pvs: $errorcode"
    exit 1
}

