Esempio n. 1
2
def problem4():
	# read in tada.wav
	rate, tada = wavfile.read('tada.wav')
	
	# upon inspection, we find that tada.wav is a stereo audio file. 
	# we create stereo white noise that lasts 10 seconds
	L_white = sp.int16(sp.random.randint(-32767,32767,rate*10))
	R_white = sp.int16(sp.random.randint(-32767,32767,rate*10))
	white = sp.zeros((len(L_white),2))
	white[:,0] = L_white
	white[:,1] = R_white
	
	# pad tada signal with zeros
	padded_tada = sp.zeros_like(white)
	padded_tada[:len(tada)] = tada
	ptada = padded_tada
	
	# fourier transforms
	ftada = sp.fft(ptada,axis=0)
	fwhite = sp.fft(white,axis=0)
	
	# inverse transform of convolution
	out = sp.ifft((ftada*fwhite),axis=0)
	
	# prepping output and writing file
	out = sp.real(out)
	scaled = sp.int16(out / sp.absolute(out).max() * 32767)
	wavfile.write('my_tada_conv.wav',rate,scaled)
Esempio n. 2
0
def XIntegralsFFT(GF_A,Bubble_A,Lambda,BubZero):
	''' calculate X integral to susceptibilities using FFT '''
	N = int((len(En_A)-1)/2)
	Kappa_A  = TwoParticleBubble(GF_A,GF_A**2,'eh')
	Bubble_A = TwoParticleBubble(GF_A,GF_A,'eh')
	#print(Kappa_A[N],Bubble_A[N])
	V_A   = 1.0/(1.0+Lambda*Bubble_A)
	KV_A  = Lambda*Kappa_A*V_A**2
	KmV_A = Lambda*sp.flipud(sp.conj(Kappa_A))*V_A**2
	## zero-padding the arrays
	exFD_A  = sp.concatenate([FD_A[N:],sp.zeros(2*N+2),FD_A[:N+1]])
	ImGF_A  = sp.concatenate([sp.imag(GF_A[N:]),sp.zeros(2*N+2),sp.imag(GF_A[:N+1])])
	ImGF2_A = sp.concatenate([sp.imag(GF_A[N:]**2),sp.zeros(2*N+2),sp.imag(GF_A[:N+1]**2)])
	ImV_A   = sp.concatenate([sp.imag(V_A[N:]),sp.zeros(2*N+2),sp.imag(V_A[:N+1])])
	ImKV_A  = sp.concatenate([sp.imag(KV_A[N:]),sp.zeros(2*N+2),sp.imag(KV_A[:N+1])])
	ImKmV_A = sp.concatenate([sp.imag(KmV_A[N:]),sp.zeros(2*N+2),sp.imag(KmV_A[:N+1])])
	## performing the convolution
	ftImX11_A = -sp.conj(fft(exFD_A*ImV_A))*fft(ImGF2_A)*dE
	ftImX12_A =  fft(exFD_A*ImGF2_A)*sp.conj(fft(ImV_A))*dE
	ftImX21_A = -sp.conj(fft(exFD_A*ImKV_A))*fft(ImGF_A)*dE
	ftImX22_A =  fft(exFD_A*ImGF_A)*sp.conj(fft(ImKV_A))*dE
	ftImX31_A = -sp.conj(fft(exFD_A*ImKmV_A))*fft(ImGF_A)*dE
	ftImX32_A =  fft(exFD_A*ImGF_A)*sp.conj(fft(ImKmV_A))*dE
	## inverse transform
	ImX1_A =  sp.real(ifft(ftImX11_A+ftImX12_A))/sp.pi
	ImX2_A =  sp.real(ifft(ftImX21_A+ftImX22_A))/sp.pi
	ImX3_A = -sp.real(ifft(ftImX31_A+ftImX32_A))/sp.pi
	ImX1_A =  sp.concatenate([ImX1_A[3*N+4:],ImX1_A[:N+1]])
	ImX2_A =  sp.concatenate([ImX2_A[3*N+4:],ImX2_A[:N+1]])
	ImX3_A =  sp.concatenate([ImX3_A[3*N+4:],ImX3_A[:N+1]])
	## getting real part from imaginary
	X1_A = KramersKronigFFT(ImX1_A) + 1.0j*ImX1_A + BubZero # constant part !!!
	X2_A = KramersKronigFFT(ImX2_A) + 1.0j*ImX2_A
	X3_A = KramersKronigFFT(ImX3_A) + 1.0j*ImX3_A
	return [X1_A,X2_A,X3_A]
Esempio n. 3
0
def prettymat(mat,fmt='%0.5g',eps=1e-14):
#        pdb.set_trace()
        if fmt[0]=='%':
            ifmt='%+'+fmt[1:]
        else:
            ifmt='%+'+fmt
            fmt='%'+fmt
        nc=scipy.shape(mat)[1]
#        print('[')
        outstr='['
#        fmtstr=fmt +(nc-1)*(' & ' +fmt)+'\\\\'
        for currow in mat.tolist():
#            curtuple=tuple(currow)
#            rowstr=fmtstr%curtuple
            rowstr='['
            for x,ent in enumerate(currow):
                if abs(scipy.real(ent))>eps:
                    realstr=fmt%scipy.real(ent)
                else:
                    realstr='0'
                if abs(scipy.imag(ent))>eps:
                    imagstr=ifmt%scipy.imag(ent)+'j'
                else:
                    imagstr=''
                rowstr+=realstr+imagstr
                if x<(len(currow)-1):
                    rowstr+=', '
                if x==(len(currow)-1):
                    rowstr+='],\n'
            outstr+=rowstr
        if outstr[-1]=='\n':
            outstr=outstr[0:-1]
        outstr+=']'
        print(outstr)
	def add_shape(self, f):
		#Create shape
		S = Shape(f, self.R, self.SHAPE_R)
	
		#Add to shape list
		S.shape_num = len(self.shape_list)
		self.shape_list.append(S)
		
		row = []
		for k in range(len(self.shape_list)):
			T = self.shape_list[k]
			ift = real(ipfft(pft_mult(pft_rotate(S.pft, 2.*pi/6.), T.pft), 2*self.SHAPE_R+1,2*self.SHAPE_R+1))
			Spad = imrotate(cpad(S.indicator, array([2*self.SHAPE_R+1,2*self.SHAPE_R+1])), 360./6.)
			Tpad = cpad(T.indicator, array([2*self.SHAPE_R+1,2*self.SHAPE_R+1]))
			pind = real(fftconvolve(Spad, Tpad, mode='same'))
			imshow(pind)
			imshow(ift)
			obst = to_ind(pind, 0.001)
			imshow(obst)
			cutoff = best_cutoff(ift, obst, S.radius + T.radius)
			print cutoff
			imshow(to_ind(ift, cutoff))
			row.append(cutoff * self.tarea)
		self.cutoff_matrix.append(row)

		return S
