Пример #1
0
def ks(x, alpha=1, D=1):
    # If x is list, convert to 1d array.
    if (isinstance(x, list)):
        x = pylab.array(x)

    # Length of the output signal must be larger than the length of the
    # input signal that is, D must be larger than 1.
    D = max(D, 1)

    # Number of input samples.
    M = len(x)

    # Create a vector of the powers of alpha, [alpha^0 alpha^1 ....].
    size_alphaVector = D;
    alphaVector = (alpha * pylab.ones(
        size_alphaVector)) ** range(size_alphaVector)

    # Create a matrix with M columns, each being the vector of the powers
    # of alpha.
    alphaMatrix = pylab.tile(alphaVector, (M, 1)).T;

    # Create a matrix with D rows filled by the input signal x.
    xMatrix = pylab.tile(x, (D, 1));

    # Multipliy the two
    yMatrix = alphaMatrix * xMatrix

    # Read out the output row by row
    y = yMatrix.flatten(0)

    return y
Пример #2
0
def magicsq(N):
    """
    copied from internet (lost the source...)
    Creates an N x N magic square.

    **Input:** 
        *N* -- an integer in some form, may be float or quotted.

    **Output:** 
        an ``'int32'`` *N* by *N* array -- the same magic square as in
        Matlab and Octave ``magic(N)`` commands.  In particular, the 
        Siamese method is used for odd *N* (but with a different 
        implementation.)

    """
    from pylab import tile, arange
    global _constant
    n = int(N)
    if n < 0 or n == 2:  # consistent with Octave
        raise TypeError("No such magic squares exist.")
    elif n % 2 == 1:
        m = n >> 1
        b = n * n + 1
        _constant = n * b >> 1
        return (
            tile(arange(1, b, n), n + 2)[m:-m - 1].reshape(n, n + 1)[..., 1:] +
            tile(arange(n), n + 2).reshape(n, n + 2)[..., 1:-1]).transpose()
    elif n % 4 == 0:
        b = n * n + 1
        _constant = n * b >> 1
        d = arange(1, b).reshape(n, n)
        d[0:n:4, 0:n:4] = b - d[0:n:4, 0:n:4]
        d[0:n:4, 3:n:4] = b - d[0:n:4, 3:n:4]
        d[3:n:4, 0:n:4] = b - d[3:n:4, 0:n:4]
        d[3:n:4, 3:n:4] = b - d[3:n:4, 3:n:4]
        d[1:n:4, 1:n:4] = b - d[1:n:4, 1:n:4]
        d[1:n:4, 2:n:4] = b - d[1:n:4, 2:n:4]
        d[2:n:4, 1:n:4] = b - d[2:n:4, 1:n:4]
        d[2:n:4, 2:n:4] = b - d[2:n:4, 2:n:4]
        return d
    else:
        m = n >> 1
        k = m >> 1
        b = m * m
        d = tile(magicsq(m), (2, 2))  # that changes the _constant
        _constant = _constant * 8 - n - m
        d[:m, :k] += 3 * b
        d[m:, k:m] += 3 * b
        d[k, k] += 3 * b
        d[k, 0] -= 3 * b
        d[m + k, 0] += 3 * b
        d[m + k, k] -= 3 * b
        d[:m, m:n - k + 1] += b + b
        d[m:, m:n - k + 1] += b
        d[:m, n - k + 1:] += b
        d[m:, n - k + 1:] += b + b
        return d
Пример #3
0
def magicsq(N):    
    """
    copied from internet (lost the source...)
    Creates an N x N magic square.

    **Input:** 
        *N* -- an integer in some form, may be float or quotted.

    **Output:** 
        an ``'int32'`` *N* by *N* array -- the same magic square as in
        Matlab and Octave ``magic(N)`` commands.  In particular, the 
        Siamese method is used for odd *N* (but with a different 
        implementation.)

    """
    from pylab import tile,arange
    global _constant
    n = int(N)
    if n < 0 or n == 2:                    # consistent with Octave
        raise TypeError("No such magic squares exist.")
    elif n%2 == 1:
        m = n>>1
        b = n*n + 1
        _constant = n*b>>1
        return (tile(arange(1,b,n),n+2)[m:-m-1].reshape(n,n+1)[...,1:]+
              tile(arange(n),n+2).reshape(n,n+2)[...,1:-1]).transpose()
    elif n%4 == 0:
        b = n*n + 1
        _constant = n*b>>1
        d=arange(1, b).reshape(n, n)
        d[0:n:4, 0:n:4] = b - d[0:n:4, 0:n:4]
        d[0:n:4, 3:n:4] = b - d[0:n:4, 3:n:4]
        d[3:n:4, 0:n:4] = b - d[3:n:4, 0:n:4]
        d[3:n:4, 3:n:4] = b - d[3:n:4, 3:n:4]
        d[1:n:4, 1:n:4] = b - d[1:n:4, 1:n:4]
        d[1:n:4, 2:n:4] = b - d[1:n:4, 2:n:4]
        d[2:n:4, 1:n:4] = b - d[2:n:4, 1:n:4]
        d[2:n:4, 2:n:4] = b - d[2:n:4, 2:n:4]
        return d
    else:
        m = n>>1
        k = m>>1
        b = m*m
        d = tile(magicsq(m), (2,2))          # that changes the _constant
        _constant = _constant*8 - n - m     
        d[:m, :k] += 3*b
        d[m:,k:m] += 3*b
        d[ k,  k] += 3*b
        d[ k,  0] -= 3*b
        d[m+k, 0] += 3*b
        d[m+k, k] -= 3*b
        d[:m,m:n-k+1] += b+b
        d[m:,m:n-k+1] += b
        d[:m, n-k+1:] += b
        d[m:, n-k+1:] += b+b
        return d
Пример #4
0
    def classify(self, x, k):
        d = self.X - tile(x.reshape(self.n, 1), self.N)
        dsq = sum(d * d, 0)
        minindex = argmin(dsq)
        temp = argsort(dsq)

        ### Custom code starting here ###

        # Save the data for each class around the point in a array
        score = [0, 0, 0]

        # With the help of k surrounding points score each class
        for x in range(0, k):
            if ((self.c[temp[x]]) == 1.0):
                score[0] += 1
            elif ((self.c[temp[x]]) == 2.0):
                score[1] += 1
            elif ((self.c[temp[x]]) == 3.0):
                score[2] += 1

        # Check to which class the point is classified
        if (score[0] > score[1] and score[0] > score[2]):
            return 1.0
        elif (score[1] > score[2]):
            return 2.0

        # If there are points with the same value, assign the class of the nearest neighbour.
        elif (score[0] == score[1] and score[0] == score[2]):
            return self.c[minindex]
        else:
            return 3.0
Пример #5
0
def ssc(signal,samplerate=16000,winlen=0.025,winstep=0.01,
          nfilt=26,nfft=512,lowfreq=0,highfreq=None,preemph=0.97):
    """Compute Spectral Subband Centroid features from an audio signal.

    :param signal: the audio signal from which to compute features. Should be an N*1 array
    :param samplerate: the samplerate of the signal we are working with.
    :param winlen: the length of the analysis window in seconds. Default is 0.025s (25 milliseconds)    
    :param winstep: the step between successive windows in seconds. Default is 0.01s (10 milliseconds)    
    :param nfilt: the number of filters in the filterbank, default 26.
    :param nfft: the FFT size. Default is 512.
    :param lowfreq: lowest band edge of mel filters. In Hz, default is 0.
    :param highfreq: highest band edge of mel filters. In Hz, default is samplerate/2
    :param preemph: apply preemphasis filter with preemph as coefficient. 0 is no filter. Default is 0.97. 
    :returns: A numpy array of size (NUMFRAMES by nfilt) containing features. Each row holds 1 feature vector. 
    """          
    highfreq= highfreq or samplerate/2
    signal = sigproc.preemphasis(signal,preemph)
    frames = sigproc.framesig(signal, winlen*samplerate, winstep*samplerate)
    pspec = sigproc.powspec(frames,nfft)
    pspec = pylab.where(pspec == 0,pylab.finfo(float).eps,pspec) # if things are all zeros we get problems
    
    fb = get_filterbanks(nfilt,nfft,samplerate,lowfreq,highfreq)
    feat = pylab.dot(pspec,fb.T) # compute the filterbank energies
    R = pylab.tile(pylab.linspace(1,samplerate/2,pylab.size(pspec,1)),(pylab.size(pspec,0),1))
    
    return pylab.dot(pspec*R,fb.T) / feat
