Weight Splitting into More than Two Location

by
William C. Foiles

Abstract: This paper investigates an algorithm to split balance weights

into more than two locations. This method extends the simple two weight
split technique to include constraints on the amount of weight placed at each
of the split locations. The solution minimizes the total amount of weight
added to affect the split.

Introduction

Balance weight splitting is the process of installing more than one

balance weight in a balance plane whose sum equals or approximates
the required balance weight. A number of balance programs and
auxiliary programs include this for the user today for a two weight split.

The necessity of splitting balance weights at locations occurs frequently.

Specific instances requiring weight splitting include occasions:

1. When either or both the location required to place a balance weight

do not exist, the balance weights need splitting between two or
more angular locations to achieve the required effective balance
weight.
2. When the required balance weight is larger than can be applied at
a single location, or when heavy balance weights are not available
or should not be used in the balance plane.
3. When the required location has damage or has a weight already
installed.

This paper is not meant to be a complete tutorial on the basics of weight

splitting or balancing, nor does this paper cover any safety aspects
necessary to work with rotating equipment when doing a balance job.
The methods shown are for the enjoyment of the readers.

One can not split weights 180 degrees apart to get a solution. Splitting
weights on one side of the desired weights will require a weight removal
on one of the weights; for practical considerations the split angles must
be on either side of the desired weight location and less than 180 degrees
apart.
 Two Weight Splits

Sometimes today as in the past the weights are split graphically. Figure
1 shows the geometry involved in a weight split. Typically the graphing
is done on polar paper.

1. First one plots the desired balance weight vector, amplitude and
angle.
2. Next lines at the desired angles to add the split weights are added
to the graph.
3. Parallel lines to these lines at the desired angle, one-at-a-time, are
constructed through the ends of the desired balance weight vector
to form the required split weight vectors (See Figure 1.). These
parallel lines can be commonly constructed using either a set of
parallels or two triangles.
4. Usually, although not absolutely required, the parallelogram is
completed by sliding the weight add vectors to the origin as in the
figure.

α2
r
V 1

r r
d V 2
r
V 2
α1
r
V 1

Figure 1: Geometry for splitting a balance weight into two

components.
Nomenclature for Figure 1:
r
d - desired balance weight vector
α - desired balance weight angle
d - desired balance weight magnitude
αr ,αr
1
- available angles to add balance weights
2
r
,
V1V 2 - split weights, vector sum = d

V ,V
1 2
- split weights magnitudes

This two weight add problem has a simple analytical solution using the.
The Law of Sines formula applied to the geometry in Figure 1 gives the
following derivation.

V2 d V1
= = (1)
sin( α −α1 ) sin(180− α 2 −α1 ) sin( α 2 −α )
The absolute value sign takes care of odd cases. The above equation
leads directly to a solution for the weight splits at the desired angles.

sin( α −α1 ) sin( α −α1 )

V =d =d (2)
sin(180− α 2 −α1 ) sin( α 2 −α1 )
2

And
sin( α 2 −α ) sin( α −α 2 )
V =d =d (3)
sin(180− α 2 −α1 ) sin( α 2 −α1 )
1

The was the simple way to get to the formula for weight splitting into two
angles. One can break the equations up into the Cartesian components,
x and y, and use algebra and trigonometry to arrive at the above
equations or something equivalent. I have not intention of duplicating
the easy solution by the more difficult solution here, but with a little
patience or one of the symbolic computation engines available today one
can get there.

Example for split in two locations

With a desired balance weight of 100 g-cm @ 40 degrees and available
locations of 20 and 50 degrees the Law of Sines solution above will be
solved.
V1=34.73 g-cm @ 20 degrees
V2= 68.40 g-cm @ 50 degrees

The total weight needed to achieve a vectorial sum of 100 g-cm @ 40

degrees is 103.13 g-cm. Notice that the most balance weight is added to
the location closes to the desired balance weight location.

Later Scilab, a free software package for numerical computations will be

used to solve this problem. One should always check the license to see if
this would be correct for their application. An example of a function will
be developed for Scilab to compute more general splits. „

For the next section on splitting a balance weight into several locations,
the Cartesian coordinate formulation of the two weight problem will help,
the algebra and trigonometry to get to the above will be left to the curious
reader.

