lin-epics-modules/ADAndor
0
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
Files
7aaaffad02bca1e00df2694eec79cc0b2eb93513
ADAndor/ADApp/Db/NDProcess.template
rivers 843716a67c Added AutoOffsetScale 
git-svn-id: https://subversion.xor.aps.anl.gov/synApps/areaDetector/trunk@15288 dc6c5ff5-0b8b-c028-a01f-ffb33f00fc8b
2012-09-30 15:32:04 +00:00

843 lines
21 KiB
Plaintext
Raw Blame History

# Database for ND PluginProcess
# Mark Rivers
# March 14, 2010
###################################################################
# These records control the data type of the array data #
# The last entry is "Automatic" meaning preserve the data type #
# of the input array. #
###################################################################
record(mbbo, "$(P)$(R)DataTypeOut")
{
field(PINI, "YES")
field(DTYP, "asynInt32")
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PROCESS_DATA_TYPE")
field(ZRST, "Int8")
field(ZRVL, "0")
field(ONST, "UInt8")
field(ONVL, "1")
field(TWST, "Int16")
field(TWVL, "2")
field(THST, "UInt16")
field(THVL, "3")
field(FRST, "Int32")
field(FRVL, "4")
field(FVST, "UInt32")
field(FVVL, "5")
field(SXST, "Float32")
field(SXVL, "6")
field(SVST, "Float64")
field(SVVL, "7")
field(EIST, "Automatic")
field(EIVL, "-1")
field(VAL, "8")
}
record(mbbi, "$(P)$(R)DataTypeOut_RBV")
{
field(DTYP, "asynInt32")
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))PROCESS_DATA_TYPE")
field(ZRST, "Int8")
field(ZRVL, "0")
field(ONST, "UInt8")
field(ONVL, "1")
field(TWST, "Int16")
field(TWVL, "2")
field(THST, "UInt16")
field(THVL, "3")
field(FRST, "Int32")
field(FRVL, "4")
field(FVST, "UInt32")
field(FVVL, "5")
field(SXST, "Float32")
field(SXVL, "6")
field(SVST, "Float64")
field(SVVL, "7")
field(EIST, "Automatic")
field(EIVL, "-1")
field(SCAN, "I/O Intr")
}
###################################################################
# These records control the background array processing #
###################################################################
record(bo, "$(P)$(R)SaveBackground")
{
field(DTYP, "asynInt32")
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SAVE_BACKGROUND")
field(VAL, "1")
field(ZNAM, "No")
field(ONAM, "Yes")
}
record(bi, "$(P)$(R)SaveBackground_RBV")
{
field(DTYP, "asynInt32")
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SAVE_BACKGROUND")
field(ZNAM, "No")
field(ONAM, "Yes")
field(SCAN, "I/O Intr")
}
record(bo, "$(P)$(R)EnableBackground")
{
field(PINI, "YES")
field(DTYP, "asynInt32")
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ENABLE_BACKGROUND")
field(ZNAM, "Disable")
field(ONAM, "Enable")
}
record(bi, "$(P)$(R)EnableBackground_RBV")
{
field(DTYP, "asynInt32")
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ENABLE_BACKGROUND")
field(ZNAM, "Disable")
field(ONAM, "Enable")
field(ZSV, "NO_ALARM")
field(OSV, "MINOR")
field(SCAN, "I/O Intr")
}
record(bi, "$(P)$(R)ValidBackground_RBV")
{
field(DTYP, "asynInt32")
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))VALID_BACKGROUND")
field(ZNAM, "Invalid")
field(ONAM, "Valid")
field(SCAN, "I/O Intr")
}
###################################################################
# These records control the flat field array processing #
###################################################################
record(bo, "$(P)$(R)SaveFlatField")
{
field(DTYP, "asynInt32")
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SAVE_FLAT_FIELD")
field(VAL, "1")
field(ZNAM, "No")
field(ONAM, "Yes")
}
record(bi, "$(P)$(R)SaveFlatField_RBV")
{
field(DTYP, "asynInt32")
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SAVE_FLAT_FIELD")
field(ZNAM, "No")
field(ONAM, "Yes")
field(SCAN, "I/O Intr")
}
record(bo, "$(P)$(R)EnableFlatField")
{
field(PINI, "YES")
field(DTYP, "asynInt32")
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ENABLE_FLAT_FIELD")
field(ZNAM, "Disable")
field(ONAM, "Enable")
}
record(bi, "$(P)$(R)EnableFlatField_RBV")
{
field(DTYP, "asynInt32")
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ENABLE_FLAT_FIELD")
field(ZNAM, "Disable")
field(ONAM, "Enable")
field(ZSV, "NO_ALARM")
field(OSV, "MINOR")
field(SCAN, "I/O Intr")
}
record(bi, "$(P)$(R)ValidFlatField_RBV")
{
field(DTYP, "asynInt32")
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))VALID_FLAT_FIELD")
field(ZNAM, "Invalid")
field(ONAM, "Valid")
field(SCAN, "I/O Intr")
}
record(ao, "$(P)$(R)ScaleFlatField")
{
field(PINI, "YES")
field(DTYP, "asynFloat64")
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SCALE_FLAT_FIELD")
field(VAL, "255.")
}
record(ai, "$(P)$(R)ScaleFlatField_RBV")
{
field(DTYP, "asynFloat64")
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SCALE_FLAT_FIELD")
field(SCAN, "I/O Intr")
}
###################################################################
# These records control the offset and scale #
###################################################################
record(bo, "$(P)$(R)EnableOffsetScale")
{
field(PINI, "YES")
field(DTYP, "asynInt32")
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ENABLE_OFFSET_SCALE")
field(ZNAM, "Disable")
field(ONAM, "Enable")
}
# Oneshot record for calculating scale and offset
record(busy, "$(P)$(R)AutoOffsetScale")
{
field(DTYP, "asynInt32")
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))AUTO_OFFSET_SCALE")
field(ZNAM, "Done")
field(ONAM, "Calculating")
}
record(bi, "$(P)$(R)EnableOffsetScale_RBV")
{
field(DTYP, "asynInt32")
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ENABLE_OFFSET_SCALE")
field(ZNAM, "Disable")
field(ONAM, "Enable")
field(ZSV, "NO_ALARM")
field(OSV, "MINOR")
field(SCAN, "I/O Intr")
}
record(ao, "$(P)$(R)Offset")
{
field(PINI, "YES")
field(DTYP, "asynFloat64")
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))OFFSET")
field(PREC, "2")
field(VAL, "0.0")
}
record(ai, "$(P)$(R)Offset_RBV")
{
field(DTYP, "asynFloat64")
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))OFFSET")
field(PREC, "2")
field(SCAN, "I/O Intr")
}
record(ao, "$(P)$(R)Scale")
{
field(PINI, "YES")
field(DTYP, "asynFloat64")
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SCALE")
field(PREC, "2")
field(VAL, "1.0")
}
record(ai, "$(P)$(R)Scale_RBV")
{
field(DTYP, "asynFloat64")
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))SCALE")
field(PREC, "2")
field(SCAN, "I/O Intr")
}
###################################################################
# These records control the high and low clipping #
###################################################################
record(bo, "$(P)$(R)EnableLowClip")
{
field(PINI, "YES")
field(DTYP, "asynInt32")
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ENABLE_LOW_CLIP")
field(ZNAM, "Disable")
field(ONAM, "Enable")
}
record(bi, "$(P)$(R)EnableLowClip_RBV")
{
field(DTYP, "asynInt32")
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ENABLE_LOW_CLIP")
field(ZNAM, "Disable")
field(ONAM, "Enable")
field(ZSV, "NO_ALARM")
field(OSV, "MINOR")
field(SCAN, "I/O Intr")
}
record(ao, "$(P)$(R)LowClip")
{
field(PINI, "YES")
field(DTYP, "asynFloat64")
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LOW_CLIP")
field(VAL, "0.0")
}
record(ai, "$(P)$(R)LowClip_RBV")
{
field(DTYP, "asynFloat64")
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))LOW_CLIP")
field(SCAN, "I/O Intr")
}
record(bo, "$(P)$(R)EnableHighClip")
{
field(PINI, "YES")
field(DTYP, "asynInt32")
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ENABLE_HIGH_CLIP")
field(ZNAM, "Disable")
field(ONAM, "Enable")
}
record(bi, "$(P)$(R)EnableHighClip_RBV")
{
field(DTYP, "asynInt32")
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ENABLE_HIGH_CLIP")
field(ZNAM, "Disable")
field(ONAM, "Enable")
field(ZSV, "NO_ALARM")
field(OSV, "MINOR")
field(SCAN, "I/O Intr")
}
record(ao, "$(P)$(R)HighClip")
{
field(PINI, "YES")
field(DTYP, "asynFloat64")
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))HIGH_CLIP")
field(VAL, "100.0")
}
record(ai, "$(P)$(R)HighClip_RBV")
{
field(DTYP, "asynFloat64")
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))HIGH_CLIP")
field(SCAN, "I/O Intr")
}
###################################################################
# These records control frame filtering #
###################################################################
record(bo, "$(P)$(R)EnableFilter")
{
field(PINI, "YES")
field(DTYP, "asynInt32")
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ENABLE_FILTER")
field(ZNAM, "Disable")
field(ONAM, "Enable")
}
record(bi, "$(P)$(R)EnableFilter_RBV")
{
field(DTYP, "asynInt32")
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))ENABLE_FILTER")
field(ZNAM, "Disable")
field(ONAM, "Enable")
field(ZSV, "NO_ALARM")
field(OSV, "MINOR")
field(SCAN, "I/O Intr")
}
record(bo, "$(P)$(R)ResetFilter")
{
field(DTYP, "asynInt32")
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))RESET_FILTER")
field(VAL, "1")
field(ZNAM, "No")
field(ONAM, "Yes")
}
record(bi, "$(P)$(R)ResetFilter_RBV")
{
field(DTYP, "asynInt32")
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))RESET_FILTER")
field(ZNAM, "No")
field(ONAM, "Yes")
field(SCAN, "I/O Intr")
}
record(bo, "$(P)$(R)AutoResetFilter")
{
field(PINI, "YES")
field(DTYP, "asynInt32")
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))AUTO_RESET_FILTER")
field(ZNAM, "No")
field(ONAM, "Yes")
}
record(bi, "$(P)$(R)AutoResetFilter_RBV")
{
field(DTYP, "asynInt32")
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))AUTO_RESET_FILTER")
field(ZNAM, "No")
field(ONAM, "Yes")
field(SCAN, "I/O Intr")
}
record(bo, "$(P)$(R)FilterCallbacks")
{
field(PINI, "YES")
field(DTYP, "asynInt32")
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_CALLBACKS")
field(ZNAM, "Every array")
field(ONAM, "Array N only")
}
record(bi, "$(P)$(R)FilterCallbacks_RBV")
{
field(DTYP, "asynInt32")
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_CALLBACKS")
field(ZNAM, "Every array")
field(ONAM, "Array N only")
field(SCAN, "I/O Intr")
}
record(longout, "$(P)$(R)NumFilter")
{
field(PINI, "YES")
field(DTYP, "asynInt32")
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))NUM_FILTER")
field(VAL, "1")
field(FLNK, "$(P)$(R)NumFilterRecip.PROC PP")
}
record(longin, "$(P)$(R)NumFilter_RBV")
{
field(DTYP, "asynInt32")
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))NUM_FILTER")
field(SCAN, "I/O Intr")
}
# This is 1/NumFilter, used in RecursiveSum filter
# If this value changes we need to process FilterType to make it update filter coefficients
record(calc, "$(P)$(R)NumFilterRecip")
{
field(INPA, "$(P)$(R)NumFilter.VAL NPP")
field(CALC, "1./A")
field(FLNK, "$(P)$(R)FilterType.PROC PP")
}
record(longin, "$(P)$(R)NumFiltered_RBV")
{
field(DTYP, "asynInt32")
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))NUM_FILTERED")
field(SCAN, "I/O Intr")
}
record(ao, "$(P)$(R)OOffset")
{
field(PINI, "YES")
field(DTYP, "asynFloat64")
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_OOFFSET")
field(VAL, "0.0")
field(PREC, "2")
}
record(ai, "$(P)$(R)OOffset_RBV")
{
field(DTYP, "asynFloat64")
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_OOFFSET")
field(PREC, "2")
field(SCAN, "I/O Intr")
}
record(ao, "$(P)$(R)OScale")
{
field(PINI, "YES")
field(DTYP, "asynFloat64")
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_OSCALE")
field(VAL, "1.0")
field(PREC, "2")
}
record(ai, "$(P)$(R)OScale_RBV")
{
field(DTYP, "asynFloat64")
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_OSCALE")
field(PREC, "2")
field(SCAN, "I/O Intr")
}
record(ao, "$(P)$(R)OC1")
{
field(PINI, "YES")
field(DTYP, "asynFloat64")
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_OC1")
field(VAL, "1.0")
field(PREC, "2")
}
record(ai, "$(P)$(R)OC1_RBV")
{
field(DTYP, "asynFloat64")
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_OC1")
field(PREC, "2")
field(SCAN, "I/O Intr")
}
record(ao, "$(P)$(R)OC2")
{
field(PINI, "YES")
field(DTYP, "asynFloat64")
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_OC2")
field(VAL, "-1.0")
field(PREC, "2")
}
record(ai, "$(P)$(R)OC2_RBV")
{
field(DTYP, "asynFloat64")
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_OC2")
field(PREC, "2")
field(SCAN, "I/O Intr")
}
record(ao, "$(P)$(R)OC3")
{
field(PINI, "YES")
field(DTYP, "asynFloat64")
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_OC3")
field(VAL, "0.0")
field(PREC, "2")
}
record(ai, "$(P)$(R)OC3_RBV")
{
field(DTYP, "asynFloat64")
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_OC3")
field(PREC, "2")
field(SCAN, "I/O Intr")
}
record(ao, "$(P)$(R)OC4")
{
field(PINI, "YES")
field(DTYP, "asynFloat64")
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_OC4")
field(VAL, "1.0")
field(PREC, "2")
}
record(ai, "$(P)$(R)OC4_RBV")
{
field(DTYP, "asynFloat64")
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_OC4")
field(PREC, "2")
field(SCAN, "I/O Intr")
}
record(ao, "$(P)$(R)FOffset")
{
field(PINI, "YES")
field(DTYP, "asynFloat64")
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_FOFFSET")
field(VAL, "0.0")
field(PREC, "2")
}
record(ai, "$(P)$(R)FOffset_RBV")
{
field(DTYP, "asynFloat64")
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_FOFFSET")
field(PREC, "2")
field(SCAN, "I/O Intr")
}
record(ao, "$(P)$(R)FScale")
{
field(PINI, "YES")
field(DTYP, "asynFloat64")
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_FSCALE")
field(VAL, "1.0")
field(PREC, "2")
}
record(ai, "$(P)$(R)FScale_RBV")
{
field(DTYP, "asynFloat64")
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_FSCALE")
field(PREC, "2")
field(SCAN, "I/O Intr")
}
record(ao, "$(P)$(R)FC1")
{
field(PINI, "YES")
field(DTYP, "asynFloat64")
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_FC1")
field(VAL, "1.0")
field(PREC, "2")
}
record(ai, "$(P)$(R)FC1_RBV")
{
field(DTYP, "asynFloat64")
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_FC1")
field(PREC, "2")
field(SCAN, "I/O Intr")
}
record(ao, "$(P)$(R)FC2")
{
field(PINI, "YES")
field(DTYP, "asynFloat64")
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_FC2")
field(VAL, "-1.0")
field(PREC, "2")
}
record(ai, "$(P)$(R)FC2_RBV")
{
field(DTYP, "asynFloat64")
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_FC2")
field(PREC, "2")
field(SCAN, "I/O Intr")
}
record(ao, "$(P)$(R)FC3")
{
field(PINI, "YES")
field(DTYP, "asynFloat64")
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_FC3")
field(VAL, "0.0")
field(PREC, "2")
}
record(ai, "$(P)$(R)FC3_RBV")
{
field(DTYP, "asynFloat64")
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_FC3")
field(PREC, "2")
field(SCAN, "I/O Intr")
}
record(ao, "$(P)$(R)FC4")
{
field(PINI, "YES")
field(DTYP, "asynFloat64")
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_FC4")
field(VAL, "1.0")
field(PREC, "2")
}
record(ai, "$(P)$(R)FC4_RBV")
{
field(DTYP, "asynFloat64")
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_FC4")
field(PREC, "2")
field(SCAN, "I/O Intr")
}
record(ao, "$(P)$(R)ROffset")
{
field(PINI, "YES")
field(DTYP, "asynFloat64")
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_ROFFSET")
field(VAL, "0.0")
field(PREC, "2")
}
record(ai, "$(P)$(R)ROffset_RBV")
{
field(DTYP, "asynFloat64")
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_ROFFSET")
field(PREC, "2")
field(SCAN, "I/O Intr")
}
record(ao, "$(P)$(R)RC1")
{
field(PINI, "YES")
field(DTYP, "asynFloat64")
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_RC1")
field(VAL, "1.0")
field(PREC, "2")
}
record(ai, "$(P)$(R)RC1_RBV")
{
field(DTYP, "asynFloat64")
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_RC1")
field(PREC, "2")
field(SCAN, "I/O Intr")
}
record(ao, "$(P)$(R)RC2")
{
field(PINI, "YES")
field(DTYP, "asynFloat64")
field(OUT, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_RC2")
field(VAL, "1.0")
field(PREC, "2")
}
record(ai, "$(P)$(R)RC2_RBV")
{
field(DTYP, "asynFloat64")
field(INP, "@asyn($(PORT),$(ADDR),$(TIMEOUT))FILTER_RC2")
field(PREC, "2")
field(SCAN, "I/O Intr")
}
# We don't see PINI=YES for FilterType because we want to restore the actual coefficients
# We do restore this record, but we don't process it
record(mbbo, "$(P)$(R)FilterType")
{
field(ZRST, "RecursiveAve")
field(ZRVL, "1")
field(ONST, "Average")
field(ONVL, "2")
field(TWST, "Sum")
field(TWVL, "3")
field(THST, "Difference")
field(THVL, "4")
field(FRST, "RecursiveAveDiff")
field(FRVL, "5")
field(FVST, "CopyToFilter")
field(FVVL, "6")
field(FLNK, "$(P)$(R)FilterTypeSeq PP MS")
}
record(seq, "$(P)$(R)FilterTypeSeq")
{
field(SELL, "$(P)$(R)FilterType.RVAL NPP")
field(SELM, "Specified")
field(DOL1, "1")
field(LNK1, "$(P)$(R)RecursiveAveSeq.PROC PP MS")
field(DOL2, "1")
field(LNK2, "$(P)$(R)AverageSeq.PROC PP MS")
field(DOL3, "1")
field(LNK3, "$(P)$(R)SumSeq.PROC PP MS")
field(DOL4, "1")
field(LNK4, "$(P)$(R)DifferenceSeq.PROC PP MS")
field(DOL5, "1")
field(LNK5, "$(P)$(R)RecursiveAveDiffSeq.PROC PP MS")
field(DOL6, "1")
field(LNK6, "$(P)$(R)CopyToFilterSeq.PROC PP MS")
}
record(seq, "$(P)$(R)RecursiveAveSeq")
{
field(DOL1, "1")
field(LNK1, "$(P)$(R)OC1 PP MS")
field(DOL2, "-1")
field(LNK2, "$(P)$(R)OC2 PP MS")
field(DOL3, "0")
field(LNK3, "$(P)$(R)OC3 PP MS")
field(DOL4, "1")
field(LNK4, "$(P)$(R)OC4 PP MS")
field(DOL5, "1")
field(LNK5, "$(P)$(R)FC1 PP MS")
field(DOL6, "-1")
field(LNK6, "$(P)$(R)FC2 PP MS")
field(DOL7, "0")
field(LNK7, "$(P)$(R)FC3 PP MS")
field(DOL8, "1")
field(LNK8, "$(P)$(R)FC4 PP MS")
field(DOL9, "0")
field(LNK9, "$(P)$(R)RC1 PP MS")
field(DOLA, "1")
field(LNKA, "$(P)$(R)RC2 PP MS")
}
record(seq, "$(P)$(R)AverageSeq")
{
field(DOL1, "1")
field(LNK1, "$(P)$(R)OC1 PP MS")
field(DOL2, "0")
field(LNK2, "$(P)$(R)OC2 PP MS")
field(DOL3, "$(P)$(R)NumFilterRecip NPP")
field(LNK3, "$(P)$(R)OC3 PP MS")
field(DOL4, "0")
field(LNK4, "$(P)$(R)OC4 PP MS")
field(DOL5, "1")
field(LNK5, "$(P)$(R)FC1 PP MS")
field(DOL6, "0")
field(LNK6, "$(P)$(R)FC2 PP MS")
field(DOL7, "$(P)$(R)NumFilterRecip NPP")
field(LNK7, "$(P)$(R)FC3 PP MS")
field(DOL8, "0")
field(LNK8, "$(P)$(R)FC4 PP MS")
field(DOL9, "0")
field(LNK9, "$(P)$(R)RC1 PP MS")
field(DOLA, "0")
field(LNKA, "$(P)$(R)RC2 PP MS")
}
record(seq, "$(P)$(R)SumSeq")
{
field(DOL1, "1")
field(LNK1, "$(P)$(R)OC1 PP MS")
field(DOL2, "0")
field(LNK2, "$(P)$(R)OC2 PP MS")
field(DOL3, "1")
field(LNK3, "$(P)$(R)OC3 PP MS")
field(DOL4, "0")
field(LNK4, "$(P)$(R)OC4 PP MS")
field(DOL5, "1")
field(LNK5, "$(P)$(R)FC1 PP MS")
field(DOL6, "0")
field(LNK6, "$(P)$(R)FC2 PP MS")
field(DOL7, "1")
field(LNK7, "$(P)$(R)FC3 PP MS")
field(DOL8, "0")
field(LNK8, "$(P)$(R)FC4 PP MS")
field(DOL9, "0")
field(LNK9, "$(P)$(R)RC1 PP MS")
field(DOLA, "0")
field(LNKA, "$(P)$(R)RC2 PP MS")
}
record(seq, "$(P)$(R)DifferenceSeq")
{
field(DOL1, "-1")
field(LNK1, "$(P)$(R)OC1 PP MS")
field(DOL2, "0")
field(LNK2, "$(P)$(R)OC2 PP MS")
field(DOL3, "1")
field(LNK3, "$(P)$(R)OC3 PP MS")
field(DOL4, "0")
field(LNK4, "$(P)$(R)OC4 PP MS")
field(DOL5, "0")
field(LNK5, "$(P)$(R)FC1 PP MS")
field(DOL6, "0")
field(LNK6, "$(P)$(R)FC2 PP MS")
field(DOL7, "1")
field(LNK7, "$(P)$(R)FC3 PP MS")
field(DOL8, "0")
field(LNK8, "$(P)$(R)FC4 PP MS")
field(DOL9, "0")
field(LNK9, "$(P)$(R)RC1 PP MS")
field(DOLA, "1")
field(LNKA, "$(P)$(R)RC2 PP MS")
}
record(seq, "$(P)$(R)RecursiveAveDiffSeq")
{
field(DOL1, "-1")
field(LNK1, "$(P)$(R)OC1 PP MS")
field(DOL2, "0")
field(LNK2, "$(P)$(R)OC2 PP MS")
field(DOL3, "1")
field(LNK3, "$(P)$(R)OC3 PP MS")
field(DOL4, "0")
field(LNK4, "$(P)$(R)OC4 PP MS")
field(DOL5, "1")
field(LNK5, "$(P)$(R)FC1 PP MS")
field(DOL6, "-1")
field(LNK6, "$(P)$(R)FC2 PP MS")
field(DOL7, "0")
field(LNK7, "$(P)$(R)FC3 PP MS")
field(DOL8, "1")
field(LNK8, "$(P)$(R)FC4 PP MS")
field(DOL9, "0")
field(LNK9, "$(P)$(R)RC1 PP MS")
field(DOLA, "1")
field(LNKA, "$(P)$(R)RC2 PP MS")
}
record(seq, "$(P)$(R)CopyToFilterSeq")
{
field(DOL1, "0")
field(LNK1, "$(P)$(R)OC1 PP MS")
field(DOL2, "0")
field(LNK2, "$(P)$(R)OC2 PP MS")
field(DOL3, "1")
field(LNK3, "$(P)$(R)OC3 PP MS")
field(DOL4, "0")
field(LNK4, "$(P)$(R)OC4 PP MS")
field(DOL5, "0")
field(LNK5, "$(P)$(R)FC1 PP MS")
field(DOL6, "0")
field(LNK6, "$(P)$(R)FC2 PP MS")
field(DOL7, "1")
field(LNK7, "$(P)$(R)FC3 PP MS")
field(DOL8, "0")
field(LNK8, "$(P)$(R)FC4 PP MS")
field(DOL9, "0")
field(LNK9, "$(P)$(R)RC1 PP MS")
field(DOLA, "1")
field(LNKA, "$(P)$(R)RC2 PP MS")
}
Reference in New Issue View Git Blame Copy Permalink