Пример #6
0
def _grad_theta(psi, xxx_todo_changeme1):
   """
   Compute the 1D gradient of a scalar field in the theta direction on a unit-
   radius spherical shell.  Assumes psi is a 2D array with theta changing along
   axis 1. We use central differences for interior points, one-sided differences
   for exterior points, and address simple periodic boundaries.
   """
   (phi,theta) = xxx_todo_changeme1
   dphi = p.diff(phi,axis=0)
   dtheta = p.diff(theta,axis=1)


   # pre-allocate output grid
   dpsidtheta = p.zeros(theta.shape)
   
   
   # use weighted central differences to compute theta gradient on the interior
   dpsidtheta[:,1:-1] = (((p.diff(psi[:,:-1],axis=1) / dtheta[:,:-1]**2 +
                           p.diff(psi[:,1:],axis=1) / dtheta[:,1:]**2) /
                          (1/dtheta[:,:-1] + 1/dtheta[:,1:]) ) )

      
   # compute theta gradients at exterior points
   if p.mod(theta[0,0],2*p.pi) == p.mod(theta[0,-1],2*p.pi):
      # use weighted central differences to compute gradient if periodic boundary
      dpsidtheta[:,[0,-1]] = p.tile(((p.diff(psi[:,:2],axis=1) / dtheta[:,0]**2 +
                                      p.diff(psi[:,-2:],axis=1) / dtheta[:,-1]**2) /
                                     (1/dtheta[:,0] + 1/dtheta[:-1]) ), (1,2) )
   else:
      # use one-sided difference to compute gradient if not a periodic boundary
      dpsidtheta[:,-1] = (p.diff(psi[:,-2:],axis=1).T / dtheta[:,-1])
      dpsidtheta[:,0] = (p.diff(psi[:,:2],axis=1).T / dtheta[:,0])
   
   return dpsidtheta
Пример #7
0
 def classify(self, x):
     d = self.X - tile(x.reshape(self.n,1), self.N);
     dsq = sum(d*d,0)
     # Get N nearest neighbors
     minindex = np.argsort(dsq)[0:self.k]
     # Group sum by value
     return Counter(self.c[minindex]).most_common()[0][0]
Пример #8
0
def flica_reorder(output_dir, nmod):

    data_dir = os.path.join(output_dir, '')
    X = []
    for i in range(0, nmod):
        X.append(np.load(data_dir + '/flica_X' + str(i + 1) + '.npy'))
    M = np.load(data_dir + '/flica_result.npz')

    K = len(X)
    R = M['H'].shape[1]
    for k in range(0, K):
        #M.X{k} * diag(M.W{k}.*sqrt( M.H.^2 * makesize(M.lambda{k},[R 1]) * M.DD(k))')]; %#ok<AGROW>
        if np.matrix(M['lambda1'][k]).shape[0] == R:
            tmp = np.dot(np.square(M['H']), M['lambda1'][k])
        else:
            tmp = np.dot(np.square(M['H']), tile(M['lambda1'][k], [R, 1]))
            tmp2 = np.sqrt(np.dot(tmp, M['DD'][k]))
            tmp3 = np.diag(np.multiply(M['W'][k], tmp2))
            tmp4 = np.dot(X[k], np.diag(tmp3))
        if k == 0:
            Xcat = copy.deepcopy(tmp4)
        else:
            Xcat = np.concatenate((Xcat, tmp4))

    weight = np.sum(np.square(Xcat), 0)
    order = np.argsort(weight)
    order = order[::-1]
    weight = weight[order]

    np.save(data_dir + 'new_order.npy', order)
    np.save(data_dir + 'new_weight.npy', weight)

    return order
Пример #9
0
 def feature_scale(M,
                   normalize=False,
                   dbscale=False,
                   norm=False,
                   bels=False):
     """
     ::
     
         Perform mutually-orthogonal scaling operations, otherwise return identity:
           normalize [False]
           dbscale  [False]
           norm      [False]        
     """
     if not (normalize or dbscale or norm or bels):
         return M
     else:
         X = M.copy()  # don't alter the original
         if norm:
             X = X / pylab.tile(pylab.sqrt((X * X).sum(0)), (X.shape[0], 1))
         if normalize:
             X = adb.normalize(X)
         if dbscale or bels:
             X = pylab.log10(X)
             if dbscale:
                 X = 20 * X
     return X
Пример #10
0
def main():
    mu = pl.array([[0], [12], [24], [36]])
    Sigma = pl.array([[3.01602775,  1.02746769, -3.60224613, -2.08792829],
                      [1.02746769,  5.65146472, -3.98616664,  0.48723704],
                      [-3.60224613, -3.98616664, 13.04508284, -1.59255406],
                      [-2.08792829,  0.48723704, -1.59255406,  8.28742469]])

    # The data matrix is created for above mu and Sigma.
    d, U = pl.eig(Sigma)
    L = pl.diagflat(d)
    A = pl.dot(U, pl.sqrt(L))
    X = pl.randn(4, 1000)

    # Y is the data matrix of random samples.
    Y = pl.dot(A, X) + pl.tile(mu, 1000)

    pl.figure(1)
    pl.clf()
    pl.plot(X[0], Y[1], '+', color='#0000FF', label='i=0,j=1')
    pl.plot(X[0], Y[2], '+', color='#FF0000', label='i=0,j=2')
    pl.plot(X[0], Y[3], '+', color='#00FF00', label='i=0,j=3')
    pl.plot(X[1], Y[0], 'x', color='#FFFF00', label='i=1,j=0')
    pl.plot(X[1], Y[2], 'x', color='#00FFFF', label='i=1,j=2')
    pl.plot(X[1], Y[3], 'x', color='#444444', label='i=1,j=3')
    pl.plot(X[2], Y[0], '.', color='#774411', label='i=2,j=0')
    pl.plot(X[2], Y[1], '.', color='#222222', label='i=2,j=1')
    pl.plot(X[2], Y[3], '.', color='#AAAAAA', label='i=2,j=3')
    pl.plot(X[3], Y[0], '+', color='#FFAA22', label='i=3,j=0')
    pl.plot(X[3], Y[1], '+', color='#22AAFF', label='i=3,j=1')
    pl.plot(X[3], Y[2], '+', color='#FFDD00', label='i=3,j=2')
    pl.legend()
    pl.savefig('fig21.png')
Пример #11
0
def plot():
    (        ml_idxs,
        ml_lengths,
        ml_lanes,
        or_idxs,
        capacity,
        w,
        ff,
        j,
        Time,
        Lengths,
        XLengths,
        Lanes,
        density,
        flow, 
        velocity,
        queues,
        dt,
        n,
        m
    ) = scen_output.load()
    rho_crit = pylab.array([fm / vff for fm, vff in zip(capacity, ff)]) * 1000.0
    rho_max = pylab.array(j) * 1000.0
    norm_density = density / pylab.tile(rho_crit, (m, 1)).transpose()
    norm_density_max = density / pylab.tile(rho_max, (m, 1)).transpose()
    norm_flow = flow / (pylab.tile(capacity, (m,1)).transpose() * 3600.0)
    nplots = 2
    mplots = 4
    g = [0]
    def plot_grid(data, title):
        g[0] += 1
        pylab.subplot(nplots, mplots, g[0])
        pylab.pcolormesh(Time, XLengths, data)
        pylab.colorbar()
        pylab.title(title)
        pylab.xlabel("Time (hours)")
        pylab.ylabel("Offset (km)")

    
    plot_grid(density, "Mainline Density (veh / km-lane)")
    plot_grid(queues, "Onramps (veh)")
    plot_grid(flow, "Flow (veh / hour / lane)")
    plot_grid(velocity, "Velocity (km / hr)")
    plot_grid(norm_density, "Ratio over Critical Mainline")
    plot_grid(norm_density_max, "Ratio over Max Mainline")
    plot_grid(norm_flow, "Ratio over Capacity Flow")
    pylab.show()
Пример #12
0
 def raytrace (self, uv, lam=1):
     uvMat = np.atleast_2d (uv)
     if uvMat.shape[0] == 1:
         uvMat = uvMat.T
     npts = uvMat.shape[1]
     invPx = self.pinvP.dot (homogeneous.homogenize (uvMat))
     XLambda = invPx + pl.tile (lam*homogeneous.homogenize (self.C), (npts, 1)).T
     return homogeneous.dehomogenize (XLambda)
Пример #13
0
def translate_back(outputs,threshold=0.7,pos=0):
    """Translate back. Thresholds on class 0, then assigns
    the maximum class to each region."""
    # print outputs
    labels,n = measurements.label(outputs[:,0]<threshold)
    mask = tile(labels.reshape(-1,1), (1,outputs.shape[1]))
    maxima = measurements.maximum_position(outputs,mask,arange(1,amax(mask)+1))
    if pos: return maxima
    return [c for (r,c) in maxima]
Пример #14
0
 def raytrace(self, uv, lam=1):
     uvMat = np.atleast_2d(uv)
     if uvMat.shape[0] == 1:
         uvMat = uvMat.T
     npts = uvMat.shape[1]
     invPx = self.pinvP.dot(homogeneous.homogenize(uvMat))
     XLambda = invPx + pl.tile(lam * homogeneous.homogenize(self.C),
                               (npts, 1)).T
     return homogeneous.dehomogenize(XLambda)
