Ejemplo n.º 1
0
    def iv(self, channel, start=0, stop=3, step=0.2, delay=0.2):
        '''
        Take an IV on channel chan:
        - start / stop in V
        - steps
        '''

        biaspar = 'bias%d' % channel
        vmeaspar = 'vmeas%d' % channel

        r = self.get_resistance() / 1000.0 # Not sure why this is dividing. Bug?
        n = (int(abs(stop - start) / step)) + 1
        data = qt.Data(name='iv')
        data.add_coordinate('Vbias', units='V')
        data.add_value('Vmeas', units='V')
        data.create_file()
        for i in range(n):
            v_out = start + i * step
            current = v_out/r
            self.set(biaspar, v_out, check=False)
            qt.msleep(delay)
            v_meas = self.get(vmeaspar)
            print 'v_out, current_out, v_meas: %f, %f, %f' %(v_out, current, v_meas)
            data.add_data_point(v_out, v_meas)

        self.set(biaspar, 0)
        qt.plot(data, name='iv', clear=True)
        return data
Ejemplo n.º 2
0
 def plot_last_histogram(self):
     y, x = self._hist, self._hist_bins[
         1:] * self._hist_binsize_ns  #np.histogram(self._dts_ns, bins = np.linspace(self.get_roi_min(), self.get_roi_max(),pts))#np.min(dts[dts>0]),np.max(dts),pts))
     plotname = self.get_name() + '_histogram'
     qt.plot(x, y, name=plotname, clear=True)
     f = common.fit_exp_decay_shifted_with_offset
     #A * exp(-(x-x0)/tau) + a
     #['g_a', 'g_A', 'g_tau', 'g_x0']
     args = [1, np.max(y) * 0.1, 12, x[np.argmax(y) + 2.]]
     first_fit_bin = int(
         np.round(self._plot_extra_range / self._hist_binsize_ns))
     xf, yf = x[first_fit_bin:], y[first_fit_bin:]
     fitres = fit.fit1d(xf,
                        yf,
                        f,
                        *args,
                        fixed=[0],
                        do_print=False,
                        ret=True,
                        maxfev=100)
     plot_pts = 200
     x_p = np.linspace(min(xf), max(xf), plot_pts)
     if fitres['success']:
         y_p = fitres['fitfunc'](x_p)
         print 'fit success'
     else:
         y_p = f(*args)[1](x_p)
         print 'fit failed'
     print fitres['params_dict']
     qt.plot(x_p, y_p, 'b', name=plotname, clear=False)
     self.y = y
     self.x = x
Ejemplo n.º 3
0
 def plot_trace(self):
     '''
     performs a measurement and plots the data.
     '''
     freqs, reply = self.get_trace()
     qt.plot(freqs, reply, name='netan',
             xlabel='freq [Hz]', ylabel='S_ij [dB]',
             clear=True)
Ejemplo n.º 4
0
 def save_spectrum(self, ret=False):
     spec = andor.get_spectrum()
     specd = qt.Data(name='spectrum')
     specd.add_value('Counts')
     specd.create_file()
     specd.add_data_point(spec)
     specd.close_file()
     qt.plot(specd, name='saved_spectrum', clear=True)
     if ret:
         return spec
Ejemplo n.º 5
0
 def save_spectrum(self, ret=False):
     spec = andor.get_spectrum()
     specd = qt.Data(name='spectrum')
     specd.add_value('Counts')
     specd.create_file()
     specd.add_data_point(spec)
     specd.close_file()
     qt.plot(specd, name='saved_spectrum', clear=True)
     if ret:
         return spec
Ejemplo n.º 6
0
 def save_spectrum(self, ret=False):
     spec = winspec.get_spectrum()
     specd = qt.Data(name='spectrum')
     specd.add_coordinate('Wavelength', units='nm')
     specd.add_value('Counts')
     specd.create_file()
     specd.add_data_point(spec)
     specd.close_file()
     qt.plot(specd, name='saved_spectrum', clear=True)
     if ret:
         return spec
Ejemplo n.º 7
0
 def save_spectrum(self, ret=False):
     spec = winspec.get_spectrum()
     specd = qt.Data(name='spectrum')
     specd.add_coordinate('Wavelength', units='nm')
     specd.add_value('Counts')
     specd.create_file()
     specd.add_data_point(spec)
     specd.close_file()
     qt.plot(specd, name='saved_spectrum', clear=True)
     if ret:
         return spec
Ejemplo n.º 8
0
 def save_spectrum(self, ret=False):
     spec = winspec.get_spectrum()
     specd = qt.Data(name="spectrum")
     specd.add_coordinate("Wavelength", units="nm")
     specd.add_value("Counts")
     specd.create_file()
     specd.add_data_point(spec)
     specd.close_file()
     qt.plot(specd, name="saved_spectrum", clear=True)
     if ret:
         return spec
Ejemplo n.º 9
0
    def iv_counts_disc_sr400(self, channel, start=0, stop=10, step=0.25, delay=0.2, discarray = [0.2]):
        '''
        Take an IV on channel chan and measure count rate:
        - start / stop in V
        - steps
        '''

        print ''
        sr400 = qt.instruments['sr400']

        biaspar = 'bias%d' % channel
        vmeaspar = 'vmeas%d' % channel



        r = self.get_resistance() / 1000.0
        n = (int(abs(stop - start) / step)) + 1
        data = qt.Data(name='iv')
        data.add_coordinate('Vbias', units='V')
        data.add_value('Vmeas', units='V')
        data.add_value('Counts', units='')
        data.create_file()

        plot3d = qt.Plot3D(data, name='3D', style='image', coorddims=(1,0), valdim=2)
        for disc in discarray:
            if (msvcrt.kbhit() and (msvcrt.getch() == 'q')): break
            sr400.set_disc_levelA(disc)
            sr400.set_disc_levelB(disc)
            for i in range(n):
                if (msvcrt.kbhit() and (msvcrt.getch() == 'q')): break
                v_out = start + i * step
                current = v_out/r
                self.set(biaspar, v_out, check=False)
                time.sleep(delay)
                v_meas = self.get(vmeaspar)
                if channel == 0:
                    counts = sr400.get_countA()
                else:
                    counts = sr400.get_countB()
                print 'v_out, current_out, v_meas, counts: %f, %f, %f, %d' % (v_out, current, v_meas, counts)
                data.add_data_point(v_out, v_meas, counts)
                data.add_data_point(v_out, disc, counts)

                if v_meas > 0.5:
                    break

        self.set(biaspar, 0)

        qt.plot(data, name='ivcounts', clear=True)
        qt.plot(data, name='ivcounts', valdim=2, right=True)

        return data
