#==================================
#----------------------------------
# rf_sig_cal_simple.template:
#
# Scale factor to convert waveform
# fraction-of-full-scale readout 
# to engineering units: MV for cavity 
# signal; sqrt(Watts) for others
#----------------------------------
#==================================

record(ao, "$(CM,recursive)10:CAV:CAL_SCALE") {
  field(SCAN, "Passive")
  field(OMSL, "supervisory")
  field(PREC, "7")
  field(VAL,  "1")
  field(PINI, "YES")
  field(FLNK, "$(CM,recursive)10:CAV:SCALE_CALC")
  info(autosaveFields, "VAL")
}

# Unnecessary intermediate PV 
# to be compatible with wfCav.template
record(ao, "$(CM,recursive)10:CAV:SCALE_CALC") {
  field(OMSL, "closed_loop")
  field(DOL,  "$(CM,recursive)10:CAV:CAL_SCALE")
  field(FLNK, "$(CM,recursive)10:CAV:SCALE")
}

# When reference is in sqrt(Watts)
record(calcout, "$(CM,recursive)10:CAV:SCALETOREF") {
  field(CALC, "B*A/C")
  field(INPA, "$(CM,recursive)10:CAV:CAL_SCALE") # current scaling
  field(INPB, "1")# B = known reference, in power
  field(INPC, "$(CM,recursive)10:CAV:AMEAN") # current amplitude mean
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,recursive)10:CAV:CAL_SCALE PP") # new scaling
  field(PINI, "NO") # do not overwrite cal on startup
  info(autosaveFields, "B")
}

# Signal waveform mean converted to counts
# To be consistent with signals. Keep this?
record(calc, "$(CM,recursive)10:CAV:AMEAN_ADC") {
  field(DESC, "WF mean in counts")
  field(CALC, "FLOOR(C*A/B)")
  field(INPA, "$(CM,recursive)10:CAV:AMEAN CPP")
  field(INPB, "$(CM,recursive)10:CAV:CAL_SCALE")
  field(INPC, "32767")
  field(EGU,  "counts")
}
#==================================
#----------------------------------
# rf_sig_cal_simple.template:
#
# Scale factor to convert waveform
# fraction-of-full-scale readout 
# to engineering units: MV for cavity 
# signal; sqrt(Watts) for others
#----------------------------------
#==================================

record(ao, "$(CM,recursive)10:DRV:CAL_SCALE") {
  field(SCAN, "Passive")
  field(OMSL, "supervisory")
  field(PREC, "7")
  field(VAL,  "1")
  field(PINI, "YES")
  field(FLNK, "$(CM,recursive)10:DRV:SCALE_CALC")
  info(autosaveFields, "VAL")
}

# Unnecessary intermediate PV 
# to be compatible with wfCav.template
record(ao, "$(CM,recursive)10:DRV:SCALE_CALC") {
  field(OMSL, "closed_loop")
  field(DOL,  "$(CM,recursive)10:DRV:CAL_SCALE")
  field(FLNK, "$(CM,recursive)10:DRV:SCALE")
}

# When reference is in sqrt(Watts)
record(calcout, "$(CM,recursive)10:DRV:SCALETOREF") {
  field(CALC, "B*A/C")
  field(INPA, "$(CM,recursive)10:DRV:CAL_SCALE") # current scaling
  field(INPB, "1")# B = known reference, in power
  field(INPC, "$(CM,recursive)10:DRV:AMEAN") # current amplitude mean
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,recursive)10:DRV:CAL_SCALE PP") # new scaling
  field(PINI, "NO") # do not overwrite cal on startup
  info(autosaveFields, "B")
}

# Signal waveform mean converted to counts
# To be consistent with signals. Keep this?
record(calc, "$(CM,recursive)10:DRV:AMEAN_ADC") {
  field(DESC, "WF mean in counts")
  field(CALC, "FLOOR(C*A/B)")
  field(INPA, "$(CM,recursive)10:DRV:AMEAN CPP")
  field(INPB, "$(CM,recursive)10:DRV:CAL_SCALE")
  field(INPC, "32767")
  field(EGU,  "counts")
}
#==================================
#----------------------------------
# rf_sig_cal_simple.template:
#
# Scale factor to convert waveform
# fraction-of-full-scale readout 
# to engineering units: MV for cavity 
# signal; sqrt(Watts) for others
#----------------------------------
#==================================

record(ao, "$(CM,recursive)10:FWD:CAL_SCALE") {
  field(SCAN, "Passive")
  field(OMSL, "supervisory")
  field(PREC, "7")
  field(VAL,  "1")
  field(PINI, "YES")
  field(FLNK, "$(CM,recursive)10:FWD:SCALE_CALC")
  info(autosaveFields, "VAL")
}

# Unnecessary intermediate PV 
# to be compatible with wfCav.template
record(ao, "$(CM,recursive)10:FWD:SCALE_CALC") {
  field(OMSL, "closed_loop")
  field(DOL,  "$(CM,recursive)10:FWD:CAL_SCALE")
  field(FLNK, "$(CM,recursive)10:FWD:SCALE")
}

# When reference is in sqrt(Watts)
record(calcout, "$(CM,recursive)10:FWD:SCALETOREF") {
  field(CALC, "B*A/C")
  field(INPA, "$(CM,recursive)10:FWD:CAL_SCALE") # current scaling
  field(INPB, "1")# B = known reference, in power
  field(INPC, "$(CM,recursive)10:FWD:AMEAN") # current amplitude mean
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,recursive)10:FWD:CAL_SCALE PP") # new scaling
  field(PINI, "NO") # do not overwrite cal on startup
  info(autosaveFields, "B")
}

# Signal waveform mean converted to counts
# To be consistent with signals. Keep this?
record(calc, "$(CM,recursive)10:FWD:AMEAN_ADC") {
  field(DESC, "WF mean in counts")
  field(CALC, "FLOOR(C*A/B)")
  field(INPA, "$(CM,recursive)10:FWD:AMEAN CPP")
  field(INPB, "$(CM,recursive)10:FWD:CAL_SCALE")
  field(INPC, "32767")
  field(EGU,  "counts")
}
#==================================
#----------------------------------
# rf_sig_cal_simple.template:
#
# Scale factor to convert waveform
# fraction-of-full-scale readout 
# to engineering units: MV for cavity 
# signal; sqrt(Watts) for others
#----------------------------------
#==================================

record(ao, "$(CM,recursive)10:REV:CAL_SCALE") {
  field(SCAN, "Passive")
  field(OMSL, "supervisory")
  field(PREC, "7")
  field(VAL,  "1")
  field(PINI, "YES")
  field(FLNK, "$(CM,recursive)10:REV:SCALE_CALC")
  info(autosaveFields, "VAL")
}

# Unnecessary intermediate PV 
# to be compatible with wfCav.template
record(ao, "$(CM,recursive)10:REV:SCALE_CALC") {
  field(OMSL, "closed_loop")
  field(DOL,  "$(CM,recursive)10:REV:CAL_SCALE")
  field(FLNK, "$(CM,recursive)10:REV:SCALE")
}

# When reference is in sqrt(Watts)
record(calcout, "$(CM,recursive)10:REV:SCALETOREF") {
  field(CALC, "B*A/C")
  field(INPA, "$(CM,recursive)10:REV:CAL_SCALE") # current scaling
  field(INPB, "1")# B = known reference, in power
  field(INPC, "$(CM,recursive)10:REV:AMEAN") # current amplitude mean
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,recursive)10:REV:CAL_SCALE PP") # new scaling
  field(PINI, "NO") # do not overwrite cal on startup
  info(autosaveFields, "B")
}

# Signal waveform mean converted to counts
# To be consistent with signals. Keep this?
record(calc, "$(CM,recursive)10:REV:AMEAN_ADC") {
  field(DESC, "WF mean in counts")
  field(CALC, "FLOOR(C*A/B)")
  field(INPA, "$(CM,recursive)10:REV:AMEAN CPP")
  field(INPB, "$(CM,recursive)10:REV:CAL_SCALE")
  field(INPC, "32767")
  field(EGU,  "counts")
}
#==================================
#----------------------------------
# rf_sig_cal_simple.template:
#
# Scale factor to convert waveform
# fraction-of-full-scale readout 
# to engineering units: MV for cavity 
# signal; sqrt(Watts) for others
#----------------------------------
#==================================

record(ao, "$(CM,recursive)10:DAC:CAL_SCALE") {
  field(SCAN, "Passive")
  field(OMSL, "supervisory")
  field(PREC, "7")
  field(VAL,  "1")
  field(PINI, "YES")
  field(FLNK, "$(CM,recursive)10:DAC:SCALE_CALC")
  info(autosaveFields, "VAL")
}

# Unnecessary intermediate PV 
# to be compatible with wfCav.template
record(ao, "$(CM,recursive)10:DAC:SCALE_CALC") {
  field(OMSL, "closed_loop")
  field(DOL,  "$(CM,recursive)10:DAC:CAL_SCALE")
  field(FLNK, "$(CM,recursive)10:DAC:SCALE")
}

# When reference is in sqrt(Watts)
record(calcout, "$(CM,recursive)10:DAC:SCALETOREF") {
  field(CALC, "B*A/C")
  field(INPA, "$(CM,recursive)10:DAC:CAL_SCALE") # current scaling
  field(INPB, "1")# B = known reference, in power
  field(INPC, "$(CM,recursive)10:DAC:AMEAN") # current amplitude mean
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,recursive)10:DAC:CAL_SCALE PP") # new scaling
  field(PINI, "NO") # do not overwrite cal on startup
  info(autosaveFields, "B")
}

# Signal waveform mean converted to counts
# To be consistent with signals. Keep this?
record(calc, "$(CM,recursive)10:DAC:AMEAN_ADC") {
  field(DESC, "WF mean in counts")
  field(CALC, "FLOOR(C*A/B)")
  field(INPA, "$(CM,recursive)10:DAC:AMEAN CPP")
  field(INPB, "$(CM,recursive)10:DAC:CAL_SCALE")
  field(INPC, "32767")
  field(EGU,  "counts")
}
#==================================
#----------------------------------
# rf_sig_cal_simple.template:
#
# Scale factor to convert waveform
# fraction-of-full-scale readout 
# to engineering units: MV for cavity 
# signal; sqrt(Watts) for others
#----------------------------------
#==================================