Пример #15
0
def translate_back(outputs,threshold=0.7,pos=0):
    """Translate back. Thresholds on class 0, then assigns
    the maximum class to each region."""
    # print outputs
    labels,n = measurements.label(outputs[:,0]<threshold)
    mask = tile(labels.reshape(-1,1), (1,outputs.shape[1]))
    maxima = measurements.maximum_position(outputs,mask,arange(1,amax(mask)+1))
    if pos: return maxima
    return [c for (r,c) in maxima]
Пример #16
0
def translate_back(outputs, threshold=0.7, pos=0):
    labels, n = measurements.label(outputs[:, 0] < threshold)
    mask = tile(labels.reshape(-1, 1), (1, outputs.shape[1]))
    maxima = measurements.maximum_position(outputs, mask,
                                           arange(1,
                                                  amax(mask) + 1))
    if pos == 1:
        return maxima
    if pos == 2:
        return [(c, outputs[r, c]) for (r, c) in maxima]
    return [c for (r, c) in maxima]
Пример #17
0
def mi(x,y, bins=11):
    """Given two arrays x and y of equal length, return their mutual information in bits
    """
    Hxy, xe, ye = pylab.histogram2d(x,y,bins=bins)
    Hx = Hxy.sum(axis=1)
    Hy = Hxy.sum(axis=0)
    Pxy = Hxy/float(x.size)
    Px = Hx/float(x.size)
    Py = Hy/float(x.size)
    pxy = Pxy.ravel()
    px = Px.repeat(Py.size)
    py = pylab.tile(Py, Px.size)
    idx = pylab.find((pxy > 0) & (px > 0) & (py > 0))
    return (pxy[idx]*pylab.log2(pxy[idx]/(px[idx]*py[idx]))).sum()
Пример #18
0
	def classify(self, x, k):
		d = self.X - tile(x.reshape(self.n,1), self.N)
		
		# Occurrence of a class
		occd = {}
		for i in range(k):
			dsq = sum(d*d,0)
			minindex = argmin(dsq)
			if self.c[minindex] in occd:
				occd[self.c[minindex]] += 1
			else:
				occd[self.c[minindex]] = 1
			# Prevent next iter giving this index again
			d[:, minindex] = self.max + 1

		# Return the name of the class that occurred most
		return max(occd.iteritems(), key=operator.itemgetter(1))[0]
Пример #19
0
def feature_scale(M, normalize=False, dbscale=False, norm=False, bels=False):
    """
    Perform mutually-orthogonal scaling operations, otherwise return identity:
    normalize [False]
    dbscale [False]
    norm [False]        
    """
    if not (normalize or dbscale or norm or bels):
        return M
    else:
        X = M.copy()  # don't alter the original
        if norm:
            X = X / P.tile(P.sqrt((X * X).sum(0)), (X.shape[0], 1))
        if normalize:
            X = _normalize(X)
        if dbscale or bels:
            X = P.log10(P.clip(X, 0.0001, X.max()))
            if dbscale:
                X = 20 * X
    return X
Пример #20
0
def mutual_information(x,y, bins=11):
  """Given two arrays x and y of equal length, return their mutual information in bits

  >>> N = 10000
  >>> xi = pylab.randn(N)
  >>> xi[pylab.find(xi>0)] = 1
  >>> xi[pylab.find(xi<=0)] = 0
  >>> yi = xi
  >>> print round(mutual_information(xi, yi, 1000),2) #One bit of info
  1.0

  >>> N = 10000
  >>> xi = pylab.uniform(size=N)
  >>> yi = pylab.floor(xi*8)
  >>> print round(mutual_information(xi, yi, 1000),2) #Three bits of info
  3.0

  >>> N = 100000
  >>> xi = pylab.randn(N)
  >>> yi = pylab.randn(N)
  >>> print round(mutual_information(xi, yi),2) #Should be zero given enough data and not too sparse binning
  0.0
  """
  Hxy, xe, ye = pylab.histogram2d(x,y,bins=bins)
  Hx = Hxy.sum(axis=1)
  Hy = Hxy.sum(axis=0)

  Pxy = Hxy/float(x.size)
  Px = Hx/float(x.size)
  Py = Hy/float(x.size)

  pxy = Pxy.ravel()
  px = Px.repeat(Py.size)
  py = pylab.tile(Py, Px.size)

  idx = pylab.find((pxy > 0) & (px > 0) & (py > 0))
  mi = (pxy[idx]*pylab.log2(pxy[idx]/(px[idx]*py[idx]))).sum()

  return mi
Пример #21
0
def mutual_information(x, y, bins=11):
    """Given two arrays x and y of equal length, return their mutual information in bits

  >>> N = 10000
  >>> xi = pylab.randn(N)
  >>> xi[pylab.find(xi>0)] = 1
  >>> xi[pylab.find(xi<=0)] = 0
  >>> yi = xi
  >>> print round(mutual_information(xi, yi, 1000),2) #One bit of info
  1.0

  >>> N = 10000
  >>> xi = pylab.uniform(size=N)
  >>> yi = pylab.floor(xi*8)
  >>> print round(mutual_information(xi, yi, 1000),2) #Three bits of info
  3.0

  >>> N = 100000
  >>> xi = pylab.randn(N)
  >>> yi = pylab.randn(N)
  >>> print round(mutual_information(xi, yi),2) #Should be zero given enough data and not too sparse binning
  0.0
  """
    Hxy, xe, ye = pylab.histogram2d(x, y, bins=bins)
    Hx = Hxy.sum(axis=1)
    Hy = Hxy.sum(axis=0)

    Pxy = Hxy / float(x.size)
    Px = Hx / float(x.size)
    Py = Hy / float(x.size)

    pxy = Pxy.ravel()
    px = Px.repeat(Py.size)
    py = pylab.tile(Py, Px.size)

    idx = pylab.find((pxy > 0) & (px > 0) & (py > 0))
    mi = (pxy[idx] * pylab.log2(pxy[idx] / (px[idx] * py[idx]))).sum()

    return mi
Пример #22
0
def feature_scale(M, normalize=False, dbscale=False, norm=False, bels=False):
    """
    ::

        Perform mutually-orthogonal scaling operations, otherwise return identity:
          normalize [False]
          dbscale  [False]
          norm      [False]        
    """
    if not (normalize or dbscale or norm or bels):
        return M
    else:
        X = M.copy() # don't alter the original
        if norm:
            X = X / P.tile(P.sqrt((X*X).sum(0)),(X.shape[0],1))
        if normalize:
            X = _normalize(X)
        if dbscale or bels:
            X = P.log10(P.clip(X,0.0001,X.max()))
            if dbscale:                
                X = 20*X
    return X
Пример #23
0
    def __init__(self, X, c):
        self.n, self.N = X.shape
        self.X = X
        self.mu = empty((3, self.n))
        self.cov = empty((3, self.n, self.n))
        self.P = empty(3)
        cond = zeros(self.N)
        for i in range(0, 3):
            cond = cond + 1.0
            indices = where(c == cond)
            # Xa bevat alle elementen uit X waar de klasse gelijk van is aan i + 1.0
            Xa = [X[:, b] for b in indices]
            # Bovenstaande pakt de xjes in een extra array, dit willen we niet
            Xa = Xa[0]
            Na = shape(Xa)[1]

            self.mu[i] = mean(Xa, axis=1)
            # Tile smeert mu uit zodat we mu kunnen aftrekken van de X matrix
            self.cov[i] = cov(Xa - tile(self.mu[i].T, Na).reshape(self.n, Na))

            # De kans op deze klasse
            self.P[i] = (Na * 1.0) / self.N
Пример #24
0
def _grad_phi(psi, xxx_todo_changeme):
   """
   Compute the 1D gradient of a scalar field in the phi direction on a unit-
   radius spherical shell. Assumes psi is a 2D array with phi changing along
   axis 0. We use central differences for interior points, one-sided differences
   for exterior points, and address simple periodic boundaries.
   """
   (phi,theta) = xxx_todo_changeme
   dphi = p.diff(phi,axis=0)
   dtheta = p.diff(theta,axis=1)


   # pre-allocate output grid
   dpsidphi = p.zeros(phi.shape)

   # use weighted central differences to compute gradient on the interior
   dpsidphi[1:-1,:] = (((p.diff(psi[:-1,:],axis=0) / dphi[:-1,:]**2 +
                         p.diff(psi[1:,:],axis=0) / dphi[1:,:]**2) /
                        (1/dphi[:-1,:] + 1/dphi[1:,:]) ) *
                       1./p.sin(theta[1:-1,:]) )

   
   # compute phi gradients at exterior points
   if p.mod(phi[0,0],2*p.pi) == p.mod(phi[-1,0],2*p.pi):
      # use weighted central differences to compute gradient if periodic boundary
      dpsidphi[[0,-1],:] = p.tile(((p.diff(psi[:2,:],axis=0) / dphi[0,:]**2 +
                                    p.diff(psi[-2:,:],axis=0) / dphi[-1,:]**2) /
                                   (1/dphi[0,:] + 1/dphi[-1,:]) ) *
                                  1./p.sin(theta[0,:]), (2,1) )
   else:
      # use one-sided difference to compute gradient if not a periodic boundary
      dpsidphi[-1,:] = (p.diff(psi[-2:,:],axis=0) / dphi[-1,:] / p.sin(theta[-1,:]) )
      dpsidphi[0,:] = (p.diff(psi[:2,:],axis=0) / dphi[0,:] / p.sin(theta[0,:]) )
   
   
   return dpsidphi