Ejemplo n.º 10
0
    def optimize(self, plot=0, dims='Vdim', cycles=1):
        if 'laserscan_plot' in qt.plots:
            qt.plots['laserscan_plot'].clear()
        qt.plot(name='laserscan_plot',clear=True,needtempfile=False)

        for c in range(cycles):
            ret = True
            #print '%s' % self.dimensions['V']
            for d in self.dimensions[dims]:
                #print 'dims is %s d is %s' % (dims, d)
                scan_length = self.dimensions[d]['scan_length']
                nr_of_points = self.dimensions[d]['nr_of_points']

                if d == 'V':
                    # Get the current voltage from the Toptica
                    cur_V = self._topt.get_piezo_voltage()
                    if cur_V == None:
                        logging.warning(__name__ + 'Current position is none! Toptica voltage not initialized?')
                        break

                    self._opt_pos_prev['V'] = cur_V
                    # Create the desired array of points to measure

                    point_array = np.linspace(cur_V-scan_length/2.0,cur_V+scan_length/2.0,nr_of_points)

                    count_array = self.sweep_laser_and_count(point_array)
                    # Find the difference between readouts to get the counts measured
                    # at a certain point, then divide by the period to get the estimate
                    # of the counts per second

                    # Call the fitting routine to determine optimal position
                    # and set it as self._opt_pos['x'], in this case.
                    ret = self.process_fit(point_array, count_array, 'V', 10.0)
                    print 'Previous V/sigma: %.3f/%.3f, new optimum V: %.3f (delta %.1f V)' % (self._opt_pos_prev['V'], self._opt_sigma_prev['V'], self._opt_pos['V'], self._opt_pos['V']-self._opt_pos_prev['V'])
                    #
                    if np.array(point_array).min() < self._opt_pos['V'] < np.array(point_array).max():
                        self._topt.set_piezo_voltage(self._opt_pos['V'])
                    else:
                        self._topt.set_piezo_voltage(self._opt_pos_prev['V'])
                        self._opt_pos['V'] = self._opt_pos_prev['V']
                        print 'Optimum outside scan range: Position is set to previous maximum'
                        ret = False



                qt.msleep(0.05)
            if msvcrt.kbhit():
                kb_char=msvcrt.getch()
                if kb_char == "q" : break


        return ret
Ejemplo n.º 11
0
    def focus_plot(self):
        samples = 12000
        rate = 240000
        channel = self.FP_params['aiport']
        while True:
            rsamples = self.read_sweep(samples, rate, channel)
            time_axis = np.linspace(0.0,float(np.size(rsamples))/rate,np.size(rsamples))
            qt.plot(time_axis,rsamples,name='fp_focusplot',traceofs=0.2, clear=True,linewidth=6)
            time.sleep(0.5)
            if msvcrt.kbhit():
                kb_char=msvcrt.getch()
                if kb_char == "q" : break

        return
Ejemplo n.º 12
0
    def iv_counts_sr400(self, channel, start=0, stop=10, step=0.25, delay=0.2):
        '''
        Take an IV on channel chan and measure count rate:
        - start / stop in V
        - steps
        '''

        print ''
        sr400 = qt.instruments['sr400']

        biaspar = 'bias%d' % channel
        vmeaspar = 'vmeas%d' % channel

        r = self.get_resistance() / 1000.0
        n = (int(abs(stop - start) / step)) + 1
        data = qt.Data(name='iv')
        data.add_coordinate('Vbias', units='V')
        data.add_value('Vmeas', units='V')
        data.add_value('Counts', units='')
        data.create_file()
        for i in range(n):
            v_out = start + i * step
            current = v_out/r
            self.set(biaspar, v_out, check=False)
            time.sleep(delay)
            v_meas = self.get(vmeaspar)
            if channel == 0:
                counts = sr400.get_countA()
            else:
                counts = sr400.get_countB()
            print 'v_out, current_out, v_meas, counts: %f, %f, %f, %d' % (v_out, current, v_meas, counts)
            data.add_data_point(v_out, v_meas, counts)

            if v_meas > 0.5:
                break

        self.set(biaspar, 0)

        qt.plot(data, name='ivcounts', clear=True)
        qt.plot(data, name='ivcounts', valdim=2, right=True)

        return data
Ejemplo n.º 13
0
def find_initial_values_lorentzian(x_data,
                                   y_data,
                                   moving_average=2,
                                   plot_res=False):
    '''
    finds the initial values for a lorentzian dip or peak
    p[0] = x0
    p[1] = 2*HM dip height
    p[2] = dx width
    p[3] = y0 offset
    '''
    p = 4 * [0]
    diffy = mva.movingaverage(diff(y_data), moving_average)
    if plot_res:
        pl = plot(name='find_resonance')
        pl.clear()
        plot(diffy, title='moving_average of diff_y', name='find_resonance')
        plot(y_data, title='y_data', name='find_resonance')
    dymax = max(diffy)
    i_dymax = diffy.tolist().index(dymax)
    dymin = min(diffy)
    i_dymin = diffy.tolist().index(dymin)
    if i_dymin > i_dymax:
        '''
        means its a peak
        '''
        peak = 1
        y0 = min(y_data)
    else:
        '''
        means its a dip
        '''
        peak = -1
        y0 = max(y_data)
    dx = abs(x_data[i_dymin] - x_data[i_dymax])
    x0 = (x_data[i_dymin] + x_data[i_dymax]) / 2
    HM = peak * abs(y_data[i_dymax] - y_data[floor((i_dymin + i_dymax) / 2)])
    p[0] = x0
    p[1] = 2 * HM
    p[2] = dx
    p[3] = y0
    return p
