#!/bin/sh  
# \
  exec oagtclsh "$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)]
APSDebugPath
APSStandardSetup

set args $argv
set debug 0
set localTest 0
set runOnce 0
# This should revert to 0 once we have live beamsize measurements
set forceRun 1
if {[APSStrictParseArguments {debug localTest forceRun runOnce}]} {
    return -code error "usage: startSddspcas \[-debug 1\] \[-localTest 1\] \[-forceRun 1\]"
}

set modelPath $OAGGlobal(SRCalibratedModelsDirectory)/default
# Use the design lattice for now until there are calibrated models available
set modelPath $OAGGlobal(SRLatticesDirectory)/default

set scriptDataPath $OAGGlobal(OAGLoggingDirectory)/SRSourceParameters
set webDataPath $OAGGlobal(OAGWebDirectory)/SRSourceParameters

if $localTest {
    set scriptDataPath .
    set webDataPath .
    set debug 1
    set forceRun 1
}

cd $scriptDataPath
set logFile computeSourceSizes.log

proc sendToLogFile {text} {
    global logFile logFileFD
    if ![file exists $logFile] {
        exec echo "[clock format [clock seconds]]: $text" > $logFile 
    } else {
        exec echo "[clock format [clock seconds]]: $text" >> $logFile 
    }
}

