Пример #1
0
def hardburn():
    freq = 1.04 * GHz
    span = 20 * MHz
    title_str = '20MHz, 2500ms, 1.8GHz'
    HP8560E_SpecAn_Trigger('FREE', 'CONTS', SpecAn)
    spin_pump_seq()
    mc.setWvfm(2)
    burn_sequence_AWG_cust(burn=50 * ms,
                           burn_freq=freq,
                           record='True',
                           rec_span=span,
                           f_name=' ' + title_str,
                           sa='N')  # ' + str(i))

    filepath = hb.create_file(SpecAn,
                              compensated='Y',
                              n=1,
                              burn_time=0,
                              filename=' Spin pumped after ' + title_str)
    sleep(100 * ms)
    pb.Sequence(
        [
            (['ch5'], 0.5 * s),
            (['ch2', 'ch4', 'ch5'
              ], 50 * ms),  #RF Switch, Trigger SpecAn, EOM Bias on 
            (['ch2', 'ch5'], 100 * ms),
        ],
        loop=False)
    hb.record_trace(SpecAn,
                    filepath,
                    filename=' Spin pumped after ' + title_str,
                    compensated='Y',
                    sweep_again='N',
                    n=1,
                    burn_time='')
Пример #2
0
def spin_jump_dmneg1(freq, state='5,2', rec='True', span=20 * MHz):
    ''' Sets the 8GB AWG to a given frequency and burns a 100kHz hole, gives the option to 
        record the anti-hole created.
        Then burns on top of the anti-hole with a larger chirp 500 kHz - 2 MHz 
        '''
    #Splittings are [107.64, 110.42,105.17,92.34,73.02,47.94]
    #delta m = -1 energy gaps 7/2 -> -7/2: [0, -107.64, -218.06, -323.23, -415.57, -488.59, -536.53]+some offset
    state_dict = {
        '5,2': 0,
        '3,2': 1,
        '1,2': 2,
        '-1,2': 3,
        '-3,2': 4,
        '-5,2': 5,
        '-7,2': 6
    }
    if state not in state_dict:  #Check if variable state is valid
        print('Error, variable state must be in [5/2, 3/2... -7/2]')

    print "Initial burn on the Delta m = -1"
    target_state = state_dict[state]

    e_gap = np.array([
        -107.64, -218.06, -323.23, -415.57, -488.59, -536.53, 460.32
    ]) * MHz  #Gaps in hyperfine energy levels
    #From 7/2 - 5/2 -> -3/2 - -5/2
    str_name = [
        ' spin jumped 5,2 antihole', ' spin jumped 3,2 antihole',
        ' spin jumped 1,2 antihole', ' spin jumped -1,2 antihole',
        ' spin jumped -3,2 antihole', ' spin jumped -5,2 antihole',
        ' spin jumped -7,2 antihole'
    ]

    #Perform the first burn (which should have a narrower chiep and quicker burn time
    if target_state >= 0:
        mc.setWvfm(0, teeth - 1)
        burn_sequence_AWG(
            burn=200 * ms,
            burn_freq=freq,
            record=rec,
            rec_freq=freq - 107.64 * MHz,
            rec_span=span,
            f_name=' spin jumped 5,2 antihole via dm1')  # ' + str(i))

    #Perform the rest of the spin jump down to the desired level.
    #Cant look at the anti-hole in each level though
    j = target_state
    print target_state
    if target_state > 0:
        ##         mc.setWvfm(teeth,teeth*(j+1)-1)#No  Comb clean up.
        mc.setWvfm(teeth, teeth * (j + 2))  #For Comb clean up.
        burn_sequence_AWG(burn=500 * ms * (j),
                          burn_freq=freq + e_gap[j - 1],
                          record=rec,
                          rec_freq=freq + e_gap[j],
                          rec_span=span,
                          f_name=str_name[j] + ' via dm1')