Esempio n. 5
0
def rlsloo_ll1( V, D, Y, lambd):
	"""
	Computes cs and the actual LOO errors for a single value of lambda. (lambd)
	"""
        n = V.shape[0]
        cl = Y.shape[1]
        
        inner  = 1/(D + lambd)
	inner = inner.conj()
        VtY = sp.dot(V.T, Y)
	VtY = VtY.conj()

        # Because of signs of D are flipped (scipy.linalg.eig returns
        # flipped signs for complex part of the eigenvalues)
        in_dot = sp.ones((n,1)) * inner
        ViD = V * in_dot
        cs = sp.dot(ViD, VtY)
        dGi = sp.sum(ViD*V, axis = 1)
        # -- till here works fine
        #check matrix dimensions
        looerrs = cs.ravel()/sp.real(dGi.ravel())
	looerrs = sp.real(looerrs)
        cs = sp.real(cs.transpose())

        return cs.ravel(), looerrs
Esempio n. 6
0
def ipfft(pft, xs, ys):
	if(xs > 2 * len(pft) + 1 and ys > 2 * len(pft) + 1):
		return fftshift(real(ifft2(fftshift(polar2rect(pft, xs, ys)))))
	t = fftshift(real(ifft2(fftshift(polar2rect(pft, 2*len(pft)+1, 2*len(pft)+1)))))
	tx = len(pft) - xs / 2
	ty = len(pft) - ys / 2
	return t[tx:(tx+xs),ty:(ty+ys)]
Esempio n. 7
0
def root_locus(sys, kvect, xlim=None, ylim=None, plotstr='-', Plot=True, 
               PrintGain=True):
    """Calculate the root locus by finding the roots of 1+k*TF(s)
    where TF is self.num(s)/self.den(s) and each k is an element
    of kvect.

    Parameters
    ----------
    sys : linsys
        Linear input/output systems (SISO only, for now)
    kvect : gain_range (default = None)
        List of gains to use in computing diagram
    Plot : boolean (default = True)
        If True, plot magnitude and phase
    PrintGain: boolean (default = True)
        If True, report mouse clicks when close to the root-locus branches,
        calculate gain, damping and print
    Return values
    -------------
    rlist : list of computed root locations
    """

    # Convert numerator and denominator to polynomials if they aren't
    (nump, denp) = _systopoly1d(sys);

    # Compute out the loci
    mymat = _RLFindRoots(sys, kvect)
    mymat = _RLSortRoots(sys, mymat)

    # Create the plot
    if (Plot):
        f = pylab.figure()
        if PrintGain:
            cid = f.canvas.mpl_connect(
                'button_release_event', partial(_RLFeedbackClicks, sys=sys))
        ax = pylab.axes();

        # plot open loop poles
        poles = array(denp.r)
        ax.plot(real(poles), imag(poles), 'x')

        # plot open loop zeros
        zeros = array(nump.r)
        if zeros.any():
            ax.plot(real(zeros), imag(zeros), 'o')

        # Now plot the loci
        for col in mymat.T:
            ax.plot(real(col), imag(col), plotstr)

        # Set up plot axes and labels
        if xlim:
            ax.set_xlim(xlim)
        if ylim:
            ax.set_ylim(ylim)
        ax.set_xlabel('Real')
        ax.set_ylabel('Imaginary')

    return mymat
def confMap(shape,mapfunc):
	shapemapped = [None]*len(shape)
	for i in range(0,len(shape)):
		shapemapped[i] = mapfunc(shape[i])
	
	plt.scatter(sp.real(shape),sp.imag(shape),color='r')
	plt.scatter(sp.real(shapemapped),sp.imag(shapemapped),color='b')
	plt . show ()
    def monitor_limitedFrames_MP(self, i):
        if self.centroid==True:
            fit_func = correlateFrames.cent
        else:
            fit_func = correlateFrames.fitCorrGaussian_v2
        corr_func = correlateFrames.corr
        
        xdim_fft, ydim_fft = self.fft_target.shape
        #i = 0

        #print "Dry Run? ", self.dry_run
        
        if (i<self.frames) and (not self.quit):
            self.active=True
            time.sleep(self.monitorDelay)
            self.times.append(time.clock())
            if self.fr_change>0 and i>(self.unactive_until + self.initialFrames-1):
                ind = int(scipy.floor(i/self.fr_change))
                self.conversion = self.conversions[ind]

            self.stage_zs.append(self.piezo.getPosition(3)-self.zoffset)
            target_gs_ht, defocus_ht_diff, target_xval, target_yval = self.getImage_doCorrs_inThread()
            
            self.target_signal.append(target_gs_ht)
            self.defocus_signal.append(defocus_ht_diff)

            latestSig = defocus_ht_diff / target_gs_ht

            self.xdrift.append(scipy.real(target_xval) - self.gaussFitRegion)
            self.ydrift.append(scipy.real(target_yval) - self.gaussFitRegion)


            if True:
                if i>(self.unactive_until + self.initialFrames-1):
                    if i==self.unactive_until + self.initialFrames:
                        self.initial_ds = scipy.mean(self.defocus_signal[self.unactive_until:])
                        self.initial_z = scipy.mean(self.stage_zs)
                        self.initial_ts = scipy.mean(self.target_signal[self.unactive_until:])
                        self.sig0 = self.initial_ds/self.initial_ts
                        print self.initial_z
                    if i>(self.unactive_until+self.initialFrames):
                        if self.use_multiplane and self.newplane>0:
                            mp = int(i)/int(self.newplane)
                        else:
                            mp = 0
                        if not self.dry_run:
                            self.react_z(self.initial_ds, self.initial_ts, self.initial_z, toprint=False, multiplane=mp)
                            self.react_xy(rolling_av=self.rollingAvXY, toprint=False)
                    initialSigFound = True
                else:
                    initialSigFound = False

            if initialSigFound:
                return self.stage_zs[-1], self.xdrift[-1], self.ydrift[-1], self.sig0, latestSig
            else:
                return self.stage_zs[-1], self.xdrift[-1], self.ydrift[-1], -1, latestSig
        return 0,0,0,0,0
Esempio n. 10
0
def rceps(x): 
	y = sp.real(ifft(sp.log(sp.absolute(fft(x)))))
	n = len(x) 
	if (n%2) == 1:
		ym = np.hstack((y[0], 2*y[1:n/2], np.zeros(n/2-1)))
	else:
		ym = np.hstack((y[0], 2*y[1:n/2], y[n/2+1], np.zeros(n/2-1)))
	ym = sp.real(ifft(sp.exp(fft(ym)))) 
	return (y, ym)
