BerkeleyLab_Bedrock/dsp/digaree/detune_coeff_calc.py

import numpy as np
from numpy import sqrt, arctan2, exp, mean, std, pi, zeros, hstack, vstack, arange, diff, linalg
from scipy.interpolate import BSpline
from matplotlib import pyplot


class rf_waveforms:
    # Default waveform dump format; can be overridden at class construction time
    DAT_FMT = ["FWD_I", "FWD_Q",
               "REV_I", "REV_Q",
               "CAV_I", "CAV_Q",
               "LOOPB_I", "LOOPB_Q", ]  # Drive
    MIN_PTS = 256

    def __init__(self, data_file, skip_pt=0, data_format=DAT_FMT):
        self.waves = np.loadtxt(data_file).transpose()

        self.skip_pt = skip_pt
        self.DAT_FMT = data_format

        if self.waves.shape[0] != len(self.DAT_FMT) or\
           self.waves.shape[1] < self.MIN_PTS:
            print("ERROR: Bad data shape: {0}".format(self.waves.data.shape))
            exit(1)

    def get_ch(self, ch_key):
        if ch_key not in self.DAT_FMT:
            print("ERROR: No channel {} in waveform data".format(ch_key))

        return self.waves[self.DAT_FMT.index(ch_key)][self.skip_pt:]


class digaree_coeff:
    CONFIG_PARAMS = ["bandwidth", "wvform_dt",
                     "freq_quantum", "digaree_dt",
                     "out_shift"]

    def __init__(self, c_dict, fir_gain=80, dig_data_w=20, dig_extra_w=4):
        for p in self.CONFIG_PARAMS:
            if p not in c_dict:
                print("ERROR: Parameter {} missing from config dict".format(p))
                exit(1)
        self.c_dict = c_dict
        self.dig_dw = dig_data_w   # Width of Digaree inputs/parameters
        self.dig_ew = dig_extra_w  # Extra guard bits
        self.fir_g = fir_gain      # pre-scaling for dV/dt

    def compute(self, wvf, plot=False, verbose=False):
        print("ERROR: This method must be overridden by a coefficient calculation method")
        exit(1)

    """
    Scale Beta and 1/T so output detune frequency is in units of scaled Hz.

    # Input Beta is in Hz.
    # conf.dict["freq_quantum"] determines the resolution of detune output.
    # conf.dict["out_shift"] compensates for resizing of detune output. E.g:
      if Digaree's data width is 20-bit but transmitted detune is 18-bit,
      this scaling factor must be set to 2**(20-18) = 4.
    # conf.dict["digaree_dt"] is pre-scaled by a constant FIR gain for dV/dt
      (see comments in cgen_srf.py)
    """
    def get_coeffs(self, beta):
        invT = 1.0/(self.c_dict["digaree_dt"]*self.fir_g)  # inverse seconds

        # Divide by 2pi to get Hz
        invT = invT / (2*pi)
        beta = beta  # beta is already in Hz

        # Scale by freq quantum and (optional) output shift
        invT = (invT * self.c_dict["out_shift"]) / self.c_dict["freq_quantum"]
        beta = (beta * self.c_dict["out_shift"]) / self.c_dict["freq_quantum"]

        detune_coeffs = [beta.real, beta.imag, invT, 32768]

        # Round to int and check for overflow wrt Digaree signed pipeline width
        sff = [int(round(x)) for x in detune_coeffs]
        ok = all([abs(x) < 2**(self.dig_dw+self.dig_ew-1) for x in sff])

        if not ok:
            print("ERROR: Computed coefficients exceed Digaree pipeline width")
            for idx, kx in enumerate(sff):
                print("sf_consts[%d] = %d" % (idx, kx))
            sff = None
        else:
            for idx, kx in enumerate(sff):
                print("sf_consts[%d] = %d" % (idx, kx))
            print("fq = %f" % (self.c_dict["freq_quantum"]))

        return sff


"""
Analyzes waveform data to get the setup parameters for detune computations.
Data is assumed to be in GDR mode, which is both good and bad:
simpler math, but need an externally-provided bandwidth.
Only needs/uses forward and cavity signals.

Depends on microphonics to make large variations in the imaginary part
of the complex state parameter, while the real part (based on Q_L) is
relatively constant on these time scales.  With GDR mode holding the
cavity voltage fixed, the forward wave can be rotated and scaled to give
that state parameter.

Has been tested when this system is parasiting off another controller.
It will be useful for in-situ correction of cable drift during long
CW GDR runs, which would otherwise introduce tune angle drift.
"""


