def magdB_colormesh(self, **kwargs):
     process_kwargs(self, kwargs, pl="magdB_{0}_{1}_{2}".format(self.filter_type, self.bgsub_type, self.name))
     if self.filter_type=="Fit":
         flux_axis=self.flux_axis[self.flat_flux_indices]
         freq_axis=self.freq_axis[self.indices]
         start_ind=0
         for ind in self.fit_indices:
             pl=colormesh(flux_axis, self.freq_axis[ind], self.MagdB[start_ind:start_ind+len(ind), :],  **kwargs)
             start_ind+=len(ind)
     elif self.filter_type=="None":
         flux_axis=self.flux_axis
         freq_axis=self.freq_axis
         pl=colormesh(self.flux_axis, self.freq_axis, self.MagdB,  **kwargs)
     else:
         flux_axis=self.flux_axis[self.flat_flux_indices]
         freq_axis=self.freq_axis[self.indices]
         pl=colormesh(flux_axis, freq_axis, self.MagdB,  **kwargs)
     if isinstance(pl, tuple):
         pl, pf=pl
     else:
         pf=None
     if pl.auto_ylim:
         pl.set_ylim(min(freq_axis), max(freq_axis))
     if pl.auto_xlim:
         pl.set_xlim(min(flux_axis), max(flux_axis))
     pl.xlabel=kwargs.pop("xlabel", self.flux_axis_label)
     pl.ylabel=kwargs.pop("ylabel", self.freq_axis_label)
     if pf is None:
         return pl
     return pl, pf

def ifft_plot(self, **kwargs):
    process_kwargs(self, kwargs, pl="hannifft_{0}_{1}_{2}".format(self.filter_type, self.bgsub_type, self.name))
    on_res=absolute(self.filt.window_ifft(self.MagcomData[:,self.on_res_ind, self.pwr2_ind]))
    strt=absolute(self.filt.window_ifft(self.MagcomData[:,self.start_ind, self.pwr2_ind]))
    stop=absolute(self.filt.window_ifft(self.MagcomData[:,self.stop_ind, self.pwr2_ind]))

    pl=line(self.time_axis, self.filt.fftshift(on_res),  color="red",
           plot_name="onres_{}".format(self.on_res_ind),label="{:.4g}".format(self.on_res_ind), **kwargs)
    line(self.time_axis, self.filt.fftshift(strt), pl=pl, linewidth=1.0, color="purple",
         plot_name="strt {}".format(self.start_ind), label="{:.4g}".format(self.start_ind))
    line(self.time_axis, self.filt.fftshift(stop), pl=pl, linewidth=1.0, color="blue",
         plot_name="stop {}".format(self.stop_ind), label="{:.4g}".format(self.stop_ind))

    self.filt.N=len(on_res)
    filt=self.filt.freqz
    #filt=filt_prep(len(on_res), self.filt_start_ind, self.filt_end_ind)
    top=max([amax(on_res), amax(strt), amax(stop)])
    line(self.time_axis, filt*top, plotter=pl, color="green", label="wdw")
    pl.xlabel=kwargs.pop("xlabel", self.time_axis_label)
    pl.ylabel=kwargs.pop("ylabel", "Mag abs")
    if 1:
        double_filt= array([[self.filt.fft_filter(a.MagcomData[:,n, m]) for n in range(len(a.frq2))] for m in range(len(a.pwr2))])#.transpose()
        print double_filt.shape
        double_filt=swapaxes(double_filt, 0, 2)
        print double_filt.shape
        print a.pwr2[10]
        colormesh(self.freq_axis[a.end_skip:-a.end_skip], self.frq2, absolute(double_filt[a.end_skip:-a.end_skip, :, 10]).transpose()) #-absolute(double_filt[a.end_skip:-a.end_skip, 56, 134]).transpose())#-absolute(double_filt[50, 10:-10, 134]))
        pl=colormesh(a.frq2, a.pwr2, absolute(double_filt[493, :, :]).transpose()) #-absolute(double_filt[a.end_skip:-a.end_skip, 56, 134]).transpose())#-absolute(double_filt[50, 10:-10, 134]))
        print a.frequency[493]
        colormesh(absolute(double_filt[329, :, :]).transpose()) #-absolute(double_filt[a.end_skip:-a.end_skip, 56, 134]).transpose())#-absolute(double_filt[50, 10:-10, 134]))
        colormesh(absolute(double_filt[93, :, :]).transpose()) #-absolute(double_filt[a.end_skip:-a.end_skip, 56, 134]).transpose())#-absolute(double_filt[50, 10:-10, 134]))
        colormesh(absolute(double_filt[880, :, :]).transpose()) #-absolute(double_filt[a.end_skip:-a.end_skip, 56, 134]).transpose())#-absolute(double_filt[50, 10:-10, 134]))

    return pl

 def phase_colormesh(self, **kwargs):
     process_kwargs(self, kwargs, pl="phase_{0}_{1}_{2}".format(self.filter_type, self.bgsub_type, self.name))
     if self.filter_type=="Fit":
         start_ind=0
         for ind in self.fit_indices:
             pl=colormesh(self.flux_axis, self.freq_axis[ind], self.Phase[start_ind:start_ind+len(ind), :], **kwargs)
             start_ind+=len(ind)
     else:
         pl=colormesh(self.flux_axis, self.freq_axis[self.indices], self.Phase, **kwargs)
     pl.set_ylim(min(self.freq_axis[self.indices]), max(self.freq_axis[self.indices]))
     pl.set_xlim(min(self.flux_axis), max(self.flux_axis))
     pl.xlabel=kwargs.pop("xlabel", self.flux_axis_label)
     pl.ylabel=kwargs.pop("ylabel", self.freq_axis_label)
     return pl

 def magabs_colormesh(self):
     pl, pf=colormesh(self.yoko, self.frequency/1e9, self.MagAbs, plotter="magabs_{}".format(self.name))
     pl.set_ylim(min(self.frequency/1e9), max(self.frequency/1e9))
     pl.set_xlim(min(self.yoko), max(self.yoko))
     pl.xlabel="Yoko (V)"
     pl.ylabel="Frequency (GHz)"
     return pl