def pltFunction (cavity1,cavity2,cavity3,plotType):
  if (plotType==0):
    return sp.absolute(cavity1[:])**2,sp.absolute(cavity2[:])**2,sp.absolute(cavity3[:])**2
  elif (plotType==1):
    return sp.real(cavity1[:]),sp.real(cavity2[:]),sp.real(cavity3[:])
  elif (plotType==2):
    return sp.imag(cavity1[:]),sp.imag(cavity2[:]),sp.imag(cavity3[:])
  else: 
    return cavity1, cavity2, cavity3
Esempio n. 12
0
def sphericalPot(x,y,shift=0,radius=1,scale=1):
    from scipy import real,sqrt
    size_x = x.max()
    size_y = y.max()
    Vbottom = 0
    x = x-size_x/2
    left_sphere = real(sqrt(radius**2-(x**2+(y-shift)**2)))*heaviside(y-shift)+real(sqrt(radius**2-x**2))*heaviside(-(y-shift))
    right_sphere = real(sqrt(radius**2-(x**2+(y-size_y+shift)**2)))*heaviside(-(y-size_y+shift))+real(sqrt(radius**2-x**2))*heaviside((y-size_y+shift))
    V = Vbottom +scale*(left_sphere+right_sphere)
    return V
Esempio n. 13
0
def RenormalizeFactor(excfile,gsfile,channel=None,Nsamp=1,O=None,q=None):
    if not type(excfile)==list:
        excfile=[excfile]
    if not type(gsfile)==list:
        gsfile=[gsfile]
    exat=GetAttr(excfile[0])
    gsat=GetAttr(gsfile[0])
    L=exat['L']
    if q==None:
        q=sc.array([exat['qx'],exat['qy']])
    if 'phasex' in exat.keys():
        shift=sc.array([exat['phasex']/2.0,exat['phasey']/2.0])
    else:
        shift=sc.array([exat['phase_shift_x']/2.0,exat['phase_shift_y']/2.0])
    phi=exat['phi']
    neel=exat['neel']
    qx,qy,Sq=GetSq(gsfile)
    kx,ky=sf.fermisea(L,L,shift)
    qidx=ml.find((qx==q[0])*(qy==q[1]))
    if O==None:
        _,O,_,_=GetEigSys(excfile,Nsamp)
    pk=None
    sqq=None
    if channel==None:
        channel=exat['channel']
    if channel=='trans':
        pk=sc.squeeze(sf.phiktrans(kx,ky,q[0]/L,q[1]/L,[phi,neel]))
        sqq=sc.real(0.5*(Sq[0,1,qidx]+Sq[0,2,qidx]))
    elif channel=='long':
        pkup=sc.squeeze(sf.phiklong(kx,ky,q[0]/L,q[1]/L,1,[phi,neel]))
        pkdo=sc.squeeze(sf.phiklong(kx,ky,q[0]/L,q[1]/L,-1,[phi,neel]))
        if (q[0]/L==0.5 and q[1]/L==0.5) or (q[0]/L==0 and q[1]/L==0):
            pk=sc.zeros(2*sc.shape(pkup)[0]+1,complex)
        else:
            pk=sc.zeros(2*sc.shape(pkup)[0],complex)
        pk[0:2*sc.shape(pkup)[0]:2]=pkup
        pk[1:2*sc.shape(pkdo)[0]:2]=pkdo
        if (qx[0]/L==0.5 and q[1]/L==0.5) or (q[0]/L==0 and q[1]/L==0):
            if neel==0:
                pk[-1]=0
            else:
                pk[-1]=sum(neel/sf.omega(kx,ky,[phi,neel]))
        sqq=Sq[0,0,qidx]
    else:
        raise(InputFileError('In file \''+excfile+'\', channel=\''+str(channel)+'\'. Should be \'trans\' or \'long\''))
    sqe=sc.einsum('i,jik,k->j',sc.conj(pk),O,pk)
    out=sc.zeros(Nsamp)
    for n in range(Nsamp):
        if abs(sqq)<1e-6 or abs(sqe[n])<1e-6:
            warnings.warn('Probably ill-defined renormalization, returns 1 for sample {0} out of {1}'.format(n,Nsamp),UserWarning)
            out[n]=1
        else:
            out[n]=sc.real(sqq/sqe[n])
    return out
Esempio n. 14
0
def predictor_step(phi,args,direction):
    assert abs(direction)==1
    
    Q = field_to_quasidensity(phi,args.L)
    Lambda = sp.exp(-args.t)*args.Delta + diags(Q,0)
    rho = sp.real(spsolve(Lambda, args.R-Q))
    
    delta_t = direction*args.epsilon/sp.real(sp.sqrt(sp.sum(rho*Q*rho)))
    delta_phi = phi + delta_t*rho
    
    return [delta_phi, delta_t]
Esempio n. 15
0
	def grad(self, A, B, q):
		#Compute relative transformation
		pr = norm(q.x)
		
		if(pr >= A.radius + B.radius ):
			return array([0., 0., 0., 0.])
		
		#Load shape parameters
		fa  = A.pft
		fb  = B.pft
		da  = A.pdft
		db  = B.pdft
		ea 	= A.energy
		eb 	= B.energy
		
		#Estimate cutoff threshold
		cutoff = self.__get_cutoff(A, B)
		
		#Compute coordinate coefficients
		m   = 2.j * pi / (2. * self.SHAPE_R + 1) * pr
		phi = atan2(q.x[1], q.x[0])
		
		#Set up initial sums
		s_0	 = real(fa[0][0] * fb[0][0])
		s_x  = 0.
		s_y  = 0.
		s_ta = 0.
		s_tb = 0.
		
		for r in range(1, self.R):
		
			#Compute theta terms
			dtheta = 2. * pi / len(fa[r])
			theta  = arange(len(fa[r])) * dtheta
		
			#Construct multiplier / v
			mult = exp((m * r) * cos(theta + phi)) * r * dtheta
			u 	 = pds.shift(conjugate(fb[r]), q.theta) * mult
			v 	 = fa[r] * u
			
			#Check for early out
			s_0  += sum(real(v))
			if(s_0 + min(ea[r], eb[r]) <= cutoff):
				return array([0.,0.,0.,0.])
				
			#Sum up gradient vectors
			v     = real(1.j * v)
			s_x  -= sum(v * sin(theta + phi) )
			s_y  -= sum(v * cos(theta + phi) )
			s_t  += sum(real(da[r] * u))
		
		if(s_0 <= cutoff):
			return array([0., 0., 0., 0.])
		return array([s_x, s_y, s_ta, s_tb, s_0])
