#!/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)]
set apsttk 1

APSApplication . -name "SCU Operational Statistics"

proc FindQuenches {args} {
    set hscu 1
    set scu1 1
    set scu6 1
    set userMode 1
    set studiesMode 1
    APSStrictParseArguments {hscu scu1 scu6 userMode studiesMode}
    
    global status
    if {!$userMode && !$studiesMode} {
        APSSetVarAndUpdate status "No modes selected"
        return
    }
    
    global StartTime EndTime StartYear EndYear
    set startMonth [clock format $StartTime -format %N]
    set endMonth [clock format $EndTime -format %N]

    set pvList ""
    set intervals ""
    if {$hscu} {
        if {$StartTime < 1513576800} {
            APSSetVarAndUpdate status "Error: HSCU data starts with Run1-2018"
            return
        }
        lappend pvList ID07ds:MainCurrentRdbk
        lappend pvList ID07ds:LHeTankPress
        lappend pvList ID07ds:MagnetTempCent
        lappend pvList ID07ds:MainCurrentSet
        lappend intervals 2 2 2 2
        
        set pressurePV(hscu) ID07ds:LHeTankPress
        set tempPV(hscu) ID07ds:MagnetTempCent
        set onOffPV(hscu) ID07ds:MainCurrentSet
        set currentPV(hscu) ID07ds:MainCurrentRdbk
    }
    if {$scu1} {
        if {$StartTime < 1430283600} {
            APSSetVarAndUpdate status "Error: SCU1 data starts with Run2-2015"
            return
        }
        lappend pvList ID01ds:MainCurrentRdbk
        lappend pvList ID01ds:LHeTankPress
        lappend pvList ID01ds:MagnetTempBotCent
        lappend pvList ID01ds:MainCurrentSet
        lappend intervals 2 2 2 2
        
        set pressurePV(scu1) ID01ds:LHeTankPress
        set tempPV(scu1) ID01ds:MagnetTempBotCent
        set onOffPV(scu1) ID01ds:MainCurrentSet
        set currentPV(scu1) ID01ds:MainCurrentRdbk
    }
    if {$scu6} {
        if {$StartTime < 1355983200} {
            APSSetVarAndUpdate status "Error: SCU6 data starts with Run1-2013"
            return
        }
        if {$StartTime < 1472101200} {
            if {$EndTime > 1472101200} {
                APSSetVarAndUpdate status "Error: SCU6 time frame cannot span over Run2-2016 and Run3-2016 because SCU0 was replaced with SCU6 then."
                return
            }
            lappend pvList ID06ds:MainCoilCurrentRdbk
            lappend pvList ID06ds:Sensor1Press
            lappend pvList ID06ds:MagnetCoreBotCenTemp
            lappend pvList ID06ds:Main_OnOff
            lappend intervals 2 2 2 2

            set pressurePV(scu6) ID06ds:Sensor1Press
            set tempPV(scu6) ID06ds:MagnetCoreBotCenTemp
            set onOffPV(scu6) ID06ds:Main_OnOff
            set currentPV(scu6) ID06ds:MainCoilCurrentRdbk
        } else {
            lappend pvList ID06ds:MainCurrentRdbk
            lappend pvList ID06ds:LHeTankPress
            lappend pvList ID06ds:MagnetTempBotCent
            lappend pvList ID06ds:MainCurrentSet
            lappend intervals 2 2 2 2

            set pressurePV(scu6) ID06ds:LHeTankPress
            set tempPV(scu6) ID06ds:MagnetTempBotCent
            set onOffPV(scu6) ID06ds:MainCurrentSet
            set currentPV(scu6) ID06ds:MainCurrentRdbk
        }
    }


    APSSetVarAndUpdate status "Calculating delivered beam times..."

    SearchForFills -startday [clock format $StartTime -format %d] -startmonth $startMonth -startyear $StartYear \
      -endday [clock format $EndTime -format %d] -endmonth $endMonth -endyear $EndYear

    #T1 and T2 do not look at shutter permit
    global T1 T2
    set timeFilter ""
    set i 0
    foreach t1 $T1 t2 $T2 {
        set t1 [expr $t1 - 600]
        set t2 [expr $t2 + 600]
        if {$i == 0} {
            set timeFilter "-filter=column,Time,${t1},${t2}"
            set i 1
        } else {
            append timeFilter ",Time,${t1},${t2},|"
        }
    }
    #override time filter
    #    set timeFilter "-filter=column,Time,$StartTime,$EndTime"
    #    puts "[clock format $StartTime] - [clock format $EndTime]"
    APSSetVarAndUpdate status "Searching data loggers..."



    if {[file exists /local]} {
        set tmpfile /local/[APSTmpString]
    } else {
        set tmpfile [APSTmpDir]/[APSTmpString]
    }
    set filelist ""
    set i 1
    foreach pv $pvList interval $intervals {
        set f$i ""
        for {set year $StartYear} {$year <= $EndYear} {incr year} {
            for {set month 1} {$month <= 12} {incr month} {
                set m [format %02d $month]
                if {($year == $StartYear) && ($month < $startMonth)} {
                    continue
                }
                if {($year == $EndYear) && ($month > $endMonth)} {
                    continue
                }
                append f$i " [glob -nocomplain /home/helios/oagData/logging/${interval}/${pv}/log-${year}-${m}.xz /home/helios/oagData/logging/${interval}/${pv}/log-${year}-${m}.????]"
                if {($pv == "ID06ds:MainCoilCurrentRdbk") || ($pv == "ID06ds:Sensor1Press") || ($pv == "ID06ds:MagnetCoreBotCenTemp") || ($pv == "ID06ds:Main_OnOff")} {
                    append f$i " [glob -nocomplain /home/helios/oagData/logging/32/${pv}/log-${year}-${m}.xz /home/helios/oagData/logging/32/${pv}/log-${year}-${m}.????]"
                }
            }
        }
        APSSetVarAndUpdate status "Combining files for ${pv}..."
        APSAddToTempFileList ${tmpfile}$i
        if {[catch {eval exec sddscombine [set f$i] -pipe=out -merge -majororder=column | sddsprocess -pipe -filter=column,CAerrors,-.5,.5 $timeFilter | sddsconvert -pipe=in ${tmpfile}$i -delete=column,CAerrors} results]} {
            APSSetVarAndUpdate status "Error1: $results"
            return
        }
        lappend filelist ${tmpfile}$i
        incr i
    }

    APSSetVarAndUpdate status "Combining all PV files..."
    APSAddToTempFileList ${tmpfile}$i
    if {[catch {eval exec sddsxref $filelist -pipe=out -equate=Time "-take=*" -nowarn | sddssort -pipe=in ${tmpfile}$i -col=Time} results]} {
        APSSetVarAndUpdate status "Error2: $results"
        return
    }
    eval file delete $filelist
    
    APSSetVarAndUpdate status "Searching for quenches..."
    
    #file copy -force ${tmpfile}$i /local/bobjunk.sdds

    APSSetVarAndUpdate status "++++++++++++++++++++++++++++++++++++++++++++++++++++++"

    global apsDeliveredTime
    APSSetVarAndUpdate status "Results for [clock format $StartTime -format %D] through [clock format $EndTime -format %D]"
    if {$userMode && $studiesMode} {
        APSSetVarAndUpdate status "Mode: User Operations and Machine Studies"
    } elseif {$userMode} {
        APSSetVarAndUpdate status "Mode: User Operations"
    } else {
        APSSetVarAndUpdate status "Mode: Machine Studies"
    }

    foreach scu "hscu scu1 scu6" {
        if {[set $scu]} {
            if {$StartTime < 1372136400} {
                set pressureLimit .4
                set tempLimit .05
                set tempLimit .04
                set timeLimit 64
            } else {
                set pressureLimit 2
                set tempLimit .3
                set timeLimit 25
            }
            if {[catch {exec sddsprocess ${tmpfile}$i -pipe=out -filter=column,$pressurePV($scu),750,2000 | sddsderiv -pipe -differentiate=$pressurePV($scu) -versus=Time | sddsprocess -pipe -filter=column,$pressurePV($scu)Deriv,$pressureLimit,1000 | sddsbreak -pipe -gapIn=Time,amount=64 | sddsprocess -pipe -process=Time,first,PressureSpike | sdds2stream -pipe=in -para=PressureSpike} pressureSpikeList]} {
                set pressureSpikeList ""
                #APSSetVarAndUpdate status "Error2 $pressureSpikeList"
                #return
            }
            if {[catch {exec sddsprocess ${tmpfile}$i -pipe=out "-filter=column,$pressurePV($scu),750,2000,$tempPV($scu),4,1000,&" | sddsderiv -pipe -differentiate=$tempPV($scu) -versus=Time | sddsprocess -pipe -filter=column,$tempPV($scu)Deriv,${tempLimit},1000 | sddsbreak -pipe -gapIn=Time,amount=64 | sddsprocess -pipe -process=Time,first,TempSpike | sdds2stream -pipe=in -para=TempSpike} tempSpikeList]} {
                set tempSpikeList ""
                #APSSetVarAndUpdate status "Error3a $tempSpikeList"
                #return
            }
            if {[catch {exec sddsprocess ${tmpfile}$i -pipe=out -filter=column,$onOffPV($scu),-.01,.01 | sddsbreak -pipe -gapIn=Time,amount=64 | sddsprocess -pipe -process=Time,first,TurnedOff | sdds2stream -pipe=in -para=TurnedOff} turnedOffList]} {
                set turnedOffList ""
                #APSSetVarAndUpdate status "Error4 $turnedOffList"
                #return
            }
            set quenchTimeList($scu) ""
            set psList ""
            set tsList ""
            foreach ps $pressureSpikeList {
                set found 0
                foreach ts $tempSpikeList {
                    if {[expr abs($ps - $ts)] <= $timeLimit} {
                        set found 1
                        set temperature $ts
                    }
                    if {$found} {
                        lappend psList $ps
                        lappend tsList $temperature
                        break
                    }
                }
            }
            foreach ps $psList ts $tsList {
                set qt [::tcl::mathfunc::min $ps $ts]
                set turnedOff 0
                foreach to $turnedOffList {
                    if {[expr abs($to - $qt)] <= $timeLimit} {
                        set turnedOff 1
                        break
                    }
                }
                if {!$turnedOff} {
                    set found 0
                    foreach t1 $T1 t2 $T2 {
                        if {($qt >= [expr $t1 - 64]) && ($qt <= [expr $t2 + 64])} {
                            set found 1
                        }
                    }
                    if {$found} {
                        #These are events that almost quenched, but didn't
                        #APSSetVarAndUpdate status "Error: $scu was not turned off for the quench at [clock format [expr int($qt)]]"
                    }
                    #return
                } else {
                    set found 0
                    foreach t1 $T1 t2 $T2 {
                        if {($qt >= [expr $t1 - 64]) && ($qt <= [expr $t2 + 64])} {
                            set found 1
                        }
                    }
                    if {$found} {
                        if {[catch {exec sddsprocess ${tmpfile}$i -pipe=out -filter=column,Time,[expr $qt - 33],[expr $qt + 1] | sdds2stream -pipe=in -col=$currentPV($scu)} current]} {
                            APSSetVarAndUpdate status "Error $currentPV($scu)"
                            return
                        }
                        set current [join [split $current \n]]
                        set current [eval tcl::mathfunc::max $current]
                        if {$current < 1} {
                            puts "[clock format [expr int($qt)]] $current"
                        } else {
                            lappend quenchTimeList($scu) $qt
                        }
                    }
                }
            }
            if {$scu == "scu1"} {
                set tag "SCU1"
            } elseif {$scu == "scu6"} {
                set tag "SCU6"
            } elseif {$scu == "hscu"} {
                set tag "HSCU"
            }
            foreach qt $quenchTimeList($scu) {
                APSSetVarAndUpdate status "$tag quenched at [clock format [expr int($qt)]]"
            }
        }

    }
    APSSetVarAndUpdate status "------------------------------------------------------"


    #    file copy ${tmpfile}$i /tmp/bobjunk.sdds
}