def magdB_colormesh(self):
    pl, pf=colormesh(self.yoko, self.frequency/1e9, (self.MagdB.transpose()-self.MagdB[:,0]).transpose(), plotter="magabs_{}".format(self.name))
    pl.set_ylim(min(self.frequency/1e9), max(self.frequency/1e9))
    pl.set_xlim(min(self.yoko), max(self.yoko))
    pl.xlabel="Yoko (V)"
    pl.ylabel="Frequency (GHz)"
    return pl

 def magabs_colormesh(self, **kwargs):
     flux_axis=self.flux_axis[self.flat_flux_indices]
     freq_axis=self.freq_axis[self.indices]
     start_ind=0
     for ind in self.fit_indices:
         pl=colormesh(flux_axis, self.freq_axis[ind], self.MagAbs[start_ind:start_ind+len(ind), :],  **kwargs)
         start_ind+=len(ind)

def magfilt_cmesh(self, f0=5.35e9, alpha=0.45):
    Magcom=self.Magcom #(self.Magcom.transpose()-self.Magcom[:, 0]).transpose()
    fq_vec=self.frequency #array([sqrt(f*(f-2*qdt.call_func("Lamb_shift", f=f, f0=f0, couple_mult=alpha))) for f in self.frequency])

    Magfilt=array([fft_filter(Magcom[:,n], self.filt_start_ind, self.filt_end_ind) for n in range(len(self.yoko))]).transpose()
    Magfilt2=array([fft_filter(Magcom[:,n], 0, 34) for n in range(len(self.yoko))]).transpose()

    pl=Plotter(fig_width=9.0, fig_height=6.0, name="magabs_{}".format(self.name))
    pl, pf=colormesh(self.yoko, fq_vec/1e9, (absolute(Magfilt.transpose()-0.0*Magfilt[:,0])).transpose(), plotter=pl)

 def magabsfilt2_colormesh(self):
     p, pf=colormesh(self.frequency[10:-10]/1e9, self.yoko[10:-10],
                     self.MagAbsFilt.transpose()[10:-10, 10:-10], plotter="magabsfilt2_{}".format(self.name))
     print self.voltage_from_flux_par2[0].shape,self.voltage_from_flux_par2[1].shape
     line(self.voltage_from_flux_par2[0]/1e9, self.voltage_from_flux_par2[1], plotter=p)
     #print max(self.voltage_from_flux_par), min(self.voltage_from_flux_par)
     p.xlabel="Yoko (V)"
     p.ylabel="Frequency (GHz)"
     return p