Esempio n. 16
0
def wigner(psi,xvec,yvec,g=sqrt(2)):
    """Wigner function for a state vector or density matrix 
    at points xvec+i*yvec.
    
    Parameters
    ----------
    state : qobj 
        A state vector or density matrix.
    
    xvec : array_like
        x-coordinates at which to calculate the Wigner function.
    
    yvec : array_like
        y-coordinates at which to calculate the Wigner function.
        
    g : float
        Scaling factor for a = 0.5*g*(x+iy), default g=sqrt(2).
    
    Returns
    --------
    W : array
        Values representing the Wigner function calculated over the specified range [xvec,yvec].
    
    
    """
    if psi.type=='ket' or psi.type=='oper':
        M=prod(psi.shape[0])
    elif psi.type=='bra':
        M=prod(psi.shape[1])
    else:
        raise TypeError('Input state is not a valid operator.')
    X,Y = meshgrid(xvec, yvec)
    amat = 0.5*g*(X + 1.0j*Y)
    wmat=zeros(shape(amat))
    Wlist=array([zeros(shape(amat),dtype=complex) for k in range(M)])
    Wlist[0]=exp(-2.0*abs(amat)**2)/pi
    if psi.type=='ket' or psi.type=='bra':
        psi=ket2dm(psi)
    wmat=real(psi[0,0])*real(Wlist[0])
    for n in range(1,M):
        Wlist[n]=(2.0*amat*Wlist[n-1])/sqrt(n)
        wmat+= 2.0*real(psi[0,n]*Wlist[n])
    for m in range(M-1):
        temp=copy(Wlist[m+1])
        Wlist[m+1]=(2.0*conj(amat)*temp-sqrt(m+1)*Wlist[m])/sqrt(m+1)
        for n in range(m+1,M-1):
            temp2=(2.0*amat*Wlist[n]-sqrt(m+1)*temp)/sqrt(n+1)
            temp=copy(Wlist[n+1])
            Wlist[n+1]=temp2
        wmat+=real(psi[m+1,m+1]*Wlist[m+1])
        for k in range(m+2,M):
            wmat+=2.0*real(psi[m+1,k]*Wlist[k])
    return 0.5*wmat*g**2
Esempio n. 17
0
def sliceFieldArr(Ein,NX,NY,NZ,SliceX,SliceY,SliceZ,figNum,fieldName):
    """ Visualizing field with slices 
    """
    vxy1=Ein[:,:,SliceZ,0]
    vxy2=Ein[:,:,SliceZ,1]
    vxy3=Ein[:,:,SliceZ,2]
    vyz1=Ein[SliceX,:,:,0]
    vyz2=Ein[SliceX,:,:,1]
    vyz3=Ein[SliceX,:,:,2]
    vxz1=Ein[:,SliceY,:,0]
    vxz2=Ein[:,SliceY,:,1]
    vxz3=Ein[:,SliceY,:,2]
    plt.ion()
    fig=plt.figure(figNum)
    fig.clear()
    plt.subplot(331)
    plt.imshow(sci.real(vxy1))
    plt.title('real($'+fieldName+'_{x}$), xy-plane')
    plt.colorbar()
    plt.subplot(332)
    plt.imshow(sci.real(sci.swapaxes(vxz1,0,1)))
    plt.title('real($'+fieldName+'_{x}$), xz-plane')
    plt.colorbar()
    plt.subplot(333)
    plt.imshow(sci.real(sci.swapaxes(vyz1,0,1)))
    plt.title('real($'+fieldName+'_{x}$), yz-plane')
    plt.colorbar()
    plt.subplot(334)
    plt.imshow(sci.real(vxy2))
    plt.title('real($'+fieldName+'_{y}$), xy-plane')
    plt.colorbar()
    plt.subplot(335)
    plt.imshow(sci.real(sci.swapaxes(vxz2,0,1)))
    plt.title('real($'+fieldName+'_{y}$), xz-plane')
    plt.colorbar()
    plt.subplot(336)
    plt.imshow(sci.real(sci.swapaxes(vyz2,0,1)))
    plt.title('real($'+fieldName+'_{y}$), yz-plane')
    plt.colorbar()
    plt.subplot(337)
    plt.imshow(sci.real(vxy3))
    plt.title('real($'+fieldName+'_{z}$), xy-plane')
    plt.colorbar()
    plt.subplot(338)
    plt.imshow(sci.real(sci.swapaxes(vxz3,0,1)))
    plt.title('real($'+fieldName+'_{z}$), xz-plane')
    plt.colorbar()
    plt.subplot(339)
    plt.imshow(sci.real(sci.swapaxes(vyz3,0,1)))
    plt.title('real($'+fieldName+'_{z}$), yz-plane')
    plt.colorbar()
    
    fig.canvas.draw()
    plt.ioff()
    
    return
Esempio n. 18
0
def _wigner_laguerre(rho, xvec, yvec, g, parallel):
    """
    Using Laguerre polynomials from scipy to evaluate the Wigner function for
    the density matrices :math:`|m><n|`, :math:`W_{mn}`. The total Wigner
    function is calculated as :math:`W = \sum_{mn} \\rho_{mn} W_{mn}`.
    """

    M = np.prod(rho.shape[0])
    X, Y = meshgrid(xvec, yvec)
    A = 0.5 * g * (X + 1.0j * Y)
    W = zeros(np.shape(A))

    # compute wigner functions for density matrices |m><n| and
    # weight by all the elements in the density matrix
    B = 4 * abs(A) ** 2
    if sp.isspmatrix_csr(rho.data):
        # for compress sparse row matrices
        if parallel:
            iterator = (
                (m, rho, A, B) for m in range(len(rho.data.indptr) - 1))
            W1_out = parfor(_par_wig_eval, iterator)
            W += sum(W1_out)
        else:
            for m in range(len(rho.data.indptr) - 1):
                for jj in range(rho.data.indptr[m], rho.data.indptr[m + 1]):
                    n = rho.data.indices[jj]

                    if m == n:
                        W += real(rho[m, m] * (-1) ** m * genlaguerre(m, 0)(B))

                    elif n > m:
                        W += 2.0 * real(rho[m, n] * (-1) ** m *
                                        (2 * A) ** (n - m) *
                                        sqrt(factorial(m) / factorial(n)) *
                                        genlaguerre(m, n - m)(B))
    else:
        # for dense density matrices
        B = 4 * abs(A) ** 2
        for m in range(M):
            if abs(rho[m, m]) > 0.0:
                W += real(rho[m, m] * (-1) ** m * genlaguerre(m, 0)(B))
            for n in range(m + 1, M):
                if abs(rho[m, n]) > 0.0:
                    W += 2.0 * real(rho[m, n] * (-1) ** m *
                                    (2 * A) ** (n - m) *
                                    sqrt(factorial(m) / factorial(n)) *
                                    genlaguerre(m, n - m)(B))

    return 0.5 * W * g ** 2 * np.exp(-B / 2) / pi
