Frequency Domain Models

In order to simplify computation and model design, the frequency domain models only consider a single frequency of interest, useful for narrow band performance evaluations.

lyceanem.models.frequency_domain.aperture_projection(aperture, environment=None, wavelength=1.0, az_range=array([-180., -160., -140., -120., -100., -80., -60., -40., -20., 0., 20., 40., 60., 80., 100., 120., 140., 160., 180.]), elev_range=array([-90., -80., -70., -60., -50., -40., -30., -20., -10., 0., 10., 20., 30., 40., 50., 60., 70., 80., 90.]), farfield_distance=2.0)

Using the aperture provided and any blocking structures, predict the maximum directivity envelope of the aperture. This will initially just cover all the triangles of a provided solid, but eventually I will include a filter list.

Parameters:

• aperture (open3d.geometry.TriangleMesh) – trianglemesh of the desired aperture

• environment (lyceanem.base_classes.structures) – the lyceanem.base_classes.structures class should contain all the environment for scattering, providing the blocking for the rays

• wavelength (float) – the wavelength of interest in metres

• az_range (numpy 1d array of float32) – the azimuth range desired for the farfield pattern in degrees

• elev_range (numpy 1d array of float32) – the elevation range desired for the farfield pattern in degrees

Returns:

• directivity_envelope (numpy 2D array of float32) – The predicted maximum directivity envelope for the provided aperture at the wavelength of interest

• pcd (open3d.geometry.PointCloud) – a point cloud colored according to the projected area, normalised to the total projected area of the aperture.

lyceanem.models.frequency_domain.calculate_farfield(aperture_coords, antenna_solid, desired_E_axis, az_range, el_range, scatter_points=None, wavelength=1.0, farfield_distance=2.0, scattering=0, source_weights=None, scattering_weight=1.0, mesh_resolution=0.5, elements=False, los=True, project_vectors=False, antenna_axes=array([[1., 0., 0.], [0., 1., 0.], [0., 0., 1.]]))

Based upon the aperture coordinates and solids, predict the farfield for the antenna.

Parameters:

• aperture_coords (open3d.geometry.PointCloud) – open3d of the aperture coordinates, from a single point to a mesh sampling across and aperture or surface

• antenna_solid (lyceanem.base_classes.structures) – the class should contain all the environment for scattering, providing the blocking for the rays

• desired_E_axis – 1*3 numpy array of the desired excitation vector

• az_range (1D numpy array of float) – the desired azimuth planes in degrees

• el_range (1D numpy array of float) – the desired elevation planes in degrees

• scatter_points (open3d point cloud) – the environment scattering points, defaults to [None]

• wavelength (float) – wavelength of interest in meters, defaults to [1]

• farfield_distance (float) – the distance to evaluate the antenna pattern, defaults to [2]

• scattering (int) –

  the number of scatters required, if this is set to 0, then only line of sight propagation is considered, defaults to [0] source_weights : numpy array complex

  the desired source weights if the source field is to be specified explicitly, should be normalised. This replaces the desired_E_axis specification.

• scattering_weight –

• mesh_resolution –

• elements (boolean) – whether the sources and sinks should be considered as elements of a phased array, or a fixed phase aperture like a horn or reflector

• los (boolean) – The line of sight component can be ignored by setting los to [False], defaults to [True]

• project_vectors (boolean) – should the excitation vector/vectors be projected to be conformal with the surface of the source coordinates

Returns:

• etheta (numpy 2D array) – The Etheta farfield component

• ephi (numpy 2D array) – The EPhi farfield component

lyceanem.models.frequency_domain.calculate_scattering(aperture_coords, sink_coords, antenna_solid, desired_E_axis, scatter_points=None, wavelength=1.0, scattering=0, elements=False, los=True, mesh_resolution=0.5, project_vectors=False, antenna_axes=array([[1., 0., 0.], [0., 1., 0.], [0., 0., 1.]]), multiE=False)

calculating the scattering from the provided source coordinates, to the provided sink coordinates in the environment. This can be used to generate point to point scattering parameters or full scattering networks.

Parameters:

• aperture_coords (open3d.geometry.PointCloud) – source coordinates

• sink_coords (open3d.geometry.PointCloud) – sink coordinates

• antenna_solid (lyceanem.base_classes.structures) – the class should contain all the environment for scattering, providing the blocking for the rays

• desired_E_axis (1D numpy array of floats) – the desired excitation vector, can be a 1*3 array or a n*3 array if multiple different exciations are desired in one lauch

• scatter_points (open3d.geometry.PointCloud) – the scattering points in the environment. Defaults to [None], in which case scattering points will be generated from the antenna_solid. If no scattering should be considered then set scattering to [0].

• wavelength (float) – the wavelength of interest in metres

• scattering (int) – the number of reflections to be considered, defaults to [0], but up to 2 can be considered. The higher this number to greater to computational effort, and for most situations 1 should be ample.

• elements (boolean) – whether the sources and sinks should be considered as elements of a phased array, or a fixed phase aperture like a horn or reflector

• los (boolean) – The line of sight component can be ignored by setting los to [False], defaults to [True]

• mesh_resolution (float) – the desired mesh resolution in terms of wavelengths if scattering points are not provided. A scattering mesh is generated on the surfaces of all provided trianglemesh structures.

• project_vectors (boolean) –

Returns:

• Ex (numpy array of complex)

• Ey (numpy array of complex)

• Ez (numpy array of complex)