record(ao, "$(CM,recursive)20:CAV:CAL_SCALE") {
  field(SCAN, "Passive")
  field(OMSL, "supervisory")
  field(PREC, "7")
  field(VAL,  "1")
  field(PINI, "YES")
  field(FLNK, "$(CM,recursive)20:CAV:SCALE_CALC")
  info(autosaveFields, "VAL")
}

# Unnecessary intermediate PV 
# to be compatible with wfCav.template
record(ao, "$(CM,recursive)20:CAV:SCALE_CALC") {
  field(OMSL, "closed_loop")
  field(DOL,  "$(CM,recursive)20:CAV:CAL_SCALE")
  field(FLNK, "$(CM,recursive)20:CAV:SCALE")
}

# When reference is in sqrt(Watts)
record(calcout, "$(CM,recursive)20:CAV:SCALETOREF") {
  field(CALC, "B*A/C")
  field(INPA, "$(CM,recursive)20:CAV:CAL_SCALE") # current scaling
  field(INPB, "1")# B = known reference, in power
  field(INPC, "$(CM,recursive)20:CAV:AMEAN") # current amplitude mean
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,recursive)20:CAV:CAL_SCALE PP") # new scaling
  field(PINI, "NO") # do not overwrite cal on startup
  info(autosaveFields, "B")
}

# Signal waveform mean converted to counts
# To be consistent with signals. Keep this?
record(calc, "$(CM,recursive)20:CAV:AMEAN_ADC") {
  field(DESC, "WF mean in counts")
  field(CALC, "FLOOR(C*A/B)")
  field(INPA, "$(CM,recursive)20:CAV:AMEAN CPP")
  field(INPB, "$(CM,recursive)20:CAV:CAL_SCALE")
  field(INPC, "32767")
  field(EGU,  "counts")
}
#==================================
#----------------------------------
# rf_sig_cal_simple.template:
#
# Scale factor to convert waveform
# fraction-of-full-scale readout 
# to engineering units: MV for cavity 
# signal; sqrt(Watts) for others
#----------------------------------
#==================================

record(ao, "$(CM,recursive)20:DRV:CAL_SCALE") {
  field(SCAN, "Passive")
  field(OMSL, "supervisory")
  field(PREC, "7")
  field(VAL,  "1")
  field(PINI, "YES")
  field(FLNK, "$(CM,recursive)20:DRV:SCALE_CALC")
  info(autosaveFields, "VAL")
}

# Unnecessary intermediate PV 
# to be compatible with wfCav.template
record(ao, "$(CM,recursive)20:DRV:SCALE_CALC") {
  field(OMSL, "closed_loop")
  field(DOL,  "$(CM,recursive)20:DRV:CAL_SCALE")
  field(FLNK, "$(CM,recursive)20:DRV:SCALE")
}

# When reference is in sqrt(Watts)
record(calcout, "$(CM,recursive)20:DRV:SCALETOREF") {
  field(CALC, "B*A/C")
  field(INPA, "$(CM,recursive)20:DRV:CAL_SCALE") # current scaling
  field(INPB, "1")# B = known reference, in power
  field(INPC, "$(CM,recursive)20:DRV:AMEAN") # current amplitude mean
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,recursive)20:DRV:CAL_SCALE PP") # new scaling
  field(PINI, "NO") # do not overwrite cal on startup
  info(autosaveFields, "B")
}

# Signal waveform mean converted to counts
# To be consistent with signals. Keep this?
record(calc, "$(CM,recursive)20:DRV:AMEAN_ADC") {
  field(DESC, "WF mean in counts")
  field(CALC, "FLOOR(C*A/B)")
  field(INPA, "$(CM,recursive)20:DRV:AMEAN CPP")
  field(INPB, "$(CM,recursive)20:DRV:CAL_SCALE")
  field(INPC, "32767")
  field(EGU,  "counts")
}
#==================================
#----------------------------------
# rf_sig_cal_simple.template:
#
# Scale factor to convert waveform
# fraction-of-full-scale readout 
# to engineering units: MV for cavity 
# signal; sqrt(Watts) for others
#----------------------------------
#==================================

record(ao, "$(CM,recursive)20:FWD:CAL_SCALE") {
  field(SCAN, "Passive")
  field(OMSL, "supervisory")
  field(PREC, "7")
  field(VAL,  "1")
  field(PINI, "YES")
  field(FLNK, "$(CM,recursive)20:FWD:SCALE_CALC")
  info(autosaveFields, "VAL")
}

# Unnecessary intermediate PV 
# to be compatible with wfCav.template
record(ao, "$(CM,recursive)20:FWD:SCALE_CALC") {
  field(OMSL, "closed_loop")
  field(DOL,  "$(CM,recursive)20:FWD:CAL_SCALE")
  field(FLNK, "$(CM,recursive)20:FWD:SCALE")
}

# When reference is in sqrt(Watts)
record(calcout, "$(CM,recursive)20:FWD:SCALETOREF") {
  field(CALC, "B*A/C")
  field(INPA, "$(CM,recursive)20:FWD:CAL_SCALE") # current scaling
  field(INPB, "1")# B = known reference, in power
  field(INPC, "$(CM,recursive)20:FWD:AMEAN") # current amplitude mean
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,recursive)20:FWD:CAL_SCALE PP") # new scaling
  field(PINI, "NO") # do not overwrite cal on startup
  info(autosaveFields, "B")
}

# Signal waveform mean converted to counts
# To be consistent with signals. Keep this?
record(calc, "$(CM,recursive)20:FWD:AMEAN_ADC") {
  field(DESC, "WF mean in counts")
  field(CALC, "FLOOR(C*A/B)")
  field(INPA, "$(CM,recursive)20:FWD:AMEAN CPP")
  field(INPB, "$(CM,recursive)20:FWD:CAL_SCALE")
  field(INPC, "32767")
  field(EGU,  "counts")
}
#==================================
#----------------------------------
# rf_sig_cal_simple.template:
#
# Scale factor to convert waveform
# fraction-of-full-scale readout 
# to engineering units: MV for cavity 
# signal; sqrt(Watts) for others
#----------------------------------
#==================================

record(ao, "$(CM,recursive)20:REV:CAL_SCALE") {
  field(SCAN, "Passive")
  field(OMSL, "supervisory")
  field(PREC, "7")
  field(VAL,  "1")
  field(PINI, "YES")
  field(FLNK, "$(CM,recursive)20:REV:SCALE_CALC")
  info(autosaveFields, "VAL")
}

# Unnecessary intermediate PV 
# to be compatible with wfCav.template
record(ao, "$(CM,recursive)20:REV:SCALE_CALC") {
  field(OMSL, "closed_loop")
  field(DOL,  "$(CM,recursive)20:REV:CAL_SCALE")
  field(FLNK, "$(CM,recursive)20:REV:SCALE")
}

# When reference is in sqrt(Watts)
record(calcout, "$(CM,recursive)20:REV:SCALETOREF") {
  field(CALC, "B*A/C")
  field(INPA, "$(CM,recursive)20:REV:CAL_SCALE") # current scaling
  field(INPB, "1")# B = known reference, in power
  field(INPC, "$(CM,recursive)20:REV:AMEAN") # current amplitude mean
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,recursive)20:REV:CAL_SCALE PP") # new scaling
  field(PINI, "NO") # do not overwrite cal on startup
  info(autosaveFields, "B")
}

# Signal waveform mean converted to counts
# To be consistent with signals. Keep this?
record(calc, "$(CM,recursive)20:REV:AMEAN_ADC") {
  field(DESC, "WF mean in counts")
  field(CALC, "FLOOR(C*A/B)")
  field(INPA, "$(CM,recursive)20:REV:AMEAN CPP")
  field(INPB, "$(CM,recursive)20:REV:CAL_SCALE")
  field(INPC, "32767")
  field(EGU,  "counts")
}
#==================================
#----------------------------------
# rf_sig_cal_simple.template:
#
# Scale factor to convert waveform
# fraction-of-full-scale readout 
# to engineering units: MV for cavity 
# signal; sqrt(Watts) for others
#----------------------------------
#==================================

record(ao, "$(CM,recursive)20:DAC:CAL_SCALE") {
  field(SCAN, "Passive")
  field(OMSL, "supervisory")
  field(PREC, "7")
  field(VAL,  "1")
  field(PINI, "YES")
  field(FLNK, "$(CM,recursive)20:DAC:SCALE_CALC")
  info(autosaveFields, "VAL")
}

# Unnecessary intermediate PV 
# to be compatible with wfCav.template
record(ao, "$(CM,recursive)20:DAC:SCALE_CALC") {
  field(OMSL, "closed_loop")
  field(DOL,  "$(CM,recursive)20:DAC:CAL_SCALE")
  field(FLNK, "$(CM,recursive)20:DAC:SCALE")
}

# When reference is in sqrt(Watts)
record(calcout, "$(CM,recursive)20:DAC:SCALETOREF") {
  field(CALC, "B*A/C")
  field(INPA, "$(CM,recursive)20:DAC:CAL_SCALE") # current scaling
  field(INPB, "1")# B = known reference, in power
  field(INPC, "$(CM,recursive)20:DAC:AMEAN") # current amplitude mean
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,recursive)20:DAC:CAL_SCALE PP") # new scaling
  field(PINI, "NO") # do not overwrite cal on startup
  info(autosaveFields, "B")
}

# Signal waveform mean converted to counts
# To be consistent with signals. Keep this?
record(calc, "$(CM,recursive)20:DAC:AMEAN_ADC") {
  field(DESC, "WF mean in counts")
  field(CALC, "FLOOR(C*A/B)")
  field(INPA, "$(CM,recursive)20:DAC:AMEAN CPP")
  field(INPB, "$(CM,recursive)20:DAC:CAL_SCALE")
  field(INPC, "32767")
  field(EGU,  "counts")
}
#==================================
#----------------------------------
# rf_sig_cal_simple.template:
#
# Scale factor to convert waveform
# fraction-of-full-scale readout 
# to engineering units: MV for cavity 
# signal; sqrt(Watts) for others
#----------------------------------
#==================================