Esempio n. 19
0
def istft(X, chunk_size, hop, w=None):
    """
    Naively inverts the short time fourier transform using an overlap and add
    method. The overlap is defined by hop

    Args:
      X: STFT windows to invert, overlap and add. 
      chunk_size: size of analysis window.
      hop: hop distance between analysis windows
      w: windowing function to apply. Must be of length chunk_size

    Returns:
      ISTFT of X using an overlap and add method. Windowing used to smooth.

    Raises:
      ValueError if window w is not of size chunk_size
    """

    if not w:
        w = sp.hanning(chunk_size)
    else:
        if len(w) != chunk_size:
            raise ValueError("window w is not of the correct length {0}.".format(chunk_size))

    x = sp.zeros(len(X) * (hop))
    i_p = 0
    for n, i in enumerate(range(0, len(x)-chunk_size, hop)):
        x[i:i+chunk_size] += w*sp.real(sp.ifft(X[n]))
    return x
Esempio n. 20
0
 def __init__(self, output='out', input='in', \
              mag=None, phase=None, coh=None, \
              freqlim=[], maglim=[], phaselim=[], \
              averaged='not specified', \
              seedfreq=-1, seedphase=0,
              labels=[], legloc=-1, compin=[]):
     self.output = output
     self.input = input
     if len(compin) > 0:
        if mag is None:
           self.mag = squeeze(colwise(abs(compin)))
        if phase is None:
           self.phase = squeeze(colwise(arctan2(imag(compin),real(compin))*180.0/pi))
     else:
         self.mag = squeeze(mag)
         self.phase = squeeze(phase)
     self.coh = coh
     self.averaged = averaged
     self.seedfreq = seedfreq
     self.seedphase = seedphase
     self.freqlim = freqlim
     self.maglim = maglim
     self.phaselim = phaselim
     self.labels = labels
     self.legloc = legloc
Esempio n. 21
0
 def bulk_bands_calculator(self,s,sub,kx,ky,kz):
   ''' Calculate the band energies for the specified kx, ky, and kz values.
       The 3x3 Hamiltonian for wurtzite crystals is used for the valence,
       while a 1x1 Hamiltonian is used for the conduction band. The model is
       from the chapter by Vurgaftman and Meyer in the book by Piprek. 
   '''
   E = scipy.zeros((4,len(s.Eg0)))   
   E[0,:] = s.Eg0+s.delcr+s.delso/3+\
               hbar**2/(2*s.mepara)*(kx**2+ky**2)+\
               hbar**2/(2*s.meperp)*(kz**2)+\
               (s.a1+s.D1)*s.epszz+(s.a2+s.D2)*(s.epsxx+s.epsyy)
   L = hbar**2/(2*m0)*(s.A1*kz**2+s.A2*(kx+ky)**2)+\
       s.D1*s.epszz+s.D2*(s.epsxx+s.epsyy)
   T = hbar**2/(2*m0)*(s.A3*kz**2+s.A4*(kx+ky)**2)+\
       s.D3*s.epszz+s.D4*(s.epsxx+s.epsyy)
   F = s.delcr+s.delso/3+L+T
   G = s.delcr-s.delso/3+L+T
   K = hbar**2/(2*m0)*s.A5*(kx+1j*ky)**2+s.D5*(s.epsxx-s.epsyy)
   H = hbar**2/(2*m0)*s.A6*(kx+1j*ky)*kz+s.D6*(s.epsxz)
   d = scipy.sqrt(2)*s.delso/3
   for ii in range(len(s.Eg0)):
     mat = scipy.matrix([[    F[ii],     K[ii],       -1j*H[ii]      ],
                         [    K[ii],     G[ii],       -1j*H[ii]+d[ii]],
                         [-1j*H[ii], -1j*H[ii]+d[ii],     L[ii]      ]])
     w,v = scipy.linalg.eig(mat)
     E[1:,ii] = scipy.flipud(scipy.sort(scipy.real(w)))
   return E
Esempio n. 22
0
def gabor2d(gsw, gsh, gx0, gy0, wfreq, worient, wphase, shape):
    """ Generate a gabor 2d array
    
    Inputs:
      gsw -- standard deviation of the gaussian envelope (width)
      gsh -- standard deviation of the gaussian envelope (height)
      gx0 -- x indice of center of the gaussian envelope
      gy0 -- y indice of center of the gaussian envelope
      wfreq -- frequency of the 2d wave
      worient -- orientation of the 2d wave
      wphase -- phase of the 2d wave
      shape -- shape tuple (height, width)

    Outputs:
      gabor -- 2d gabor with zero-mean and unit-variance

    """
    
    height, width = shape
    y, x = N.mgrid[0:height, 0:width]
    
    X = x * N.cos(worient) * wfreq
    Y = y * N.sin(worient) * wfreq
	
    env = N.exp( -.5 * ( ((x-gx0)**2./gsw**2.) + ((y-gy0)**2./gsh**2.) ) )
    wave = N.exp( 1j*(2*N.pi*(X+Y) + wphase) )
    gabor = N.real(env * wave)
    
    gabor -= gabor.mean()
    gabor /= fastnorm(gabor)
    
    return gabor
Esempio n. 23
0
    def calc_a_coef(self):
        a = self.a
        nu = self.nu
        k = self.k
        arc_R = self.arc_R
        M = self.M

        fft_a_coef = self.get_expected_a_coef()

        if self.acheat:
            self.a_coef = fft_a_coef
        else:
            eval_phi0 = self.problem.eval_phi0

            def eval_bc0(th):
                r = self.boundary.eval_r(th)
                return eval_phi0(th) - self.v_interp(r, th)

            a_coef, singvals = abcoef.calc_a_coef(self.problem,
                self.boundary, eval_bc0, self.M, self.problem.get_m1())

            self.a_coef = a_coef

            np.set_printoptions(precision=4)
            if self.boundary.name == 'arc':
                error = np.abs(self.a_coef - fft_a_coef)
                print('a_coef error:', error)
                print()
            elif self.problem.name == 'iz-bessel':
                print('a_coef:', scipy.real(a_coef))
                print()
