#!/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)]
APSStandardSetup

#
# $Log: not supported by cvs2svn $
# Revision 18673  2012/09/28 added new voltage scaling factor for new voltage board shang
# note that /usr/local/oag/apps/bin/linux-x86_64/BRampWaveformMon.00011 is the working version for
# new voltage board (the waveform has 4000 points, before it had 5274 points) without new scaling.
#  /usr/local/oag/apps/bin/linux-x86_64/BRampWaveformMon.00012 was installed for both new voltage and current board
# by mistake since new current board is still under testing, not ready for user operation by now.
#
# Revision 1.12  2012/08/09 11:23:46  shang
# updated due to the voltage hardward changes, the voltage waveform length and time step changed.
#
# Revision 1.11  2011/09/30 19:06:27  shang
# combined sddsprocess and sddsconvert into one command with -pipe option to make make the code cleaner and more efficiency.
#
# Revision 1.10  2011/09/30 18:52:39  shang
# added "-printErrors" option to cavget to print error message when there is CA error; and added -nowarning option to sddsprocess and sddsconvert to skip warning messages.
#
# Revision 1.9  2011/09/30 15:34:38  shang
# added error catching and printing to stderr statement to help debugging when error occurs.
#
# Revision 1.8  2008/10/01 18:39:58  sereno
# Removed filter which limited the number of sample points to 1053.  Use
# -sparseinterval to change the number of sample points.
#
# Revision 1.7  2006/02/27 17:05:11  sereno
# Added computation of the magnet family resistance and inductance removed in
# the previous change.
#
# Revision 1.6  2006/02/27 16:19:38  sereno
# Removed computation of current offset at the beginning of the ramp since
# H. Shang proved is was not necessary.  Added computation of the current
# intercept since that takes into account the current offset and is computed
# directly by sddsprocess.
#
# Revision 1.5  2006/02/23 20:53:24  sereno
# Added computation of magnet string resistance and inductance parameters.
#
# Revision 1.4  2002/05/14 17:22:58  sereno
# Changed scale factor for quadrupole gain factors from 2000 / 600 to
# 1000 / 600 per PS group instruction.  N. Sereno
#
# Revision 1.3  2002/05/13 21:24:06  sereno
# Changed the QF and QD scale factor to reflect the new 2000 ampere transductor
# heads.  New scale factor is increased by the value of 2000 / 600 amperes.
# N. Sereno
#
# Revision 1.2  1999/06/21 14:53:21  borland
# Added CVS header.
#
# 
# Script to replace program Bmon.  Acquires booster main ramped supply 
# current and voltage waveforms, does a linear fit to the current over 
# a specified range and computes dI/I and dI for each supply based on the fit.
# Optionally allows plotting, sparsing, listing of current ramp slope and zero,
# acquiring the waveforms over a specified duration, including Error and Comp
# waveforms, specifiying the start and end time (relative to injection time)
# of the current waveform fit, and changing the time stepsize.
 
set usage "usage:  BRampWaveformMon -filename <output-file> -startTime <start-of-fit> -endTime <end-of-fit> \
-sparseInterval <interval> -sparseOffset <offset> -stepsize <time-step/point-in-ms> -duration <time-in-ms> \
-listParams <1 | 0> -include <1 | 0> -plot <1 | 0>"

set filename ""
set startTime 0.0
set endTime 100.0
set stepsize [expr 5.0 * 0.09764884]
set timePerPoint 0.09764884
set sparseInterval 5
set sparseOffset 0
set duration 515.0
set listParams 0
set include 0
set plot 0
set args $argv