The two equations for the x and y coordinates from Figure 1 result in the
below equation.

V 1cos(α 1) +V 2 cos(α 2) = d cos(α ) (4)

V 1 sin(α 1) +V 2 sin(α 2) = d sin(α )
These two equations in the two unknowns for the desired split
magnitudes, V1 and V2 can be solved as usual. One can check that the
two weight split example above solves the equations labeled 4 above.

Splitting Weights at n Angles

The above framework for writing the Cartesian coordinates generalizes to

splitting at more than two angles.
Nomenclature for Multi-Weight Splitting:
r
d - desired balance weight vector
α - desired balance weight angle
d - desired balance weight magnitude
α i
- available angles to add balance weights, i = 1L n

Vr i
- split weight magnitudes, i = 1L n
r
V i
- split weights, vector sum = d

L i
- lower bounds on the weight magnitudes, i = 1L n

U i
- upper bounds on the weight magnitudes, i = 1L n

n
∑ V i cos(α i) = d cos(α )
i =1
(5)
n
∑ V i sin(α i) = d sin(α )
i =1

The equations above in general have an infinite number of solutions.

Again, the split angles should be on either side of the desired angle, and
generally the angles should spread less than 180 degrees. Without
something else, this doesn’t help much.

Adding a goal or optimization objective will lead to solutions. One

practical solution is to minimize the total amount of added weight as
below.

n
min ∑ V (6)
i =1 i

To the above assume all the weights are additions or positive

magnitudes. The weight removal procedure can be processed by adding
weights at the opposite angles. These equations form a linear
programming problem that can be solved.

On top of the equalities, one may desire to limit the magnitudes of the
weights that can be added. Such extra constraints would give the
following equations. Without some constraints the solution, which
minimizes the sum of the weights, only uses the two positions closest to
the desired balance weight position.

0 ≥ Li ≥ Vi ≤ U i , i = 1Ln (7)

The following is a linear program that will split a desired balance weight
at n desired angles while minimizing the sum of the split weights.
Weight bounds, both upper and lower, may be applied to the split
weights.

n
min ∑ V such that:
i =1
i
n
∑ V i cos(α i) = d cos(α )
i =1
(8)
n
∑ V i sin(α i) = d sin(α )
i =1
0 ≥ Li ≥ Vi ≤ U i , i = 1Ln

Sample function to do splits

function w=split(des,ang, lower, upper)

//split.sci - hole split program for balancing
//
// w= split(desired,angles,lower,upper);
//
//
// w - weights at each of the angles in 'angles'
// angles - column with angles for weight adds
// desired - magnitude, angle 1 row with two columns
// lower - bounds on weights at the angles
// upper - upper bound on weights at the angles
//
// angles in degrees
//
// Converted to Scilab

d2r=%pi/180;

ar=d2r*ang; // convert to radians

Aeq=[cos(ar.');sin(ar.')]; //equality constraints for LP
beq=[des(1,1)*cos(des(1,2)*d2r);des(1,1)*sin(des(1,2)*d2r)];

f=ones(size(ang,1),1); // objective function - minimize the sum

// of the weights

ne=size(beq) ; ne=ne(1,1); // number of rows

[w,lagr,opt]=linpro(f,Aeq,beq,lower,upper,ne);

disp(w);

endfunction

„
Perhaps a few comments on the above example of what one can do to
solve this problem are in order. “//” represent comments. One can use
Scilab to vectorize the solution, which shortens the coding. The function
linpro is a built-in linear program solver. Some examples should clarify
the idea of using more than two split locations for a desired balance
weight.

Example 1

Desired balance weight = 100 g-cm @ 40 degrees

Angles available = 20, 30, 50 and 60 degrees
Balance weights can not exceed 40 g-cm

Below is the input and output from Scilab

-->balwt=[100 40]
balwt =

! 100. 40. !

-->ang=[20;30;50;60];

-->lower=[0;0;0;0];

-->upper=[40;40;40;40];

-->split(balwt,ang,lower,upper);
 ! 11.288468 !
! 40. !
! 40. !
! 11.288468 !
One would place 11.28 g-cm at 20 degrees and 60 degrees and 40 g-cm
at 30 and 50 degrees. Again the largest balance weights go nearest the
desired location.

