Example #1
0
def admitant_2d_matrix_element_bm(mesh, row_idx, col_idx, z0, k, coupling_sign):
    n, ns = mesh.normals[row_idx], mesh.normals[col_idx]
    r = mesh.centers[row_idx]
    corners, admittance = mesh.corners[col_idx], mesh.admittances[col_idx]
    singular = row_idx == col_idx

    if singular:
        element_vector = corners[1] - corners[0]
        length = np.sqrt(element_vector.dot(element_vector))
        lk2 = length * k / 2
        return (
            +(z0 * admittance * np.pi * length * k / 8)
            * (+hankel2(0, lk2) * struve(-1, lk2) + hankel2(1, lk2) * struve(0, lk2))
            - coupling_sign
            * fixed_quad(regularized_hypersingular_bm_part, 0, lk2)[0]
            / 2
            + coupling_sign * 2j / (np.pi * k * length)
            + (1 - coupling_sign * z0 * admittance) / 2
        )

    else:

        def integral_function(rs):
            return (
                hs_2d(ns, k, r, rs)
                - 1j * k * z0 * admittance * g_2d(k, r, rs)
                + coupling_sign * z0 * admittance * h_2d(n, k, r, rs)
                + coupling_sign * 1j / k * hypersingular(k, r, rs, n, ns)
            )

        return line_integral(integral_function, corners[0], corners[1], singular)
Example #2
0
def radimp(wf, dia):
    """calculatio radiation impedance for each frequency"""
    if not wf > 0:
        return 0

    if dia > 0:
        if _rad_calc == 'NONE':
            return 0  # simple open end impedance
        else:
            s = dia*dia*np.pi/4.0
            k = wf/_c0
            x = k*dia

            re = _rhoc0/s*(1 - special.jn(1, x)/x*2)  # 1st order bessel function.
            im = _rhoc0/s*special.struve(1, x)/x*2  # 1st order struve function.

            if _rad_calc == 'BAFFLE':
                zr = re + im*1j
            elif _rad_calc == 'PIPE':
                # real is about 0.5 times and imaginary is 0.7 times when without frange.
                zr = 0.5*re + 0.7*im*1j

            return zr
    else:
        return np.inf  # closed end
Example #3
0
def randFunc(x, sdev):

    functions = [
        np.sin(x),
        np.cos(x),
        special.gammaln(x),
        np.sqrt(x),
        np.log(x),
        np.log10(x),
        special.erf(x),
        np.square(x),
        special.struve(np.random.uniform(0, 2), x),
        special.rgamma(x)
    ]

    index = np.random.randint(0, int(len(functions)))

    choice = functions[index] / max(functions[index])
    choice = (choice**2)**0.5
    choice *= np.random.uniform(0, 150)
    choice += 10

    for k in range(len(x)):
        devSN = np.random.normal(0, sdev)
        choice[k] += devSN

    return (choice)
Example #4
0
def G_int_sp(x_in):
    """Special function solution of G(x) (Coulomb integral)
    Defined in Eq. (17b) Mares and Chuang, J. Appl. Phys. 74, 1388 (1993)

    Keyword arguments:
       x_in -- Normalized 2|ze-zh|/lambda
    """

    G = x_in*(sp.pi/2.0*(sps.struve(1,x_in)-sps.y1(x_in))-1)
    G[x_in <= 1.0E-8] = 1.0    
      
    return G