if {[APSStrictParseArguments {filename startTime endTime stepsize sparseInterval sparseOffset duration listParams include plot}] || ![string length $filename] || $startTime<0.0 || $endTime<0.0 || $startTime>$endTime || $stepsize<=0.0 || $sparseInterval<1 || $sparseOffset<0 || $stepsize<0.09764884 || $duration<1.0 || $listParams=="" || $listParams!=0 && $listParams!=1 || $include=="" || $include!=0 && $include!=1 || $plot=="" || $plot!=0 && $plot!=1} {
    puts stderr $usage
    puts stderr ""
    puts stderr "-filename           Name of file to put raw and fit data."
    puts stderr "-startTime          Start of fit relative to injection time.  Must be >= 0 ms and < endTime (default is 0 ms)."
    puts stderr "-endTime            End of fit relative to injection time.  Must be > 0 ms and > startTime (default is 100 ms)."
    puts stderr "-sparseInterval     Interval to sparse the raw waveform (default is 5 point sparsing)."
    puts stderr "-sparseOffset       Interval to offset before sparsing the raw waveform at sparseInterval intervals (default is 0 point offset)."
    puts stderr "-stepsize           Defines the time step per point.  The smallest stepsize is 0.09764884 ms (Default stepsize is 0.488244 ms)."
    puts stderr "-duration           Duration allows collection of less than the full 515 ms of data.  Must be > 1 ms."
    puts stderr "-listParams         Optionally list ramp fit slope and zero crossing for each supply.  1 to list parameters,"
    puts stderr "                    0 to not list parameters (default)."
    puts stderr "-include            Optionally include PSError and PSComp waveform data in filename.  1 to include this data,"
    puts stderr "                    0 not to include this data (default)."
    puts stderr "-plot               Optionally plot raw ramp and fit data acquired in filename.  1 to plot 0 to not plot (default)."
    exit 1
}

#set preTrig 20.0
if [catch {exec cavget -list=B:PretriggerAI -pend=30 -printErrors} preTrig] {
    puts stderr "BRampWaveformMon: Error in reading B:PRETRIGGER: $preTrig"
    exit 1
}
if [catch {exec cavget -list=It:Bs:StartRamp2BsIp.VAL -pendIoTime=20 -printErrors} startRamp] {
    puts stderr "BRampWaveformMon: error in reading It:Bs:StartRamp2BsIp.VAL: $startRamp"
    exit 1
}

set injTime $startRamp
set fitStart [expr int(0.5 + (($preTrig + $injTime + $startTime) * 5.0) / ($sparseInterval * $stepsize))]
set fitEnd [expr int(0.5 + (($preTrig + $injTime + $endTime) * 5.0) / ($sparseInterval * $stepsize))]
set durationOffset [expr $duration - 20.0]

set bMagVoltageWFPVs "B:BM:PSVoltageWF,B:QF:PSVoltageWF,B:QD:PSVoltageWF,B:SF:PSVoltageWF,B:SD:PSVoltageWF,B:SF-U:PSVoltageWF,B:SD-U:PSVoltageWF"
set bMagCurrentWFPVs "B:BM:CurrentWF,B:QF:CurrentWF,B:QD:CurrentWF,B:SF:CurrentWF,B:SD:CurrentWF,B:SF-U:CurrentWF,B:SD-U:CurrentWF"
set bMagPSErrorWFPVs "B:BM:PSErrorWF,B:QF:PSErrorWF,B:QD:PSErrorWF,B:SF:PSErrorWF,B:SD:PSErrorWF"
set bMagPSCompWFPVs  "B:BM:PSCompWF,B:QF:PSCompWF,B:QD:PSCompWF,B:SF:PSCompWF,B:SD:PSCompWF"

set BMVoltageScale 0.1220722
set BMCurrentScale 0.0152590
set BMErrorScale 0.06103608
set BMCompScale 0.00030518

set QFVoltageScale 0.0219730
# Scale factor changed for new 2000 amp transductor heads.
# Old heads were 600 amperes maximum.  Full scale for the
# ADC is 2 * 32768.
#set QFCurrentScale [expr (0.0091554 * 1000.0) / 600.0]
set QFCurrentScale 0.015259021896696
set QFErrorScale 0.03051804
set QFCompScale 0.00030518

