User:Balluwun-enjoyer

Hello

Aloha, namaste, greetings, etc.

I work in aerospace research, and generally try to edit within this field. If I have code that can produce pretty plots to help explain things in an article, I'll put some of those plots in the article, and dump the code on this page.

Code Snippets

Array Factor

import multiprocessing as mp
import numpy as np
import matplotlib.pyplot as plt
import matplotlib
matplotlib.rcParams['text.usetex'] = True

# configurable values

freq = 1e9

steering_azimuth = 0
steering_elevation = 0

array_dims = [16,16]
array_lambda_spacing = 2.0

# deduced values

steering_azimuth *= np.pi / 180
steering_elevation *= np.pi / 180

steering_theta = np.arccos(np.cos(steering_azimuth) * np.cos(steering_elevation))
steering_phi = np.arctan2(np.sin(steering_elevation),np.sin(steering_azimuth) * np.cos(steering_elevation))

wavelength = 3e8/freq
k = 2.0 * np.pi * freq / 3e8
d = wavelength * array_lambda_spacing

azimuth_meshgrid, elevation_meshgrid = np.meshgrid(np.linspace(-60,60,800),np.linspace(60,-60,800))

azimuth_meshgrid *= np.pi / 180.
elevation_meshgrid *= np.pi / 180.

theta = np.arccos(np.cos(azimuth_meshgrid) * np.cos(elevation_meshgrid))
phi = np.arctan2(np.sin(elevation_meshgrid),np.sin(azimuth_meshgrid) * np.cos(elevation_meshgrid))

af = np.ndarray(shape=np.shape(phi), dtype=np.complex64)

af.fill(0+0.j)

beta_x = -k * d * np.sin(steering_theta) * np.cos(steering_phi)
beta_y = -k * d * np.sin(steering_theta) * np.sin(steering_phi)

phase_x = k * d * np.sin(theta) * np.cos(phi) + beta_x
phase_y = k * d * np.sin(theta) * np.sin(phi) + beta_y

for n in range(array_dims[0]):
    
    y_comp = np.exp(1.j * n * phase_y)
    
    af_x = np.ndarray(shape=np.shape(phi), dtype=np.complex64)

    af_x.fill(0+0.j)
    
    for m in range(array_dims[1]):
        
        af_x += np.exp(1.j * m * phase_x)
        
    af += af_x * y_comp
    
af = 10*np.log10(np.abs(af))
    
plt.title(r'$' + f'{array_dims[0]}' + r'\times' + f'{array_dims[1]}' + '\mathrm{\;Array,\;} ' + f'{array_lambda_spacing}' + r'\lambda\mathrm{\; Spacing}$', fontsize=20)
plt.pcolormesh(azimuth_meshgrid * 180. / np. pi, elevation_meshgrid * 180. / np.pi, af, vmin=-50)
plt.xlabel(r"$\mathrm{Azimuth\;(degrees)}$", fontsize=18)
plt.ylabel(r"$\mathrm{Elevation\;(degrees)}$", fontsize=18)
plt.gca().invert_xaxis()
plt.xticks(fontsize=16)
plt.yticks(fontsize=16)
cbar = plt.colorbar()
cbar.ax.tick_params(labelsize=16)
cbar.set_label(r"$10\log_{10}\|\mathrm{AF}\|$", fontsize=20, rotation=-90, labelpad=24)
dp_val = int(np.floor(array_lambda_spacing))
pd_val = int(1000 * array_lambda_spacing - dp_val * 1000)            
plt.savefig(f'phased-array/{array_dims[0]}x{array_dims[1]}_{dp_val}p{pd_val}_lambda_spacing_planar_array_factor.png', dpi=500, bbox_inches='tight')
plt.close()

Ackley Function

import numpy as np
import matplotlib.pylab as plt
import matplotlib
matplotlib.rcParams['text.usetex'] = True

x_linspace, y_linspace = np.meshgrid(np.linspace(-5,5,1500),np.linspace(-5,5,1500))

ackley = -20. * np.exp(-0.2 * np.sqrt(0.5 * (x_linspace**2 + y_linspace**2))) - np.exp(0.5 * (np.cos(2 * np.pi * x_linspace) + np.cos(2 * np.pi * y_linspace))) + np.e + 20

plt.pcolormesh(x_linspace, y_linspace, ackley)
plt.xlabel(r"$x$", fontsize=20)
plt.ylabel(r"$y$", fontsize=20)
plt.xticks(fontsize=18)
plt.yticks(fontsize=18)
cbar = plt.colorbar(ticks=np.linspace(0,14,8))
cbar.ax.tick_params(labelsize=18)
cbar.set_label(r"$f\left(x,y\right)$", fontsize=20, rotation=-90, labelpad=24)
contour_lines = plt.contour(x_linspace, y_linspace, ackley, colors='w', levels=np.linspace(2,14,7), linewidths=0.5)
plt.gca().set_aspect(1)
plt.tight_layout()
plt.savefig(f'ackley-function/ackley_2d.png', dpi=500, bbox_inches='tight')
plt.close()