Esempio n. 24
0
def HolsteinPrimakoff( generation, lattice = "cactus", periodic = True ):
    """
    Given a generation we want to build the cactus out to construct the matrix
    and return the eigenvalues.  We will do this in the semi-roundabout way
    proposed by Mucciolo, Castro Neto, and Chamon in PRB 69 (214424), so what
    is returned is the true eigenspectrum and an eigenvalue matrix representing
    the rotations of a boguliobov-type transformation.
    """
    if lattice == "cactus":
        H = HusimiHamiltonian( generation, periodic )
    elif lattice == "triangle":
        H = TriangleHamiltonian( generation )
    else:
        raise ValueError, "Options are 'cactus' and 'triangle'"
        
    l = H.shape[0] / 2
    K = H[:l, :l]
    L = H[:l, l:]
    
    squaredDiff = scipy.dot(K, K) - scipy.dot(L, L)
    commutator = scipy.dot(L,K) - scipy.dot(K,L)
    
    if scipy.sum(commutator) == 0.0:
        eigVals, eigVects = scipy.linalg.eigh( squaredDiff )
    else:
        eigVals, eigVects = scipy.linalg.eig( squaredDiff - commutator )
    
    #   The 'real' is not a cheat -- zero values could be negative as a result
    #   of roundoff, this takes that into account.
    eigVals = scipy.real( scipy.sqrt( eigVals ) )
    
    return eigVals, eigVects
Esempio n. 25
0
def construct(phi1, phi2, nomod = 0, amp1 =[], amp2=[], eta = 0, ampout= 0): #does ampout need to be there?
	if len(amp1) > 0 or len(amp2) > 0:
		tempshape = phi1.shape
		w = tempshape[1]
		h = tempshape[0]
		if len(amp1) == 0:
			temp1 = np.ones(w)
			temp2 = np.ones(h)
			for r in temp2:
				amp1 += [temp1]
		if len(amp2) == 0:
			temp1 = np.ones(w)
			temp2 = np.ones(h)
			for r in temp2:
				amp2 += [temp1]
		psi1 = amp1 * np.exp(1j*phi1)
		psi2 = amp2 * np.exp(1j*phi2)
		psi = psi1 * psi2
		psi = np.array(psi)
		apsi = abs(psi)
		psi = psi/(np.amax(abs(psi)))
		phi = np.arctan2(sp.real(psi),sp.imag(psi))
		phi -= np.amin(phi)
		phi = phi % (2.*np.pi)
		eta = 2*np.median(abs(psi))
		randarray = np.array([[random.random() for i in range(w)] for j in range(h)])
		shape = (abs(psi) >= (eta*randarray)) 
		index = np.where(shape == False)
		phi[index] = 0
		ampout = abs(psi)
	else:
		phi = phi1 + phi2
		phi = phi - np.amin(phi)
		phi = phi % (2.*np.pi)
	return phi
def bb_step(sys,X0=None,Tf=None,Ts=0.001):
    """Plot the step response of the continous system sys

    Call:
    y=bb_step(sys [,Tf=final time] [,Ts=time step])

    Parameters
    ----------
    sys : Continous System in State Space form
    X0: Initial state vector (not used yet)
    Ts  : sympling time
    Tf  : Final simulation time
 
    Returns
    -------
    Nothing

    """
    if Tf==None:
        vals = eigvals(sys.A)
        r = min(abs(real(vals)))
        if r < 1e-10:
            r = 0.1
        Tf = 7.0 / r
    sysd=c2d(sys,Ts)
    dstep(sysd,Tf=Tf)
Esempio n. 27
0
def fidelity(A,B):
    """
    Calculates the fidelity (pseudo-metric) between two density matricies.
    See: Nielsen & Chuang, "Quantum Computation and Quantum Information"
    
    Parameters
    ----------
    A : qobj
        Density matrix
    B : qobj 
        Density matrix with same dimensions as A.
    
    Returns
    -------
    fid : float
        Fidelity pseudo-metric between A and B.
    
    Examples
    --------
    >>> x=fock_dm(5,3)
    >>> y=coherent_dm(5,1)
    >>> fidelity(x,y)
    0.24104350624628332
        
    """
    if A.dims!=B.dims:
        raise TypeError('Density matricies do not have same dimensions.')
    else:
        A=A.sqrtm()
        return float(real((A*(B*A)).sqrtm().tr()))
Esempio n. 28
0
def _par_wig_eval(args):
    """
    Private function for calculating terms of Laguerre Wigner function in parfor.
    """
    m,rho,A,B=args
    W1 = zeros(shape(A))
    for jj in range(rho.data.indptr[m], rho.data.indptr[m+1]):        
        n = rho.data.indices[jj]

        if m == n:
            W1 += real(rho[m,m] * (-1)**m * genlaguerre(m,0)(B))

        elif n > m:
            W1 += 2.0 * real(rho[m,n] * (-1)**m * (2*A)**(n-m) * \
                 sqrt(factorial(m)/factorial(n)) * genlaguerre(m,n-m)(B))
    return W1
Esempio n. 29
0
def KramersKronigFFT(ImX_A):
	'''	Hilbert transform used to calculate real part of a function from its imaginary part
	uses piecewise cubic interpolated integral kernel of the Hilbert transform
	use only if len(ImX_A)=2**m-1, uses fft from scipy.fftpack  '''
	X_A = sp.copy(ImX_A)
	N = int(len(X_A))
	## be careful with the data type, orherwise it fails for large N
	if N > 3e6: A = sp.arange(3,N+1,dtype='float64')
	else:       A = sp.arange(3,N+1)  
	X1 = 4.0*sp.log(1.5)
	X2 = 10.0*sp.log(4.0/3.0)-6.0*sp.log(1.5)
	## filling the kernel
	if N > 3e6: Kernel_A = sp.zeros(N-2,dtype='float64')
	else:       Kernel_A = sp.zeros(N-2)
	Kernel_A = (1-A**2)*((A-2)*sp.arctanh(1.0/(1-2*A))+(A+2)*sp.arctanh(1.0/(1+2*A)))\
	+((A**3-6*A**2+11*A-6)*sp.arctanh(1.0/(3-2*A))+(A+3)*(A**2+3*A+2)*sp.arctanh(1.0/(2*A+3)))/3.0
	Kernel_A = sp.concatenate([-sp.flipud(Kernel_A),sp.array([-X2,-X1,0.0,X1,X2]),Kernel_A])/sp.pi
	## zero-padding the functions for fft
	ImXExt_A = sp.concatenate([X_A[int((N-1)/2):],sp.zeros(N+2),X_A[:int((N-1)/2)]])
	KernelExt_A = sp.concatenate([Kernel_A[N:],sp.zeros(1),Kernel_A[:N]])
	## performing the fft
	ftReXExt_A = -fft(ImXExt_A)*fft(KernelExt_A)
	ReXExt_A = sp.real(ifft(ftReXExt_A))
	ReX_A = sp.concatenate([ReXExt_A[int((3*N+3)/2+1):],ReXExt_A[:int((N-1)/2+1)]])
	return ReX_A