set QDVoltageScale 0.0219730
# Scale factor changed for new 2000 amp transductor heads.
# Old heads were 600 amperes maximum.  Full scale for the
# ADC is 2 * 32768.
#set QDCurrentScale [expr (0.0091554 * 1000.0) / 600.0]
set QDCurrentScale 0.015259021896696
set QDErrorScale 0.00030518
set QDCompScale 0.00030518

set SFVoltageScale 0.0045777
set SFCurrentScale 0.0022888
set SFErrorScale 0.00610360
set SFCompScale 0.00030518

set SDVoltageScale 0.0045777
set SDCurrentScale 0.0022888
set SDErrorScale 0.00610360
set SDCompScale 0.00030518

#set BMVoltageOffset 4200.0
set BMVoltageOffset 0
set BMCurrentOffset 0.0
set BMErrorOffset -2000.0
set BMCompOffset -10.0

#set QFVoltageOffset 690.0
set QFVoltageOffset 0
set QFCurrentOffset 0.0
set QFErrorOffset -1000.0
set QFCompOffset -10.0

#set QDVoltageOffset 690.0
set  QDVoltageOffset 0
set QDCurrentOffset 0.0
set QDErrorOffset -30.0
set QDCompOffset -10.0

#set SFVoltageOffset 150.0
set SFVoltageOffset 0
set SFCurrentOffset 0.0
set SFErrorOffset -200.0
set SFCompOffset -10.0

#set SDVoltageOffset 150.0
set SDVoltageOffset 0
set SDCurrentOffset 0.0
set SDErrorOffset -200.0
set SDCompOffset -10.0

#new current scale and offset for converting new current waveform to old ones.

set newTimeOffset 0
set timePerPointNew 0.11906744143094607
set newVoltageScale 1.019473597764458


#new current scale and offset for converting new current waveform to old ones.

set newTimeOffset 0

if [catch {exec cavget -list=B:SampleperiodAI -pend=20} sampleInterval] {
    puts stderr "error reading B:SampleperiodAI: $sampleInterval"
    exit 1
}
if [catch {exec cavget -list=Mt:TopUpCurrentDeltaQM.VAL,Mt:TopUpCurrentDeltaIM.VAL,Mt:TopUpInjectEffM.VAL -pend=10 -printErrors } valList] {
    puts stderr "Error reading injection efficiency: $ valList"
    exit 1
}
set DeltaCharge(value) [lindex $valList 0]
set DeltaI(value) [lindex $valList 1]
set Efficiency(value) [lindex $valList 2]
set DeltaCharge(pv) Mt:TopUpCurrentDeltaQM.VAL
set DeltaI(pv) Mt:TopUpCurrentDeltaIM.VAL
set Efficiency(pv) Mt:TopUpInjectEffM.VAL
set DeltaCharge(units) nC
set DeltaI(units) mA


set timePerPointNew [expr $sampleInterval / 4000.0]
foreach magnet {BM QF QD SF SD SF-U SD-U} {
    if [catch {exec cavget -list=B:${magnet}:SlopeInterceptSUB. -list=L,K,D -pend=10 } valueList] {
        puts stderr "Error in reading $magnet offset and scaling: $valueList"
        exit 1
    }
    set ${magnet}CurrentScaleNew [lindex $valueList 1]
    set ${magnet}CurrentOffsetNew [lindex $valueList 0]
    set ${magnet}TimeShift [lindex $valueList 2]
    
}

#set BooP0Interval [expr 432.0 / $rfFreq * 1e3 ]
#set timePerPointNew [expr $BooP0Interval * 97]


