# Define input wave properties
frequency = 20e6
wavelength = speed_of_light/frequency
input_angle = 120*np.pi/180
# Create a plane with a circle in the middle
epsilon_circle = plane_with_circle(plane_size, step_size, 10, 4.7)
# Convert grid to dynamic
max_size = 4
size_limits = [0, 6, 12]
locations, location_sizes, epsilon = grid_to_dynamic(epsilon_circle, step_size, size_limits)
# Convert back to test
farfield_samples = 0
epsilon_grid = dynamic_to_grid(locations, epsilon, location_sizes, plane_size, step_size)
show_plane(np.real(epsilon_grid), step_size)
# Plot location points on plane
fig = plt.figure()
for loc in locations:
plt.scatter(loc[0], loc[1], s=5, color='black')
plt.gca().set_aspect('equal')
plt.ylim(0, plane_size[1])
plt.xlim(0, plane_size[0])
plt.xlabel("X [m]")
plt.ylabel("Y [m]")
# Calculate incident wave on locations
E_0 = np.sqrt(mu_0/epsilon_0) # Amplitude of incident wave
E_incident = create_planewave(locations, E_0, wavelength, input_angle, plane_size, step_size)
def domain_integral_equation(simparams):
#Initialization: read parameters from dictionary
wavelength = simparams['wavelength']
# wavelength = wavelength of incident plane wave
permittivity = simparams['relative_permittivity']
# relative_permittivity = relative permittivity at all evaluation points
input_angle = simparams['input_angle']
# input_angle = angle of incident wave, with respect to x-axis
step_size = simparams['step_size']
# step_size = physical distance between points in relative_permittivity
simulation_size = simparams['simulation_size']
# array containing number of evaluation points in x,y-directions
if 'dynamic_sample_distance' in simparams:
dynamic_sample_distance = simparams['dynamic_sample_distance']
size_limits = simparams['size_limits']
else:
dynamic_sample_distance = False
if 'farfield_samples' in simparams:
farfield_samples = simparams['farfield_samples']
else:
farfield_samples = 0
# Prepare inputs for dynamic sampling distances
if dynamic_sample_distance:
locations, location_sizes, permittivity = grid_to_dynamic(
permittivity, step_size, size_limits)
else:
locations = (np.array(
list(np.ndindex(simulation_size[0], simulation_size[1]))) +
0.5) * step_size
location_sizes = np.ones(np.shape(locations)[0])
permittivity = np.matrix.flatten(permittivity)
# Prepare farfield samples if they are requested
if farfield_samples != 0:
# Add and calculate values farfield
ff_distance = 10 * wavelength #Farfield calculated at this distance from cylinder
ff_angle = np.linspace(
0, 2 * np.pi, farfield_samples, endpoint=False
) #Starting angle in radians 45 degrees from incident
# Locations of the farfield samples
loc_ff = np.array(
[np.cos(ff_angle + np.pi / 2),
np.sin(ff_angle + np.pi / 2)]).T * ff_distance
loc_ff = np.array([
loc_ff[:, 0] + simulation_size[0] / 2 * step_size,
loc_ff[:, 1] + simulation_size[0] / 2 * step_size
]).T #Shift locations around center of simulation plane
# Add the farfield samples to the simulation locations
locations = np.append(locations, loc_ff, axis=0)
location_sizes = np.append(location_sizes, np.ones(farfield_samples))
permittivity = np.append(
permittivity, np.ones(farfield_samples)
) #Farfield samples are in background medium, which is vacuum so permittivity is 1
# Calculate incident wave on locations
E_0 = np.sqrt(mu_0 /
epsilon_0) #Amplitude of incident wave in background medium
E_incident = create_planewave(locations, E_0, wavelength, input_angle,
simulation_size, step_size)
# Calculate scattering
E = martin98(locations, E_incident, permittivity, location_sizes,
wavelength, step_size)
# Extract farfield samples
if farfield_samples != 0:
E_ff = E[-farfield_samples:]
E = E[:-farfield_samples]
E_ff = E_ff / E_0 #Normalizing over E_0
else:
E_ff = []
# Convert result to grid again
if dynamic_sample_distance:
E_grid = np.conjugate(
dynamic_to_grid(locations[:len(E)], E, location_sizes[:len(E)],
simulation_size, step_size))
else:
E_grid = np.reshape(np.conjugate(E), simulation_size, order='C')
return E_grid.T, E_ff
def dynamic_shaping(simparams, farfield_samples):
#Initialization: read parameters from dictionary
locations = simparams['locations']
wavelength = simparams['wavelength']
# wavelength = wavelength of incident plane wave
permittivity = simparams['relative_permittivity']
# relative_permittivity = relative permittivity at all evaluation points
input_angle = simparams['input_angle']
# input_angle = angle of incident wave, with respect to x-axis
step_size = simparams['step_size']
# step_size = physical distance between points in relative_permittivity
location_sizes = simparams['location_sizes']
plane_size = simparams['simulation_size']
# array containing number of evaluation points in x,y-directions
epsilon_circle = simparams['relative_permittivity']
#Permittivity of the circle
simulation_size = plane_size
loc_ff = []
if (farfield_samples != 0):
#Add and calculate values farfield
ff_distance = 200 #Farfield calculated at this distance from cylinder
ff_angle = np.linspace(0, np.pi * 2 - 2 * np.pi / farfield_samples,
farfield_samples)
# for k in range(farfield_samples):
loc_ff = ([
np.cos(ff_angle) * ff_distance +
(simulation_size[0] / 2 * step_size),
np.sin(ff_angle) * ff_distance +
(simulation_size[1] / 2 * step_size)
])
# loc_ff = ([np.cos(ff_angle)*ff_distance, np.sin(ff_angle)*ff_distance])
loc_ff = np.transpose(np.reshape(loc_ff, (2, farfield_samples)))
# loc_ff = loc_ff+np.sqrt(2*(simulation_size[0]/2*step_size)**2)
# loc_ff = loc_ff+(simulation_size[0]/2*step_size)
locations = np.append(
locations, loc_ff,
axis=0) # Add ff locations, with respective size and permittivity
location_sizes = np.append(location_sizes, np.ones(farfield_samples))
permittivity = np.append(permittivity, np.ones(farfield_samples))
# Convert back to test
epsilon_grid = dynamic_to_grid(locations, permittivity, location_sizes,
plane_size, step_size, farfield_samples)
# Calculate incident wave on locations
E_0 = np.sqrt(mu_0 / epsilon_0) # Amplitude of incident wave
E_incident = create_planewave(locations, E_0, wavelength, input_angle,
simulation_size, step_size)
# Convert to grid again
E_incident_grid = dynamic_to_grid(locations, E_incident,
location_sizes, plane_size,
step_size, farfield_samples)
# Calculate scattering
E = martin98(locations, E_incident, permittivity, location_sizes,
wavelength, step_size)
#Taking out farfield samples
E_ff = E[len(E) - farfield_samples:len(E)]
E_ff = E_ff / E_0
E_ff = E_ff * ff_distance #Cancelling the 1/r dependence
E = E[0:len(E) - farfield_samples]
# Convert result to grid
E_grid = dynamic_to_grid(locations, E, location_sizes, plane_size,
step_size, farfield_samples)
show_plane_ff(np.absolute(E_ff),
loc_ff,
ff_angle,
ff_distance,
title="Locations farfield of algorithm solution")
else:
# Convert back to test
epsilon_grid = dynamic_to_grid(locations, permittivity, location_sizes,
plane_size, step_size, farfield_samples)
# Calculate incident wave on locations
E_0 = np.sqrt(mu_0 / epsilon_0) # Amplitude of incident wave
E_incident = create_planewave(locations, E_0, wavelength, input_angle,
simulation_size, step_size)
# Convert to grid again
E_incident_grid = dynamic_to_grid(locations, E_incident,
location_sizes, plane_size,
step_size, farfield_samples)
# Calculate scattering
E = martin98(locations, E_incident, permittivity, location_sizes,
wavelength, step_size)
# Convert result to grid
E_grid = dynamic_to_grid(locations, E, location_sizes, plane_size,
step_size, farfield_samples)
E_ff = []
return E_grid, E_ff
input_angle = 120 * np.pi / 180
diameter_cylinder = 50
cylinder_permittivity = 4.7
# Create a plane with a circle in the middle
epsilon_circle = plane_with_circle(plane_size, step_size, diameter_cylinder,
cylinder_permittivity)
# Convert grid to dynamic
max_size = 4
size_limits = [0, 200, 400]
locations, location_sizes, permittivity = grid_to_dynamic(
epsilon_circle, step_size, size_limits)
# Calculate incident wave on locations
E_0 = np.sqrt(mu_0 /
epsilon_0) #Amplitude of incident wave in background medium
E_incident = create_planewave(locations, E_0, wavelength, input_angle,
plane_size, step_size)
# Calculate the scattered field
E = martin98(locations, E_incident, permittivity, location_sizes, wavelength,
step_size)
# Convert dynamic locations to grid
E_grid = dynamic_to_grid(locations, E, location_sizes, plane_size, step_size)
# Show the scattering
show_plane(np.absolute(E_grid.T),
step_size,
title="E field of algorithm solution")
'radius': circle_diameter/2,
'epsilon_r': circle_permittivity,
'incident_angle': input_angle,
'modes': 50, #used in jupyter notebook example
'evaluation_points_x': xpoints,
'evaluation_points_y': ypoints
}
# Compute E-field using TEcil
start_analytical = timer()
_, _, E_fieldval_dyn, E_inval = Analytical_2D_TE(simparams)
end_analytical = timer()
print("Analytical solution found in {} seconds".format(end_analytical-start_analytical))
# Show the validation E field
E_fieldval_dyn = dynamic_to_grid(locations,E_fieldval_dyn,location_sizes,simulation_size,step_size, 0)
show_plane(np.absolute(E_fieldval_dyn), step_size, title="E field of analytical solution on dynamic grid")
"""
Error Calculation
"""
# # Calculate difference in magnitude between implementation and validation
E_difference_grid = np.abs(E_fieldval_dyn) - np.abs(E_grid)
# # Get the error between analytical and algorithm in percentage
E_griderror = np.abs(E_difference_grid)/np.abs(E_fieldval_dyn) * 100
E_griderror_abs, E_griderror_norm = energybased_error(E_fieldval_dyn,E_grid)
# # Plot the error