Пример #25
0
import pylab as plt

n = 1000
mu = [[0],
      [0],
      [0],
      [0]]
Sigma = [[3.01602775, 1.02746769, -3.60224613, -2.08792829],
         [1.02746769, 5.65146472, -3.98616664, 0.48723704],
         [-3.60224613, -3.98616664, 13.04508284, -1.59255406],
         [-2.08792829, 0.48723704, -1.59255406, 8.28742469]]

d, U = plt.eig(Sigma)  # Sigma = U L Ut
L = plt.diagflat(d)
A = plt.dot(U, plt.sqrt(L))  # Required transform matrix.

X = plt.randn(4, n)  # 4*n matrix with each element ~ N(0,1)
# 4*n each column vector ~N(mu,Sigma), random draws from distribution.
Y = plt.dot(A, X) + plt.tile(mu, n)

Ybar = [[avg] for avg in plt.mean(Y, 1)]  # Mean along the 1 axis.
Yzm = Y - plt.tile(Ybar, n)  # Subtract mean from each column.
# Estimator for covariance matrix.
S = plt.dot(Yzm, plt.transpose(Yzm)) / n - 1

print(Ybar, S)
Пример #26
0
 def classify(self, x):
     d = self.X - tile(x.reshape(self.n, 1), self.N)
     dsq = sum(d*d, 0)
     neighbours = self.c[argpartition(dsq, self.k)[:self.k]]
     most_common = argmax(bincount(neighbours.astype(int)))
     return most_common
Пример #27
0
	def classify(self, x):
		d = self.X - tile(x.reshape(self.n,1), self.N)
		dsq = sum(d*d,0)
		minindex = argmin(dsq)
		return self.c[minindex]