def magabs_colormesh(self):
    pl=Plotter(fig_width=9.0, fig_height=6.0, name="magabs_{}".format(self.name))
    pl, pf=colormesh(self.frequency/1e9, self.yoko, (self.MagdB.transpose()-self.MagdB[:, 0]), plotter=pl)
    pf.set_clim(-0.3, 0.1)
    pl.set_xlim(min(self.frequency/1e9), max(self.frequency/1e9))
    pl.set_ylim(min(self.yoko), max(self.yoko))

    pl.ylabel="Yoko (V)"
    pl.xlabel="Frequency (GHz)"
    return pl

def magabs_colormesh3(self, f0=5.35e9, alpha=0.45, pl=None):
    fq_vec=array([sqrt(f*(f-2*qdt.call_func("Lamb_shift", f=f, f0=f0, couple_mult=alpha))) for f in self.frequency])
    pl=Plotter(fig_width=9.0, fig_height=6.0, name="magabs_{}".format(self.name))
    pl, pf=colormesh(self.yoko, self.frequency/1e9, absolute((self.Magcom.transpose()-self.Magcom[:, 0]).transpose()), plotter=pl)
    #pf.set_clim(-0.3, 0.1)
    #pl.set_ylim(min(fq_vec/1e9), max(fq_vec/1e9))
    #pl.set_xlim(min(self.yoko), max(self.yoko))

    pl.ylabel="Yoko (V)"
    pl.xlabel="Frequency (GHz)"
    return pl

def magabs_colormesh2(self, offset=-0.08, flux_factor=0.52, Ejmax=h*44.0e9, f0=5.35e9, alpha=0.7, pl=None):
    fq_vec=array([sqrt(f*(f+alpha*calc_freq_shift(f, qdt.ft, qdt.Np, f0, qdt.epsinf, qdt.W, qdt.Dvv))) for f in self.frequency])

    pl=Plotter(fig_width=9.0, fig_height=6.0, name="magabs_{}".format(self.name))
    pl, pf=colormesh(fq_vec, self.yoko, (self.MagdB.transpose()-self.MagdB[:, 0]), plotter=pl)
    pf.set_clim(-0.3, 0.1)
    #pl.set_xlim(min(self.frequency/1e9), max(self.frequency/1e9))
    pl.set_ylim(min(self.yoko), max(self.yoko))

    pl.ylabel="Yoko (V)"
    pl.xlabel="Frequency (GHz)"
    return pl

 def magphasefilt_colormesh(self):
     phase=angle(self.Magcom[10:-10, 10:-10])
     #phasefilt=array([unwrap(phase[:,n], discont=5.5) for n in range(phase.shape[1])])
     phase=(phase.transpose()-phase[:,0]).transpose()
     phasefilt=unwrap(phase, discont=1.5, axis=1)
     #phasefilt=phasefilt-phasefilt[0, :]
     pl, pf=colormesh(self.flux_over_flux0[10:-10], self.frequency[10:-10]/1e9,
                      phasefilt, plotter="magphasefilt_{}".format(self.name))
     #print self.voltage_from_flux_par2[0].shape,self.voltage_from_flux_par2[1].shape
     #line(self.voltage_from_flux_par2[0]/1e9, self.voltage_from_flux_par2[1], plotter=p)
     #print max(self.voltage_from_flux_par), min(self.voltage_from_flux_par)
     pl.xlabel="Yoko (V)"
     pl.ylabel="Frequency (GHz)"
     return pl

