beamforming question/help...

I've got a question regarding weight calculation in a beamformer...

In previous work, I was able to ADAPTIVELY determine weights using
something like LMS, but I needed to generate an actual inbound signal,
noise, reference, interferers and what-not...  What I'd like to do now
is pick a few directions in which to intentionally form beams, and
other directions to intentionally form nulls.  That is, the directions
are pre-determined, and not determined (adaptively) on the fly.
Trouble is, I am not getting this to work.

For a 4 element example (where the first element is at the origin, and
the others may be anywhere in x,y,z space), my code looks like:

diff_dist2=p2x.*cos(theta_a).*cos(theta_e)+p2y.*sin(theta_a).*cos(theta_e)+p2z.*sin(theta_e);
diff_dist3=p3x.*cos(theta_a).*cos(theta_e)+p3y.*sin(theta_a).*cos(theta_e)+p3z.*sin(theta_e);
diff_dist4=p4x.*cos(theta_a).*cos(theta_e)+p4y.*sin(theta_a).*cos(theta_e)+p4z.*sin(theta_e);
phi2=diff_dist2.*2.*pi./lambda;
phi3=diff_dist3.*2.*pi./lambda;
phi4=diff_dist4.*2.*pi./lambda;

mag_pattern=abs(w1.*rcart1+w2.*exp(j.*phi2).*rcart2+w3.*exp(j.*phi3).*rcart3+w4.*exp(j.*phi4).*rcart4);
[x,y,z]=sph2cart(theta_a,theta_e,mag_pattern);

How can I pick my weights to, say, put a beam at theta_a0, theta_e0,
and nulls in 2 other directions?.  How about additional beams/nulls, if
I add elements?

Any help would be appreciated.

Thanks.
-Steve

srjm72499@frontiernet.net writes:

> I've got a question regarding weight calculation in a beamformer...
> 
> In previous work, I was able to ADAPTIVELY determine weights using
> something like LMS, but I needed to generate an actual inbound signal,
> noise, reference, interferers and what-not...  What I'd like to do now
> is pick a few directions in which to intentionally form beams, and
> other directions to intentionally form nulls.  That is, the directions
> are pre-determined, and not determined (adaptively) on the fly.
> Trouble is, I am not getting this to work.
> 
> For a 4 element example (where the first element is at the origin, and
> the others may be anywhere in x,y,z space), my code looks like:
> 
> diff_dist2=p2x.*cos(theta_a).*cos(theta_e)+p2y.*sin(theta_a).*cos(theta_e)+p2z.*sin(theta_e);
> diff_dist3=p3x.*cos(theta_a).*cos(theta_e)+p3y.*sin(theta_a).*cos(theta_e)+p3z.*sin(theta_e);
> diff_dist4=p4x.*cos(theta_a).*cos(theta_e)+p4y.*sin(theta_a).*cos(theta_e)+p4z.*sin(theta_e);
> phi2=diff_dist2.*2.*pi./lambda;
> phi3=diff_dist3.*2.*pi./lambda;
> phi4=diff_dist4.*2.*pi./lambda;
> 
> mag_pattern=abs(w1.*rcart1+w2.*exp(j.*phi2).*rcart2+w3.*exp(j.*phi3).*rcart3+w4.*exp(j.*phi4).*rcart4);
> [x,y,z]=sph2cart(theta_a,theta_e,mag_pattern);
> 
> How can I pick my weights to, say, put a beam at theta_a0, theta_e0,
> and nulls in 2 other directions?.  How about additional beams/nulls, if
> I add elements?

You might find that only 4 elements, and in 3D space at that, is too
few to get anything sensible happening.

For a linear array, having only 4 elements is like, in signal
processing, only using a 4 point FFT.  You can do it, but the
frequency resolution (in FFT case; spatial resolution in the array
case) sucks.

There are a couple of ways of placing nulls (either at a specific
direction for all frequencies or at a specific direction, frequency
pair) in this:

http://eprint.uq.edu.au/archive/00000071/

Though it's only for a linear array, in 2D, so a little less complex
than what you're after.

Ciao,

Peter K.

I'm not an expert and I don't even play one on TV but....

don't you change the DIRECTION of the nulls and lobes by chaning the
PHASE of the drive elements, not the weighting...

I'm thinking about the so called broadside and endfire arrays, in both
cases, all the elements are fed with equal power, but the phases are
changed to re-direct the pattern...