def acker(A,B,poles):
    """Pole placemenmt using Ackermann method

    Call:
    k=acker(A,B,poles)

    Parameters
    ----------
    A, B : State and input matrix of the system
    poles: desired poles

    Returns
    -------
    k: matrix
    State feedback gains

    """
    a=mat(A)
    b=mat(B)
    p=real(poly(poles))
    ct=ctrb(A,B)
    if det(ct)==0:
        k=0
        print "Pole placement invalid"
    else:
        n=size(p)
        pmat=p[n-1]*a**0
        for i in arange(1,n):
            pmat=pmat+p[n-i-1]*a**i
        k=inv(ct)*pmat
        k=k[-1][:]
    return k
Esempio n. 31
0
 def export(self, filename):
     # Casting as reals and absolute maximum?
     scaled = sp.real(self.wave)
     scaled = sp.int16(scaled * 32676. / scaled.max())
     wavfile.write(filename, self.rate, scaled)
Esempio n. 32
0
 def real_func(x):
     return real(func(x))
Esempio n. 33
0
def computePCA(matrix=None):
    #compute eigen values and vectors
    [eigen_values, eigen_vectors] = linalg.eig(matrix)
    #sort eigen vectors in decreasing order based on eigen values
    indices = sp.argsort(-eigen_values)
    return [sp.real(eigen_values[indices]), eigen_vectors[indices]]
import matplotlib.pyplot as plt
import scipy
from SloppyCell.ReactionNetworks import *
from geodesic import geodesic, InitialVelocity

import model18_fit

x = np.log(model18_fit.popt)

# Calculate jtj approximation to hessian (in log params) and plot eigenvalue
# spectrum
j = model18_fit.m.jacobian_log_params_sens(np.log(model18_fit.popt))
jtj = np.dot(np.transpose(j), j)
np.savetxt('hessian18.dat', jtj)
e, v = Utility.eig(jtj)
e = scipy.real(e)
Plotting.figure(1)
l = Plotting.plot_eigval_spectrum(e, offset=0.15, widths=0.7, lw=2)

## Reduce

func = lambda logp: np.array(model18_fit.m.res_log_params(logp))
jacobian = lambda logp: np.array(
    model18_fit.m.jacobian_log_params_sens(logp).values())

M = jacobian(x).shape[0]
N = jacobian(x).shape[1]
print(M)
print(N)

Esempio n. 35
0
def tdo_fft(inputfile, outputfile):
    ''' Perform Fourier transform and return frequency evolution '''
    # Input parameters
    fourier_le = 1024  # Fourier length
    time_le = 1024  # timewindow
    dfmin = 0.01  # Frequency resolution
    dt = 2e-8  # timestep of acquisition
    load_balancing = 1

    # Lecture du fichier
    fid = open(inputfile, 'rb')
    fid.seek(512)  # Skip useless header
    V = fromfile(fid, int16, -1, '')
    fid.close()

    pstart = 1  # First timewindow
    pend = int(floor(
        (len(V) - 4 * fourier_le) / time_le)) + 1  # Last timewindow

    t = arange(0, fourier_le) * dt

    # Approximation of main frequency
    Vf = abs(real(fft(V[0:fourier_le])))
    tf = fftfreq(fourier_le, dt)
    fmax = zeros((pend + 2 - pstart, 2))
    fmax[0, 1] = tf[argmax(Vf[0:int(fourier_le / 2)])]
    fmax[0, 0] = time_le * dt / 2

    # Calculation of constants
    expon = -2j * pi * t
    deltaf0 = tf[1] / 1000
    if deltaf0 < dfmin:
        deltaf0 = 10 * dfmin

    # Start jobs
    job_server = pp.Server()
    ncpus = int(job_server.get_ncpus())

    serv_jobs = []

    # Load-balancing
    # Last processes are faster
    # If nprocess = ncpus, half of the core remains mostly idle
    if load_balancing == 1:
        nprocess = ncpus * 4
    else:
        nprocess = ncpus

    pstart_b = pstart
    for i in range(0, nprocess):
        if nprocess == 1:
            pend_b = pend
        else:
            pend_b = int(pstart_b + floor(pend / nprocess))

        print(pstart_b, pend_b)

        args_tuple = (pstart_b, pend_b+1, \
        V[pstart_b*time_le:(pend_b+1)*time_le+fourier_le], \
        dt, dfmin, deltaf0, expon, fourier_le, time_le,)

        serv_jobs.append(job_server.submit(find_freq, args_tuple, \
        (local_trapz,)))

        pstart_b = pend_b

    pstart_b = pstart
    for i in range(0, nprocess):
        if nprocess == 1:
            pend_b = pend
        else:
            pend_b = int(pstart_b + floor(pend / nprocess))

        fmax[pstart_b:pend_b, :] = serv_jobs[i]()
        pstart_b = pend_b

    # Save calculation in file
    savetxt(outputfile, fmax)
    job_server.print_stats()
Esempio n. 36
0
def find_freq(ps, pe, V, dt, dfmin, deltaf0, expon, fourier_le, time_le):
    '''Perform DFT of signal and return main frequency'''
    from scipy import zeros, real, fft, argmax, exp, arange, cos, pi, mean
    from scipy.fftpack import fftfreq

    Vf = abs(real(fft(V[0:fourier_le] - mean(V[0:fourier_le]))))
    tf = fftfreq(fourier_le, dt)
    fmax = zeros((pe - ps, 2))
    fmax[0, 1] = tf[argmax(Vf[0:int(fourier_le / 2)])]
    fmax[0, 0] = (ps * time_le + fourier_le / 2) * dt

    # Rectangular
    #window  =  ones(fourier_le)
    # Cosinus
    window = arange(0, fourier_le)
    window = 1 - cos(window * 2 * pi / (fourier_le - 1))

    for i in xrange(1, pe - ps):
        # Utilisation de la dernière valeur comme point de depart
        a = fmax[i - 1, 1]
        V_temp = window * V[i * time_le:i * time_le + fourier_le]

        # Previous frequency spectral weight
        # Complex exponential time consuming
        # Need a smarter way to perform this calculations
        deltaf = deltaf0
        essaimax = abs(local_trapz(V_temp * exp(expon * a)))

        # Calculation of local derivative of Fourier transform
        # If derivative positive, then search for frequency in growing direction
        if abs(local_trapz(V_temp * exp(expon * (a + deltaf)))) > essaimax:
            while abs(deltaf) > dfmin:
                F = abs(local_trapz(V_temp * exp(expon * (a + deltaf))))
                if F > essaimax:
                    essaimax = F
                    a += deltaf
                else:
                    deltaf = -deltaf / 5
                    if (abs(deltaf) < dfmin) and (abs(deltaf) > dfmin * 4.9):
                        deltaf = deltaf / abs(deltaf) * 1.01 * dfmin

            # Store frequency
            fmax[i, 0:2] = [((i + ps) * time_le + fourier_le / 2) * dt,
                            a - 2.5 * deltaf]
        # Lower frequency otherwise
        else:
            while abs(deltaf) > dfmin:
                F = abs(local_trapz(V_temp * exp(expon * (a - deltaf))))
                if F > essaimax:
                    essaimax = F
                    a -= deltaf
                else:
                    deltaf = -deltaf / 5
                    if (abs(deltaf) < dfmin) and (abs(deltaf) > dfmin * 4.9):
                        deltaf = deltaf / abs(deltaf) * 1.01 * dfmin

            # Store frequency
            fmax[i, 0:2] = [((i + ps) * time_le + fourier_le / 2) * dt,
                            a + 2.5 * deltaf]

    return fmax[1:, :]