def magabs_colormesh(self, offset=-0.08, flux_factor=0.52, Ejmax=h*44.0e9, f0=5.35e9, alpha=0.7, pl=None):
    fq_vec=array([sqrt(f*(f+alpha*calc_freq_shift(f, qdt.ft, qdt.Np, f0, qdt.epsinf, qdt.W, qdt.Dvv))) for f in self.frequency])
    freq, frq2=flux_parabola(self.yoko, offset, 0.16, Ejmax, qdt.Ec)

    pl=Plotter(fig_width=9.0, fig_height=6.0, name="magabs_{}".format(self.name))
    pl, pf=colormesh(freq, fq_vec, (self.MagdB.transpose()-self.MagdB[:, 0]).transpose(), plotter=pl)
    pf.set_clim(-0.3, 0.1)
    line([min(freq), max(freq)], [min(freq), max(freq)], plotter=pl)
    flux_o_flux0=flux_over_flux0(self.yoko, offset, flux_factor)
    qEj=Ej(Ejmax, flux_o_flux0)
    EjdivEc=qEj/qdt.Ec
    ls_fq=qdt.call_func("lamb_shifted_fq", EjdivEc=EjdivEc)
    ls_fq2=qdt.call_func("lamb_shifted_fq2", EjdivEc=EjdivEc)

    frq2=qdt.call_func("lamb_shifted_anharm", EjdivEc=EjdivEc)/h
    line(ls_fq, ls_fq2, plotter=pl)

    #pl.set_xlim(min(self.frequency/1e9), max(self.frequency/1e9))
    #pl.set_ylim(min(self.yoko), max(self.yoko))

    pl.ylabel="Yoko (V)"
    pl.xlabel="Frequency (GHz)"
    return pl

    #dlist.extend([add_data(N) for N in range(87*2+1, 0, -1)])

    dlist.extend([add_data(N) for N in range(1,70+1)])
    #dlist.extend([add_data(39*2) for N in range(1,37+1)])
    dlist.extend([add_data(N) for N in range(70+1, 0, -1)])
    dlist.extend([add_data(1) for N in range(1,30+1)])
    
    
    
    data=array(dlist) 
    print data.shape
    #vf=3488.0
    #lbda0=vf/fc
    #lbda0/3488.0
    pl1=colormesh(f/1e9, 1/fc*linspace(0, 200, 201)/1e-9, data,
                  pl="SAW pulse simple theory", xlabel="Frequency (GHz)", ylabel="Time (ns)",
                auto_xlim=False, x_min=4.0, x_max=5.0,
                auto_ylim=False, y_min=0.0, y_max=44.0)
    colormesh(10*log10(absolute(data)))#.show()


    
    
def read_data(self):
    with File(self.rd_hdf.file_path, 'r') as f:
        print f["Traces"].keys()
        Magvec=f["Traces"]["test_osc - Ch1 - Data"]
        data=f["Data"]["Data"]
        self.comment=f.attrs["comment"]
        self.yoko=data[:,0,0].astype(float64)
        fstart=f["Traces"]['test_osc - Ch1 - Data_t0dt'][0][0]
        fstep=f["Traces"]['test_osc - Ch1 - Data_t0dt'][0][1]

a.bgsub_type="Complex" #"Abs" #"dB" #"Abs"

a.save_folder.main_dir=a.name

a.frq2_ind=0
a.pwr2_ind=1

a.read_data()
#a.pwr_ind=39
print a.yoko.shape
a.filter_type="None"
#a.magabs_colormesh(fig_width=6.0, fig_height=4.0)#.show()
scatter(absolute(a.MagcomFilt[170, 192, :]))
scatter(absolute(a.MagcomFilt[170, :, 0]))