I know so called taperd drive (various weighting of the elements) can
be used to modify the shape of the main lobe and reduce sidelobes etc,
but still I thought that changing DIRECTION of the lobes is done by
changing phase,  not weighting.... am I wrong?

Mark

Mark wrote:
> I'm not an expert and I don't even play one on TV but....
> 
> don't you change the DIRECTION of the nulls and lobes by chaning the
> PHASE of the drive elements, not the weighting...
> 
> I'm thinking about the so called broadside and endfire arrays, in both
> cases, all the elements are fed with equal power, but the phases are
> changed to re-direct the pattern...
> 
> I know so called taperd drive (various weighting of the elements) can
> be used to modify the shape of the main lobe and reduce sidelobes etc,
> but still I thought that changing DIRECTION of the lobes is done by
> changing phase,  not weighting.... am I wrong?

Both methods change the pattern. Tapering the drives to the ends of the 
arrays can have an effect similar to that of windowing FFT data. Look up 
a "binomial antenna". It ought to be on the web as a curiosity.

Jerry
-- 
Engineering is the art of making what you want from things you can get.
�����������������������������������������������������������������������

"Mark" <makolber@yahoo.com> writes:

> I'm not an expert and I don't even play one on TV but....
> 
> don't you change the DIRECTION of the nulls and lobes by chaning the
> PHASE of the drive elements, not the weighting...

Er, that's what his equations are doing.

Ciao,

Peter K.

srjm72499@frontiernet.net wrote:

> I've got a question regarding weight calculation in a beamformer...
> 
> In previous work, I was able to ADAPTIVELY determine weights using
> something like LMS, but I needed to generate an actual inbound signal,
> noise, reference, interferers and what-not...  What I'd like to do now
> is pick a few directions in which to intentionally form beams, and
> other directions to intentionally form nulls.  That is, the directions
> are pre-determined, and not determined (adaptively) on the fly.
> Trouble is, I am not getting this to work.
> 
> For a 4 element example (where the first element is at the origin, and
> the others may be anywhere in x,y,z space), my code looks like:
> 
> diff_dist2=p2x.*cos(theta_a).*cos(theta_e)+p2y.*sin(theta_a).*cos(theta_e)+p2z.*sin(theta_e);
> diff_dist3=p3x.*cos(theta_a).*cos(theta_e)+p3y.*sin(theta_a).*cos(theta_e)+p3z.*sin(theta_e);
> diff_dist4=p4x.*cos(theta_a).*cos(theta_e)+p4y.*sin(theta_a).*cos(theta_e)+p4z.*sin(theta_e);
> phi2=diff_dist2.*2.*pi./lambda;
> phi3=diff_dist3.*2.*pi./lambda;
> phi4=diff_dist4.*2.*pi./lambda;
> 
> mag_pattern=abs(w1.*rcart1+w2.*exp(j.*phi2).*rcart2+w3.*exp(j.*phi3).*rcart3+w4.*exp(j.*phi4).*rcart4);
> [x,y,z]=sph2cart(theta_a,theta_e,mag_pattern);
> 
> How can I pick my weights to, say, put a beam at theta_a0, theta_e0,
> and nulls in 2 other directions?.  How about additional beams/nulls, if
> I add elements?

The task requires the solution of the system of equations. The problem 
is you can't set the directions for nulls and beams as the arbitrary - 
the exact solution exists only for the certain cases. Instead of setting 
nulls and beams you can optimize the null/beam ratios in the directions 
of interest. This is a task of multi variable minimization and there are
some good algorithms to do that.

Vladimir Vassilevsky

DSP and Mixed Signal Design Consultant

http://www.abvolt.com

Peter K. wrote:
> "Mark" <makolber@yahoo.com> writes:
>
> > I'm not an expert and I don't even play one on TV but....
> >
> > don't you change the DIRECTION of the nulls and lobes by chaning the
> > PHASE of the drive elements, not the weighting...
>
> Er, that's what his equations are doing.
>
> Ciao,
>
> Peter K.

OK I guess I took the OPs words too literally.

thanks

>>>How can I pick my weights to, say, put a beam at theta_a0, theta_e0,
>>>and nulls in 2 other directions?.  

Mark

Vladimir, if possible, could you list any applicable references...
It seems apparent that in a 10-element case, I would have 9 degrees of
freedom to play around with, and the overall performance will depend on
the geometry of the array.  I guess I'm just suprised that this is a
difficult question.  Placing either a single beam or a single null in a
given direction is trivial, and there would still appear to be 8 DOFs
left.
I guess perhaps a better way to look at this is to assume the following
(not the actual application at all!):