Пример #28
0
def CreateFrames(path='./', run='', 
                 t0='', t1='', 
                 hemisphere='north', geoGrid=False, 
                 ignoreBinary=False, binaryType='pkl',
                 configFile=None):
    """
    Compute deltaBs hemispheric grid given LFM-MIX output files in path.
    
    Computes:
      pngFiles  - a list of PNG filenames, each corresponding to a snapshot in
                  time of LFM-MIX ground deltaB vector fields
                  NOTE: while the output is a list of filenames, the function
                        generates binary pkl/mat files that can be read in by
                        other software for further analysis.
                  FIXME: southern hemisphere summary plots are presented from a
                        point of view below the south pole, looking up. Likewise
                        for the data files. This is not technically a right-handed 
                        frame of reference, so any analysis of southern hemisphere 
                        data must rotate fields 180 degrees about the X axis, or 
                        0 longitude, 0 latitude line. This odd data file convention 
                        is consistent with how southern hemisphere data is stored 
                        in MIX files, but there is a strong argument to just store 
                        everything assuming the same (northern) POV, and rotate 
                        to a southern POV for display purposes only; this will 
                        require significant work.
                        
    Requires:
      Nothing, all inputs are optional
    
    Optional:
      path      - path to data directory holding LFM and MIX model output files
                  (default is current directory)
      run       - output filename prefix identifying LFM-MIX run (i.e., the part
                  of the filename prior to [mhd|mix]_yyyy-mm-ddTHH-MM-SSZ.hdf)
                  (default is any mhd|mix files in path)
      t0        - datetime object specifying the earliest of available time step
                  to include in the extraction
                  (default is earliest available)
      t1        - datetime object specfiying the latest of available time step
                  to include in the extraction
                  (default is last available)
      hemisphere - specify 'north' or 'south' hemisphere
                  (default is 'north')
      geoGrid   - if True, assume observatory coordinates are in geographic
                  coordinates rather than solar magnetic; same for outputs
                  (default is False)
      ignoreBinary - if True, ignore any pre-computed binary files and re-
                  compute everything from scratch; NOTE: individual binary files
                  will be ignored anyway if they are incompatible with specified
                  inputs, but this option avoids reading the binary file entirely.
                  (default is False)
      binaryType - binary type to generate, NOT to read in...routine looks for
                  PKL files first, then mat files, then proceeds to re-compute
                  if neither are available.
                  (default is 'pkl')
      configFile - specifies plotting config file; if None, default config file
                   is path/figs/north|south/deltaBSum.config; if this doesn't
                   exist, create new one with default config parameters.
    """
    
    assert( (hemisphere == 'north') | (hemisphere == 'south') )
    
    hemiSelect = {'north': 'North', 'south': 'South'}[hemisphere]

    # Make sure the output directory exisits if not make it
    dirname = os.path.join(path, 'figs', hemisphere)
    if not os.path.exists(dirname):
        os.makedirs( dirname )

    print(('Rendering ' + hemiSelect + 'ern hemisphere, storing frames at ' + dirname))        
    #Now check to make sure the MIX files are correct
    dMIX = pyLTR.Models.MIX(path, run)
    modelVars = dMIX.getVarNames()
    for v in ['Grid X', 'Grid Y', 
              'Potential North [V]', 'Potential South [V]', 
              'FAC North [A/m^2]', 'FAC South [A/m^2]',
              'Pedersen conductance North [S]', 'Pedersen conductance South [S]', 
              'Hall conductance North [S]', 'Hall conductance South [S]']:
        assert( v in modelVars )
    
    
    timeRange = dMIX.getTimeRange()
    
    #Now check to make sure the LFM files are correct
    dLFM = pyLTR.Models.LFM(path, run)
    modelVars = dLFM.getVarNames()
    for v in ['X_grid', 'Y_grid', 'Z_grid', 
              'bx_', 'by_', 'bz_']:
        assert( v in modelVars )

    # check that LFM output timeRanges are exactly the same as MIX output timeRanges
    trLFM = dLFM.getTimeRange()
    # _roundTime() rounds to nearest minute by default, which should suffice here
    # NOTE: we do NOT change the time stamps at all, just make sure they match
    #       to a 1-minute tolerance
    if list(map(_roundTime, timeRange)) != list(map(_roundTime, trLFM)):
       raise Exception(('Mismatched MIX and LFM output files'))
    
    
    if len(timeRange) == 0:
        raise Exception(('No data files found.  Are you pointing to the correct run directory?'))
    
    
    
    ## Original code defaulted to entire data set if the user-supplied time range
    ## fell outside of the available data, almost certainly not a desired result.
    ## Now if the user requests a time range that falls completely outside of the
    ## available data, and exception is raised.
    
    ##index0 = 0
    ##if t0:
    ##    for i,t in enumerate(timeRange):
    ##        if t0 >= t:
    ##            index0 = i
    ##
    ###index1 = len(timeRange)-1
    ##index1 = len(timeRange) # we were skipping the last valid time step
    ##if t1:
    ##    for i,t in enumerate(timeRange):
    ##        if t1 >= t:
    ##            #index1 = i
    ##            index1 = i + 1 # we were skipping the last valid time step
    
    
    if t0:
       if t1 and t1 < timeRange[0]: # upper time stamp below lowest available time stamp
          raise Exception('Requested time range falls outside available data')
       if t0 > timeRange[-1]: # lower time stamp above highest available time stamp
          raise Exception('Requested time range falls outside available data')
       
       for i,t in enumerate(timeRange):
          if t0 >= t:
             index0 = i
    else:
       index0 = 0
    
    
    if t1:
       if t0 and t0 > timeRange[-1]: # lower time stamp above highest available time stamp
          raise Exception('Requested time range falls outside available data')
       if t1 < timeRange[0]: # upper time stamp below lowest available time stamp
          raise Exception('Requested time range falls outside available data')
       
       for i,t in enumerate(timeRange):
          if t1 >= t:
             index1 = i+1
    else:
       index1 = len(timeRange)
    
    
    if index1 > index0:
       print(( 'Extracting LFM and MIX quantities for time series over %d time steps.' % (index1-index0) ))
    else:
       raise Exception('Requested time range is invalid')
    
    
    
    # Output a status bar displaying how far along the computation is.
    progress = pyLTR.StatusBar(0, index1-index0)
    progress.start()

    # Pre-compute r and theta
    x = dMIX.read('Grid X', timeRange[index0])
    xdict={'data':x*6500e3,'name':'X','units':r'm'}
    y = dMIX.read('Grid Y', timeRange[index0])
    ydict={'data':y*6500e3,'name':'Y','units':r'm'}
    theta=n.arctan2(y,x)
    theta[theta<0]=theta[theta<0]+2*n.pi
    # plotting routines now rotate local noon to point up
    #theta=theta+n.pi/2 # to put noon up
    r=n.sqrt(x**2+y**2)
    # plotting routines now expect longitude and colatitude, in radians, stored in dictionaries
    longitude = {'data':theta,'name':r'\phi','units':r'rad'}
    colatitude = {'data':n.arcsin(r),'name':r'\theta','units':r'rad'}
    
    
    # Deal with the plot options
    if (configFile == None and os.path.exists(os.path.join(dirname,'deltaBSum.config')) ):
       configFile = os.path.join(dirname,'deltaBSum.config')
    
    if configFile == None:
       # scalar radial magnetic pertubations
       dBradialTotOpts={'min':-100,'max':100,'colormap':'jet'}
       dBradialIonOpts={'min':-100,'max':100,'colormap':'jet'}
       dBradialFACOpts={'min':-100,'max':100,'colormap':'jet'}
       dBradialMagOpts={'min':-100,'max':100,'colormap':'jet'}
       
       # 2D vector horizontal perturbations
       dBhvecTotOpts={'width':.0025,'scale':1e3,'pivot':'middle'}
       dBhvecIonOpts={'width':.0025,'scale':1e3,'pivot':'middle'}
       dBhvecFACOpts={'width':.0025,'scale':1e3,'pivot':'middle'}
       dBhvecMagOpts={'width':.0025,'scale':1e3,'pivot':'middle'}
              
       # place all config dictionaries in one big dictionary
       optsObject = {'dBradialTot':dBradialTotOpts,
                     'dBradialIon':dBradialIonOpts,
                     'dBradialFAC':dBradialFACOpts,
                     'dBradialMag':dBradialMagOpts,
                     'dBhvecTot':dBhvecTotOpts,
                     'dBhvecIon':dBhvecIonOpts,
                     'dBhvecFAC':dBhvecFACOpts,
                     'dBhvecMag':dBhvecMagOpts,
                     'altPole':altPoleOpts}
       configFilename=os.path.join(dirname,'deltaBSum.config')
       print(("Writing plot config file at " + configFilename))
       f=open(configFilename,'w')
       f.write(pyLTR.yaml.safe_dump(optsObject,default_flow_style=False))
       f.close()
    else:
       f=open(configFile,'r')
       optsDict=pyLTR.yaml.safe_load(f.read())
       f.close()
       if ('dBradialTot' in optsDict):
          dBradialTotOpts = optsDict['dBradialTot']
       else:
          dBradialTotOpts={'min':-100.,'max':100.,'colormap':'jet'}
       
       if ('dBradialIon' in optsDict):
          dBradialIonOpts = optsDict['dBradialIon']
       else:
          dBradialIonOpts={'min':-100.,'max':100.,'colormap':'jet'}
           
       if ('dBradialFAC' in optsDict):
          dBradialFACOpts = optsDict['dBradialFAC']
       else:
          dBradialFACOpts={'min':-100.,'max':100.,'colormap':'jet'}
       
       if ('dBradialMag' in optsDict):
          dBradialMagOpts = optsDict['dBradialMag']
       else:
          dBradialMagOpts={'min':-100.,'max':100.,'colormap':'jet'}
       
       
       if ('dBhvecTot' in optsDict):
          dBhvecTotOpts = optsDict['dBhvecTot']
       else:
          dBhvecTotOpts={'min':-100.,'max':100.,'colormap':'jet'}
       
       if ('dBhvecIon' in optsDict):
          dBhvecIonOpts = optsDict['dBhvecIon']
       else:
          dBhvecIonOpts={'min':-100.,'max':100.,'colormap':'jet'}
           
       if ('dBhvecFAC' in optsDict):
          dBhvecFACOpts = optsDict['dBhvecFAC']
       else:
          dBhvecFACOpts={'min':-100.,'max':100.,'colormap':'jet'}
       
       if ('dBhvecMag' in optsDict):
          dBhvecMagOpts = optsDict['dBhvecMag']
       else:
          dBhvecMagOpts={'min':-100.,'max':100.,'colormap':'jet'}
       
       if ('altPole' in optsDict):
          altPoleOpts = optsDict['altPole']
       else:
          altPoleOpts = {'poleMarker1':'x', 'poleMarker2':'x',
                         'poleSize1':7, 'poleSize2':5,
                         'poleWidth1':3, 'poleWidth2':1,
                         'poleColor1':'blue', 'poleColor2':'white'}
       
    # initialize output list
    pngFilenames = []
    for i,time in enumerate(timeRange[index0:index1]):
        
        try:
           
           try:
              
              # ignore binary file even if one exists
              if ignoreBinary:
                 raise Exception
              
              # look for a .pkl file that already holds all the data required for
              # subsequent plots before recalculating all the derived data...if
              # this fails, look for a .mat file, if this fails, fall through to 
              # recalculate all summary data
              filePrefix = os.path.join(path,'figs',hemisphere)
              
              # this is a possible race condition, but try/except just doesn't do what I want
              if os.path.exists(os.path.join(filePrefix,
                                             'frame_deltaB_%04d-%02d-%02dT%02d-%02d-%02dZ.pkl'%
                                             (time.year,time.month,time.day,
                                              time.hour,time.minute,time.second))):
                 
                 binFilename = os.path.join(filePrefix,
                                            'frame_deltaB_%04d-%02d-%02dT%02d-%02d-%02dZ.pkl'%
                                            (time.year,time.month,time.day,
                                             time.hour,time.minute,time.second))
                 fh=open(binFilename,'rb')
                 allDict = pickle.load(fh)
                 fh.close()
                 
              elif os.path.exists(os.path.join(filePrefix,
                                               'frame_deltaB_%04d-%02d-%02dT%02d-%02d-%02dZ.mat'%
                                               (time.year,time.month,time.day,
                                                time.hour,time.minute,time.second))):
                 
                 binFilename = os.path.join(filePrefix,
                                            'frame_deltaB_%04d-%02d-%02dT%02d-%02d-%02dZ.mat'%
                                            (time.year,time.month,time.day,
                                             time.hour,time.minute,time.second))
                 fh=open(binFilename,'rb')
                 allDict = sio.loadmat(fh, squeeze_me=True)
                 fh.close()
                 
              
              else:
              
                 print(('No binary file found, recalculating '+
                        'frame_deltaB_%04d-%02d-%02dT%02d-%02d-%02dZ'%
                        (time.year,time.month,time.day,time.hour,time.minute,time.second)+
                        '...'))
                 raise Exception
              
              
              
              
              # ignore binary file if the coordinate system is not consistent with geoGrid
              if ((geoGrid and allDict['coordinates'] != 'Geographic') or
                  (not(geoGrid) and allDict['coordinates'] != 'Solar Magnetic')):
                 raise Exception
              
              phi_dict,theta_dict,rho_dict = allDict['dB_obs']            
              phi = phi_dict['data'] * 1. # '*1' forces array of floats, NOT objects
              theta = theta_dict['data'] * 1. # '*1' forces array of floats, NOT objects
              rho = rho_dict['data'] * 1. # '*1' forces array of floats, NOT objects
              
              if geoGrid:
                 phi_geo = phi
                 theta_geo = theta
                 rho_geo = rho
              
              dBphi_ion_dict,dBtheta_ion_dict,dBrho_ion_dict = allDict['dB_ion']
              dBphi_ion = dBphi_ion_dict['data'] / 1e9 # convert to Tesla
              dBtheta_ion = dBtheta_ion_dict['data'] / 1e9 # convert to Tesla
              dBrho_ion = dBrho_ion_dict['data'] / 1e9 # convert to Tesla
              
              dBphi_fac_dict,dBtheta_fac_dict,dBrho_fac_dict = allDict['dB_fac']
              dBphi_fac = dBphi_fac_dict['data'] / 1e9 # convert to Tesla
              dBtheta_fac = dBtheta_fac_dict['data'] / 1e9 # convert to Tesla
              dBrho_fac = dBrho_fac_dict['data'] / 1e9 # convert to Tesla
              
              dBphi_mag_dict,dBtheta_mag_dict,dBrho_mag_dict = allDict['dB_mag']
              dBphi_mag = dBphi_mag_dict['data'] / 1e9 # convert to Tesla
              dBtheta_mag = dBtheta_mag_dict['data'] / 1e9 # convert to Tesla
              dBrho_mag = dBrho_mag_dict['data'] / 1e9 # convert to Tesla
              
              
           except:
              
              
              # first read the MIX data
              vals=dMIX.read('Potential '+hemiSelect+' [V]',time)/1000.0
              psi_dict={'data':vals,'name':r'$\Phi$','units':r'kV'}
              vals=dMIX.read('Pedersen conductance '+hemiSelect+' [S]',time)
              sigmap_dict={'data':vals,'name':r'$\Sigma_{P}$','units':r'S'}
              vals=dMIX.read('Hall conductance '+hemiSelect+' [S]',time)
              sigmah_dict={'data':vals,'name':r'$\Sigma_{H}$','units':r'S'}
              vals=dMIX.read('FAC '+hemiSelect+' [A/m^2]',time)
              fac_dict={'data':vals*1e6,'name':r'$J_\parallel$','units':r'$\mu A/m^2$'}
              
              
              
              # then compute the electric field vectors
              ((phi_dict,theta_dict),
               (ephi_dict,etheta_dict)) = pyLTR.Physics.MIXCalcs.efieldDict(
                       xdict, ydict, psi_dict, ri=6500e3)
              
              
              # then compute total, Pedersen, and Hall current vectors
              if hemisphere=='north':
                 ((Jphi_dict,Jtheta_dict),
                  (Jpedphi_dict,Jpedtheta_dict),
                  (Jhallphi_dict,Jhalltheta_dict)) = pyLTR.Physics.MIXCalcs.jphithetaDict(
                          (ephi_dict,etheta_dict), sigmap_dict, sigmah_dict, colatitude['data'])
              else:
                 ((Jphi_dict,Jtheta_dict),
                  (Jpedphi_dict,Jpedtheta_dict),
                  (Jhallphi_dict,Jhalltheta_dict)) = pyLTR.Physics.MIXCalcs.jphithetaDict(
                          (ephi_dict,etheta_dict), sigmap_dict, sigmah_dict, n.pi-colatitude['data'])
               
              
              
              # then generate the SSECS, starting with min/max bounds of ionosphere
              # segments
              phi = phi_dict['data']
              theta = theta_dict['data']

              # caclulate MIX grid cell boundaries in phi and theta
              rion_min = [None] * 3 # initialize empty 3 list
              rion_min[0] = p.zeros(phi.shape)
              rion_min[0][1:,:] = phi[1:,:] - p.diff(phi, axis=0)/2.
              rion_min[0][0,:] = phi[0,:] - p.diff(phi[0:2,:], axis=0).squeeze()/2.

              rion_min[1] = p.zeros(theta.shape)
              rion_min[1][:,1:] = theta[:,1:] - p.diff(theta, axis=1)/2.
              rion_min[1][:,0] = theta[:,0] - p.diff(theta[:,0:2], axis=1).squeeze()/2.

              rion_min[2] = p.zeros(theta.shape)
              rion_min[2][:,:] = 6500.e3


              rion_max = [None] * 3 # initialize empty 3 list
              rion_max[0] = p.zeros(phi.shape)
              rion_max[0][:-1,:] = phi[:-1,:] + p.diff(phi, axis=0)/2.
              rion_max[0][-1,:] = phi[-1,:] + p.diff(phi[-2:,:], axis=0).squeeze()/2.

              rion_max[1] = p.zeros(theta.shape)
              rion_max[1][:,:-1] = theta[:,:-1] + p.diff(theta, axis=1)/2.
              rion_max[1][:,-1] = theta[:,-1] + p.diff(theta[:,-2:], axis=1).squeeze()/2.

              rion_max[2] = p.zeros(theta.shape)
              rion_max[2][:,:] = p.Inf
              
              
              
              # generate SSECS for ionospheric currents only
              (rv_ion, 
               Jv_ion, 
               dv_ion) = pyLTR.Physics.SSECS.ssecs_sphere([rion_min[0],rion_min[1],rion_min[2]], 
                                                          [rion_max[0],rion_max[1],rion_min[2]], 
                                                          (Jphi_dict['data']/1e6, 
                                                           Jtheta_dict['data']/1e6), 
                                                          10, False)
              
              # generate SSECS inside LFM inner boundary
              (rv_IBin, 
               Jv_IBin, 
               dv_IBin) = pyLTR.Physics.SSECS.ssecs_sphere([rion_min[0],rion_min[1],rion_min[2]], 
                                                           [rion_max[0],rion_max[1],2.5*rion_min[2]], 
                                                           (Jphi_dict['data']/1e6, 
                                                            Jtheta_dict['data']/1e6), 
                                                           10, False)
              
              # do NOT attempt to generate SSECS for FACs alone...this isn't possible
              # with existing code; However, the deltaB from FACs is the difference
              # between deltaBs calculated from the two SSECS above
              
              
              # generate SSECS outside LFM inner boundary
              # (this is serving as a proxy for magnetosphere currents for now)
              (rv_mag, 
               Jv_mag, 
               dv_mag) = pyLTR.Physics.SSECS.ssecs_sphere([rion_min[0],rion_min[1],2.5*rion_min[2]], 
                                                          [rion_max[0],rion_max[1],rion_min[2]],
                                                          (Jphi_dict['data']/1e6, 
                                                           Jtheta_dict['data']/1e6), 
                                                          10, False)
              
              # extract currents from MHD data
              # NOTE: LFM time stamps are not necessarily the same as MIX, so it
              #       is necessary to use the LFM's timeRange list (i.e., trLFM)
              x=dLFM.read('X_grid', trLFM[index0:index1][i]) # this is in cm
              y=dLFM.read('Y_grid', trLFM[index0:index1][i]) # this is in cm
              z=dLFM.read('Z_grid', trLFM[index0:index1][i]) # this is in cm
              Bx=dLFM.read('bx_', trLFM[index0:index1][i]) # this is in G
              By=dLFM.read('by_', trLFM[index0:index1][i]) # this is in G
              Bz=dLFM.read('bz_', trLFM[index0:index1][i]) # this is in G
              hgrid=pyLTR.Grids.HexahedralGrid(x,y,z)
              xB,yB,zB=hgrid.cellCenters()
              hgridcc=pyLTR.Grids.HexahedralGrid(xB,yB,zB) # B is at cell centers
              Jx,Jy,Jz = pyLTR.Physics.LFMCurrent(hgridcc,Bx,By,Bz,rion=1) # ...should be A/m^2 given default input units
              xJ,yJ,zJ = hgridcc.cellCenters() # ...and J is at the centers of these cells
              xJ = xJ/100 # ...and the coordinates should be in meters for BS.py
              yJ = yJ/100 # ...and the coordinates should be in meters for BS.py
              zJ = zJ/100 # ...and the coordinates should be in meters for BS.py
              ldV = hgridcc.cellVolume()/(100**3) # ...and we need dV in m^3 for BS.py
              
              if hemisphere=='south':
                 # it's easier to rotate the LFM grid than convert the MIX coordinates
                 # for southern hemisphere output
                 yJ = -yJ
                 zJ = -zJ
                 Jy = -Jy
                 Jz = -Jz
              
              
              
              #
              # This is a little ugly...Quad (and Oct) resolution LFM runs use
              # MIX grids that are different resoltions than Single and Double
              # runs; not surprising, but I was slow to figure this out. Anyway,
              # we need to visualize and cross-validate on similar grids, thus
              # the following kludge ('kludge' because the better answer is to
              # specify a useful grid without any reference to the MIX grid).
              #
              if phi.size == 181*27:
                 pass
              elif phi.size == 361*48:
                 phi = phi[::2,[0,1,2,3,4]+list(range(5,48,2))]
                 theta = theta[::2,[0,1,2,3,4]+list(range(5,48,2))]
              else:
                 raise Exception('Unrecognized MIX grid dimensions')
              
              
              
              # calculate deltaBs on a grid that decimates MIX grid by 2/3, and removes
              # the lowest 3 colatitutdes
              phi = phi[::3,3:]
              theta = theta[::3,3:]
              rho = p.tile(6378e3,phi.shape)
              
              if geoGrid:
                 phi_geo = phi
                 theta_geo = theta
                 rho_geo = rho
                 x,y,z = pyLTR.transform.SPHtoCAR(phi,theta,rho)
                 x,y,z = pyLTR.transform.GEOtoSM(x,y,z,time)
                 phi,theta,rho = pyLTR.transform.CARtoSPH(x,y,z)
              
              
              # deltaB for ionospheric currents
              (dBphi_ion, 
               dBtheta_ion, 
               dBrho_ion) = pyLTR.Physics.BS.bs_sphere(rv_ion, 
                                                       Jv_ion, 
                                                       dv_ion, 
                                                       (phi,theta,rho))
              
              
              # deltaB for currents inside IB
              (dBphi_IBin, 
               dBtheta_IBin, 
               dBrho_IBin) = pyLTR.Physics.BS.bs_sphere(rv_IBin, 
                                                        Jv_IBin, 
                                                        dv_IBin, 
                                                        (phi,theta,rho))
              # difference between dB*_IBin and dB*_ion is the FAC inside IB
              dBphi_fac = dBphi_IBin - dBphi_ion
              dBtheta_fac = dBtheta_IBin - dBtheta_ion
              dBrho_fac = dBrho_IBin - dBrho_ion
                            
              
              # deltaB from magnetospheric currents
              # convert cartesian positions and vectors to spherical
              lphi,ltheta,lrho,lJphi,lJtheta,lJrho=pyLTR.transform.CARtoSPH(xJ,yJ,zJ,Jx,Jy,Jz)
              (dBphi_mag, 
               dBtheta_mag, 
               dBrho_mag) = pyLTR.Physics.BS.bs_sphere((lphi,ltheta,lrho), 
                                                       (lJphi,lJtheta,lJrho), 
                                                       ldV, 
                                                       (phi,theta,rho))
              
              
              if geoGrid:
                 
                 # rotate ionospheric contribution from SM to GEO coordinates; leave
                 # position vectors unchanged for subsequent rotations
                 x,y,z,dx,dy,dz = pyLTR.transform.SPHtoCAR(phi,theta,rho,dBphi_ion,dBtheta_ion,dBrho_ion)
                 x,y,z = pyLTR.transform.SMtoGEO(x,y,z,time)
                 dx,dy,dz = pyLTR.transform.SMtoGEO(dx,dy,dz,time)
                 _, _, _, dBphi_ion, dBtheta_ion, dBrho_ion = pyLTR.transform.CARtoSPH(x,y,z,dx,dy,dz)
                 
                 # rotate FAC contribution from SM to GEO coordinates leave
                 # position vectors unchanged for subsequent rotations
                 x,y,z,dx,dy,dz = pyLTR.transform.SPHtoCAR(phi,theta,rho,dBphi_fac,dBtheta_fac,dBrho_fac)
                 x,y,z = pyLTR.transform.SMtoGEO(x,y,z,time)
                 dx,dy,dz = pyLTR.transform.SMtoGEO(dx,dy,dz,time)
                 _, _, _, dBphi_fac, dBtheta_fac, dBrho_fac = pyLTR.transform.CARtoSPH(x,y,z,dx,dy,dz)
                 
                 # rotate magnetospheric contribution from SM to GEO coordinates
                 x,y,z,dx,dy,dz = pyLTR.transform.SPHtoCAR(phi,theta,rho,dBphi_mag,dBtheta_mag,dBrho_mag)
                 x,y,z = pyLTR.transform.SMtoGEO(x,y,z,time)
                 dx,dy,dz = pyLTR.transform.SMtoGEO(dx,dy,dz,time)
                 _, _, _, dBphi_mag, dBtheta_mag, dBrho_mag = pyLTR.transform.CARtoSPH(x,y,z,dx,dy,dz)
                 
                 phi = phi_geo
                 theta = theta_geo
                 rho = rho_geo
              
              
              #
              # end of [re]processing 'except' block
              #
           
           
           
           
           # (re)create grid dictionary for subsequent plots and pickling
           toPickle={}
           
           if hemisphere=='south':
              toPickle['pov'] = 'south'
           else:
              toPickle['pov'] = 'north'
           
           if geoGrid:
              toPickle['coordinates'] = 'Geographic'
              
              # get geographic coordinates of sm pole
              x,y,z = pyLTR.transform.SPHtoCAR(0,0,1)
              x,y,z = pyLTR.transform.SMtoGEO(x,y,z,time)
              poleCoords = pyLTR.transform.CARtoSPH(x,y,z)
           else:
              toPickle['coordinates'] = 'Solar Magnetic'
              
              ## # get sm coordinates of geographic pole
              ## x,y,z = pyLTR.transform.SPHtoCAR(0,0,1)
              ## x,y,z = pyLTR.transform.GEOtoSM(x,y,z,time)
              ## poleCoords = pyLTR.transform.CARtoSPH(x,y,z)
              
              ## now that MapPlot is being used, and until it can properly
              ## plot in centered SM coordinates, we want to just plot the 
              ## magnetic pole;
              poleCoords = (0, 0, 1)
           
           phi_dict = {'data':phi,'name':r'$\phi$','units':r'rad'}
           theta_dict = {'data':theta,'name':r'$\theta$','units':r'rad'}
           rho_dict = {'data':rho,'name':r'$\rho$','units':r'm'}
           
           toPickle['dB_obs'] = (phi_dict,theta_dict,rho_dict)
           
           
           
           
           #####################################################################
           ##
           ## FIXME: move plots from this function into if __name__ == '__main__'
           ##        section like deltaBTimeSeries.py; plots will then only be
           ##        generated if user requests it, and this function may be
           ##        called as part of a module...
           ##        But note: one reason the plots are generated inside this
           ##                  function is that a long time series of gridded
           ##                  data becomes unmanageable memory-wise fairly
           ##                  quickly...think this through carefully. -EJR
           ##
           #####################################################################
           
           
           
           # Now onto the plots
           tt=time.timetuple()
           
           p.figure(1,figsize=(28,6))
           p.figtext(0.5,0.92,'Ground '+'$\Delta{\mathbf{B}}$'+' - '+hemiSelect+
                     '\n%4d-%02d-%02d  %02d:%02d:%02d' %
                  (tt.tm_year,tt.tm_mon,tt.tm_mday,
                  tt.tm_hour,tt.tm_min,tt.tm_sec),
                  fontsize=14,multialignment='center')
           
           
           # plot total deltaB
           ax=p.subplot(141)
           # temporary dictionaries
           dBphi_dict = {'data':(dBphi_ion + dBphi_fac + dBphi_mag)*1e9,'name':r'$\Delta \mathrm{B}_{\phi}$','units':'nT'}
           dBtheta_dict = {'data':(dBtheta_ion + dBtheta_fac + dBtheta_mag)*1e9,'name':r'$\Delta \mathrm{B}_{\theta}$','units':'nT'}
           dBrho_dict = {'data':(dBrho_ion + dBrho_fac + dBrho_mag)*1e9,'name':r'$\Delta \mathrm{B}_{\rho}$','units':'nT'}
           bm = pyLTR.Graphics.MapPlot.QuiverPlotDict(phi_dict,theta_dict, 
                                                      dBrho_dict,(dBphi_dict, dBtheta_dict),
                                                      dtUTC=time, coordSystem=toPickle['coordinates'],
                                                      plotOpts1=dBradialTotOpts,
                                                      plotOpts2=dBhvecTotOpts,
                                                      points=[(poleCoords[0],poleCoords[1])],
                                                      userAxes=ax, northPOV=hemisphere=='north')
           
           to=p.text(.05, .95, r"$\Delta \mathbf{B}_{\mathrm{Total}}$", 
                     fontsize=14, transform=ax.transAxes)
          
           
           
           
           
           # plot ionospheric deltaB
           ax=p.subplot(142)
           # temporary dictionaries
           dBphi_dict = {'data':(dBphi_ion)*1e9,'name':r'$\Delta \mathrm{B}_{\phi}$','units':'nT'}
           dBtheta_dict = {'data':(dBtheta_ion)*1e9,'name':r'$\Delta \mathrm{B}_{\theta}$','units':'nT'}
           dBrho_dict = {'data':(dBrho_ion)*1e9,'name':r'$\Delta \mathrm{B}_{\rho}$','units':'nT'}
           bm = pyLTR.Graphics.MapPlot.QuiverPlotDict(phi_dict,theta_dict, 
                                                      dBrho_dict,(dBphi_dict, dBtheta_dict),
                                                      dtUTC=time, coordSystem=toPickle['coordinates'],
                                                      plotOpts1=dBradialIonOpts,
                                                      plotOpts2=dBhvecIonOpts,
                                                      points=[(poleCoords[0],poleCoords[1])],
                                                      userAxes=ax, northPOV=hemisphere=='north')
                      
           to=p.text(.05, .95, r"$\Delta \mathbf{B}_{\mathrm{ion}}$", 
                     fontsize=14, transform=ax.transAxes)
           
           # for subsequent pickling
           toPickle['dB_ion'] = (dBphi_dict,dBtheta_dict,dBrho_dict)
           
           
           # plot FAC deltaB
           ax=p.subplot(143)
           # temporary dictionaries
           dBphi_dict = {'data':(dBphi_fac)*1e9,'name':r'$\Delta \mathrm{B}_{\phi}$','units':'nT'}
           dBtheta_dict = {'data':(dBtheta_fac)*1e9,'name':r'$\Delta \mathrm{B}_{\theta}$','units':'nT'}
           dBrho_dict = {'data':(dBrho_fac)*1e9,'name':r'$\Delta \mathrm{B}_{\rho}$','units':'nT'}
           bm = pyLTR.Graphics.MapPlot.QuiverPlotDict(phi_dict,theta_dict, 
                                                      dBrho_dict,(dBphi_dict, dBtheta_dict),
                                                      dtUTC=time, coordSystem=toPickle['coordinates'],
                                                      plotOpts1=dBradialFACOpts,
                                                      plotOpts2=dBhvecFACOpts,
                                                      points=[(poleCoords[0],poleCoords[1])],
                                                      userAxes=ax, northPOV=hemisphere=='north')
           
           to=p.text(.05, .95, r"$\Delta \mathbf{B}_{\mathrm{fac}}$", 
                     fontsize=14, transform=ax.transAxes)
           
           # for subsequent pickling
           toPickle['dB_fac'] = (dBphi_dict,dBtheta_dict,dBrho_dict)
           
           
           # plot magnetospheric deltaB
           ax=p.subplot(144)
           # temporary dictionaries
           dBphi_dict = {'data':(dBphi_mag)*1e9,r'name':'$\Delta \mathrm{B}_{\phi}$','units':'nT'}
           dBtheta_dict = {'data':(dBtheta_mag)*1e9,r'name':'$\Delta \mathrm{B}_{\theta}$','units':'nT'}
           dBrho_dict = {'data':(dBrho_mag)*1e9,'name':r'$\Delta \mathrm{B}_{\rho}$','units':'nT'}
           bm = pyLTR.Graphics.MapPlot.QuiverPlotDict(phi_dict,theta_dict, 
                                                      dBrho_dict,(dBphi_dict, dBtheta_dict),
                                                      dtUTC=time, coordSystem=toPickle['coordinates'],
                                                      plotOpts1=dBradialMagOpts,
                                                      plotOpts2=dBhvecMagOpts,
                                                      points=[(poleCoords[0],poleCoords[1])],
                                                      userAxes=ax, northPOV=hemisphere=='north')
                      
           to=p.text(.05, .95, r"$\Delta \mathbf{B}_{\mathrm{mag}}$", 
                     fontsize=14, transform=ax.transAxes)
           
           # for subsequent pickling
           toPickle['dB_mag'] = (dBphi_dict,dBtheta_dict,dBrho_dict)
           
           
           
           
           #savefigName = os.path.join(path,'figs',hemisphere,'frame_deltaB_%05d.png'%i)
           filePrefix = os.path.join(path,'figs',hemisphere)
           pngFilename = os.path.join(filePrefix,'frame_deltaB_%04d-%02d-%02dT%02d-%02d-%02dZ.png'%
                                                 (time.year,time.month,time.day,time.hour,time.minute,time.second))
           
           p.savefig(pngFilename,dpi=150)
           p.clf()
           
           
           if binaryType.lower() == 'pkl' or binaryType.lower() == '.pkl' or binaryType.lower() == 'pickle':
              # --- Dump a pickle!
              pklFilename = os.path.join(filePrefix,'frame_deltaB_%04d-%02d-%02dT%02d-%02d-%02dZ.pkl'%
                                                    (time.year,time.month,time.day,time.hour,time.minute,time.second))
              fh = open(pklFilename, 'wb')
              pickle.dump(toPickle, fh, protocol=2)
              fh.close()
           elif binaryType.lower() == 'mat' or binaryType.lower() == '.mat' or binaryType.lower() == 'matlab':
              # --- Dump a .mat file!
              matFilename = os.path.join(filePrefix,'frame_deltaB_%04d-%02d-%02dT%02d-%02d-%02dZ.mat'%
                                                    (time.year,time.month,time.day,time.hour,time.minute,time.second))
              sio.savemat(matFilename, toPickle)
           elif binaryType.lower() == 'none':
              pass
           else:
              print(('Unrecognized binary type '+binaryType+' requested'))
              raise Exception
              
              
           progress.increment()
           
           
        except KeyboardInterrupt:
            # Exit when the user hits CTRL+C.
            progress.stop()
            progress.join()            
            print('Exiting.')
            import sys
            sys.exit(0)
                
        except:
            # Cleanup progress bar if something bad happened.
            progress.stop()
            progress.join()
            raise
    
        
        # append pngFilename to list of fully qualified filenames 
        pngFilenames.append(pngFilename)
    
        
    progress.stop()
    progress.join()

    
    #return  os.path.join(path,'figs',hemisphere)
    return pngFilenames