Example #5
0
def _create_plot_component():

    x = linspace(-2.0, 10.0, 100)
    pd = ArrayPlotData(x=x)

    # Create some line plots of some of the data
    plot = Plot(pd, padding=50, border_visible=True, overlay_border=True)
    plot.legend.visible = True

    # Extend the plot's list of drawing layers
    ndx = plot.draw_order.index("plot")
    plot.draw_order[ndx:ndx] = ["bessel", "sine", "struve"]

    # Draw struve
    for i in range(3):
        y_name = "struve" + str(i)
        pd.set_data(y_name, struve(i, x))
        renderer = plot.plot(("x", y_name),
                             color="blue",
                             name=y_name,
                             line_width=2)[0]
        renderer.draw_layer = "struve"
        renderer.unified_draw = True

    # Draw bessels
    for i in range(3):
        y_name = "bessel" + str(i)
        pd.set_data(y_name, jn(i, x))
        renderer = plot.plot(("x", y_name),
                             color="green",
                             name=y_name,
                             line_width=2)[0]
        renderer.draw_layer = "bessel"
        renderer.unified_draw = True

    # Draw sines
    for i in range(3):
        y_name = "sine" + str(i)
        pd.set_data(y_name, sin(x * (i + 1) / 1.5))
        renderer = plot.plot(("x", y_name),
                             color="red",
                             name=y_name,
                             line_width=2)[0]
        renderer.draw_layer = "sine"
        renderer.unified_draw = True

    # Attach some tools to the plot
    plot.tools.append(PanTool(plot))
    zoom = ZoomTool(component=plot, tool_mode="box", always_on=False)
    plot.overlays.append(zoom)

    return plot
Example #6
0
def Hv_zeros(order, n):
    """
    Calculates the first 20 zeros of the Struve function of arbitrary order
    :param order: order of the Struve function
    :param n: number of zeros returned (max 20)
    """
    # x-vector - use only positive part, Struve functions are
    # even (if order is odd) or odd( if order is even)
    x = np.arange(0., 70., 0.0001)
    H = struve(order, x)
    xi = zero_crossings(x, H)
    xi[0] = 0.
    return xi[1:n + 1]
def keldysh_interaction(radius, radius_0, ep12):
    """
    Keldysh Interaction.
    :param radius: Distance from centre
    :param radius_0: Scale distance corresponding to inherent screening.
    :param ep12: average of top and bottome dielectric constants.
    :return: interaction
    """
    term_arg = (radius / radius_0) * ep12
    struve_term = spec.struve(0, term_arg)
    bessel_term = spec.y0(term_arg)
    interaction = keldysh_prefactor / radius_0 * (struve_term - bessel_term)
    return interaction
    def misc_flatspectrum_plots(self):
        """ Miscilanous plots for the flat spectrum paper """
        self.logger.debug("Entering misc_flatspectrum_plots")

        # Plot piston resistance and reactance functions
        from scipy.special import j1, struve

        x = arange(0, 15, 0.001)

        r1 = lambda x: 1 - 2 * j1(x) / x
        x1 = lambda x: 2 * struve(1, x) / x

        plot(x, r1(x), label="$R_{1}\left(x)\\right)$")
        plot(x, x1(x), linestyle="--", color="black", label="$X_{1}\left(x)\\right)$")

        xlim([0, 13])
        annotate("$R_{1}(x)$", xy=(10, r1(10)), xycoords="data", xytext=(10.5, r1(10.5) - 0.2),
                    arrowprops=dict(arrowstyle="->"))
        annotate("$X_{1}(x)$", xy=(5, x1(5)), xycoords="data", xytext=(6, x1(6) + 0.2),
                    arrowprops=dict(arrowstyle="->"))
        grid(True)
        savefig("Analysis/Images/piston_impedance_functions.eps")

        # Plot the piston resisance for a 100mm piston
        cla()
        a = 0.055
        c = 340
        p0 = 1.2250
        f = arange(100, 10000, 0.01)
        k = 2 * pi * f / c
        Rr = p0 * c * pi * a ** 2 * r1(2 * k * a)

        normalized_Rr = 10 * log10(Rr) - 10 * log10(Rr[-1])
        semilogx(f, normalized_Rr)
        ax = gca()
        ax.set_xticks([16, 20, 25, 31.5, 40, 50, 63, 80, 100, 125,
            160, 200, 250, 315, 400, 500, 630, 800, 1000, 1250, 1600, 2000, 2500, 3150,
            4000, 5000, 6300, 8000, 1000, 12500])
        ax.set_xticklabels([16, 20, 25, 31.5, 40, 50, 63, 80, 100, 125,
            160, 200, 250, 315, 400, 500, 630, 800, 1000, 1250, 1600, 2000, 2500, 3150,
            4000, 5000, 6300, 8000, 1000, 12500])
        xlim(100, 5000)

        for label in ax.get_xticklabels():
            label.set_rotation('vertical')

        grid(True)
        subplots_adjust(left=0.15, right=0.97, top=0.97, bottom=0.15)
        xlabel("Frequency Hz")
        ylabel("dB re $R_{1}(2ka) = 1$")
        savefig("Analysis/Images/piston_resistance_100mm.eps")