Lets say I have an array with k-elements already in place.  All I can
do is vary the complex weights (which allow me to play with both the
relative phases and amplitudes).  I know the relative locations of the
elements (and thus their relative phases for any azimuth and elevation
angle if I know what frequency I'm working with).  The task is to pick
the weights given this phase relationship that provide a beam in
directions A and B, and nulls in directions C, D, and E.  Let's assume
that I'm transmitting, and I want to have high gain in the two
directions because I klnow that's where my buddies are, and also assume
that I have some devices that I don't want to disturb in the other
specified directions.  Adaptive techniques can get me there (finding
good weights, that is) if I "receive" desired signals from the beam
directions and if I see interfering signals from the other specified
directions, but if it's given that I am only transmitting, I don't have
that info available.  Given only the desired beam/null locations and
the element phase relationships (in all directions), I still think that
I should be able to determine an optimal weight vector
(non-adaptively).

Mark wrote:
> I'm not an expert and I don't even play one on TV but....
> 
> don't you change the DIRECTION of the nulls and lobes by chaning the
> PHASE of the drive elements, not the weighting...


Assume you have a ideal linear array with the ideal elements spaced at 
half a wavelength, a narrow band signal at the design frequency, and M 
elements. Also assume a reasonable weight function.  The beam pattern 
will have a main lobe and M-1 nulls.  If you fatten up the main lobe, 
the nulls will shift out a bit in the vicinity of the main lobe.  If you 
narrow the main lobe, they pull in a bit.  In general, you need to use 
complex weights, (shifts) to arbitrarily shift, as your question asks 
but the weights without phase shifts do have an effect on null position. 
There is also a difference in null location between the cases of a 
continuous aperture and discrete elements with the same weighting 
function.
> 
> I'm thinking about the so called broadside and endfire arrays, in both
> cases, all the elements are fed with equal power, but the phases are
> changed to re-direct the pattern...
> 
> I know so called taperd drive (various weighting of the elements) can
> be used to modify the shape of the main lobe and reduce sidelobes etc,
> but still I thought that changing DIRECTION of the lobes is done by
> changing phase,  not weighting.... am I wrong?
> 
> Mark
> 

"Steve" <srjm72499@frontiernet.net> writes:

> Vladimir, if possible, could you list any applicable references...
> It seems apparent that in a 10-element case, I would have 9 degrees of
> freedom to play around with, and the overall performance will depend on
> the geometry of the array.  

Sounds sensible.

> I guess I'm just suprised that this is a difficult question.

It's easy to ask; harder to answer.

> Placing either a single beam or a single null in a given direction
> is trivial, and there would still appear to be 8 DOFs left. 

Yup, depending no your array geometry. I can think of cases where you
might not get all the DOFs you're after (e.g. trivial example of
coincident elements).

> I guess perhaps a better way to look at this is to assume the
> following (not the actual application at all!):
> 
> Lets say I have an array with k-elements already in place.  All I can
> do is vary the complex weights (which allow me to play with both the
> relative phases and amplitudes).  I know the relative locations of the
> elements (and thus their relative phases for any azimuth and elevation
> angle if I know what frequency I'm working with).  The task is to pick
> the weights given this phase relationship that provide a beam in
> directions A and B, and nulls in directions C, D, and E.  Let's assume
> that I'm transmitting, and I want to have high gain in the two
> directions because I klnow that's where my buddies are, and also assume
> that I have some devices that I don't want to disturb in the other
> specified directions.  Adaptive techniques can get me there (finding
> good weights, that is) if I "receive" desired signals from the beam
> directions and if I see interfering signals from the other specified
> directions, but if it's given that I am only transmitting, I don't have
> that info available.  Given only the desired beam/null locations and
> the element phase relationships (in all directions), I still think that
> I should be able to determine an optimal weight vector
> (non-adaptively).

Yes, see the paper I referenced previously.  The "multiple frequency
nulling" part will impose nulls in the required directions at the
required operating frequencies.

What we found was that imposing nulls in a given direction worked, but
the beam pattern was very "steep" near the null.  So that any mistake
in direction meant you still had significant gain when you were trying
to null.  Our "solution" was to null in directions either side of the
required direction, that gave a pattern that was less deep (not
exactly zero) in the null direction, but broader to give some
robustness to directional uncertainties.

There are other ways of formulating the problem, too.

Ciao,

Peter K.