def find_initial_values_lorentzian(x_data,y_data,moving_average = 2, plot_res = False):
    '''
    finds the initial values for a lorentzian dip or peak
    p[0] = x0
    p[1] = 2*HM dip height
    p[2] = dx width
    p[3] = y0 offset
    '''
    p=4*[0]
    diffy = mva.movingaverage(diff(y_data),moving_average)
    if plot_res:
        pl = plot(name='find_resonance')
        pl.clear()
        plot(diffy,title='moving_average of diff_y',name='find_resonance')
        plot(y_data,title='y_data',name='find_resonance')
    dymax = max(diffy)
    i_dymax = diffy.tolist().index(dymax)
    dymin = min(diffy)
    i_dymin = diffy.tolist().index(dymin)
    if i_dymin>i_dymax:
        '''
        means its a peak
        '''
        peak = 1
        y0 = min(y_data)
    else:
        '''
        means its a dip
        '''
        peak = -1
        y0 = max(y_data)
    dx = abs(x_data[i_dymin] - x_data[i_dymax])
    x0 = (x_data[i_dymin] + x_data[i_dymax])/2
    HM = peak*abs(y_data[i_dymax] - y_data[floor((i_dymin+i_dymax)/2)])
    p[0] = x0
    p[1] = 2*HM
    p[2] = dx
    p[3] = y0
    return p
    def save_ROI_data(self, x, y, z, sweepname='sweep_value'):
        roix = y
        roiy = z[:,self.ROI_min:self.ROI_max].sum(axis=1)
        np.savetxt(os.path.join(self.save_folder, 
            self.save_filebase+'_ROI_sum.dat'), np.vstack((roix,roiy)).T)

        p = qt.plot(roix, roiy, 'rO-', name='ROI_summed', clear=True,
                xlabel=sweepname, ylabel='counts', title='ROI summed')
        p.reset()
        
        h,ts = os.path.split(self.save_folder)
        h,date = os.path.split(h)

        p.set_plottitle(date+'/'+ts+': '+'ROI_summed')
        p.save_png(os.path.join(self.save_folder, self.save_filebase))
Ejemplo n.º 16
0
    def optimize(self):
        self.initialize()
        for i in range(int(self._iterations)):
            print 'Iteration %d, cur_f %.2f' % (i, self._cur_f)
            self.iterate()
            print 'Current x location is: %s, %s' % (np.array(self._cur_x), self._cur_f)
            time.sleep(0.1)
        print 'Done!'

        self._optimization_is_on = False
        if self._complete_poll == True:
            hist = np.array(self._history)
            plot2d_1 = qt.plot(np.arange(hist.size),hist,name='mads_optimize',clear=True)
            #plot2d = qt.plot(self._hypd, coorddim=0, valdim=1,name='optT4',clear=True)
            #plot2d.add_data(self._hypd, coorddim=0, valdim=2, maxtraces=1)
            #plot2d.add_data(self._hypd, coorddim=0, valdim=3, maxtraces=1)
#
#            plota1 = qt.plot(self._hypd, coorddim=0, valdim=4,name='angle1',clear=True)
#            plota2 = qt.plot(self._hypd, coorddim=0, valdim=5,name='angle2',clear=True)
#            plotcmax = qt.plot(self._hypd, coorddim=0, valdim=6,name='cmax',clear=True)
#            plotfevals = qt.plot(self._hypd, coorddim=0, valdim=8, maxtraces=1, clear=True)
#            plotmmax = qt.plot(self._hypd, coorddim=0, valdim=9, name='mmax', maxtraces=1, clear=True)
        else:
            hist = np.array(self._history)
            plot2d_1 = qt.plot(np.arange(hist.size),hist,name='mads_optimize',clear=True)
#
#            plota1 = qt.plot(self._hypd, coorddim=0, valdim=1,name='angle1',clear=True)
#            plota2 = qt.plot(self._hypd, coorddim=0, valdim=2,name='angle2',clear=True)
#            plotcmax = qt.plot(self._hypd, coorddim=0, valdim=3,name='cmax',clear=True)
#            plotfevals = qt.plot(self._hypd, coorddim=0, valdim=5, maxtraces=1, clear=True)
#            plotmmax = qt.plot(self._hypd, coorddim=0, valdim=6, maxtraces=1, clear=True, name='mmax')


        print 'Total function evals: %d' % self._nfeval
#        plotff = qt.plot(self._fed, coorddim=0, valdim=1, maxtraces=1, name='fevalp', clear=True)
        return np.array(self._cur_x)
Ejemplo n.º 17
0
    def max_intensity_plot(self):
        samples = 500
        rate = 10000
        channel = self.FP_params['aiport']
        data = qt.Data(name='max_int_data')
        data.add_coordinate('time')
        data.add_value('intensity')
        t0 = time.time()
        miplot = qt.plot(data,name='maxintplot',traceofs=0.2, coorddim=0, valdim=1, maxpoints=100, linewidth=6, clear=True)
        while True:
            rsamples = self.read_sweep(samples, rate, channel)
            data.add_data_point((time.time()-t0),np.max(rsamples))
            miplot.update()

            time.sleep(0.5)
            if msvcrt.kbhit():
                kb_char=msvcrt.getch()
                if kb_char == "q" : break

        return