record(ao, "$(CM,recursive)30:CAV:CAL_SCALE") {
  field(SCAN, "Passive")
  field(OMSL, "supervisory")
  field(PREC, "7")
  field(VAL,  "1")
  field(PINI, "YES")
  field(FLNK, "$(CM,recursive)30:CAV:SCALE_CALC")
  info(autosaveFields, "VAL")
}

# Unnecessary intermediate PV 
# to be compatible with wfCav.template
record(ao, "$(CM,recursive)30:CAV:SCALE_CALC") {
  field(OMSL, "closed_loop")
  field(DOL,  "$(CM,recursive)30:CAV:CAL_SCALE")
  field(FLNK, "$(CM,recursive)30:CAV:SCALE")
}

# When reference is in sqrt(Watts)
record(calcout, "$(CM,recursive)30:CAV:SCALETOREF") {
  field(CALC, "B*A/C")
  field(INPA, "$(CM,recursive)30:CAV:CAL_SCALE") # current scaling
  field(INPB, "1")# B = known reference, in power
  field(INPC, "$(CM,recursive)30:CAV:AMEAN") # current amplitude mean
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,recursive)30:CAV:CAL_SCALE PP") # new scaling
  field(PINI, "NO") # do not overwrite cal on startup
  info(autosaveFields, "B")
}

# Signal waveform mean converted to counts
# To be consistent with signals. Keep this?
record(calc, "$(CM,recursive)30:CAV:AMEAN_ADC") {
  field(DESC, "WF mean in counts")
  field(CALC, "FLOOR(C*A/B)")
  field(INPA, "$(CM,recursive)30:CAV:AMEAN CPP")
  field(INPB, "$(CM,recursive)30:CAV:CAL_SCALE")
  field(INPC, "32767")
  field(EGU,  "counts")
}
#==================================
#----------------------------------
# rf_sig_cal_simple.template:
#
# Scale factor to convert waveform
# fraction-of-full-scale readout 
# to engineering units: MV for cavity 
# signal; sqrt(Watts) for others
#----------------------------------
#==================================

record(ao, "$(CM,recursive)30:DRV:CAL_SCALE") {
  field(SCAN, "Passive")
  field(OMSL, "supervisory")
  field(PREC, "7")
  field(VAL,  "1")
  field(PINI, "YES")
  field(FLNK, "$(CM,recursive)30:DRV:SCALE_CALC")
  info(autosaveFields, "VAL")
}

# Unnecessary intermediate PV 
# to be compatible with wfCav.template
record(ao, "$(CM,recursive)30:DRV:SCALE_CALC") {
  field(OMSL, "closed_loop")
  field(DOL,  "$(CM,recursive)30:DRV:CAL_SCALE")
  field(FLNK, "$(CM,recursive)30:DRV:SCALE")
}

# When reference is in sqrt(Watts)
record(calcout, "$(CM,recursive)30:DRV:SCALETOREF") {
  field(CALC, "B*A/C")
  field(INPA, "$(CM,recursive)30:DRV:CAL_SCALE") # current scaling
  field(INPB, "1")# B = known reference, in power
  field(INPC, "$(CM,recursive)30:DRV:AMEAN") # current amplitude mean
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,recursive)30:DRV:CAL_SCALE PP") # new scaling
  field(PINI, "NO") # do not overwrite cal on startup
  info(autosaveFields, "B")
}

# Signal waveform mean converted to counts
# To be consistent with signals. Keep this?
record(calc, "$(CM,recursive)30:DRV:AMEAN_ADC") {
  field(DESC, "WF mean in counts")
  field(CALC, "FLOOR(C*A/B)")
  field(INPA, "$(CM,recursive)30:DRV:AMEAN CPP")
  field(INPB, "$(CM,recursive)30:DRV:CAL_SCALE")
  field(INPC, "32767")
  field(EGU,  "counts")
}
#==================================
#----------------------------------
# rf_sig_cal_simple.template:
#
# Scale factor to convert waveform
# fraction-of-full-scale readout 
# to engineering units: MV for cavity 
# signal; sqrt(Watts) for others
#----------------------------------
#==================================

record(ao, "$(CM,recursive)30:FWD:CAL_SCALE") {
  field(SCAN, "Passive")
  field(OMSL, "supervisory")
  field(PREC, "7")
  field(VAL,  "1")
  field(PINI, "YES")
  field(FLNK, "$(CM,recursive)30:FWD:SCALE_CALC")
  info(autosaveFields, "VAL")
}

# Unnecessary intermediate PV 
# to be compatible with wfCav.template
record(ao, "$(CM,recursive)30:FWD:SCALE_CALC") {
  field(OMSL, "closed_loop")
  field(DOL,  "$(CM,recursive)30:FWD:CAL_SCALE")
  field(FLNK, "$(CM,recursive)30:FWD:SCALE")
}

# When reference is in sqrt(Watts)
record(calcout, "$(CM,recursive)30:FWD:SCALETOREF") {
  field(CALC, "B*A/C")
  field(INPA, "$(CM,recursive)30:FWD:CAL_SCALE") # current scaling
  field(INPB, "1")# B = known reference, in power
  field(INPC, "$(CM,recursive)30:FWD:AMEAN") # current amplitude mean
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,recursive)30:FWD:CAL_SCALE PP") # new scaling
  field(PINI, "NO") # do not overwrite cal on startup
  info(autosaveFields, "B")
}

# Signal waveform mean converted to counts
# To be consistent with signals. Keep this?
record(calc, "$(CM,recursive)30:FWD:AMEAN_ADC") {
  field(DESC, "WF mean in counts")
  field(CALC, "FLOOR(C*A/B)")
  field(INPA, "$(CM,recursive)30:FWD:AMEAN CPP")
  field(INPB, "$(CM,recursive)30:FWD:CAL_SCALE")
  field(INPC, "32767")
  field(EGU,  "counts")
}
#==================================
#----------------------------------
# rf_sig_cal_simple.template:
#
# Scale factor to convert waveform
# fraction-of-full-scale readout 
# to engineering units: MV for cavity 
# signal; sqrt(Watts) for others
#----------------------------------
#==================================

record(ao, "$(CM,recursive)30:REV:CAL_SCALE") {
  field(SCAN, "Passive")
  field(OMSL, "supervisory")
  field(PREC, "7")
  field(VAL,  "1")
  field(PINI, "YES")
  field(FLNK, "$(CM,recursive)30:REV:SCALE_CALC")
  info(autosaveFields, "VAL")
}

# Unnecessary intermediate PV 
# to be compatible with wfCav.template
record(ao, "$(CM,recursive)30:REV:SCALE_CALC") {
  field(OMSL, "closed_loop")
  field(DOL,  "$(CM,recursive)30:REV:CAL_SCALE")
  field(FLNK, "$(CM,recursive)30:REV:SCALE")
}

# When reference is in sqrt(Watts)
record(calcout, "$(CM,recursive)30:REV:SCALETOREF") {
  field(CALC, "B*A/C")
  field(INPA, "$(CM,recursive)30:REV:CAL_SCALE") # current scaling
  field(INPB, "1")# B = known reference, in power
  field(INPC, "$(CM,recursive)30:REV:AMEAN") # current amplitude mean
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,recursive)30:REV:CAL_SCALE PP") # new scaling
  field(PINI, "NO") # do not overwrite cal on startup
  info(autosaveFields, "B")
}

# Signal waveform mean converted to counts
# To be consistent with signals. Keep this?
record(calc, "$(CM,recursive)30:REV:AMEAN_ADC") {
  field(DESC, "WF mean in counts")
  field(CALC, "FLOOR(C*A/B)")
  field(INPA, "$(CM,recursive)30:REV:AMEAN CPP")
  field(INPB, "$(CM,recursive)30:REV:CAL_SCALE")
  field(INPC, "32767")
  field(EGU,  "counts")
}
#==================================
#----------------------------------
# rf_sig_cal_simple.template:
#
# Scale factor to convert waveform
# fraction-of-full-scale readout 
# to engineering units: MV for cavity 
# signal; sqrt(Watts) for others
#----------------------------------
#==================================

record(ao, "$(CM,recursive)30:DAC:CAL_SCALE") {
  field(SCAN, "Passive")
  field(OMSL, "supervisory")
  field(PREC, "7")
  field(VAL,  "1")
  field(PINI, "YES")
  field(FLNK, "$(CM,recursive)30:DAC:SCALE_CALC")
  info(autosaveFields, "VAL")
}

# Unnecessary intermediate PV 
# to be compatible with wfCav.template
record(ao, "$(CM,recursive)30:DAC:SCALE_CALC") {
  field(OMSL, "closed_loop")
  field(DOL,  "$(CM,recursive)30:DAC:CAL_SCALE")
  field(FLNK, "$(CM,recursive)30:DAC:SCALE")
}

# When reference is in sqrt(Watts)
record(calcout, "$(CM,recursive)30:DAC:SCALETOREF") {
  field(CALC, "B*A/C")
  field(INPA, "$(CM,recursive)30:DAC:CAL_SCALE") # current scaling
  field(INPB, "1")# B = known reference, in power
  field(INPC, "$(CM,recursive)30:DAC:AMEAN") # current amplitude mean
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,recursive)30:DAC:CAL_SCALE PP") # new scaling
  field(PINI, "NO") # do not overwrite cal on startup
  info(autosaveFields, "B")
}

# Signal waveform mean converted to counts
# To be consistent with signals. Keep this?
record(calc, "$(CM,recursive)30:DAC:AMEAN_ADC") {
  field(DESC, "WF mean in counts")
  field(CALC, "FLOOR(C*A/B)")
  field(INPA, "$(CM,recursive)30:DAC:AMEAN CPP")
  field(INPB, "$(CM,recursive)30:DAC:CAL_SCALE")
  field(INPC, "32767")
  field(EGU,  "counts")
}
#==================================
#----------------------------------
# rf_sig_cal_simple.template:
#
# Scale factor to convert waveform
# fraction-of-full-scale readout 
# to engineering units: MV for cavity 
# signal; sqrt(Watts) for others
#----------------------------------
#==================================