Example #9
0
def kernel_fn(r: float) -> float:
    """

    Args:
        r: distance from center, expressed in terms of grid position

    Returns:
        value of U(r)
    """
    alpha = 1.0
    r0 = 10
    # TODO Fix this value to r -> 0
    if r == 0:
        return -2 * alpha / r0

    H0 = special.yn(0, r / r0)
    Y0 = special.struve(0, r / r0)
    return alpha / r0 * (H0 - Y0)
Example #10
0
def _create_plot_component():

    x = linspace(-2.0, 10.0, 100)
    pd = ArrayPlotData(x = x)

    # Create some line plots of some of the data
    plot = Plot(pd, padding=50, border_visible=True, overlay_border=True)
    plot.legend.visible = True

    # Extend the plot's list of drawing layers
    ndx = plot.draw_order.index("plot")
    plot.draw_order[ndx:ndx] = ["bessel", "sine", "struve"]

    # Draw struve
    for i in range(3):
        y_name = "struve" + str(i)
        pd.set_data(y_name, struve(i, x))
        renderer = plot.plot(("x", y_name), color="blue", name=y_name, line_width=2)[0]
        renderer.set(draw_layer = "struve", unified_draw=True)

    # Draw bessels
    for i in range(3):
        y_name = "bessel" + str(i)
        pd.set_data(y_name, jn(i,x))
        renderer = plot.plot(("x", y_name), color="green", name=y_name, line_width=2)[0]
        renderer.set(draw_layer = "bessel", unified_draw=True)

    # Draw sines
    for i in range(3):
        y_name = "sine" + str(i)
        pd.set_data(y_name, sin(x * (i+1) / 1.5))
        renderer = plot.plot(("x", y_name), color="red", name=y_name, line_width=2)[0]
        renderer.set(draw_layer="sine", unified_draw=True)

    # Attach some tools to the plot
    plot.tools.append(PanTool(plot))
    zoom = ZoomTool(component=plot, tool_mode="box", always_on=False)
    plot.overlays.append(zoom)

    return plot
Example #11
0
def randFunc(x,sdev):

    tempDM = x/np.amax(x)
    functions = [
                special.gammaln(tempDM),
                np.sqrt(tempDM), np.log(tempDM), np.log10(tempDM), 
                special.erf(tempDM), np.square(tempDM),
                special.struve(np.random.uniform(0,2),tempDM)
                #special.rgamma(x)
                ]

    randVar = np.random.uniform(0,1)
    combProb = 1/2
    
    if randVar < combProb:
        indices = np.random.randint(0, len(functions), 2)
        distA = functions[indices[0]]
        distB = functions[indices[1]]
        choice = np.concatenate((distA, distB))
        choice = np.random.choice(choice, size = len(tempDM), replace = False)
    else:
        indices = np.random.randint(0, int(len(functions)))
        choice = functions[indices]

    choice /= np.amax(choice)
    choice = (choice**2)**0.5
    choice *= np.random.uniform(2, 32)
    choice += 8
    
    for k in range(len(tempDM)):
        devSN = np.random.normal(0,sdev)
        choice[k] += devSN
        
    fig2 = plt.figure()
    ax2 = fig2.add_subplot(111)
    ax2.scatter(x, choice)
    ax2.set_title(indices)
    
    return(choice)