proc CombineFiles {args} {
    set scu1 1
    set scu6 1
    set hscu 1
    set userMode 1
    set studiesMode 1
    APSStrictParseArguments {hscu scu1 scu6 userMode studiesMode}
    
    global status
    if {!$userMode && !$studiesMode} {
        APSSetVarAndUpdate status "No modes selected"
        return
    }
    
    global StartTime EndTime StartYear EndYear
    set startMonth [clock format $StartTime -format %N]
    set endMonth [clock format $EndTime -format %N]

    set pvList ""
    set intervals ""
    if {$hscu} {
        if {$StartTime < 1513576800} {
            APSSetVarAndUpdate status "Error: HSCU data starts with Run1-2018"
            return
        }
        lappend pvList ID07ds:MainCurrentRdbk
        lappend pvList ID07ds:LHeTankPress
        lappend intervals 2 2        
    }
    if {$scu1} {
        if {$StartTime < 1430283600} {
            APSSetVarAndUpdate status "Error: SCU1 data starts with Run2-2015"
            return
        }
        lappend pvList ID01ds:MainCurrentRdbk
        lappend pvList ID01ds:LHeTankPress
        lappend intervals 2 2        
    }
    if {$scu6} {
        if {$StartTime < 1355983200} {
            APSSetVarAndUpdate status "Error: SCU6 data starts with Run1-2013"
            return
        }
        if {$StartTime < 1472101200} {
            if {$EndTime > 1472101200} {
                APSSetVarAndUpdate status "Error: SCU6 time frame cannot span over Run2-2016 and Run3-2016 because SCU0 was replaced with SCU6 then."
                return
            }
            lappend pvList ID06ds:MainCoilCurrentRdbk
            lappend pvList ID06ds:Sensor1Press
            lappend intervals 2 2
        } else {
            lappend pvList ID06ds:MainCurrentRdbk
            lappend pvList ID06ds:LHeTankPress
            lappend intervals 2 2
        }
    }


    APSSetVarAndUpdate status "Calculating delivered beam times..."

    SearchForFills -startday [clock format $StartTime -format %d] -startmonth $startMonth -startyear $StartYear \
      -endday [clock format $EndTime -format %d] -endmonth $endMonth -endyear $EndYear

    #T1 and T2 do not look at shutter permit
    #TT1 and TT2 do
    global T1 T2 TT1 TT2
    set timeFilter ""
    set i 0
    foreach t1 $T1 t2 $T2 {
        if {$i == 0} {
            set timeFilter "-filter=column,Time,${t1},${t2}"
            set i 1
        } else {
            append timeFilter ",Time,${t1},${t2},|"
        }
    }

    set timeFilter2 ""
    set i 0
    foreach t1 $TT1 t2 $TT2 {
        if {$i == 0} {
            set timeFilter2 "-filter=column,Time,${t1},${t2}"
            set i 1
        } else {
            append timeFilter2 ",Time,${t1},${t2},|"
        }
    }
    APSSetVarAndUpdate status "Searching data loggers..."



    if {[file exists /local]} {
        set tmpfile /local/[APSTmpString]
    } else {
        set tmpfile [APSTmpDir]/[APSTmpString]
    }
    set filelist ""
    set filelista ""
    set i 1
    foreach pv $pvList interval $intervals {
        set f$i ""
        for {set year $StartYear} {$year <= $EndYear} {incr year} {
            for {set month 1} {$month <= 12} {incr month} {
                set m [format %02d $month]
                if {($year == $StartYear) && ($month < $startMonth)} {
                    continue
                }
                if {($year == $EndYear) && ($month > $endMonth)} {
                    continue
                }
                append f$i " [glob -nocomplain /home/helios/oagData/logging/${interval}/${pv}/log-${year}-${m}.xz /home/helios/oagData/logging/${interval}/${pv}/log-${year}-${m}.????]"
                if {($pv == "ID06ds:MainCoilCurrentRdbk") || ($pv == "ID06ds:Sensor1Press")} {
                    append f$i " [glob -nocomplain /home/helios/oagData/logging/32/${pv}/log-${year}-${m}.xz /home/helios/oagData/logging/32/${pv}/log-${year}-${m}.????]"
                }
            }
        }
        APSSetVarAndUpdate status "Combining files for ${pv}..."
        APSAddToTempFileList ${tmpfile}$i ${tmpfile}${i}a
        if {[catch {eval exec sddscombine [set f$i] -pipe=out -merge -majororder=column | sddsprocess -pipe -filter=column,CAerrors,-.5,.5 $timeFilter | sddsconvert -pipe=in ${tmpfile}$i -delete=column,CAerrors} results]} {
            APSSetVarAndUpdate status "Error1: $results"
            return
        }
        if {[catch {eval exec sddscombine [set f$i] -pipe=out -merge -majororder=column | sddsprocess -pipe -filter=column,CAerrors,-.5,.5 $timeFilter2 | sddsconvert -pipe=in ${tmpfile}${i}a -delete=column,CAerrors} results]} {
            APSSetVarAndUpdate status "Error1: $results"
            return
        }
        lappend filelist ${tmpfile}$i
        lappend filelista ${tmpfile}${i}a
        incr i
    }

    APSSetVarAndUpdate status "Combining all PV files..."
    APSAddToTempFileList ${tmpfile}$i ${tmpfile}${i}a
    if {[catch {eval exec sddsxref $filelist ${tmpfile}$i -equate=Time "-take=*" -nowarn } results]} {
        APSSetVarAndUpdate status "Error2: $results"
        return
    }
    if {[catch {eval exec sddsxref $filelista ${tmpfile}${i}a -equate=Time "-take=*" -nowarn } results]} {
        APSSetVarAndUpdate status "Error2: $results"
        return
    }
    eval file delete $filelist $filelista 
    
    APSSetVarAndUpdate status "++++++++++++++++++++++++++++++++++++++++++++++++++++++"

    global apsDeliveredTime
    APSSetVarAndUpdate status "Results for [clock format $StartTime -format %D] through [clock format $EndTime -format %D]"
    APSSetVarAndUpdate status "APS Delivered Time = [expr int($apsDeliveredTime)] seconds, [format %.2f [expr $apsDeliveredTime / 3600.0]] hours"
    if {$userMode && $studiesMode} {
        APSSetVarAndUpdate status "Mode: User Operations and Machine Studies"
    } elseif {$userMode} {
        APSSetVarAndUpdate status "Mode: User Operations"
    } else {
        APSSetVarAndUpdate status "Mode: Machine Studies"
    }
    global runStartTimes runEndTimes runList
    if {$hscu} {
        if {[catch {exec sddsprocess ${tmpfile}$i -pipe=out \
                      -retain=column,ID07ds:MainCurrentRdbk \
                      -filter=column,ID07ds:MainCurrentRdbk,50,451 \
                      -process=ID07ds:MainCurrentRdbk,count,Count -nowarn | \
                      sdds2stream -pipe=in -parameter=Count} results]} {
            APSSetVarAndUpdate status "Error3: $results"
            return
        }
        set hscuoperatingSeconds [expr $results * 2]
        APSSetVarAndUpdate status "HSCU Operation Time = $hscuoperatingSeconds seconds, [format %.2f [expr $hscuoperatingSeconds / 3600.0]] hours"


        if {[catch {exec sddsprocess ${tmpfile}${i}a -pipe=out \
                      -retain=column,ID07ds:LHeTankPress,ID07ds:MainCurrentRdbk \
                      -filter=column,ID07ds:LHeTankPress,830,2000,ID07ds:MainCurrentRdbk,-10,50,& \
                      -process=ID07ds:LHeTankPress,count,Count -nowarn | \
                      sdds2stream -pipe=in -parameter=Count} results]} {
            APSSetVarAndUpdate status "Error4: $results"
            return
        }
        set hscudowntimeSeconds [expr $results * 2]
        APSSetVarAndUpdate status "HSCU Downtime = $hscudowntimeSeconds seconds, [format %.2f [expr $hscudowntimeSeconds / 3600.0]] hours"
    }
    if {$scu1} {
        if {[catch {exec sddsprocess ${tmpfile}$i -pipe=out \
                      -retain=column,ID01ds:MainCurrentRdbk,Time \
                      -filter=column,ID01ds:MainCurrentRdbk,50,451,Time,0,1671602400,& \
                      -process=ID01ds:MainCurrentRdbk,count,Count -nowarn | \
                      sdds2stream -pipe=in -parameter=Count} results1]} {
            APSSetVarAndUpdate status "Error3: $results1"
            return
        }
        if {[catch {exec sddsprocess ${tmpfile}$i -pipe=out \
                      -retain=column,ID01ds:MainCurrentRdbk,Time \
                      -filter=column,ID01ds:MainCurrentRdbk,50,875,Time,0,1671602400,!,& \
                      -process=ID01ds:MainCurrentRdbk,count,Count -nowarn | \
                      sdds2stream -pipe=in -parameter=Count} results2]} {
            APSSetVarAndUpdate status "Error3: $results2"
            return
        }
        set scu1operatingSeconds [expr ($results1 + $results2) * 2]
        APSSetVarAndUpdate status "SCU1 Operation Time = $scu1operatingSeconds seconds, [format %.2f [expr $scu1operatingSeconds / 3600.0]] hours"

        if {[catch {exec sddsprocess ${tmpfile}${i}a -pipe=out \
                      -retain=column,ID01ds:LHeTankPress,ID01ds:MainCurrentRdbk \
                      -filter=column,ID01ds:LHeTankPress,830,2000,ID01ds:MainCurrentRdbk,-10,50,& \
                      -process=ID01ds:LHeTankPress,count,Count -nowarn | \
                      sdds2stream -pipe=in -parameter=Count} results]} {
            APSSetVarAndUpdate status "Error4a: $results"
            return
        }
        set scu1downtimeSeconds [expr $results * 2]
        APSSetVarAndUpdate status "SCU1 Downtime = $scu1downtimeSeconds seconds, [format %.2f [expr $scu1downtimeSeconds / 3600.0]] hours"
    }
    if {$scu6} {
        if {$StartTime >= 1472101200} {
            if {[catch {exec sddsprocess ${tmpfile}$i -pipe=out \
                          -retain=column,ID06ds:MainCurrentRdbk \
                          -filter=column,ID06ds:MainCurrentRdbk,50,701 \
                          -process=ID06ds:MainCurrentRdbk,count,Count -nowarn | \
                          sdds2stream -pipe=in -parameter=Count} results]} {
                APSSetVarAndUpdate status "Error3: $results"
                return
            }
            set scu6operatingSeconds [expr $results * 2]
            APSSetVarAndUpdate status "SCU6 Operation Time = $scu6operatingSeconds seconds, [format %.2f [expr $scu6operatingSeconds / 3600.0]] hours"


            if {[catch {exec sddsprocess ${tmpfile}${i}a -pipe=out \
                          -retain=column,ID06ds:LHeTankPress,ID06ds:MainCurrentRdbk \
                          -filter=column,ID06ds:LHeTankPress,830,2000,ID06ds:MainCurrentRdbk,-10,50,& \
                          -process=ID06ds:LHeTankPress,count,Count -nowarn | \
                          sdds2stream -pipe=in -parameter=Count} results]} {
                APSSetVarAndUpdate status "Error4: $results"
                return
            }
            set scu6downtimeSeconds [expr $results * 2]

            APSSetVarAndUpdate status "SCU6 Downtime = $scu6downtimeSeconds seconds, [format %.2f [expr $scu6downtimeSeconds / 3600.0]] hours"
        } else {
            if {[catch {exec sddsprocess ${tmpfile}$i -pipe=out \
                          -retain=column,ID06ds:MainCoilCurrentRdbk,Time \
                          -filter=column,ID06ds:MainCoilCurrentRdbk,50,701,Time,0,1370892033,& \
                          -process=ID06ds:MainCoilCurrentRdbk,count,Count | \
                          sdds2stream -pipe=in -parameter=Count} results]} {
                set results 0
            }
            set scu6operatingSeconds [expr $results * 32]

            if {[catch {exec sddsprocess ${tmpfile}$i -pipe=out \
                          -retain=column,ID06ds:MainCoilCurrentRdbk,Time \
                          -filter=column,ID06ds:MainCoilCurrentRdbk,50,701,Time,0,1370892033,!,& \
                          -process=ID06ds:MainCoilCurrentRdbk,count,Count | \
                          sdds2stream -pipe=in -parameter=Count} results]} {
                set results 0
            }
            set scu6operatingSeconds [expr $scu6operatingSeconds + $results * 2]

            APSSetVarAndUpdate status "SCU0 Operation Time = $scu6operatingSeconds seconds, [format %.2f [expr $scu6operatingSeconds / 3600.0]] hours"

            set index [lsearch -exact $runList "Run1-2013"]
            set tlimit [lindex $runEndTimes $index]
            
            if {[catch {exec sddsprocess ${tmpfile}${i}a -pipe=out \
                          -retain=column,ID06ds:Sensor1Press,ID06ds:MainCoilCurrentRdbk,Time \
                          -filter=column,ID06ds:Sensor1Press,830,2000,ID06ds:MainCoilCurrentRdbk,-10,50,&,Time,0,${tlimit},& \
                          -process=ID06ds:Sensor1Press,count,Count -nowarn | \
                          sdds2stream -pipe=in -parameter=Count} results]} {
                set results 0
            }
            set scu6downtimeSeconds [expr $results * 32]

            if {[catch {exec sddsprocess ${tmpfile}${i}a -pipe=out \
                          -retain=column,ID06ds:Sensor1Press,ID06ds:MainCoilCurrentRdbk,Time \
                          -filter=column,ID06ds:Sensor1Press,890,2000,ID06ds:MainCoilCurrentRdbk,-10,50,&,Time,${tlimit},1370892033,& \
                          -process=ID06ds:Sensor1Press,count,Count -nowarn | \
                          sdds2stream -pipe=in -parameter=Count} results]} {
                set results 0
            }
            set scu6downtimeSeconds [expr $scu6downtimeSeconds + $results * 32]

            set index [lsearch -exact $runList "Run1-2014"]
            set tlimit [lindex $runEndTimes $index]
            if {[catch {exec sddsprocess ${tmpfile}${i}a -pipe=out \
                          -retain=column,ID06ds:Sensor1Press,ID06ds:MainCoilCurrentRdbk,Time \
                          -filter=column,ID06ds:Sensor1Press,890,2000,ID06ds:MainCoilCurrentRdbk,-10,50,&,Time,1370892033,${tlimit},& \
                          -process=ID06ds:Sensor1Press,count,Count -nowarn | \
                          sdds2stream -pipe=in -parameter=Count} results]} {
                set results 0
            }
            set scu6downtimeSeconds [expr $scu6downtimeSeconds + $results * 2]

            if {[catch {exec sddsprocess ${tmpfile}${i}a -pipe=out \
                          -retain=column,ID06ds:Sensor1Press,ID06ds:MainCoilCurrentRdbk,Time \
                          -filter=column,ID06ds:Sensor1Press,940,2000,ID06ds:MainCoilCurrentRdbk,-10,50,&,Time,0,${tlimit},!,& \
                          -process=ID06ds:Sensor1Press,count,Count -nowarn | \
                          sdds2stream -pipe=in -parameter=Count} results]} {
                set results 0
            }
            set scu6downtimeSeconds [expr $scu6downtimeSeconds + $results * 2]
            APSSetVarAndUpdate status "SCU0 Downtime = $scu6downtimeSeconds seconds, [format %.2f [expr $scu6downtimeSeconds / 3600.0]] hours"
        }



    }
    APSSetVarAndUpdate status "------------------------------------------------------"
    
    file delete ${tmpfile}$i
}