class detune_gdr(digaree_coeff):

    def fwd_coeff(self, fwd, verbose=False):
        # This covariance and eigenvalue computation finds out how to
        # rotate the forward wave to give large imaginary fluctuations
        # but small real fluctuations.
        mmm1 = np.cov(fwd.real, fwd.imag)
        e_val, e_vec = np.linalg.eig(mmm1)

        # we need e_val sorted from larger to smaller
        ev_list = list(zip(e_val, e_vec))
        ev_list.sort(key=lambda tup: tup[0], reverse=True)
        e_val, e_vec = zip(*ev_list)
        fp0 = arctan2(e_vec[0][0], e_vec[0][1])
        coeff = exp(-1j*fp0)
        fwdx = fwd * coeff

        # eigenvectors have arbitrary sign
        if mean(fwdx).real < 0:
            fwdx = -fwdx
            coeff = -coeff
            fp0 = (fp0 + 2*pi) % (2*pi) - pi
        drv = fwdx.imag/mean(fwdx.real)
        coeff = coeff/mean(fwdx.real)
        if verbose:
            print("Orthogonal fwd rms (%.1f, %.1f)" % tuple(sqrt(e_val)))
            print("Forward phase zero %.3f radians" % fp0)
            print("Drive normalized variation %.3f rms" % std(drv))
        return coeff

    def compute(self, wvf, plot=False, verbose=False):
        # loopback and reverse not used
        fwd = wvf.get_ch("FWD_I") + 1j*wvf.get_ch("FWD_Q")
        cav = wvf.get_ch("CAV_I") + 1j*wvf.get_ch("CAV_Q")
        fwd_c = self.fwd_coeff(fwd, verbose=verbose)
        cav_c = 1/mean(cav)
        beta = self.c_dict["bandwidth"] * fwd_c / cav_c

        # Plot FWD, CAV and beta*FWD/CAV
        fwdx = fwd * fwd_c
        cavx = cav * cav_c
        a = beta * fwd / cav
        t = np.arange(len(cav)) * self.c_dict["wvform_dt"]
        f, (ax1, ax2) = pyplot.subplots(1, 2, figsize=(16, 8))
        ax1.plot(fwdx.real, fwdx.imag, label="Forward")
        ax1.plot(cavx.real, cavx.imag, label="Cavity")
        ax1.set_xlim(0.98, 1.02)
        ax1.set_ylim(-0.8, 0.8)
        ax1.set_xlabel('Real')
        ax1.set_ylabel('Imag')
        ax1.legend(frameon=False)
        ax1.set_title("Input waveforms, normalized and rotated")
        ax2.plot(t, a.real, label='real')
        ax2.plot(t, a.imag, label='imag')
        ax2.set_xlim(0, max(t))
        ax2.set_ylim(-12.0, 18.0)
        ax2.set_xlabel("Time (s)")
        ax2.set_ylabel("Frequency (Hz)")
        ax2.set_title("Resulting state-space coefficient")
        ax2.legend(frameon=False)
        # Note that the mean value of the coefficient's real part is,
        # by construction, equal to the bandwidth supplied to us in
        # c_dict["bandwidth"].
        # All the results are normalized based on that single number.

        fig_name = "cw_fit.png"
        pyplot.savefig(fig_name)
        print("Plot saved to {}".format(fig_name))
        if plot:
            pyplot.show()

        if verbose:
            print("SI beta %.3f%+.3fj Hz, magnitude %.3f Hz" % (beta.real, beta.imag, abs(beta)))
        return self.get_coeffs(beta)


"""
Analyzes waveform data to get the setup parameters for detune computations.
Data is assumed to be in pulsed mode.
Only needs/uses forward and cavity signals.
"""