Пример #29
0
def main():
    mu = pl.array([[2], [8], [16], [32]])
    Sigma = pl.array([[3.01602775,  1.02746769, -3.60224613, -2.08792829],
                      [1.02746769,  5.65146472, -3.98616664,  0.48723704],
                      [-3.60224613, -3.98616664, 13.04508284, -1.59255406],
                      [-2.08792829,  0.48723704, -1.59255406,  8.28742469]])
    d, U = pl.eig(Sigma)
    L = pl.diagflat(d)
    A = pl.dot(U, pl.sqrt(L))

    N = []
    mu_deviations = []
    Sigma_deviations = []

    # First part of the exercise.
    # This loop is used to get different sizes of N.
    for i in range(1, 40):
        means = pl.array([])
        covariances = pl.array([])
        N.append(50 * i)
        # From this loop, the average is taken to get an accurate measurement.
        for _ in range(1, 200):
            X = pl.randn(4, 50 * i)
            Y = pl.dot(A, X) + pl.tile(mu, 50 * i)
            mean = pl.mean(Y, axis=1)
            covariance = pl.cov(Y)
            covariance = covariance.reshape((1, 16))
            if (len(means) == 0 and len(covariances) == 0):
                means = mean
                covariances = covariance
            else:
                means = pl.vstack((means, mean))
                covariances = pl.vstack((covariances, covariance))
        mu_deviations.append(pl.mean(pl.std(covariances, axis=0)))
        Sigma_deviations.append(pl.mean(pl.std(means, axis=0)))

    pl.figure(1)
    pl.clf()
    pl.title('The average deviation, over 200 times,\n of the mean\
             and covariance matrix for a given N')
    pl.xlabel('N')
    pl.ylabel('average deviation')
    pl.plot(N, mu_deviations, label='average mean deviation')
    pl.plot(N, Sigma_deviations, label='average covariance deviation')
    pl.legend()
    pl.savefig('fig22.png')

    # Second part of the exercise.
    covariances = pl.array([])

    # Over the loop is iterated to create a data matrix of the covariances of
    # the data matrices obtained from the multivariate normal distribution.
    # The covariance from this data matrix of covariances is shown.
    for _ in range(1, 200):
        X = pl.randn(4, 1000)
        Y = pl.dot(A, X) + pl.tile(mu, 1000)
        covariance = pl.cov(Y)
        if (len(covariances) == 0):
            covariances = covariance
        else:
            covariances = pl.hstack((covariances, covariance))
    covariance_data = pl.cov(covariances)
    print(covariance_data)