Esempio n. 37
0
def preproc():
    img = cv2.imread('5DnwY.jpg', 0)
    # Number of rows and columns
    [cols, rows] = img.shape

    # Remove some columns from the beginning and end
    img = img[:, 59:cols - 20]

    # Convert image to 0 to 1, then do log(1 + I)
    imgLog = np.log1p(np.array(img, dtype="float") / 255)

    # Create Gaussian mask of sigma = 10
    M = 2 * rows + 1
    N = 2 * cols + 1
    sigma = 10
    (X, Y) = np.meshgrid(np.linspace(0, N - 1, N), np.linspace(0, M - 1, M))
    centerX = np.ceil(N / 2)
    centerY = np.ceil(M / 2)
    gaussianNumerator = (X - centerX)**2 + (Y - centerY)**2

    # Low pass and high pass filters
    Hlow = np.exp(-gaussianNumerator / (2 * sigma * sigma))
    Hhigh = 1 - Hlow

    # Move origin of filters so that it's at the top left corner to
    # match with the input image

    HlowShift = scipy.fftpack.ifftshift(Hlow.copy())
    HhighShift = scipy.fftpack.ifftshift(Hhigh.copy())

    # Filter the image and crop
    If = scipy.fftpack.fft2(imgLog.copy(), (M, N))
    Ioutlow = scipy.real(scipy.fftpack.ifft2(If.copy() * HlowShift, (M, N)))
    Iouthigh = scipy.real(scipy.fftpack.ifft2(If.copy() * HhighShift, (M, N)))

    # Set scaling factors and add
    gamma1 = 0.3
    gamma2 = 1.5
    Iout = gamma1 * Ioutlow[0:rows, 0:cols] + gamma2 * Iouthigh[0:rows, 0:cols]

    # Anti-log then rescale to [0,1]
    Ihmf = np.expm1(Iout)
    Ihmf = (Ihmf - np.min(Ihmf)) / (np.max(Ihmf) - np.min(Ihmf))
    Ihmf2 = np.array(255 * Ihmf, dtype="uint8")

    # Threshold the image - Anything below intensity 65 gets set to white
    Ithresh = Ihmf2 < 65
    Ithresh = 255 * Ithresh.astype("uint8")

    # Clear off the border.  Choose a border radius of 5 pixels
    Iclear = imclearborder(Ithresh, 5)

    # Eliminate regions that have areas below 120 pixels
    Iopen = bwareaopen(Iclear, 120)

    # Show all images
    cv2.imshow('Original Image', img)
    cv2.imshow('Homomorphic Filtered Result', Ihmf2)
    cv2.imshow('Thresholded Result', Ithresh)
    cv2.imshow('Opened Result', Iopen)
    cv2.waitKey(0)
    cv2.destroyAllWindows()
Esempio n. 38
0
# Initialize vortex
omega, p = nst.vortex_pair(nx, ny, dx, dy)

# Gradient operators in Fourier domain for x- and y-direction
Kx, Ky = nst.Spectral_Gradient(nx, ny, lx, ly)

# 2D Laplace operator and 2D inverse Laplace operator in Fourier domain
K2, K2inv = nst.Spectral_Laplace(nx, ny, Kx, Ky)

# Simulation time
#T_simu = 0.165
T_simu = 0.01

# Set discrete time step by choosing CFL number (condition: CFL <= 1)
CFL = 1
u = sc.real(ifft2(-Ky * K2inv * fft2(omega)))
v = sc.real(ifft2(Kx * K2inv * fft2(omega)))
u_max = sc.amax(sc.absolute(u))
v_max = sc.amax(sc.absolute(v))
t_step = (CFL * dx * dy) / (u_max * dy + v_max * dx)

# Delete (if existent) "Data.txt" before writing new data
if os.path.exists("Data"):
    os.remove("Data")

# Open file
file = open("Data", "ab")

# Start Simulation
t_sum = 0
i = 0
 def real_func(x):
     return scipy.real(func(x))
Esempio n. 40
0
 def real_func(x, y):
     return scipy.real(func(x, y))
Esempio n. 41
0
    m1 = Im1[it_m1]
    # c1 = sp.special.jn(m1, b * x_net) * x_net
    c1 = c1_coefs[it_m1, :]
    for it_h1 in range(len(Ih1)):
        h1 = Ih1[it_h1]
        c2 = c2_coefs[it_h1, :] * c1
        # c2 = sp.special.jn(h1, b * x_net) * c1
        for it_mm in range(len(Imm)):
            mm = Imm[it_mm]
            coef = 2 * np.pi * np.exp(1j * (h1 + mm) * eps)
            # Fm = FBT(pol1, m1+h1+mm, x_net, u_net, theta_net)
            #             Fm_arr[it_m1 + it_h1 + it_mm] = Fm
            Fm = Fm_arr[it_m1 + it_h1 + it_mm]
            Gm = Gm_arr[it_mm]
            func = Fm * np.conj(Gm) * c2
            Tf[it_m1, it_h1, it_mm] = np.trapz(sp.real(func), x_net) \
                                      + 1j*np.trapz(sp.imag(func), x_net)
            Tf[it_m1, it_h1, it_mm] *= coef

# for it_m1 in tqdm.tqdm(range(len(Im1))):
#     m1 = Im1[it_m1]
#     c1 = sp.special.jn(m1, b * x_net) * x_net
#     for it_h1 in range(len(Ih1)):
#         h1 = Ih1[it_h1]
#         # c2 = c2_coefs[it_m1, it_h1, :]
#         c2 = sp.special.jn(h1, b * x_net) * c1
#         for it_mm in range(len(Imm)):
#             mm = Imm[it_mm]
#             coef = 2*np.pi * np.exp(1j*(h1+mm)*eps)
#             # Fm = FBT(pol1, m1+h1+mm, x_net, u_net, theta_net)
# #             Fm_arr[it_m1 + it_h1 + it_mm] = Fm