record(ao, "$(CM,recursive)40:CAV:CAL_SCALE") {
  field(SCAN, "Passive")
  field(OMSL, "supervisory")
  field(PREC, "7")
  field(VAL,  "1")
  field(PINI, "YES")
  field(FLNK, "$(CM,recursive)40:CAV:SCALE_CALC")
  info(autosaveFields, "VAL")
}

# Unnecessary intermediate PV 
# to be compatible with wfCav.template
record(ao, "$(CM,recursive)40:CAV:SCALE_CALC") {
  field(OMSL, "closed_loop")
  field(DOL,  "$(CM,recursive)40:CAV:CAL_SCALE")
  field(FLNK, "$(CM,recursive)40:CAV:SCALE")
}

# When reference is in sqrt(Watts)
record(calcout, "$(CM,recursive)40:CAV:SCALETOREF") {
  field(CALC, "B*A/C")
  field(INPA, "$(CM,recursive)40:CAV:CAL_SCALE") # current scaling
  field(INPB, "1")# B = known reference, in power
  field(INPC, "$(CM,recursive)40:CAV:AMEAN") # current amplitude mean
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,recursive)40:CAV:CAL_SCALE PP") # new scaling
  field(PINI, "NO") # do not overwrite cal on startup
  info(autosaveFields, "B")
}

# Signal waveform mean converted to counts
# To be consistent with signals. Keep this?
record(calc, "$(CM,recursive)40:CAV:AMEAN_ADC") {
  field(DESC, "WF mean in counts")
  field(CALC, "FLOOR(C*A/B)")
  field(INPA, "$(CM,recursive)40:CAV:AMEAN CPP")
  field(INPB, "$(CM,recursive)40:CAV:CAL_SCALE")
  field(INPC, "32767")
  field(EGU,  "counts")
}
#==================================
#----------------------------------
# rf_sig_cal_simple.template:
#
# Scale factor to convert waveform
# fraction-of-full-scale readout 
# to engineering units: MV for cavity 
# signal; sqrt(Watts) for others
#----------------------------------
#==================================

record(ao, "$(CM,recursive)40:DRV:CAL_SCALE") {
  field(SCAN, "Passive")
  field(OMSL, "supervisory")
  field(PREC, "7")
  field(VAL,  "1")
  field(PINI, "YES")
  field(FLNK, "$(CM,recursive)40:DRV:SCALE_CALC")
  info(autosaveFields, "VAL")
}

# Unnecessary intermediate PV 
# to be compatible with wfCav.template
record(ao, "$(CM,recursive)40:DRV:SCALE_CALC") {
  field(OMSL, "closed_loop")
  field(DOL,  "$(CM,recursive)40:DRV:CAL_SCALE")
  field(FLNK, "$(CM,recursive)40:DRV:SCALE")
}

# When reference is in sqrt(Watts)
record(calcout, "$(CM,recursive)40:DRV:SCALETOREF") {
  field(CALC, "B*A/C")
  field(INPA, "$(CM,recursive)40:DRV:CAL_SCALE") # current scaling
  field(INPB, "1")# B = known reference, in power
  field(INPC, "$(CM,recursive)40:DRV:AMEAN") # current amplitude mean
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,recursive)40:DRV:CAL_SCALE PP") # new scaling
  field(PINI, "NO") # do not overwrite cal on startup
  info(autosaveFields, "B")
}

# Signal waveform mean converted to counts
# To be consistent with signals. Keep this?
record(calc, "$(CM,recursive)40:DRV:AMEAN_ADC") {
  field(DESC, "WF mean in counts")
  field(CALC, "FLOOR(C*A/B)")
  field(INPA, "$(CM,recursive)40:DRV:AMEAN CPP")
  field(INPB, "$(CM,recursive)40:DRV:CAL_SCALE")
  field(INPC, "32767")
  field(EGU,  "counts")
}
#==================================
#----------------------------------
# rf_sig_cal_simple.template:
#
# Scale factor to convert waveform
# fraction-of-full-scale readout 
# to engineering units: MV for cavity 
# signal; sqrt(Watts) for others
#----------------------------------
#==================================

record(ao, "$(CM,recursive)40:FWD:CAL_SCALE") {
  field(SCAN, "Passive")
  field(OMSL, "supervisory")
  field(PREC, "7")
  field(VAL,  "1")
  field(PINI, "YES")
  field(FLNK, "$(CM,recursive)40:FWD:SCALE_CALC")
  info(autosaveFields, "VAL")
}

# Unnecessary intermediate PV 
# to be compatible with wfCav.template
record(ao, "$(CM,recursive)40:FWD:SCALE_CALC") {
  field(OMSL, "closed_loop")
  field(DOL,  "$(CM,recursive)40:FWD:CAL_SCALE")
  field(FLNK, "$(CM,recursive)40:FWD:SCALE")
}

# When reference is in sqrt(Watts)
record(calcout, "$(CM,recursive)40:FWD:SCALETOREF") {
  field(CALC, "B*A/C")
  field(INPA, "$(CM,recursive)40:FWD:CAL_SCALE") # current scaling
  field(INPB, "1")# B = known reference, in power
  field(INPC, "$(CM,recursive)40:FWD:AMEAN") # current amplitude mean
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,recursive)40:FWD:CAL_SCALE PP") # new scaling
  field(PINI, "NO") # do not overwrite cal on startup
  info(autosaveFields, "B")
}

# Signal waveform mean converted to counts
# To be consistent with signals. Keep this?
record(calc, "$(CM,recursive)40:FWD:AMEAN_ADC") {
  field(DESC, "WF mean in counts")
  field(CALC, "FLOOR(C*A/B)")
  field(INPA, "$(CM,recursive)40:FWD:AMEAN CPP")
  field(INPB, "$(CM,recursive)40:FWD:CAL_SCALE")
  field(INPC, "32767")
  field(EGU,  "counts")
}
#==================================
#----------------------------------
# rf_sig_cal_simple.template:
#
# Scale factor to convert waveform
# fraction-of-full-scale readout 
# to engineering units: MV for cavity 
# signal; sqrt(Watts) for others
#----------------------------------
#==================================

record(ao, "$(CM,recursive)40:REV:CAL_SCALE") {
  field(SCAN, "Passive")
  field(OMSL, "supervisory")
  field(PREC, "7")
  field(VAL,  "1")
  field(PINI, "YES")
  field(FLNK, "$(CM,recursive)40:REV:SCALE_CALC")
  info(autosaveFields, "VAL")
}

# Unnecessary intermediate PV 
# to be compatible with wfCav.template
record(ao, "$(CM,recursive)40:REV:SCALE_CALC") {
  field(OMSL, "closed_loop")
  field(DOL,  "$(CM,recursive)40:REV:CAL_SCALE")
  field(FLNK, "$(CM,recursive)40:REV:SCALE")
}

# When reference is in sqrt(Watts)
record(calcout, "$(CM,recursive)40:REV:SCALETOREF") {
  field(CALC, "B*A/C")
  field(INPA, "$(CM,recursive)40:REV:CAL_SCALE") # current scaling
  field(INPB, "1")# B = known reference, in power
  field(INPC, "$(CM,recursive)40:REV:AMEAN") # current amplitude mean
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,recursive)40:REV:CAL_SCALE PP") # new scaling
  field(PINI, "NO") # do not overwrite cal on startup
  info(autosaveFields, "B")
}

# Signal waveform mean converted to counts
# To be consistent with signals. Keep this?
record(calc, "$(CM,recursive)40:REV:AMEAN_ADC") {
  field(DESC, "WF mean in counts")
  field(CALC, "FLOOR(C*A/B)")
  field(INPA, "$(CM,recursive)40:REV:AMEAN CPP")
  field(INPB, "$(CM,recursive)40:REV:CAL_SCALE")
  field(INPC, "32767")
  field(EGU,  "counts")
}
#==================================
#----------------------------------
# rf_sig_cal_simple.template:
#
# Scale factor to convert waveform
# fraction-of-full-scale readout 
# to engineering units: MV for cavity 
# signal; sqrt(Watts) for others
#----------------------------------
#==================================

record(ao, "$(CM,recursive)40:DAC:CAL_SCALE") {
  field(SCAN, "Passive")
  field(OMSL, "supervisory")
  field(PREC, "7")
  field(VAL,  "1")
  field(PINI, "YES")
  field(FLNK, "$(CM,recursive)40:DAC:SCALE_CALC")
  info(autosaveFields, "VAL")
}

# Unnecessary intermediate PV 
# to be compatible with wfCav.template
record(ao, "$(CM,recursive)40:DAC:SCALE_CALC") {
  field(OMSL, "closed_loop")
  field(DOL,  "$(CM,recursive)40:DAC:CAL_SCALE")
  field(FLNK, "$(CM,recursive)40:DAC:SCALE")
}

# When reference is in sqrt(Watts)
record(calcout, "$(CM,recursive)40:DAC:SCALETOREF") {
  field(CALC, "B*A/C")
  field(INPA, "$(CM,recursive)40:DAC:CAL_SCALE") # current scaling
  field(INPB, "1")# B = known reference, in power
  field(INPC, "$(CM,recursive)40:DAC:AMEAN") # current amplitude mean
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,recursive)40:DAC:CAL_SCALE PP") # new scaling
  field(PINI, "NO") # do not overwrite cal on startup
  info(autosaveFields, "B")
}

# Signal waveform mean converted to counts
# To be consistent with signals. Keep this?
record(calc, "$(CM,recursive)40:DAC:AMEAN_ADC") {
  field(DESC, "WF mean in counts")
  field(CALC, "FLOOR(C*A/B)")
  field(INPA, "$(CM,recursive)40:DAC:AMEAN CPP")
  field(INPB, "$(CM,recursive)40:DAC:CAL_SCALE")
  field(INPC, "32767")
  field(EGU,  "counts")
}
#==================================
#----------------------------------
# rf_sig_cal_simple.template:
#
# Scale factor to convert waveform
# fraction-of-full-scale readout 
# to engineering units: MV for cavity 
# signal; sqrt(Watts) for others
#----------------------------------
#==================================