Пример #30
0
n = 1000
mu = [[0],
      [0],
      [0],
      [0]]
Sigma = [[3.01602775, 1.02746769, -3.60224613, -2.08792829],
         [1.02746769, 5.65146472, -3.98616664, 0.48723704],
         [-3.60224613, -3.98616664, 13.04508284, -1.59255406],
         [-2.08792829, 0.48723704, -1.59255406, 8.28742469]]

d, U = plt.eig(Sigma)  # Sigma = U L Ut
L = plt.diagflat(d)
A = plt.dot(U, plt.sqrt(L))  # required transform matrix

X = plt.randn(4, n)  # 4xn matrix with each element ~ N(0,1)
Y = plt.dot(A, X) + plt.tile(mu, n)  # 4xn each column vector ~N(mu,Sigma)

f, axarr = plt.subplots(4, 4, sharex=True, sharey=True)
for i in range(0, len(Y)):
    for j in range(0, len(Y)):
        if(i == j):
            axarr[i][j].set_title(str(i) + ',' + str(j))
            axarr[i][j].axis('off')
            continue

        axarr[i][j].plot(Y[i], Y[j], 'xg')
        axarr[i][j].set_title(str(i) + ',' + str(j))

plt.setp([a.get_xticklabels() for a in axarr[0, :]], visible=False)
plt.setp([a.get_yticklabels() for a in axarr[:, 1]], visible=False)
plt.tight_layout()
Пример #31
0
# calculate ionospheric components of SSECS from MIX data
(rv_MIX_iono, Jv_MIX_iono, dv_MIX_iono) = pyLTR.Physics.SSECS.ssecs_sphere(
    [rion_min_MIX[0], rion_min_MIX[1], rion_min_MIX[2]],
    [rion_max_MIX[0], rion_max_MIX[1], rion_min_MIX[2]],
    (Jphi_MIX_dict['data'] / 1e6, Jtheta_MIX_dict['data'] / 1e6), 10, False)