proc SelectRun {} {
    global selectedRun runStart runEnd
    global StartTextDay StartDay StartTextMonth StartYear StartTime
    global EndTextDay EndDay EndTextMonth EndYear EndTime
    
    if {$selectedRun == "Undefined"} {return}

    set s [expr int($runStart($selectedRun))]
    set StartTextDay [clock format $s -format %a]
    set StartDay [clock format $s -format %d]
    set StartTextMonth [clock format $s -format %b]
    set StartYear [clock format $s -format %Y]
    set StartTime [clock scan "$StartDay $StartTextMonth $StartYear"]
    set s [expr int($runEnd($selectedRun))]
    set EndTextDay [clock format $s -format %a]
    set EndDay [clock format $s -format %d]
    set EndTextMonth [clock format $s -format %b]
    set EndYear [clock format $s -format %Y]
    set EndTime [clock scan "$EndTextMonth $EndDay 23:59:59 $EndYear"]

}

proc SetupGUI {} {
    global status
    set status "Ready..."
    APSScrolledStatus .status \
      -parent .userFrame \
      -textVariable status \
      -withButtons 1 \
      -height 20 \
      -packOption "-fill both -expand true"
    
    ttk::frame .userFrame.cbf
    pack .userFrame.cbf -anchor nw

    global hscu scu1 scu6
    set hscu 1
    set scu1 1
    set scu6 1
    APSCheckButtonFrame .scu \
      -parent .userFrame.cbf \
      -label "SCU Selection" \
      -buttonList {"HSCU" "SCU1" "SCU6"} \
      -variableList "hscu scu1 scu6" \
      -allNone 1 \
      -packOption "-side left -anchor nw"
    
    global userMode studiesMode
    set userMode 1
    set studiesMode 0
    APSCheckButtonFrame .mode \
      -parent .userFrame.cbf \
      -label "Mode Selection" \
      -buttonList {"User Operations Mode" "Machine Studies Mode"} \
      -variableList "userMode studiesMode" \
      -allNone 1 \
      -packOption "-side left -anchor nw"

    ttk::label .tflabel -text "Time Frame"
    ttk::labelframe .userFrame.tf -labelwidget .tflabel
    pack .userFrame.tf -fill x

    if [catch {sdds open /home/helios/oagData/sr/runHistory/runFile} fd] {
	APSSetVarAndUpdate status "error: $fd (ListRuns)"
	bell
	return
    }
    global runStartTimes runEndTimes runList
    set runStartTimes [APSGetSDDSColumn -sddsFD $fd -column StartRun]
    set runEndTimes [APSGetSDDSColumn -sddsFD $fd -column EndRun]
    set runList [APSGetSDDSColumn -sddsFD $fd -column RunName]
    catch {sdds close $fd}
    global runNameList runStart runEnd
    set runNameList Undefined
    set lastEnd ""
    foreach rst $runStartTimes ret $runEndTimes rl $runList {
        if {$rst >= 1355983199.0} {
            lappend runNameList $rl
            if {$lastEnd != ""} {
                if {[clock format [expr int($lastEnd)] -format %T] == "00:00:00"} {
                    set rst $lastEnd
                } else {
                    set rst [expr $lastEnd + 3600]
                }
            }
            set lastEnd $ret
            if {[clock format [expr int($ret)] -format %T] == "00:00:00"} {
                set ret [expr $ret - 1]
            }
            set runStart($rl) $rst
            set runEnd($rl) $ret
        }
    }

    global selectedRun
    ttk::label .userFrame.tf.runlabel -text "Run:"
    ttk::combobox .userFrame.tf.runvalue -textvariable selectedRun -values $runNameList -state readonly
    grid .userFrame.tf.runlabel -row 1 -column 1 -sticky e
    grid .userFrame.tf.runvalue -row 1 -column 2 -sticky ew
    bind .userFrame.tf.runvalue <<ComboboxSelected>> SelectRun


    global StartTextDay StartDay StartTextMonth StartYear StartTime
    global EndTextDay EndDay EndTextMonth EndYear EndTime

    spinbox .userFrame.tf.fromtextday -values "Mon Tue Wed Thu Fri Sat Sun" \
      -width 3 -wrap true -textvariable StartTextDay \
      -command {TimeAdjusted Start %W %s %d} -bg white
    grid .userFrame.tf.fromtextday -row 1 -column 3 -sticky w
    spinbox .userFrame.tf.fromday -from 1 -to 31 -width 2 -wrap true \
      -textvariable StartDay \
      -validate key -vcmd {string is integer %P} \
      -command {TimeAdjusted Start %W %s %d} -bg white
    grid .userFrame.tf.fromday -row 1 -column 4 -sticky w
    spinbox .userFrame.tf.frommonth \
      -values "Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec" \
      -width 3 -wrap true -textvariable StartTextMonth \
      -command {TimeAdjusted Start %W %s %d} -bg white
    grid .userFrame.tf.frommonth -row 1 -column 5 -sticky w
    spinbox .userFrame.tf.fromyear -from 1900 -to 2100 -width 4 -wrap true \
      -textvariable StartYear \
      -validate key -vcmd {string is integer %P} \
      -command {TimeAdjusted Start %W %s %d} -bg white
    grid .userFrame.tf.fromyear -row 1 -column 6 -sticky w    

    bind .userFrame.tf.fromtextday <Return> "TimeAdjustedManually"
    bind .userFrame.tf.fromday <Return> "TimeAdjustedManually"
    bind .userFrame.tf.frommonth <Return> "TimeAdjustedManually"
    bind .userFrame.tf.fromyear <Return> "TimeAdjustedManually"
    set s [clock scan "1/1/2015"]
    set StartTextDay [clock format $s -format %a]
    set StartDay [clock format $s -format %d]
    set StartTextMonth [clock format $s -format %b]
    set StartYear [clock format $s -format %Y]
    set StartTime [clock scan "$StartDay $StartTextMonth $StartYear"]

    spinbox .userFrame.tf.totextday -values "Mon Tue Wed Thu Fri Sat Sun" \
      -width 3 -wrap true -textvariable EndTextDay \
      -command {TimeAdjusted End %W %s %d} -bg white
    grid .userFrame.tf.totextday -row 2 -column 3 -sticky w
    spinbox .userFrame.tf.today -from 1 -to 31 -width 2 -wrap true \
      -textvariable EndDay \
      -validate key -vcmd {string is integer %P} \
      -command {TimeAdjusted End %W %s %d} -bg white
    grid .userFrame.tf.today -row 2 -column 4 -sticky w
    spinbox .userFrame.tf.tomonth \
      -values "Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec" \
      -width 3 -wrap true -textvariable EndTextMonth \
      -command {TimeAdjusted End %W %s %d} -bg white
    grid .userFrame.tf.tomonth -row 2 -column 5 -sticky w
    spinbox .userFrame.tf.toyear -from 1900 -to 2100 -width 4 -wrap true \
      -textvariable EndYear \
      -validate key -vcmd {string is integer %P} \
      -command {TimeAdjusted End %W %s %d} -bg white
    grid .userFrame.tf.toyear -row 2 -column 6 -sticky w

    bind .userFrame.tf.totextday <Return> "TimeAdjustedManually"
    bind .userFrame.tf.today <Return> "TimeAdjustedManually"
    bind .userFrame.tf.tomonth <Return> "TimeAdjustedManually"
    bind .userFrame.tf.toyear <Return> "TimeAdjustedManually"
    set s [clock seconds]
    set EndTextDay [clock format $s -format %a]
    set EndDay [clock format $s -format %d]
    set EndTextMonth [clock format $s -format %b]
    set EndYear [clock format $s -format %Y]
    set EndTime [clock scan "$EndTextMonth $EndDay 23:59:59 $EndYear"]

    button .userFrame.tf.last24 -text "Last 24 Hours" -command "AdjustTimeFrame -option 1day" -pady 0
    grid .userFrame.tf.last24 -row 1 -column 7 -sticky ew -padx 2
    button .userFrame.tf.forward1day -text "Forward 1 Day" -command "AdjustTimeFrame -option 1plus" -pady 0
    grid .userFrame.tf.forward1day -row 1 -column 8 -sticky ew
    button .userFrame.tf.lastweek -text "Last 7 Days" -command "AdjustTimeFrame -option 7days" -pady 0
    grid .userFrame.tf.lastweek -row 2 -column 7 -sticky ew -padx 2
    button .userFrame.tf.backward1day -text "Backward 1 Day" -command "AdjustTimeFrame -option 1minus" -pady 0
    grid .userFrame.tf.backward1day -row 2 -column 8 -sticky ew

    APSButton .run -parent .userFrame \
      -text "Operation Time & Downtime" -width "" \
      -command {CombineFiles -hscu $hscu -scu1 $scu1 -scu6 $scu6 -userMode $userMode -studiesMode $studiesMode}
    
    APSButton .quenches -parent .userFrame \
      -text "Quenches" -width "" \
      -command {FindQuenches -hscu $hscu -scu1 $scu1 -scu6 $scu6 -userMode $userMode -studiesMode $studiesMode}
    
    set pdfs [glob -nocomplain /net/epics-ops/web_roots/ops/statistics/????/????-?/fill_list.pdf]
    if {[llength $pdfs]} {
        APSMenubarAddMenu .fillhistory -text "Fill History" -parent .menu
        set submenus ""
        foreach pdf $pdfs {
            lappend submenus "[file tail [file dir [file dir $pdf]]]"
            lappend fhruns([file tail [file dir [file dir $pdf]]]) [file tail [file dir $pdf]]
        }
        set submenus [lsort -unique -decreasing $submenus]
        foreach sm $submenus {
            menu .menu.fillhistory.menu.run$sm
            .menu.fillhistory.menu add cascade -label $sm -menu .menu.fillhistory.menu.run$sm
            set fhruns($sm) [lsort $fhruns($sm)]
            foreach run $fhruns($sm) {
                .menu.fillhistory.menu.run$sm add command -label $run -command "exec evince /net/epics-ops/web_roots/ops/statistics/${sm}/${run}/fill_list.pdf &"
            }
        }
    } else {
        APSSetVarAndUpdate status "Info: /net/epics-ops/web_roots/ops/statistics is not mounted on this computer."
        APSSetVarAndUpdate status "Info: This is needed to open the fill history reports."
    }

}

