# inverse FFT for recreating radiation pattern

10 visualizzazioni (ultimi 30 giorni)
fima v il 23 Mar 2024
Risposto: Umeshraja il 9 Ago 2024 alle 12:21
Hello,I have created a code which created the plot below. The heart of the code is the AF expression.(array factor) I want to do the inverse process , to take the plot do the inverse of it and somehow to find using optimization the coeffects(genetic algorithm) which will recreate the plot. my plot is from -90 to 90 degrees what could be done next to continue the process? Is there a manual you could reccomend?
Thanks.
theta=linspace(-pi/2,pi/2,1000);
f=5.6;
N=6;
lambda=300/f;
d=0.8*lambda;
theta_0=pi*((0)/180);
amplitude_norm_V=[0.05,0.3,0.75,1,0.75,0.3,0.05];
k=(2*pi)/lambda;
delta=k*d*cos(theta_0);
x=sqrt(1/(sum(amplitude_norm_V.^2)));
real_voltage=amplitude_norm_V.*x;
real_power=(real_voltage.^2);
sum(real_power);
phases=[0,0,0,0,0,0,0]
total=0;
tot=0;
for z=1:6
AF=real_voltage(z)*exp(1i*(phases(z)/180*pi))*exp(-1i*(z-1)*k*d*cos(theta)+1i*(z-1)*delta);
total=total+AF;
end
plot((theta/pi)*180,20*log10(total));
sin_p=cos(theta_0)+lambda/d;
##### 0 CommentiMostra -2 commenti meno recentiNascondi -2 commenti meno recenti

Accedi per commentare.

### Risposte (1)

Umeshraja il 9 Ago 2024 alle 12:21
Hi,
I can understand that you wanted to find the set of amplitudes and phases for the array elements that produce a radiation pattern matching a given target plot. You can solve this using a Genetic Algorithm (GA). GA is a stochastic optimization algorithm that can find approximate solutions to such optimization problems. Here’s an outline of how it works:
• Selection: Evaluate the fitness of each solution and retaining best performing ones.
• Crossover: Combine pairs of solutions to create new offspring.
• Mutation: Introduce random changes to some solutions to maintain diversity.
• Iteration: Repeat the selection, crossover, and mutation steps until convergence.
This can be implemented using the Global Optimization Toolbox in MATLAB. Below is a demonstration of the Genetic Algorithm approach:
% Define the target plot (this should be your original plot data)
theta = linspace(-pi/2, pi/2, 1000);
f = 5.6;
N = 6;
lambda = 300 / f;
d = 0.8 * lambda;
theta_0 = pi * ((0) / 180);
k = (2 * pi) / lambda;
delta = k * d * cos(theta_0);
rng default
% Assume amplitude_norm_V and phases are known for the target plot
amplitude_norm_V = [0.05, 0.3, 0.75, 1, 0.75, 0.3, 0.05];
real_voltage = amplitude_norm_V .* sqrt(1 / sum(amplitude_norm_V.^2));
phases = [0, 0, 0, 0, 0, 0];
% Calculate the target plot
total = 0;
for z = 1:N
AF = real_voltage(z) * exp(1i * (phases(z) / 180 * pi)) * exp(-1i * (z-1) * k * d * cos(theta) + 1i * (z-1) * delta);
total = total + AF;
end
target_plot=abs(total);
% Define the objective function
function error = objective_function(coeffs, target_plot, theta, f, N, d, theta_0)
lambda = 300 / f;
k = (2 * pi) / lambda;
delta = k * d * cos(theta_0);
real_voltage = coeffs(1:N);
phases = coeffs(N+1:end);
total = 0;
for z = 1:N
AF = real_voltage(z) * exp(1i * (phases(z) / 180 * pi)) * exp(-1i * (z-1) * k * d * cos(theta) + 1i * (z-1) * delta);
total = total + AF;
end
generated_plot=abs(total);
error = sum((target_plot - generated_plot).^2); % Mean squared error
end
% Set up the genetic algorithm
population_size = 100;
num_generations = 200;
num_coeffs = 2 * N; % N amplitudes + N phases
lb = [zeros(1, N), -90 * ones(1, N)]; % Lower bounds for amplitudes and phases
ub = [ones(1, N), 90 * ones(1, N)]; % Upper bounds for amplitudes and phases
rng default % For reproducibility
options = optimoptions('ga', 'PopulationSize', population_size, 'MaxGenerations', num_generations);
% Run the genetic algorithm
[optimal_coeffs, fval] = ga(@(coeffs) objective_function(coeffs, target_plot, theta, f, N, d, theta_0), num_coeffs, [], [], [], [], lb, ub, [], options);
ga stopped because it exceeded options.MaxGenerations.
% Extract the optimized amplitudes and phases
optimized_amplitudes = optimal_coeffs(1:N);
optimized_phases = optimal_coeffs(N+1:end);
% Validate the solution
total = 0;
for z = 1:N
AF = optimized_amplitudes(z) * exp(1i * (optimized_phases(z) / 180 * pi)) * exp(-1i * (z-1) * k * d * cos(theta) + 1i * (z-1) * delta);
total = total + AF;
end
generated_plot = 20 * log10(abs(total));
target_plot= 20*log10(target_plot);
% Plot the original and generated plots for comparison
figure;
plot((theta / pi) * 180, target_plot , 'b', 'DisplayName', 'Target Plot');
hold on;
plot((theta / pi) * 180, generated_plot, 'r--', 'DisplayName', 'Generated Plot');
legend;
xlim([-90 90])
xlabel('Angle (degrees)');
ylabel('Magnitude (dB)');
title('Comparison of Target and Generated Plots');
You can tune the Genetic Algorithm Parameters for better exploration and convergence. Feel free to adjust objective function or any parameters to better suit your specific needs.
For more details on Genetic Algorithm, you can refer to the following documentation:
I hope it helps!
##### 0 CommentiMostra -2 commenti meno recentiNascondi -2 commenti meno recenti

Accedi per commentare.

### Categorie

Scopri di più su Genetic Algorithm in Help Center e File Exchange

### Community Treasure Hunt

Find the treasures in MATLAB Central and discover how the community can help you!

Start Hunting!

Translated by