SPE
Society of Petroleum EngIneers of "IME
SPE 13535
Sparse Gaussian Elimination for Complex Reservoir Models
by A.H. Sherman, J.S. Nolen & Assocs. Inc.
SPE Member
Copyright 1985, Society of Petroleum Engineers
This paper was presented at the SPE 1985 Reservoir Simulation Symposium held in Dallas, Texas, February 10-13,1985. The material is subject to cor
rection by the author. Permission to copy is restricted to an abstract of not more than 300 words. Write SPE, P.O. Box 833836, Richardson, Texas
75083-3836. Telex: 730989 SPE DAL.
ABSTRACT
The simulation industry is rapidly moving
towards the frequent use of complex reservoir models
including such features as faults, implicit well
terms, and thermal or compositional effects. All of
these things can pose great difficulties for the
standard direct elimination methods typically found
in reservoir simulators. This paper takes a new
look at sparse Gaussian elimination methods in the
context of the current technology and trends in
simulation and computing. A novel implementation is
described, and numerical results are presented that
indicate that this implementation can be a more
effective tool for simUlation than previous versions
of sparse elimination.
INTRODUCTION
It is well known that the solution of linear
equations can account for far more than half of the
total computational effort in a numerical reservoir
simUlation. I 0 Because of this a great deal of
attention has been given to the development of
effective (i.e., accurate and efficient) methods for
solving such equations. Major recent advances have
been made in the technology of i terati ve methods,
especially those based on conjugate-gradient-like
iterations (cf., References 1, 8, and 12 for
example). Despite this, however, there is still
strong evidence that direct methods, based on
Gaussian elimination, can play an important role.
In addition to the moderate-size two-dimensional
models on which such methods have traditionally been
used, it appears that direct methods can also be
useful for a variety of complex fully-implicit
reservoir models incorporating such features as
faults, implicit well models, or compositional or
thermal effects. Such models, which are coming into
increasingly-more-frequent use, can pose great
difficulties for even the best iterative methods.l2
Moreover, some of the newer i terati ve methods that
may be capable of solving extremely difficult linear
systems require the solution of certain submodels
that seem most amenable to efficient solution by
direct methods. 12
References and illustrations at end of paper.
407
Most direct methods tradi tionally used in
reservoir simulators are based on band Gaussian
elimination in combination with a clever re-ordering
of the unknowns to exploit certain structural
features of the linear equations. The most commonly-
mentioned method is the D4-Gauss method due to Price
and CoatS. 11 In the past ten years, however, there
has been substantial interest in more general sparse
Gaussian elimination methods that can more fully
exploit the large number of zero entries in the
coefficient matrices arising from reservoir simula-
tion. Within the simulation industry, there have
been a number of proposals for such methods and
several papers have examined the performance of
sparse Gaussian elimination in the context of
reservoir simulation. 2 ,13-IS By and large, the
methodology of these studies has involved the
application, with little modification, of high-
quality general-purpose codes developed by
specialists in numerical linear algebra. The usual
conclusion has been that, especially for larger
problems, sparse methods can offer some advantages
over simpler alternatives such as band elimination
or D4-Gauss, but that the gain does not warrant the
significant increase in code complexity. This has
seemed to be particularly true on the vector and
array processors now so widespread in the industry;
in fact, the sparse methods tested were often very
uncompetitive on such machines.l~
The studies just summarized offer a reasonable
assessment of the utility of the sparse matrix soft-
ware of the late 1970's. Available codes were not
designed to exploit the special structure inherent
in the linear equations arising in reservoir simula-
tion, particularly those from fully-implicit models
having several equations and unknowns per grid
block. Moreover, the sparse matrix technology on
which they were based had not yet advanced to the
point of allowing substantial vectorization on
machines such as the CRAY-1 or Cyber 205. In addi-
tion, the test problems used in the studies were
mainly confined to IMPES-type models without
complexities, such as faults or implicit well
treatments, that create non-standard grid connec-
tions and make Simpler elimination methods (and many
iterative methods) less attractive. As a result,
while the studies were extremely useful when they
were presented, the insights offered in them may no
2 SPARSE GAUSSIAN ELIMINATION FOR COMPLEX RESERVOIR MODELS
longer be accurate in the light of recent develop-
ments in sparse matrix technology and the industry's
move toward larger, more implicit, more complex
reservoir models.
The goal of this paper is to reexamine the
merits of sparse Gaussian elimination in the context
of current technology and trends in simulation. The
first part of the paper outlines an implementation
of sparse Gaussian elimination that can effectively
exploit the structure of the simulation equations
and seems better sui ted to vector processors than
previous sparse methods. Following this, we present
the results of several numerical experiments
designed to investigate the capabilities of the new
method. We conclude by assessing the current state
of technology for direct methods in reservoir
simulation.
IMPLEMENTING SPARSE GAUSSIAN ELIMINATION
In this section we outline an implementation of
sparse Gaussian elimination that is appropriate for
the systems of linear equations arising in reservoir
simulation. The linear systems of interest here
have the form
Ax = b (1)
with
A = rM1 J
I C
[R I M2 (2)
where M1 is a block NB x NB matrix with NVB x NVB
blocks, M2 is a block NW x NW matrix with NVW x NVW
blocks, and R and C are rectangular matrices with
commensurate block order and size. The overall
order of the system is N = NBNVB + NWNVW. Typi-
cally, NB NW. In this paper we will consider
only NVB < 3 and NVW = 1, but the methods described
are not restricted to those values.
Equation (2) is general enough to include most
simUlation models in use today. It may be thought
of as corresponding to a reservoir model containing
NB grid blocks (including inactive zero-pore-volume
blocks) and NW wells in which the interblock flow
equations are formulated with NVB implicit equa-
tions/unknowns per grid block, and NVW parameters
per well are solved for implicitly. Our restric-
tions here on NVB and NVW still allow for general
black oil models, which typically have NVB = 1
(IMPES or sequential method pressure equations) or
NVB = 3 (simultaneous, fully impliCit method
equations) and NVW = 1 (implicit bottomhole pressure
in each well). Compositional or thermal models
typically require larger values for NVB and NVW.
We assume that the matrix A has a block-
symmetric incidence matrix; that is, the pattern of
nonzero blocks is symmetric. This is unlikely to be
a significant restriction in practice, since essen-
tially all reservoir simulation models give rise to
matrices satisfying the assumption. The nonzero
entries of A, and, indeed, its (nonblock) incidence
matrix will frequently be nonsymmetric.
408
SPE 13535
The sparse Gaussian elimination method
described here solves the linear system (1) by
applying nonsymmetric Gaussian elimination to a
symmetrically permuted system of equations
(PAPT) (Px) = (Pb)
where the permutation matrix P reorders the blocks
of M1 and M2 so as to reduce the number of opera-
tions or amount of storage required to solve (3).
Our actual implementation uses the minimum degree
ordering 9 to reorder the blocks of M1 and leaves M2
in original order, but other choices for P can be
easily accomodated. In general, P is chosen at the
beginning of a simulation and retained throughout.
Clearly, (3) satisfies all our assumptions about
(1)
Once P has been chosen, the solution x is
obtained by a two-step process. First, we compute
an upper triangular matrix U and a vector y satis-
fying
U = L- 1QPAPT , Y = L- 1QPb (4)
where L is a unit lower triangular matrix and Q is a
sec~nd permutation matrix that reorders the rows of
PAP corresponding to a restricted form of partial
pi voting during the elimination process. We then
complete the process by solving
Uz = y, Px =z
In implementing sparse Gaussian elimination for
the simulation operations, it is important to
exploit several properties of the system (3). First,
the individual matrix blocks (for NVB, NVW)1) are
typically either almost dense initially or rapidly
filled in by elimination operations. Hence, there
is little motivation to treat intrablock sparsity,
and by not doing so, it is possi ble to achieve a
significant savings in the amount of overhead
integer storage. Second, each linear system (3)
will be solved for only one righthand side. By
computing the vector y simultaneously with the
matrix U, it is possible to avoid storing all of the
nonzeroes in the matrix L (although a significant
portion of L must be retained temporarily to allow
for partial pi voting) Finally, by sui tably
restricting the row interchanges due to parti~l
pivoting and exploiting the block symmetry of PAP ,
it is possible to avoid storing even a structural
description of L that might otherwise be required to
control the elimination process. This yields a
substantial further reduction in pOinter storage.
Empirically, it appears that the required restric-
tion on the partial pivoting process does not impact
the numerical stability of the overall method.
With this discussion in mind, it is possible to
design a number of different implementations of
sparse Gaussian elimination. A straightforward
approach might be to adapt a code such as the Yale
Sparse Matrix Package (YSMP). 7 Such an implementa-
tion would be particularly efficient on scalar
machines, 13 but it would suffer on vector machines
like the CYBER 205 or CRAY-1. lit In addition, the
incorporation of partial pi voting would be awkward
and might lead to a substantial increase in the
required amount of integer pointer storage.
SPE 13535 ANDREW H. SHERMAN
The alternative considered in this work is
based on an algebraic interpretation of the multi-
frontal elimination method from structural engi-
neering in combination with an optional tradeoff
between computation and storage by which certain
matrix entries in U are computed several times in
order to avoid storing them. Many of the details of
the approach are similar to those described by
Eisenstat, et al,6 and Duff and Reid.~'s The
prinCipal modifications in the code itself concern
adaptations to the standard simulation data struc-
tures in which the matrix and righthand side are
presented.
The tradeoff between computation and storage is
user-selectable. The code offers three options:
OPT=3 (maximum speed, no recomputation), OPT=2
(limited recomputation to save storage), and OPT=1
(full recomputation to minimize storage). As will
be evident from the numerical results in the next
section, OPT=3 and OPT=2 seem the most useful.
The major features of the implementation
include the following:
1. The innermost loops involve computations on
dense submatrices rather than on sparse
vectors. This allows more efficient coding of
the loops and enhances vectorization. In
particular, the Gaussian elimination computa-
tion itself is really dense Gaussian elimi-
nation; and, in order to enhance performance on
vector machines, we have adopted the algorith-
mic approach suggested by Dongarra and
Eisenstat. 3 In our code, the elimination loops
are unrolled to a depth of four.
2. Extremely large systems of equations may be
sol ved by the method without the use of any
auxiliary storage such as disk. The major
reason for this is that the required amount of
integer pointer storage is quite low (as a
percentage of the number of nonzeroes in L or
U). Further enhancement of the method to
inClude the use of auxiliary storage would be
quite straightforward.
3. Partial pivoting may be incorporated in the
elimination computation at very little addi-
tional cost. s While this may not be especially
important for black-oil problems, it is likely
that pivoting is required on a significant
portion of thermal and compositional models.
Experience indicates that local pivoting by
interchanging equatiOns within individual grid
blocks is usually sufficient to insure numeri-
cal stability, and a slight generalization of
this restricted pivoting is quite natural with
our method. In the long run, it may turn out
that our method has its greatest utility when
pivoting is required, since the use of pivoting
can substantially increase the storage demands
of other direct methods. (We note, however,
that the results presented later in this paper
were obtained without pivoting.)
4. As compared to the D4-Gauss or band Gaussian
elimination methods, our sparse method requires
substantially less arithmetic and generates a
sparser set of factors for A. This is espe-
cially true when the matrix blocks R and C are
nonzero, as is the case when implicit bottom-
409
3
hole pressure is required for wells completed
in multiple layers of a model. It is worth
noting, however, that a well-coded D4-Gauss
method may be able to make more efficient use
of storage in certain situations where partial
pivoting is not required.
NUMERICAL RESULTS
In this section we report on several numerical
experiments designed to investigate aspects of the
performance of our implementation of sparse Gaussian
elimination. Three sets of experiments were run.
The first set provides information on possible
tradeoffs between storage and time and on the effect
of a vectorizing compiler on speed. The second set
of experiments illustrates the performance of the
method on realistic reservoir models. Finally, the
last set of experiments contains performance data
for a range of problem sizes in two and three dimen-
sions and allows direct comparison with previous
implementations of sparse Gaussian elimination for
reservoir simulation models. As noted earlier, none
of our examples require partial pivoting, so this
feature of our method was turned off for these
experiments.
All the examples in Test Sets 1 and 3 arise
from reservoir models on regular grids. The grid
dimensions and number of variables/equations per
grid block are shown in Table 1. These models are
based on 5-point (2-D) or 7-point (3-D) difference
operators and contain neither faults nor implicitly-
treated well variables.
The two examples used in Test Set 2 are based
on actual field models. FIELD 1 has a 35 x 11 x 13
grid containing 5005 cells of which only 28g8 have
nonzero pore volume. The model contains 18 wells
and includes an implicit bottomhole pressure treat-
ment. The most effective approach to simulating the
model uses a sequential formulation, and it has been
found that the pressure equation can be extremely
difficult for some standard iterative methods.
(However, see Wallis, et al,12 for discussion of an
iterative method that is extremely effective for
this problem.) For models such as this, it can be
useful to apply direct methods; particularly during
the initial period of model setup and testing, even
if it is possible to tune up an iterative method for
the most efficient final set of production runs.
FIELD2, the second example in Test Set 2, has a
41 x 25 x 4 grid containing 4100 grid blocks. Again
there are a large number of zero-pore-volume blocks,
so only 2125 blocks are active in the model. The
model contains faults that both create 175 non-
standard inter-block connections and seal off
certain parts of the reservoir from the remainder.
In addition, it is necessary to use an implicit
bottomhole pressure treatment for the seven wells.
As with FIELD1, the combination of features creates
a difficult situation for most itrative methods and
all but eliminates any Gaussian elimination methods
based on two-cyclic matrices or banded solvers.
All the test runs were made on a CRAY-1-S using
a program written entirely in Fortran. The compiler
used was CRAY' s CFT 1. 10 Compiler (in some cases
with vectorization turned off). Reported CPU times
are in seconds, and storage figures are in thousands
4 SPARSE GAUSSIAN ELIMINATION FOR COMPLEX RESERVOIR MODELS
of words. Storage figures include all storage
except that for the original matrix and righthand
side. The reported rates are millions of floating
point operations per second, counting only opera-
tions involved in Gaussian elimination and backsolu-
tion. We note that where unvectorized times are
gi ven, the relative comparisons among times are
qualitatively similar to what has been observed on a
Digital Equipment Co. VAX 11/780 computer.
Apart from loop unrolling and the overall
algorithm design discussed in the previous section,
no speCial effort was made to vectorize the sparse
Gaussian elimination code. It is highly probable
that improvement could be achieved through the use
of certain assembly language routines available as
part of system or mathematical libraries on the
CRAY-1-S, but this has not been attempted for this
study.
The results from Test Set 1 are shown in Table
2. The data give inSight into several aspects of
the new method:
1. The method allows quite large problems to be
sol ved in relatively small amounts of storage.
For example, by choosing OPT=2, it is possible
to solve the problem corresponding to the 50 x
50 grid using approximately 11 vectors of
length 2500 (NGB). Even choosing OPT=3 is
reasonably storage efficient when compared to
band Gaussian elimination or other implementa-
tions of sparse Gaussian elimination. When
NVB) 1, the integer storage overhead for the
method may be reduced below 10%.
2. Depending on the availability of computing
resources and the particular charging algorithm
in use, the use of OPT=2 may provide an attrac-
ti ve tradeoff between storage and time. As a
conservative example, consider a situation in
which the charging algorithm defines cost as
the product of storage and time. In such a
case, the costs of solving the linear systems
in Test Set 1 may be reduced by up to 40% (30 x
30 grid) by using OPT=2. This example is
conservative because many cost algorithms use a
higher power of the storage measure, and, in
virtual storage systems, the use of extra
storage may lead to significant increases in
other costs that are not measured in our data.
3. It would appear that using OPT=1 is almost
never an attractive alternative, since it
increases CPU time substantially without
providing much additional storage reduction
over OPT=2.
4. The method can aChieve a Significant level of
vectorization, particularly when NVB>1. In the
case of the 8 x 8 x 8 grid for OPT=3, vectori-
zation leads to a 3.5-fold increase in speed.
For NVB=1, the relatively small amount of
vectorization is somewhat disappointing and is
due largely to the overall code complexity and
the amount of time spent outside the innermost
loops.
410
SPE 13535
Table 3 contains the results from Test Set 2.
The main purpose of running these examples was to
demonstrate that the qualities of the method
observed on model data carryover to realistic
reservoir models. We believe that this is borne out
by the data in Table 3, since we again observe many
of the properties noticed in our discussion of Test
Set 1. In particular, there seems to be a signifi-
cant amount of vectorization despite the decrease in
structural regularity of the linear equations due to
faults, implicit bottomhole pressure, and inactive
grid blocks.
The results from Test Set 3 are given in Table
4. One striking feature of these data is the
significant improvement in the speed of the method
with increasing problem size. There are two main
reasons for this: first, as problem size increases,
a greater portion of total time is spent in the
innermost loops (which are the most efficient); and,
second, the average vector length increases with the
problem size. Since there is little evidence that
performance is reaching an asymptotic level, it is
to be expected that the speed would continue to
improve for larger examples than those considered in
this work.
Several of the examples in Test Set 4 are iden-
tical to examples considered by Woo and Levesque.lIt
A comparison of results shows that our method is
more dependent on problem size (i.e., vector length)
than their YSMP-like implementation, but that its
peak performance can be substantially better for
large problems. For small problems, the vector
lengths are short, and the YSMP-like approach
appears to be faster than our new method. However,
the situation is entirely reversed when the example
problems approach the sizes more typically encoun-
tered in actual modeling. For these problems, the
new method is up to three times faster.
DISCUSSION AND CONCLUSION
In this paper we have reported on experience
with a new implementation of sparse Gaussian elimi-
nation. We began with the goal of evaluating such
methods in the context of current trends in simula-
tion and computing. While our results are certainly
not conclusive, it does appear that our new imple-
mentation offers Significantly better performance on
computers like the CRAY-1 than implementations
reported previously. Moreover, we have seen that it
is now possible to efficiently incorporate partial
pivoting into a sparse Gaussian elimination code and
to use such a code to deal effectively with linear
equations including the effects of a variety of
modeling complexities such as faults, impliCit well
terms, and inactive grid blocks.
Despite these comments, however, we do not
recommend that sparse Gaussian elimination be the
sole direct method in a reservoir simulator. For a
significant range of problems not requiring partial
pivoting, it appears from our experience that a
well-coded D4-Gauss routine may be both faster and
more storage-efficient than sparse Gaussian elimina-
tion. This is especially true for two-dimensional
black-oil models with NVB= 1 on vector machines. On
scalar machines, and for large values of NVB, sparse
Gaussian elimination becomes preferable on much
SPE 13535 ANDREW H. SHERMAN 5
smaller problems. Of course, it remains the case 12. Wallis, J.R., Kendall, R.P., and Little, T.E.:
that the use of implicit well equations, faulted "Constrained Residual Acceleration of
grids, or denser finite difference operators that Conjugate Residual Methods," Paper SPE 13536
destroy the two-cyclic nature of the coefficient presented at the 8th SPE Symposium on
matrix will cause D4-Gauss to be inapplicable. In Reservoir Simulation, Dallas, TX (1985).
such instances, sparse Gaussian elimination will
very likely be the only suitable direct method. 13. Woo, P.T., Eisenstat, S.C., Schultz, M.H., and
Sherman, A.H.: "Application of Sparse Matrix
Techniques to Reservoir Simulation," in Sparse
REFERENCES Matrix Computations, J.R. Bunch and D.J. Rose,
eds., Academic Press (1976) 427-438.
1. Appleyard, J.R. and Cheshire, 1.M.: "Nested
Factorization," Paper SPE 12265 presented at 14. Woo, P.T. and Levesque, J.M.: "Benchmarking a
the 7th SPE Symposium on Reservoir Simulation Sparse Elimination Routine on the Cyber 205
(1983) 315-324. and the CRAY-1," paper SPE 10526 presented at
the 6th SPE Symposium on Reservoir Simulation,
2. Calahan, D.A.: "Vectorized Direct Solvers for New Orleans, LA (1982) 535-538.
2-D Grids," Paper SPE 10522 presented at the
6th SPE Symposium on Reservoir Simulation, New 15. Woo, P.T., Roberts, S.J., and Gustavson, F.G.:
Orleans, LA (1982) 489-497. "Application of Sparse Matrix Techniques in
Reservoir Simulation," Paper SPE 4544
3. Dongarra, J.J. and Eisenstat, S.C.: "Squeezing presented at the 48th Annual Meeting of the
the Most out of an Algorithm in CRAY FORTRAN," SPE, Las Vegas, Nevada (1973).
ACM Trans. Math. Software, .1Q (1984) 221-230.
4. Duff, 1.S. and Reid, J.K.: "The Multifrontal
Solution of Indefinite Sparse Symmetric Linear
EquatiOns," ACM Trans. Math. Software 9 (1983)
302-325. -
5. Duff, 1.S. and Reid, J .K.: "The Multifrontal
Solution of Unsymnetric Sets of Linear Equa-
tiOns," SIAM J. Numer. Anal. .2. (1984) 633-641.
6. Eisenstat, S.C., Schultz, M.H., and Sherman,
A.H.: "Software for Sparse Gaussian Elimina-
tion with Limited Core Storage," in Sparse
Matrix Proceedings 1978, 1.S. Duff and G.W.
Stewart, eds., SIAM Press (1979) 135-153.
7. Eisenstat, S.C., Schultz, M.H., Sherman, A.H.,
and Gursky, M.C.: "The Yale Sparse Matrix
Package II: Nonsymmetric Matrices," Report
114, Department of Computer SCience, Yale
University (1977).
8. Elman, H., Eisenstat, S.C., and Schultz, M.H.:
"Block-Preconditioned Conjugate Gradient-Like
Methods for Numerical Reservoir Simulation,"
Paper SPE 13534 presented at the 8th SPE
Symposium on Reservoir Simulation, Dallas, TX
(1985)
9. George, J.A. and Liu, J.W.: Computer Solution
of Large Sparse Positive Definite Systems,
Prentice-Hall (1981) 115-137.
10. Stanat, P.L. and Nolen, J.S.: "Performance
Comparisons for Reservoir Simulation Problems
on Three Supercomputers," Paper SPE 10640
presented at the 6th SPE Symposium on
Reservoir Simulation, New Orleans, LA (1983)
593-602.
11. Price, H.S. and Coats, K.H.: "Direct Methods
in Reservoir Simulation," SPE Journal (1974),
295-308.