proc AdjustTimeFrame {args} {
    APSStrictParseArguments {option}
    global StartTextDay StartDay StartTextMonth StartYear StartTime
    global EndTextDay EndDay EndTextMonth EndYear EndTime
    set s [clock seconds]
    if {($option == "1day") || ($option == "7days")} {
	set EndTextDay [clock format $s -format %a]
	set EndDay [clock format $s -format %d]
	set EndTextMonth [clock format $s -format %b]
	set EndYear [clock format $s -format %Y]
	set EndTime [clock scan "$EndTextMonth $EndDay 23:59:59 $EndYear"]
	if  {$option == "1day"} {
	    set s [expr $s - 60 * 60 * 24]
	} else {
	    set s [expr $s - 60 * 60 * 24 * 7]
	}
	set StartTextDay [clock format $s -format %a]
	set StartDay [clock format $s -format %d]
	set StartTextMonth [clock format $s -format %b]
	set StartYear [clock format $s -format %Y]
	set StartTime [clock scan "$StartTextMonth $StartDay 00:00:00 $StartYear"]
    } elseif {($option == "1plus") || ($option == "1minus")} {
	foreach var "Start End" {
	    if {$option == "1plus"} {
		incr ${var}Time [expr 60 * 60 * 24]
	    } else {
		incr ${var}Time [expr -60 * 60 * 24]
	    }
	    set ${var}TextDay [clock format [set ${var}Time] -format %a]
	    set ${var}Day [clock format [set ${var}Time] -format %d]
	    set ${var}TextMonth [clock format [set ${var}Time] -format %b]
	    set ${var}Year [clock format [set ${var}Time] -format %Y]
	}
    }
}
proc TimeAdjustedManually {args} {
    foreach var "Start End" {
        global ${var}TextDay ${var}Day ${var}TextMonth ${var}Year ${var}Time
        if {$var == "End"} {
	    set ${var}Time [clock scan "[set ${var}TextMonth] [set ${var}Day] 23:59:59 [set ${var}Year]"]
	} else {
	    set ${var}Time [clock scan "[set ${var}Day] [set ${var}TextMonth] [set ${var}Year]"]
	}
        set ${var}TextDay [clock format [set ${var}Time] -format %a]
        set ${var}Day [clock format [set ${var}Time] -format %d]
        set ${var}TextMonth [clock format [set ${var}Time] -format %b]
        set ${var}Year [clock format [set ${var}Time] -format %Y]
    }
}

