示例#1
0
    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
示例#2
0
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
示例#3
0
    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
示例#4
0
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
示例#5
0
def flux_par3(self, offset=-0.08, flux_factor=0.52, Ejmax=h*44.0e9, f0=5.35e9, alpha=0.7, pl=None):
    set_all_tags(qdt, log=False)
    flux_o_flux0=qdt.call_func("flux_over_flux0", voltage=self.yoko, offset=offset, flux_factor=flux_factor)
    #print flux_o_flux0-pi/2*trunc(flux_o_flux0/(pi/2.0))
    #Ej=qdt.call_func("Ej", flux_over_flux0=flux_o_flux0, Ejmax=Ejmax)
    #EjdivEc=Ej/qdt.Ec
    fq_vec=array([sqrt(f*(f+1.0*qdt.call_func("calc_Lamb_shift", fqq=f))) for f in self.frequency])
    fq_vec=array([f-qdt.call_func("calc_Lamb_shift", fqq=f) for f in self.frequency])
    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])
    Ej=Ej_from_fq(fq_vec, qdt.Ec)
    flux_d_flux0=arccos(Ej/Ejmax)#-pi/2
    flux_d_flux0=append(flux_d_flux0, -arccos(Ej/Ejmax))
    flux_d_flux0=append(flux_d_flux0, -arccos(Ej/Ejmax)+pi)
    flux_d_flux0=append(flux_d_flux0, arccos(Ej/Ejmax)-pi)

    if pl is not None:
        volt=voltage_from_flux(flux_d_flux0, offset, flux_factor)
        freq=s3a4_wg.frequency[:]/1e9
        freq=append(freq, freq) #append(freq, append(freq, freq)))
        freq=append(freq, freq)
        #freq=append(freq, freq)
        line(freq, volt, plotter=pl, linewidth=1.0, alpha=0.5)
        Ejdivh=Ej/h
        w0=4*Ejdivh*(1-sqrt(1-fq_vec/(2*Ejdivh)))
        EjdivEc=Ej/qdt.Ec
        #print -(w0**2)/(8*Ejdivh)

        ls_fq2=qdt.call_func("lamb_shifted_fq2", EjdivEc=EjdivEc)
        E0, E1, E2=qdt.call_func("transmon_energy_levels", EjdivEc=EjdivEc, n_energy=3)
        fq2=(E2-E1)/h
        f_vec=lamb_shifted_anharm(EjdivEc, qdt.ft, qdt.Np, qdt.f0, qdt.epsinf, qdt.W, qdt.Dvv)
        print f_vec/h
        ah=-ls_fq2/2#-fq2)
        #fq_vec=array([sqrt((f-ah[n])*(f-ah[n]+alpha*calc_freq_shift(f-ah[n], qdt.ft, qdt.Np, f0, qdt.epsinf, qdt.W, qdt.Dvv))) for n, f in enumerate(self.frequency)])
        fq_vec=array([f/2-qdt.call_func("calc_Lamb_shift", fqq=f/2) for f in self.frequency])
        coup=qdt.call_func("calc_coupling", fqq=self.frequency)
        print coup
        volt=array([
          voltage_from_flux(arccos(Ej_from_fq(f-f_vec[c]/h/2, qdt.Ec)/Ejmax), offset, flux_factor)
          for c,f in enumerate(self.frequency)])
        #freq=nan_to_num(freq)/1e9
        #print freq
        freq=s3a4_wg.frequency[:]/1e9

        #freq=(s3a4_wg.frequency[:]+coup)/1e9
        #freq=append(freq, freq)
        #freq=append(freq, freq)
        #Ej=Ej_from_fq(fq_vec, f_vec/h)
        #flux_d_flux0=arccos(Ej/Ejmax)#-pi/2
        #flux_d_flux0=append(flux_d_flux0, -arccos(Ej/Ejmax))
        #flux_d_flux0=append(flux_d_flux0, -arccos(Ej/Ejmax)+pi)
        #flux_d_flux0=append(flux_d_flux0, arccos(Ej/Ejmax)-pi)

        #freq=append(freq, freq)
        #fq_vec+=f_vec/h/2
        #fq2_vec=fq2(Ej, qdt.Ec)
        #Ej=Ej_from_fq(fq_vec, qdt.Ec) #qdt.call_func("lamb_shifted_fq2", EjdivEc=EjdivEc)
        #Ej=Ej_from_fq(fq_vec, qdt.Ec)
        #flux_d_flux0=arccos(Ej/Ejmax)#-pi/2
        #flux_d_flux0=append(flux_d_flux0, -arccos(Ej/Ejmax))
        #volt=voltage_from_flux(flux_d_flux0, offset, flux_factor)
        line(freq, volt, plotter=pl, plot_name="second", color="green", linewidth=1.0, alpha=0.5)
    #flux_d_flux0.append(-)
    return voltage_from_flux(flux_d_flux0, offset, flux_factor)