411
 TABLE 1
Models Used in Test Sets 1 and 3

Grid .1frL NVB (Test Set 1) NVB (Test Set 2)

20 x 20 400 1, 3
30 x 30 900 3 1, 3
40 x 40 1600 1, 3
50 x 50 2500 1, 3
80 x 40 3200 1, 3
6x6x6 216 1, 3
8x8 x8 512 3 1, 3
10 x 10 x 10 1000

TABLE 2
Results of Test Set 1

Storage Vectorized Unvectorized

Grid NVB OPT Integer Real ~ Rate Time Rate
3 31.7 50.4 0.57 4.1 0.92 2.5
50 x 50 2 16.2 12.2 1.25 3.1 1.88 2.1
12.7 12.2 3.37 1.8 4.50 1.3

3 16.5 71.1 .54 10.5 1.34 4.2

10 x 10 x 10 2 6.1 48.8 .90 8.0 1.97 3.7
5.4 48.8 1.74 4.5 3.00 2.6

3 13.0 133.2 .92 12.2 2.34 4.8

30 x 30 3 2 7.0 40.5 1.72 9.9 3.96 4.3
6.5 40.5 3.49 6.9 6.82 3.5

3 8.9 211.0 1.34 21.7 4.77 6.1

8x8x8 3 2 4.3 149.3 1.93 17.6 6.08 5.6
3.8 149.3 3.06 12.2 7.81 4.8
 TABLE 3