proc TimeAdjusted {var widget value direction} {
    global ${var}TextDay ${var}Day ${var}TextMonth ${var}Year ${var}Time

    if {[lsearch -glob [lindex [split $widget .] end] "*textday"] != -1} {
        if {$direction == "up"} {
            set direction "+"
        } else {
            set direction "-"
        }
        set ${var}Time [expr "[set ${var}Time] $direction (24 * 60 * 60)"]
        set initTextDay [set ${var}TextDay]
        set ${var}TextDay [clock format [set ${var}Time] -format %a]
        if {$initTextDay != [set ${var}TextDay]} {
            #This is needed for the transition to daylight savings time.
            set ${var}Time [expr "[set ${var}Time] $direction (1 * 60 * 60)"]
            set ${var}TextDay [clock format [set ${var}Time] -format %a]
        }
        set ${var}Day [clock format [set ${var}Time] -format %d]
        set ${var}TextMonth [clock format [set ${var}Time] -format %b]
        set ${var}Year [clock format [set ${var}Time] -format %Y]
    } elseif {[lsearch -glob [lindex [split $widget .] end] "*day"] != -1} {
        if {$direction == "up"} {
            set direction "+"
        } else {
            set direction "-"
        }
        set ${var}Time [expr "[set ${var}Time] $direction (24 * 60 * 60)"]
        set initTextDay [set ${var}TextDay]
        set ${var}TextDay [clock format [set ${var}Time] -format %a]
        if {$initTextDay == [set ${var}TextDay]} {
            #This is needed for the transition to daylight savings time.
            set ${var}Time [expr "[set ${var}Time] $direction (1 * 60 * 60)"]
            set ${var}TextDay [clock format [set ${var}Time] -format %a]
        }
        set ${var}Day [clock format [set ${var}Time] -format %d]
        set ${var}TextMonth [clock format [set ${var}Time] -format %b]
        set ${var}Year [clock format [set ${var}Time] -format %Y]
    } elseif {[lsearch -glob [lindex [split $widget .] end] "*month"] != -1} {
        set month [clock format [set ${var}Time] -format %b]
        set year [clock format [set ${var}Time] -format %Y]
        set s1 [clock scan "$month 01 00:00:00 $year"]
        if {$direction == "up"} {
            if {$month == "Dec"} {
                incr year
            }
        } else {
            if {$month == "Jan"} {
                incr year -1
            }
        }
        set s2 [clock scan "[set ${var}TextMonth] 01 00:00:00 $year"]
        set s [expr {$s2 - $s1 + (60 * 60)}]
        set ${var}Time [expr "[set ${var}Time] + $s"]
        while {[set ${var}TextMonth] != [clock format [set ${var}Time] -format %b]} {
            if {$month == [clock format [set ${var}Time] -format %b]} {
                if {$direction == "up"} {
                    set ${var}Time [expr "[set ${var}Time] + (12 * 60 * 60)"]
                } else {
                    set ${var}Time [expr "[set ${var}Time] - (12 * 60 * 60)"]
                }
            } else {
                if {$direction == "up"} {
                    set ${var}Time [expr "[set ${var}Time] - (12 * 60 * 60)"]
                } else {
                    set ${var}Time [expr "[set ${var}Time] + (12 * 60 * 60)"]
                }
            }
        }
        set ${var}TextDay [clock format [set ${var}Time] -format %a]
        set ${var}Day [clock format [set ${var}Time] -format %d]
        set ${var}TextMonth [clock format [set ${var}Time] -format %b]
        set ${var}Year [clock format [set ${var}Time] -format %Y]
    } elseif {[lsearch -glob [lindex [split $widget .] end] "*year"] != -1} {
        if {([set ${var}Day] == "29") && ([set ${var}TextMonth] == "Feb")} {
            set ${var}Day 28
        }
        set ${var}Time [clock scan "[set ${var}Day] [set ${var}TextMonth] [set ${var}Year]"]
        set ${var}TextDay [clock format [set ${var}Time] -format %a]
    }
    if {$var == "End"} {
	set ${var}Time [clock scan "[set ${var}TextMonth] [set ${var}Day] 23:59:59 [set ${var}Year]"]
    } else {
	set ${var}Time [clock scan "[set ${var}Day] [set ${var}TextMonth] [set ${var}Year]"]
    }
}

