コード例 #1
0
def measurement(reading,channels,fpga,probe,g0,g1,g2,g3,generator,bw,LO,RF_power,fsteps):

    print("LO frequency must be "+str(LO)+"[GHz] (manual set)")
    print( "Current RF power is set to: "+ str(RF_power) + "dBm")
    generator.write("power "+repr(RF_power)+"dbm\r\n")
    generator.write("Output on\r\n")
    for channel_number in range(0,channels,fsteps):
        print("##########################################################")
        print("               Current channel = "+str(channel_number)+"               ")
        print("##########################################################")
        # A calculation to see what the current frequency should be (in MHz) and setting the signal generator to the middle of a spectral channel
        freq = bw/float(channels)*(channel_number)
        freq = max(0.01,freq + LO*1000)     # LO addition
        print( "Current frequency is set to: "+ str(freq) + "MHz")
        generator.write("freq "+repr(freq)+"mhz\r\n")
        time.sleep(0.2)

        # Read the data from the ROACH
        spectrum_z1_a, spectrum_z1_c, spectrum_z0_a, spectrum_z0_c = calibrate_inputs.get_data(fpga, channels)

        # Constructing the voltage vectors V. We are only interested in the channel where the tone is, the rest can be discarded.
        V = np.array([spectrum_z1_a[channel_number], spectrum_z1_c[channel_number], spectrum_z0_a[channel_number], spectrum_z0_c[channel_number]])

        # Computing the power of the spectra for plotting
        power_spectrum_z1_a, power_spectrum_z1_c, power_spectrum_z0_a, power_spectrum_z0_c = calibrate_functions.channel_power(spectrum_z1_a, spectrum_z1_c, spectrum_z0_a, spectrum_z0_c, channels)

        print("\nVoltage vector V = "+str(V)+"\n")

        # Check if the channel with the maximum power correspond to the input frequency
        V_power = 10*np.log10((1+abs(V)**2))
        print("Powers on channel: ")
        print(V_power)
        print("")

        # Constructing the matrix M = <VV*> where V is the vector composed of the channels
        M = calibrate_functions.compute_m(V)
        print("The cross-spectrum matrix M =")
        print M

        # Computing the magnitudes of M
        magnitude = calibrate_functions.compute_mag(M)
        print('\nMagnitude is equal to: '+str(magnitude)+'\n')

        # Computing the phase of M
        rel_phase = calibrate_functions.compute_relative_phase(M)
        print('Relative phase is equal to:\n')
        print rel_phase

        # According to the probe settings the maximum is either user-defined or chosen by the maximum correlation
        index = int(probe)

        # Normalising the matrix and changing to the definite phases
        if index == 0:
            phase[0] = rel_phase[index,0]
            phase[1] = rel_phase[index,1]
            phase[2] = rel_phase[index,2]
            phase[3] = rel_phase[index,3]
        elif index == 1:
            phase[0] = rel_phase[index,0]
            phase[1] = rel_phase[index,1]
            phase[2] = rel_phase[index,2]
            phase[3] = rel_phase[index,3]
        elif index == 2:
            phase[0] = rel_phase[index,0]
            phase[1] = rel_phase[index,1]
            phase[2] = rel_phase[index,2]
            phase[3] = rel_phase[index,3]
        elif index == 3:
            phase[0] = rel_phase[index,0]
            phase[1] = rel_phase[index,1]
            phase[2] = rel_phase[index,2]
            phase[3] = rel_phase[index,3]
        else:
            print('No valid index for the phase')