colormesh(absolute(a.MagcomFilt[260, :, :]))#.show()
a.ifft_plot(fig_width=6.0, fig_height=4.0).show() #, time_axis_type="time",

a.filter_type="FFT"

a.pwr_ind=0
a.magabs_colormesh(pl=str(a.pwr[a.pwr_ind]))#.show()
a.pwr_ind=1
a.magabs_colormesh(pl=str(a.pwr[a.pwr_ind]))
a.pwr_ind=2
a.magabs_colormesh(pl=str(a.pwr[a.pwr_ind]))
#offset=0
a.pwr_ind=3
a.magabs_colormesh(pl=str(a.pwr[a.pwr_ind]))
a.pwr_ind=4
print a.frq2[a.frq_ind]

if __name__=="__main2__":
    pl.set_xlim(-6,6)
    pl.set_ylim(3.5, 7.5)
    pl.savefig(r"/Users/thomasaref/Dropbox (Clan Aref)/Current stuff/Logbook/TA210715A88_cooldown210216/tex_source_files/TA88_processed/", "fit_fluxmap")
    pl1.show()


if __name__=="__main2__":
    from taref.physics.filtering import Filter
    from numpy import absolute
    b=Filter(center=0, halfwidth=40, reflect=False, N=len(a.yoko))
    #Magcom=a.Magcom.transpose()
    Magfilt=array([b.fft_filter(a.Magcom[m,:]) for m in range(len(a.frequency[a.indices]))])#.transpose()
    pl=line(b.fftshift(absolute(b.window_ifft(a.Magcom[261, :]))), color="red")
    line(b.fftshift(absolute(b.window_ifft(a.Magcom[240, :]))), pl=pl)
    pl=colormesh(a.MagAbs)
    colormesh(absolute(Magfilt)[:, 10:-10]).show()
    colormesh((absolute(Magfilt).transpose()-absolute(Magfilt[:,20])).transpose()[:, 10:-10]).show()
    a.bgsub_type="Complex"
    pl, pf=line(a.MagAbs[:, 517])
    line(a.MagAbs[:, 519], color="red", pl=pl)
    line(a.MagAbs[:, 521], color="green", pl=pl)

    pl, pf=line(a.freq_axis, a.qdt._get_VfFWHM(f=a.frequency)[0],  color="blue")
    line(a.freq_axis, a.qdt._get_VfFWHM(f=a.frequency)[1],  color="green", pl=pl)

    line(a.freq_axis, a.qdt._get_VfFWHM(f=a.frequency)[2],  color="red", pl=pl)

    line(a.freq_axis, a.qdt._get_Vfq0(f=a.frequency),  color="purple", pl=pl)

    a.magabs_colormesh()

    #a.fitter.gamma=0.01
    c.flux_axis_type="flux"#"yoko"#
    c.end_skip=10
    c.read_data()
    #a.ifft_plot()

    c.bgsub_type="dB"
    #a.bgsub_type="Complex"
    c.filter_type="FFT"
    flux_axis=c.flux_axis[c.flat_flux_indices]
    freq_axis=c.freq_axis[c.indices]
    f0=qdt.f0/1e9
    colormesh(flux_axis, freq_axis/f0, c.MagAbs,  
              vmin=0.987, vmax=1.00, cmap="afmhot",
                       auto_zlim=False, pl=pl,
                       auto_xlim=False, x_min=0.25, x_max=0.35,
                       auto_ylim=False, y_min=0.85, #4.3/f0,
                       y_max=1.15, #6.0/f0,
                       xlabel="$\Phi/\Phi_0$", ylabel="Frequency ($f_0$)")#.show()

    line(array([0.25, 0.35]), array([4.85/f0, 4.85/f0]), pl=pl, linestyle="dashed", color="cyan", linewidth=1.0)                       
    line(array([0.25, 0.35]), array([5.75/f0, 5.75/f0]), pl=pl, linestyle="dashed", color="cyan", linewidth=1.0)                       

    pl.axes.set_xticks(linspace(0.25, 0.35, 3))
    #pl.axes.set_yticks(linspace(4.5, 6.0, 4))
    pl.axes.set_yticks(linspace(0.9, 1.1, 3))

    pl.figure.subplots_adjust(left = 0.0, right = 1.0, bottom = 0.0, top = 1.0, wspace = wspace, hspace = hspace)

    pl.nplot=4

    a.fd = 4.5066e9#/1e6 # Drive frequency.
    a.Ct=150e-15/3
    a.Cc=2e-15
    a.Zc=50.0
    a.acoustic_plot=True #False
    pwr=-100.0
    #Omega=a.Omega_arr[0]
    fd=4.5e9 #a.frq_arr[15]

    def find_expect(vg, self=a, fd=fd, pwr=pwr):
        return self.find_expect(vg=vg, fd=fd, pwr=pwr)
    a.funcer=find_expect


    if 1:
        pl=colormesh(a.phi_arr, a.pwr_arr, absolute(a.fexpt2), cmap="RdBu_r")
        lp=line(a.pwr_arr, absolute(a.fexpt2[:, 199])) #127/4
        lp=line(a.pwr_arr, absolute(a.fexpt2[:, 199+1]), pl=lp)
        lp=line(a.pwr_arr, absolute(a.fexpt2[:, 199-1]), pl=lp)

        pl=colormesh(a.phi_arr, a.pwr_arr, 1-absolute(a.fexpt2), cmap="RdBu_r")

        pl=colormesh(a.phi_arr, a.pwr_arr, 10*log10(absolute(a.fexpt2)), cmap="RdBu_r")
        #pl.show()
    a.phi_arr=linspace(-1.0, 1.0, 50)*pi


    if 1:

        pl1=colormesh(a.phi_arr, a.frq_arr, absolute(a.fexpt), cmap="RdBu_r")
        pl1=colormesh(a.phi_arr, a.frq_arr, 1-absolute(a.fexpt), cmap="RdBu_r")

