def plot_parameters(gid, data):
    print("Plotting transformed wavepacket parameters of group '"+str(gid)+"'")

    # Grid of mother and first spawned packet
    grid_m = data[0][0]
    grid_s = data[1][0]

    # Parameters of mother and first spawned packet
    P, Q, S, p, q = data[0][1]
    B, A, S, b, a = data[1][1]

    X = P*abs(Q)/Q

    # Various interesting figures

    fig = figure()
    ax = fig.gca()

    ax.plot(grid_m, real(X), "*", label=r"$\Re \frac{P |Q|}{Q}$")
    ax.plot(grid_s, real(B), "o", label=r"$\Re B$")

    ax.legend()
    ax.grid(True)
    fig.savefig("test_spawned_PI_realparts_group"+str(gid)+GD.output_format)



    fig = figure()
    ax = fig.gca()

    ax.plot(grid_m, imag(X), "*", label=r"$\Im \frac{P |Q|}{Q}$")
    ax.plot(grid_s, imag(B), "o", label=r"$\Im B$")

    ax.legend()
    ax.grid(True)
    fig.savefig("test_spawned_PI_imagparts_group"+str(gid)+GD.output_format)



    fig = figure()
    ax = fig.gca()

    ax.plot(real(X), imag(X), "-*", label=r"traject $\frac{P |Q|}{Q}$")
    ax.plot(real(B), imag(B), "-*", label=r"traject $B$")

    ax.legend()
    ax.grid(True)
    fig.savefig("test_spawned_PI_complex_trajectories_group"+str(gid)+GD.output_format)



    fig = figure()
    ax = fig.gca()

    ax.plot(grid_m, angle(X), label=r"$\arg \frac{P |Q|}{Q}$")
    ax.plot(grid_s, angle(B), label=r"$\arg B$")

    ax.legend()
    ax.grid(True)
    fig.savefig("test_spawned_PI_angles_group"+str(gid)+GD.output_format)
Example #2
0
    def zplane(self, title="", fontsize=18):
        """ Display filter in the complex plane

        Parameters
        ----------

        """
        rb = self.z
        ra = self.p

        t = np.arange(0, 2 * np.pi + 0.1, 0.1)
        plt.plot(np.cos(t), np.sin(t), "k")

        plt.plot(np.real(ra), np.imag(ra), "x", color="r")
        plt.plot(np.real(rb), np.imag(rb), "o", color="b")
        M1 = -10000
        M2 = -10000
        if len(ra) > 0:
            M1 = np.max([np.abs(np.real(ra)), np.abs(np.imag(ra))])
        if len(rb) > 0:
            M2 = np.max([np.abs(np.real(rb)), np.abs(np.imag(rb))])
        M = 1.6 * max(1.2, M1, M2)
        plt.axis([-M, M, -0.7 * M, 0.7 * M])
        plt.title(title, fontsize=fontsize)
        plt.show()
Example #3
0
	def SaveData (self, fname, verbose = True):

		if (verbose):
			print ("  Saving measurement to %s ... " % fname)

		start = time.clock()

		f = h5py.File(fname, 'w')

		f['data_r'] = np.squeeze(np.real(self.data).transpose())
		f['data_i'] = np.squeeze(np.imag(self.data).transpose())

		if (self.noise != 0):
			f['noise_r'] = np.squeeze(np.real(self.noise).transpose())
			f['noise_i'] = np.squeeze(np.imag(self.noise).transpose())
		
		if (self.acs != 0):
			f['acs_r'] = np.squeeze(np.real(self.acs).transpose())
			f['acs_i'] = np.squeeze(np.imag(self.acs).transpose())
		
		if (self.sync.any() != 0):
                        f['sync']  = self.sync.transpose()

		f.close()

		if (verbose):
			print '    ... saved in %(time).1f s.\n' % {"time": time.clock()-start}

		return
Example #4
0
def real(a): # doubled ranks!

    b = tensor()
    
    b.n = a.n
    b.u[0] = np.concatenate((np.real(a.u[0]), np.imag(a.u[0])), 1)
    b.u[1] = np.concatenate((np.real(a.u[1]), np.imag(a.u[1])), 1)
    b.u[2] = np.concatenate((np.real(a.u[2]), np.imag(a.u[2])), 1)

    R1 = np.zeros((2*a.r[0], a.r[0]), dtype = np.complex128)
    R2 = np.zeros((2*a.r[1], a.r[1]), dtype = np.complex128)
    R3 = np.zeros((2*a.r[2], a.r[2]), dtype = np.complex128)

    R1[:a.r[0], :] = np.identity(a.r[0])
    R1[a.r[0]:, :] = 1j*np.identity(a.r[0])
    R2[:a.r[1], :] = np.identity(a.r[1])
    R2[a.r[1]:, :] = 1j*np.identity(a.r[1])
    R3[:a.r[2], :] = np.identity(a.r[2])
    R3[a.r[2]:, :] = 1j*np.identity(a.r[2])
    
    
    GG = np.tensordot(np.transpose(a.core,[2,1,0]),np.transpose(R1), (2,0))
    GG = np.tensordot(np.transpose(GG,[0,2,1]),np.transpose(R2), (2,0))
    GG = np.transpose(GG,[1,2,0])
    b.core = np.real(np.tensordot(GG,np.transpose(R3), (2,0)))

    b.r = b.core.shape
    
    return b
Example #5
0
    def process(self, X, V, C):
        BifPoint.process(self, X, V, C)

        J_coords = C.sysfunc.jac(X, C.coords)

        eigs, VL, VR = linalg.eig(J_coords, left=1, right=1)

        # Check for nonreal multipliers
        found = False
        for i in range(len(eigs)):
            for j in range(i+1,len(eigs)):
                if abs(imag(eigs[i])) > 1e-10 and \
                   abs(imag(eigs[j])) > 1e-10 and \
                   abs(eigs[i]*eigs[j] - 1) < 1e-5:
                    found = True

        if not found:
            del self.found[-1]
            return False

        self.found[-1].eigs = eigs

        self.info(C, -1)

        return True
Example #6
0
def childGeneration(N, particles, tree, i):
    maxInCell = 3
    p, t = noOfParticlesInside(particles, N[i])
    N[i].particleIndex = t
    if p > maxInCell:
        t = len(N)
        tree[i] = [t, t + 1, t + 2, t + 3]
        c = N[i].center
        v = N[i].vertex
        N.append(Node((c - (v - c) / 2), c, t))
        N.append(Node((c + (v - c) / 2), v, t + 1))
        N.append(Node(c + (conj(v - c) / 2), real(v) + 1j * imag(c), t + 2))
        N.append(Node(c - (conj(v - c) / 2), real(c) + 1j * imag(v), t + 3))
        tree.append([])
        tree.append([])
        tree.append([])
        tree.append([])
        for ch in tree[i]:
            childGeneration(N, particles, tree, ch)

        N[i].aj = zeros(noOfTerms) * 1j
        for j in range(1, noOfTerms + 1):
            for k in range(1, j + 1):
                for chi in tree[i]:
                    N[i].aj[j - 1] += (
                        N[chi].aj[k - 1] * combitorial(j - 1, k - 1) * pow((-N[i].center + N[chi].center), j - k)
                    )

    else:
        N[i].aj = zeros(noOfTerms) * 1j
        for j in range(1, noOfTerms + 1):
            for tempIdx in t:
                N[i].aj[j - 1] += particles[tempIdx].strength * pow((particles[tempIdx].xy - N[i].center), (j - 1))
Example #7
0
def fourier(self):
    """
    Generate a profile of fourier coefficients, amplitudes and phases
    """
    if pynbody.config['verbose'] : print 'Profile: fourier()'

    f = {'c': np.zeros((7, self.nbins),dtype=complex),
         'amp': np.zeros((7, self.nbins)),
         'phi': np.zeros((7, self.nbins))}

    for i in range(self.nbins):
        if self._profiles['n'][i] > 100:
            phi = np.arctan2(self.sim['y'][self.binind[i]], self.sim['x'][self.binind[i]])
            mass = self.sim['mass'][self.binind[i]]
            
            hist, binphi = np.histogram(phi,weights=mass,bins=100)
            binphi = .5*(binphi[1:]+binphi[:-1])
            for m in range(7) : 
                f['c'][m,i] = np.sum(hist*np.exp(-1j*m*binphi))


    f['c'][:,self['mass']>0] /= self['mass'][self['mass']>0]
    f['amp'] = np.sqrt(np.imag(f['c'])**2 + np.real(f['c'])**2)
    f['phi'] = np.arctan2(np.imag(f['c']), np.real(f['c']))

    return f
Example #8
0
 def writeToAscii(self, directory):
     """
     This function writes the values of the normalization integral to a text file.
     Make sure to run execute method first.
     """
     outfile = open(os.path.join(directory, "normint.txt"), "w")
     outfile.write(str(len(self.waves)) + "\n")
     outfile.write(str(len(self.alphaList)) + "\n")
     for eps1 in range(2):
         for eps2 in range(2):
             outfile.write(
                 str(len(self.waves)) + " " + str(len(self.waves)) + " " + str(eps1) + " " + str(eps2) + "\n"
             )
             for index1 in range(len(self.waves)):
                 for index2 in range(len(self.waves) - 1):
                     tempcomplex = self.ret[eps1, eps2, index1, index2]
                     tempreal = numpy.real(tempcomplex)
                     tempim = numpy.imag(tempcomplex)
                     outfile.write(" (" + str(tempreal) + " + i " + str(tempim) + ") , ")
                 tempcomplex = self.ret[eps1, eps2, index1, int(len(self.waves) - 1)]
                 tempreal = numpy.real(tempcomplex)
                 tempim = numpy.imag(tempcomplex)
                 outfile.write(" (" + str(tempreal) + " + i " + str(tempim) + ")")
                 outfile.write("\n")
             outfile.write("\n")
             outfile.write(str(len(self.waves)) + "\n")
             for wave in self.waves:
                 outfile.write(wave.filename + " " + str(self.waves.index(wave)) + "\n")
     outfile.close()
Example #9
0
    def start(self, f, a, b, args=()):
        r"""Prepare for the iterations."""
        self.function_calls = 0
        self.iterations = 0

        self.f = f
        self.args = args
        self.ab[:] = [a, b]
        if not np.isfinite(a) or np.imag(a) != 0:
            raise ValueError("Invalid x value: %s " % (a))
        if not np.isfinite(b) or np.imag(b) != 0:
            raise ValueError("Invalid x value: %s " % (b))

        fa = self._callf(a)
        if not np.isfinite(fa) or np.imag(fa) != 0:
            raise ValueError("Invalid function value: f(%f) -> %s " % (a, fa))
        if fa == 0:
            return _ECONVERGED, a
        fb = self._callf(b)
        if not np.isfinite(fb) or np.imag(fb) != 0:
            raise ValueError("Invalid function value: f(%f) -> %s " % (b, fb))
        if fb == 0:
            return _ECONVERGED, b

        if np.sign(fb) * np.sign(fa) > 0:
            raise ValueError("a, b must bracket a root f(%e)=%e, f(%e)=%e " %
                             (a, fa, b, fb))
        self.fab[:] = [fa, fb]

        return _EINPROGRESS, sum(self.ab) / 2.0
Example #10
0
    def mix_parameters(self, Pibra, Piket):
        r"""Mix the two parameter sets :math:`\Pi_i` and :math:`\Pi_j`
        from the 'bra' and the 'ket' wavepackets :math:`\Phi\left[\Pi_i\right]`
        and :math:`\Phi^\prime\left[\Pi_j\right]`.

        :param Pibra: The parameter set :math:`\Pi_i` from the bra part wavepacket.
        :param Piket: The parameter set :math:`\Pi_j` from the ket part wavepacket.
        :return: The mixed parameters :math:`q_0` and :math:`Q_S`. (See the theory for details.)
        """
        # <Pibra | ... | Piket>
        qr, pr, Qr, Pr = Pibra
        qc, pc, Qc, Pc = Piket

        # Mix the parameters
        Gr = dot(Pr, inv(Qr))
        Gc = dot(Pc, inv(Qc))

        r = imag(Gc - conjugate(Gr.T))
        s = imag(dot(Gc, qc) - dot(conjugate(Gr.T), qr))

        q0 = dot(inv(r), s)
        Q0 = 0.5 * r

        # Here we can not avoid the matrix root by using svd
        Qs = inv(sqrtm(Q0))

        return (q0, Qs)
Example #11
0
def writeToDatFile(data, file, field="E", punits="mm", funits="V/m", pscale=1.0, fscale=1.0):
    """
    Write to field map to DAT data file.
    """

    nx = data.nx
    ny = data.ny
    nz = data.nz

    file.write("       x [{0}]         y [{0}]         z [{0}]     {1}xRe [{2}]     {1}yRe [{2}]     {1}zRe [{2}]     {1}xIm [{2}]     {1}yIm [{2}]     {1}zIm [{2}]  \r\n".format(punits, field, funits))
    file.write("------------------------------------------------------------------------------------------------------------------------------------------\r\n")

    for x in xrange(nx):
        px = pscale * data.px[x]
        for y in xrange(ny):
            py = pscale * data.py[y]
            for z in xrange(nz):
                pz = pscale * data.pz[z]
                fxre = fscale * numpy.real(data.fx[x,y,z])
                fyre = fscale * numpy.real(data.fy[x,y,z])
                fzre = fscale * numpy.real(data.fz[x,y,z])
                fxim = fscale * numpy.imag(data.fx[x,y,z])
                fyim = fscale * numpy.imag(data.fy[x,y,z])
                fzim = fscale * numpy.imag(data.fz[x,y,z])
                file.write("%13.1f  %13.1f  %13.1f  %13.6g  %13.6g  %13.6g  %13.6g  %13.6g  %13.6g\r\n" % (px, py, pz, fxre, fyre, fzre, fxim, fyim, fzim))
def getArgumentVariable(_ComplexVariable):

	#Debug
	'''
	print('l 31 Numscipier')
	print('_ComplexVariable is ')
	print(_ComplexVariable)
	print('')
	'''

	#import
	import numpy as np

	#return
	return 2.*np.arctan(
	np.imag(_ComplexVariable)/(
	        np.sqrt(
	            np.imag(
	                _ComplexVariable
	            )**2+np.real(
	                _ComplexVariable
	            )**2)+np.real(
	                _ComplexVariable
	            )
	    )
	);