record(ao, "$(CM,recursive)50:CAV:CAL_SCALE") {
  field(SCAN, "Passive")
  field(OMSL, "supervisory")
  field(PREC, "7")
  field(VAL,  "1")
  field(PINI, "YES")
  field(FLNK, "$(CM,recursive)50:CAV:SCALE_CALC")
  info(autosaveFields, "VAL")
}

# Unnecessary intermediate PV 
# to be compatible with wfCav.template
record(ao, "$(CM,recursive)50:CAV:SCALE_CALC") {
  field(OMSL, "closed_loop")
  field(DOL,  "$(CM,recursive)50:CAV:CAL_SCALE")
  field(FLNK, "$(CM,recursive)50:CAV:SCALE")
}

# When reference is in sqrt(Watts)
record(calcout, "$(CM,recursive)50:CAV:SCALETOREF") {
  field(CALC, "B*A/C")
  field(INPA, "$(CM,recursive)50:CAV:CAL_SCALE") # current scaling
  field(INPB, "1")# B = known reference, in power
  field(INPC, "$(CM,recursive)50:CAV:AMEAN") # current amplitude mean
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,recursive)50:CAV:CAL_SCALE PP") # new scaling
  field(PINI, "NO") # do not overwrite cal on startup
  info(autosaveFields, "B")
}

# Signal waveform mean converted to counts
# To be consistent with signals. Keep this?
record(calc, "$(CM,recursive)50:CAV:AMEAN_ADC") {
  field(DESC, "WF mean in counts")
  field(CALC, "FLOOR(C*A/B)")
  field(INPA, "$(CM,recursive)50:CAV:AMEAN CPP")
  field(INPB, "$(CM,recursive)50:CAV:CAL_SCALE")
  field(INPC, "32767")
  field(EGU,  "counts")
}
#==================================
#----------------------------------
# rf_sig_cal_simple.template:
#
# Scale factor to convert waveform
# fraction-of-full-scale readout 
# to engineering units: MV for cavity 
# signal; sqrt(Watts) for others
#----------------------------------
#==================================

record(ao, "$(CM,recursive)50:DRV:CAL_SCALE") {
  field(SCAN, "Passive")
  field(OMSL, "supervisory")
  field(PREC, "7")
  field(VAL,  "1")
  field(PINI, "YES")
  field(FLNK, "$(CM,recursive)50:DRV:SCALE_CALC")
  info(autosaveFields, "VAL")
}

# Unnecessary intermediate PV 
# to be compatible with wfCav.template
record(ao, "$(CM,recursive)50:DRV:SCALE_CALC") {
  field(OMSL, "closed_loop")
  field(DOL,  "$(CM,recursive)50:DRV:CAL_SCALE")
  field(FLNK, "$(CM,recursive)50:DRV:SCALE")
}

# When reference is in sqrt(Watts)
record(calcout, "$(CM,recursive)50:DRV:SCALETOREF") {
  field(CALC, "B*A/C")
  field(INPA, "$(CM,recursive)50:DRV:CAL_SCALE") # current scaling
  field(INPB, "1")# B = known reference, in power
  field(INPC, "$(CM,recursive)50:DRV:AMEAN") # current amplitude mean
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,recursive)50:DRV:CAL_SCALE PP") # new scaling
  field(PINI, "NO") # do not overwrite cal on startup
  info(autosaveFields, "B")
}

# Signal waveform mean converted to counts
# To be consistent with signals. Keep this?
record(calc, "$(CM,recursive)50:DRV:AMEAN_ADC") {
  field(DESC, "WF mean in counts")
  field(CALC, "FLOOR(C*A/B)")
  field(INPA, "$(CM,recursive)50:DRV:AMEAN CPP")
  field(INPB, "$(CM,recursive)50:DRV:CAL_SCALE")
  field(INPC, "32767")
  field(EGU,  "counts")
}
#==================================
#----------------------------------
# rf_sig_cal_simple.template:
#
# Scale factor to convert waveform
# fraction-of-full-scale readout 
# to engineering units: MV for cavity 
# signal; sqrt(Watts) for others
#----------------------------------
#==================================

record(ao, "$(CM,recursive)50:FWD:CAL_SCALE") {
  field(SCAN, "Passive")
  field(OMSL, "supervisory")
  field(PREC, "7")
  field(VAL,  "1")
  field(PINI, "YES")
  field(FLNK, "$(CM,recursive)50:FWD:SCALE_CALC")
  info(autosaveFields, "VAL")
}

# Unnecessary intermediate PV 
# to be compatible with wfCav.template
record(ao, "$(CM,recursive)50:FWD:SCALE_CALC") {
  field(OMSL, "closed_loop")
  field(DOL,  "$(CM,recursive)50:FWD:CAL_SCALE")
  field(FLNK, "$(CM,recursive)50:FWD:SCALE")
}

# When reference is in sqrt(Watts)
record(calcout, "$(CM,recursive)50:FWD:SCALETOREF") {
  field(CALC, "B*A/C")
  field(INPA, "$(CM,recursive)50:FWD:CAL_SCALE") # current scaling
  field(INPB, "1")# B = known reference, in power
  field(INPC, "$(CM,recursive)50:FWD:AMEAN") # current amplitude mean
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,recursive)50:FWD:CAL_SCALE PP") # new scaling
  field(PINI, "NO") # do not overwrite cal on startup
  info(autosaveFields, "B")
}

# Signal waveform mean converted to counts
# To be consistent with signals. Keep this?
record(calc, "$(CM,recursive)50:FWD:AMEAN_ADC") {
  field(DESC, "WF mean in counts")
  field(CALC, "FLOOR(C*A/B)")
  field(INPA, "$(CM,recursive)50:FWD:AMEAN CPP")
  field(INPB, "$(CM,recursive)50:FWD:CAL_SCALE")
  field(INPC, "32767")
  field(EGU,  "counts")
}
#==================================
#----------------------------------
# rf_sig_cal_simple.template:
#
# Scale factor to convert waveform
# fraction-of-full-scale readout 
# to engineering units: MV for cavity 
# signal; sqrt(Watts) for others
#----------------------------------
#==================================

record(ao, "$(CM,recursive)50:REV:CAL_SCALE") {
  field(SCAN, "Passive")
  field(OMSL, "supervisory")
  field(PREC, "7")
  field(VAL,  "1")
  field(PINI, "YES")
  field(FLNK, "$(CM,recursive)50:REV:SCALE_CALC")
  info(autosaveFields, "VAL")
}

# Unnecessary intermediate PV 
# to be compatible with wfCav.template
record(ao, "$(CM,recursive)50:REV:SCALE_CALC") {
  field(OMSL, "closed_loop")
  field(DOL,  "$(CM,recursive)50:REV:CAL_SCALE")
  field(FLNK, "$(CM,recursive)50:REV:SCALE")
}

# When reference is in sqrt(Watts)
record(calcout, "$(CM,recursive)50:REV:SCALETOREF") {
  field(CALC, "B*A/C")
  field(INPA, "$(CM,recursive)50:REV:CAL_SCALE") # current scaling
  field(INPB, "1")# B = known reference, in power
  field(INPC, "$(CM,recursive)50:REV:AMEAN") # current amplitude mean
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,recursive)50:REV:CAL_SCALE PP") # new scaling
  field(PINI, "NO") # do not overwrite cal on startup
  info(autosaveFields, "B")
}

# Signal waveform mean converted to counts
# To be consistent with signals. Keep this?
record(calc, "$(CM,recursive)50:REV:AMEAN_ADC") {
  field(DESC, "WF mean in counts")
  field(CALC, "FLOOR(C*A/B)")
  field(INPA, "$(CM,recursive)50:REV:AMEAN CPP")
  field(INPB, "$(CM,recursive)50:REV:CAL_SCALE")
  field(INPC, "32767")
  field(EGU,  "counts")
}
#==================================
#----------------------------------
# rf_sig_cal_simple.template:
#
# Scale factor to convert waveform
# fraction-of-full-scale readout 
# to engineering units: MV for cavity 
# signal; sqrt(Watts) for others
#----------------------------------
#==================================

record(ao, "$(CM,recursive)50:DAC:CAL_SCALE") {
  field(SCAN, "Passive")
  field(OMSL, "supervisory")
  field(PREC, "7")
  field(VAL,  "1")
  field(PINI, "YES")
  field(FLNK, "$(CM,recursive)50:DAC:SCALE_CALC")
  info(autosaveFields, "VAL")
}

# Unnecessary intermediate PV 
# to be compatible with wfCav.template
record(ao, "$(CM,recursive)50:DAC:SCALE_CALC") {
  field(OMSL, "closed_loop")
  field(DOL,  "$(CM,recursive)50:DAC:CAL_SCALE")
  field(FLNK, "$(CM,recursive)50:DAC:SCALE")
}

# When reference is in sqrt(Watts)
record(calcout, "$(CM,recursive)50:DAC:SCALETOREF") {
  field(CALC, "B*A/C")
  field(INPA, "$(CM,recursive)50:DAC:CAL_SCALE") # current scaling
  field(INPB, "1")# B = known reference, in power
  field(INPC, "$(CM,recursive)50:DAC:AMEAN") # current amplitude mean
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,recursive)50:DAC:CAL_SCALE PP") # new scaling
  field(PINI, "NO") # do not overwrite cal on startup
  info(autosaveFields, "B")
}

# Signal waveform mean converted to counts
# To be consistent with signals. Keep this?
record(calc, "$(CM,recursive)50:DAC:AMEAN_ADC") {
  field(DESC, "WF mean in counts")
  field(CALC, "FLOOR(C*A/B)")
  field(INPA, "$(CM,recursive)50:DAC:AMEAN CPP")
  field(INPB, "$(CM,recursive)50:DAC:CAL_SCALE")
  field(INPC, "32767")
  field(EGU,  "counts")
}
#==================================
#----------------------------------
# rf_sig_cal_simple.template:
#
# Scale factor to convert waveform
# fraction-of-full-scale readout 
# to engineering units: MV for cavity 
# signal; sqrt(Watts) for others
#----------------------------------
#==================================