proc FindPVDataFiles {args} {
    set ReadbackName ""
    set StartTime [clock scan "Jan 01 00:00:00 1990"]
    set EndTime [clock seconds]
    set startDateList ""
    set endDateList ""
    set SampleIntervals "1 2 4 8 16 32 64 128 256"
    APSStrictParseArguments {ReadbackName StartTime EndTime SampleIntervals startDateList endDateList}

    if {[llength $startDateList]} {
        set StartTime [clock scan "[lindex $startDateList 2]/[lindex $startDateList 3]/[lindex $startDateList 0]"]
    }
    if {[llength $endDateList]} {
        set EndTime [clock scan "23:59:59 [lindex $endDateList 2]/[lindex $endDateList 3]/[lindex $endDateList 0]"]
    }
    
    set fileList ""
    set ReadbackName [join [split $ReadbackName / ] + ]
    set year [clock format $StartTime -format %Y]
    set month [clock format $StartTime -format %m]
    set endyear [clock format $EndTime -format %Y]
    set endmonth [clock format $EndTime -format %m]
    while {($year < $endyear) || (($year == $endyear) && ($month <= $endmonth))} {
        append fileList "[lsort [glob -nocomplain /home/helios/oagData/logging/Variable/[string index ${ReadbackName} 0]/${ReadbackName}/log-${year}-${month}.{gz,xz}]] "
        append fileList "[lsort [glob -nocomplain /home/helios/oagData/logging/\{[join $SampleIntervals ,]\}/${ReadbackName}/log-${year}-${month}.{gz,xz,????}]] "
        if {$month == 12} {
            set month 01
            incr year
        } else {
            scan $month %d month
            incr month
            set month [format %02d $month]
        }
    }
    return $fileList
}