class detune_pulse(digaree_coeff):

    """
    Cardinal B-spline  https://en.wikipedia.org/wiki/B-spline
    Same as the output of a second-order CIC interpolator
    Bespoke wrapper as drop-in for the old scipy.signal.bspline,
    which was removed in SciPy 1.13.
    """
    def bspline(self, x, n):
        knots = np.arange(-(n+1)/2, (n+3)/2)
        out = BSpline.basis_element(knots)(x)
        out[(x < knots[0]) | (x > knots[-1])] = 0.0
        return out

    def create_basist(self, block=15, n=10):
        npt = (n-1)*block+1
        basist = zeros([npt, n])
        x = arange(npt)/float(block)
        for jx in range(n):
            basist[:, jx] = self.bspline(x-jx, 2)
        # end-effects, it's important that the sum is flat
        basist[:, 0] += self.bspline(x+1, 2)
        basist[:, n-1] += self.bspline(x-n, 2)
        return basist

    # basist is n*m, where n=len(cav)-1, m is number of time-dependent bases
    def compute(self, wvf, plot=False, verbose=False):
        b_blk, b_n = self.c_dict["basist_block"], self.c_dict["basist_n"]
        basist = self.create_basist(block=b_blk, n=b_n)
        cav = wvf.get_ch("CAV_I") + 1j*wvf.get_ch("CAV_Q")
        fwd = wvf.get_ch("FWD_I") + 1j*wvf.get_ch("FWD_Q")

        ny = basist.shape[0]+1
        cav = cav[:ny]
        fwd = fwd[:ny]

        acav = 0.5 * (cav[1:] + cav[:-1])
        afwd = 0.5 * (fwd[1:] + fwd[:-1])
        dcav = diff(cav)/self.c_dict["wvform_dt"]
        cave = acav * basist.T
        # Fit dcav to a*acav + b*afwd
        # Treat real and imaginary parts separately, since we want the imaginary
        # part of b to be sum_i g_i*f_i(t) while the real part is constant.
        goal = hstack([dcav.real, dcav.imag])
        basis1 = hstack([afwd.real, afwd.imag])   # b.real
        basis2 = hstack([-afwd.imag, afwd.real])  # b.imag
        basis3 = hstack([acav.real, acav.imag])   # a.real
        basisn = hstack([-cave.imag, cave.real])  # a.imag repeated
        basis = vstack([basis1, basis2, basis3, basisn])

        fitc, resid, rank, sing = linalg.lstsq(basis.T, goal, rcond=-1)

        beta = fitc[0]+1j*fitc[1]  # in rad/s
        beta_hz = beta / (2*pi)
        bw_hz = fitc[2]/(2*pi)  # Hz
        det_hz = fitc[3:]/(2*pi)  # Hz
        if verbose:
            print("Bandwidth %.3f Hz" % -bw_hz)
            print("Detune Hz", det_hz)
            print("SI beta %.3f%+.3fj Hz, magnitude %.3f Hz" % (beta.real, beta.imag, abs(beta)))

        if False:
            fitv = fitc.dot(basis)
            # print(goal.shape, basis.shape, fitv.shape)
            pyplot.plot(goal, label='goal')
            pyplot.plot(fitv, label='fit')
            for jx in range(len(fitc)):
                pyplot.plot(fitc[jx]*basis[jx, :], label="%d" % jx)
            pyplot.legend(frameon=False)
            pyplot.show()

        # Useful for plotting
        detune_hz = basist.dot(fitc[3:])/(2*pi)

        return self.get_coeffs(beta_hz), beta, detune_hz, bw_hz


if __name__ == "__main__":
    from argparse import ArgumentParser

    parser = ArgumentParser(description="Detune coefficient computation")
    parser.add_argument("-m", "--mode", dest="mode", default="cw", const="cw", nargs="?",
                        choices=["cw", "pulse"], help="Coeff calculation mode")
    parser.add_argument("-f", "--datafile", dest="datafile", default=None, required=True,
                        help="IQ data input file")
    parser.add_argument("-v", "--verbose", action="store_true", dest="verbose", help="Verbose mode")
    parser.add_argument("-p", "--plot", action="store_true", dest="plot", help="Plot")

    args = parser.parse_args()

    # Read in IQ waveforms
    rf_wvf = rf_waveforms(args.datafile, data_format=["UN_I", "UN_Q",
                                                      "FWD_I", "FWD_Q",
                                                      "REV_I", "REV_Q",
                                                      "CAV_I", "CAV_Q"])

    adc_clk = 1320.0e6 / 14.0  # Hz

    # Waveform acquisition timestep
    wvform_dt = (255*2*33) / adc_clk

    # Digaree data stream timestep
    digaree_dt = (32*2*33) / adc_clk

    # Setup configuration dict for detune coefficient calculation
    detune_dict = {"bandwidth": 15.0,  # Ignored in pulse mode
                   "wvform_dt": wvform_dt,
                   "freq_quantum": 0.0355256,
                   "digaree_dt": digaree_dt,
                   "basist_block": 10,
                   "basist_n": 24,
                   "out_shift": 4}
    # I should write a long essay about the meaning of basist_block and
    # basist_n, which are only used in pulse-mode.  These describe the
    # degrees of freedom available to fit variations in cavity frequency
    # during a pulse due to Lorentz Force Detuning (LFD).  basist_block is
    # the number of sample points per degree of freedom, and basist_n is
    # the number of such degrees of freedom.  The number of waveform points
    # used in the analysis is basist_block * (basist_n - 1) + 2.  That should
    # be less than the number of points in the "on" time of the pulse.
    # I hope that helps.  :-)

    if args.mode == "cw":
        print("Calculating detune coefficients from CW data")
        detune_coeff = detune_gdr(detune_dict)
    else:
        detune_coeff = detune_pulse(detune_dict)

    detune_coeff.compute(rf_wvf, args.plot, args.verbose)