Ejemplo n.º 18
0
    def save_trace(self, filepath=None, plot=True):
        '''
        runs 'get_trace()' and saves the output to a file.

        Input:
            filepath (string):  Path to where the file should be saved.(optional)

        Output:
            filepath (string):  The filepath where the file has been created.
        '''
        #TODO: change value label 'S_ij' to represent actual measurement
        freqs, reply = self.get_trace()
        d = qt.Data(name='netan')
        d.add_coordinate('freq [Hz]')
        d.add_value('S_ij [dB]')
        d.create_file(filepath=filepath)
        d.add_data_point(zip(freqs, reply))
        d.close_file()
        if plot:
            p = qt.plot(d, name='netan', clear=True)
            p.save_png()
            p.save_gp()
        return d.get_filepath()
    def save_ROI_data(self, x, y, z, sweepname='sweep_value'):
        roix = y
        roiy = z[:, self.ROI_min:self.ROI_max].sum(axis=1)
        np.savetxt(
            os.path.join(self.save_folder,
                         self.save_filebase + '_ROI_sum.dat'),
            np.vstack((roix, roiy)).T)

        p = qt.plot(roix,
                    roiy,
                    'rO-',
                    name='ROI_summed',
                    clear=True,
                    xlabel=sweepname,
                    ylabel='counts',
                    title='ROI summed')
        p.reset()

        h, ts = os.path.split(self.save_folder)
        h, date = os.path.split(h)

        p.set_plottitle(date + '/' + ts + ': ' + 'ROI_summed')
        p.save_png(os.path.join(self.save_folder, self.save_filebase))
Ejemplo n.º 20
0
    def avg_max_intensity_plot(self):
        samples = 500
        rate = 10000
        channel = self.FP_params['aiport']
        data = qt.Data(name='avg_max_int_data')
        data.add_coordinate('time')
        data.add_value('intensity')
        t0 = time.time()
        miplot = qt.plot(data,name='avgmaxintplot',traceofs=0.2, coorddim=0, valdim=1, maxpoints=100,linewidth=7,clear=True)
        while True:
            rsamples = self.read_sweep(samples, rate, channel)
            time_axis = np.linspace(0.0,float(np.size(rsamples))/rate,np.size(rsamples))
            p = pf.PeakFinder(time_axis,rsamples, maxpeaks = 4,threshold = 4,fitwidth=35,fitfunc='FIT_LORENTZIAN',amp_threshold=0.2)
            peaks = p.find(sign=1, bgorder=1)
            peak_array = np.array(peaks)
            data.add_data_point((time.time()-t0),np.mean(peak_array[:,1]))
            miplot.update()
            time.sleep(0.5)
            if msvcrt.kbhit():
                kb_char=msvcrt.getch()
                if kb_char == "q" : break

        return
Ejemplo n.º 21
0
    def save_trace(self, filepath=None, plot=True):
        '''
        runs 'get_trace()' and saves the output to a file.

        Input:
            filepath (string):  Path to where the file should be saved.(optional)

        Output:
            filepath (string):  The filepath where the file has been created.
        '''
        #TODO: change value label 'S_ij' to represent actual measurement
        freqs, reply = self.get_trace()
        d = qt.Data(name='netan')
        d.add_coordinate('freq [Hz]')
        d.add_value('S_ij [dB]')
        d.create_file(filepath=filepath)
        d.add_data_point(zip(freqs, reply))
        d.close_file()
        if plot:
            p = qt.plot(d, name='netan', clear=True)
            p.save_png()
            p.save_gp()
        return d.get_filepath()
Ejemplo n.º 22
0
import numpy as np
import qt

x = np.arange(-10, 10, 0.2)
y = np.sinc(x)
yerr = 0.1 * np.random.rand(len(x))

d = qt.Data()
d.add_coordinate("x")
d.add_coordinate("y")
d.add_coordinate("yerr")
d.create_file()
d.add_data_point(x, y, yerr)

p = qt.Plot2D()
p.add_data(d, coorddim=0, valdim=1, yerrdim=2)

# or:
qt.plot(x, y, yerr=yerr, name="test2")
Ejemplo n.º 23
0
 def plot(self):
     if not self._dev:
         return
     import qt
     x, trace = self._dev.get_block()
     qt.plot(trace, name='picoharp', clear=True)
Ejemplo n.º 24
0
    def process_fit(self, p, cr, dimension):

        # p is position array
        # cr is countrate array
        # d is a string corresponding to the dimension

        # Get the Gaussian width sigma guess from the dimensions dictionary
        sigma_guess = self.dimensions[dimension]['sigma']
        # Always do a Gaussian fit, for now
        self._gaussian_fit = True

        if self._gaussian_fit:
            # Come up with some robust estimates, for low signal/noise conditions
            a_guess = np.array(cr).min()
            A_guess = np.array(cr).max()-np.array(cr).min()
            p_size = np.size(p)
            x0_guess = p[np.round(p_size/2.0)] #np.sum(np.array(cr) * np.array(p))/np.sum(np.array(cr)**2)
            #sigma_guess = 1.0#np.sqrt(np.sum(((np.array(cr)-x0_guess)**2)*(np.array(p))) / np.sum((np.array(p))))
            #print 'Guesses: %r %r %r %r' % (a_guess,  x0_guess,A_guess,sigma_guess)

            gaussian_fit = fit.fit1d(np.array(p,dtype=float), np.array(cr,dtype=float),common.fit_gauss, a_guess,
                    x0_guess,A_guess, sigma_guess, do_print=False,ret=True)

            ababfunc = a_guess + A_guess*np.exp(-(p-x0_guess)**2/(2.0*sigma_guess**2))

            if type(gaussian_fit) != dict:
                pamax = np.argmax(cr)
                self._opt_pos[dimension] = p[pamax]
                ret = False
                print '(%s) fit failed! Set to maximum.' % dimension


            else:

                if gaussian_fit['success'] != False:
                    self._fit_result = [gaussian_fit['params'][1],
                            gaussian_fit['params'][2],
                            gaussian_fit['params'][3],
                            gaussian_fit['params'][0] ]
                    self._fit_error = [gaussian_fit['error'][1],
                            gaussian_fit['error'][2],
                            gaussian_fit['error'][3],
                            gaussian_fit['error'][0] ]
                    self._opt_pos[dimension] = self._fit_result[0]
                    ret = True
                    final_fit_func = gaussian_fit['params'][0] + gaussian_fit['params'][2]*np.exp(-(p-gaussian_fit['params'][1])**2/(2.0*gaussian_fit['params'][3]**2))
                    qt.plot(p,cr,p,ababfunc,p,final_fit_func,name='fbl_plot',needtempfile=False)
                    #print '(%s) optimize succeeded!' % self.get_name()


                else:
                    self.set_data('fit', zeros(len(p)))
                    ret = False
                    print '(%s) optimize failed! Set to maximum.' % dimension
                    self._opt_pos[dimension] = p[np.argmax(cr)]
                    qt.plot(p,cr,p,ababfunc,name='fbl_plot',clear=True,needtempfile=False)




        return ret