def true_func(x):
	return struve(0, x) - y0(x)
Example #13
0
from scipy.special import struve, y0, yn
from fast_interp import FunctionGenerator as FG

def protect(F):
	def new_func(x):
		if isinstance(x, np.ndarray):
			dtype = type(F(1))
			sel = x > 1e-10
			out = np.zeros(x.shape, dtype=dtype)
			out[sel] = F(x[sel])
		else:
			out = 0.0 if x < 1e-10 else F(x)
		return out
	return new_func

H0 = FG(lambda x: struve( 0, x), 1e-10, 10)
H1 = FG(lambda x: struve(-1, x), 1e-10, 10)
H2 = FG(lambda x: struve(-2, x), 1e-10, 10)
H3 = FG(lambda x: struve(-3, x), 1e-10, 10)
Y0 = FG(lambda x: y0(x),         1e-10, 10)
Y1 = FG(lambda x: yn(1, x),      1e-10, 10)
Y2 = FG(lambda x: yn(2, x),      1e-10, 10)

"""
Test how to do biharmonic FMM using cloud of points...
"""

def random3(N):
	a1 = np.random.rand(N)-0.5
	a2 = np.random.rand(N)-0.5
	a3 = np.random.rand(N)-0.5
Example #14
0
def X(x):
	return struve(1, x) / x
Example #15
0
def chi(omega, r_mouth):
	"""Reactive part of impedance"""
	return struve(1, omega * r_mouth) / omega / r_mouth
Example #16
0
import numpy as np
from scipy import special
from matplotlib import pyplot as plt


tempDM = np.linspace(0.001, 10, 10000)      # X-vals to evaluate the distributions over
    
functions = np.array([      # Possible distributions that noise can follow
            special.gammaln(tempDM), np.sqrt(tempDM), np.log(tempDM),
            -special.gammaln(tempDM), -np.sqrt(tempDM), -np.log(tempDM),
            special.erf(tempDM), np.square(tempDM),
            -special.erf(tempDM), -np.square(tempDM),
            special.struve(0,tempDM), special.struve(1,tempDM), special.struve(2,tempDM),
            -special.struve(0,tempDM), -special.struve(1,tempDM), -special.struve(2,tempDM),
            [np.random.uniform(0, 5)]*len(tempDM), tempDM, -tempDM, special.rgamma(tempDM)
            ])


def generation(numPoints, upperDM):
    """Randomly pick shapes for noise to follow. With probability of multiple, different,
    distributions (as well as their inverted counterparts) to be convolved with each other and
    form unpredictable shapes.

    Keyword arguments:
    numPoints -- the number of points that the noise/fake signal will have
    upperDM -- the highest DM for the data (w.r.t. 0), to be multiplied by the normalised plot in the end
    """
    
    np.random.seed()    # As random seeds are used at some points this just ensure it is reset every time
    
    convProb = 3/4      # Probability of convolution of a signal taking place
Example #17
0
def base_gf(x):
    Y = y0(x)
    H = struve(0, x)
    return 0.25 * (H - Y)
Example #18
0
def GF(x):
    Y = yn(1, x)
    S3 = struve(-3, x)
    S2 = struve(-2, x)
    return (x * (Y - S3) - 4 * S2) / x**2