proc updateSourcePointData {args} {
    global modelPath scriptDataPath webDataPath debug localTest forceRun OAGGlobal
    
    if {!$localTest && [catch {APSRunControlPing} result]} {
        puts stderr "Ending via ping from runControl"
        exit 1
    }
    set ptime [clock seconds]

    # Check for valid files
    if ![file exists $modelPath/aps.twi] {
        sendToLogFile "not found: $modelPath/aps.twi"
        if $debug {puts stderr "not found: $modelPath/aps.twi" }
        catch {exec sddscasr $scriptDataPath/computeSourceSizes.pcas -restore &}
        return 
    }
    if {[expr {[clock seconds] - $ptime}] > 1} {
        if {!$localTest && [catch {APSRunControlPing} result]} {
            puts stderr "Ending via ping from runControl"
            exit 1
        }
        set ptime [clock seconds]
    }

    # Get the current and machine mode
    set ts [clock format [clock seconds]]
    if [catch {exec cavget -list=S-DCCT:CurrentM,S:ActualMode -num} resultList] {
        sendToLogFile "error: $resultList"
        if $debug {puts stderr "error: $resultList" }
        catch {exec sddscasr $scriptDataPath/computeSourceSizes.pcas -restore &}
        return 
    }
    if {[expr {[clock seconds] - $ptime}] > 1} {
        if {!$localTest && [catch {APSRunControlPing} result]} {
            puts stderr "Ending via ping from runControl"
            exit 1
        }
        set ptime [clock seconds]
    }

    # See if machine is stored or delivered beam mode and has at least 10 mA
    set current [lindex $resultList 0]
    set mode [lindex $resultList 1]
    if {$current == "?"} {
        return
    }
    if {$mode == "?"} {
        return
    }
    if {!$forceRun && (($mode!=4 && $mode!=3) || [expr $current<10.0])} {
        sendToLogFile "mode=$mode (need 3 or 4), current=$current (need >=10mA)"
        if $debug {puts stderr "mode=$mode (need 3 or 4), current=$current (need >=10mA)" }
        catch {exec sddscasr $scriptDataPath/computeSourceSizes.pcas -restore &}
        return 
    }

    # assume round-beam emittances 
    if [catch {exec sddsprocess $modelPath/aps.twi -pipe=out "-define=param,kappa,1" \
                 "-define=param,ex,ex0 1 kappa Jx / + /,units=m" "-define=param,ey,ex kappa *,units=m" \
                 | sdds2stream -pipe -parameter=ex,ey} emittanceList] {
        sendToLogFile "error: $emittanceList"
        if $debug {puts stderr "error: $emittanceList" }
        catch {exec sddscasr $scriptDataPath/computeSourceSizes.pcas -restore &}
        return 
    }
    set xEmittance [lindex $emittanceList 0]
    set yEmittance [lindex $emittanceList 1]
    if {$xEmittance == "?"} {
        return
    }
    if {$yEmittance == "?"} {
        return
    }
    set current [format %.2f $current]

    if {[expr {[clock seconds] - $ptime}] > 1} {
        if {!$localTest && [catch {APSRunControlPing} result]} {
            puts stderr "Ending via ping from runControl"
            exit 1
        }
        set ptime [clock seconds]
    }

    if {0} {
        # To be updated once we have live beamsize measurements
        # See if the x and y emittance values are positive
        if !$localTest {
            if {($xEmittance <0) || ($yEmittance <0)} {
                sendToLogFile "xEmittance=$xEmittance (need positive), yEmittance=$yEmittance (need positive)"
                if $debug {puts stderr "xEmittance=$xEmittance (need positive), yEmittance=$yEmittance (need positive)" }
                catch {exec sddscasr $scriptDataPath/computeSourceSizes.pcas -restore &}
                return         
            }
        }
    }

    # ID computations.  Make three files:
    # sourcePointDataID.sdds --- SDDS file with beam sizes and Twiss parameters at IDs
    # sourcePointSizesID-1.tex --- LaTeX table with beam sizes
    # sourcePointSizesID-2.tex --- LaTeX table with Twiss parameters
    set nominalCoupling 0.1
    if [catch \
          {exec sddsprocess $modelPath/aps.twi sourcePointDataID.sdds -nowarn \
             "-define=parameter,exMeas,$xEmittance 1e12 *,units=pm" \
             "-define=parameter,eyMeas,$yEmittance 1e12 *,units=pm" \
             "-define=parameter,ex,$xEmittance,units=m" \
             "-define=parameter,ey,$yEmittance,units=m" \
             -match=column,ElementName=S??END -match=column,ElementType=MARK* \
             -edit=column,SourcePointName,ElementName,%/END/ID/ \
             "-define=column,Sx,ex betax * etax Sdelta0 * sqr + sqrt 1e6 *,units=um" \
             "-define=column,Sxp,ex 1 alphax sqr + * betax /  etaxp Sdelta0 * sqr + sqrt 1e6 *,units=urad" \
             "-define=column,Sxpx,ex alphax * chs  Sdelta0 sqr etax * etaxp * + 1e12 * ,units=um*urad" \
             "-define=column,exEffective,Sx Sxp * sqr Sxpx sqr - 0 < ? 1e-15 : pop sqrt $,units=pm" \
             "-define=column,Sy,ey betay * etay Sdelta0 * sqr + sqrt 1e6 *,units=um" \
             "-define=column,Syp,ey 1 alphay sqr + * betay /  etayp Sdelta0 * sqr + sqrt 1e6 *,units=urad" \
             "-define=column,Sypy,ey alphay * chs  Sdelta0 sqr etay * etayp * + 1e12 * ,units=um*urad" \
             "-define=column,eyEffective,Sy Syp * sqr Sypy sqr - 0 < ? 0 : pop sqrt $,units=pm" \
             "-define=column,couplingEffective,eyEffective exEffective / 100 *,units=%" \
             "-define=param,kappa,$nominalCoupling" \
             "-define=param,exNom,ex0 1 kappa Jx / + /,units=m" "-define=param,eyNom,exNom kappa *,units=m" \
             "-define=column,Sx0,exNom betax * etax Sdelta0 * sqr + sqrt 1e6 *,units=um" \
             "-define=column,Sxp0,exNom 1 alphax sqr + * betax /  etaxp Sdelta0 * sqr + sqrt 1e6 *,units=urad" \
             "-define=column,Sxpx0,exNom alphax * chs  Sdelta0 sqr etax * etaxp * + 1e12 * ,units=um*urad" \
             "-define=column,exEffective0,Sx0 Sxp0 * sqr Sxpx0 sqr - 0 < ? 1e-15 : pop sqrt $,units=pm" \
             "-define=column,Sy0,eyNom betay * etay Sdelta0 * sqr + sqrt 1e6 *,units=um" \
             "-define=column,Syp0,eyNom 1 alphay sqr + * betay /  etayp Sdelta0 * sqr + sqrt 1e6 *,units=urad" \
             "-define=column,Sypy0,eyNom alphay * chs  Sdelta0 sqr etay * etayp * + 1e12 * ,units=um*urad" \
             "-define=column,eyEffective0,Sy0 Syp0 * sqr Sypy0 sqr - 0 < ? 0 : pop sqrt $,units=pm" \
             "-define=column,couplingEffective0,eyEffective0 exEffective0 / 100 *,units=%" \
             "-print=parameter,TimeStamp,$ts" \
             -scan=column,ID,SourcePointName,S%ld,type=long \
             -filter=column,ID,0.5,35.5} result] {
        sendToLogFile "$result"
        if $debug {puts stderr "$result" }
        APSSendEMail -address soliday -message "Warning: computeSourceSizes: $result" 
        catch {exec sddscasr $scriptDataPath/computeSourceSizes.pcas -restore}
        exit 1
    }


    if [catch \
          {exec sddsprintout sourcePointDataID.sdds sourcePointSizesID-1.tex -latexFormat \
             "-title=Round-beam source point data generated $ts for I=$current mA\\, along with nominal flat-beam (0) values." \
             -column=SourcePointName,label=Name \
             -column=exEffective,format=%5.2f,label=exEff \
             -column=couplingEffective,format=%5.1f,label=CplngEff \
             -column=Sx,format=%5.1f \
             -column=Sxp,format=%5.1f \
             -column=Sy,format=%5.1f \
             -column=Syp,format=%5.1f \
             -column=exEffective0,format=%5.2f,label=exEff0 \
             -column=couplingEffective0,format=%5.1f,label=CplngEff0 \
             -column=Sx0,format=%5.1f \
             -column=Sxp0,format=%5.1f \
             -column=Sy0,format=%5.1f \
             -column=Syp0,format=%5.1f 
              exec  sddsprintout sourcePointDataID.sdds sourcePointSizesID-2.tex -latexFormat \
             "-title=Source Point Data Generated $ts for I=$current mA" \
             -column=SourcePointName,label=Name \
             -column=betax,format=%5.1f \
             -column=alphax,format=%5.3f \
             -column=etax,format=%5.3f \
             -column=etaxp,format=%6.3f \
             -column=betay,format=%5.1f \
             -column=alphay,format=%5.3f \
             -column=etay,format=%5.3f \
             -column=etayp,format=%6.3f \
         } result] {
        sendToLogFile "$result"
        if $debug {puts stderr "$result" }
        APSSendEMail -address soliday -message "Warning: computeSourceSizes: $result" 
        catch {exec sddscasr $scriptDataPath/computeSourceSizes.pcas -restore}
        exit 1
    }
    set latexList ""
    lappend latexList sourcePointSizesID-1.tex sourcePointSizesID-2.tex

    if {[expr {[clock seconds] - $ptime}] > 1} {
        if {!$localTest && [catch {APSRunControlPing} result]} {
            puts stderr "Ending via ping from runControl"
            exit 1
        }
        set ptime [clock seconds]
    }

    # BM computations.  Make three files:
    # sourcePointDataBM.sdds --- SDDS file with beam sizes and Twiss parameters at BMs
    # sourcePointSizesBM-1.tex --- LaTeX table with beam sizes
    # sourcePointSizesBM-2.tex --- LaTeX table with Twiss parameters
    if [catch \
          {exec sddsprocess $modelPath/aps.twi sourcePointDataBM.sdds -nowarn \
             "-define=parameter,exMeas,$xEmittance 1e12 *,units=pm" \
             "-define=parameter,eyMeas,$yEmittance 1e12 *,units=pm" \
             "-define=parameter,ex,$xEmittance,units=m" \
             "-define=parameter,ey,$yEmittance,units=m" \
             -match=column,ElementName=S*A:M4,ElementType=*BEN*,& \
             -filter=column,ElementOccurence,0.5,1.5 \
             -edit=column,SourcePointName,ElementName,%/A:M4/BM/ \
             "-define=column,Sx,ex betax * etax Sdelta0 * sqr + sqrt 1e6 *,units=um" \
             "-define=column,Sxp,ex 1 alphax sqr + * betax /  etaxp Sdelta0 * sqr + sqrt 1e6 *,units=urad" \
             "-define=column,Sxpx,ex alphax * chs  Sdelta0 sqr etax * etaxp * + 1e12 * ,units=um*urad" \
             "-define=column,exEffective,Sx Sxp * sqr Sxpx sqr - 0 < ? 1e-15 : pop sqrt $,units=pm" \
             "-define=column,Sy,ey betay * etay Sdelta0 * sqr + sqrt 1e6 *,units=um" \
             "-define=column,Syp,ey 1 alphay sqr + * betay /  etayp Sdelta0 * sqr + sqrt 1e6 *,units=urad" \
             "-define=column,Sypy,ey alphay * chs  Sdelta0 sqr etay * etayp * + 1e12 * ,units=um*urad" \
             "-define=column,eyEffective,Sy Syp * sqr Sypy sqr - 0 < ? 0 : pop sqrt $,units=pm" \
             "-define=column,couplingEffective,eyEffective exEffective / 100 *,units=%" \
             "-define=param,kappa,$nominalCoupling" \
             "-define=param,exNom,ex0 1 kappa Jx / + /,units=m" "-define=param,eyNom,exNom kappa *,units=m" \
             "-define=column,Sx0,exNom betax * etax Sdelta0 * sqr + sqrt 1e6 *,units=um" \
             "-define=column,Sxp0,exNom 1 alphax sqr + * betax /  etaxp Sdelta0 * sqr + sqrt 1e6 *,units=urad" \
             "-define=column,Sxpx0,exNom alphax * chs  Sdelta0 sqr etax * etaxp * + 1e12 * ,units=um*urad" \
             "-define=column,exEffective0,Sx0 Sxp0 * sqr Sxpx0 sqr - 0 < ? 1e-15 : pop sqrt $,units=pm" \
             "-define=column,Sy0,eyNom betay * etay Sdelta0 * sqr + sqrt 1e6 *,units=um" \
             "-define=column,Syp0,eyNom 1 alphay sqr + * betay /  etayp Sdelta0 * sqr + sqrt 1e6 *,units=urad" \
             "-define=column,Sypy0,eyNom alphay * chs  Sdelta0 sqr etay * etayp * + 1e12 * ,units=um*urad" \
             "-define=column,eyEffective0,Sy0 Syp0 * sqr Sypy0 sqr - 0 < ? 0 : pop sqrt $,units=pm" \
             "-define=column,couplingEffective0,eyEffective0 exEffective0 / 100 *,units=%" \
             -scan=column,BM,SourcePointName,S%ld,type=long \
             -filter=column,BM,0.5,35.5 \
             "-print=parameter,TimeStamp,$ts"} result] {
        sendToLogFile "$result"
        if $debug {puts stderr "$result" }
        APSSendEMail -address soliday -message "Warning: computeSourceSizes: $result"
        catch {exec sddscasr $scriptDataPath/computeSourceSizes.pcas -restore}
        exit 1
    }


    if [catch {exec sddsprintout sourcePointDataBM.sdds sourcePointSizesBM-1.tex -latexFormat \
             "-title=Round-beam source point data generated $ts for I=$current mA\\, along with nominal flat-beam (0) values." \
             -column=SourcePointName,label=Name \
             -column=exEffective,format=%5.2f,label=exEff \
             -column=couplingEffective,format=%5.1f,label=CplngEff \
             -column=Sx,format=%5.1f \
             -column=Sxp,format=%5.1f \
             -column=Sy,format=%5.1f \
             -column=Syp,format=%5.1f \
             -column=exEffective0,format=%5.2f,label=exEff0 \
             -column=couplingEffective0,format=%5.1f,label=CplngEff0 \
             -column=Sx0,format=%5.1f \
             -column=Sxp0,format=%5.1f \
             -column=Sy0,format=%5.1f \
             -column=Syp0,format=%5.1f 
              exec  sddsprintout sourcePointDataBM.sdds sourcePointSizesBM-2.tex -latexFormat \
             "-title=Source Point Data Generated $ts for I=$current mA" \
             -column=SourcePointName,label=Name \
             -column=betax,format=%5.1f \
             -column=alphax,format=%5.3f \
             -column=etax,format=%5.3f \
             -column=etaxp,format=%6.3f \
             -column=betay,format=%5.1f \
             -column=alphay,format=%5.3f \
             -column=etay,format=%5.3f \
             -column=etayp,format=%6.3f \
         } result] {
        sendToLogFile "$result"
        if $debug {puts stderr "$result" }
        APSSendEMail -address soliday -message "Warning: computeSourceSizes: $result"
        catch {exec sddscasr $scriptDataPath/computeSourceSizes.pcas -restore}
        exit 1
    }
    lappend latexList sourcePointSizesBM-1.tex sourcePointSizesBM-2.tex

    if {[expr {[clock seconds] - $ptime}] > 1} {
        if {!$localTest && [catch {APSRunControlPing} result]} {
            puts stderr "Ending via ping from runControl"
            exit 1
        }
        set ptime [clock seconds]
    }

    if !$localTest {
        # prepare data to send to PVs
        exec sddscombine sourcePointDataID.sdds sourcePointDataBM.sdds -merge -overwrite \
          sourcePointData.sdds 

        if {[expr {[clock seconds] - $ptime}] > 1} {
            if {!$localTest && [catch {APSRunControlPing} result]} {
                puts stderr "Ending via ping from runControl"
                exit 1
            }
            set ptime [clock seconds]
        }

        set tmpRoot /tmp/[APSTmpString]
        set i 0
        if [catch {exec sddsmakedataset $tmpRoot.$i -defaultType=string \
                     -column=ControlName -data=S:SrcPrmtrsVld,S:SrcPrmtrsTmVl \
                     -column=ValueString -data=1,[clock seconds]} result] {
            sendToLogFile "$result"
            if $debug {puts stderr "$result" }
            APSSendEMail -address soliday -message "Warning: computeSourceSizes: $result"
            catch {exec sddscasr $scriptDataPath/computeSourceSizes.pcas -restore}
            exit 1
        }

        if {[expr {[clock seconds] - $ptime}] > 1} {
            if {!$localTest && [catch {APSRunControlPing} result]} {
                puts stderr "Ending via ping from runControl"
                exit 1
            }
            set ptime [clock seconds]
        }

        set tmpList $tmpRoot.0
        incr i
        # For each plane and each type of value, make a snapshot file
        foreach Plane {X Y} plane {x y} {
            foreach Name {Size Divergence Beta Alpha Eta EtaSlope} \
              template {S%s S%sp beta%s alpha%s eta%s eta%sp} {
                  set name [format $template $plane]
                  if [catch {exec sddsprocess sourcePointData.sdds $tmpRoot.$i \
                               -print=column,ControlName,%s${Name}${Plane},SourcePointName \
                               -print=column,ValueString,%f,$name} result] {
                      sendToLogFile "$result"
                      if $debug {puts stderr "$result" }
                      APSSendEMail -address soliday -message "Warning: computeSourceSizes: $result"
                      catch {exec sddscasr $scriptDataPath/computeSourceSizes.pcas -restore}
                      exit 1
                  }
                  lappend tmpList $tmpRoot.$i
                  incr i

                  if {[expr {[clock seconds] - $ptime}] > 1} {
                      if {!$localTest && [catch {APSRunControlPing} result]} {
                          puts stderr "Ending via ping from runControl"
                          exit 1
                      }
                      set ptime [clock seconds]
                  }
              }
        }
        # combine snapshot files and send to the IOC
        if [catch {eval exec sddscombine $tmpList -merge sourcePointData.snp -overwrite} result] {
            sendToLogFile "$result"
            if $debug {puts stderr "$result" }
            APSSendEMail -address soliday -message "Warning: computeSourceSizes: $result"
            catch {exec sddscasr $scriptDataPath/computeSourceSizes.pcas -restore}
            exit 1
        }
        if [catch {eval exec sddscasr -restore sourcePointData.snp} result] {
            sendToLogFile "$result"
            if $debug {puts stderr "$result" }
            APSSendEMail -address soliday -message "Warning: computeSourceSizes: $result"
            catch {exec sddscasr $scriptDataPath/computeSourceSizes.pcas -restore}
            exit 1
        }

        if {[expr {[clock seconds] - $ptime}] > 1} {
            if {!$localTest && [catch {APSRunControlPing} result]} {
                puts stderr "Ending via ping from runControl"
                exit 1
            }
            set ptime [clock seconds]
        }

        eval file delete -force $tmpList 
    }

    if {[expr {[clock seconds] - $ptime}] > 1} {
        if {!$localTest && [catch {APSRunControlPing} result]} {
            puts stderr "Ending via ping from runControl"
            exit 1
        }
        set ptime [clock seconds]
    }

    #--- Calculating chromaticity:
    if 0 {
        # This doesn't belong here!
        if $debug {puts stdout "Calculating chromaticity..."}
        if [catch {exec $OAGGlobal(OAGLoggingDirectory)/SRLatticeParameters/computeLatticeParameters \
                     -localTest $localTest} result] {
            sendToLogFile "computeLatticeParameters: $result"
            if $debug {puts stderr "computeLatticeParameters: $result" }
            APSSendEMail -address soliday -message \
              "Warning: computeSourceSizes: computeLatticeParameters: $result"
            catch {exec sddscasr $scriptDataPath/computeSourceSizes.pcas -restore}
            exit 1
        }
        #--- End of calculating chromatictiy.
    }
    
    if {[expr {[clock seconds] - $ptime}] > 1} {
        if {!$localTest && [catch {APSRunControlPing} result]} {
            puts stderr "Ending via ping from runControl"
            exit 1
        }
        set ptime [clock seconds]
    }

    # combine the tex files with a header and footer
    if {[catch {open $webDataPath/sourcePointResults.tex w} fd]} {
        return
    }
    puts $fd "\\documentclass\{article\}\[10pt\]"
    puts $fd "\\begin\{document\}"
    puts $fd "\\setlength\{\\evensidemargin\}\{0.25in\}"
    puts $fd "\\setlength\{\\oddsidemargin\}\{0.25in\}"
    foreach file $latexList {
        if {[catch {open $file r} fd1]} {
            catch {close $fd}
            return
        }
        while {![eof $fd1]} {
            gets $fd1 s
            puts $fd $s
        }
        catch {close $fd1}
        puts $fd "\\newpage"
    }
    puts $fd "\\end\{document\}"
    catch {close $fd}

    if {[expr {[clock seconds] - $ptime}] > 1} {
        if {!$localTest && [catch {APSRunControlPing} result]} {
            puts stderr "Ending via ping from runControl"
            exit 1
        }
        set ptime [clock seconds]
    }

    eval file delete -force $latexList

    if {[expr {[clock seconds] - $ptime}] > 1} {
        if {!$localTest && [catch {APSRunControlPing} result]} {
            puts stderr "Ending via ping from runControl"
            exit 1
        }
        set ptime [clock seconds]
    }

    cd $webDataPath

    if {[expr {[clock seconds] - $ptime}] > 1} {
        if {!$localTest && [catch {APSRunControlPing} result]} {
            puts stderr "Ending via ping from runControl"
            exit 1
        }
        set ptime [clock seconds]
    }

    # run latex
    if {[catch {exec latex sourcePointResults} result]} {
        APSSendEMail -address soliday -message "Warning: computeSourceSizes: $result"
    }
    if $debug { puts stderr "latex: $result"}

    if {[expr {[clock seconds] - $ptime}] > 1} {
        if {!$localTest && [catch {APSRunControlPing} result]} {
            puts stderr "Ending via ping from runControl"
            exit 1
        }
        set ptime [clock seconds]
    }

    # make postscript
    if {[catch {exec dvips sourcePointResults -o sourcePointResults.ps} result]} {
        #        APSSendEMail -address soliday -message "Warning: computeSourceSizes: $result"
    }
    if $debug { puts stderr "dvips: $result"}

    if {[expr {[clock seconds] - $ptime}] > 1} {
        if {!$localTest && [catch {APSRunControlPing} result]} {
            puts stderr "Ending via ping from runControl"
            exit 1
        }
        set ptime [clock seconds]
    }

    # make PDF
    if {[catch {exec ps2pdf sourcePointResults.ps} result]} {
        APSSendEMail -address soliday -message "Warning: computeSourceSizes: $result"
    }
    if $debug { puts stderr "ps2pdf: $result"}

    if {[catch {file copy sourcePointResults.pdf History/sourcePointResults-[clock format [clock seconds] -format %Y-%m-%d_%H:%M:%S].pdf} result]} {
        APSSendEMail -address soliday -message "Warning: computeSourceSizes: $result"
    }
    if $debug { puts stderr "copy sourcePointResults.pdf: $result"}
    
    if {[expr {[clock seconds] - $ptime}] > 1} {
        if {!$localTest && [catch {APSRunControlPing} result]} {
            puts stderr "Ending via ping from runControl"
            exit 1
        }
        set ptime [clock seconds]
    }

    # make html

    if {[catch {exec htlatex sourcePointResults "html,3" "" "-d${webDataPath}"} result]} {
        #        APSSendEMail -address soliday -message "Warning: computeSourceSizes: $result"
    }
    if $debug { puts stderr "htlatex: $result"}

    if {[expr {[clock seconds] - $ptime}] > 1} {
        if {!$localTest && [catch {APSRunControlPing} result]} {
            puts stderr "Ending via ping from runControl"
            exit 1
        }
        set ptime [clock seconds]
    }

    cd $scriptDataPath

    if {[expr {[clock seconds] - $ptime}] > 1} {
        if {!$localTest && [catch {APSRunControlPing} result]} {
            puts stderr "Ending via ping from runControl"
            exit 1
        }
        set ptime [clock seconds]
    }

    sendToLogFile "computations completed"
    if $debug { puts stderr "computations completed"}
}

