phased replicated subarrays with different phases on each subarray

I have an antenna model and it uses subarrays. These arrays are physically pointing in different directions and I want use the replicated subarray ability, but also I want to add weight or a taper which will steer the subarrays in different directions. If there are 2 subarrays, I want one to have a certain taper and the second to have a different taper. The examples i've found use the same weights or taper for all subarrays in the model... Is it possible to have different phasing on each array and use the replicated subarray model? In this example below there are subarrays physically pointed in different directions, but if I wanted to phase them all to steer to the same point it would require different phasing for each subarray...

Another type of nonplanar antenna array is an array with multiple planar faces. The next example shows uniform hexagonal arrays arranged as subarrays on a sphere. https://www.mathworks.com/help/phased/examples/phased-array-gallery.html?s_tid=srchtitle

R = 9;                          % Radius (m)
az = unigrid(-180,60,180,'[)'); % Azimuth angles
el = unigrid(-30,60,30);        % Elevation angles (excluding poles)
[az_grid, el_grid] = meshgrid(az,el);
poles = [0 0; -90 90];          % Add south and north poles
nDir = [poles [az_grid(:) el_grid(:)]']; % Subarray normal directions
N = size(nDir,2);               % Number of subarrays
[x, y, z] = sph2cart(degtorad(nDir(1,:)), degtorad(nDir(2,:)),R*ones(1,N));
sphericalHexagonalSubarray = phased.ReplicatedSubarray('Subarray',uha,...
        'Layout','Custom',...
        'SubarrayPosition',[x; y; z], ...
        'SubarrayNormal',nDir);

viewArray(sphericalHexagonalSubarray,...
    'Title','Hexagonal Subarrays on a Sphere');
view(30,0)

Answer 1

[Honglei Chen]

The steering of the entire array is divided into two parts. The first parts is the weights at the subarray level, that's where you can use a weighting vector. However, you cannot directly access within each subarray. Therefore, the phasing within each subarray is controlled by a property in the subarray. For example,

sphericalHexagonalSubarray.SubarraySteering = 'Phase';

This means that the phase within each subarray will be controlled via phase shifters. You can also specify the frequency at which those phase shifters operate on.

Now if you want to see the beam pattern, you can do the following

stv = phased.SteeringVector('SensorArray',sphericalHexagonalSubarray);
fc = 3e8;
steer_ang = 30;
w = step(stv,fc,steer_ang);
pattern(sphericalHexagonalSubarray,fc,-90:90,0,'Type','PowerdB','SteerAngle',steer_ang);

In general, if you use subarray with SubarraySteering turned on, then you will need to specify an extra input to indicate which angle you want to steer the subarrays to.

Please let me know if this addresses your concern. Thanks.

Answer 2

[Honglei Chen]

Currently the capability of pointing the subarrays to different directions is not available in phased.ReplicatedSubarray and phased.PartitionedArray. The example does apply different phasing to each subarray, but the phases are computed based on the same pointing direction. As a workaround, you can build separate arrays and then point them to different directions.

I do have a question regarding the use case. Since the subarrays point to different directions, it seems that they sort of work independently? Besides the physical connections, is there any other relations between the subarrays that are important for you to model? Thanks.

[mike susedik]

I have to think about your answer more. Is there an example? Are you saying using phased.replicatedsubarrays will take a taper which has different phases for each subarray? In other words, if I have subarrays with 10 elements and I use 2 of those subarrays (20 total radiators), I can create a taper with 10 phases for one subarray and 10 phases for the other subarray? Then a single taper with 20 phases covering both subarrays and compute a final pattern combining both subarrays contributions like they were connected together?

I think I'd need to create my own (?) replicated subarray? I'd have to create one subarray, use those element locations and translate them to the new position? I'd need to calculate the phasing in separate calculations for each array. Then I'd have to combine the 2 arrays in a single object. Then I'd have to combine the phasings into a single "taper" and then plot the results? Right now it isn't obvious to me how to construct the model, including the final directivity pattern.

To your question, the feed networks would work phasing independently, but they would beam form on the same point in space, say a single star. I want to be able to simulate panels making a piece wise circle, using only the appropriate panels to form the final array, but all point at a single star. The output of the arrays would be combined in the final output, so I need a composite pattern for the panels used together. I would like to see how much I can make up for scanloss if I have to keep the arrays conformal to a certain shape.

I also want to do a time domain beamforming, something like the VLA arrays they use for probing outer space. Also in my case, if I start separating the arrays, such as the VLA case, but I have the freedom of many elements and can create phase and amplitude for each of the elements, can I find ways of reducing the grating lobes created? I am also working on the use of "phased.apps.internal.plotGratingLobeDiagramPlanar", but I guess it is only a suggestion and not an official matlab function...

[Honglei Chen]

Sorry I misunderstood the situation. If all subarrays are focusing on the same star, then the existing ReplicatedSubarray should work. Although each subarray has different orientations but the star is in a fixed direction relative to the entire array, so the ReplicatedSubarray will compute the appropriate phase for each subarray. The example you quoted does exactly that, is there anything in particular that you need clarification?

The beamforming should work the same way. The grating lobe diagram is a bit more complex as the helper function you noticed only works for planar arrays. The computation for conformal array is not supported yet and frankly I haven't seen a lot of reference on that either.

HTH and please let me know if you need any further clarification.

[mike susedik]

%-( Where in the example (The code I posted, not the entire example, which is the last array in that example) does it calculate the phases? I see where the replicated array object is created, the array viewed, but not where the phases are created nor the final pattern computed? I have taken that code and plotted a pattern for a reduced version of the entire subarrays on a sphere. I can get the subarray to phase and steer properly with the method below, but when I apply the same effort to the replicated array, it gives me a dimension mismatch in the loop with the step function... Should I be using this method to calculate the phases? (Warning: this code was just cut and pasted in here, but not actually tested.)

% Calculate Steering Weights for the subarray
w = zeros(getNumElements(sphericalHexagonalSubarray), length(freq)); % Pre-allocate

elementVector = phased.SteeringVector('SensorArray',sphericalHexagonalSubarray, ... 
     'PropagationSpeed', propagationSpeed,...
     'IncludeElementResponse',true);%SV steering vector
%Find the weights and the strings for the legend
for idx = 1:length(freq)
    w(:, idx) = step(elementVector, freq(idx), steeringAngle(:, idx));
end
wAmpPhPerElement = [abs(w), angle(w)*180/pi];
sphericalHexagonalSubarray.Taper = w; % This is the phase&amp taper applied to the subarrays used inside the entire array.

and then to plot the pattern -

figure(1);
subplot(2,1,1),plotResponse(sphericalHexagonalSubarray, freq, propagationSpeed, 'Unit','dbi', ...
                'Format', 'Line', 'RespCut', 'El', 'ElevationAngles',...
                [-90:0.2:90]);%, 'weights', w); %Weights is not used here, the 
            % phase&amp taper is done in the phased.ura system object
            % earlier

subplot(2,1,2),plotResponse(sphericalHexagonalSubarray, freq, propagationSpeed, 'Unit','dbi', ...
                'Format', 'Line', 'RespCut', 'Az', 'AzimuthAngles',...
                [-180:0.2:180]);%, 'weights', w);