a.end_skip=10
#a.flux_indices=[range(479, 712)] #range(0,41), range(43, 479), range(482, len(a.yoko))]
#a.bgsub_type="Abs"

a.save_folder.main_dir=a.name

a.read_data()
a.pwr_ind=20
print a.yoko.shape, a.pwr.shape
a.filter_type="None"
a.magabs_colormesh(fig_width=6.0, fig_height=4.0)#.show()
#scatter(absolute(a.MagcomFilt[535, 316, :]))
#scatter(absolute(a.MagcomFilt[535, :, 7]))

colormesh(absolute(a.MagcomData[139, :, :]))#.show()
colormesh(absolute(a.MagcomData[129, :, :]))#.show()
colormesh(absolute(a.MagcomData[149, :, :]))#.show()

#a.ifft_plot(fig_width=6.0, fig_height=4.0)#.show() #, time_axis_type="time",

#a.filter_type="FFT"
#a.pwr_ind=10
#a.magabs_colormesh(pl=str(a.pwr[a.pwr_ind]))
#a.pwr_ind=9
#a.magabs_colormesh(pl=str(a.pwr[a.pwr_ind]))
#a.pwr_ind=8
#a.magabs_colormesh(pl=str(a.pwr[a.pwr_ind]))
a.pwr_ind=15
a.magabs_colormesh(pl=str(a.pwr[a.pwr_ind]))
a.pwr_ind=6

 def magabsfit_colormesh(self, pl=None, xlabel="$\Phi/\Phi_0$", ylabel="Frequency (GHz)"):
     colormesh(self.flux_over_flux0[10:-10], self.frequency[self.indices][10:-10]/1e9,
                     self.MagAbsFit[10:-10, 10:-10], plotter=pl, xlabel=xlabel, ylabel=ylabel)