record(ao, "$(CM,recursive)60:CAV:CAL_SCALE") {
  field(SCAN, "Passive")
  field(OMSL, "supervisory")
  field(PREC, "7")
  field(VAL,  "1")
  field(PINI, "YES")
  field(FLNK, "$(CM,recursive)60:CAV:SCALE_CALC")
  info(autosaveFields, "VAL")
}

# Unnecessary intermediate PV 
# to be compatible with wfCav.template
record(ao, "$(CM,recursive)60:CAV:SCALE_CALC") {
  field(OMSL, "closed_loop")
  field(DOL,  "$(CM,recursive)60:CAV:CAL_SCALE")
  field(FLNK, "$(CM,recursive)60:CAV:SCALE")
}

# When reference is in sqrt(Watts)
record(calcout, "$(CM,recursive)60:CAV:SCALETOREF") {
  field(CALC, "B*A/C")
  field(INPA, "$(CM,recursive)60:CAV:CAL_SCALE") # current scaling
  field(INPB, "1")# B = known reference, in power
  field(INPC, "$(CM,recursive)60:CAV:AMEAN") # current amplitude mean
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,recursive)60:CAV:CAL_SCALE PP") # new scaling
  field(PINI, "NO") # do not overwrite cal on startup
  info(autosaveFields, "B")
}

# Signal waveform mean converted to counts
# To be consistent with signals. Keep this?
record(calc, "$(CM,recursive)60:CAV:AMEAN_ADC") {
  field(DESC, "WF mean in counts")
  field(CALC, "FLOOR(C*A/B)")
  field(INPA, "$(CM,recursive)60:CAV:AMEAN CPP")
  field(INPB, "$(CM,recursive)60:CAV:CAL_SCALE")
  field(INPC, "32767")
  field(EGU,  "counts")
}
#==================================
#----------------------------------
# rf_sig_cal_simple.template:
#
# Scale factor to convert waveform
# fraction-of-full-scale readout 
# to engineering units: MV for cavity 
# signal; sqrt(Watts) for others
#----------------------------------
#==================================

record(ao, "$(CM,recursive)60:DRV:CAL_SCALE") {
  field(SCAN, "Passive")
  field(OMSL, "supervisory")
  field(PREC, "7")
  field(VAL,  "1")
  field(PINI, "YES")
  field(FLNK, "$(CM,recursive)60:DRV:SCALE_CALC")
  info(autosaveFields, "VAL")
}

# Unnecessary intermediate PV 
# to be compatible with wfCav.template
record(ao, "$(CM,recursive)60:DRV:SCALE_CALC") {
  field(OMSL, "closed_loop")
  field(DOL,  "$(CM,recursive)60:DRV:CAL_SCALE")
  field(FLNK, "$(CM,recursive)60:DRV:SCALE")
}

# When reference is in sqrt(Watts)
record(calcout, "$(CM,recursive)60:DRV:SCALETOREF") {
  field(CALC, "B*A/C")
  field(INPA, "$(CM,recursive)60:DRV:CAL_SCALE") # current scaling
  field(INPB, "1")# B = known reference, in power
  field(INPC, "$(CM,recursive)60:DRV:AMEAN") # current amplitude mean
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,recursive)60:DRV:CAL_SCALE PP") # new scaling
  field(PINI, "NO") # do not overwrite cal on startup
  info(autosaveFields, "B")
}

# Signal waveform mean converted to counts
# To be consistent with signals. Keep this?
record(calc, "$(CM,recursive)60:DRV:AMEAN_ADC") {
  field(DESC, "WF mean in counts")
  field(CALC, "FLOOR(C*A/B)")
  field(INPA, "$(CM,recursive)60:DRV:AMEAN CPP")
  field(INPB, "$(CM,recursive)60:DRV:CAL_SCALE")
  field(INPC, "32767")
  field(EGU,  "counts")
}
#==================================
#----------------------------------
# rf_sig_cal_simple.template:
#
# Scale factor to convert waveform
# fraction-of-full-scale readout 
# to engineering units: MV for cavity 
# signal; sqrt(Watts) for others
#----------------------------------
#==================================

record(ao, "$(CM,recursive)60:FWD:CAL_SCALE") {
  field(SCAN, "Passive")
  field(OMSL, "supervisory")
  field(PREC, "7")
  field(VAL,  "1")
  field(PINI, "YES")
  field(FLNK, "$(CM,recursive)60:FWD:SCALE_CALC")
  info(autosaveFields, "VAL")
}

# Unnecessary intermediate PV 
# to be compatible with wfCav.template
record(ao, "$(CM,recursive)60:FWD:SCALE_CALC") {
  field(OMSL, "closed_loop")
  field(DOL,  "$(CM,recursive)60:FWD:CAL_SCALE")
  field(FLNK, "$(CM,recursive)60:FWD:SCALE")
}

# When reference is in sqrt(Watts)
record(calcout, "$(CM,recursive)60:FWD:SCALETOREF") {
  field(CALC, "B*A/C")
  field(INPA, "$(CM,recursive)60:FWD:CAL_SCALE") # current scaling
  field(INPB, "1")# B = known reference, in power
  field(INPC, "$(CM,recursive)60:FWD:AMEAN") # current amplitude mean
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,recursive)60:FWD:CAL_SCALE PP") # new scaling
  field(PINI, "NO") # do not overwrite cal on startup
  info(autosaveFields, "B")
}

# Signal waveform mean converted to counts
# To be consistent with signals. Keep this?
record(calc, "$(CM,recursive)60:FWD:AMEAN_ADC") {
  field(DESC, "WF mean in counts")
  field(CALC, "FLOOR(C*A/B)")
  field(INPA, "$(CM,recursive)60:FWD:AMEAN CPP")
  field(INPB, "$(CM,recursive)60:FWD:CAL_SCALE")
  field(INPC, "32767")
  field(EGU,  "counts")
}
#==================================
#----------------------------------
# rf_sig_cal_simple.template:
#
# Scale factor to convert waveform
# fraction-of-full-scale readout 
# to engineering units: MV for cavity 
# signal; sqrt(Watts) for others
#----------------------------------
#==================================

record(ao, "$(CM,recursive)60:REV:CAL_SCALE") {
  field(SCAN, "Passive")
  field(OMSL, "supervisory")
  field(PREC, "7")
  field(VAL,  "1")
  field(PINI, "YES")
  field(FLNK, "$(CM,recursive)60:REV:SCALE_CALC")
  info(autosaveFields, "VAL")
}

# Unnecessary intermediate PV 
# to be compatible with wfCav.template
record(ao, "$(CM,recursive)60:REV:SCALE_CALC") {
  field(OMSL, "closed_loop")
  field(DOL,  "$(CM,recursive)60:REV:CAL_SCALE")
  field(FLNK, "$(CM,recursive)60:REV:SCALE")
}

# When reference is in sqrt(Watts)
record(calcout, "$(CM,recursive)60:REV:SCALETOREF") {
  field(CALC, "B*A/C")
  field(INPA, "$(CM,recursive)60:REV:CAL_SCALE") # current scaling
  field(INPB, "1")# B = known reference, in power
  field(INPC, "$(CM,recursive)60:REV:AMEAN") # current amplitude mean
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,recursive)60:REV:CAL_SCALE PP") # new scaling
  field(PINI, "NO") # do not overwrite cal on startup
  info(autosaveFields, "B")
}

# Signal waveform mean converted to counts
# To be consistent with signals. Keep this?
record(calc, "$(CM,recursive)60:REV:AMEAN_ADC") {
  field(DESC, "WF mean in counts")
  field(CALC, "FLOOR(C*A/B)")
  field(INPA, "$(CM,recursive)60:REV:AMEAN CPP")
  field(INPB, "$(CM,recursive)60:REV:CAL_SCALE")
  field(INPC, "32767")
  field(EGU,  "counts")
}
#==================================
#----------------------------------
# rf_sig_cal_simple.template:
#
# Scale factor to convert waveform
# fraction-of-full-scale readout 
# to engineering units: MV for cavity 
# signal; sqrt(Watts) for others
#----------------------------------
#==================================

record(ao, "$(CM,recursive)60:DAC:CAL_SCALE") {
  field(SCAN, "Passive")
  field(OMSL, "supervisory")
  field(PREC, "7")
  field(VAL,  "1")
  field(PINI, "YES")
  field(FLNK, "$(CM,recursive)60:DAC:SCALE_CALC")
  info(autosaveFields, "VAL")
}

# Unnecessary intermediate PV 
# to be compatible with wfCav.template
record(ao, "$(CM,recursive)60:DAC:SCALE_CALC") {
  field(OMSL, "closed_loop")
  field(DOL,  "$(CM,recursive)60:DAC:CAL_SCALE")
  field(FLNK, "$(CM,recursive)60:DAC:SCALE")
}

# When reference is in sqrt(Watts)
record(calcout, "$(CM,recursive)60:DAC:SCALETOREF") {
  field(CALC, "B*A/C")
  field(INPA, "$(CM,recursive)60:DAC:CAL_SCALE") # current scaling
  field(INPB, "1")# B = known reference, in power
  field(INPC, "$(CM,recursive)60:DAC:AMEAN") # current amplitude mean
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,recursive)60:DAC:CAL_SCALE PP") # new scaling
  field(PINI, "NO") # do not overwrite cal on startup
  info(autosaveFields, "B")
}

# Signal waveform mean converted to counts
# To be consistent with signals. Keep this?
record(calc, "$(CM,recursive)60:DAC:AMEAN_ADC") {
  field(DESC, "WF mean in counts")
  field(CALC, "FLOOR(C*A/B)")
  field(INPA, "$(CM,recursive)60:DAC:AMEAN CPP")
  field(INPB, "$(CM,recursive)60:DAC:CAL_SCALE")
  field(INPC, "32767")
  field(EGU,  "counts")
}
#==================================
#----------------------------------
# rf_sig_cal_simple.template:
#
# Scale factor to convert waveform
# fraction-of-full-scale readout 
# to engineering units: MV for cavity 
# signal; sqrt(Watts) for others
#----------------------------------
#==================================