Example #19
0
    def __init__(self,
                 N,
                 vb,
                 cb,
                 epsilon,
                 r0=33.875,
                 shift=0.5,
                 spin_orbit=True,
                 cutoff=np.inf):
        if spin_orbit:
            self.model = tbmodels.Model.from_wannier_files(
                hr_file='TB-Models/MoS2_hr.dat',
                wsvec_file='TB-Models/MoS2_wsvec.dat',
                xyz_file='TB-Models/MoS2_centres.xyz',
                win_file='TB-Models/MoS2.win')
        else:
            self.model = tbmodels.Model.from_wannier_files(
                hr_file='TB-Models/wann_hr.dat',
                wsvec_file='TB-Models/wann_wsvec.dat',
                xyz_file='TB-Models/wann_centres.xyz',
                win_file='TB-Models/wann.win')
        self.k1 = self.model.reciprocal_lattice[0]
        self.k2 = self.model.reciprocal_lattice[1]
        self.a1 = self.model.uc[0]
        self.a2 = self.model.uc[1]
        self.norb = self.model.hamilton([0., 0., 0.]).shape[0]
        self.cutoff = cutoff

        self.epsilon = epsilon  #
        self.r0 = r0 / epsilon
        self.shift = shift  # scissor operator
        self.N = N  # k-points grid
        self.vb = vb  # valence bands
        self.cb = cb  # conduction bands
        self.nv = len(self.vb)
        self.nc = len(self.cb)

        self.E = np.zeros((N, N, self.norb))
        self.K = np.zeros((N, N, 3))
        self.D = np.zeros((N, N, self.norb, self.norb), dtype=np.complex)
        self.H = np.zeros((N, N, self.norb, self.norb), dtype=np.complex)
        for i, j in product(range(N), range(N)):
            self.H[i, j] = self.model.hamilton([i / N, j / N, 0])
            e, d = np.linalg.eigh(self.H[i, j])
            self.E[i, j] = e
            self.D[i, j] = d
            self.K[i, j] = i * self.k1 / N + j * self.k2 / N

        R = np.zeros((N, N, 3))
        for i, j in product(range(N), range(N)):
            R[i, j] = self.a1 * (i - N / 2) + self.a2 * (j - N / 2)
        self.R = R
        WR = np.zeros((N, N))
        VR = np.zeros((N, N))
        for i, j in product(range(N), range(N)):
            radius = np.linalg.norm(R[i, j])
            if radius != 0:
                WR[i, j] = Hartree * Bohr * np.pi / (
                    2 * self.epsilon * self.r0) * (
                        struve(0, radius / self.r0) - yn(0, radius / self.r0))
                VR[i, j] = Hartree * Bohr / radius
            else:
                WR[i, j] = 0
                VR[i, j] = 0

        WR = np.fft.fftshift(WR)
        self.W = np.fft.fft2(WR) / N**2
        VR = np.fft.fftshift(VR)
        self.V = np.fft.fft2(VR) / N**2

        self.gap = self.E[:, :, cb[0]] - self.E[:, :, vb[-1]] + shift
        self.Egap = np.min(self.gap)
        self.weight = np.ones((self.N, self.N))

        self.weight[self.gap > (self.Egap + self.cutoff)] = 0
        self.indexes = []
        for kx, ky in product(range(self.N), range(self.N)):
            if self.weight[kx, ky] == 1:
                for i, j in product(self.cb, self.vb):
                    self.indexes.append((kx, ky, i, j))
        self.NH = len(self.indexes)
        print('Exciton Hamiltonian size: ' + str(self.NH) + ' K-space size: ' +
              str(int(np.sum(self.weight))))

        R = np.fft.fftshift(self.R, axes=(0, 1))
        HR = np.fft.ifft2(self.H, axes=(0, 1))
        dx = np.fft.fft2(1j * R[:, :, 0, None, None] * HR, axes=(0, 1))
        dy = np.fft.fft2(1j * R[:, :, 1, None, None] * HR, axes=(0, 1))
        for i, j in product(range(N), range(N)):
            dx[i, j] = np.linalg.multi_dot(
                [self.D[i, j].T.conj(), dx[i, j], self.D[i, j]])
            dy[i, j] = np.linalg.multi_dot(
                [self.D[i, j].T.conj(), dy[i, j], self.D[i, j]])
        self.dx = dx
        self.dy = dy
Example #20
0
 def _init_values_struve(self):
     temp_values = np.arange(0, 20, 0.002)
     self.value_map = special.struve(1, temp_values)
     c_max = np.amax(self.value_map)
     np.multiply(self.value_map, 1.0 / c_max, out=self.value_map)
     self.value_map = np.concatenate((self.value_map, self.value_map[::-1]))
