Exemplo n.º 1
0
    def test_eigenmask1(self):
        m = wave.eigenmask((1, 13), (1, 2), betamax=1.5)
        m1 = wave.eigenmask1(13, (1, 2), betamax=1.5)
        self.allclose(m[:, 0, :], m1)
        m = wave.eigenmask((1, 13), 2, betamax=1.5)
        m1 = wave.eigenmask1(13, 2, betamax=1.5)
        self.allclose(m[0, :], m1)

        m = wave.eigenmask((1, 13), 2, betamax=1.5)
        m1 = wave.eigenmask1(13, 2, betamax=1.5)
        self.allclose(m[0, :], m1)
Exemplo n.º 2
0
    def test_mask2indices1(self):
        mask = wave.eigenmask((1, 12), (1, 2), betamax=1.8)
        indices = wave.mask2indices(mask, (1, 2))
        mask1 = wave.eigenmask1(12, (1, 2), betamax=1.8)
        indices1 = wave.mask2indices1(mask1, (1, 2))
        self.allclose(indices[0][..., 1], indices1[0])
        self.allclose(indices[1][..., 1], indices1[1])

        mask = wave.eigenmask((1, 12), 2, betamax=1.8)
        indices = wave.mask2indices(mask, 2)
        mask1 = wave.eigenmask1(12, 2, betamax=1.8)
        indices1 = wave.mask2indices1(mask1, 2)
        self.allclose(indices[..., 1], indices1)
Exemplo n.º 3
0
    def test_mask2betax1(self):
        mask = wave.eigenmask((12, 1), (1, 2), 1.8)
        beta = wave.mask2beta(mask, (1, 2))
        mask1 = wave.eigenmask1(12, (1, 2), 1.8)
        betax1 = wave.mask2betax1(mask1, (1, 2))

        self.allclose(beta[0], np.abs(betax1[0]))
        self.allclose(beta[1], np.abs(betax1[1]))

        mask = wave.eigenmask((12, 1), 2, 1.8)
        beta = wave.mask2beta(mask, 2)
        mask1 = wave.eigenmask1(12, 2, 1.8)
        betax1 = wave.mask2betax1(mask1, 2)

        self.allclose(beta, np.abs(betax1))
Exemplo n.º 4
0
 def test_mask2indices(self):
     mask = wave.eigenmask((4, 3), (1, 2), 1.8)
     indices = wave.mask2indices(mask, (1, 2))
     self.allclose(indices[0], self.eigenindices[0])
     self.allclose(indices[1], self.eigenindices[1])
     indices = wave.mask2indices(mask[1], 2)
     self.allclose(indices, self.eigenindices[1])
Exemplo n.º 5
0
 def test_mask2beta(self):
     mask = wave.eigenmask((4, 3), (1, 2), 1.8)
     beta = wave.mask2beta(mask, (1, 2))
     self.allclose(beta[0], self.beta[0][mask[0]])
     self.allclose(beta[1], self.beta[1][mask[1]])
     beta = wave.mask2beta(mask[1], 2)
     self.allclose(beta, self.beta[1][mask[1]])
     self.isfloat(beta)
Exemplo n.º 6
0
 def test_mask2phi(self):
     mask = wave.eigenmask((4, 3), (1, 2), 1.8)
     phi = wave.mask2phi(mask, (1, 2))
     self.allclose(phi[0], self.phi[mask[0]])
     self.allclose(phi[1], self.phi[mask[1]])
     phi = wave.mask2phi(mask[1], 2)
     self.allclose(phi, self.phi[mask[1]])
     self.isfloat(phi)
Exemplo n.º 7
0
def ffield2modes(ffield, k0, betamax=BETAMAX):

    k0 = np.asarray(k0)
    mask = eigenmask(ffield.shape[-2:], k0, betamax)
    if k0.ndim == 0:
        return mask, np.moveaxis(ffield[..., mask], -2, -1)
    else:
        return mask, tuple((np.moveaxis(ffield[..., i, :, :, :][..., mask[i]],
                                        -2, -1) for i in range(len(k0))))
Exemplo n.º 8
0
def layer_mat3d(k0, d, epsv, epsa, mask=None, method="4x4"):
    """Computes characteristic matrix of a single layer M=F.P.Fi,
    
    Numpy broadcasting rules apply
    
    Parameters
    ----------
    k0 : float or sequence of floats
        A scalar or a vector of wavenumbers
    d : array_like
        Layer thickness
    epsv : array_like
        Epsilon eigenvalues.
    epsa : array_like
        Optical axes orientation angles (psi, theta, phi).
    method : str, optional
        Either a 4x4 or 4x4_1
    
    Returns
    -------
    cmat : ndarray
        Characteristic matrix of the layer.
    """
    if method not in ("4x4", "4x4_1", "2x2"):
        raise ValueError("Unsupported method: '{}'".format(method))
    k0 = np.asarray(k0)
    shape = epsv.shape[-3], epsv.shape[-2]
    if mask is None:
        mask = eigenmask(shape, k0)
        betas = eigenbeta(shape, k0)
        phis = eigenphi(shape, k0)
        indices = eigenindices(shape, k0)
    else:
        betas = mask2beta(mask, k0)
        phis = mask2phi(mask, k0)
        indices = mask2indices(mask, k0)
    if k0.ndim == 0:
        return _layer_mat3d(k0, d, epsv, epsa, mask, betas, phis, indices,
                            method)
    else:
        out = (_layer_mat3d(k0[i], d, epsv, epsa, mask[i], betas[i], phis[i],
                            indices[i], method) for i in range(len(k0)))
        return tuple(out)
Exemplo n.º 9
0
def field2modes(field, k0, betamax=BETAMAX):
    """Converts 2D field array to modes array.
    
    Parameters
    ----------
    field : ndarray or tuple of ndarrays
        Input field array (or tuple of input fields for each wavenumber). The 
        shape of the input arrays must be (...,4,:,:) representing.
    k0 : float or a sequence of floats
        Defines the wavenumber. Fol multi-wavelength data, this must be a
        sequence of wawenumbers
    betamax : float, optional
        The beta cutoff parameter.
        
    Returns
    -------
    mask, modes : ndarray, ndarray or ndarray, tuple of ndarrays
        For a single-wavelength data it returns the mask array specifying
        the mode indices and modes coefficients array. For multi-wavelength data
        the modes is a tuple of ndarrays for each of the wavelengths. Length
        of the mask in this case equals length of the wavenumbers. 
            
    """
    if isinstance(field, tuple):
        out = tuple(
            (field2modes(field[i], k0[i], betamax) for i in range(len(field))))
        mask = tuple(o[0] for o in out)
        modes = tuple(o[1] for o in out)
        return mask, modes

    f = fft2(field)
    k0 = np.asarray(k0)
    mask = eigenmask(f.shape[-2:], k0, betamax)
    if k0.ndim == 0:
        return mask, np.moveaxis(f[..., mask], -2, -1)
    else:
        return mask, tuple((np.moveaxis(f[..., i, :, :, :][..., mask[i]], -2,
                                        -1) for i in range(len(k0))))
Exemplo n.º 10
0
 def test_eigenmask(self):
     m = self.beta < 1.8
     out = wave.eigenmask(self.shape, self.ks, betamax=1.8)
     self.allclose(out, m)
Exemplo n.º 11
0
def _field2modes(field, k0, betamax=BETAMAX):
    f = fft2(field)
    mask = eigenmask(f.shape[-2:], k0, betamax)
    f = f[mask]
    return np.moveaxis(f, -2, -1)