record(ao, "$(CM,recursive)70:CAV:CAL_SCALE") {
  field(SCAN, "Passive")
  field(OMSL, "supervisory")
  field(PREC, "7")
  field(VAL,  "1")
  field(PINI, "YES")
  field(FLNK, "$(CM,recursive)70:CAV:SCALE_CALC")
  info(autosaveFields, "VAL")
}

# Unnecessary intermediate PV 
# to be compatible with wfCav.template
record(ao, "$(CM,recursive)70:CAV:SCALE_CALC") {
  field(OMSL, "closed_loop")
  field(DOL,  "$(CM,recursive)70:CAV:CAL_SCALE")
  field(FLNK, "$(CM,recursive)70:CAV:SCALE")
}

# When reference is in sqrt(Watts)
record(calcout, "$(CM,recursive)70:CAV:SCALETOREF") {
  field(CALC, "B*A/C")
  field(INPA, "$(CM,recursive)70:CAV:CAL_SCALE") # current scaling
  field(INPB, "1")# B = known reference, in power
  field(INPC, "$(CM,recursive)70:CAV:AMEAN") # current amplitude mean
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,recursive)70:CAV:CAL_SCALE PP") # new scaling
  field(PINI, "NO") # do not overwrite cal on startup
  info(autosaveFields, "B")
}

# Signal waveform mean converted to counts
# To be consistent with signals. Keep this?
record(calc, "$(CM,recursive)70:CAV:AMEAN_ADC") {
  field(DESC, "WF mean in counts")
  field(CALC, "FLOOR(C*A/B)")
  field(INPA, "$(CM,recursive)70:CAV:AMEAN CPP")
  field(INPB, "$(CM,recursive)70:CAV:CAL_SCALE")
  field(INPC, "32767")
  field(EGU,  "counts")
}
#==================================
#----------------------------------
# rf_sig_cal_simple.template:
#
# Scale factor to convert waveform
# fraction-of-full-scale readout 
# to engineering units: MV for cavity 
# signal; sqrt(Watts) for others
#----------------------------------
#==================================

record(ao, "$(CM,recursive)70:DRV:CAL_SCALE") {
  field(SCAN, "Passive")
  field(OMSL, "supervisory")
  field(PREC, "7")
  field(VAL,  "1")
  field(PINI, "YES")
  field(FLNK, "$(CM,recursive)70:DRV:SCALE_CALC")
  info(autosaveFields, "VAL")
}

# Unnecessary intermediate PV 
# to be compatible with wfCav.template
record(ao, "$(CM,recursive)70:DRV:SCALE_CALC") {
  field(OMSL, "closed_loop")
  field(DOL,  "$(CM,recursive)70:DRV:CAL_SCALE")
  field(FLNK, "$(CM,recursive)70:DRV:SCALE")
}

# When reference is in sqrt(Watts)
record(calcout, "$(CM,recursive)70:DRV:SCALETOREF") {
  field(CALC, "B*A/C")
  field(INPA, "$(CM,recursive)70:DRV:CAL_SCALE") # current scaling
  field(INPB, "1")# B = known reference, in power
  field(INPC, "$(CM,recursive)70:DRV:AMEAN") # current amplitude mean
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,recursive)70:DRV:CAL_SCALE PP") # new scaling
  field(PINI, "NO") # do not overwrite cal on startup
  info(autosaveFields, "B")
}

# Signal waveform mean converted to counts
# To be consistent with signals. Keep this?
record(calc, "$(CM,recursive)70:DRV:AMEAN_ADC") {
  field(DESC, "WF mean in counts")
  field(CALC, "FLOOR(C*A/B)")
  field(INPA, "$(CM,recursive)70:DRV:AMEAN CPP")
  field(INPB, "$(CM,recursive)70:DRV:CAL_SCALE")
  field(INPC, "32767")
  field(EGU,  "counts")
}
#==================================
#----------------------------------
# rf_sig_cal_simple.template:
#
# Scale factor to convert waveform
# fraction-of-full-scale readout 
# to engineering units: MV for cavity 
# signal; sqrt(Watts) for others
#----------------------------------
#==================================

record(ao, "$(CM,recursive)70:FWD:CAL_SCALE") {
  field(SCAN, "Passive")
  field(OMSL, "supervisory")
  field(PREC, "7")
  field(VAL,  "1")
  field(PINI, "YES")
  field(FLNK, "$(CM,recursive)70:FWD:SCALE_CALC")
  info(autosaveFields, "VAL")
}

# Unnecessary intermediate PV 
# to be compatible with wfCav.template
record(ao, "$(CM,recursive)70:FWD:SCALE_CALC") {
  field(OMSL, "closed_loop")
  field(DOL,  "$(CM,recursive)70:FWD:CAL_SCALE")
  field(FLNK, "$(CM,recursive)70:FWD:SCALE")
}

# When reference is in sqrt(Watts)
record(calcout, "$(CM,recursive)70:FWD:SCALETOREF") {
  field(CALC, "B*A/C")
  field(INPA, "$(CM,recursive)70:FWD:CAL_SCALE") # current scaling
  field(INPB, "1")# B = known reference, in power
  field(INPC, "$(CM,recursive)70:FWD:AMEAN") # current amplitude mean
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,recursive)70:FWD:CAL_SCALE PP") # new scaling
  field(PINI, "NO") # do not overwrite cal on startup
  info(autosaveFields, "B")
}

# Signal waveform mean converted to counts
# To be consistent with signals. Keep this?
record(calc, "$(CM,recursive)70:FWD:AMEAN_ADC") {
  field(DESC, "WF mean in counts")
  field(CALC, "FLOOR(C*A/B)")
  field(INPA, "$(CM,recursive)70:FWD:AMEAN CPP")
  field(INPB, "$(CM,recursive)70:FWD:CAL_SCALE")
  field(INPC, "32767")
  field(EGU,  "counts")
}
#==================================
#----------------------------------
# rf_sig_cal_simple.template:
#
# Scale factor to convert waveform
# fraction-of-full-scale readout 
# to engineering units: MV for cavity 
# signal; sqrt(Watts) for others
#----------------------------------
#==================================

record(ao, "$(CM,recursive)70:REV:CAL_SCALE") {
  field(SCAN, "Passive")
  field(OMSL, "supervisory")
  field(PREC, "7")
  field(VAL,  "1")
  field(PINI, "YES")
  field(FLNK, "$(CM,recursive)70:REV:SCALE_CALC")
  info(autosaveFields, "VAL")
}

# Unnecessary intermediate PV 
# to be compatible with wfCav.template
record(ao, "$(CM,recursive)70:REV:SCALE_CALC") {
  field(OMSL, "closed_loop")
  field(DOL,  "$(CM,recursive)70:REV:CAL_SCALE")
  field(FLNK, "$(CM,recursive)70:REV:SCALE")
}

# When reference is in sqrt(Watts)
record(calcout, "$(CM,recursive)70:REV:SCALETOREF") {
  field(CALC, "B*A/C")
  field(INPA, "$(CM,recursive)70:REV:CAL_SCALE") # current scaling
  field(INPB, "1")# B = known reference, in power
  field(INPC, "$(CM,recursive)70:REV:AMEAN") # current amplitude mean
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,recursive)70:REV:CAL_SCALE PP") # new scaling
  field(PINI, "NO") # do not overwrite cal on startup
  info(autosaveFields, "B")
}

# Signal waveform mean converted to counts
# To be consistent with signals. Keep this?
record(calc, "$(CM,recursive)70:REV:AMEAN_ADC") {
  field(DESC, "WF mean in counts")
  field(CALC, "FLOOR(C*A/B)")
  field(INPA, "$(CM,recursive)70:REV:AMEAN CPP")
  field(INPB, "$(CM,recursive)70:REV:CAL_SCALE")
  field(INPC, "32767")
  field(EGU,  "counts")
}
#==================================
#----------------------------------
# rf_sig_cal_simple.template:
#
# Scale factor to convert waveform
# fraction-of-full-scale readout 
# to engineering units: MV for cavity 
# signal; sqrt(Watts) for others
#----------------------------------
#==================================

record(ao, "$(CM,recursive)70:DAC:CAL_SCALE") {
  field(SCAN, "Passive")
  field(OMSL, "supervisory")
  field(PREC, "7")
  field(VAL,  "1")
  field(PINI, "YES")
  field(FLNK, "$(CM,recursive)70:DAC:SCALE_CALC")
  info(autosaveFields, "VAL")
}

# Unnecessary intermediate PV 
# to be compatible with wfCav.template
record(ao, "$(CM,recursive)70:DAC:SCALE_CALC") {
  field(OMSL, "closed_loop")
  field(DOL,  "$(CM,recursive)70:DAC:CAL_SCALE")
  field(FLNK, "$(CM,recursive)70:DAC:SCALE")
}

# When reference is in sqrt(Watts)
record(calcout, "$(CM,recursive)70:DAC:SCALETOREF") {
  field(CALC, "B*A/C")
  field(INPA, "$(CM,recursive)70:DAC:CAL_SCALE") # current scaling
  field(INPB, "1")# B = known reference, in power
  field(INPC, "$(CM,recursive)70:DAC:AMEAN") # current amplitude mean
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,recursive)70:DAC:CAL_SCALE PP") # new scaling
  field(PINI, "NO") # do not overwrite cal on startup
  info(autosaveFields, "B")
}

# Signal waveform mean converted to counts
# To be consistent with signals. Keep this?
record(calc, "$(CM,recursive)70:DAC:AMEAN_ADC") {
  field(DESC, "WF mean in counts")
  field(CALC, "FLOOR(C*A/B)")
  field(INPA, "$(CM,recursive)70:DAC:AMEAN CPP")
  field(INPB, "$(CM,recursive)70:DAC:CAL_SCALE")
  field(INPC, "32767")
  field(EGU,  "counts")
}
#==================================
#----------------------------------
# rf_sig_cal_simple.template:
#
# Scale factor to convert waveform
# fraction-of-full-scale readout 
# to engineering units: MV for cavity 
# signal; sqrt(Watts) for others
#----------------------------------
#==================================

