inverse FFT for recreating radiation pattern

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;

Answer 1

[Umeshraja]

Hi @fima v,

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:

• Initialization: Start with a randomly generated population of potential solutions.
• 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:

https://www.mathworks.com/help/gads/ga.html?s_tid=doc_ta

https://www.mathworks.com/help/gads/genetic-algorithm-options.html

I hope it helps!