#voltage board is new
if [catch {exec sddswmonitor -PVnames=${bMagCurrentWFPVs},${bMagVoltageWFPVs} $filename.1 -steps=1  \
             "-comment=FileContents,Booster Main Ramped Supply Raw and Fit Waveform Data"    } result] {
    puts stderr "BRampWaveformMon1a: Error in reading waveform pvs ${bMagCurrentWFPVs},${bMagVoltageWFPVs}: $result"
    exit 1
}
set rows1 [exec sdds2stream -rows=bar $filename.1]
if {$rows1!=5274} {
    foreach magnet {BM QF QD SF SD SF-U SD-U} {
        set timeShift [set ${magnet}TimeShift]
        if [catch {exec sddsprocess $filename.1 -pipe=out "-redefine=col,time,Index $timePerPointNew * $timeShift -" \
                     | sddsconvert -pipe -retain=col,time,*${magnet}*WF \
                     | sddsinterp -pipe=in $filename.$magnet -sequence=5274,0,514.90233332 \
                     -col=time,*WF -aboveRange=saturate} result] {
            puts stderr "BRampWaveformMon3: Error interpolating voltage waveforms: $result"
            exit 1
        }
    }
    if [catch {exec sddsxref $filename.BM $filename.QF $filename.QD $filename.SF $filename.SD -leave=time $filename.1a } result] {
        puts stderr "BRampWaveformMon3a: Error interpolating voltage waveforms: $result"
        exit 1
    }
    file delete -force $filename.BM $filename.QF $filename.QD $filename.SF $filename.SD
    exec mv $filename.1a $filename.1
} 