record(ao, "$(CM,recursive)80:CAV:CAL_SCALE") {
  field(SCAN, "Passive")
  field(OMSL, "supervisory")
  field(PREC, "7")
  field(VAL,  "1")
  field(PINI, "YES")
  field(FLNK, "$(CM,recursive)80:CAV:SCALE_CALC")
  info(autosaveFields, "VAL")
}

# Unnecessary intermediate PV 
# to be compatible with wfCav.template
record(ao, "$(CM,recursive)80:CAV:SCALE_CALC") {
  field(OMSL, "closed_loop")
  field(DOL,  "$(CM,recursive)80:CAV:CAL_SCALE")
  field(FLNK, "$(CM,recursive)80:CAV:SCALE")
}

# When reference is in sqrt(Watts)
record(calcout, "$(CM,recursive)80:CAV:SCALETOREF") {
  field(CALC, "B*A/C")
  field(INPA, "$(CM,recursive)80:CAV:CAL_SCALE") # current scaling
  field(INPB, "1")# B = known reference, in power
  field(INPC, "$(CM,recursive)80:CAV:AMEAN") # current amplitude mean
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,recursive)80:CAV:CAL_SCALE PP") # new scaling
  field(PINI, "NO") # do not overwrite cal on startup
  info(autosaveFields, "B")
}

# Signal waveform mean converted to counts
# To be consistent with signals. Keep this?
record(calc, "$(CM,recursive)80:CAV:AMEAN_ADC") {
  field(DESC, "WF mean in counts")
  field(CALC, "FLOOR(C*A/B)")
  field(INPA, "$(CM,recursive)80:CAV:AMEAN CPP")
  field(INPB, "$(CM,recursive)80:CAV:CAL_SCALE")
  field(INPC, "32767")
  field(EGU,  "counts")
}
#==================================
#----------------------------------
# rf_sig_cal_simple.template:
#
# Scale factor to convert waveform
# fraction-of-full-scale readout 
# to engineering units: MV for cavity 
# signal; sqrt(Watts) for others
#----------------------------------
#==================================

record(ao, "$(CM,recursive)80:DRV:CAL_SCALE") {
  field(SCAN, "Passive")
  field(OMSL, "supervisory")
  field(PREC, "7")
  field(VAL,  "1")
  field(PINI, "YES")
  field(FLNK, "$(CM,recursive)80:DRV:SCALE_CALC")
  info(autosaveFields, "VAL")
}

# Unnecessary intermediate PV 
# to be compatible with wfCav.template
record(ao, "$(CM,recursive)80:DRV:SCALE_CALC") {
  field(OMSL, "closed_loop")
  field(DOL,  "$(CM,recursive)80:DRV:CAL_SCALE")
  field(FLNK, "$(CM,recursive)80:DRV:SCALE")
}

# When reference is in sqrt(Watts)
record(calcout, "$(CM,recursive)80:DRV:SCALETOREF") {
  field(CALC, "B*A/C")
  field(INPA, "$(CM,recursive)80:DRV:CAL_SCALE") # current scaling
  field(INPB, "1")# B = known reference, in power
  field(INPC, "$(CM,recursive)80:DRV:AMEAN") # current amplitude mean
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,recursive)80:DRV:CAL_SCALE PP") # new scaling
  field(PINI, "NO") # do not overwrite cal on startup
  info(autosaveFields, "B")
}

# Signal waveform mean converted to counts
# To be consistent with signals. Keep this?
record(calc, "$(CM,recursive)80:DRV:AMEAN_ADC") {
  field(DESC, "WF mean in counts")
  field(CALC, "FLOOR(C*A/B)")
  field(INPA, "$(CM,recursive)80:DRV:AMEAN CPP")
  field(INPB, "$(CM,recursive)80:DRV:CAL_SCALE")
  field(INPC, "32767")
  field(EGU,  "counts")
}
#==================================
#----------------------------------
# rf_sig_cal_simple.template:
#
# Scale factor to convert waveform
# fraction-of-full-scale readout 
# to engineering units: MV for cavity 
# signal; sqrt(Watts) for others
#----------------------------------
#==================================

record(ao, "$(CM,recursive)80:FWD:CAL_SCALE") {
  field(SCAN, "Passive")
  field(OMSL, "supervisory")
  field(PREC, "7")
  field(VAL,  "1")
  field(PINI, "YES")
  field(FLNK, "$(CM,recursive)80:FWD:SCALE_CALC")
  info(autosaveFields, "VAL")
}

# Unnecessary intermediate PV 
# to be compatible with wfCav.template
record(ao, "$(CM,recursive)80:FWD:SCALE_CALC") {
  field(OMSL, "closed_loop")
  field(DOL,  "$(CM,recursive)80:FWD:CAL_SCALE")
  field(FLNK, "$(CM,recursive)80:FWD:SCALE")
}

# When reference is in sqrt(Watts)
record(calcout, "$(CM,recursive)80:FWD:SCALETOREF") {
  field(CALC, "B*A/C")
  field(INPA, "$(CM,recursive)80:FWD:CAL_SCALE") # current scaling
  field(INPB, "1")# B = known reference, in power
  field(INPC, "$(CM,recursive)80:FWD:AMEAN") # current amplitude mean
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,recursive)80:FWD:CAL_SCALE PP") # new scaling
  field(PINI, "NO") # do not overwrite cal on startup
  info(autosaveFields, "B")
}

# Signal waveform mean converted to counts
# To be consistent with signals. Keep this?
record(calc, "$(CM,recursive)80:FWD:AMEAN_ADC") {
  field(DESC, "WF mean in counts")
  field(CALC, "FLOOR(C*A/B)")
  field(INPA, "$(CM,recursive)80:FWD:AMEAN CPP")
  field(INPB, "$(CM,recursive)80:FWD:CAL_SCALE")
  field(INPC, "32767")
  field(EGU,  "counts")
}
#==================================
#----------------------------------
# rf_sig_cal_simple.template:
#
# Scale factor to convert waveform
# fraction-of-full-scale readout 
# to engineering units: MV for cavity 
# signal; sqrt(Watts) for others
#----------------------------------
#==================================

record(ao, "$(CM,recursive)80:REV:CAL_SCALE") {
  field(SCAN, "Passive")
  field(OMSL, "supervisory")
  field(PREC, "7")
  field(VAL,  "1")
  field(PINI, "YES")
  field(FLNK, "$(CM,recursive)80:REV:SCALE_CALC")
  info(autosaveFields, "VAL")
}

# Unnecessary intermediate PV 
# to be compatible with wfCav.template
record(ao, "$(CM,recursive)80:REV:SCALE_CALC") {
  field(OMSL, "closed_loop")
  field(DOL,  "$(CM,recursive)80:REV:CAL_SCALE")
  field(FLNK, "$(CM,recursive)80:REV:SCALE")
}

# When reference is in sqrt(Watts)
record(calcout, "$(CM,recursive)80:REV:SCALETOREF") {
  field(CALC, "B*A/C")
  field(INPA, "$(CM,recursive)80:REV:CAL_SCALE") # current scaling
  field(INPB, "1")# B = known reference, in power
  field(INPC, "$(CM,recursive)80:REV:AMEAN") # current amplitude mean
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,recursive)80:REV:CAL_SCALE PP") # new scaling
  field(PINI, "NO") # do not overwrite cal on startup
  info(autosaveFields, "B")
}

# Signal waveform mean converted to counts
# To be consistent with signals. Keep this?
record(calc, "$(CM,recursive)80:REV:AMEAN_ADC") {
  field(DESC, "WF mean in counts")
  field(CALC, "FLOOR(C*A/B)")
  field(INPA, "$(CM,recursive)80:REV:AMEAN CPP")
  field(INPB, "$(CM,recursive)80:REV:CAL_SCALE")
  field(INPC, "32767")
  field(EGU,  "counts")
}
#==================================
#----------------------------------
# rf_sig_cal_simple.template:
#
# Scale factor to convert waveform
# fraction-of-full-scale readout 
# to engineering units: MV for cavity 
# signal; sqrt(Watts) for others
#----------------------------------
#==================================

record(ao, "$(CM,recursive)80:DAC:CAL_SCALE") {
  field(SCAN, "Passive")
  field(OMSL, "supervisory")
  field(PREC, "7")
  field(VAL,  "1")
  field(PINI, "YES")
  field(FLNK, "$(CM,recursive)80:DAC:SCALE_CALC")
  info(autosaveFields, "VAL")
}

# Unnecessary intermediate PV 
# to be compatible with wfCav.template
record(ao, "$(CM,recursive)80:DAC:SCALE_CALC") {
  field(OMSL, "closed_loop")
  field(DOL,  "$(CM,recursive)80:DAC:CAL_SCALE")
  field(FLNK, "$(CM,recursive)80:DAC:SCALE")
}

# When reference is in sqrt(Watts)
record(calcout, "$(CM,recursive)80:DAC:SCALETOREF") {
  field(CALC, "B*A/C")
  field(INPA, "$(CM,recursive)80:DAC:CAL_SCALE") # current scaling
  field(INPB, "1")# B = known reference, in power
  field(INPC, "$(CM,recursive)80:DAC:AMEAN") # current amplitude mean
  field(OOPT, "Every Time")
  field(OUT,  "$(CM,recursive)80:DAC:CAL_SCALE PP") # new scaling
  field(PINI, "NO") # do not overwrite cal on startup
  info(autosaveFields, "B")
}

# Signal waveform mean converted to counts
# To be consistent with signals. Keep this?
record(calc, "$(CM,recursive)80:DAC:AMEAN_ADC") {
  field(DESC, "WF mean in counts")
  field(CALC, "FLOOR(C*A/B)")
  field(INPA, "$(CM,recursive)80:DAC:AMEAN CPP")
  field(INPB, "$(CM,recursive)80:DAC:CAL_SCALE")
  field(INPC, "32767")
  field(EGU,  "counts")
}