Results of Test Set 2

Stor~e Vectorized Unvectorized

Model NVB OPT Integer Real Time Rate Time Rate

FIELD 1 3 55.0 153.4 1.66 11.2 4.03 4.6

FIELD 1 2 33.1 57.8 3.13 9.4 7.05 4.2

FIELD2 3 45.9 90.0 1.17 6.9

FIELD2 2 25.1 53.3 2.45 5.3

TABLE 4

Results of Test Set 3

Storage Vectorized
Q!j& NVB OPT Integer Real Time Rate
20 x 20 3 4.9 5.7 0.07 1.5
30 x 30 3 11.2 15.1 0.18 2.4
40 x 40 3 20.1 30.3 0.34 3.2
50 x 50 3 31.7 50.4 0.57 4.1
80 x 40 3 40.6 62.6 0.73 4.2
6x6x6 3 3.2 6.5 0.07 2.7
8x8x8 3 7.9 23.7 0.20 5.6
10 x 10 x 10 1 3 16.5 71.1 0.54 10.5
20 x 20 3 3 5.7 49.6 0.33 8.2
30 x 30 3 3 13.0 133.2 0.92 12.2
40 x 40 3 2 13.4 75.2 3.63 12.4
50 x 50 3 2 21.2 115.8 6.83 14.9
80 x 40 3 2 27.3 131.8 9.20 15.1
6x6x6 3 3 3.7 57.4 0.36 12.1
8x8x8 3 3 8.9 211.0 1.34 21.7