proc releaseRunControl {args} {
    catch {APSRunControlExit}
}

if !$localTest {
    if $debug {puts stderr "Attempting to connect to runcontrol record"}
    if {[catch {APScavget -list=OAG:ComputeSourceSizeRC.HBTO -num} result]} {
    }
    if {$result != 0} {
        if {[catch {APScavput -list=OAG:ComputeSourceSizeRC.CLR=1} result]} {
        }
    }
    if {[catch {APScavget -list=OAG:ComputeSourceSizeRC.MSG -noquotes} result]} {
    }
    if {$result == "** Aborted **"} {
        if {[catch {APScavput -list=OAG:ComputeSourceSizeRC.CLR=1} result]} {
        }
    }
    if {[catch {APSRunControlInit -pv OAG:ComputeSourceSizeRC \
                  -description "Compute Source Size" \
                  -timeout 60000} result]} {
        sendToLogFile "Run control indicates that another version is already running"
        exit
    }
    if {[catch {APSRunControlLogMessage -message "Running"} result]} {
    }
    if $debug {puts stderr "Connected to runcontrol record"}
    dp_atexit append "releaseRunControl"
}

if $runOnce {
    updateSourcePointData
    exit
}

set strobePV OAG:loggerPeriod128M
set period 128.0

proc TriggerSeen {args} {
    global strobeSec dataLogged debug strobe
    if $debug {puts stderr "Got trigger.  Waiting for interval."}
    set strobeSec [expr {int($strobe)}]
    set dataLogged 0
}

if {[catch {pv linkw strobe $strobePV} result]} {
    puts stderr "error: $result"
    exit 1
}
set strobeSec 0
set dataLogged 0
if {[catch {pv mon strobe TriggerSeen} result]} {
    puts stderr "error: $result"
    exit 1
}

proc Ping {args} {
    global debug strobeSec dataLogged localTest

    if {!$localTest} {
        if $debug {puts stderr "Pinging runcontrol."}
        if {[catch {APSRunControlPing} result]} {
            puts stderr "Ending via ping from runControl"
            exit 1
        }
    }
    if {$dataLogged == 0} {
        set t [expr {[clock seconds] - $strobeSec}]
        if {($t >= 100) && ($t < 125)} {
            if $debug { puts stderr "Updating source point data."}
            updateSourcePointData
            if $debug { puts stderr "Updated source point data."}
            set dataLogged 1
            if $debug {puts stderr "Data updated."}
            if {!$localTest && [catch {APSRunControlPing} result]} {
                puts stderr "Ending via ping from runControl"
                exit 1
            }
        }
    }
    if $debug {puts stderr "Waiting 5 seconds."}
    after 5000 Ping
}

after 5000 Ping
vwait state

