Custom Antenna Pattern from msi data

[jonathanuniberg]

So I would like to create an antenna pattern from an msi document, that contains all the gain values for the different angles from 0-359 degrees. I have the horizontal and vertical values. My idea was to read the data and save the data into two list (horizontal and vertical) and then use interpolation to connect the discrete values so that I can aim for the pattern.
Like this:

def create_interpolating_function(horizontal_data, vertical_data):
    # Unpack the angle and gain values
    theta_h, gain_h = zip(*horizontal_data)
    theta_v, gain_v = zip(*vertical_data)

    # Convert angles to radians (if they are not already)
    theta_h_rad = np.deg2rad(theta_h)  # Horizontal angles in radians
    theta_v_rad = np.deg2rad(theta_v)  # Vertical angles in radians

    # Convert to NumPy arrays
    theta_h = np.array(theta_h_rad)
    gain_h = np.array(gain_h)
    theta_v = np.array(theta_v_rad)
    gain_v = np.array(gain_v)

    # Create interpolators (use 'linear' first for debugging)
    interpolator_h = interp1d(theta_h, gain_h, kind='linear', fill_value="extrapolate")
    interpolator_v = interp1d(theta_v, gain_v, kind='linear', fill_value="extrapolate")

    return interpolator_h, interpolator_v

and then try to use the return functions to get the gain of the antenna.

def custom_pattern(theta, phi, slant_angle=0.0, polarization_model=2, dtype=tf.complex64):
    """
    Custom antenna pattern using interpolated gain data from MSI files.
    
    Input
    -----
    theta: array_like, float
        Zenith angles wrapped within [0,pi] [rad]

    phi: array_like, float
        Azimuth angles wrapped within [-pi, pi) [rad]

    slant_angle: float
        Slant angle of the linear polarization [rad].
        Defaults to 0 (vertical polarization).

    polarization_model: int, one of [1,2]
        Polarization model to be used. Options `1` and `2`
        refer to `polarization_model_1` and `polarization_model_2`,
        respectively.
        Defaults to `2`.

    dtype : tf.complex64 or tf.complex128
        Datatype.
        Defaults to `tf.complex64`.

    Output
    ------
    c_theta: array_like, complex
        Zenith pattern

    c_phi: array_like, complex
        Azimuth pattern
    """
    rdtype = dtype.real_dtype
    theta = tf.cast(theta, rdtype)
    phi = tf.cast(phi, rdtype)
    slant_angle = tf.cast(slant_angle, rdtype)

    # Interpolate gain values for theta and phi
    gain_theta_values = tf.py_function(func=interpolator_h, inp=[theta], Tout=tf.float32)
    gain_phi_values = tf.py_function(func=interpolator_v, inp=[phi], Tout=tf.float32)

    # Convert gain values into the antenna pattern
    # Take the square root of the gain to convert it to C(theta, phi)
    c_theta = tf.complex(tf.sqrt(gain_theta_values), 0.0) 
    c_phi = tf.complex(tf.sqrt(gain_phi_values), 0.0) 

    # Apply the chosen polarization model
    if polarization_model == 1:
        return polarization_model_1(c_theta, theta, phi, slant_angle)
    else:
        return polarization_model_2(c_phi, slant_angle)

I tried to visualise but it seems like something is still wrong. Does anyone have an idea? The data is read correctly and I can plot the data and everything seems fine, but there is an issue in converting the data to Sionna. Maybe the interpolation method is not that practical.

interpolator_h, interpolator_v = create_interpolating_function(angle_data["horizontal"], angle_data["vertical"])
fig_v, fig_h, fig_3d = visualize(custom_pattern)

[jhoydis]

Hi @jonathanuniberg,

An antenna pattern gives you for every pair of spherical angles (theta, phi), a zenith and azimuth antenna response.
For example, a vertically polarized antenna would have always a zero azimuth antenna response.

Your dataset seems to consist of only theta angles while it is unknown what phi is. You also seem to indicate that theta ranges from 0-359deg, which is strange because the zenith angle only ranges from 0-180degree.

What you actually need are measurements of the antenna pattern for directions defined by points on a sphere, i.e., (theta, phi) values. Then you need to write an interpolation of the pattern on the sphere.

[RobinUniberg]

Hi @jhoydis,

Thank you for your answer! We are currently still trying to find out how we can import or define antenna patterns in Sionna. Our problem could be quickly summarised as follows:

1. we only have information about the gain pattern and miss information about the phase
2. the information about the gain pattern does probably not have the right format

Based on our experience manufacturers of antennas typically provide only the antenna gain pattern as they usually don’t measure the phase. A standard format to define the gain pattern is e.g. the .msi (MSI Planet Antenna) file-format (see here: http://radiomobile.pe1mew.nl/?The_program___Definitions___MSI). This is also the format that we have available and with that we tried to generate a custom antenna pattern in Sionna.
It contains information about the maximum gain as well as datapoints for the horizontal and for the vertical gain pattern. For both, patterns, datapoints from 0 to 359 degrees are provided. However, we’re not sure how to interpret the horizontal and vertical patterns, as each point on a sphere can already be defined by azimuth (0–359 degrees) and zenith (0–180 degrees) angles, as you noted previously. Yet, the file does not appear to contain redundant information. We believe it may represent some kind of cross-sectional or profile view of the 3D antenna pattern. Also, other common file formats (e.g., Radio Mobile V3 .ant) seem to use data points from 0 to 359 degrees for both the horizontal and vertical patterns as well.

We have already plotted the pattern with an antenna pattern editor. When we use Python and Matplotlib to read the values of the file, interpolate them and plot them in polar coordinates we actually get the same figure as shown in the pattern editor.
Therefore our first intent was to create an antenna pattern in Sionna using a callable that returns the interpolated gain in respect to theta and phi.
Now, as of our current understanding we need to provide a complex antenna pattern C(θ, Φ), which consists of √G (=max gain) times the phase information regarding to theta and phi. The problem is that we only have information about G(θ, Φ) (maybe not even that, as we are not sure how to interpret the value of the file). About the phase pattern we don’t have any information.

We also thought about whether it is possible to make assumptions about the phase or neglect it for calculating the antenna pattern. As we only use max gain in C(θ, Φ) = √(G)*F(θ, Φ) the information of G(θ, Φ) needs to be somehow included in F(θ, Φ).

Therefore we would like to ask you if you could help us in understanding the phase pattern correctly? Do you have an idea how we could proceed to get the antenna pattern modelled in Sionna regarding missing phase information and a different format for zenith/vertical pattern?

Thanks a lot in advance!

[jhoydis]

Hi @RobinUniberg,

You actually do not need to provide a complex-valued pattern. In a recent paper, we did this (where you chose the angle based on the desired polarization):

I actually think that you would only need a complex-valued pattern to model, e.g., a circularly polarized antenna, or the pattern of an antenna array, where different elements have different observed phase shifts, depending on the angle.

It would be great to have some helper function that would enable the import of msi files for Sionna. We currently do not have the bandwidth to do this. In case that you figure it out, this could be a great contribution.