How to plot far-field 3D power pattern in dBi?

[CoolNamesAllTaken]

I'm just getting started with trying out OpenEMS, and I'm excited by the capability it seems to offer!

One question I had was how to plot the 3D directivity pattern of the an antenna in dBi. I can see that the example scripts use the plotFF3D function to generate the far-field electric field pattern (V/m) on a linear or logarithmic scale, but I haven't found a function that can plot the same 3D far-field pattern relative to an isotropic far-field pattern (dBi). I think that I've seen some 3D power pattern plots generated by OpenEMS, so I feel like this feature probably exists and I just haven't found it yet.

What I've found so far:

• plotFF3D - generates far-field electric field pattern in 3D.
• plotFFdB - generates plots for far-field power pattern, but only in 2D.

Is there a version of plotFFdB that generates a 3D plot? It looks pretty straightforward to mash some plotFFdB and plotFF3D together to generate a surface plot for power directivity, but I wanted to make sure I wasn't straying too far off the beaten path before jumping into that.

[CoolNamesAllTaken]

I ended up writing a function to do this! It will also plot the antenna geometry itself, as long as it's made of only CSX boxes and you have matGeom installed and matGeom/matGeom added to your path. Could also be refactored to use MATLAB / Octave's built-in mesh3 function instead with pretty minimal effort.

I wanted to separate out the antenna / radiation pattern plotting from the OpenEMS simulation workflow so that I could plot antennas after a run completed, so this script assumes that all of the necessary variables from examples/antennas/inverted_f.m are saved as a file called variables.mat. Variables like nf2ff etc are pulled from there. The antennas in the screenshots are from a different project, and not the inverted_f.m example.

function plot_antenna_3d(varargin)
% plot_antenna_3d(varargin)
% Plots antenna geometry on top of the currently active figure.
% 
% Input:
%   ignore_attrs: List of CSX attributes to ignore (not draw geometry for).
%   save_dir: Directory to scrape the antenna out of.
% 
% Variable Input:
%   'ignore_attrs': Cell array of strings indicating attributes to ignore.

    save_dir = ["output", "/", 'mifa_l=52.0mm'];

    ignore_attrs = {'groundplane'};
    figs = []

    for i=1:2:nargin
        switch varargin{i}
            % case 'theta_range'
            %     theta_range = varargin{i+1}
            % case 'phi_range'
            %     phi_range = varargin{i+1}
            case 'ignore_attrs'
                ignore_attrs = varargin{i+1};
            case 'save_dir'
                save_dir = varargin{i+1};
        end
    end

    sim_vars = load([save_dir, "/", "variables.mat"]);

    freq_index = 1;
    normalize = 0;

    nf2ff = sim_vars.nf2ff;
    D_log = nf2ff.E_norm{freq_index} / max(nf2ff.E_norm{freq_index}(:));
    D_log = 20*log10(D_log) + 10*log10(nf2ff.Dmax(freq_index));
    
    % Value of gain at the origin. WARNING: values lower than this will be reflected across the origin!
    ORIGIN_LOGSCALE = -20; % [dB]
    % Normalize directivity values so that they plot on the same scale as a normalized antenna shape.
    % Still using real directivity value for coloration.
    D_log_normalized = D_log ./ -ORIGIN_LOGSCALE + 1;
    D_log_normalized = D_log_normalized ./ max(D_log_normalized(:));

    titletext = sprintf('Directivity [dBi] @ f = %e Hz',nf2ff.freq(freq_index));

    [theta,phi] = ndgrid(nf2ff.theta,nf2ff.phi);
    x = D_log_normalized .* sin(theta) .* cos(phi);
    y = D_log_normalized .* sin(theta) .* sin(phi);
    z = D_log_normalized .* cos(theta);

    % Plot antenna directivity pattern as a solid surface.
    figs(end+1) = figure('NumberTitle', 'off', 'Name', save_dir);
    h = surf(x,y,z, D_log); % solid surface plot of directivity pattern
    set(h,'EdgeColor','none');
    axis equal
    axis off
    title(titletext)
    colorbar

    % Plot transparent mesh of the directivity pattern to show the antenna (alpha not implemented for surf() in Octave).
    figs(end+1) = figure('NumberTitle', 'off', 'Name', save_dir);
    h = mesh(x,y,z, D_log, 'facecolor', 'none', 'linestyle', ':'); % transparent mesh plot of directivity pattern
    axis equal
    axis off
    title(titletext)
    colorbar

    hold on;

    csx_metals = sim_vars.CSX.Properties.Metal;
    faces = {};
    max_dims = [];
    for i = 1:length(csx_metals)
        printf("Parsing metal object %d:\r\n", i);
        metal = csx_metals{i};
        printf("\tATTRIBUTE = %s\r\n", metal.ATTRIBUTE.Name)
        if any(strcmp(metal.ATTRIBUTE.Name, ignore_attrs))
            printf("\t\tIgnoring!\r\n")
            continue
        end
        for j = 1:length(metal.Primitives.Box)
            p1_att = metal.Primitives.Box{j}.P1.ATTRIBUTE;
            p2_att = metal.Primitives.Box{j}.P2.ATTRIBUTE;
            printf("\t\tBOX with corners at (%.3f, %.3f, %3f), (%.3f, %.3f, %3f)\r\n", 
                p1_att.X, p1_att.Y, p1_att.Z, p2_att.X, p2_att.Y, p2_att.Z)

            % Rectangles parallel to XY plane.
            for z=[p1_att.Z, p2_att.Z]
                faces{end+1} = [p1_att.X, p1_att.Y, z;
                                p2_att.X, p1_att.Y, z;
                                p2_att.X, p2_att.Y, z;
                                p1_att.X, p2_att.Y, z;];           
                max_dims(end+1) = max(max(abs(faces{end})));
            end
            % Rectangles parallel to the XZ plane.
            for y=[p1_att.Y, p2_att.Y]
                faces{end+1} = [p1_att.X, y, p1_att.Z;
                                p2_att.X, y, p1_att.Z;
                                p2_att.X, y, p2_att.Z;
                                p1_att.X, y, p2_att.Z;];           
                max_dims(end+1) = max(max(abs(faces{end})));
            end
            % Rectangles parallel to the YZ plane.
            for x=[p1_att.X, p2_att.X]
                faces{end+1} = [x, p1_att.Y, p1_att.Z;
                                x, p2_att.Y, p1_att.Z;
                                x, p2_att.Y, p2_att.Z;
                                x, p1_att.Y, p2_att.Z;];           
                max_dims(end+1) = max(max(abs(faces{end})));
            end
        end
    end

    max_dimension = max(max_dims);
    
    for i = 1:length(faces)
        normalized_face = faces{i} ./ max_dimension;
        fillPolygon3d(normalized_face, 'r')
    end
end

[salyym]

Can you please explain how to acheive that ? i'm trying to plot the 3D far field of a simple dipole but since i'm starting with opensEMS python i'm a bit lost!

[CoolNamesAllTaken]

Hi @rinadyx, I'm not sure how to do it in OpenEMS Python, but in regular OpenEMS there were some scripts available for plotting the far field pattern, such as plotFF3D. If you want to convert the far-field pattern from electric field strength (V/m) to dBi, you can see the conversion math included at the start of my script.

[salyym]

thank you for your answer,

When you say regular openEMS you mean MatLab/Octave one ?

[CoolNamesAllTaken]

Yes, that is what I meant by "regular OpenEMS".

[salyym]

Thank you for your answer