[Honglei Chen]

Hi Mike, I probably didn't understand your question correctly. Are you trying to plot the pattern for each subarray? Currently the steering only applies to the entire array, and that will be what you see when you plot the entire array. Is your sphericalHexagonalSubarray the entire array, or the individual subarray that gets replicated? Thanks.

[mike susedik]

Hi, Thank you for your patience in my explanation of this problem.

I want to use the subarrays together as a single antenna, though physically they are angled differently as they are in the sphericalHexagonalSubarray. I want them phased so they produce a maximum in the same direction (at a star). I have been able to plot the entire array as a single antenna from the sphericalHexagonalSubarray, but I have not figured out how to phase the subarrays so the received signal is from the same point. I want the subarrays to constructively add in the same direction, such as from a distant star. Or in this case a satellite: http://www.ball.com/aerospace/programs/gdpaa Maybe you'll find that interesting since it is much like your example. Should I be using "weights" or the "taper" attribute with the phased.ReplicatedSubarray to plot the pattern?

How do I add phasing to the phased.ReplicatedSubarray section of the example code at the top so these subarrays are phased to the same spot?

[mike susedik]

this array example

[Honglei Chen]

The steering of the entire array is divided into two parts. The first parts is the weights at the subarray level, that's where you can use a weighting vector. However, you cannot directly access within each subarray. Therefore, the phasing within each subarray is controlled by a property in the subarray. For example,

sphericalHexagonalSubarray.SubarraySteering = 'Phase';

This means that the phase within each subarray will be controlled via phase shifters. You can also specify the frequency at which those phase shifters operate on.

Now if you want to see the beam pattern, you can do the following

stv = phased.SteeringVector('SensorArray',sphericalHexagonalSubarray);
fc = 3e8;
steer_ang = 30;
w = step(stv,fc,steer_ang);
pattern(sphericalHexagonalSubarray,fc,-90:90,0,'Type','PowerdB','SteerAngle',steer_ang);

In general, if you use subarray with SubarraySteering turned on, then you will need to specify an extra input to indicate which angle you want to steer the subarrays to.

Please let me know if this addresses your concern. Thanks.

[Honglei Chen]

Sorry I accidentally made a separate answer entry.