Ejemplo n.º 25
0
    def num2str(num, precision):
        return "%0.*f" % (precision, num)

    A = fit.Parameter(max(measured_power - BG) / 2)
    B = fit.Parameter(max(measured_power - BG) / 2)
    f = fit.Parameter(1 / 2.5)
    phi = fit.Parameter(0)

    def fit_cos(x):
        return A() + B() * cos(2 * pi * f() * x + phi())

    ret = fit.fit1d(V_EOM.reshape(-1),
                    measured_power.reshape(-1) - BG,
                    None,
                    fitfunc=fit_cos,
                    p0=[A, B, f, phi],
                    do_plot=True,
                    do_print=True,
                    ret=True)
    p = qt.plots['EOM Calibration curve']
    V = linspace(EOM_min_voltage, EOM_max_voltage, V_step_size / 10)
    qt.plot(V, fit_cos(V), 'r-', name='EOM Calibration curve')

plt.save_png(file_directory[0:65] + 'calibration_EOM_curve.png')

print 'Extinction = max/min = ' + num2str(
    max(measured_power - BG) / min(measured_power - BG), 0)

print 'Done'
Ejemplo n.º 26
0
 def plot(self):
     if not self._dev:
         return
     import qt
     x, trace = self._dev.get_block()
     qt.plot(trace, name='picoharp', clear=True)