proc SearchForFills {args} {
    global inputFile suppFile
    global minLength

    set Rootname ChargeFast
    set startyear ""
    set startday ""
    set startmonth ""
    set endyear ""
    set endday ""
    set endmonth ""
    APSStrictParseArguments {startday startmonth startyear endday endmonth endyear}


    #  Determine which run this data is from
    set startTime [clock scan ${startmonth}/${startday}/${startyear}]
    set endTime [clock scan ${endmonth}/${endday}/${endyear}]

    if { $startTime > $endTime } {
        return -code error "invalid time"
    }

    if {$startTime >= [clock scan 10/01/2002]} {
        set minLength 1.0
    } elseif {$endTime < [clock scan 10/01/2002]} {
        set minLength 0.5
    } else {
        return -code error "invalid time"
    }
    
    set S35DCCTFiles [FindPVDataFiles -ReadbackName S35DCCT -SampleIntervals 8 \
                        -startDateList [APSFormatDate -year $startyear -month $startmonth -day $startday -dateFormat list] \
                        -endDateList   [APSFormatDate -year $endyear -month $endmonth -day $endday -dateFormat list]]
    set ShutterPermitFiles [FindPVDataFiles -ReadbackName ShutterPermit -SampleIntervals 8 \
                              -startDateList [APSFormatDate -year $startyear -month $startmonth -day $startday -dateFormat list] \
                              -endDateList   [APSFormatDate -year $endyear -month $endmonth -day $endday -dateFormat list]]
    set SRModifiedDesiredModeFiles [FindPVDataFiles -ReadbackName SRModifiedDesiredMode -SampleIntervals 8 \
                                      -startDateList [APSFormatDate -year $startyear -month $startmonth -day $startday -dateFormat list] \
                                      -endDateList   [APSFormatDate -year $endyear -month $endmonth -day $endday -dateFormat list]]

    if {[catch {eval exec sddscombinelogfiles $S35DCCTFiles $ShutterPermitFiles \
                  $SRModifiedDesiredModeFiles -pipe=out | \
                  sddsprocess -pipe=input $inputFile \
                  -filter=col,Time,[clock scan "${startmonth}/${startday}/${startyear}"],[clock scan "23:59:59 ${endmonth}/${endday}/${endyear}"] \
                  -define=param,numRows,n_rows} results]} {
	APSSetVarAndUpdate status "error: $results (SearchForFills)"
	bell
	return
    }

    #  define a parameter that is 10% greater than the number of rows to use in interpolation. This is to ensure that
    #  there are no small gaps in time that were inadvertently created while data was being taken

    set tempRows [APSGetSDDSParameter -fileName $inputFile -parameter numRows]
    set tempRows [expr int([expr $tempRows*1.1])]


    #   perform interpolation. Then filter out all data that was not taken during 'User Mode'
    #   Determine the amount of time that the SR current was greater than 10 ma. Save this 
    #   non-paginated file as tempFile (it will be turned into a file in /tmp)
    if {[catch {exec sddsinterp $inputFile ${suppFile}.2 \
                  -column=Time,* -sequence=$tempRows -forceMonotonic=increasing} results]} {
	APSSetVarAndUpdate status "error: $results (SearchForFills)"
	bell
	return
    }	
    file delete $inputFile

    global userMode studiesMode

    global TT1 TT2
    set TT1 ""
    set TT2 ""
    if {[catch {exec sddsprocess ${suppFile}.2 -pipe=out \
                  -filter=col,SRModifiedDesiredMode,.999,1.001,S35DCCT,50,300.0,&,ShutterPermit,.9,1.1,& \
                  | sddsbreak -pipe -gapIn=Time \
                  | sddsprocess -pipe -noWarnings \
                  -process=Time,first,T1\
                  -process=Time,last,T2 \
                  "-define=param,duration, T2 T1 - 3600.0 /" \
                  -filter=param,duration,-1.0,$minLength,! \
                  | sddscollapse -pipe \
                  | sdds2stream -pipe -col=T1,T2} results]} {
        return -code error $results
    }
    global apsDeliveredTime
    set apsDeliveredTime 0
    foreach "t1 t2" $results {
        lappend TT1 $t1
        lappend TT2 $t2
        set apsDeliveredTime [expr $apsDeliveredTime + ($t2 - $t1)]
    }


    #Ignore the ShutterPermit and the length of the individual fills.
    global T1 T2
    set T1 ""
    set T2 ""
    if {$userMode} {
        if {[catch {exec sddsprocess ${suppFile}.2 -pipe=out \
                      -filter=col,SRModifiedDesiredMode,.999,1.001,S35DCCT,50,300.0,& \
                      | sddsbreak -pipe -gapIn=Time \
                      | sddsprocess -pipe -noWarnings \
                      -process=Time,first,T1\
                      -process=Time,last,T2 \
                      | sddscollapse -pipe \
                      | sdds2stream -pipe -col=T1,T2} results]} {
            return -code error $results
        }
        foreach "t1 t2" $results {
            lappend T1 $t1
            lappend T2 $t2
        }
    }
    if {$studiesMode} {
        if {[catch {exec sddsprocess ${suppFile}.2 -pipe=out \
                      -filter=col,SRModifiedDesiredMode,1.999,4.001,S35DCCT,50,300.0,& \
                      | sddsbreak -pipe -gapIn=Time \
                      | sddsprocess -pipe -noWarnings \
                      -process=Time,first,T1\
                      -process=Time,last,T2 \
                      | sddscollapse -pipe \
                      | sdds2stream -pipe -col=T1,T2} results]} {
            return -code error $results
        }
        foreach "t1 t2" $results {
            lappend T1 $t1
            lappend T2 $t2
        }
    }
    file delete ${suppFile}.2

}

set inputFile /tmp/[APSTmpString]inp
set suppFile /tmp/[APSTmpString]sup

APSAddToTempFileList $inputFile ${inputFile}~ $suppFile

SetupGUI

