# 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