Ejemplo n.º 27
0
    def optimize(self, plot=0, dims='xyz', cycles=1):
        if 'fbl_plot' in qt.plots:
            qt.plots['fbl_plot'].clear()
        qt.plot(name='fbl_plot',clear=True,needtempfile=False)

        for c in range(cycles):
            ret = True

            for d in self.dimensions[dims]:
                scan_length = self.dimensions[d]['scan_length']
                nr_of_points = self.dimensions[d]['nr_of_points']

                if d == 'x':
                    # Get the current position from the FSM - only works if the
                    # FSM has been written to at least once!
                    cur_pos = self._fsm.get_abs_positionX()
                    if cur_pos == None:
                        print 'Current position is none! FSM not initialized?'
                        break

                    self._opt_pos_prev['x'] = cur_pos
                    # Create the desired array of points to measure

                    point_array = np.linspace(cur_pos-scan_length/2.0,cur_pos+scan_length/2.0,nr_of_points)

                    # Add the beginning point so that it's in the array twice
                    # at the beginning. This is because we're looking for the
                    # difference between counter reads to get the counts per
                    # second at a position.
                    temp_point_array = np.insert(point_array,0,cur_pos-scan_length/2.0,axis=0)
                    # Use AO Smooth Goto code to smoothly go to the beginning point
                    self._fsm.AO_smooth(cur_pos, cur_pos-scan_length/2.0, 'X')
                    # Now write the points and get the counts
                    fsm_rate = 40.0 # Hz

                    counts = self._fsm.sweep_and_count(temp_point_array,fsm_rate, 'ctr0','PFI0','X')
                    # Find the difference between readouts to get the counts measured
                    # at a certain point, then divide by the period to get the estimate
                    # of the counts per second
                    cps = np.diff(counts)*fsm_rate
                    # Call the fitting routine to determine optimal position
                    # and set it as self._opt_pos['x'], in this case.
                    ret = self.process_fit(point_array, np.diff(counts), 'x', fsm_rate)
                    print 'Previous x: %.3f, new optimum: %.3f (delta %.1f nm)' % (self._opt_pos_prev['x'], self._opt_pos['x'], self._opt_pos['x']*1E3-self._opt_pos_prev['x']*1E3)
                    #
                    if np.array(point_array).min() < self._opt_pos['x'] < np.array(point_array).max():
                        self._fsm.set_abs_positionX(self._opt_pos['x'])
                    else:
                        self._fsm.set_abs_positionX(self._opt_pos_prev['x'])
                        self._opt_pos['x'] = self._opt_pos_prev['x']
                        print'Optimum outside scan range: Position is set to previous maximum'
                        ret = False

                    #print 'Position changed %d nm' % (self._opt_pos['x']*1E3-self._opt_pos_prev['x']*1E3)

                if d == 'y':
                    # Get the current position from the FSM - only works if the
                    # FSM has been written to at least once!
                    cur_pos = self._fsm.get_abs_positionY()
                    self._opt_pos_prev['y'] = cur_pos
                    # Create the desired array of points to measure
                    point_array = np.linspace(cur_pos-scan_length/2.0,cur_pos+scan_length/2.0,nr_of_points)

                    # Add the beginning point so that it's in the array twice
                    # at the beginning. This is because we're looking for the
                    # difference between counter reads to get the counts per
                    # second at a position.
                    temp_point_array = np.insert(point_array,0,cur_pos-scan_length/2.0,axis=0)
                    ##print 'y temp point array %s' % temp_point_array
                    # Use AO Smooth Goto code to smoothly go to the beginning point
                    self._fsm.AO_smooth(cur_pos, cur_pos-scan_length/2.0, 'Y')
                    # Now write the points and get the counts
                    fsm_rate = 40.0 # Hz
                    counts = self._fsm.sweep_and_count(temp_point_array,fsm_rate, 'ctr0','PFI0','Y')
                    # Find the difference between readouts to get the counts measured
                    # at a certain point, then divide by the period to get the estimate
                    # of the counts per second
                    cps = np.diff(counts)*fsm_rate
                    # Call the fitting routine to determine optimal position
                    # and set it as self._opt_pos['y'], in this case.
                    ret = self.process_fit(point_array, np.diff(counts), 'y', fsm_rate)
                    print 'Previous y: %.3f, new optimum: %.3f (delta %.1f nm)' % (self._opt_pos_prev['y'], self._opt_pos['y'], self._opt_pos['y']*1.0E3-self._opt_pos_prev['y']*1.0E3)

                    if np.array(point_array).min() < self._opt_pos['y'] < np.array(point_array).max():
                        self._fsm.set_abs_positionY(self._opt_pos['y'])
                    else:
                        self._fsm.set_abs_positionY(self._opt_pos_prev['y'])
                        self._opt_pos['y'] = self._opt_pos_prev['y']
                        print 'Optimum outside scan range: Position is set to previous maximum'
                        ret = False

                    #print 'Position changed %d nm' % (self._opt_pos['y']*1.0E3-self._opt_pos_prev['y']*1.0E3)

                if d == 'z':
                    # Get the current position from the FSM - only works if the
                    # FSM has been written to at least once!
                    cur_pos = self._xps.get_abs_positionZ() # In mm, not um!
                    self._opt_pos_prev['z'] = cur_pos # In mm
                    # Create the desired array of points to measure
                    # Note 0.001 converts from mm to um!
                    point_array = np.linspace(cur_pos-scan_length*0.001/2.0,cur_pos+scan_length*0.001/2.0,nr_of_points)

                    # No need to double up on initial position in the point array
                    # since the counts will be read out step-by-step and not in
                    # a synchronized DAQ read.

                    # Set the position on the XPS to the initial point; sort of redundant
                    self._xps.set_abs_positionZ((cur_pos-0.001*scan_length/2.0))
                    # Now write the points and get the counts
                    counts = np.zeros(nr_of_points)
                    # HARDCODED SETUP FOR COUNT READING
                    xps_rate = 40.0 # Hz
                    xps_settle_time = 10.0*0.001 # 10 ms
                    prev_ctr0_src = self._ni63.get_ctr0_src()
                    self._ni63.set_ctr0_src('PFI0')
                    prev_count_time = self._ni63.get_count_time()
                    self._ni63.set_count_time(1.0/xps_rate)
                    for i in range(nr_of_points):
                        # Point array is in mm, so this should work
                        self._xps.set_abs_positionZ((point_array[i]))
                        qt.msleep(xps_settle_time)
                        counts[i] = self._ni63.get_ctr0()
                    self._ni63.set_count_time(prev_count_time)
                    self._ni63.set_ctr0_src(prev_ctr0_src)
                    # Find the difference between readouts to get the counts measured
                    # at a certain point, then divide by the period to get the estimate
                    # of the counts per second
                    cps = counts*xps_rate

                    # Call the fitting routine to determine optimal position
                    # and set it as self._opt_pos['z'], in this case.
                    ret = self.process_fit(point_array, counts, 'z', xps_rate)
                    print 'Previous z: %.6f, new optimum is %.6f (delta %.1f nm)' % (self._opt_pos_prev['z'], self._opt_pos['z'], self._opt_pos['z']*1.0E6-self._opt_pos_prev['z']*1.0E6)


                    #
                    if np.array(point_array).min() < self._opt_pos['z'] < np.array(point_array).max():
                        self._xps.set_abs_positionZ(self._opt_pos['z'])
                    else:
                        self._xps.set_abs_positionZ(self._opt_pos_prev['z'])
                        print 'Optimum outside scan range: Position is set to previous maximum'
                        self._opt_pos['z'] = self._opt_pos_prev['z']
                        ret = False
                    # Use 10^6 instead of 10^3 to convert from mm to nm
                    qt.msleep(0.1)


                qt.msleep(0.05)
            if msvcrt.kbhit():
                kb_char=msvcrt.getch()
                if kb_char == "q" : break


        return ret
    def num2str(num, precision):
        return "%0.*f" % (precision, num)

    A = fit.Parameter(max(measured_power - BG) / 2)
    B = fit.Parameter(max(measured_power - BG) / 2)
    f = fit.Parameter(1 / 2.5)
    phi = fit.Parameter(0)

    def fit_cos(x):
        return A() + B() * cos(2 * pi * f() * x + phi())

    ret = fit.fit1d(
        V_EOM.reshape(-1),
        measured_power.reshape(-1) - BG,
        None,
        fitfunc=fit_cos,
        p0=[A, B, f, phi],
        do_plot=True,
        do_print=True,
        ret=True,
    )
    p = qt.plots["EOM Calibration curve"]
    V = linspace(EOM_min_voltage, EOM_max_voltage, V_step_size / 10)
    qt.plot(V, fit_cos(V), "r-", name="EOM Calibration curve")

plt.save_png(file_directory[0:65] + "calibration_EOM_curve.png")

print "Extinction = max/min = " + num2str(max(measured_power - BG) / min(measured_power - BG), 0)

print "Done"
Ejemplo n.º 29
0
 def take_spectrum(self, ret=False):
     spec = winspec.get_spectrum()
     qt.plot(spec, name='winspec_spectrum', clear=True)
     if ret:
         return spec
Ejemplo n.º 30
0
 def take_spectrum(self, ret=False):
     spec = winspec.get_spectrum()
     qt.plot(spec, name='winspec_spectrum', clear=True)
     if ret:
         return spec
Ejemplo n.º 31
0
 def take_spectrum(self, ret=False):
     spec = andor.get_spectrum()
     qt.plot(spec, name='andor_spectrum', clear=True)
     if ret:
         return spec