Example #21
0
File: qw.py Project: song1211/misc
def G(a, gamma):
    if abs(gamma) < 1.0e-9:
        return 1.0
    else:
        x = 2 * abs(gamma) / a
        return x * (np.pi / 2 * (sp.struve(1, x) - sp.y1(x)) - 1)
from mpl_toolkits.mplot3d import Axes3D
from matplotlib import cm
from matplotlib.ticker import LinearLocator, FormatStrFormatter
import matplotlib.pyplot as plt
from scipy import special
import numpy as np

fig = plt.figure()
ax = fig.gca(projection='3d')
X = np.arange(-5, 5, 0.25)
Y = np.arange(-5, 5, 0.25)
X, Y = np.meshgrid(X, Y)
R = np.sqrt(X**2 + Y**2)

Z = special.struve(0, R)
surf = ax.plot_surface(X,
                       Y,
                       Z,
                       rstride=1,
                       cstride=1,
                       cmap=cm.coolwarm,
                       linewidth=0,
                       antialiased=False)
ax.set_zlim(None, None)
ax.zaxis.set_major_locator(LinearLocator(10))
ax.zaxis.set_major_formatter(FormatStrFormatter('%.02f'))

fig.colorbar(surf, shrink=0.5, aspect=5)
plt.show()
    def misc_flatspectrum_plots(self):
        """ Miscilanous plots for the flat spectrum paper """
        self.logger.debug("Entering misc_flatspectrum_plots")

        # Plot piston resistance and reactance functions
        from scipy.special import j1, struve

        x = arange(0, 15, 0.001)

        r1 = lambda x: 1 - 2 * j1(x) / x
        x1 = lambda x: 2 * struve(1, x) / x

        plot(x, r1(x), label="$R_{1}\left(x)\\right)$")
        plot(x,
             x1(x),
             linestyle="--",
             color="black",
             label="$X_{1}\left(x)\\right)$")

        xlim([0, 13])
        annotate("$R_{1}(x)$",
                 xy=(10, r1(10)),
                 xycoords="data",
                 xytext=(10.5, r1(10.5) - 0.2),
                 arrowprops=dict(arrowstyle="->"))
        annotate("$X_{1}(x)$",
                 xy=(5, x1(5)),
                 xycoords="data",
                 xytext=(6, x1(6) + 0.2),
                 arrowprops=dict(arrowstyle="->"))
        grid(True)
        savefig("Analysis/Images/piston_impedance_functions.eps")

        # Plot the piston resisance for a 100mm piston
        cla()
        a = 0.055
        c = 340
        p0 = 1.2250
        f = arange(100, 10000, 0.01)
        k = 2 * pi * f / c
        Rr = p0 * c * pi * a**2 * r1(2 * k * a)

        normalized_Rr = 10 * log10(Rr) - 10 * log10(Rr[-1])
        semilogx(f, normalized_Rr)
        ax = gca()
        ax.set_xticks([
            16, 20, 25, 31.5, 40, 50, 63, 80, 100, 125, 160, 200, 250, 315,
            400, 500, 630, 800, 1000, 1250, 1600, 2000, 2500, 3150, 4000, 5000,
            6300, 8000, 1000, 12500
        ])
        ax.set_xticklabels([
            16, 20, 25, 31.5, 40, 50, 63, 80, 100, 125, 160, 200, 250, 315,
            400, 500, 630, 800, 1000, 1250, 1600, 2000, 2500, 3150, 4000, 5000,
            6300, 8000, 1000, 12500
        ])
        xlim(100, 5000)

        for label in ax.get_xticklabels():
            label.set_rotation('vertical')

        grid(True)
        subplots_adjust(left=0.15, right=0.97, top=0.97, bottom=0.15)
        xlabel("Frequency Hz")
        ylabel("dB re $R_{1}(2ka) = 1$")
        savefig("Analysis/Images/piston_resistance_100mm.eps")