Remove the upper constraints and we get the original two weight split in
the example using the Law of Sines. Change the upper bound to a large
value and change the upper bound to 0 for the weight at 30 degrees,
which was not available in the two weight example. Otherwise, use the
same input data as above and get the following:

-->upper=[100;0;100;100];

-->split(balwt,ang,lower,upper);

! 34.729636 !
! 3.553D-15 !
! 68.404029 !
! 0. !

The value for the 30 degree angle reads 3.553D-15; this is 3.553 ×10-15
which is essentially zero. Again, without bounds the weights are placed
closest to the desired location. Note the agreement with the above and
the two weight solution, 34.73 g-cm @ 20 degrees and 68.40 g-cm @ 50
degrees. Had the closer location at 30 degrees not been constrained it
would have had weight and the location at 20 degrees would not have
any weight. „

Example 2

In this example the constraints will differ for different angles.

Desired weight = 450 g @ 100 degrees– all weights placed at the same
radius, so the radius is assumed in the units for the weights.

Angles available = 75, 90, 105, 120 degrees

Weights are already at 90 degrees and 105 degrees, but the material can
be changed and approximately 100 g can be added at 90 degrees and
105 degrees. 250 g can be added to each of 75 degrees and 120 degrees.
Below is the solution from Scilab.

-->bwt=[450 100];

-->angles=[75;90;105;120];

-->lower=[0;0;0;0];

-->upper=[250;100;100;250];

-->split(bwt,angles,lower,upper);

! 110.34707 !
! 100. !
! 100. !
! 161.6394 !

Thus, the solution is to place 110.3 g @ 75, 100 g @ 90, 100 g @ 105,
and 161.6 g @ 120 degrees.

The sum of the weight added is 471.99 g with the vector sum = 450 @
100 degrees. In the function the value opt could have been printed out;
opt is the optimum value for the linear program, i.e. the sum of the
balance weights forming the split solution. „

Example 3

When adding weights, one is often or always limited by how little weight
can be added. So, the lower bounds do come into play often. Of course,
the real situation would be either one can place no weight, or the weight
must exceed a certain value.

An example for this would occur when trying to add a balance weight.
First one might try to add the weight to two or three locations, adding
locations as required; this would require more than one run with the
routine. For instance try to add 775 g @ 135 degrees with available
locations of 120 degrees and 150 degrees with the weights limited at 120
degrees at 250 g and 150 degrees by 500 g. Clearly, this has not
solution, and the simple routine provided will end with an error message
indicating there are no feasible solutions.
Add the angular location at 90 degrees, which is also available. Nothing
less than 100 g can be placed on the rotor to balance. With the three
angles, 120 degrees, 150 degrees, and 180 degrees no feasible solution
could be found. See this example below.

-->balwt=[775 135];

-->ang=[120;150;180];

-->upper=[500;250;100];

-->lower=[100;100;100];

-->split(balwt,ang,lower,upper);
!--error 127
no feasible solution
at line 41 of function quapro called by :
line 11 of function linpro called by :
line 28 of function split called by :
split(balwt,ang,lower,upper);

One can place a weight at 180 degrees also. Add this to the example.
Notice that the weight at 120 degrees has a different constraint on the
upper end of 250 g. This problem has the solution given below of 145 g
@ 90°, 250 g @ 120° – hitting the upper constraint, 372 g @ 150° , and
100 g @ 180° – restrained by the lower value.

-->ang=[90;120;150;180];

-->lower=[100;100;100;100];

-->upper=[500;250;500;500];

-->split(balwt,ang,lower,upper);

! 145.01279 !
! 250. !
! 372.97723 !
! 100. !

Note if the lower constraints were removed this weight can be split at
90°, 120°, and 150°. The lower constraint may become active in some
problems. „
 Conclusion

The above derives an algorithm to split balance weights into more than
two locations for those occasions where one has limits on the amount of
weight that can be added to the two closest locations to the desired
location. This often occurs when using either slot weights or plug type
weights.

One can notice that when constraints on the weights are active, the
optimal solution has more total weight than an unconstrained problem.
In general, the optimal solution will have greater than or equal to the
original solution.