Ejemplo n.º 32
0
def fit1D(x,y,fit_func, **kw):
    '''
    parameters
    x : tuple of indep. variables
    y : dep. var. (data)
    fit_func : function to be fitted structure fit_fun(x, p0) with p0 parameters
    
    known KW
    init_guess : vector of initial estimates for p0
    guess_func : function that guesses the initial parameters p0
    full_output : True by default
    onscreen : print reuslts on screen
    ret_fit : return an array fit_func(x, Pfit)
    plot_results=False
    '''
    full_output = kw.pop('full_output',True)
    onscreen = kw.pop('onscreen',True)
    kw_c=kw.copy()
    qt.mstart()
    
    try:
        p0 = kw_c.pop('init_guess')
    except KeyError:
        print('No initial guess given, trying guess func instead')
        p0 = kw_c.pop('guess_func')(x,y) 
    if type(x)==type((0,)):
        var = x+(y,)
    else :
        x=(x,)
        var=x+(y,)

    if type(p0)==type((0,)):
        pass
    else :
        p0=tuple(p0)

    plres=kw.pop('plot_results', False)
    if plres:
        pltr=plot(name='fit monitor')
        pltr.clear()
        init_guess_arr = fit_func(*(x+tuple(p0)))
        plot(x[0], init_guess_arr, title = 'initial guess',name='fit monitor')
        plot(x[0], y, title = 'data',name='fit monitor')
        



    plsq,cov,info,mesg,success = leastsq(_residuals_m, \
            p0, args=(fit_func,)+var, full_output = 1, maxfev=10000)#,xtol=kw.pop('xtol',1.e-10))
    try :
        len(plsq)
    except TypeError :
        plsq=[plsq]
    if onscreen:
        print('plsq',plsq)
        print('mesg',mesg)
        print(cov)
        #print 'info: ',info
    dof = max(np.shape(y)) - len(plsq)
    errors = estimate_errors(plsq,info,cov,dof)
    k=0
    if plres:
        
        fresarr = fit_func(*(x+tuple(plsq)))
        plot(x[0],fresarr , title = 'fit',name='fit monitor')
    if onscreen:
        for p in plsq:
            print('p%s = %s +/- %s'%(k,p,errors[k]))
            k+=1
    if kw.pop('ret_fit',False):
        return plsq, errors, fit_func(*(x+tuple(plsq))),cov,info
    else:
        return plsq, errors
    qt.mstop()
Ejemplo n.º 33
0
import numpy as np
import qt

x = np.arange(-10, 10, 0.2)
y = np.sinc(x)
yerr = 0.1*np.random.rand(len(x))

d = qt.Data()
d.add_coordinate('ixs')
d.add_coordinate('ylon')
d.add_coordinate('yerr')
d.create_file()
d.add_data_point(x,y,yerr)

p = qt.Plot2D()
p.add_data(d, coorddim=0, valdim=1, yerrdim=2)

# or: ('ok' is style for black circles)
qt.plot(x, y, 'ok', yerr=yerr, name='test2')
Ejemplo n.º 34
0
    def process_fit(self, p, cr, dimension, rate):

        # p is position array
        # cr is countrate array
        # d is a string corresponding to the dimension

        # Get the Gaussian width sigma guess from the dimensions dictionary
        sigma_guess = self.dimensions[dimension]['sigma']
        # Always do a Gaussian fit, for now
        self._gaussian_fit = True

        if self._gaussian_fit:
            # Come up with some robust estimates, for low signal/noise conditions
            a_guess = np.array(cr).min()*0.9
            A_guess = np.array(cr).max()-np.array(cr).min()
            p_size = np.size(p)
            x0_guess = p[np.round(p_size/2.0)]  #np.sum(np.array(cr) * np.array(p))/np.sum(np.array(cr)**2)
            #sigma_guess = 1.0#np.sqrt(np.sum(((np.array(cr)-x0_guess)**2)*(np.array(p))) / np.sum((np.array(p))))
            #print 'Guesses: %r %r %r %r' % (a_guess,  x0_guess,A_guess,sigma_guess)
            # The following statement is that if the old sigma is within a factor of 2 of the initial fixed value
            # then use the old sigma as the guess for the fit.
            if np.abs(self._opt_sigma_prev[dimension]/self.dimensions[dimension]['sigma']) < 2.0 and np.abs(self._opt_sigma_prev[dimension]/self.dimensions[dimension]['sigma']) > 0.3:
                sigma_guess = self._opt_sigma_prev[dimension]
            else:
                sigma_guess = self.dimensions[dimension]['sigma']

            ababfunc = (a_guess + A_guess*np.exp(-(p-x0_guess)**2/(2.0*sigma_guess**2)))*rate

            # New method for fitting
            # Purpose of this new method is to improve the robustness of both the numerical optimization and the 'mistracks'
            # that can occur because of nearby luminescence.
            # I think that the numerical robustness can be improved by using a
            # multiple start technique -- start the optimization at a series of
            # guesses across the frequency range, and note the 'best fit' value
            # of each. Pick the one with the best fit of each of these fits, and
            # return it, subject to the condition that the center of the peak is
            # within the min/max of the scan range. This way, it will be no
            # worse than the existing method and significantly more robust to
            # finding the global minimum.
            # The second modification is to reduce the probability of a fit to
            # a nearby peak that isn't the one we want, which I call a 'mistrack'.
            # This can be done by multiplying the likelihood by a prior, making
            # it a Bayesian method, that incorporates our knowledge that the
            # peak we want will not drift too far from scan to scan. Therefore,
            # given two peaks that fit equally well, the one nearest to the old
            # peak location should be selected preferentially. The exception to
            # this is if the other peak fits exceedingly well; these statements
            # are quantified by the exact prior probability distribution used.
            bf_ret = self.bayesian_fit(p, cr, np.array((A_guess, x0_guess, sigma_guess, a_guess)),self.dimensions[dimension]['drift_prior'])

            # check if fit result is in range, process it accordingly
            if not (bf_ret[1] > np.min(p)) and (bf_ret[1] < np.max(p)):
                # fit out of range, set location to max
                pamax = np.argmax(cr)
                self._opt_pos[dimension] = p[pamax]
                ret = False

                print '(%s) fit failed! Set to maximum.' % dimension


            else:
                self._opt_pos[dimension] = bf_ret[1]
                self._opt_sigma_prev[dimension] = bf_ret[2]
                ret = True

                final_fit_func = (bf_ret[3] + bf_ret[0]*np.exp(-(p-bf_ret[1])**2/(2.0*bf_ret[2]**2)))*rate
                qt.plot(p,cr*rate,p,ababfunc,p,final_fit_func,name='fbl_plot',needtempfile=False)
                #print '(%s) optimize succeeded!' % self.get_name()





        return ret