#        # Normalising the matrix and changing to the definite phases
#        if index == 0:
#            phase[0] = 0
#            phase[1] = -rel_phase[index,1]
#            phase[2] = -rel_phase[index,2]
#            phase[3] = -rel_phase[index,3]
#        elif index == 1:
#            phase[0] = -rel_phase[index,0]
#            phase[1] = 0
#            phase[2] = -rel_phase[index,2]
#            phase[3] = -rel_phase[index,3]
#        elif index == 2:
#            phase[0] = -rel_phase[index,0]
#            phase[1] = -rel_phase[index,1]
#            phase[2] = 0
#            phase[3] = -rel_phase[index,3]
#        elif index == 3:
#            phase[0] = -rel_phase[index,0]
#            phase[1] = -rel_phase[index,1]
#            phase[2] = -rel_phase[index,2]
#            phase[3] = 0
#        else:
#            print('No valid index for the phase')

        # Writing the phases and magnitudes of the channels into a larger array. This is used to plot the increase of the phase and magnitude over the measurement.
        for i in range(4):
            total_magnitude[i][reading][channel_number] = magnitude[i]
            total_phase[i][reading][channel_number] = phase[i]
        print('\nNormalisation has been done, the results are: \nMagnitude: '+str(magnitude)+'\nPhase:     '+str(phase)+'\n')

        # See if the data is consistent (a.k.a. sanity check)
        calibrate_functions.consistency_magnitude(M)
        consistent_phase = calibrate_functions.consistency_phase(M)

        # Plot the spectra
        calibrate_plot.plot_calibration(channels,channel_number, power_spectrum_z1_a, power_spectrum_z1_c, power_spectrum_z0_a, power_spectrum_z0_c,magnitude,phase,total_magnitude, total_phase,g0,g1,g2,g3)

        # Saving the coefficients:
        for i in range(0,4):
            G[i,reading,channel_number] = magnitude[i]*cos(phase[i])+1j*magnitude[i]*sin(phase[i])

    # Saving the relevant plots
    #g2.hardcopy('normalized_magnitude.ps', enhanced =1, color=1)
    #g3.hardcopy('normalized_phase.ps', enhanced =1, color=1)
    raw_input('press enter to continue')
    return G    
コード例 #2
0
def measurement(channels, fpga,g0, g1, g2, g3, generator, LO, RF_power, fsteps, gain_matrix_g, s0):

    print("LO frequency must be "+str(LO)+"[GHz] (manual set)")
    print( "Current RF power is set to: "+ str(RF_power) + "dBm")
    generator.write("power "+repr(RF_power)+"dbm\r\n")
    generator.write("Output on\r\n")
    bw = 600.0

    s0_2 = s0*s0

    for channel_number in range(0, channels, fsteps):
        print("##########################################################")
        print("               Current channel = "+str(channel_number))
        print("##########################################################")
        # A calculation to see what the current frequency should be (in MHz) and setting the signal generator to the middle of a spectral channel
        freq = (bw/channels)*(channel_number)
        freq = max(0.01, freq + LO*1000)     # LO addition
        print( "Current frequency is set to: "+ str(freq) + "MHz")
        generator.write("freq "+str(freq)+"mhz\r\n")
        #time.sleep(0.05)

        spectrum_z1_a, spectrum_z1_c, spectrum_z0_a, spectrum_z0_c = calibrate_inputs.get_data(fpga, channels)

        # Constructing the voltage vectors V. We are only interested in the channel where the tone is, the rest can be discarded.
        V = numpy.array([spectrum_z1_a[channel_number], spectrum_z1_c[channel_number], spectrum_z0_a[channel_number], spectrum_z0_c[channel_number]])

        gain_matrix_h = numpy.linalg.pinv( gain_matrix_g[:][:][channel_number])

        # obtain the estimated values of given the partialy
        # calibrated matrix
        s_prima = gain_matrix_h*V

        # convert from linear polarization to circular
        to_circular_matrix = numpy.matrix('1 -1j; 1 1j')
        s_circular = to_circular_matrix*s_prima

        # get the square module of each polarization component
        s_left_abs_2 = s_circular[0]*s_circular[0].conjugate()
        s_rigth_abs_2 = s_circular[1]*s_circular[1].conjugate()

        # get the value of eps given equation 22a of the paper
        # compact orthomode transducers using digital polarizatio synthesis
        sin_eps = (s_left_abs_2 + s_rigth_abs_2)/(2*s0_2) - 1.0
        eps = numpy.arcsin(sin_eps)

        # values that are needed for leater
        cos_eps = numpy.cos(eps)
        sin_2_eps = 2*sin_eps*cos_eps

        # calculate phi given equation 22b
        sin_phi = (s_left_abs_2 - s_rigth_abs_2)/(s0_2*(sin_2_eps + 2*cos_eps))
        s_cross_product = s_circular[0]*s_circular[1]
        cos_phi = 2*(numpy.imag(s_cross_product))/(s0_2*(sin_2_eps + 2*cos_eps))

        # the rotations matrix given equaton 24
        rotation_matrix_eps = numpy.matrix('1 %f;0 %f'.format(sin_eps,cos_eps))
        rotation_matrix_phi = numpy.matrix('1 0;0 {:.2f}'.format(cos_phi + 1j*sin_phi))

        gain_matrix_g[:][:][channel_number] = gain_matrix_g[:][:][channel_number] * rotation_matrix_phi * rotation_matrix_eps

    return gain_matrix_g