if [catch {exec sddsprocess $filename.1 -sparse=${sparseInterval},${sparseOffset} -nowarnings -pipe=out \
             "-redefine=col,index,i_row" \
             "-redefine=col,time,index $stepsize * $sparseInterval * 5.0 / 20.0 -,units=ms" \
             "-filter=col,time,-20.1,${durationOffset}" \
             "-redefine=col,BMvout,B:BM:PSVoltageWF 32768 - $BMVoltageScale * $BMVoltageOffset +,units=Volts" \
             "-redefine=col,QFvout,B:QF:PSVoltageWF 32768 - $QFVoltageScale * $QFVoltageOffset +,units=Volts" \
             "-redefine=col,QDvout,B:QD:PSVoltageWF 32768 - $QDVoltageScale * $QDVoltageOffset +,units=Volts" \
             "-redefine=col,SFvout,B:SF:PSVoltageWF 32768 - $SFVoltageScale * $SFVoltageOffset +,units=Volts" \
             "-redefine=col,SDvout,B:SD:PSVoltageWF 32768 - $SDVoltageScale * $SDVoltageOffset +,units=Volts" \
             "-redefine=col,SF-Uvout,B:SF-U:PSVoltageWF 32768 - $SFVoltageScale * $SFVoltageOffset +,units=Volts" \
             "-redefine=col,SD-Uvout,B:SD-U:PSVoltageWF 32768 - $SDVoltageScale * $SDVoltageOffset +,units=Volts" \
             "-redefine=col,BMcurrent,B:BM:CurrentWF $BMCurrentScaleNew * $BMCurrentOffsetNew +" \
             "-redefine=col,QFcurrent,B:QF:CurrentWF $QFCurrentScaleNew * $QFCurrentOffsetNew +" \
             "-redefine=col,QDcurrent,B:QD:CurrentWF $QDCurrentScaleNew * $QDCurrentOffsetNew +" \
             "-redefine=col,SFcurrent,B:SF:CurrentWF $SFCurrentScaleNew * $SFCurrentOffsetNew +" \
             "-redefine=col,SDcurrent,B:SD:CurrentWF $SDCurrentScaleNew * $SDCurrentOffsetNew +" \
             "-redefine=col,SF-Ucurrent,B:SF-U:CurrentWF $SFCurrentScaleNew * $SFCurrentOffsetNew +" \
             "-redefine=col,SD-Ucurrent,B:SD-U:CurrentWF $SDCurrentScaleNew * $SDCurrentOffsetNew +" \
             | sddsprocess -pipe "-redefine=col,%s,%s $newVoltageScale *,select=*vout" \
             "-redefine=col,BMcurrent,BMcurrent $BMCurrentScale * $BMCurrentOffset +,units=Amperes" \
             "-redefine=col,QFcurrent,QFcurrent $QFCurrentScale * $QFCurrentOffset +,units=Amperes" \
             "-redefine=col,QDcurrent,QDcurrent $QDCurrentScale * $QDCurrentOffset +,units=Amperes" \
             "-redefine=col,SFcurrent,SFcurrent $SFCurrentScale * $SFCurrentOffset +,units=Amperes" \
             "-redefine=col,SDcurrent,SDcurrent $SDCurrentScale * $SDCurrentOffset +,units=Amperes" \
             "-redefine=col,SF-Ucurrent,SF-Ucurrent $SFCurrentScale * $SFCurrentOffset +,units=Amperes" \
             "-redefine=col,SD-Ucurrent,SD-Ucurrent $SDCurrentScale * $SDCurrentOffset +,units=Amperes" \
             | sddsprocess -pipe \
             "-process=BMcurrent,slope,BMslope,functionOf=index,lowerLimit=${fitStart},upperLimit=${fitEnd}" \
             "-process=BMcurrent,intercept,BMintercept,functionOf=index,lowerLimit=${fitStart},upperLimit=${fitEnd}" \
             "-process=BMvout,slope,BMvSlope,functionOf=index,lowerLimit=${fitStart},upperLimit=${fitEnd}" \
             "-process=BMvout,intercept,BMvIntercept,functionOf=index,lowerLimit=${fitStart},upperLimit=${fitEnd}" \
             | sddsprocess -pipe \
             "-define=col,BMfitI,index BMintercept BMslope / -1.0 * < ? 0.0 : BMslope index * BMintercept + $ ,units=Amperes" \
             "-define=col,BMfitError,BMcurrent BMfitI -,units=Amperes" \
             "-define=col,BMdeltaI/I,BMfitI 0.001 < ? 1.0 : BMfitError BMfitI / $ " \
             "-redefine=param,BMslope,BMslope $stepsize / $sparseInterval / 5.0 *,units=Amperes/ms" \
             "-redefine=param,BMvSlope,BMvSlope $stepsize / $sparseInterval / 5.0 *,units=Volts/ms" \
             "-redefine=param,BMzero,-1.0 BMintercept * BMslope / $preTrig -,units=ms" \
             "-redefine=param,BM_R,BMslope 0.0 == ? 0.0 : BMvSlope BMslope / $ ,units=Ohms" \
             "-redefine=param,BM_L,BMslope 0.0 == ? 0.0 : BMvIntercept BM_R BMintercept * - BMslope / $ ,units=mH" \
             "-process=QFcurrent,slope,QFslope,functionOf=index,lowerLimit=${fitStart},upperLimit=${fitEnd}" \
             "-process=QFcurrent,intercept,QFintercept,functionOf=index,lowerLimit=${fitStart},upperLimit=${fitEnd}" \
             "-process=QFvout,slope,QFvSlope,functionOf=index,lowerLimit=${fitStart},upperLimit=${fitEnd}" \
             "-process=QFvout,intercept,QFvIntercept,functionOf=index,lowerLimit=${fitStart},upperLimit=${fitEnd}" \
             "-define=col,QFfitI,index QFintercept QFslope / -1.0 * < ? 0.0 : QFslope index * QFintercept + $ ,units=Amperes" \
             "-define=col,QFfitError,QFcurrent QFfitI -,units=Amperes" \
             "-define=col,QFdeltaI/I,QFfitI 0.001 < ? 1.0 : QFfitError QFfitI / $ " \
             "-redefine=param,QFslope,QFslope $stepsize / $sparseInterval / 5.0 *,units=Amperes/ms" \
             "-redefine=param,QFvSlope,QFvSlope $stepsize / $sparseInterval / 5.0 *,units=Volts/ms" \
             "-redefine=param,QFzero,-1.0 QFintercept * QFslope / $preTrig -,units=ms" \
             "-redefine=param,QF_R,QFslope 0.0 == ? 0.0 : QFvSlope QFslope / $ ,units=Ohms" \
             "-redefine=param,QF_L,QFslope 0.0 == ? 0.0 : QFvIntercept QF_R QFintercept * - QFslope / $ ,units=mH" \
             "-process=QDcurrent,slope,QDslope,functionOf=index,lowerLimit=${fitStart},upperLimit=${fitEnd}" \
             "-process=QDcurrent,intercept,QDintercept,functionOf=index,lowerLimit=${fitStart},upperLimit=${fitEnd}" \
             "-process=QDvout,slope,QDvSlope,functionOf=index,lowerLimit=${fitStart},upperLimit=${fitEnd}" \
             "-process=QDvout,intercept,QDvIntercept,functionOf=index,lowerLimit=${fitStart},upperLimit=${fitEnd}" \
             "-define=col,QDfitI,index QDintercept QDslope / -1.0 * < ? 0.0 : QDslope index * QDintercept + $ ,units=Amperes" \
             "-define=col,QDfitError,QDcurrent QDfitI -,units=Amperes" \
             "-define=col,QDdeltaI/I,QDfitI 0.001 < ? 1.0 : QDfitError QDfitI / $ " \
             "-redefine=param,QDslope,QDslope $stepsize / $sparseInterval / 5.0 *,units=Amperes/ms" \
             "-redefine=param,QDvSlope,QDvSlope $stepsize / $sparseInterval / 5.0 *,units=Volts/ms" \
             "-redefine=param,QDzero,-1.0 QDintercept * QDslope / $preTrig -,units=ms" \
             "-redefine=param,QD_R,QDslope 0.0 == ? 0.0 : QDvSlope QDslope / $ ,units=Ohms" \
             "-redefine=param,QD_L,QDslope 0.0 == ? 0.0 : QDvIntercept QD_R QDintercept * - QDslope / $ ,units=mH" \
             "-process=SFcurrent,slope,SFslope,functionOf=index,lowerLimit=${fitStart},upperLimit=${fitEnd}" \
             "-process=SFcurrent,intercept,SFintercept,functionOf=index,lowerLimit=${fitStart},upperLimit=${fitEnd}" \
             "-process=SFvout,slope,SFvSlope,functionOf=index,lowerLimit=${fitStart},upperLimit=${fitEnd}" \
             "-process=SFvout,intercept,SFvIntercept,functionOf=index,lowerLimit=${fitStart},upperLimit=${fitEnd}" \
             "-process=SF-Ucurrent,slope,SF-Uslope,functionOf=index,lowerLimit=${fitStart},upperLimit=${fitEnd}" \
             "-process=SF-Ucurrent,intercept,SF-Uintercept,functionOf=index,lowerLimit=${fitStart},upperLimit=${fitEnd}" \
             "-process=SF-Uvout,slope,SF-UvSlope,functionOf=index,lowerLimit=${fitStart},upperLimit=${fitEnd}" \
             "-process=SF-Uvout,intercept,SF-UvIntercept,functionOf=index,lowerLimit=${fitStart},upperLimit=${fitEnd}" \
             "-define=col,SFfitI,index SFintercept SFslope / -1.0 * < ? 0.0 : SFslope index * SFintercept + $ ,units=Amperes" \
             "-define=col,SFfitError,SFcurrent SFfitI -,units=Amperes" \
             "-define=col,SFdeltaI/I,SFfitI 0.001 < ? 1.0 : SFfitError SFfitI / $ " \
             "-redefine=param,SFslope,SFslope $stepsize / $sparseInterval / 5.0 *,units=Amperes/ms" \
             "-redefine=param,SFvSlope,SFvSlope $stepsize / $sparseInterval / 5.0 *,units=Volts/ms" \
             "-redefine=param,SFzero,-1.0 SFintercept * SFslope / $preTrig -,units=ms" \
             "-redefine=param,SF_R,SFslope 0.0 == ? 0.0 : SFvSlope SFslope / $ ,units=Ohms" \
             "-redefine=param,SF_L,SFslope 0.0 == ? 0.0 : SFvIntercept SF_R SFintercept * - SFslope / $ ,units=mH" \
             "-process=SDcurrent,slope,SDslope,functionOf=index,lowerLimit=${fitStart},upperLimit=${fitEnd}" \
             "-process=SDcurrent,intercept,SDintercept,functionOf=index,lowerLimit=${fitStart},upperLimit=${fitEnd}" \
             "-process=SDvout,slope,SDvSlope,functionOf=index,lowerLimit=${fitStart},upperLimit=${fitEnd}" \
             "-process=SDvout,intercept,SDvIntercept,functionOf=index,lowerLimit=${fitStart},upperLimit=${fitEnd}" \
             "-process=SD-Ucurrent,slope,SD-Uslope,functionOf=index,lowerLimit=${fitStart},upperLimit=${fitEnd}" \
             "-process=SD-Ucurrent,intercept,SD-Uintercept,functionOf=index,lowerLimit=${fitStart},upperLimit=${fitEnd}" \
             "-process=SD-Uvout,slope,SD-UvSlope,functionOf=index,lowerLimit=${fitStart},upperLimit=${fitEnd}" \
             "-process=SD-Uvout,intercept,SD-UvIntercept,functionOf=index,lowerLimit=${fitStart},upperLimit=${fitEnd}" \
             "-define=col,SDfitI,index SDintercept SDslope / -1.0 * < ? 0.0 : SDslope index * SDintercept + $ ,units=Amperes" \
             "-define=col,SDfitError,SDcurrent SDfitI -,units=Amperes" \
             "-define=col,SDdeltaI/I,SDfitI 0.001 < ? 1.0 : SDfitError SDfitI / $ " \
             "-redefine=param,SDslope,SDslope $stepsize / $sparseInterval / 5.0 *,units=Amperes/ms" \
             "-redefine=param,SDvSlope,SDvSlope $stepsize / $sparseInterval / 5.0 *,units=Volts/ms" \
             "-redefine=param,SDzero,-1.0 SDintercept * SDslope / $preTrig -,units=ms" \
             "-redefine=param,SD_R,SDslope 0.0 == ? 0.0 : SDvSlope SDslope / $ ,units=Ohms" \
             "-redefine=param,SD_L,SDslope 0.0 == ? 0.0 : SDvIntercept SD_R SDintercept * - SDslope / $ ,units=mH" \
             "-define=par,DeltaCharge,$DeltaCharge(value),units=nC,symbol=$DeltaCharge(pv)" \
             "-define=par,DeltaI,$DeltaI(value),units=mA,symbol=$DeltaI(pv)" \
             "-define=par,InjectionEfficiency,$Efficiency(value),symbol=$Efficiency(pv)" \
             | sddsconvert -pipe=in  -delete=col,${bMagVoltageWFPVs},${bMagCurrentWFPVs} $filename  } result] {
    puts stderr "BRampWaveformMon: error in processing data1a: $result"
    exit 1
}
if {$plot} {
    
    catch {exec sddsplot -title=$filename -sep=nameIndex \
                 "-topline=Booster Main Ramped Supply Waveforms" \
             -col=time,*vout -end \
             -col=index,*vout -end \
             -col=time,*current -end \
             -col=index,*current \&}
}

if {$plot} {
    
    catch {exec sddsplot ${filename} -title= -sep=nameIndex \
             "-topline=Booster Ramped Supply Current Fit and Error Waveforms" \
             -col=time,*fitI -end \
             -col=index,*fitI -end \
             -col=time,*fitError -end \
             -col=index,*fitError -end \
             -col=time,*deltaI/I -end \
             -col=index,*deltaI/I \&}
}

if {$listParams} {
    puts ""
    puts "Booster ramped supply current fit waveform slope and zero parameters :"
    puts ""
    puts [exec sddsprintout $filename -param=(*slope,*zero)]
    puts ""
}

catch {exec rm ${filename}~}
catch {exec rm ${filename}.1}
exit 0