Ejemplo n.º 35
0
 def read_sweep_plot(self, samples, rate, channel):
     rsamples = self.read_sweep(samples, rate, channel)
     time_axis = np.linspace(0.0,float(np.size(rsamples))/rate,np.size(rsamples))
     qt.plot(time_axis,rsamples,name='fpplot1',traceofs=0.2, maxtraces=20)
     return
Ejemplo n.º 36
0
import numpy as np
import qt

x = np.arange(-10, 10, 0.2)
y = np.sinc(x)
yerr = 0.1 * np.random.rand(len(x))

d = qt.Data()
d.add_coordinate('x')
d.add_coordinate('y')
d.add_coordinate('yerr')
d.create_file()
d.add_data_point(x, y, yerr)

p = qt.Plot2D()
p.add_data(d, coorddim=0, valdim=1, yerrdim=2)

# or:
qt.plot(x, y, yerr=yerr, name='test2')
Ejemplo n.º 37
0
    def save_2D_data(self, timename='t (ns)', sweepname='sweep_value', ret=False):

        grp=h5.DataGroup('p7889_raw_data',self.h5data,base=self.h5base)
        self.save_params(grp=grp.group)

        x,yint,z = self._get_p7889_data()

        #### convert x to bins.... because this is what we see on the 
        y=self.params['sweep_pts']
        xx, yy = np.meshgrid(x,y)

        #dat=h5.HDF5Data(name=self.name)
        grp.add_coordinate(name='t (ns)',data=x, dtype='f8')
        grp.add_coordinate(name=self.params['sweep_name'],data=y)
        grp.add_value(name='Counts',data=z)

        # m2.save_instrument_settings_file(grp.group)

        #do post-processing
        grp1=h5.DataGroup('processed data',self.h5data,base=self.h5base)

        
        if self.params['Eval_ROI_start']<np.amin(x):
            startind=[0]
        else:
            startind=np.where(x==self.params['Eval_ROI_start'])


        if self.params['Eval_ROI_end']>np.amax(x):
            endind=[x.size-1]
        else:
            endind=np.where(x==self.params['Eval_ROI_end'])

        #strip the count array of points in time that lie outside of the specified ROIs
        # print x
        # print startind,endind
        sliced=z[:,startind[0]:endind[0]]
        # print sliced

        summation=np.array(range(self.params['pts']))

        for i,row in enumerate(sliced):
            summation[i]=np.sum(row)

        grp1.add_coordinate(name=self.params['sweep_name'],data=y)
        grp1.add_value(name='Counts in ROI',data=summation)

        plt=qt.plot(name=self.mprefix+self.name,clear=True)
        plt.add(y,summation,'rO',yerr=np.sqrt(summation))
        plt.add(y,summation,'r-')
        plt.set_plottitle(self.name)
        plt.set_legend(False)
        plt.set_xlabel(self.params['sweep_name'])
        plt.set_ylabel('counts')
        plt.save_png(self.datafolder+'\\'+self.name+'.png')

        self.h5data.flush()

        if ret:
            return x,y,z

        else:
            self.h5data.flush()
Ejemplo n.º 38
0
    def updated_measurement(self):
        """
        Incorporates live plotting for the p7889.
        """
        self.p7889.Start()
        qt.msleep(0.5)
        self.awg.start()
        counter = 0
        opt_ins = qt.instruments['optimiz0r'] # added for long measurements MJD

        GreenAOM = qt.instruments['GreenAOM']

        last_time = time.time()
        sample_time = 5.0

        while self.p7889.get_state(): 
            qt.msleep(0.1)
            counter += 1

            if counter % 1500 == 0: # idem added for long measurement 
                GreenAOM.set_power(self.params['GreenAOM_power'])
                opt_ins.optimize(dims=['x','y','z'], cycles=1)
                opt_ins.optimize(dims=['x','y','z'], cycles=1)
                GreenAOM.turn_off() 
            elif msvcrt.kbhit():
                kb_char=msvcrt.getch()
                if kb_char == "q": 
                    stop = True
                    break
            if (time.time() - last_time) > sample_time:
                last_time = time.time()

                x,z = self.p7889.get_P7889data()
                y=self.params['sweep_pts']

                if self.params['Eval_ROI_start']<np.amin(x):
                    startind=[0]
                else:
                    startind=np.where(x==self.params['Eval_ROI_start'])

                if self.params['Eval_ROI_end']>np.amax(x):
                    endind=[x.size-1]
                else:
                    endind=np.where(x==self.params['Eval_ROI_end'])

                #strip the count array of points in time that lie outside of the specified ROIs
                # print x
                # print startind,endind
                sliced=z[:,startind[0]:endind[0]]
                # print sliced

                summation=np.array(range(self.params['pts']))

                for i,row in enumerate(sliced):
                    summation[i]=np.sum(row)

                plt=qt.plot(name=self.mprefix+self.name,clear=True)
                plt.add(y,summation,'rO',yerr=np.sqrt(summation))
                plt.add(y,summation,'r-')
                plt.set_plottitle(self.name)
                plt.set_legend(False)
                plt.set_xlabel(self.params['sweep_name'])
                plt.set_ylabel('counts')



        self.stop_sequence()
Ejemplo n.º 39
0
 def take_spectrum(self, ret=False):
     spec = andor.get_spectrum()
     qt.plot(spec, name='andor_spectrum', clear=True)
     if ret:
         return spec