Example #13
0
def instantaneous_frequency(data, fs, fk):
    """
    Instantaneous frequency of a signal.

    Computes the instantaneous frequency of the given data which can be
    windowed or not. The instantaneous frequency is determined by the time
    derivative of the analytic signal of the input data.

    :type data: :class:`~numpy.ndarray`
    :param data: Data to determine instantaneous frequency of.
    :param fs: Sampling frequency.
    :param fk: Coefficients for calculating time derivatives
        (calculated via central difference).
    :return: **omega[, domega]** - Instantaneous frequency of input data, Time
        derivative of instantaneous frequency (windowed only).
    """
    x = envelope(data)
    if len(x[0].shape) > 1:
        omega = np.zeros(x[0].shape[0], dtype=np.float64)
        i = 0
        for row in x[0]:
            f = np.real(row)
            h = np.imag(row)
            # faster alternative to calculate f_add
            f_add = np.hstack(([f[0]] * (np.size(fk) // 2), f, [f[np.size(f) - 1]] * (np.size(fk) // 2)))
            fd = signal.lfilter(fk, 1, f_add)
            # correct start and end values of time derivative
            fd = fd[np.size(fk) - 1 : np.size(fd)]
            # faster alternative to calculate h_add
            h_add = np.hstack(([h[0]] * (np.size(fk) // 2), h, [h[np.size(h) - 1]] * (np.size(fk) // 2)))
            hd = signal.lfilter(fk, 1, h_add)
            # correct start and end values of time derivative
            hd = hd[np.size(fk) - 1 : np.size(hd)]
            omega_win = abs(((f * hd - fd * h) / (f * f + h * h)) * fs / 2 / np.pi)
            omega[i] = np.median(omega_win)
            i = i + 1
        # faster alternative to calculate omega_add
        omega_add = np.hstack(
            ([omega[0]] * (np.size(fk) // 2), omega, [omega[np.size(omega) - 1]] * (np.size(fk) // 2))
        )
        domega = signal.lfilter(fk, 1, omega_add)
        # correct start and end values of time derivative
        domega = domega[np.size(fk) - 1 : np.size(domega)]
        return omega, domega
    else:
        omega = np.zeros(np.size(x[0]), dtype=np.float64)
        f = np.real(x[0])
        h = np.imag(x[0])
        # faster alternative to calculate f_add
        f_add = np.hstack(([f[0]] * (np.size(fk) // 2), f, [f[np.size(f) - 1]] * (np.size(fk) // 2)))
        fd = signal.lfilter(fk, 1, f_add)
        # correct start and end values of time derivative
        fd = fd[np.size(fk) - 1 : np.size(fd)]
        # faster alternative to calculate h_add
        h_add = np.hstack(([h[0]] * (np.size(fk) // 2), h, [h[np.size(h) - 1]] * (np.size(fk) // 2)))
        hd = signal.lfilter(fk, 1, h_add)
        # correct start and end values of time derivative
        hd = hd[np.size(fk) - 1 : np.size(hd)]
        omega = abs(((f * hd - fd * h) / (f * f + h * h)) * fs / 2 / np.pi)
        return omega
Example #14
0
def test_mexh():
    LB = -5
    UB = 5
    N = 1000

    [psi, x] = ref_mexh(LB, UB, N)
    w = pywt.ContinuousWavelet("mexh")
    w.upper_bound = UB
    w.lower_bound = LB
    PSI, X = w.wavefun(length=N)

    assert_allclose(np.real(PSI), np.real(psi))
    assert_allclose(np.imag(PSI), np.imag(psi))
    assert_allclose(X, x)

    LB = -5
    UB = 5
    N = 1001

    [psi, x] = ref_mexh(LB, UB, N)
    w = pywt.ContinuousWavelet("mexh")
    w.upper_bound = UB
    w.lower_bound = LB
    PSI, X = w.wavefun(length=N)

    assert_allclose(np.real(PSI), np.real(psi))
    assert_allclose(np.imag(PSI), np.imag(psi))
    assert_allclose(X, x)
def dynamic_axis(zero,pole,K):
    if list(zero)+list(pole)==[]:
        x_min,x_max,y_min,y_max = -1,1,-1,1
    else:
        x_min = min(list(np.real(zero))+list(np.real(pole)))
        x_max = max(list(np.real(zero))+list(np.real(pole)))
        if x_min == x_max:
            x_min -= 1
            x_max += 1
        else:
            x_min,x_max = (x_min- 0.75*(x_max-x_min)),(x_max + 0.75*(x_max-x_min))
        y_min = min(list(np.imag(zero))+list(np.imag(pole)))
        y_max = max(list(np.imag(zero))+list(np.imag(pole)))
        if y_min == y_max:
            y_min -= 1
            y_max += 1
        else:
            y_min,y_max = (y_min- 0.75*(y_max-y_min)),(y_max + 0.75*(y_max-y_min))
    if K == 0:
        z_min,z_max = -1,1
    else:
        K = abs(K)
        print K
        z_min,z_max = K*0.1,K*10.0
    return x_min,x_max,y_min,y_max,z_min,z_max
	def state_toString(self,state,params={}):
		states = [
				'l0',
				'l1',
				'Q',
				'ml0',
				'ml1',
				'q',
				'u',
				'd'
				]

		s = ""
		for i,v in enumerate(state):
			if v != 0:

				if i < 8:
					repr = states[i]
				else:
					repr = self.__state_str(i)

				if s != "" and v >= 0:
					s +="+"
				if v == 1:
					s += "|%s>" % repr
				else:
					if np.imag(v) != 0:
						s += "(%.3f + %.3fi)|%s>" % (np.real(v),np.imag(v),repr)
					else:
						s += "%.3f|%s>" % (v,repr)
		return s
Example #17
0
 def GaussLk( self, newLkFile, sigma ) :
   fout = open( newLkFile, "w" )
   fout.write("# input data : %s\n" % "+ Gaussian error"  )
   percentU = percentQ = 0.
   for lineStr,f1,f2 in zip (self.LeakList[0].lineStr, self.LeakList[0].f1, self.LeakList[0].f2) :
     print lineStr
     fout.write("#\n")
     for ant in range(1,16) :
       DRlist = []
       DLlist = []
       for Lk in self.LeakList :
         if Lk.ant == ant :
           for lineStr1,DR1,DL1 in zip( Lk.lineStr, Lk.DR, Lk.DL ) :
             if (lineStr1 == lineStr) and (abs(DR1) > 0.) and (abs(DL1) > 0.) :
               DRlist.append( DR1 )
               DLlist.append( DL1 )
               print "... ant %d - appending data from %s" % ( ant, Lk.legend )
       if len(DRlist) > 0 :
         DRmean = numpy.mean(DRlist)
         DLmean = numpy.mean(DLlist)
         DRnew = random.gauss(numpy.real(DRmean), sigma) + random.gauss(numpy.imag(DRmean), sigma) * 1j
         DLnew = random.gauss(numpy.real(DLmean), sigma) + random.gauss(numpy.imag(DLmean), sigma) * 1j
       else :
         DRnew = 0. + 0j
         DLnew = 0. + 0j
       print ant, DRnew, DLnew
       fout.write("C%02d %8.3f %8.3f %8.3f %6.3f %8.3f %6.3f %8.3f %6.3f    %s\n" % \
           ( ant, f1, f2, DRnew.real, DRnew.imag, DLnew.real, \
           DLnew.imag, percentQ, percentU, lineStr) )
   fout.close()
Example #18
0
def tvtkGridFunction(g):
    """Return a TVTK object visualizing the specified grid function."""
    tvtkObj = tvtkGrid(g.grid())
    point_data = g.evaluateAtSpecialPoints("vertex_data")
    cell_data = g.evaluateAtSpecialPoints("cell_data")

    tvtkObj.cell_data.add_array(np.real(cell_data.T))
    tvtkObj.cell_data.add_array(np.imag(cell_data.T))
    tvtkObj.cell_data.add_array(np.sum(abs(cell_data)**2,axis=0))
    tvtkObj.cell_data.get_abstract_array(0).name = 'real'
    tvtkObj.cell_data.get_abstract_array(1).name = 'imag'
    tvtkObj.cell_data.get_abstract_array(2).name = 'abs^2'

    tvtkObj.point_data.add_array(np.real(point_data.T))
    tvtkObj.point_data.add_array(np.imag(point_data.T))
    tvtkObj.point_data.add_array(np.sum(abs(point_data)**2,axis=0))
    tvtkObj.point_data.get_abstract_array(0).name = 'real'
    tvtkObj.point_data.get_abstract_array(1).name = 'imag'
    tvtkObj.point_data.get_abstract_array(2).name = 'abs^2'

    if g.componentCount()==3:
        tvtkObj.cell_data.set_active_scalars('abs^2')
        tvtkObj.point_data.set_active_scalars('abs^2')
        tvtkObj.cell_data.set_active_vectors('real')
        tvtkObj.point_data.set_active_vectors('real')
    elif g.componentCount()==1:
        tvtkObj.cell_data.set_active_scalars('real')
        tvtkObj.point_data.set_active_scalars('real')
    else:
        raise Exception("plotGridFunction: Only GridFunctions with "
                        "componentCount 1 or 3 are supported.")

    return tvtkObj
Example #19
0
    def analytic(self):
        """The natural output for this analyzer is the analytic signal"""
        data = self.input.data
        sampling_rate = self.input.sampling_rate

        a_signal =\
    ts.TimeSeries(data=np.zeros(self.freqs.shape + data.shape,
                                dtype='D'), sampling_rate=sampling_rate)
        if self.freqs.ndim == 0:
            w = self.wavelet(self.freqs, self.sd,
                             sampling_rate=sampling_rate, ns=5,
                             normed='area')

            # nd = (w.shape[0] - 1) / 2
            a_signal.data[...] = (np.convolve(data, np.real(w), mode='same') +
                            1j * np.convolve(data, np.imag(w), mode='same'))
        else:
            for i, (f, sd) in enumerate(zip(self.freqs, self.sd)):
                w = self.wavelet(f, sd, sampling_rate=sampling_rate,
                                 ns=5, normed='area')

                # nd = (w.shape[0] - 1) / 2
                a_signal.data[i, ...] = (
                    np.convolve(data, np.real(w), mode='same') +
                    1j * np.convolve(data, np.imag(w), mode='same'))

        return a_signal
Example #20
0
    def test_Transect(self):

        for src in self.prb.survey.srcList:
            print(' --- testing {} --- '.format(src.__class__.__name__))
            bfz = self.mesh.r(self.u[src, 'b'],'F','Fz','M')
            x = np.linspace(-55,55,12)
            XYZ = Utils.ndgrid(x,np.r_[0],np.r_[0])

            P = self.mesh.getInterpolationMat(XYZ, 'Fz')

            ana = mu_0*np.imag(EM.Analytics.FDEM.hzAnalyticDipoleF(x, src.freq, self.sig))
            num = P*np.imag(self.u[src, 'b'])

            diff = np.linalg.norm(num - ana)

            if plotIt:
                import matplotlib.pyplot as plt
                plt.plot(x, np.log10(np.abs(num)))
                plt.plot(x, np.log10(np.abs(ana)), 'r')
                plt.plot(x, diff, 'g')
                plt.show()

            norm_num = np.linalg.norm(num)
            norm_ana = np.linalg.norm(ana)
            tol = tol_Transect*(norm_num + norm_ana)/2.

            passed = diff < tol
            print ('analytic: {}, numeric {}, difference {} < tolerance {} ? '
                   ' {}'.format(norm_ana, norm_num, diff,
                                tol, passed))

            self.assertTrue(passed)
Example #21
0
def test_pupilfn_3():
    """
    Test PF X derivative (C library).
    """
    dx = 1.0e-6
    geo = pupilMath.Geometry(20, 0.1, 0.6, 1.5, 1.4)
    pf = geo.createFromZernike(1.0, [[1.3, 2, 2]])

    pf_c = pfFnC.PupilFunction(geometry = geo)
    pf_c.setPF(pf)
    
    # Calculate derivative of magnitude as a function of x.
    psf_c = pf_c.getPSF()
    psf_c_dx = pf_c.getPSFdx()
    mag_dx_calc = 2.0 * (numpy.real(psf_c)*numpy.real(psf_c_dx) + numpy.imag(psf_c)*numpy.imag(psf_c_dx))

    # Estimate derivative using (f(x+dx) - f(x))/dx
    mag = pupilMath.intensity(psf_c)
    pf_c.translate(dx,0.0,0.0)
    mag_dx_est = (pupilMath.intensity(pf_c.getPSF()) - mag)/dx
                
    if False:
        with tifffile.TiffWriter(storm_analysis.getPathOutputTest("test_pupilfn_3.tif")) as tf:
            #tf.save(mag.astype(numpy.float32))
            tf.save(mag_dx_calc.astype(numpy.float32))
            tf.save(mag_dx_est.astype(numpy.float32))
            tf.save(numpy.abs(mag_dx_calc - mag_dx_est).astype(numpy.float32))

    assert numpy.allclose(mag_dx_calc, mag_dx_est, atol = 1.0e-6)
    
    pf_c.cleanup()
Example #22
0
def normalmode_frequencies(hessian, metric=None, eps=1e-4):
    """calculate (squared) normal mode frequencies

    Parameters
    ----------
    hessian: 2d array
        hessian matrix
    metric: 2d array
        mass weighted metric tensor

    Returns
    -------
    sorted array of normal mode frequencies

    """
    A = hessian
    if metric is not None:
        A = np.dot(np.linalg.pinv(metric), hessian)

    frq = np.linalg.eigvals(A)

    if np.max(np.abs(np.imag(frq))) > eps:
        print(frq)
        raise ValueError("imaginary eigenvalue in frequency calculation"
                         ", check hessian + metric tensor\n"
                         "the largest imaginary part is %g" %
                         np.max(np.abs(np.imag(frq))))

    return np.sort(np.real(frq))
def mode_finder(xxx_todo_changeme):
    (det_mat_slice, wl_list, kx) = xxx_todo_changeme
    dispcurve = []
    xtol = 1e-4*wl_0
    for j in range(len(wl_list)-1):
        # Check determinant crosses zero, noth real and imaginary
        if np.real(det_mat_slice[j])*np.real(det_mat_slice[j+1]) < 0:
            if np.imag(det_mat_slice[j])*np.imag(det_mat_slice[j+1]) < 0:
                if j != 0:
                    diffreq = np.abs(det_mat_slice[j-1]-det_mat_slice[j])
                else:
                    diffreq = np.abs(det_mat_slice[j+2]-det_mat_slice[j+1])
                # Check we are not just at a discontinuity
                if np.abs(det_mat_slice[j+1]-det_mat_slice[j]) < 3*diffreq:
                    try:
                        # Optimise the wl
                        finwl = optimize.brentq(lambda wl: np.real(np.exp(1j)*simulate_stack([wl, kx])),wl_list[j],wl_list[j+1],rtol=1e-3,xtol=xtol)
                        findet=simulate_stack([finwl, kx])
                        print('#################################')
                        print('found root = ', findet)
                        print('#################################')
                        #check the final determinant is below some tolerance
                        if np.abs(findet)< 1.e-3:
                            finfreq=2*np.pi*c_speed*1e9/finwl
                            dispcurve.append((kx*1e9,finfreq))
                    except AttributeError:
                        print(det_mat_slice[j], det_mat_slice[j+1])
    return dispcurve
Example #24
0
def extract_outfield_from_dict( outpdict ):
    """ 
    extract only the output field (time, freq)
    and the freq vectors from a dict created
    by mydict  = loadoutput(filename)
   
    returns a Nx7 numpy.array
    """    

    tvec  = outpdict['tvec']
    omvec = outpdict['omvec']
    relomvec = outpdict['relomvec']
    tfieldreal = np.real(outpdict['tfield2'])
    tfieldimag = np.imag(outpdict['tfield2'])
    ffieldreal = np.real(outpdict['ffield2'])
    ffieldimag = np.imag(outpdict['ffield2'])
    M = np.zeros( [len( tvec), 7])
    M[:,0]=tvec
    M[:,1]=omvec
    M[:,2]=relomvec
    M[:,3]=tfieldreal
    M[:,4]=tfieldimag
    M[:,5]=ffieldreal
    M[:,6]=ffieldimag
    return M
Example #25
0
 def resData2(self,xval,yval,yval_sim=None,xlabel='Frequency',xunit='Hz',plottype='amp',
             ampformat='log',save=False,Dir=None):
     
     self.figure.clear()
     self.figure.subplots_adjust(bottom=0.15,left=0.17)
     self.axes = self.figure.add_subplot(111)
             
     if plottype=='real/imag':
         self.axes.plot(np.real(yval),np.imag(yval),np.real(yval_sim),np.imag(yval_sim))
         self.axes.set_xlabel("Re(S)")
         self.axes.set_ylabel("Im(S)")
     else:
         self.axes.set_xlabel(xlabel+' ['+xunit+']')
             
     if plottype=='amp':
         if ampformat=="log":
             self.axes.plot(xval,10*np.log(np.absolute(yval)),xval,10*np.log(np.absolute(yval_sim)))
             self.axes.set_ylabel("Amplitude [dB]")
         if ampformat=='lin':
             self.axes.plot(xval,np.absolute(yval),xval,np.absolute(yval_sim))
             self.axes.set_ylabel("Amplitude")      
         
     if plottype=='phase':
         if yval_sim==None: #this option is needed for lorentz function since we only fit the amplitude
             self.axes.plot(xval,np.angle(yval))
         else:                
             self.axes.plot(xval,np.angle(yval),xval,np.angle(yval_sim))
         self.axes.set_ylabel('Phase [rad]') 
         
     if save:
         print_fig = self.figure
         print_fig.savefig(Dir)
     else:
         self.draw()
Example #26
0
def rot_ell(m_rt_ps):
    '''Utility to compute rotation and ellipticity
       starting from reflection and transmission matrix

    Parameters
    ----------
    'm_RTsp' = sp reflection and transmission matrix

    Returns
    -------
    'a dictionary' = {'theta_p':theta_p,
                      'eps_p':eps_p,
                      'theta_s':theta_s,
                      'eps_s':eps_s}
    '''

    # extracting values from the matrix
    rt_pp = m_rt_ps[0,0]
    rt_ps = m_rt_ps[0,1]
    rt_sp = m_rt_ps[1,0]
    rt_ss = m_rt_ps[1,1]

    # calculating the values
    theta_p = np.real(rt_sp/rt_pp)
    eps_p = np.imag(rt_sp/rt_pp)
    theta_s = np.real(rt_ps/rt_ss)
    eps_s = np.imag(rt_ps/rt_ss)

    out_dict = {'theta_p':theta_p,
                'eps_p':eps_p,
                'theta_s':theta_s,
                'eps_s':eps_s}

    return out_dict
Example #27
0
def fidelity(statevec, dm, u_dm, ustatevec=np.array([0,0])):
    '''
    returns the fidelity (and its uncertainty) of the measured density
    matrix with a given state vector.
    '''
   
    f = error.Formula()
    beta,a,x,b,alpha = sympy.symbols('beta,a,x,b,alpha')
    v = Matrix([alpha, beta])
    rho = Matrix([[x,a+1j*b],[a-1j*b, 1-x]])    
    f.formula = (v.conjugate().transpose() * rho * v)[0]
    
    f.values[alpha] = statevec[0]
    f.values[beta] = statevec[1]
    f.values[a]=float(np.real(dm[0,1]))
    f.values[x]=float(dm[0,0])
    f.values[b]=float(np.imag(dm[0,1]))

    f.uncertainties[alpha]=ustatevec[0]
    f.uncertainties[beta]=ustatevec[1]
    f.uncertainties[x]=u_dm[0,0]
    f.uncertainties[a]=float(np.real(u_dm[0,1]))
    f.uncertainties[b]=float(np.imag(u_dm[0,1]))
    
    _fid,_ufid = f.num_eval()
    fid = float(_fid.as_real_imag()[0])
    ufid = float(_ufid.as_real_imag()[0])
   
    return (fid,ufid)
def write_readable(sigma, g_w, n_k, n_w, wgrid):

    print "Writing E_file for checking"

    print n_k, n_w
    print sigma[n_w-1][n_k-1][n_k-1]


    greal_file=open("PARSED_Greal_1", "w+")
    gimag_file=open("PARSED_Gimag_1", "w+")
    sigma_file=open("PARSED_SIGMA_1", "w+")
    for w in range (n_w/2, n_w):
      print w
      print np.real(g_w[w][0][0])
      write_string=str(wgrid[w])+" "
      write_string2=str(wgrid[w])+" "
      write_string_sigma=str(wgrid[w])+" "
      for kx in range (n_k):
        for ky in range (n_k):
          write_string+=" "+str(np.real(g_w[w][kx][ky])[0])
          write_string2+=" "+" "+str(np.imag(g_w[w][kx][ky])[0])
          write_string_sigma+=" "+str(np.real(sigma[w][kx][ky])[0])+" "+str(np.imag(sigma[w][kx][ky])[0])
     # print write_string
      greal_file.write(write_string+"\n")
      gimag_file.write(write_string+"\n")
      sigma_file.write(write_string_sigma+"\n")
Example #29
0
    def check_sum_rule(self, df1_w=None, df2_w=None):
        """Check f-sum rule."""

	if df1_w is None:
            df1_w = self.df1_w
            df2_w = self.df2_w

        N1 = N2 = 0
        for iw in range(self.Nw):
            w = iw * self.dw
            N1 += np.imag(df1_w[iw]) * w
            N2 += np.imag(df2_w[iw]) * w
        N1 *= self.dw * self.vol / (2 * pi**2)
        N2 *= self.dw * self.vol / (2 * pi**2)

        self.printtxt('')
        self.printtxt('Sum rule for ABS:')
        nv = self.nvalence
        self.printtxt('Without local field: N1 = %f, %f  %% error' %(N1, (N1 - nv) / nv * 100) )
        self.printtxt('Include local field: N2 = %f, %f  %% error' %(N2, (N2 - nv) / nv * 100) )

        N1 = N2 = 0
        for iw in range(self.Nw):
            w = iw * self.dw
            N1 -= np.imag(1/df1_w[iw]) * w
            N2 -= np.imag(1/df2_w[iw]) * w
        N1 *= self.dw * self.vol / (2 * pi**2)
        N2 *= self.dw * self.vol / (2 * pi**2)
                
        self.printtxt('')
        self.printtxt('Sum rule for EELS:')
        nv = self.nvalence
        self.printtxt('Without local field: N1 = %f, %f  %% error' %(N1, (N1 - nv) / nv * 100) )
        self.printtxt('Include local field: N2 = %f, %f  %% error' %(N2, (N2 - nv) / nv * 100) )
Example #30
0
File: ar.py Project: idiap/ssp
def ARLineSpectra(ar):
    """
    Convert AR coeffs to LSPs

    From wikipedia:
    A palindromic polynomial (i.e., P) of odd degree has -1 as a root.
    An antipalindromic polynomial (i.e., Q) has 1 as a root.
    An antipalindromic polynomial of even degree has -1 and 1 as roots
    """
    order = ar.shape[-1]
    ret = np.zeros(ar.shape)
    for a, o in core.refiter([ar, ret], core.newshape(ar.shape)):
        p = np.ones((order+2))
        q = np.ones((order+2))
        q[-1] = -1.0
        for i in range(order):
            p[i+1] = -a[i] - a[order-i-1]
            q[i+1] = -a[i] + a[order-i-1]
        pr = np.roots(p)
        qr = np.roots(q)

        j = 0
        an = np.ndarray((order+2))
        for i in range(len(pr)):
            if np.imag(pr[i]) >= 0.0:
                an[j] = np.angle(pr[i])
                j += 1
            if np.imag(qr[i]) >= 0.0:
                an[j] = np.angle(qr[i])
                j += 1
        # The angle list (an) will always contain both 0 and pi; they
        # will move to the ends after the sort
        o[...] = np.sort(an)[1:-1]
    return ret;
Example #31
0
    def _propagate_SExp_RTOp_ReSymK_Re_numpy(self, rhoi, Ham, RT, dt, L=4):
        """Integration by short exponentional expansion
        
        Integration by expanding exponential (_SExp_) to Lth order. 
        This is a numpy (_numpy) implementation with real (_Re_) matrices
        for  a system part of the system-bath interaction operator  ``K``
        in a form of real symmetric operator (ReSymK). The relaxation tensor
        is assumed in form of a set of operators (_RTOp_)
              
            
        """

        Nref = self.Nref
        Nt = self.Nt
        verbose = self.verbose
        timea = self.TimeAxis
        prop_name = self.propagation_name
        
        # no self beyond this point
        
        qr.log_detail("PROPAGATION (short exponential with "+
                    "relaxation in operator form): order ", L, 
                    verbose=verbose)
        qr.log_detail("Using real valued numpy implementation")
        
        pr = ReducedDensityMatrixEvolution(timea, rhoi,
                                           name=prop_name)
        
        rho1_r = numpy.real(rhoi.data)
        rho2_r = numpy.real(rhoi.data)
        rho1_i = numpy.imag(rhoi.data)
        rho2_i = numpy.imag(rhoi.data)
         
        HH = Ham.data
                
        try:
            Km = RT.Km #self.RelaxationTensor.Km # real
            Lm_r = numpy.real(RT.Lm) #self.RelaxationTensor.Lm) # complex
            Lm_i = numpy.imag(RT.Lm) #self.RelaxationTensor.Lm)
            Nm = Km.shape[0]
        except:
            raise Exception("Tensor is not in operator form")
            
        indx = 1
        
        # verbosity inside loops
        levs = [qr.LOG_QUICK] 
        verb = qr.loglevels2bool(levs, verbose=self.verbose)

        # after each step we apply pure dephasing (if present)
        if self.has_PDeph:
        
            # loop over time
            for ii in range(1, Nt):
                qr.printlog("time step ", ii, "of", Nt, 
                            verbose=verb[0], loglevel=levs[0], end="\r")
                
                # steps in between saving the results
                for jj in range(Nref):
                    
                    # L interations to get short exponential expansion
                    for ll in range(1, L+1):
    
                        A = numpy.dot(HH,rho1_i)
                        B = numpy.dot(HH,rho1_r)
                        rhoY_r =  (dt/ll)*(A + numpy.transpose(A))
                        rhoY_i = -(dt/ll)*(B - numpy.transpose(B)) 
                        
                        for mm in range(Nm):
                        
                            a = numpy.dot(Lm_r[mm,:,:], rho1_r)
                            A = a - numpy.transpose(a)
                            b = numpy.dot(Lm_i[mm,:,:], rho1_i)
                            B = b - numpy.transpose(b)
                            c = numpy.dot(Lm_r[mm,:,:], rho1_i)
                            C = -(c + numpy.transpose(c))
                            d = numpy.dot(Lm_i[mm,:,:], rho1_r)
                            D = d + numpy.transpose(d)
                            
                            E = B - A
                            F = C - D
                            
                            A = numpy.dot(Km[mm,:,:], E)
                            B = numpy.dot(Km[mm,:,:], F)
                            rhoY_r += (dt/ll)*(A + numpy.transpose(A))
                            rhoY_i += (dt/ll)*(B - numpy.transpose(B))
                            
                        rho1_r = rhoY_r 
                        rho1_i = rhoY_i
                        
                        rho2_r +=  rho1_r
                        rho2_i +=  rho1_i
                        
                        rho2_r = rho2_r*numpy.exp(-self.PDeph.data*dt)
                        rho2_i = rho2_i*numpy.exp(-self.PDeph.data*dt)
                        
                    rho1_r = rho2_r
                    rho1_i = rho2_i
                    
                pr.data[indx,:,:] = rho2_r + 1j*rho2_i 
                indx += 1             

        # propagatiomn with no extra dephasing
        else:
            
            # loop over time
            for ii in range(1, Nt):
                qr.printlog("time step ", ii, "of", Nt, 
                            verbose=verb[0], loglevel=levs[0], end="\r")
                
                # steps in between saving the results
                for jj in range(Nref):
                    
                    # L interations to get short exponential expansion
                    for ll in range(1, L+1):
    
                        A = numpy.dot(HH,rho1_i)
                        B = numpy.dot(HH,rho1_r)
                        rhoY_r =  (dt/ll)*(A + numpy.transpose(A))
                        rhoY_i = -(dt/ll)*(B - numpy.transpose(B)) 
                        
                        for mm in range(Nm):
                        
                            a = numpy.dot(Lm_r[mm,:,:], rho1_r)
                            A = a - numpy.transpose(a)
                            b = numpy.dot(Lm_i[mm,:,:], rho1_i)
                            B = b - numpy.transpose(b)
                            c = numpy.dot(Lm_r[mm,:,:], rho1_i)
                            C = -(c + numpy.transpose(c))
                            d = numpy.dot(Lm_i[mm,:,:], rho1_r)
                            D = d + numpy.transpose(d)
                            
                            E = B - A
                            F = C - D
                            
                            A = numpy.dot(Km[mm,:,:], E)
                            B = numpy.dot(Km[mm,:,:], F)
                            rhoY_r += (dt/ll)*(A + numpy.transpose(A))
                            rhoY_i += (dt/ll)*(B - numpy.transpose(B))
                            
                        rho1_r = rhoY_r 
                        rho1_i = rhoY_i
                        
                        rho2_r +=  rho1_r
                        rho2_i +=  rho1_i
                        
                    rho1_r = rho2_r
                    rho1_i = rho2_i
                    
                pr.data[indx,:,:] = rho2_r + 1j*rho2_i 
                indx += 1             

        
        qr.log_detail()
        qr.log_detail("...DONE")

        return pr
Example #32
0
        A6 = Asum6(0.5)
        A7 = Asum7(0.5)

        pl = Plotter()
        #line(frq/1e9, real(A), plotter=pl)
        #line(frq/1e9, imag(A), plotter=pl, color="red")

        #line(frq/1e9, real(A2), plotter=pl, color="green", linewidth=0.5)
        #line(frq/1e9, imag(A2), plotter=pl, color="black", linewidth=0.5)

        line(frq / 1e9,
             sin(pi * 9 * frq / f0) / sin(pi * frq / f0),
             plotter=pl)

        line(frq / 1e9, real(A3), plotter=pl, color="green", linewidth=0.5)
        line(frq / 1e9, imag(A3), plotter=pl, color="black", linewidth=0.5)

        line(frq / 1e9, A4, plotter=pl, color="red", linewidth=0.5)
        #line(frq/1e9, A5, plotter=pl, color="purple", linewidth=0.5)
        line(frq / 1e9, real(A6), plotter=pl, color="darkgray", linewidth=0.5)
        line(frq / 1e9, imag(A6), plotter=pl, color="darkgray", linewidth=0.5)

        #pl.show()
        pl = Plotter()

        line(frq / 1e9, 1 / 81.0 * absolute(A)**2, plotter=pl, color="black")
        #line(frq/1e9, 1/81.0*absolute(sin(pi*9*frq/f0)/sin(pi*frq/f0))**2, plotter=pl, color="green", linewidth=0.4)
        #line(frq/1e9, 1/81.0*absolute(A5)**2, plotter=pl, color="blue", linewidth=0.5)
        line(frq / 1e9,
             1 / 81.0 * absolute(A6)**2,
             plotter=pl,
Example #33
0
 def update_data_matrix(self, tableWidgetItem):
     lower_bound = 0.0
     upper_bound = float("inf")
     value = 0.0
     if tableWidgetItem.column() == 0:
         element = "length"
         value = utility.validate(tableWidgetItem.text(),
                                  lower_bound,
                                  upper_bound,
                                  l_inclusive=False,
                                  u_inclusive=False)
     elif tableWidgetItem.column() == 1:
         element = "separation"
         lower_bound = -1.0 * float("inf")
         value = utility.validate(tableWidgetItem.text(),
                                  lower_bound,
                                  upper_bound,
                                  l_inclusive=False,
                                  u_inclusive=False)
     elif tableWidgetItem.column() == 2:
         element = "earth impedance"
         try:
             # explicit string conversion required for Python 2.7
             value = np.complex(str(tableWidgetItem.text()))
         except:
             value = False
     elif tableWidgetItem.column() == 3:
         element = "soil resistivity"
         value = utility.validate(tableWidgetItem.text(),
                                  lower_bound,
                                  upper_bound,
                                  l_inclusive=False,
                                  u_inclusive=False)
     if not value is False:
         columns = [0, 1, 2, 4, 5]
         column = columns[tableWidgetItem.column()]
         update_mapping = (globals.sections[tableWidgetItem.row(), column]
                           != value)
         if isinstance(value, np.complex):
             globals.sections[tableWidgetItem.row(),
                              column] = np.real(value)
             globals.sections[tableWidgetItem.row(),
                              column + 1] = np.imag(value)
             if np.imag(value) == 0.0:
                 tableWidgetItem.setText(str(np.real(value)))
             else:
                 tableWidgetItem.setText(str(value))
         else:
             globals.sections[tableWidgetItem.row(), column] = value
             #tableWidgetItem.setText(str(value))
         if update_mapping:
             self.main_window.refresh_mapping()
     else:
         self.main_window.show_status_message(
             "Section " + str(tableWidgetItem.row() + 1) + " " + element +
             ": Input value '" + tableWidgetItem.text() +
             "' out of bounds. (" + str(lower_bound) + " to " +
             str(upper_bound) + "). Value not set.",
             error=True,
             beep=True)
         self.tableWidget.itemChanged.disconnect()
         self.refresh_data()
         self.tableWidget.itemChanged.connect(self.update_data_matrix)
    tf_fwd = muscat.computeconvolution(TF_ASF=None, is_padding=True)
    ''' Evaluate the model '''
    sess = tf.Session()  #config=tf.ConfigProto(log_device_placement=True))
    sess.run(tf.global_variables_initializer())
    ''' Compute the ATF '''
    myATF = sess.run(muscat.TF_ATF)
    myASF = sess.run(muscat.TF_ASF)

    #%% run model and measure memory/time
    start = time.time()
    myfwd = sess.run(
        tf_fwd,
        feed_dict={
            muscat.TF_ASF_placeholder: myASF,
            muscat.TF_obj: np.real(obj),
            muscat.TF_obj_absorption: np.imag(obj)
        }
    )  #, options=tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE, output_partition_graphs=True), run_metadata=run_metadata)
    end = time.time()
    print(end - start)

#%% display the results
centerslice = myfwd.shape[0] // 2

#sess.run(muscat.normfac)

if (muscat.Nz == 1 and False):
    plt.figure()
    plt.subplot(221), plt.title('real XY'), plt.imshow(
        np.real(np.squeeze(myfwd))), plt.colorbar()  #, plt.show()
    plt.subplot(222), plt.title('imag XY'), plt.imshow(
        first_iter = False

#    sddict = {'f':f,'11':P11,'12':P12,'13':P13,'22':P22,'23':P23,'33':P33}
#    sdpath = avgsddir + '/d%03d.cpkl' % day
#    file = open( sd_path , 'wb' )
#    cpkl.dump( sddict , file , -1 )
#    file.close()
sdpath = avgsddir + '/avgsd.dat' 
if avgsddir not in glob.glob( avgsddir ) :
    os.system( 'mkdir -p %s' % avgsddir )
file = open( sdpath , 'w' )
print >> file , '\n'
print >> file , '#CSD'
print >> file , ('#'+'%19s'+8*'%20s') % ('freq[Hz]','Re{g12}','Im{g12}','Re{P12}','Im{P12}','Re{P11}',
                                         'Im{P11}','Re{P22}','Im{P22}')
for k in range( f.shape[0] ) :
    print >> file , (9*'%20.10e') % ( f[k] ,np.real(g12[k]),np.imag(g12[k]), np.real(P12[k]),np.imag(P12[k]),
                                      np.real(P11[k]),np.imag(P11[k]),
                                      np.real(P22[k]),np.imag(P22[k]) )
file.close()
    





    
        

Example #36
0
while True:
    if s.code_p < l1cd.code_length / 2:
        n = int(fs * 0.01 * (l1cd.code_length - s.code_p) / l1cd.code_length)
    else:
        n = int(fs * 0.01 * (2 * l1cd.code_length - s.code_p) /
                l1cd.code_length)

    x = io.get_samples_complex(fp, n)
    if x is None:
        break

    nco.mix(x, -coffset / fs, coffset_phase)
    coffset_phase = coffset_phase - n * coffset / fs
    coffset_phase = np.mod(coffset_phase, 1)

    for j in range(10):
        a, b = int(j * n / 10), int((j + 1) * n / 10)
        p_prompt, s = track(x[a:b], s)
        vars = block, np.real(p_prompt), np.imag(
            p_prompt), s.carrier_f, s.code_f - l1cd.chip_rate, (
                180 / np.pi) * np.angle(p_prompt), s.early, s.prompt, s.late
        print('%d %f %f %f %f %f %f %f %f' % vars)

        block = block + 1
#    if (block%100)==0:
#      sys.stderr.write("%d\n"%block)
#    if block==500:
#      s.mode = 'FLL_NARROW'
#    if block==1000:
#      s.mode = 'PLL'
Example #37
0
    def _propagate_SExp_RTOp_ReSymK_Re_pytorch(self, rhoi, Ham, RT, dt,
                                               use_gpu=False, L=4):
        """Integration by short exponentional expansion
        
        Integration by expanding exponential (_SExp_) to Lth order. 
        This is a PyTorch (_pytorch) implementation with real (_Re_) matrices
        for  a system part of the system-bath interaction operator  ``K``
        in a form of real symmetric operator (ReSymK). The relaxation tensor
        is assumed in form of a set of operators (_RTOp_)
              
            
        """

        Nref = self.Nref
        Nt = self.Nt
        verbose = self.verbose
        timea = self.TimeAxis
        prop_name = self.propagation_name
        
        try: 
            import torch
        except:
            raise Exception("PyTorch not installed")
        
        # no self beyond this point
        
        qr.log_detail("PROPAGATION (short exponential with "+
                    "relaxation in operator form): order ", L, 
                    verbose=verbose)
        qr.log_detail("Using pytorch implementation")
        qr.log_detail("Using GPU: ", use_gpu & torch.cuda.is_available())
        
        pr = ReducedDensityMatrixEvolution(timea, rhoi,
                                           name=prop_name)
        
        rho1_r = torch.from_numpy(numpy.real(rhoi.data))
        rho2_r = torch.from_numpy(numpy.real(rhoi.data))
        rho1_i = torch.from_numpy(numpy.imag(rhoi.data))
        rho2_i = torch.from_numpy(numpy.imag(rhoi.data))
         
        HH = torch.from_numpy(Ham.data)
                
        try:
            Km = torch.from_numpy(RT.Km) #self.RelaxationTensor.Km # real
            Lm_r = torch.from_numpy(numpy.real(RT.Lm)) #self.RelaxationTensor.Lm) # complex
            Lm_i = torch.from_numpy(numpy.imag(RT.Lm)) #self.RelaxationTensor.Lm)
            Nm = RT.Km.shape[0]
        except:
            raise Exception("Tensor is not in operator form")
            
        if use_gpu & torch.cuda.is_available():
            rho1_r = rho1_r.cuda()
            rho2_r = rho1_r
            rho1_i = rho1_i.cuda()
            rho2_i = rho1_i
            HH = HH.cuda()
            Km = Km.cuda()
            Lm_r = Lm_r.cuda()
            Lm_i = Lm_i.cuda()
 
        indx = 1
        
        # verbosity inside loops
        levs = [qr.LOG_QUICK] 
        verb = qr.loglevels2bool(levs)
        
        # loop over time
        for ii in range(1, Nt):
            qr.printlog(" time step ", ii, "of", Nt, 
                        verbose=verb[0], loglevel=levs[0])
            
            # steps in between saving the results
            for jj in range(Nref):
                
                # L interations to get short exponential expansion
                for ll in range(1, L+1):

                    A = torch.matmul(HH,rho1_i)
                    B = torch.matmul(HH,rho1_r)
                    rhoY_r = torch.mul(A + torch.transpose(A, 0, 1), dt/ll)
                    rhoY_i = torch.mul(B - torch.transpose(B, 0, 1), -dt/ll) 

                    for mm in range(Nm):
                    
                        a = torch.matmul(Lm_r[mm,:,:], rho1_r)
                        A = a - torch.transpose(a, 0, 1)
                        b = torch.matmul(Lm_i[mm,:,:], rho1_i)
                        B = b - torch.transpose(b, 0, 1)
                        c = torch.matmul(Lm_r[mm,:,:], rho1_i)
                        C = -(c + torch.transpose(c, 0, 1))
                        d = torch.matmul(Lm_i[mm,:,:], rho1_r)
                        D = d + torch.transpose(d, 0, 1)
                        
                        E = B - A
                        F = C - D
                        
                        A = torch.matmul(Km[mm,:,:], E)
                        B = torch.matmul(Km[mm,:,:], F)
                        rhoY_r += torch.mul(A + torch.transpose(A, 0, 1),dt/ll)
                        rhoY_i += torch.mul(B - torch.transpose(B, 0, 1),dt/ll)
 
                    rho1_r = rhoY_r 
                    rho1_i = rhoY_i
                    
                    rho2_r += rho1_r
                    rho2_i += rho1_i
                    
                rho1_r = rho2_r
                rho1_i = rho2_i
            
            if use_gpu & torch.cuda.is_available():
                rho2_sr = rho2_r.cpu()
                rho2_si = rho2_i.cpu()
            else:
                rho2_sr = rho2_r
                rho2_si = rho2_i                
    
            pr.data[indx,:,:] = rho2_sr.numpy() + 1j*rho2_si.numpy() 
            indx += 1             
         
        qr.log_detail("...DONE")
        return pr
Example #38
0
"""
Estatisticas basicas
"""
print(pd.DataFrame(y).describe())
"""
Plota a decomposiĆ§Ć£o em series de fourier,
com o periodo invĆ©s de a frequĆŖncia
"""

#y = y-y.mean()
signal = y
fourier = np.fft.rfft(signal)
n = signal.size
sample_rate = 1
freq = np.fft.fftfreq(n, d=1. / sample_rate)
module = (np.real(y)**2 + np.imag(y)**2)**0.5
angle = np.angle(y)

plt.figure(figsize=(16, 4))
periodo = 1 / freq[:int(len(module) / 2)]
plt.plot(module[:int(len(module) / 2)])
#plt.plot(angle[:int(len(angle)/2)])
plt.grid(linestyle='dashed')
plt.ylim(min(module[:int(len(module) / 2)]),
         max(module[:int(len(module) / 2)]))
plt.xlim(1, 82)
plt.xticks(range(0, len(periodo), 5), periodo[range(0, len(periodo),
                                                    5)].round(decimals=2))
periodo = 1 / freq[:int(len(module) / 2)]
plt.xlabel("Period (1/F)")
plt.ylabel("Amplitude")
Example #39
0
#np.savetxt('ValsRe.txt', np.real(HamiltonEigVals), fmt='%1.4e')   # use exponential notation
#np.savetxt('ValsIm.txt', np.imag(HamiltonEigVals), fmt='%1.4e')   # use exponential notation
#np.savetxt('Vals.txt', HamiltonEigVals, fmt='%1.4e')   # use exponential notation
#np.savetxt('VecsHamiltonCalculator0010.txt', HamiltonEigVecs, fmt='%1.4e')   # use exponential notation

for m1 in range(0, 2 * NNN * SSS):
    file1.write("%s" % (MomentumAxis[m1])),
    file1.write("\t"),
    file1.write("%s" % (KineticAxis[m1]))
    file1.write("\t"),
    file1.write("%s" % (SelfEnergyAxis[m1]))
    file1.write("\t"),
    file1.write("%s" % (np.real(HamiltonEigVals[m1])))
    file1.write("\t"),
    file1.write("%s" % (np.imag(HamiltonEigVals[m1])))
    file1.write("\t"),
    file1.write("%s" % (HamiltonEigVals[m1]))
    file1.write('\n'),

file1.close()

print "gK = ", GGG
print "aK = ", AAA
print "L = ", LLL
print "N = ", NNN

print "Fin"

#216
Example #40
0
def s_sys(en):
    s = kwant.smatrix(sys, en).data
    return s


si0 = s_sys(e1)
sf0 = s_sys(e1 + df)
dos_sys = np.trace(si0.conj().T @ (sf0 - si0)) / df / (4 * np.pi**2) * (-1j)


def eigentime(u0, u1, vh0, vh1):

    vv0 = vh0.conj().T
    vv1 = vh1.conj().T
    t = (u0.conj().T @ (u1 - u0) -
         vv0.conj().T @ (vv1 - vv0)) / 1j / df / (2 * np.pi)
    return t


gf = kwant.greens_function(sys, e1).submatrix(1, 0)
u0, s0, vh0 = np.linalg.svd(gf, full_matrices=True, compute_uv=True)
gf1 = kwant.greens_function(sys, e1 + df).submatrix(1, 0)
u1, s1, vh1 = np.linalg.svd(gf1, full_matrices=True, compute_uv=True)

#u0, s0, vh0=np.linalg.svd(si[n:2*n,0:n], full_matrices=True, compute_uv=True)
#u1, s1, vh1=np.linalg.svd(sf[n:2*n,0:n], full_matrices=True, compute_uv=True)

t = np.diag(eigentime(u0, u1, vh0, vh1) / np.pi)
tt = sum(t[np.abs(np.imag(t)) < 1e-4])
elapsed = time() - t_ini
Example #41
0
def main():

    # Settings.
    scenario_name = fledge.config.config['tests']['scenario_name']
    results_path = fledge.utils.get_results_path(__file__, scenario_name)
    power_multipliers = np.arange(-0.2, 1.2, 0.1)

    # Recreate / overwrite database, to incorporate changes in the CSV files.
    fledge.data_interface.recreate_database()

    # Obtain base scaling parameters.
    scenario_data = fledge.data_interface.ScenarioData(scenario_name)
    base_power = scenario_data.scenario.at['base_apparent_power']
    base_voltage = scenario_data.scenario.at['base_voltage']

    # Obtain electric grid model.
    electric_grid_model = fledge.electric_grid_models.ElectricGridModelDefault(
        scenario_name)

    # Obtain power flow solution for nominal power conditions.
    power_flow_solution_initial = fledge.electric_grid_models.PowerFlowSolutionFixedPoint(
        electric_grid_model)

    # Obtain linear electric grid model for nominal power conditions.
    linear_electric_grid_model = (
        fledge.electric_grid_models.LinearElectricGridModelGlobal(
            electric_grid_model, power_flow_solution_initial))

    # Instantiate results variables.
    der_power_vector_active = (pd.DataFrame(index=power_multipliers,
                                            columns=electric_grid_model.ders,
                                            dtype=float))
    der_power_vector_reactive = (pd.DataFrame(index=power_multipliers,
                                              columns=electric_grid_model.ders,
                                              dtype=float))
    der_power_vector_active_change = (pd.DataFrame(
        index=power_multipliers, columns=electric_grid_model.ders,
        dtype=float))
    der_power_vector_reactive_change = (pd.DataFrame(
        index=power_multipliers, columns=electric_grid_model.ders,
        dtype=float))
    node_voltage_vector_power_flow = (pd.DataFrame(
        index=power_multipliers,
        columns=electric_grid_model.nodes,
        dtype=complex))
    node_voltage_vector_linear_model = (pd.DataFrame(
        index=power_multipliers,
        columns=electric_grid_model.nodes,
        dtype=complex))
    node_voltage_vector_magnitude_power_flow = (pd.DataFrame(
        index=power_multipliers,
        columns=electric_grid_model.nodes,
        dtype=float))
    node_voltage_vector_magnitude_linear_model = (pd.DataFrame(
        index=power_multipliers,
        columns=electric_grid_model.nodes,
        dtype=float))
    branch_power_vector_1_squared_power_flow = (pd.DataFrame(
        index=power_multipliers,
        columns=electric_grid_model.branches,
        dtype=float))
    branch_power_vector_1_squared_linear_model = (pd.DataFrame(
        index=power_multipliers,
        columns=electric_grid_model.branches,
        dtype=float))
    branch_power_vector_2_squared_power_flow = (pd.DataFrame(
        index=power_multipliers,
        columns=electric_grid_model.branches,
        dtype=float))
    branch_power_vector_2_squared_linear_model = (pd.DataFrame(
        index=power_multipliers,
        columns=electric_grid_model.branches,
        dtype=float))
    branch_power_vector_1_magnitude_power_flow = (pd.DataFrame(
        index=power_multipliers,
        columns=electric_grid_model.branches,
        dtype=float))
    branch_power_vector_1_magnitude_linear_model = (pd.DataFrame(
        index=power_multipliers,
        columns=electric_grid_model.branches,
        dtype=float))
    branch_power_vector_2_magnitude_power_flow = (pd.DataFrame(
        index=power_multipliers,
        columns=electric_grid_model.branches,
        dtype=float))
    branch_power_vector_2_magnitude_linear_model = (pd.DataFrame(
        index=power_multipliers,
        columns=electric_grid_model.branches,
        dtype=float))
    loss_active_power_flow = (pd.Series(index=power_multipliers, dtype=float))
    loss_active_linear_model = (pd.Series(index=power_multipliers,
                                          dtype=float))
    loss_reactive_power_flow = (pd.Series(index=power_multipliers,
                                          dtype=float))
    loss_reactive_linear_model = (pd.Series(index=power_multipliers,
                                            dtype=float))

    # Obtain DER power / change.
    der_power_vector_active.loc[:, :] = (
        np.transpose([power_multipliers]) @ np.array(
            [np.real(power_flow_solution_initial.der_power_vector)]))
    der_power_vector_reactive.loc[:, :] = (
        np.transpose([power_multipliers]) @ np.array(
            [np.imag(power_flow_solution_initial.der_power_vector)]))
    der_power_vector_active_change.loc[:, :] = (
        np.transpose([power_multipliers - 1]) @ np.array(
            [np.real(power_flow_solution_initial.der_power_vector)]))
    der_power_vector_reactive_change.loc[:, :] = (
        np.transpose([power_multipliers - 1]) @ np.array(
            [np.imag(power_flow_solution_initial.der_power_vector)]))

    # Obtain power flow solutions.
    power_flow_solutions = (fledge.utils.starmap(
        fledge.electric_grid_models.PowerFlowSolutionFixedPoint,
        [(electric_grid_model, row)
         for row in (der_power_vector_active +
                     1.0j * der_power_vector_reactive).values]))
    power_flow_solutions = dict(zip(power_multipliers, power_flow_solutions))
    for power_multiplier in power_multipliers:
        power_flow_solution = power_flow_solutions[power_multiplier]
        node_voltage_vector_power_flow.loc[
            power_multiplier, :] = power_flow_solution.node_voltage_vector
        node_voltage_vector_magnitude_power_flow.loc[
            power_multiplier, :] = np.abs(
                power_flow_solution.node_voltage_vector)
        branch_power_vector_1_magnitude_power_flow.loc[
            power_multiplier, :] = np.abs(
                power_flow_solution.branch_power_vector_1)
        branch_power_vector_2_magnitude_power_flow.loc[
            power_multiplier, :] = np.abs(
                power_flow_solution.branch_power_vector_2)
        branch_power_vector_1_squared_power_flow.loc[
            power_multiplier, :] = np.abs(
                power_flow_solution.branch_power_vector_1)**2
        branch_power_vector_2_squared_power_flow.loc[
            power_multiplier, :] = np.abs(
                power_flow_solution.branch_power_vector_2)**2
        loss_active_power_flow.loc[power_multiplier] = np.real(
            power_flow_solution.loss)
        loss_reactive_power_flow.loc[power_multiplier] = np.imag(
            power_flow_solution.loss)

    # Obtain linear model solutions.
    node_voltage_vector_linear_model.loc[:, :] = (
        np.transpose([power_flow_solution_initial.node_voltage_vector] *
                     len(power_multipliers)) +
        linear_electric_grid_model.sensitivity_voltage_by_der_power_active
        @ np.transpose(der_power_vector_active_change.values) +
        linear_electric_grid_model.sensitivity_voltage_by_der_power_reactive
        @ np.transpose(der_power_vector_reactive_change.values)).transpose()
    node_voltage_vector_magnitude_linear_model.loc[:, :] = (
        np.transpose([np.abs(power_flow_solution_initial.node_voltage_vector)]
                     * len(power_multipliers)) + linear_electric_grid_model.
        sensitivity_voltage_magnitude_by_der_power_active @ np.transpose(
            der_power_vector_active_change.values) +
        linear_electric_grid_model.
        sensitivity_voltage_magnitude_by_der_power_reactive @ np.transpose(
            der_power_vector_reactive_change.values)).transpose()
    branch_power_vector_1_magnitude_linear_model.loc[:, :] = (
        np.transpose(
            [np.abs(power_flow_solution_initial.branch_power_vector_1)] *
            len(power_multipliers)) + linear_electric_grid_model.
        sensitivity_branch_power_1_magnitude_by_der_power_active
        @ np.transpose(der_power_vector_active_change.values) +
        linear_electric_grid_model.
        sensitivity_branch_power_1_magnitude_by_der_power_reactive
        @ np.transpose(der_power_vector_reactive_change.values)).transpose()
    branch_power_vector_2_magnitude_linear_model.loc[:, :] = (
        np.transpose(
            [np.abs(power_flow_solution_initial.branch_power_vector_2)] *
            len(power_multipliers)) + linear_electric_grid_model.
        sensitivity_branch_power_2_magnitude_by_der_power_active
        @ np.transpose(der_power_vector_active_change.values) +
        linear_electric_grid_model.
        sensitivity_branch_power_2_magnitude_by_der_power_reactive
        @ np.transpose(der_power_vector_reactive_change.values)).transpose()
    branch_power_vector_1_squared_linear_model.loc[:, :] = (
        np.transpose(
            [np.abs(power_flow_solution_initial.branch_power_vector_1**2)] *
            len(power_multipliers)) + linear_electric_grid_model.
        sensitivity_branch_power_1_squared_by_der_power_active @ np.transpose(
            der_power_vector_active_change.values) +
        linear_electric_grid_model.
        sensitivity_branch_power_1_squared_by_der_power_reactive
        @ np.transpose(der_power_vector_reactive_change.values)).transpose()
    branch_power_vector_2_squared_linear_model.loc[:, :] = (
        np.transpose(
            [np.abs(power_flow_solution_initial.branch_power_vector_2**2)] *
            len(power_multipliers)) + linear_electric_grid_model.
        sensitivity_branch_power_2_squared_by_der_power_active @ np.transpose(
            der_power_vector_active_change.values) +
        linear_electric_grid_model.
        sensitivity_branch_power_2_squared_by_der_power_reactive
        @ np.transpose(der_power_vector_reactive_change.values)).transpose()
    loss_active_linear_model.loc[:] = (
        np.transpose([np.real(power_flow_solution_initial.loss)] *
                     len(power_multipliers)) +
        linear_electric_grid_model.sensitivity_loss_active_by_der_power_active
        @ np.transpose(der_power_vector_active_change.values) +
        linear_electric_grid_model.sensitivity_loss_active_by_der_power_reactive
        @ np.transpose(der_power_vector_reactive_change.values)).ravel()
    loss_reactive_linear_model.loc[:] = (
        np.transpose([np.imag(power_flow_solution_initial.loss)] *
                     len(power_multipliers)) + linear_electric_grid_model.
        sensitivity_loss_reactive_by_der_power_active @ np.transpose(
            der_power_vector_active_change.values) +
        linear_electric_grid_model.
        sensitivity_loss_reactive_by_der_power_reactive @ np.transpose(
            der_power_vector_reactive_change.values)).ravel()

    # Instantiate error variables.
    node_voltage_vector_error = (pd.Series(index=power_multipliers,
                                           dtype=float))
    node_voltage_vector_magnitude_error = (pd.Series(index=power_multipliers,
                                                     dtype=float))
    branch_power_vector_1_magnitude_error = (pd.Series(index=power_multipliers,
                                                       dtype=float))
    branch_power_vector_2_magnitude_error = (pd.Series(index=power_multipliers,
                                                       dtype=float))
    branch_power_vector_1_squared_error = (pd.Series(index=power_multipliers,
                                                     dtype=float))
    branch_power_vector_2_squared_error = (pd.Series(index=power_multipliers,
                                                     dtype=float))
    loss_active_error = (pd.Series(index=power_multipliers, dtype=float))
    loss_reactive_error = (pd.Series(index=power_multipliers, dtype=float))

    # Obtain error values.
    node_voltage_vector_error = (100.0 * (
        (node_voltage_vector_linear_model - node_voltage_vector_power_flow) /
        node_voltage_vector_power_flow).abs().mean(axis='columns'))
    node_voltage_vector_magnitude_error = (100.0 * (
        (node_voltage_vector_magnitude_linear_model -
         node_voltage_vector_magnitude_power_flow) /
        node_voltage_vector_magnitude_power_flow).mean(axis='columns'))
    branch_power_vector_1_magnitude_error = (100.0 * (
        (branch_power_vector_1_magnitude_linear_model -
         branch_power_vector_1_magnitude_power_flow) /
        branch_power_vector_1_magnitude_power_flow).mean(axis='columns'))
    branch_power_vector_2_magnitude_error = (100.0 * (
        (branch_power_vector_2_magnitude_linear_model -
         branch_power_vector_2_magnitude_power_flow) /
        branch_power_vector_2_magnitude_power_flow).mean(axis='columns'))
    branch_power_vector_1_squared_error = (100.0 * (
        (branch_power_vector_1_squared_linear_model -
         branch_power_vector_1_squared_power_flow) /
        branch_power_vector_1_squared_power_flow).mean(axis='columns'))
    branch_power_vector_2_squared_error = (100.0 * (
        (branch_power_vector_2_squared_linear_model -
         branch_power_vector_2_squared_power_flow) /
        branch_power_vector_2_squared_power_flow).mean(axis='columns'))
    loss_active_error = (100.0 *
                         ((loss_active_linear_model - loss_active_power_flow) /
                          loss_active_power_flow))
    loss_reactive_error = (
        100.0 * ((loss_reactive_linear_model - loss_reactive_power_flow) /
                 loss_reactive_power_flow))

    # Obtain error table.
    linear_electric_grid_model_error = (pd.DataFrame(
        [
            node_voltage_vector_error, node_voltage_vector_magnitude_error,
            branch_power_vector_1_magnitude_error,
            branch_power_vector_2_magnitude_error,
            branch_power_vector_1_squared_error,
            branch_power_vector_2_squared_error, loss_active_error,
            loss_reactive_error
        ],
        index=[
            'node_voltage_vector_error', 'node_voltage_vector_magnitude_error',
            'branch_power_vector_1_magnitude_error',
            'branch_power_vector_2_magnitude_error',
            'branch_power_vector_1_squared_error',
            'branch_power_vector_2_squared_error', 'loss_active_error',
            'loss_reactive_error'
        ]))
    linear_electric_grid_model_error = linear_electric_grid_model_error.round(
        2)

    # Print results.
    print(f"der_power_vector_active =\n{der_power_vector_active}")
    print(f"der_power_vector_reactive =\n{der_power_vector_reactive}")
    print(
        f"der_power_vector_active_change =\n{der_power_vector_active_change}")
    print(
        f"der_power_vector_reactive_change =\n{der_power_vector_reactive_change}"
    )
    print(
        f"node_voltage_vector_power_flow =\n{node_voltage_vector_power_flow}")
    print(
        f"node_voltage_vector_linear_model =\n{node_voltage_vector_linear_model}"
    )
    print(
        f"node_voltage_vector_magnitude_power_flow =\n{node_voltage_vector_magnitude_power_flow}"
    )
    print(
        f"node_voltage_vector_magnitude_linear_model =\n{node_voltage_vector_magnitude_linear_model}"
    )
    print(
        f"branch_power_vector_1_squared_power_flow =\n{branch_power_vector_1_squared_power_flow}"
    )
    print(
        f"branch_power_vector_1_squared_linear_model =\n{branch_power_vector_1_squared_linear_model}"
    )
    print(
        f"branch_power_vector_2_squared_power_flow =\n{branch_power_vector_2_squared_power_flow}"
    )
    print(
        f"branch_power_vector_2_squared_linear_model =\n{branch_power_vector_2_squared_linear_model}"
    )
    print(
        f"branch_power_vector_1_magnitude_power_flow =\n{branch_power_vector_1_magnitude_power_flow}"
    )
    print(
        f"branch_power_vector_1_magnitude_linear_model =\n{branch_power_vector_1_magnitude_linear_model}"
    )
    print(
        f"branch_power_vector_2_magnitude_power_flow =\n{branch_power_vector_2_magnitude_power_flow}"
    )
    print(
        f"branch_power_vector_2_magnitude_linear_model =\n{branch_power_vector_2_magnitude_linear_model}"
    )
    print(f"loss_active_power_flow =\n{loss_active_power_flow}")
    print(f"loss_active_linear_model =\n{loss_active_linear_model}")
    print(f"loss_reactive_power_flow =\n{loss_reactive_power_flow}")
    print(f"loss_reactive_linear_model =\n{loss_reactive_linear_model}")
    print(
        f"linear_electric_grid_model_error =\n{linear_electric_grid_model_error}"
    )

    # Store results as CSV.
    der_power_vector_active.to_csv(
        os.path.join(results_path, 'der_power_vector_active.csv'))
    der_power_vector_reactive.to_csv(
        os.path.join(results_path, 'der_power_vector_reactive.csv'))
    der_power_vector_active_change.to_csv(
        os.path.join(results_path, 'der_power_vector_active_change.csv'))
    der_power_vector_reactive_change.to_csv(
        os.path.join(results_path, 'der_power_vector_reactive_change.csv'))
    node_voltage_vector_power_flow.to_csv(
        os.path.join(results_path, 'node_voltage_vector_power_flow.csv'))
    node_voltage_vector_linear_model.to_csv(
        os.path.join(results_path, 'node_voltage_vector_linear_model.csv'))
    node_voltage_vector_magnitude_power_flow.to_csv(
        os.path.join(results_path,
                     'node_voltage_vector_magnitude_power_flow.csv'))
    node_voltage_vector_magnitude_linear_model.to_csv(
        os.path.join(results_path,
                     'node_voltage_vector_magnitude_linear_model.csv'))
    branch_power_vector_1_squared_power_flow.to_csv(
        os.path.join(results_path,
                     'branch_power_vector_1_squared_power_flow.csv'))
    branch_power_vector_1_squared_linear_model.to_csv(
        os.path.join(results_path,
                     'branch_power_vector_1_squared_linear_model.csv'))
    branch_power_vector_2_squared_power_flow.to_csv(
        os.path.join(results_path,
                     'branch_power_vector_2_squared_power_flow.csv'))
    branch_power_vector_2_squared_linear_model.to_csv(
        os.path.join(results_path,
                     'branch_power_vector_2_squared_linear_model.csv'))
    branch_power_vector_1_magnitude_power_flow.to_csv(
        os.path.join(results_path,
                     'branch_power_vector_1_magnitude_power_flow.csv'))
    branch_power_vector_1_magnitude_linear_model.to_csv(
        os.path.join(results_path,
                     'branch_power_vector_1_magnitude_linear_model.csv'))
    branch_power_vector_2_magnitude_power_flow.to_csv(
        os.path.join(results_path,
                     'branch_power_vector_2_magnitude_power_flow.csv'))
    branch_power_vector_2_magnitude_linear_model.to_csv(
        os.path.join(results_path,
                     'branch_power_vector_2_magnitude_linear_model.csv'))
    loss_active_power_flow.to_csv(
        os.path.join(results_path, 'loss_active_power_flow.csv'))
    loss_active_linear_model.to_csv(
        os.path.join(results_path, 'loss_active_linear_model.csv'))
    loss_reactive_power_flow.to_csv(
        os.path.join(results_path, 'loss_reactive_power_flow.csv'))
    loss_reactive_linear_model.to_csv(
        os.path.join(results_path, 'loss_reactive_linear_model.csv'))
    linear_electric_grid_model_error.to_csv(
        os.path.join(results_path, 'linear_electric_grid_model_error.csv'))

    # Plot results.

    # Voltage magnitude.
    for node_index, node in enumerate(electric_grid_model.nodes):
        plt.plot(power_multipliers,
                 base_voltage *
                 node_voltage_vector_magnitude_power_flow.loc[:, node],
                 label='Power flow')
        plt.plot(power_multipliers,
                 base_voltage *
                 node_voltage_vector_magnitude_linear_model.loc[:, node],
                 label='Linear model')
        plt.scatter([0.0], [
            base_voltage *
            abs(electric_grid_model.node_voltage_vector_reference[node_index])
        ],
                    label='No load')
        plt.scatter([1.0], [
            base_voltage *
            abs(power_flow_solution_initial.node_voltage_vector[node_index])
        ],
                    label='Initial point')
        plt.legend()
        plt.title(
            f"Voltage magnitude [V] for\n (node_type, node_name, phase): {node}"
        )
        plt.savefig(os.path.join(results_path,
                                 f'voltage_magnitude_{node}.png'))
        # plt.show()
        plt.close()

    # Branch flow.
    for branch_index, branch in enumerate(electric_grid_model.branches):
        plt.plot(power_multipliers,
                 base_power *
                 branch_power_vector_1_magnitude_power_flow.loc[:, branch],
                 label='Power flow')
        plt.plot(power_multipliers,
                 base_power *
                 branch_power_vector_1_magnitude_linear_model.loc[:, branch],
                 label='Linear model')
        plt.scatter([0.0], [0.0], label='No load')
        plt.scatter([1.0], [
            base_power * abs(power_flow_solution_initial.
                             branch_power_vector_1[branch_index])
        ],
                    label='Initial point')
        plt.legend()
        plt.title(
            f"Branch power 1 magnitude [VA] for\n (branch_type, branch_name, phase): {branch}"
        )
        plt.savefig(
            os.path.join(results_path,
                         f'branch_power_1_magnitude_{branch}.png'))
        # plt.show()
        plt.close()

        plt.plot(power_multipliers,
                 base_power *
                 branch_power_vector_2_magnitude_power_flow.loc[:, branch],
                 label='Power flow')
        plt.plot(power_multipliers,
                 base_power *
                 branch_power_vector_2_magnitude_linear_model.loc[:, branch],
                 label='Linear model')
        plt.scatter([0.0], [0.0], label='No load')
        plt.scatter([1.0], [
            base_power * abs(power_flow_solution_initial.
                             branch_power_vector_2[branch_index])
        ],
                    label='Initial point')
        plt.legend()
        plt.title(
            f"Branch power 2 magnitude [VA] for\n (branch_type, branch_name, phase): {branch}"
        )
        plt.savefig(
            os.path.join(results_path,
                         f'branch_power_2_magnitude_{branch}.png'))
        # plt.show()
        plt.close()

        plt.plot(power_multipliers, (base_power**2) *
                 branch_power_vector_1_squared_power_flow.loc[:, branch],
                 label='Power flow')
        plt.plot(power_multipliers, (base_power**2) *
                 branch_power_vector_1_squared_linear_model.loc[:, branch],
                 label='Linear model')
        plt.scatter([0.0], [0.0], label='No load')
        plt.scatter([1.0], [(base_power**2) * abs(
            power_flow_solution_initial.branch_power_vector_1[branch_index]**2)
                            ],
                    label='Initial point')
        plt.legend()
        plt.title(
            f"Branch power 1 squared [VAĀ²] for\n (branch_type, branch_name, phase): {branch}"
        )
        plt.savefig(
            os.path.join(results_path, f'branch_power_1_squared_{branch}.png'))
        # plt.show()
        plt.close()

        plt.plot(power_multipliers, (base_power**2) *
                 branch_power_vector_2_squared_power_flow.loc[:, branch],
                 label='Power flow')
        plt.plot(power_multipliers, (base_power**2) *
                 branch_power_vector_2_squared_linear_model.loc[:, branch],
                 label='Linear model')
        plt.scatter([0.0], [0.0], label='No load')
        plt.scatter([1.0], [(base_power**2) * abs(
            power_flow_solution_initial.branch_power_vector_2[branch_index]**2)
                            ],
                    label='Initial point')
        plt.legend()
        plt.title(
            f"Branch power 2 squared [VAĀ²] for\n (branch_type, branch_name, phase): {branch}"
        )
        plt.savefig(
            os.path.join(results_path, f'branch_power_2_squared_{branch}.png'))
        # plt.show()
        plt.close()

    # Loss.
    plt.plot(power_multipliers,
             base_power * loss_active_power_flow,
             label='Power flow')
    plt.plot(power_multipliers,
             base_power * loss_active_linear_model,
             label='Linear model')
    plt.scatter([0.0], [0.0], label='No load')
    plt.scatter([1.0],
                [base_power * np.real([power_flow_solution_initial.loss])],
                label='Initial point')
    plt.legend()
    plt.title("Total loss active [W]")
    plt.savefig(os.path.join(results_path, f'loss_active.png'))
    # plt.show()
    plt.close()

    plt.plot(power_multipliers,
             base_power * loss_reactive_power_flow,
             label='Power flow')
    plt.plot(power_multipliers,
             base_power * loss_reactive_linear_model,
             label='Linear model')
    plt.scatter([1.0],
                [base_power * np.imag([power_flow_solution_initial.loss])],
                label='Initial point')
    plt.legend()
    plt.title("Total loss reactive [VAr]")
    plt.savefig(os.path.join(results_path, f'loss_reactive.png'))
    # plt.show()
    plt.close()

    # Print results path.
    fledge.utils.launch(results_path)
    print(f"Results are stored in: {results_path}")
Example #42
0
    for K_it in Ks:
        j = int((K_it - Kstart) / Kstep)

        rp_arr[i, j] = rp(k_it, K_it, i, theta, phi, psi)


# remove horizontal scars
omega = omega[np.logical_not(rp_arr[:, 0] == 1. + 0.j)]
rp_arr = rp_arr[np.logical_not(rp_arr[:, 0] == 1. + 0.j)]

# remove vertical scars
qs = qs[np.logical_not(rp_arr[127, :] == 1. + 0.j)]
rp_arr = rp_arr[:, np.logical_not(rp_arr[127, :] == 1. + 0.j)]

imrp_arr = np.imag(rp_arr)

# --------------- Plot -------------- #

fig = plt.figure(figsize=(20, 10))
ax = fig.add_subplot(121)
ax.set_aspect('auto')
X, Y = np.meshgrid(qs, omega)
mesh = plt.contourf(X, Y, imrp_arr, np.linspace(cmin, cmax, cstep))
plt.xlabel(r'$q\ (10^{5}\ cm^{-1})$')
plt.ylabel(r'$\omega\ (cm^{-1})$')
cbar = fig.colorbar(mesh, ax=ax)
cbar.set_label(r'$Im(r_p)$', rotation=270)
cbar.ax.set_yticklabels([])

ax2 = fig.add_subplot(122, projection='3d')
Example #43
0
    def eigen_stationary_density(self):
        """
        Solve for the exact stationary density. First constructs the Nz*Ns by Nz*Ns transition matrix Q(a',z'; a,z) 
        from state (a,z) to (a',z'). Then obtains the eigenvector associated with the unique eigenvalue equal to 1. 
        This eigenvector (renormalized so that it sums to one) is the unique stationary density function.
        
        Note: About 99% of the computation time is spend on the eigenvalue calculation. For now there is no
        way to speed this function up as numba only supports np.linalg.eig() when there is no domain change 
        (ex. real numbers to real numbers). Here there is a domain change as some eigenvalues and eigenvector 
        elements are complex.

        *Output
            * stationary_pdf: stationary density function
            * Q: transition matrix
        """

        # a. initialize transition matrix
        Q = np.zeros((self.Nz * self.Na_fine, self.Nz * self.Na_fine))

        # b. interpolate and construct transition matrix
        for i_z in range(self.Nz):  #current productivity
            for i_a, a0 in enumerate(self.grid_a_fine):

                # i. interpolate
                a_intp = interp(self.grid_a, self.pol_sav[i_z, :], a0)

                #take the grid index to the right. a_intp lies between grid_sav_fine[j-1] and grid_sav_fine[j].
                j = np.sum(self.grid_a_fine <= a_intp)

                #less than or equal to lowest grid value
                if a_intp <= self.grid_a_fine[0]:
                    p = 0

                #more than or equal to greatest grid value
                elif a_intp >= self.grid_a_fine[-1]:
                    p = 1
                    j = j - 1  #since right index is outside the grid make it the max index

                #inside grid
                else:
                    p = (a_intp - self.grid_a_fine[j - 1]) / (
                        self.grid_a_fine[j] - self.grid_a_fine[j - 1])

                # ii. transition matrix
                na = i_z * self.Na_fine  #minimum row index

                for i_zz in range(self.Nz):  #next productivity state
                    ma = i_zz * self.Na_fine  #minimum column index

                    Q[na + i_a, ma + j] = p * self.pi[i_z, i_zz]
                    Q[na + i_a, ma + j - 1] = (1.0 - p) * self.pi[i_z, i_zz]

        # iii. ensure that the rows sum up to 1
        assert np.allclose(Q.sum(axis=1), np.ones(
            self.Nz *
            self.Na_fine)), "Transition matrix error: Rows do not sum to 1"

        # c. get the eigenvector
        eigen_val, eigen_vec = np.linalg.eig(
            Q.T)  #transpose Q for eig function.

        # i. find column index for eigen value equal to 1
        idx = np.argmin(np.abs(eigen_val - 1.0))

        eigen_vec_stat = np.copy(eigen_vec[:, idx])

        # ii. ensure complex arguments of any complex numbers are small and convert to real numbers

        if np.max(np.abs(np.imag(eigen_vec_stat))) < 1e-6:
            eigen_vec_stat = np.real(
                eigen_vec_stat
            )  # drop the complex argument of any complex numbers.

        else:
            raise Exception(
                "Stationary eigenvector error: Maximum complex argument greater than 0.000001. Use a different distribution solution method."
            )

        # d. obtain stationary density from stationary eigenvector

        # i. reshape
        stationary_pdf = eigen_vec_stat.reshape(self.Nz, self.Na_fine)

        # ii. stationary distribution by percent
        stationary_pdf = stationary_pdf / np.sum(np.sum(stationary_pdf,
                                                        axis=0))

        return stationary_pdf, Q
Example #44
0
def set_resolution(file: str, t_start: float, u_start: np.ndarray, num_dofs: int) -> None:
    """
    Create resolution file

    :param file: file
    :param t_start: time associated with the input approximate solution u_start
    :param u_start: approximate solution for the input time t_start
    :param num_dofs: number of unknowns
    """
    dofpos = np.cumsum([0, num_dofs])
    com_str = ['$ResFormat /* GetDP 2.10.0, ascii */', '1.1 0', '$EndResFormat']

    for j in range(np.size(t_start)):
        for k in range(np.size(num_dofs)):
            com_str.append('$Solution  /* DofData #' + str(k) + ' */')
            com_str.append(str(k) + ' ' + str(t_start) + ' 0 ' + str(j))
            y = u_start[dofpos[k]: dofpos[k + 1]]
            com_str.append("\n".join(" ".join(map(str, line)) for line in np.vstack((np.real(y), np.imag(u_start))).T))
            com_str.append('$EndSolution\n')

    with open(file, "w") as fid:
        fid.write("\n".join(com_str))
Example #45
0
def hqam(M, nn_dist=2):
    # M is the order of constellation, nn_dist is the nearest neighbour dist
    # The idea behind this algo is that we will create an M-ary constellation with a center point at(0,-y_1)
    # and then we will shift the constellation backwards in the x-axis in order to achieve the symmetry
    # of the constellation around the origin for a regular HQAM
    # We have to parametrize the func in order to generate different types of HQAM
    # depending on M and nn_dist
    # First we check if M is the square of an even integer
    even = 0  # even number that is even^2=M or the first even number that is even^2>M
    for i in range(2, M, 2):
        if i * i == M:
            even = i
            break
        elif i * i > M:
            even = i
            break

    diff = even**2 - M
    symbols = np.array([])

    # this works only for nn_dist = 2, something went wrong with listing comprehension below (check the bounds)
    # We can observe that we have two possible arrays for the x_axis values
    if diff == 0:
        pos_x_axis1 = np.array([
            x for x in range(nn_dist // 2, even + 1) if x % 2 == 1
        ])  # for 64-HQAM
        neg_x_axis1 = np.array(
            [-x for x in range(nn_dist // 2, even + 1) if x % 2 == 1])
        pos_x_axis2 = np.array(
            [x for x in range(nn_dist // 2, even + 1) if x % 2 == 0])
        neg_x_axis2 = np.array([-x for x in range(0, even)
                                if x % 2 == 0])  # for 64-HQAM
        # We can observe that we have only one array for y_axis values
        y_unity = np.sqrt(3 * (nn_dist**2) /
                          4)  # the height of the basic equilateral triangle
        pos_y_axis = np.array([
            y_unity / 2 + y_unity * i for i in range(0, even // 2)
        ])  # for 64-HQAM not exactly xd
        neg_y_axis = np.array([
            -y_unity / 2 - y_unity * (even // 2 - i - 1)
            for i in range(0, even // 2)
        ])

        # build 1st quadrant
        cnt1 = 0
        cnt2 = 0
        for column in range(0, even, 1):
            if column % 2 == 0:
                temp = np.ones(np.ceil(even // 4).astype(int)) * pos_x_axis1[
                    cnt1]  # the real part of the symbol
                temp = temp + 1j * np.array(
                    [pos_y_axis[i] for i in range(0, even // 2) if i % 2 == 0])
                symbols = np.concatenate((symbols, temp))
                cnt1 += 1
            else:
                temp = np.ones(np.ceil(
                    even // 4).astype(int)) * pos_x_axis2[cnt2]
                temp = temp + 1j * np.array(
                    [pos_y_axis[i] for i in range(0, even // 2) if i % 2 != 0])
                symbols = np.concatenate((symbols, temp))
                cnt2 += 1
        # build 2nd quadrant
        cnt1 = 0
        cnt2 = 0
        for column in range(0, even, 1):
            if column % 2 == 0:
                temp = np.ones(np.ceil(even // 4).astype(int)) * neg_x_axis1[
                    cnt1]  # the ceil and astype(int) are added
                # because of the posibility that we want to produce 32-HQAM and therefore even == 6
                temp = temp + 1j * np.array(
                    [pos_y_axis[i] for i in range(0, even // 2) if i % 2 == 0])
                symbols = np.concatenate((symbols, temp))
                cnt1 += 1
            else:
                temp = np.ones(np.ceil(
                    even // 4).astype(int)) * neg_x_axis2[cnt2]
                temp = temp + 1j * np.array(
                    [pos_y_axis[i] for i in range(0, even // 2) if i % 2 != 0])
                symbols = np.concatenate((symbols, temp))
                cnt2 += 1
        # build 3rd quadrant
        cnt1 = 0
        cnt2 = 0
        for column in range(0, even, 1):
            if column % 2 == 0:
                temp = np.ones(np.ceil(
                    even // 4).astype(int)) * neg_x_axis1[cnt1]
                temp = temp + 1j * np.array(
                    [neg_y_axis[i] for i in range(0, even // 2) if i % 2 == 0])
                symbols = np.concatenate((symbols, temp))
                cnt1 += 1
            else:
                temp = np.ones(np.ceil(
                    even // 4).astype(int)) * neg_x_axis2[cnt2]
                temp = temp + 1j * np.array(
                    [neg_y_axis[i] for i in range(0, even // 2) if i % 2 != 0])
                symbols = np.concatenate((symbols, temp))
                cnt2 += 1
        # build 4th quadrant
        cnt1 = 0
        cnt2 = 0
        for column in range(0, even, 1):
            if column % 2 == 0:
                temp = np.ones(np.ceil(
                    even // 4).astype(int)) * pos_x_axis1[cnt1]
                temp = temp + 1j * np.array(
                    [neg_y_axis[i] for i in range(0, even // 2) if i % 2 == 0])
                symbols = np.concatenate((symbols, temp))
                cnt1 += 1
            else:
                temp = np.ones(np.ceil(
                    even // 4).astype(int)) * pos_x_axis2[cnt2]
                temp = temp + 1j * np.array(
                    [neg_y_axis[i] for i in range(0, even // 2) if i % 2 != 0])
                symbols = np.concatenate((symbols, temp))
                cnt2 += 1
        # Now we will shift the constellation in x-axis direction
        shift = np.sqrt((nn_dist / 2)**2 -
                        (y_unity / 2)**2)  # calculated by pythagorean theorem
        for k in range(0, len(symbols)):
            symbols[k] -= shift  # by this move we achieve the symmetry
        return symbols
    else:  # diff !=0
        # We will assume that we can create the constellation with even * even points and then we will erase
        # diff points from the constellation, we will erase them depending on their energy

        # First, we have created an even^2 constellation,
        # symbols is an already constructed np.array with points on the complex plane
        # Now , we are going to remove the diff points from the symbols
        pos_x_axis1 = np.array([
            x for x in range(nn_dist // 2, even + 1) if x % 2 == 1
        ])  # for 64-HQAM
        neg_x_axis1 = np.array(
            [-x for x in range(nn_dist // 2, even + 1) if x % 2 == 1])
        pos_x_axis2 = np.array(
            [x for x in range(nn_dist // 2, even + 1) if x % 2 == 0])
        neg_x_axis2 = np.array([-x for x in range(0, even)
                                if x % 2 == 0])  # for 64-HQAM
        # We can observe that we have only one array for y_axis values
        y_unity = np.sqrt(3 * (nn_dist**2) /
                          4)  # the height of the basic equilateral triangle
        pos_y_axis = np.array([
            y_unity / 2 + y_unity * i for i in range(0, even // 2)
        ])  # for 64-HQAM not exactly xd
        neg_y_axis = np.array([
            -y_unity / 2 - y_unity * (even // 2 - i - 1)
            for i in range(0, even // 2)
        ])

        # build 1st quadrant
        cnt1 = 0
        cnt2 = 0
        for column in range(0, even, 1):
            if column % 2 == 0:
                temp = np.ones(np.ceil(even // 4).astype(int)) * pos_x_axis1[
                    cnt1]  # the real part of the symbol
                temp = temp + 1j * np.array(
                    [pos_y_axis[i] for i in range(0, even // 2) if i % 2 == 0])
                symbols = np.concatenate((symbols, temp))
                cnt1 += 1
            else:
                temp = np.ones(np.ceil(
                    even // 4).astype(int)) * pos_x_axis2[cnt2]
                temp = temp + 1j * np.array(
                    [pos_y_axis[i] for i in range(0, even // 2) if i % 2 != 0])
                symbols = np.concatenate((symbols, temp))
                cnt2 += 1
        # build 2nd quadrant
        cnt1 = 0
        cnt2 = 0
        for column in range(0, even, 1):
            if column % 2 == 0:
                temp = np.ones(np.ceil(
                    even // 4).astype(int)) * neg_x_axis1[cnt1]
                temp = temp + 1j * np.array(
                    [pos_y_axis[i] for i in range(0, even // 2) if i % 2 == 0])
                symbols = np.concatenate((symbols, temp))
                cnt1 += 1
            else:
                temp = np.ones(np.ceil(
                    even // 4).astype(int)) * neg_x_axis2[cnt2]
                temp = temp + 1j * np.array(
                    [pos_y_axis[i] for i in range(0, even // 2) if i % 2 != 0])
                symbols = np.concatenate((symbols, temp))
                cnt2 += 1
        # build 3rd quadrant
        cnt1 = 0
        cnt2 = 0
        for column in range(0, even, 1):
            if (even // 2) % 2 == 0:
                if column % 2 == 0:
                    temp = np.ones(np.ceil(
                        even // 4).astype(int)) * neg_x_axis1[cnt1]
                    temp = temp + 1j * np.array([
                        neg_y_axis[i]
                        for i in range(0, even // 2) if i % 2 == 0
                    ])
                    symbols = np.concatenate((symbols, temp))
                    cnt1 += 1
                else:
                    temp = np.ones(np.ceil(
                        even // 4).astype(int)) * neg_x_axis2[cnt2]
                    temp = temp + 1j * np.array([
                        neg_y_axis[i]
                        for i in range(0, even // 2) if i % 2 != 0
                    ])
                    symbols = np.concatenate((symbols, temp))
                    cnt2 += 1
            else:  # exception when we have 32-HQAM even = 6 and even//2 = 3
                if column % 2 == 0:
                    temp = np.ones(np.ceil(
                        even // 4).astype(int)) * neg_x_axis2[cnt1]
                    temp = temp + 1j * np.array([
                        neg_y_axis[i]
                        for i in range(0, even // 2) if i % 2 == 0
                    ])
                    symbols = np.concatenate((symbols, temp))
                    cnt1 += 1
                else:
                    temp = np.ones(np.ceil(
                        even // 4).astype(int)) * neg_x_axis1[cnt2]
                    temp = temp + 1j * np.array([
                        neg_y_axis[i]
                        for i in range(0, even // 2) if i % 2 != 0
                    ])
                    symbols = np.concatenate((symbols, temp))
                    cnt2 += 1

        # build 4th quadrant
        cnt1 = 0
        cnt2 = 0
        for column in range(0, even, 1):
            if (even // 2) % 2 == 0:
                if column % 2 == 0:
                    temp = np.ones(np.ceil(
                        even // 4).astype(int)) * pos_x_axis1[cnt1]
                    temp = temp + 1j * np.array([
                        neg_y_axis[i]
                        for i in range(0, even // 2) if i % 2 == 0
                    ])
                    symbols = np.concatenate((symbols, temp))
                    cnt1 += 1
                else:
                    temp = np.ones(np.ceil(
                        even // 4).astype(int)) * pos_x_axis2[cnt2]
                    temp = temp + 1j * np.array([
                        neg_y_axis[i]
                        for i in range(0, even // 2) if i % 2 != 0
                    ])
                    symbols = np.concatenate((symbols, temp))
                    cnt2 += 1
            else:  # exception when we have 32-HQAM even = 6 and even//2 = 3
                if column % 2 == 0:
                    temp = np.ones(np.ceil(
                        even // 4).astype(int)) * pos_x_axis2[cnt1]
                    temp = temp + 1j * np.array([
                        neg_y_axis[i]
                        for i in range(0, even // 2) if i % 2 == 0
                    ])
                    symbols = np.concatenate((symbols, temp))
                    cnt1 += 1
                else:
                    temp = np.ones(np.ceil(
                        even // 4).astype(int)) * pos_x_axis1[cnt2]
                    temp = temp + 1j * np.array([
                        neg_y_axis[i]
                        for i in range(0, even // 2) if i % 2 != 0
                    ])
                    symbols = np.concatenate((symbols, temp))
                    cnt2 += 1

        shift = np.sqrt((nn_dist / 2)**2 - (y_unity / 2)**2)
        for k in range(0, len(symbols)):
            symbols[k] -= shift  # by this move we achieve the symmetry

        energy = [
            np.real(symbol)**2 + np.imag(symbol)**2 for symbol in symbols
        ]
        energy = sorting.merge(
            energy
        )  # sorted in ascending order O(n*log n) algorithm complexity
        erased = []
        removed = 0
        for k in range(0, len(symbols)):
            symbol_energy = np.real(symbols[k])**2 + np.imag(
                symbols[k]
            )**2  # calculate energy per symbol while traversing symbols array
            # compare it to the diff-biggest elements of the energy array and if it is inside delete it
            for j in range(len(energy) - 1, len(energy) - diff, -1):
                if energy[j] == symbol_energy:
                    removed += 1
                    erased.append(k)
                    break
            if removed == diff:
                break

        print(len(erased))
        symbols = np.delete(symbols, erased)
        print(len(symbols))
        return symbols
Example #46
0
def apply_caltable_uvfits(gaincaltable,
                          datastruct,
                          filename_out,
                          cal_amp=False):
    """apply a calibration table to a uvfits file
       Args:
        caltable (Caltable) : a gaincaltable object
        datastruct (Datastruct) :  input data structure in EHTIM format
        filename_out (str) :  uvfits output file name
        cal_amp (bool): whether to do amplitude calibration
    """

    if datastruct.dtype != "EHTIM":
        raise Exception(
            "datastruct must be in EHTIM format in apply_caltable_uvfits!")

    gains0 = pd.read_csv(gaincaltable)
    polygain = {}
    mjd_start = {}
    polyamp = {}

    #deterimine which calibration to use when multiple options for multiple periods
    mjd_mean = datastruct.data['time'].mean() - MJD_0
    gains = gains0[(gains0.mjd_start <= mjd_mean)
                   & (gains0.mjd_stop >= mjd_mean)].reset_index(
                       drop=True).copy()

    for cou, row in gains.iterrows():
        polygain[row.station] = poly_from_str(str(row.ratio_phas))
        mjd_start[row.station] = row.mjd_start
        if cal_amp == True:
            polyamp[row.station] = poly_from_str(str(row.ratio_amp))
        else:
            polyamp[row.station] = poly_from_str('1.0')

    #print(gains0)
    #print(polygain)
    # interpolate the calibration  table
    rinterp = {}
    linterp = {}
    skipsites = []

    #-------------------------------------------
    # sort by baseline
    data = datastruct.data
    idx = np.lexsort((data['t2'], data['t1']))
    bllist = []
    for key, group in it.groupby(data[idx], lambda x: set((x['t1'], x['t2']))):
        bllist.append(np.array([obs for obs in group]))
    bllist = np.array(bllist)

    # apply the  calibration

    datatable = []
    coub = 0
    for bl_obs in bllist:
        t1 = bl_obs['t1'][0]
        t2 = bl_obs['t2'][0]
        coub = coub + 1
        print('Calibrating {}-{} baseline, {}/{}'.format(
            t1, t2, coub, len(bllist)))
        time_mjd = bl_obs['time'] - MJD_0  #dates are in mjd in Datastruct

        ###########################################################################################################################
        #OLD VERSION WHERE LCP IS SHIFTED TO RCP
        #        if t1 in skipsites:
        #            rscale1 = lscale1 = np.array(1.)
        #       else:
        #            try:
        #                rscale1 = 1./np.sqrt(polyamp[t1](time_mjd))
        #                lscale1 = np.sqrt(polyamp[t1](time_mjd))*np.exp(1j*polygain[t1](time_mjd - mjd_start[t1])*np.pi/180.)
        #            except KeyError:
        #                rscale1 = lscale1 = np.array(1.)
        #
        #        if t2 in skipsites:
        #            rscale2 = lscale2 = np.array(1.)
        #        else:
        #            try:
        #                rscale2 = 1./np.sqrt(polyamp[t2](time_mjd))
        #                lscale2 = np.sqrt(polyamp[t2](time_mjd))*np.exp(1j*polygain[t2](time_mjd - mjd_start[t2])*np.pi/180.)
        #            except KeyError:
        #                rscale2 = lscale2 = np.array(1.)
        ###########################################################################################################################

        ###########################################################################################################################
        #NEW VERSION WHERE RCP IS SHIFTED TO LCP // MW 2018/NOV/13
        if t1 in skipsites:
            rscale1 = lscale1 = np.array(1.)
        else:
            try:
                rscale1 = 1. / np.sqrt(polyamp[t1](time_mjd)) * np.exp(
                    -1j * polygain[t1](time_mjd - mjd_start[t1]) * np.pi /
                    180.)
                lscale1 = np.sqrt(polyamp[t1](time_mjd))
            except KeyError:
                rscale1 = lscale1 = np.array(1.)

        if t2 in skipsites:
            rscale2 = lscale2 = np.array(1.)
        else:
            try:
                rscale2 = 1. / np.sqrt(polyamp[t2](time_mjd)) * np.exp(
                    -1j * polygain[t2](time_mjd - mjd_start[t2]) * np.pi /
                    180.)
                lscale2 = np.sqrt(polyamp[t2](time_mjd))
            except KeyError:
                rscale2 = lscale2 = np.array(1.)
###########################################################################################################################

        rrscale = rscale1 * rscale2.conj()
        llscale = lscale1 * lscale2.conj()
        rlscale = rscale1 * lscale2.conj()
        lrscale = lscale1 * rscale2.conj()

        bl_obs['rr'] = (bl_obs['rr']) * rrscale
        bl_obs['ll'] = (bl_obs['ll']) * llscale
        bl_obs['rl'] = (bl_obs['rl']) * rlscale
        bl_obs['lr'] = (bl_obs['lr']) * lrscale

        bl_obs['rrweight'] = (bl_obs['rrweight']) / (np.abs(rrscale)**2)
        bl_obs['llweight'] = (bl_obs['llweight']) / (np.abs(llscale)**2)
        bl_obs['rlweight'] = (bl_obs['rlweight']) / (np.abs(rlscale)**2)
        bl_obs['lrweight'] = (bl_obs['lrweight']) / (np.abs(lrscale)**2)

        if len(datatable):
            datatable = np.hstack((datatable, bl_obs))
        else:
            datatable = bl_obs

    # put in uvfits format datastruct
    # telescope arrays
    tarr = datastruct.antenna_info
    tkeys = {tarr[i]['site']: i for i in range(len(tarr))}
    tnames = tarr['site']
    tnums = np.arange(1, len(tarr) + 1)
    xyz = np.array([[tarr[i]['x'], tarr[i]['y'], tarr[i]['z']]
                    for i in np.arange(len(tarr))])

    # uvfits format output data table
    bl_list = []
    for i in xrange(len(datatable)):
        entry = datatable[i]
        t1num = entry['t1']
        t2num = entry['t2']
        rl = entry['rl']
        lr = entry['lr']
        if tkeys[entry['t2']] < tkeys[
                entry['t1']]:  # reorder telescopes if necessary
            #print entry['t1'], tkeys[entry['t1']], entry['t2'], tkeys[entry['t2']]
            entry['t1'] = t2num
            entry['t2'] = t1num
            entry['u'] = -entry['u']
            entry['v'] = -entry['v']
            entry['rr'] = np.conj(entry['rr'])
            entry['ll'] = np.conj(entry['ll'])
            entry['rl'] = np.conj(lr)
            entry['lr'] = np.conj(rl)
            datatable[i] = entry
        bl_list.append(
            np.array((entry['time'], entry['t1'], entry['t2']), dtype=BLTYPE))
    _, unique_idx_anttime, idx_anttime = np.unique(bl_list,
                                                   return_index=True,
                                                   return_inverse=True)
    _, unique_idx_freq, idx_freq = np.unique(datatable['freq'],
                                             return_index=True,
                                             return_inverse=True)

    # random group params
    u = datatable['u'][unique_idx_anttime]
    v = datatable['v'][unique_idx_anttime]
    t1num = [tkeys[scope] + 1 for scope in datatable['t1'][unique_idx_anttime]]
    t2num = [tkeys[scope] + 1 for scope in datatable['t2'][unique_idx_anttime]]
    bls = 256 * np.array(t1num) + np.array(t2num)
    jds = datatable['time'][unique_idx_anttime]
    tints = datatable['tint'][unique_idx_anttime]

    # data table
    nap = len(unique_idx_anttime)
    nsubchan = 1
    nstokes = 4
    nchan = datastruct.obs_info.nchan

    outdat = np.zeros((nap, 1, 1, nchan, nsubchan, nstokes, 3))
    outdat[:, :, :, :, :, :, 2] = -1.0

    vistypes = ['rr', 'll', 'rl', 'lr']
    for i in xrange(len(datatable)):
        row_freq_idx = idx_freq[i]
        row_dat_idx = idx_anttime[i]

        for j in range(len(vistypes)):
            outdat[row_dat_idx, 0, 0, row_freq_idx, 0, j,
                   0] = np.real(datatable[i][vistypes[j]])
            outdat[row_dat_idx, 0, 0, row_freq_idx, 0, j,
                   1] = np.imag(datatable[i][vistypes[j]])
            outdat[row_dat_idx, 0, 0, row_freq_idx, 0, j,
                   2] = datatable[i][vistypes[j] + 'weight']

    # package data for saving
    obsinfo_out = datastruct.obs_info
    antennainfo_out = Antenna_info(tnames, tnums, xyz)
    uvfitsdata_out = Uvfits_data(u, v, bls, jds, tints, outdat)
    datastruct_out = Datastruct(obsinfo_out, antennainfo_out, uvfitsdata_out)

    # save final file
    save_uvfits(datastruct_out, filename_out)
    return
Example #47
0
    
#    ntmodplot = (tmod[-1]-tmod[0])/dtmod + 1
    
    
#    tmodplot = 
#    ntmod=tmod.shape[0]

#calculate the fourier transform of the data must be evenly spaced, if not evenly spaced, interpolate.
    
    
    ft = np.fft.fft(x) / nt
    
    
    ftreal = np.real(ft)
    ftimag = np.imag(ft)
    freq = np.fft.fftfreq(nt,d=dt)
    w = twopi*freq
    ftabs = np.abs(ft)
    
    for it in range(ntmod):
        xmodplot[it] = xmodplot[it]  + np.sum( ftreal*np.cos(w*tfftmod[it]) - ftimag*np.sin(w*tfftmod[it]) )
    
#    xmodplot = xmodplot
 
 
 
    ft = myfft.myft(t,x,sig)
    ftabs = ft[4]
    sigftabs=ft[5]
    freq = ft[6]
Example #48
0
    def get_slowest_pole(self, h_step, dt, NP, known_poles, stride):
        #print('\nget_slowest called with', NP, known_poles, stride)

        def d(n, stride):
            return np.array([h_step[n+stride*i] for i in range(NP+1)])

        def get_data_for_stride(stride):
            num_samples = len(h_step) - NP*stride
            samples = [d(n, stride) for n in range(num_samples)]

            # make samples rows in a (tall) matrix
            sample_matrix = np.stack(samples, 0)
            return sample_matrix

        data = get_data_for_stride(stride)

        # We split the collected data into the initial points, and the final point
        A = data[:,:-1]
        B = data[:,-1:]

        # Consider 5 poles, 2 already known
        # We can do some linear algebra to find column vector X such that
        # x0*a[n] + x1*a[n+1] + x2*a[n+2] + x3*a[n+3] + x4*a[n+4] + a[n+5] = 0
        # a[n](x0 + x1*r + x2*r^2 + x3*r^3 + x4*r^4 + r^5) = 0
        # r^5 + x4*r^4 + x3*r^3 + x2*r^2 + x1*r + x0 = 0
        # and then solve this polynomial to find the roots

        # BUT
        # With 2 known poles, we know this should factor out to
        # (r-p1)(r-p2)(r^3 + y0*r^2 + y1*r + y2) = 0
        # So we really want to use our linear algebra to find the Y vector instead
        # First we need a matrix Z, which depends on the known ps, s.t. X = ZY, (5x1) = (5x3)(3x1)
        # Then our linear algebra that was AX+B=0 becomes AZY+B=0, which is easily solvable for Y

        # Step 1: find Z
        # A a reminder, X = ZY where X and Y are defined as:
        # r^5 + x4*r^4 + x3*r^3 + x2*r^2 + x1*r + x0 = 0
        # (r-p1)(r-p2)(r^3 + y2*r^2 + y1*r + y0) = 0
        # Define C, which is coefficients of poly from known roots
        # r^2 + (-p1-p2)*r + p1*p2 -> c0=p1*p2, c1=(-p1-p2)
        # We see that each term in X[i] is a product of Y[j] and C[k] terms s.t. i=j+k
        # SO we can directly write Z[i,j] = C[i-j], or 0 if that's outside the C bounds

        # BE CAREFUL about the leading 1s in these polynomials.
        # In our example, the full Z would be 6x4, including leading 1s. It's okay to drop the
        # bottom row because it only contributes to the leading 1 of x, which we want to drop.
        # But we can't drop the right column, which corresponds to the leading 1 of Y, because
        # it contributes to other rows in X.
        # Z: 5x3 version of Z, with bottom row and right column dropped
        # Z~: 5x4 version of Z, with only bottom row dropped
        # Y~: 4x1 version of Y, with a constant one in the fourth spot
        # A Z~ Y~ == -B
        # We can't use least-squares to find Y right now because of that required constant 1
        # E: 4x3 almost-identity
        # F: 4x1 column, [0,0,0,1]
        # A Z~ (E Y + F) == -B
        # A Z~ E Y  +  A Z~ F == -B
        # A Z Y == -B - A Z~_last_column
        # So we need to do a modified regression: we can drop that extra column on Z~, but we have
        # to first use it to modify the B vector
        # Similarly, X = Z~ Y~ becomes X = Z Y + Z~_last_column

        known_rs = np.exp(np.array(known_poles)*stride)
        if np.isinf(known_rs).any():
            # probably got a bad pole in known_poles, should just give up
            return []

        poly = np.polynomial.polynomial
        C = poly.polyfromroots(known_rs)

        Z_tilde = np.zeros((NP, NP-len(known_rs)+1), dtype=C.dtype)
        for i in range(Z_tilde.shape[0]):
            for j in range(Z_tilde.shape[1]):
                k = i-j
                if k >= 0 and k < len(C):
                    Z_tilde[i,j] = C[k]
        Z = Z_tilde[:,:-1]
        Z_column = Z_tilde[:,-1:]

        Y = np.linalg.pinv(A@Z) @ (-B - (A@Z_column))
        X = Z@Y + Z_column

        # x0 * d0 + x1 * d2 + d2 = 0
        # a[n](x0 + x1*r + r^2) = 0

        poly = np.concatenate([[1], X[::-1,0]])

        #print('poly', poly)
        roots = np.roots(poly)
        #print('roots', roots)

        # errors often cause small roots to go negative when they shouldn't.
        # This messes with the log, so we explicitly call those nan.
        def mylog(x):
            if (np.real(x) == 0):
                return float('nan')
            if not abs(np.imag(x)/np.real(x)) > 1e-6 and np.real(x) <= 0:
                return float('nan')
            else:
                return np.log(x)
        ps_with_stride = np.vectorize(mylog)(roots)
        ps = ps_with_stride / (stride * dt)

        # remove known poles
        key=lambda x: float('inf') if np.isnan(x) else abs(x)
        new_ps = sorted(ps, key=key)
        #print('Before processing, found ps', new_ps)
        for known_p in known_poles:
            for i in range(len(new_ps)):
                # TODO is this epsilon reasonable when ps are likely ~1e10?
                if new_ps[i] is not None and abs((new_ps[i] - known_p) < 1e-6):
                    new_ps.pop(i)
                    break
            else:
                if np.isnan(new_ps).any():
                    # the nans are probably causing the error
                    return []
                #print(known_poles)
                #print(new_ps)
                assert False, f'Known pole {known_p} not found!'

        # finally, return 0 (if nan), 1, or 2 (if complex conjugate) slowest new poles
        #print('After processing, new ps', new_ps)
        assert len(new_ps) > 0, 'Found no new poles ... check NP and len(known_poles)'
        if abs(np.imag(new_ps[0])) > 1e-6:
            # complex conjugate pair
            #print(ps, new_ps)
            assert len(new_ps) >= 2, 'Only found one of complex conjugate pair?'
            if abs(np.conj(new_ps[0]) - new_ps[1]) > 1e-6 and np.isnan(new_ps).any():
                return []
            assert abs(np.conj(new_ps[0]) - new_ps[1]) < 1e-6, 'Issue with conjugate pair, check sorting?'
            return new_ps[:2]
        elif not np.isnan(new_ps[0]):
            return new_ps[:1]
        else:
            # empty list
            return new_ps[:0]
Example #49
0
def remap_uv(src_file, src_grd, dst_grd, dmax=0, cdepth=0, kk=0, dst_dir='./'):

    ystart = 240
    # get time
    nctime.long_name = 'time'
    nctime.units = 'days since 1900-01-01 00:00:00'
    # time reference "days since 1900-01-01 00:00:00"
    ref = datetime(1900, 1, 1, 0, 0, 0)
    ref = date2num(ref)
    tag = src_file.rsplit('/')[-1].rsplit('_')[-1].rsplit('-')[0]
    year = int(tag[:4])
    month = int(tag[4:6])
    day = int(tag[6:])
    time = datetime(year, month, day, 0, 0, 0)
    time = date2num(time)
    time = time - ref
    time = time + 2.5  # 5-day average

    # get dimensions
    Mp, Lp = dst_grd.hgrid.mask_rho.shape

    # create destination file
    dst_file = src_file.rsplit('/')[-1]
    dst_fileu = dst_dir + dst_file[:-4] + '_u_ic_' + dst_grd.name + '.nc'
    print '\nCreating destination file', dst_fileu
    if os.path.exists(dst_fileu) is True:
        os.remove(dst_fileu)
    pyroms_toolbox.nc_create_roms_file(dst_fileu, dst_grd, nctime)
    dst_filev = dst_dir + dst_file[:-4] + '_v_ic_' + dst_grd.name + '.nc'
    print 'Creating destination file', dst_filev
    if os.path.exists(dst_filev) is True:
        os.remove(dst_filev)
    pyroms_toolbox.nc_create_roms_file(dst_filev, dst_grd, nctime)

    # open destination file
    ncu = netCDF.Dataset(dst_fileu, 'a', format='NETCDF3_64BIT')
    ncv = netCDF.Dataset(dst_filev, 'a', format='NETCDF3_64BIT')

    #load var
    cdf = netCDF.Dataset(src_file)
    src_varu = cdf.variables['u']
    src_varv = cdf.variables['v']

    #get missing value
    spval = src_varu._FillValue

    # ARCTIC grid sub-sample
    src_varu = src_varu[:]
    src_varu = src_varu[:, np.r_[ystart:np.size(src_varu, 1), -1], :]
    src_varv = src_varv[:]
    src_varv = src_varv[:, np.r_[ystart:np.size(src_varv, 1), -1], :]

    # get weights file
    wts_file = 'remap_weights_SODA_2.1.6_to_ARCTIC2_bilinear_uv_to_rho.nc'

    # build intermediate zgrid
    zlevel = -src_grd.z_t[::-1, 0, 0]
    nzlevel = len(zlevel)
    dst_zcoord = pyroms.vgrid.z_coordinate(dst_grd.vgrid.h, zlevel, nzlevel)
    dst_grdz = pyroms.grid.ROMS_Grid(dst_grd.name + '_Z', dst_grd.hgrid,
                                     dst_zcoord)

    # create variable in destination file
    print 'Creating variable u'
    ncu.createVariable('u',
                       'f8', ('ocean_time', 's_rho', 'eta_u', 'xi_u'),
                       fill_value=spval)
    ncu.variables['u'].long_name = '3D u-momentum component'
    ncu.variables['u'].units = 'meter second-1'
    ncu.variables['u'].field = 'u-velocity, scalar, series'
    # create variable in destination file
    print 'Creating variable ubar'
    ncu.createVariable('ubar',
                       'f8', ('ocean_time', 'eta_u', 'xi_u'),
                       fill_value=spval)
    ncu.variables['ubar'].long_name = '2D u-momentum component'
    ncu.variables['ubar'].units = 'meter second-1'
    ncu.variables['ubar'].field = 'ubar-velocity,, scalar, series'

    print 'Creating variable v'
    ncv.createVariable('v',
                       'f8', ('ocean_time', 's_rho', 'eta_v', 'xi_v'),
                       fill_value=spval)
    ncv.variables['v'].long_name = '3D v-momentum component'
    ncv.variables['v'].units = 'meter second-1'
    ncv.variables['v'].field = 'v-velocity, scalar, series'
    print 'Creating variable vbar'
    ncv.createVariable('vbar',
                       'f8', ('ocean_time', 'eta_v', 'xi_v'),
                       fill_value=spval)
    ncv.variables['vbar'].long_name = '2D v-momentum component'
    ncv.variables['vbar'].units = 'meter second-1'
    ncv.variables['vbar'].field = 'vbar-velocity,, scalar, series'

    # remaping
    print 'remapping and rotating u and v from', src_grd.name, \
                      'to', dst_grd.name
    print 'time =', time

    # flood the grid
    print 'flood the grid'
    src_uz = pyroms_toolbox.BGrid_SODA.flood(src_varu, src_grd, Bpos='uv', \
                spval=spval, dmax=dmax, cdepth=cdepth, kk=kk)
    src_vz = pyroms_toolbox.BGrid_SODA.flood(src_varv, src_grd, Bpos='uv', \
                spval=spval, dmax=dmax, cdepth=cdepth, kk=kk)

    # horizontal interpolation using scrip weights
    print 'horizontal interpolation using scrip weights'
    dst_uz = pyroms.remapping.remap(src_uz, wts_file, \
                                      spval=spval)
    dst_vz = pyroms.remapping.remap(src_vz, wts_file, \
                                      spval=spval)

    # vertical interpolation from standard z level to sigma
    print 'vertical interpolation from standard z level to sigma'
    dst_u = pyroms.remapping.z2roms(dst_uz[::-1,:,:], dst_grdz, \
                        dst_grd, Cpos='rho', spval=spval, flood=False)
    dst_v = pyroms.remapping.z2roms(dst_vz[::-1,:,:], dst_grdz,  \
                        dst_grd, Cpos='rho', spval=spval, flood=False)

    # rotate u,v fields
    src_angle = np.zeros(dst_grd.hgrid.angle_rho.shape)
    dst_angle = dst_grd.hgrid.angle_rho
    angle = dst_angle - src_angle
    angle = np.tile(angle, (dst_grd.vgrid.N, 1, 1))
    U = dst_u + dst_v * 1j
    eitheta = np.exp(-1j * angle[:, :, :])
    U = U * eitheta
    dst_u = np.real(U)
    dst_v = np.imag(U)

    # move back to u,v points
    dst_u = 0.5 * (dst_u[:, :, :-1] + dst_u[:, :, 1:])
    dst_v = 0.5 * (dst_v[:, :-1, :] + dst_v[:, 1:, :])

    # spval
    idxu = np.where(dst_grd.hgrid.mask_u == 0)
    idxv = np.where(dst_grd.hgrid.mask_v == 0)
    for n in range(dst_grd.vgrid.N):
        dst_u[n, idxu[0], idxu[1]] = spval
        dst_v[n, idxv[0], idxv[1]] = spval

    # compute depth average velocity ubar and vbar
    # get z at the right position
    z_u = 0.5 * (dst_grd.vgrid.z_w[0, :, :, :-1] +
                 dst_grd.vgrid.z_w[0, :, :, 1:])
    z_v = 0.5 * (dst_grd.vgrid.z_w[0, :, :-1, :] +
                 dst_grd.vgrid.z_w[0, :, 1:, :])

    dst_ubar = np.zeros((dst_u.shape[1], dst_u.shape[2]))
    dst_vbar = np.zeros((dst_v.shape[1], dst_v.shape[2]))

    for i in range(dst_ubar.shape[1]):
        for j in range(dst_ubar.shape[0]):
            dst_ubar[j, i] = (dst_u[:, j, i] *
                              np.diff(z_u[:, j, i])).sum() / -z_u[0, j, i]

    for i in range(dst_vbar.shape[1]):
        for j in range(dst_vbar.shape[0]):
            dst_vbar[j, i] = (dst_v[:, j, i] *
                              np.diff(z_v[:, j, i])).sum() / -z_v[0, j, i]

    # spval
    dst_ubar[idxu[0], idxu[1]] = spval
    dst_vbar[idxv[0], idxv[1]] = spval

    # write data in destination file
    print 'write data in destination file'
    ncu.variables['ocean_time'][0] = time
    ncu.variables['u'][0] = dst_u
    ncu.variables['ubar'][0] = dst_ubar

    ncv.variables['ocean_time'][0] = time
    ncv.variables['v'][0] = dst_v
    ncv.variables['vbar'][0] = dst_vbar

    print dst_u.shape
    print dst_ubar.shape
    print dst_v.shape
    print dst_vbar.shape

    # close destination file
    ncu.close()
    ncv.close()
Example #50
0
    irregular = []
    while idx < M:
        irregular.append(
            temp[hash_map[idx]
                 [0]])  # we create the irregular constelation by selecting the
        # the lowest M energies from the hash_map
        idx += 1

    irregular = np.array(irregular)
    return irregular


if __name__ == '__main__':
    constellation = IrrHQAM(16, 2)  # Generate Constellation with nn_dist = 2
    n = np.random.normal(0, 0.1, 10000) + 1j * np.random.normal(
        0, 0.1, 10000)  # AWGN np.random.normal(mean, sigma, size)
    #by changing sigma we change noise power and because energy per symol is fixed due to standard nn_dist we can
    #change SNR parameter
    noise_power = 0.5  # SNR parameter
    r = np.random.choice(constellation, 10000) + n  # received symbol
    energy = [
        np.real(symbol)**2 + np.imag(symbol)**2 for symbol in constellation
    ]
    total = 0
    for k in energy:
        total += k
    Es = total / 16
    plt.plot(np.real(r), np.imag(r), '.')
    plt.grid(True)
    plt.show()
Example #51
0
def complex2ReIm(complx):
    return npy.real(complx), npy.imag(complx)
Example #52
0
        lambda x: np.linalg.eigvals(x),
    ],
)
def test_array_notimpl_function_dask(func):
    x = np.random.random((100, 100))
    y = da.from_array(x, chunks=(50, 50))

    with pytest.warns(FutureWarning,
                      match="The `.*` function is not implemented by Dask"):
        func(y)


@pytest.mark.skipif(missing_arrfunc_cond, reason=missing_arrfunc_reason)
@pytest.mark.parametrize(
    "func",
    [lambda x: np.real(x), lambda x: np.imag(x), lambda x: np.transpose(x)])
def test_array_function_sparse(func):
    sparse = pytest.importorskip("sparse")
    x = da.random.random((500, 500), chunks=(100, 100))
    x[x < 0.9] = 0

    y = x.map_blocks(sparse.COO)

    assert_eq(func(x), func(y))


@pytest.mark.skipif(missing_arrfunc_cond, reason=missing_arrfunc_reason)
def test_array_function_sparse_tensordot():
    sparse = pytest.importorskip("sparse")
    x = np.random.random((2, 3, 4))
    x[x < 0.9] = 0
Example #53
0
def fvol2sf(vol, r, b):
    """Transfer a volume in Fourier space into a serial of spherical functions.
    Makes use of the Hermitian symmetry to speed up.

    Parameters
    ----------
    vol: The volume of Fourier coefficients. It should be full and zero frequency in the center!
         numpy.ndarray

    r: Radius in k-space
       Integer

    b: Bandwidth, which determines the sampling on the sphere
       Integer

    Returns
    -------
    f(the_0, phi_0) ... f(the_0, phi_2B-1), f(the_2B-1, phi_0) ... f(the_2B-1, phi_2B-1)
    List
    """
    if r > vol.shape[0]//2 or r > vol.shape[1]//2 or r > vol.shape[2]//2:
        raise RuntimeError("Given radius is larger than the volume!")
    elif r <= 0:
        raise RuntimeError("Radius should be larger than the 0!")
    else:
        pass
    
    # zero frequency position
    m_x = vol.shape[0]//2; m_y = vol.shape[1]//2; m_z = vol.shape[2]//2

    # only half
    the = np.pi*(2*np.arange(b)+1) / (4*b)
    phi = np.pi*np.arange(2*b) / b

    # C order mesh
    phi, the = np.meshgrid(phi, the)
    the = the.flatten()
    phi = phi.flatten()

    # compute the coordinates
    x = r*np.cos(phi)*np.sin(the) + m_x
    y = r*np.sin(phi)*np.sin(the) + m_y
    z = r*np.cos(the) + m_z

    # use spline intepolation on the real/imaginary parts
    # can be done better, but now it suffices
    vol_r = np.real(vol)
    vol_i = np.imag(vol)

    from scipy.ndimage import map_coordinates
    res_r_a = map_coordinates(vol_r, [x, y, z], order=2)
    res_i_a = map_coordinates(vol_i, [x, y, z], order=2)

    # fill in the other half
    ind = np.arange(2*b**2)
    cind = (2*b-1-(ind+2*b**2)//(2*b))*2*b + np.mod(np.mod(ind, 2*b)+b, 2*b)

    res_r = np.zeros((4*b**2,))
    res_r[:2*b**2] = res_r_a
    res_r[2*b**2:] = res_r_a[cind]

    res_i = np.zeros((4*b**2,))
    res_i[:2*b**2] = res_i_a
    res_i[2*b**2:] = -res_i_a[cind]
    
    return [res_r, res_i]
Example #54
0
def turb_3d(xmin, xmax, ymin, ymax, zmin, zmax, nx, ny, nz):
    """
    Parameters:
    -----------    
    xmin: float
        The min domain size in the x-direction.
    xmax: float
        The max domain size in the x-direction.
    ymin: float
        The min domain size in the y-direction.
    ymax: float
        The max domain size in the y-direction.        
    zmin: float
        The min domain size in the z-direction.
    zmax: float
        The max domain size in the z-direction.   
    nx: integer
        The number of grid points in the x-direction.
    ny: integer
        The number of grid points in the y-direction.
    nz: integer
        The number of grid points in the z-direction. 
 
    """
    i_cmplx = np.complex(0, 1)
    #create a complex array of size nx, ny, nz
    uk = np.zeros([nx, ny, nz], dtype=complex)
    q1 = np.zeros([nx, ny, nz], dtype=complex)
    q = np.zeros([nx, ny, nz], dtype=complex)
    X_FFT = np.zeros([nx, ny, nz], dtype=complex)
    delta = np.max(((xmax - xmin) / (nx)) and ((ymax - ymin) / (ny))
                   and ((zmax - zmin) / (nz)))
    kc = pi / delta

    #determine the amplitude for the passot-poquet spectrum
    amp = (sqrt(
        (2.0 * pi)**3) / ((xmax - xmin) * (ymax - ymin) * (zmax - zmin)))

    for k in range(0, nz):
        #Sets the point, which is called the pi-wavenumber, to 0
        if ((2 * int(nz / 2) == nz) and (k == nz / 2)):
            continue
        for j in range(0, ny):
            #Sets the point, which is called the pi-wavenumber, to 0
            if ((2 * int(ny / 2) == ny) and (j == ny / 2)):
                continue
            for i in range(0, int(nx / 2)):
                """create random angles
                    - ps1 and ps2 ranges from -pi to pi
                    - psr ranges from 0 to 2*pi
                """
                ps1 = np.random.uniform(-pi, pi)
                ps2 = np.random.uniform(-pi, pi)
                psr = np.random.uniform(0, 2.0 * pi)
                #Leave the origin value as 0, otherwise a mean velocity will occur
                if ((i == 0) and (j == 0) and (k == 0)):
                    continue
                    #Sets the point, which is called the pi-wavenumber, to 0
                if ((2 * int(nx / 2) == nx) and (i == nx / 2)):
                    continue
                kx = (i) * 2.0 * pi / (xmax - xmin)
                if (j <= ny / 2):
                    ky = (j) * 2.0 * pi / (ymax - ymin)
                else:
                    ky = -1.0 * (ny - j) * 2.0 * pi / (ymax - ymin)
                if (k <= nz / 2):
                    kz = (k) * 2.0 * pi / (zmax - zmin)
                else:
                    kz = -1.0 * (nz - k) * 2.0 * pi / (zmax - zmin)

                k2 = sqrt(kx**2 + ky**2)
                kmag = sqrt(kx**2 + ky**2 + kz**2)
                #Checks to see that the wave numvers are not larger than the cutoff
                if (kmag > kc):
                    continue
                e_spec, up, ke = passot_pouquet_spectrum(
                    kmag, min(xmax, ymax, zmax))
                ak = amp * sqrt(e_spec / (2.0 * pi * kmag**2)) * np.exp(
                    i_cmplx * ps1) * cos(psr)
                bk = amp * sqrt(e_spec / (2.0 * pi * kmag**2)) * np.exp(
                    i_cmplx * ps2) * sin(psr)
                #Calculates the turbulence values
                if (k2 < (ke / 1e4)):
                    uk[i, j, k] = (ak + bk) / sqrt(2.0)
                else:
                    uk[i, j, k] = (ak * kmag * ky + bk * kx * kz) / (kmag * k2)

    #Finds the conjugate value calculation across the YZ Plane
    conjugate_yzplane(uk[0, :, :], nx, ny, nz)

    #Finds the FFT in the Y-Direction
    Y_FFT = fft(uk, axis=1)

    #Finds the FFT in the Z-Direction
    Z_FFT = fft(Y_FFT, axis=2)

    #Finds the FFT in the X-Direction after performing the conjugate
    for k in range(0, nz):
        for j in range(0, ny):
            q[0:nx, j, k] = Z_FFT[0:nx, j, k]
            for i in range(int(1 + nx / 2), nx):
                q[i, j, k] = conj(q[nx - i, j, k])
            q1 = fft(q, axis=0)
            X_FFT[0:nx, j, k] = q1[0:nx, j, k]
    """ To verify that the turbulence is generated correctly, the data must satisfy these three conditions:
    1. The sum of the real values after the FFTs should be equal or close to 0.
    2. The maximum imaginary value after the FFTs should be equal or close to 0.
    3. The Spectral Energy Content and the Physical Energy Content should be the sane. 
        - To determine the Spectral Energy Content, you use the turbuelence array before the FFTs.
        - TO determine the Physical Energy Content, you use the turbuelence array after the FFTs.
    """
    #Sum of Real Values
    sum_real = np.sum(X_FFT.real)

    #Maximum Imaginary Value
    max_imag = np.amax(np.abs(np.imag(X_FFT)))

    #Spectral Energy Content
    spectral_energy = np.sum(np.real(uk * np.conj(uk)))
    spectral_energy = spectral_energy - 0.5 * np.sum(
        np.real(uk[0, :, :] * np.conj(uk[0, :, :])))
    spectral_energy = spectral_energy / (1.5 * up**2)

    #Physical Energy Content
    physical_energy = 0.5 * np.sum(X_FFT.real**2)
    physical_energy = physical_energy / (1.5 * up**2 * nx * ny * nz)

    print("Sum of the Real Values: ", sum_real)
    print("Maximum Imaginary Value: ", max_imag)
    print("Spectral Energy Content: ", spectral_energy)
    print("Physical Energy Content: ", physical_energy)

    #Converts the array into a C-order array
    U = np.ascontiguousarray(X_FFT.real, dtype=np.float32)

    #Writes the data calculated into a Binary File
    with open('Z.bin', 'wb') as f:
        f.write(U)

    return U
    """csv_file = '3D_FFT_Output.csv'
Example #55
0
def extract_netcdf_constants(ilon,
                             ilat,
                             grid_file,
                             model_files,
                             TYPE='z',
                             METHOD='spline',
                             EXTRAPOLATE=False,
                             CUTOFF=10.0,
                             GZIP=True,
                             SCALE=1.0):
    """
    Reads files for a netCDF4 tidal model
    Makes initial calculations to run the tide program
    Spatially interpolates tidal constituents to input coordinates

    Arguments
    ---------
    ilon: longitude to interpolate
    ilat: latitude to interpolate
    grid_file: grid file for model (can be gzipped)
    model_files: list of model files for each constituent (can be gzipped)

    Keyword arguments
    -----------------
    TYPE: tidal variable to read
        z: heights
        u: horizontal transport velocities
        U: horizontal depth-averaged transport
        v: vertical transport velocities
        V: vertical depth-averaged transport
    METHOD: interpolation method
        bilinear: quick bilinear interpolation
        spline: scipy bivariate spline interpolation
        linear, nearest: scipy regular grid interpolations
    EXTRAPOLATE: extrapolate model using nearest-neighbors
    CUTOFF: extrapolation cutoff in kilometers
        set to np.inf to extrapolate for all points
    GZIP: input netCDF4 files are compressed
    SCALE: scaling factor for converting to output units

    Returns
    -------
    amplitude: amplitudes of tidal constituents
    phase: phases of tidal constituents
    D: bathymetry of tide model
    constituents: list of model constituents
    """

    #-- raise warning if model files are entered as a string
    if isinstance(model_files, str):
        warnings.warn("Tide model is entered as a string")
        model_files = [model_files]

    #-- read the tide grid file for bathymetry and spatial coordinates
    lon, lat, bathymetry = read_netcdf_grid(grid_file, TYPE, GZIP=GZIP)
    #-- grid step size of tide model
    dlon = lon[1] - lon[0]
    dlat = lat[1] - lat[0]
    #-- replace original values with extend arrays/matrices
    lon = extend_array(lon, dlon)
    bathymetry = extend_matrix(bathymetry)
    #-- create masks
    bathymetry.mask = (bathymetry.data == 0)

    #-- adjust dimensions of input coordinates to be iterable
    ilon = np.atleast_1d(ilon)
    ilat = np.atleast_1d(ilat)
    #-- adjust longitudinal convention of input latitude and longitude
    #-- to fit tide model convention
    lt0, = np.nonzero(ilon < 0)
    ilon[lt0] += 360.0
    #-- number of points
    npts = len(ilon)

    #-- interpolate bathymetry and mask to output points
    D = np.ma.zeros((npts))
    D.mask = np.zeros((npts), dtype=bool)
    if (METHOD == 'bilinear'):
        #-- replace invalid values with nan
        bathymetry[bathymetry.mask] = np.nan
        #-- use quick bilinear to interpolate values
        D.data[:] = bilinear_interp(lon, lat, bathymetry, ilon, ilat)
        #-- replace nan values with fill_value
        D.mask[:] = np.isnan(D.data)
        D.data[D.mask] = D.fill_value
    elif (METHOD == 'spline'):
        #-- use scipy bivariate splines to interpolate values
        f1 = scipy.interpolate.RectBivariateSpline(lon,
                                                   lat,
                                                   bathymetry.data.T,
                                                   kx=1,
                                                   ky=1)
        f2 = scipy.interpolate.RectBivariateSpline(lon,
                                                   lat,
                                                   bathymetry.mask.T,
                                                   kx=1,
                                                   ky=1)
        D.data[:] = f1.ev(ilon, ilat)
        D.mask[:] = np.ceil(f2.ev(ilon, ilat).astype(bool))
    else:
        #-- use scipy regular grid to interpolate values for a given method
        r1 = scipy.interpolate.RegularGridInterpolator((lat, lon),
                                                       bathymetry.data,
                                                       method=METHOD,
                                                       bounds_error=False)
        r2 = scipy.interpolate.RegularGridInterpolator((lat, lon),
                                                       bathymetry.mask,
                                                       method=METHOD,
                                                       bounds_error=False,
                                                       fill_value=1)
        D.data[:] = r1.__call__(np.c_[ilat, ilon])
        D.mask[:] = np.ceil(r2.__call__(np.c_[ilat, ilon])).astype(bool)

    #-- u and v are velocities in cm/s
    if TYPE in ('v', 'u'):
        unit_conv = (D.data / 100.0)
    #-- U and V are transports in m^2/s
    elif TYPE in ('V', 'U'):
        unit_conv = 1.0

    #-- number of constituents
    nc = len(model_files)
    #-- list of constituents
    constituents = []
    #-- amplitude and phase
    ampl = np.ma.zeros((npts, nc))
    ampl.mask = np.zeros((npts, nc), dtype=bool)
    ph = np.ma.zeros((npts, nc))
    ph.mask = np.zeros((npts, nc), dtype=bool)
    #-- read and interpolate each constituent
    for i, model_file in enumerate(model_files):
        if (TYPE == 'z'):
            #-- read constituent from elevation file
            z, con = read_elevation_file(model_file, GZIP=GZIP)
            #-- append constituent to list
            constituents.append(con)
            #-- replace original values with extend matrices
            z = extend_matrix(z)
            #-- interpolate amplitude and phase of the constituent
            z1 = np.ma.zeros((npts), dtype=z.dtype)
            z1.mask = np.zeros((npts), dtype=bool)
            if (METHOD == 'bilinear'):
                #-- replace invalid values with nan
                z[z.mask] = np.nan
                z1.data[:] = bilinear_interp(lon,
                                             lat,
                                             z,
                                             ilon,
                                             ilat,
                                             dtype=z.dtype)
                #-- mask invalid values
                z1.mask[:] |= np.copy(D.mask)
                z1.data[z1.mask] = z1.fill_value
            elif (METHOD == 'spline'):
                f1 = scipy.interpolate.RectBivariateSpline(lon,
                                                           lat,
                                                           z.data.real.T,
                                                           kx=1,
                                                           ky=1)
                f2 = scipy.interpolate.RectBivariateSpline(lon,
                                                           lat,
                                                           z.data.imag.T,
                                                           kx=1,
                                                           ky=1)
                z1.data.real = f1.ev(ilon, ilat)
                z1.data.imag = f2.ev(ilon, ilat)
                #-- mask invalid values
                z1.mask[:] |= np.copy(D.mask)
                z1.data[z1.mask] = z1.fill_value
            else:
                #-- use scipy regular grid to interpolate values
                r1 = scipy.interpolate.RegularGridInterpolator(
                    (lat, lon),
                    z.data,
                    method=METHOD,
                    bounds_error=False,
                    fill_value=z1.fill_value)
                z1.data[:] = r1.__call__(np.c_[ilat, ilon])
                #-- mask invalid values
                z1.mask[:] |= np.copy(D.mask)
                z1.data[z1.mask] = z1.fill_value
            #-- extrapolate data using nearest-neighbors
            if EXTRAPOLATE and np.any(z1.mask):
                #-- find invalid data points
                inv, = np.nonzero(z1.mask)
                #-- replace invalid values with nan
                z[z.mask] = np.nan
                #-- extrapolate points within cutoff of valid model points
                z1.data[inv] = nearest_extrap(lon,
                                              lat,
                                              z,
                                              ilon[inv],
                                              ilat[inv],
                                              dtype=z.dtype,
                                              cutoff=CUTOFF)
                #-- replace nan values with fill_value
                z1.mask[inv] = np.isnan(z1.data[inv])
                z1.data[z1.mask] = z1.fill_value
            #-- amplitude and phase of the constituent
            ampl.data[:, i] = np.abs(z1.data)
            ampl.mask[:, i] = np.copy(z1.mask)
            ph.data[:, i] = np.arctan2(-np.imag(z1.data), np.real(z1.data))
            ph.mask[:, i] = np.copy(z1.mask)
        elif TYPE in ('U', 'u', 'V', 'v'):
            #-- read constituent from transport file
            tr, con = read_transport_file(model_file, TYPE, GZIP=GZIP)
            #-- append constituent to list
            constituents.append(con)
            #-- replace original values with extend matrices
            tr = extend_matrix(tr)
            #-- interpolate amplitude and phase of the constituent
            tr1 = np.ma.zeros((npts), dtype=tr.dtype)
            tr1.mask = np.zeros((npts), dtype=bool)
            if (METHOD == 'bilinear'):
                tr1.data[:] = bilinear_interp(lon,
                                              lat,
                                              tr,
                                              ilon,
                                              ilat,
                                              dtype=tr.dtype)
                #-- mask invalid values
                tr1.mask[:] |= np.copy(D.mask)
                tr1.data[tr1.mask] = tr1.fill_value
            elif (METHOD == 'spline'):
                f1 = scipy.interpolate.RectBivariateSpline(lon,
                                                           lat,
                                                           tr.data.real.T,
                                                           kx=1,
                                                           ky=1)
                f2 = scipy.interpolate.RectBivariateSpline(lon,
                                                           lat,
                                                           tr.data.imag.T,
                                                           kx=1,
                                                           ky=1)
                tr1.data.real = f1.ev(ilon, ilat)
                tr1.data.imag = f2.ev(ilon, ilat)
                #-- mask invalid values
                tr1.mask[:] |= np.copy(D.mask)
                tr1.data[tr1.mask] = z1.fill_value
            else:
                #-- use scipy regular grid to interpolate values
                r1 = scipy.interpolate.RegularGridInterpolator(
                    (lat, lon),
                    tr.data,
                    method=METHOD,
                    bounds_error=False,
                    fill_value=tr1.fill_value)
                tr1.data[:] = r1.__call__(np.c_[ilat, ilon])
                #-- mask invalid values
                tr1.mask[:] |= np.copy(D.mask)
                tr1.data[tr1.mask] = tr1.fill_value
            #-- extrapolate data using nearest-neighbors
            if EXTRAPOLATE and np.any(tr1.mask):
                #-- find invalid data points
                inv, = np.nonzero(tr1.mask)
                #-- replace invalid values with nan
                tr[tr.mask] = np.nan
                #-- extrapolate points within cutoff of valid model points
                tr1.data[inv] = nearest_extrap(lon,
                                               lat,
                                               tr,
                                               ilon[inv],
                                               ilat[inv],
                                               dtype=tr.dtype,
                                               cutoff=CUTOFF)
                #-- replace nan values with fill_value
                tr1.mask[inv] = np.isnan(tr1.data[inv])
                tr1.data[tr1.mask] = tr1.fill_value
            #-- convert units
            #-- amplitude and phase of the constituent
            ampl.data[:, i] = np.abs(tr1.data) / unit_conv
            ampl.mask[:, i] = np.copy(tr1.mask)
            ph.data[:, i] = np.arctan2(-np.imag(tr1.data), np.real(tr1.data))
            ph.mask[:, i] = np.copy(tr1.mask)

    #-- convert amplitude from input units to meters
    amplitude = ampl * SCALE
    #-- convert phase to degrees
    phase = ph * 180.0 / np.pi
    phase[phase < 0] += 360.0
    #-- return the interpolated values
    return (amplitude, phase, D, constituents)
Example #56
0
def complex2dB(complx):
    dB = 20 * npy.log10(npy.abs( (npy.real(complx) + 1j*npy.imag(complx) )))
    return dB
Example #57
0
def save_all_parameters():

    if fileExtension == '.h5':
        f = h5py.File(str(directory), 'r+')

        if frame.radioButton.isChecked():
            param_dim = 9  #we get 9+3 parameters for the circle fit and only 2 for lorentz

            path = '/entry/analysis/notch resonator'
            _x = '/re'
            _y = '/im'

        if frame.radioButton_2.isChecked():
            param_dim = 6

            path = '/entry/analysis/lorentz'
            _x = '/amplitude'

        # in case the dataset already exists at e.g. /entry/data/notch_res/re create a new one at /entry/data/notch_res 2/re etc.
        try:
            dset_x_sim = f.create_dataset(path + _x,
                                          (len(i_data), len(f_data)))
            dset_parameters = f.create_dataset(path + '/param',
                                               (len(i_data), param_dim))
            if frame.radioButton.isChecked():
                #notch res: amplitude and phase therefore two datasets
                dset_y_sim = f.create_dataset(path + _y,
                                              (len(i_data), len(f_data)))
        except RuntimeError:
            #iterate datasets .../re 1, ../re 2 ,......
            it = 2
            while True:
                try:
                    dset_x_sim = f.create_dataset(path + ' ' + str(it) + _x,
                                                  (len(i_data), len(f_data)))
                    dset_parameters = f.create_dataset(
                        path + ' ' + str(it) + '/param',
                        (len(i_data), param_dim))
                    if frame.radioButton.isChecked():
                        dset_y_sim = f.create_dataset(
                            path + ' ' + str(it) + _y,
                            (len(i_data), len(f_data)))
                    break
                except RuntimeError:
                    it += 1

        dset_x_sim.attrs.create('y_unit', y_unit)
        dset_x_sim.attrs.create('x_name', x_name)
        dset_x_sim.attrs.create('y_name', y_name)
        dset_x_sim.attrs.create('x_unit', x_unit)
        dset_x_sim.attrs.create('dx', dx)
        dset_x_sim.attrs.create('dy', dy)
        dset_x_sim.attrs.create('y0', f_data[0])
        dset_x_sim.attrs.create('x0', x0)
        dset_x_sim.attrs.create('fill', fill)

        if frame.radioButton.isChecked():
            dset_y_sim.attrs.create('y_unit', y_unit)
            dset_y_sim.attrs.create('x_name', x_name)
            dset_y_sim.attrs.create('y_name', y_name)
            dset_y_sim.attrs.create('x_unit', x_unit)
            dset_y_sim.attrs.create('dx', dx)
            dset_y_sim.attrs.create('dy', dy)
            dset_y_sim.attrs.create('y0', f_data[0])
            dset_y_sim.attrs.create('x0', x0)
            dset_y_sim.attrs.create('fill', fill)

            dset_parameters.attrs.create("amp_norm", data_fit["amp_norm"])
            dset_parameters.attrs.create("alpha", data_fit["alpha"])
            dset_parameters.attrs.create("delay", data_fit["delay"])
            dset_parameters.attrs.create(
                "order of parameters:",
                "fr, Qr, absQc, Qi_no_corr, Qi_dia_corr, Qc_dia_corr, phi0, theta0, chi_square"
            )

        if frame.radioButton_2.isChecked():
            dset_parameters.attrs.create("order of parameters:",
                                         "A1, A2, A3, A4, fr, Qr")

        param = data_fit["parameters"]
        i = 0

        if frame.radioButton.isChecked():
            for z in z_data:
                dset_x_sim[i] = np.real(z)
                dset_y_sim[i] = np.imag(z)
                p = param[i]
                dset_parameters[i] = np.array([
                    p["fr"], p["Qr"], p["absQc"], p["Qi_no_corr"],
                    p["Qi_dia_corr"], p["Qc_dia_corr"], p["phi0"], p["theta0"],
                    p["chi_square"]
                ])
                i += 1
        if frame.radioButton_2.isChecked():
            for z in z_data:
                dset_x_sim[i] = np.absolute(z)
                p = param[i]
                dset_parameters[i] = np.array(
                    [p[0], p[1], p[2], p[3], p[4], p[5]])
                i += 1
        f.close()
        return

    FileName3 = str(QFileDialog.getSaveFileName())
    f_out = open(FileName3, 'w')

    if frame.radioButton.isChecked():
        label1 = '#' + str(frame.lineEdit_11.text()) + ' [' + str(
            frame.lineEdit_4.text()) + ']:'
        label2 = 'fr' + ' [' + str(frame.lineEdit_6.text()) + ']:'

        tag = [
            label1 + (20 - len(label1)) * ' ',
            label2 + (20 - len(label2)) * ' ', 'Qr:                 ',
            'Qi_dia_corr:        ', 'absQc:              ',
            'phi0:               '
        ]

        f_out.write(tag[0])
        f_out.write(tag[1])
        f_out.write(tag[2])
        f_out.write(tag[3])
        f_out.write(tag[4])
        f_out.write(tag[5])

        f_out.write('\n')

        i = 0
        for res in data_fit["parameters"]:
            f_out.write(str(i_data[i]))
            f_out.write((20 - len(str(i_data[i]))) * ' ')
            f_out.write(str(res["fr"]))
            f_out.write((20 - len(str(res["fr"]))) * ' ')
            f_out.write(str(res["Qr"]))
            f_out.write((20 - len(str(res["Qr"]))) * ' ')
            f_out.write(str(res["Qi_dia_corr"]))
            f_out.write((20 - len(str(res["Qi_dia_corr"]))) * ' ')
            f_out.write(str(res["absQc"]))
            f_out.write((20 - len(str(res["absQc"]))) * ' ')
            f_out.write(str(res["phi0"]))
            f_out.write((20 - len(str(res["phi0"]))) * ' ')

            i += 1
            f_out.write('\n')

    if frame.radioButton_2.isChecked():
        label1 = '#' + str(frame.lineEdit_11.text()) + ' [' + str(
            frame.lineEdit_4.text()) + ']:'
        label2 = 'fr' + ' [' + str(frame.lineEdit_6.text()) + ']:'

        tag = [
            label1 + (20 - len(label1)) * ' ',
            label2 + (20 - len(label2)) * ' ', 'Qr:                 '
        ]

        f_out.write(tag[0])
        f_out.write(tag[1])
        f_out.write(tag[2])

        f_out.write('\n')

        i = 0
        for res in data_fit["parameters"]:
            f_out.write(str(i_data[i]))
            f_out.write((20 - len(str(i_data[i]))) * ' ')
            f_out.write(str(res[4]))
            f_out.write((20 - len(str(res[4]))) * ' ')
            f_out.write(str(res[5]))
            f_out.write((20 - len(str(res[5]))) * ' ')
            i += 1
            f_out.write('\n')

    f_out.close()
# read first portion of file

ms_pad = ms + 5
n = int(fs*0.001*ms_pad)
fp = open(filename,"rb")
x = io.get_samples_complex(fp,n)

# resample to 3*10.230 MHz

fsr = 3*10230000.0/fs
nco.mix(x,-coffset/fs,0)
h = scipy.signal.firwin(161,12e6/(fs/2),window='hanning')
x = scipy.signal.filtfilt(h,[1],x)
xr = np.interp((1/fsr)*np.arange(ms_pad*3*10230),np.arange(len(x)),np.real(x))
xi = np.interp((1/fsr)*np.arange(ms_pad*3*10230),np.arange(len(x)),np.imag(x))
x = xr+(1j)*xi

# iterate (in parallel) over PRNs of interest

def worker(p):
  x,prn = p
  metric,code,doppler = search(x,prn,doppler_search,ms)
  return 'prn %2d doppler % 7.1f metric % 7.1f code_offset %6.1f' % (prn,doppler,metric,code)

import multiprocessing as mp

cpus = mp.cpu_count()
results = mp.Pool(cpus).map(worker, map(lambda prn: (x,prn),prns))

for r in results:
Example #59
0
#
# > Inserting k=0 we see that np.sum(x)  corresponds to y[0]. This term will be non-zero if we haven't removed any large scale trend in the data. For N even, the elements y[1]...y[N/2āˆ’1] contain the positive-frequency terms, and the elements y[N/2]...y[Nāˆ’1] contain the negative-frequency terms, in order of decreasingly negative frequency. For N odd, the elements y[1]...y[(Nāˆ’1)/2] contain the positive- frequency terms, and the elements y[(N+1)/2]...y[Nāˆ’1] contain the negative- frequency terms, in order of decreasingly negative frequency.
# > In case the sequence x is real-valued, the values of y[n] for positive frequencies is the conjugate of the values y[n] for negative frequencies (because the spectrum is symmetric). Typically, only the FFT corresponding to positive frequencies is plotted.
#
# So the first peak at index 20 is (20 bins) x (0.05 Hz/bin) = 1 Hz, as expected.  The nyquist frequency of 2.5 Hz is at an index of N/2 = 50 and the negative frequency peak is 20 bins to the left of the end bin.
#
#
# The inverse transform is:
#
# $$x[n] = \frac{1}{N} \sum_{k=0}^{N-1} y]k]\exp \left ( i 2 \pi k n /N \right )$$

# %% [markdown]
# What about the imaginary part?  All imaginary coefficients are zero (neglecting roundoff errors)

# %%
imag_coeffs=np.imag(thefft)
fig,theAx=plt.subplots(1,1,figsize=(8,6))
theAx.plot(imag_coeffs)
out=theAx.set_title('imag fft of onehz')

# %%
#now evaluate the power spectrum using Stull's 8.6.1a on p. 312

Power=np.real(thefft*np.conj(thefft))
totsize=len(thefft)
halfpoint=int(np.floor(totsize/2.))
firsthalf=Power[0:halfpoint] 


fig,ax=plt.subplots(1,1)
freq=np.arange(0,5.,0.05)
Example #60
0
plt.subplot(3, 1, 3)  # subplot 3
plt.plot(x, y1, '--r', label='y1 ')
plt.plot(x, y2, 'o', label='y2 ')  # plotting both functions on one plot
plt.axis([-2.5, 2.5, -0.5, 4.5])  # define axis
plt.grid(True)
plt.legend(loc='lower right ')  # prints a legend on the plot
plt.xlabel('x')  # x- axis label for all three subplots ( entire figure )
plt.ylabel('Subplot 3')  # label for subplot 3
plt.show()  ### --- This MUST be included to view your plots ! --- ###

cRect = 2 + 3j
print(cRect)

cPol = abs(cRect) * np.exp(1j * np.angle(cRect))
print(cPol)  # notice Python will store this in rectangular form
cRect2 = np.real(cPol) + 1j * np.imag(cPol)
print(cRect2)  # converting from polar to rectangular

print(numpy.sqrt(3 * 5 - 5 * 5 + 0j))  #must include 0j

#common packages to import
import numpy as np
import matplotlib.pyplot as plt
import scipy as sp
import scipy.signal as sig
import pandas as pd
import control
import time
from scipy.fftpack import fft, fftshift
"""
### common python commands with explanations###