# calculate non-ionospheric component of SSECS from MIX data
(rv_MIX_faceq, Jv_MIX_faceq, dv_MIX_faceq) = pyLTR.Physics.SSECS.ssecs_sphere(
    [rion_min_MIX[0], rion_min_MIX[1], rion_min_MIX[2] + 1],
    [rion_max_MIX[0], rion_max_MIX[1], rion_min_MIX[2]],
    (Jphi_MIX_dict['data'] / 1e6, Jtheta_MIX_dict['data'] / 1e6), 10, False)

# calculate deltaB for total SSECS
(dBphi_MIX_total,
 dBtheta_MIX_total, dBrho_MIX_total) = pyLTR.Physics.BS.bs_sphere(
     rv_MIX_total, Jv_MIX_total, dv_MIX_total,
     (phi_MIX, theta_MIX, p.tile(6378e3, phi_MIX.shape)))
# convert into nanoTeslas
dBphi_MIX_total_dict = {
    'data': dBphi_MIX_total * 1e9,
    'name': r'$dB_\phi$',
    'units': r'nT'
}
dBtheta_MIX_total_dict = {
    'data': dBtheta_MIX_total * 1e9,
    'name': r'$dB_\theta$',
    'units': r'nT'
}
dBrho_MIX_total_dict = {
    'data': dBrho_MIX_total * 1e9,
    'name': r'$dB_\rho$',
    'units': r'nT'