Пример #3
0
def comb_background_abs(burn_f=1.1 * GHz, shots=1000, delay=0):
    ''' Idea: Spin pump crystal 
              Burn a narrow hole where the AFC will be (100 kHz)
              Send broad pulse through quickly after (>1ms after, MHz broad)
    What comes out should give a measurement of the background where the AFC will be
    before spin jumping.
    
    Turn WF on
    Set up PS for RAPID BLOCK mode'''

    mc.setWvfm(0)
    sleep(0.1)
    pb.Sequence([(['ch1', 'ch5'], 50 * ms), (['ch5'], 1 * ms)], loop=False)
    sleep(0.1)

    AWG_trig_out()
    ##     wf = wf_24_cw(burn_f + 19e6 + 460.99e6, -10)
    mc.setWvfm(1)
    sleep(0.1)

    arr = [(['ch5', 'ch6'], 10 * s), (['ch5'], 20 * ms)
           ]  #10s to spin pol. crystal, 20ms to let the mems switch switch.
    pb.Sequence(arr, loop=False)
    time.sleep(10.1)

    pb.ProbBurnLoop(shots=1000)
    time.sleep(shots * 7e-4)  #replace this is Wvfm time length

    mc.setWvfm(2)
    pb.ProbBurnLoop(shots=1000)
    time.sleep(shots * 5e-4)  #replace this is Wvfm time length
Пример #4
0
def spin_jump(freq,
              state='3,2',
              rec='True',
              span=20 * MHz,
              teeth=1,
              f_ext='',
              bjt=500,
              rec_offs=True):
    ''' Sets the 8GB AWG to a given frequency and burns a 100kHz hole, gives the option to 
        record the anti-hole created.
        Then burns on top of the anti-hole with a larger chirp 500 kHz - 2 MHz 
        rec_offs if you want a new background measurement
        '''
    #Splittings are [107.64, 110.42,105.17,92.34,73.02,47.94]
    #delta m = -1 energy gaps 7/2 -> -7/2: [0, -107.64, -218.06, -323.23, -415.57, -488.59, -536.53]+some offset
    state_dict = {
        '3,2': 0,
        '1,2': 1,
        '-1,2': 2,
        '-3,2': 3,
        '-5,2': 4,
        '-7,2': 5
    }

    if state not in state_dict:  #Check if variable state is valid
        print('Error, variable state must be in [3,2 ... -7,2]')

    print("Initial burn on the Delta m = -2")
    target_state = state_dict[state]

    #I am keeping the -107.64 to allow the ability to image the 5/2> easily
    #DELTA M=-2 |7/2> location is -903.02MHz
    e_gap = np.array([
        -107.60, -218.09, -323.2, -415.50, -488.20, -535.89, 460.99
    ]) * MHz  #Gaps in hyperfine energy levels
    ##     e_gap = np.array([0, -107.60, -218.09, -323.2, -415.50, -488.20, -535.89, 460.99])*MHz #GUse this if you want to look at one hyperfine higher
    ##     e_gap = np.array([1685.0, 1603.5, 1530.0, 1472.2, 1436.3, 1428.8, 1453.5])*MHz #Use this to look at dm = 1
    ##     e_gap = np.array([1557, 1557, 1557, 1557, 1557, 1557, 1557])*MHz #Set span to 270MHz and use this to image the entire DM = 1
    #From 7/2 - 5/2 -> -5/2 - -7/2 (have the image the -7/2> on the Delta m = 0
    str_name = [
        ' 3,2 antihole', ' 1,2 antihole', ' -1,2 antihole', ' -3,2 antihole',
        ' -5,2 antihole', ' -7,2 antihole'
    ]

    #Perform the first burn (which should have a narrower chirp and quicker burn time
    n = teeth
    if target_state >= 0:
        mc.setWvfm(0, teeth - 1)
        burn_sequence_AWG_cust(burn=100 * ms,
                               burn_freq=freq,
                               record='False',
                               rec_span=span,
                               f_name=' ' + f_ext + ' 7,2 hole',
                               sa='N')  # ' + str(i))

    #Perform the rest of the spin jump down to the desired level.
    #Cant look at the anti-hole in each level though
    j = target_state
    if target_state >= 0:
        #This part here is ugly and weird. Maybe ill fix it properly one day.
        if target_state == 0:
            mc.setWvfm(0,
                       teeth - 1)  #Jumps the comb from the |3/2> to the |-7/2>
        else:
            mc.setWvfm(0,
                       teeth * (j + 1) -
                       1)  #Jumps the comb from the |3/2> to the |-7/2>
##             mc.setWvfm(0,teeth*(j+2))  #For Comb clean up.
        burn_sequence_AWG_cust(burn=bjt * ms * (j + 1),
                               burn_freq=freq,
                               record=rec,
                               rec_freq=freq + e_gap[j + 1],
                               rec_span=span,
                               f_name=' ' + f_ext + str_name[j],
                               sa='N',
                               rec_offs=rec_offs)