Parametric Design and Gridding Through Relational Geometry

John S. Letcher, Jr. and D. Michael Shook
AeroHydro, Inc.
P. O. Box 684
Southwest Harbor, Maine 04679

Summary

Relational Geometric Synthesis (RGS) is a new logical framework for building up precise definitions of complex geometric models from points, curves, surfaces and solids. RGS achieves unprecedented design flexibility by supporting a rich variety of useful curve and surface entities. During the design process, many qualitative and quantitative relationships between elementary objects may be captured and retained in a data structure equivalent to a directed graph, such that they can be utilized for automatically updating the complete model geometry following changes in the shape or location of an underlying object. Capture of relationships enables many new possibilities for parametric variations and optimization. Examples are given of panelization applications for submarines, sailing yachts, offshore structures, and propellers.

Introduction

Relational Geometric Synthesis (RGS) [1, 2] is a novel approach to 3-D geometric design, with many advantages over previous technology:

  1. RGS provides a new, transparent, object-oriented conceptual framework for building up complex models from a logical hierarchy of point, curve, surface and solid entities.
  2. A wide variety of useful point, curve, surface and solid entities are supported in a unified way, so that they can be used essentially interchangeably in the construction of other objects.
  3. During the design sequence, qualitative and quantitative relationships between objects are captured in such a way that they are automatically enforced during updates of the model, following changes in underlying objects.
  4. To a great degree, RGS avoids the common difficulties of surface-surface intersections and trimming that plague conventional B-rep solid modeling, by providing convenient ways to create surfaces that join accurately in the first place, and that remain accurately joined through capture and enforcement of this qualitative relationship.
  5. RGS models can be stored in an extremely compact format conveying only the "logical model", i.e. the "genetic instructions" for recreating the model from scratch, including all defined relationships between objects.

RGS clearly has some features in common with Armit's TAG [3] and Boeing's AGPS [4, 5, 6]. The extent of similarities to these systems is difficult to judge from the available references, but we believe RGS provides much more pervasive use of dependency relationships than AGPS, and a much richer entity set than either TAG or AGPS. Automatic update of geometry following changes is also characteristic of "constraint-based" modeling systems [7]. In our opinion, RGS is qualitatively different from constraint-based modeling and in particular is much more adept at supporting 3-D design with free-form curves and surfaces.

Compared with NURBS-based curve and surface modeling, RGS's explicit support of many entities not precisely representable by NURBS has large advantages in modeling convenience and accuracy.

RGS is the basis of AeroHydro's MultiSurf (R) surface modeler for IBM-PC compatibles (DOS and Windows) [8]. UNIX workstation versions are under development. All the mathematical and logical functions of MultiSurf are available in an ANSI C library RGKERNEL, for incorporation into third party applications. Patent applications are pending which claim many of the novel features of RGS.

RGS lends itself to a highly interactive, highly visual 3-D design environment for creation, viewing, revision and analysis of models. Largely motivated by marine design needs, RGS provides new solutions to many panelization and gridding problems for CFD and FEM applications.

RGS Fundamentals

Definitions:

entity -- an abstract type of geometric object, e.g. point, line, plane, B-spline surface

object -- a particular concrete instance of an entity; e.g. an absolute point at (0., 1., 2.)

In conventional computer-aided geometric design (CAGD), the nouns entity and object are applied more or less interchangeably to either of these concepts. In RGS, the two concepts are semantically distinguished by the above defined usage. An entity is like a blank form with spaces to be filled in with data such as object name, color, visibility, coordinates, names of other objects. An object is like a filled-in copy of that form. RGS entities and objects correspond to the "classes" and "objects" of object-oriented programming terminology.

In RGS, every object -- point, curve, snake, surface, etc. -- has a unique object name. The object name may be used to reference the object whenever it is used in construction of other objects. This is the essential means by which many qualitative relationships are captured. The object name can also be used to select, edit and interrogate the object while constructing and editing a model interactively.

Entities can be broadly classified first according to their dimensionality, and secondarily according to their embedding in other objects. Table 1 is a hierarchical listing of currently implemented RGS entities.

Under Points (0-dimensional entities) there are 4 classes:

  • 3-D points (constructed in various ways)
  • Magnet - a point embedded in a surface
  • Beads - a point embedded in a 3-D curve
  • Rings - a point embedded in a snake

Under Curves (1-dimensional entities) there are 3 classes:

Under Surfaces (2-dimensional entities) there are 2 classes:

Table 1 lists many specific entities in each class, with an explanation of the essential data required for each.

Generally, curves are formed from points, in a variety of ways as indicated in Table 1. For example, the data for a Line is simply the names of two points. The data for a B-spline curve is a list of points specified by their object names. Any type of point object (point, bead, magnet, ring, etc.) will serve as a point, and different point types can be freely mixed.

Surfaces are formed in some cases (e.g. B-spline surface, NURBS surface) from a net of points; usually (e.g. Coons patch, lofted surfaces) from a set of curves; or sometimes (e.g. SubSurface, Fillet) from a set of snakes on one or more underlying surfaces. In each case the supporting point, curve, and snake objects are all specified by using their object names; any kind of point, curve or snake can be used, and these can be freely mixed.

Most of the basic curve and surface entities supported under RGS are well known. The difference lies in how the data is organized and obtained to evaluate the curve and surface objects. Some novel entities have arisen by recognizing gaps in the logical structure of RGS; for example, the Blofted and BlendCenter surfaces, which are useful generalizations of the B-spline surface and Coons patch.

Six RGS surface entities (Ruled, Arc-Loft, FoilLoft, B-Loft, C-Loft, X-Loft Surfaces) are classed as "lofted surfaces", and share a common structure. Each lofted surface is supported by 2 or more master curves, depending on the surface type. Evaluation of a single point at parameters u,v on a lofted surface is a 3-stage process:

  1. Evaluate each of the master curves at a parameter value t = u
  2. Construct the curve of appropriate type (Line, Arc, Foil, B-spline or C-spline) which uses these points as data
  3. Evaluate the curve at parameter value t = v 
Surface       No. of MC's   Lofting Curve       
Entity                                          
Ruled         2             line                
Arc-lofted    3             circular arc        
Foil-lofted   3 or 5        NACA foil           
B-lofted      >1            B-spline            
C-lofted      >1            interpolating       
                            spline              
X-lofted      >1            explicit spline

Figure 1 is an example of an RGS model for a 30-ft sailboat hull. 'hull' is a C-Lofted surface, supported by 3 master curves 'MC1', 'MC2', 'MC3'. Each of the master curves is a B-spline curve, supported by 4 absolute points. The surface is displayed by showing some of the longitudinal "lofting" C-splines.

Another way to view RGS is as a programming or representation language. The data base ("Model File") for the model of Figure 1 is given in Table 2 as an example. Each line in the Model File creates an object. The entity names 'AbsPoint', 'BCurve', etc. may be viewed as commands or functions, which are followed by required parameters in prescribed order. The language has a prescribed syntax. Models can be created and modified by editing text files adhering to this syntax. Dependencies are represented by the occurrence of object names as parameters for other objects.

Since the model file contains only concise instructions for building the absolute model, it is extremely compact compared with conventional CAD representations. Model files average about 35 bytes per object, whether the object is a point, curve or surface.

Snakes are generally formed from magnets, in a variety of ways as indicated in Table 1. (Rings also qualify as "magnets" for this purpose, since a ring is logically constrained to the surface to which its snake belongs.) The snakes are highly parallel to the curve entities, so they work in a consistent fashion. Snakes can also serve as curves in the construction of surfaces.

"Relative" entities are specified by coordinate or parameter offsets from another object of the same class. For example, a relative bead is specified by a parameter offset dt from a basis bead. It lies on the same curve as its basis bead, at a fixed offset in parameter space. If the basis bead is moved along the supporting curve, the relative bead automatically moves also, to maintain its (parametric) distance away. Use of these relative entities is an important mechanism for capturing and enforcing quantitative relationships between objects.

All curves and snakes are parameterized from 0 to 1 in a parameter t. All parametric surface patches are parameterized from 0 to 1 in each of two parameters u,v, in most cases inheriting the parameterization of their supporting curves. Beads, rings and magnets are located using these parameters. Thus, objects located on a curve or surface will automatically shift to "similar" positions following a change in their supporting curve or surface. Uniformity of the ranges of parameterization is an important key to the interchangeability of various curve, snake and surface types in construction of other objects.

Dependencies of objects on other objects are always represented by references using object names. These take several forms; for example:

  1. a Relative Point depends on its basis point.
  2. a Relative bead depends on its basis bead, and indirectly on the curve that supports both beads.
  3. a Coons patch or lofted surface depends on each of its supporting curves, and indirectly on the points that support them
  4. a B-spline Snake depends on each of its supporting magnets, and indirectly on the surface that supports them, and all the curves and points supporting that surface, etc.

Dependency can extend to an arbitrary number of levels. The dependency structure of a model is representable by a directed graph (digraph), which is sometimes a useful way to contemplate the topological structure of a model. (Figure 2 is the dependency digraph for the model given in Figure 1/ Table 2). The digraph structure can also be used advantageously by the program to selectively update only the objects affected by a given change, i.e., the set of objects that depend directly or indirectly on the particular object that was changed.

It is the capture and maintenance of these dependencies that enables the automatic update feature of RGS, providing a dramatically new paradigm for geometric design. We envisage conventional design, computer-aided or otherwise, as a linear process, a sequence of forward stages, each depending on completion of the prior stage. In sequence, each basic component is designed and frozen, so that other components that depend on it can be designed on a firm foundation. At some point, the whole design is evaluated, and usually found deficient in some respects. At this point, it is very costly to go back to an early stage, altering early components, because all the intermediate design stages have to be repeated. With RGS, the intermediate design steps are captured in the model, and the entire model can be cheaply updated at any time. This is a whole new dimension of freedom in design. Instead of segmenting design into a series of stages, and freezing components in non-optimal states, RGS allows the entire geometric design process to be fluid and integrated end-to-end.

Qualitative model properties which result from the capture and enforcement of these relationships, and are thus conserved under changes in underlying objects, are referred to as "durable" properties.

Avoidance of surface-surface intersection problems is accomplished in several ways:

  1. Two lofted surfaces of the same type and the same number of master curves, whose master curves share endpoints, will join accurately and durably along their common edge.
  2. RGS supports several surface entities that interpolate 2 or 4 arbitrary boundary curves. Two such surfaces A and B that share the same curve as data will have a durable common edge along that curve.
  3. Suppose surface B is required to join surface A accurately, not along an edge of A, but somewhere out in the middle of A. This can be accomplished durably by using a snake on A as an edge curve for B, then using a surface for B that interpolates this edge curve.

Although the above methods eliminate the need for intersection and trimming in the great majority of situations, there still arise some modeling situations in which projection or intersection entities are required. These are met by a set of "projection" and "intersection" entities; for example, a ProjSnake is the projection of a curve onto a surface; an IntBead is at the intersection of a curve with a plane or surface. The projection and intersection entities involve iterative solutions, and are therefore subject to all the ills which intersections are heir to: possible nonexistence; possible multiple solutions; possible failures to converge; computational expense, etc. However, under RGS these evils are substantially alleviated by the possibility of providing good starting values for the iteration. For example, the data for an IntBead can be a bead (which identifies the intersecting curve, and provides a starting value for t) and a magnet (which identifies the intersecting surface, and provides starting values for u and v).

Parametric Design

"Parametric design" is a capability to specify a family of related designs having N numeric parameters xi, i=1...N, so that the specification of suitable values for all N parameters produces a valid instance of the family. The parameters xi span an n-dimensional "design space" within which, for example, an optimal design can be sought [9].

In RGS, a high degree of separation between topological and metrical components of geometry provides a strong capability for generating parametrically varied models having durable topology and other durable shape characteristics. Essentially, each real number occurring in the model file is a potential parameter; for the most part, these are the X,Y,Z coordinates or offsets of points, or the parameter values of beads, magnets and rings. The non-numeric content of the model file, especially the specification of interobject relationships through use of object names, conveys the topology.

A stronger parametric capability currently under development arises from permitting use of numeric variables and expressions in the model file. This is currently being simulated by use of model file preprocessors.

Panelization Using Patches and SubSurfs

Since all parametric surface objects in RGS are topologically rectangular patches, it is quite simple and direct to use the mesh of isoparametric lines on any fully wetted patch to generate quadrilateral or triangular panels. The subdivision of any surface into a mesh is part of its specification, and can easily be changed to control panel counts.

Panel size variations, e.g. cosine spacing on foil elements, is handled through a general facility for reparameterization ("relabeling") of curves and lofted surfaces. The surface mesh division responds to the relabeling of its supporting curves. Figure 3 shows some panel distributions available through relabeling of a wing surface.

Often, there are portions of a base surface object which are not wetted (e.g., the portion of a fuselage covered by the wing root or wing root fillet), and which should therefore not be panelized. The embedded SubSurf provides a general solution for this situation: the wetted portion is covered by quadrilateral SubSurf patches. It is generally possible, in fact easy, to durably coordinate the subdivisions of adjacent patches, e.g. wing and fuselage, so that neighboring panels on the two surfaces have identical corner points, since the two patches share snakes as common boundaries. Figure 4 shows a filleted wing-body example with this property.

Examples of Parametric Design and Panelization

Tension-leg Platform Example

Figure 5 shows several members of a 4-parameter family of tension-leg platforms (TLP's). TLP's are buoyant structures, moored to the seafloor by taut cables, commonly used for offshore drilling platforms in relatively deep water. The vertical cylinders are called "legs" and the horizontal members are "pontoons". Panel methods are used to analyze the response of TLP's and their mooring systems to gravity waves in the ocean environment.

In this model family, both legs and pontoons are circular cylinders; the 4 parameters are:

  • leg depth
  • leg radius
  • pontoon depth
  • pontoon radius

Each parameter is associated with a single real number in the model file. Figure 5 shows the base model and 4 variants, with one parameter varied at a time.

The essential structure of the model is as follows:

  1. Exploiting symmetry, only 1/8 of the model needs to be explicitly constructed.
  2. The model begins with a base half-cylinder (RevSurf) for the complete leg surface.
  3. A circle is constructed to define the pontoon depth and radius.
  4. The circle is projected horizontally onto the leg, making a ProjSnake.
  5. The pontoon surface is a ruled surface between the circle and the ProjSnake.
  6. The wetted portion of the leg (outside the ProjSnake) is cut by snakes into 3 SubSurfs.
  7. The bottom is a RevSurf made from a radial line as meridian.

Note the durable neat join between neighboring panels across the pontoon-leg and bottom-leg junctions, detailed in Fig. 6.

Sailing Yacht Example

Figure 7 shows a panelization of the underwater portions of a sailing yacht hull, keel and rudder. The yacht hull provides buoyant support for the vessel; the keel provides horizontal lift to resist side forces from the sails; the rudder provides directional control and stability. The lift and induced drag performance of the combination are crucial to sailing performance. These characteristics are typically analyzed by panel-based potential flow solutions.

In this example, the keel, keel tip, rudder, and rudder tip surfaces are fully wetted patches. A problem typical of panel methods in hydrodynamics is that only a portion of the hull surface is wetted, i.e., the portion below the water level and outside the keel and rudder root areas. This is handled with a single SubSurf covering this area. The edge of the SubSurf along the waterline is an intersection snake; the edge along the centerplane is a PolySnake which follows the centerplane where possible, but is indented around the keel and rudder. The SubSurf has one degenerate edge (a magnet) at the aft ending of the waterline, producing one row of triangular panels at this corner. The neat join between neighbor panels at the keel-hull and rudder-hull junctions arises from use of snakes on the hull surface to define both the root junctions and the centerline PolySnake. These properties are durable with respect to many possible variations in the hull, keel, and rudder geometries.

Submarine Example

Fig. 8 shows the base model and several variants on a parametric submarine design. The hull is a body of revolution; the conning tower or sail is a B-lofted surface attached to a snake on the hull. Available parameters include:

  • hull diameter
  • bow and stern prismatic coefficients
  • nose radius
  • sail height
  • sail length
  • sail width
  • sail longitudinal position.

The lower hull is a fully wetted patch; the wetted portion of the upper hull is a SubSurf built around the snake at the sail-hull junction. The panelization is topologically invariant with respect to all shape parameters, except the longitudinal position of the sail; if this changes too much, there needs to be some reparametrization of the dorsal PolySnake to avoid skewed panels.

Propeller Example

Fig. 9 shows a member of a parametrically generated propeller series. The data for this example is a standard propeller sheet (Table 3) giving chord, thickness, camber, rake and skew at selected radii. An auxiliary program performed curve fitting and smoothing on the radial variations of these shape parameters, generating a MultiSurf model file which reproduces the specified blade geometry. The modeled blade is a B-lofted surface using FoilSnakes on concentric cylinders as master curves.

Volume Gridding Using RG Solids

A straightforward extension of RGS to 3-D parametric solids has been made at a pilot level. This appears to have important potential for 3-D gridding. A parametric solid is a vector function of three parameters: x = x(u,v,w). It is easy to formulate RG solids constructed in several ways analogous to various surface entities; for example:

RuledSolid -- linear interpolation between two surfaces

BSolid -- trivariate tensor product using a 3-D array of control points

CLoftSolid -- spline interpolation through 2 or more surfaces

BlendSolid -- trivariate linear blending of 6 boundary surfaces

TranSolid, SweepSolid -- a surface patch swept along an axis curve

A parametric solid can easily be subdivided along isoparametric surfaces to create a structured mesh. It appears that the same techniques that produce neat, durable joins between neighboring patches in 2-D will extend naturally to solids, allowing continuity of elements between adjacent blocks.

Configuration Optimization

As diagrammed in Fig. 10, MultiSurf can serve as a geometry and panelization engine in a closed-loop optimization system including an optimizer and one or more analysis programs. The optimizer treats the model as a point in design space, and feeds design-space parameters to a model file generator. The resulting model file is read into MultiSurf , which generates a standard output file of surface meshes. A preprocessor casts this mesh data into the particular format required for input to the analysis program. The analysis program is run, and its output file is inspected by a postprocessor which extracts the required performance measures and returns the value of the objective function to the optimizer.

Concluding Remarks

We have outlined the principles of Relational Geometric Synthesis and given several examples of application to panelization and gridding problems. The capability of RGS to define parametric families of topologically invariate designs and to generate geometric representations of them, including high quality panelizations for analysis, promises large reductions in the skilled labor currently required for application of CFD and FEM in practical engineering design.

Acknowledgment

This work was supported in part by the U. S. Navy, Carderock Naval Surface Warfare Center, under contract N00167-95-C-0003.

References

1. Letcher, J. S. Jr. and Shook, D. M.: "Applications of Relational Geometric Synthesis in Sailing Yacht Design", Proceedings 11th Chesapeake Sailing Yacht Symposium, S.N.A.M.E. (1993)

2. Letcher, J. S. Jr., Shook, D. M. and Shepherd, S. G.: "Relational Geometric Synthesis -- Part 1: Framework", Computer Aided Design (accepted for publication)

3. Armit. A.: "TAG -- A High Performance Interactive 3D Graphics System", Computers in Industry, vol. 3, pp. 117-123 (1982)

4. Snepp, D. K. and Pomeroy, R. C.: "A Geometry System for Aerodynamic Design", AIAA-87-2902 (1987)

5. Capron, W. K. and Smit, K. L.: "Advanced Aerodynamic Applications of an Interactive Geometry and Visualization System", AIAA-91-0800 (1991)

6. Gentry, A. E.: "Requirements for a Geometry Programming Language for CFD Applications", NASA CP-3143 (1992)

7. MacKrell, J.: "Making Sense of a Revolution", Computer Graphics World, v. 16, no. 11 (Nov. 1993)

8. AeroHydro, Inc.: MultiSurf User's Manual (1994)

9. Haug, E. J. and Arora, J. S.: Applied Optimal Design, Wiley, New York (1979)

Table 1. MultiSurf entities

Points (0-dimensional), including:

3-DOF points:

Absolute Point -- X,Y,Z coordinates
Relative Points -- X,Y,Z offsets from another point
Polar coordinates relative to another point

2-DOF points: Magnets -- points constrained to lie on a surface

Absolute Magnet -- u,v parameters
Relative Magnet -- u,v offsets
Projected Magnet -- projection of point onto surface
Intersection Magnet -- intersection of surface with a curve

1-DOF points: Beads -- points constrained to lie on a curve

Absolute Bead -- t parameter
Relative Bead -- t offset
Intersection Bead -- intersection of curve with plane or surface

Rings -- points constrained to lie on a snake

Absolute Ring -- t parameter
Relative Ring -- t offset
Intersection Ring -- intersection of snake with plane or curve

0-DOF points: Projected Point -- point projected onto a plane

Mirror Point -- point reflected in a plane
Offset Point -- offset along normal to surface
Tangent Point -- offset along the tangent to a curve

Curves (1-dimensional), including:

Line -- 2 points
Circular Arc -- 3 points
Conic sections -- type, 3 points, 2 parameters
NACA Foils -- 3 points (half section) or 5 points (full section)
B-spline Curve -- type, N points
C-spline Curve -- type, N points
X-spline Curve -- type, N points, end slopes or moments
NURBS Curve -- type, knotlist, N x ( point, weight )
SubCurve -- portion of a curve between 2 beads
PolyCurve -- concatenation of N curves
Relative Curve -- curve, 2 points, graph
Projected Curve -- curve projected onto a plane
Mirror Curve -- curve, plane
Offset Curve -- snake, 2 offsets, graph

Snakes (1-dimensional) -- curves constrained to lie on a surface:

Line Snake -- 2 magnets
Arc Snake -- 3 magnets
Foil Snake -- 3 magnets (half-section), or 5 magnets (full section)
B-spline Snake -- type, N magnets
C-spline Snake -- type, N magnets

NURBS Snake -- type, knotlist, N x ( magnet, weight )
SubSnake -- portion of a snake between 2 rings
PolySnake -- concatenation of N snakes
Relative Snake -- snake, 2 magnets
EdgeSnake -- type, surface
Projected Snake -- projection of a curve onto a surface
Intersection Snake -- intersection with a plane or surface

Surfaces (2-dimensional), including:

Revolution Surface -- curve, axis line, 2 angles
Translation Surface -- 2 curves
Coons patch -- 4 curves (nominally end-to-end), 2 graphs
Developable Surface -- 2 curves
Ruled Surface -- 2 curves
B-spline Lofted Surface -- type, N curves
C-spline Lofted Surface -- type, N curves
X-spline Lofted Surface -- type, N curves, 4 graphs for end conditions
Foil-lofted Surface -- type, 3 or 5 curves
B-spline Surface -- utype, vtype, N x M points
NURBS Surface -- utype, vtype, 2 knotlists, N x M x (point, weight)
Offset Surface -- surface, 4 offsets
Relative Surface -- surface, 4 points
Blister -- type, 2 snakes, curve
Fillet -- 2 snakes on each of 2 surfaces
SubSurface -- 4 snakes (nominally end-to-end)
Projected Surface -- surface, plane
Mirror Surface -- surface, plane
Sweep Surface -- surface, curve
PolySurf -- concatenation of N surfaces

Miscellaneous:

Planes -- nonparametric planes, specified several ways (e.g., 3 points)
Contours -- set of parallel plane, cylindrical, or spherical sections
Knotlist -- knot vector, used in NURBS entities
Wireframe -- name of a wireframe file, point
Graphs -- univariate function of parameter
Frames -- local orientable coordinate system

Table 2. Model file for the example of Figure 1.

MultiSurf 0.35 /y 
Rem demo of C-lofted surface with 3 B-spline MCs 
AbsPoint P11 14 1 0.000 0.000 3.600; 
AbsPoint P12 14 1 1.367 0.000 0.602; 
AbsPoint P13 14 1 2.324 0.000 -0.800; 
AbsPoint P14 14 1 3.000 0.000 -0.900; 
BCurve MC1 11 1 10 * 2 
{ P11 P12 P13 P14 }; 
AbsPoint P21 14 1 15.000 4.815 2.560; 
AbsPoint P22 14 1 15.000 5.046 0.628; 
AbsPoint P23 14 1 15.000 3.603 -0.870; 
AbsPoint P24 14 1 15.000 0.000 -1.175; 
BCurve MC2 11 1 10 * 2 
{ P21 P22 P23 P24 }; 
AbsPoint P31 14 1 30.000 3.500 2.760; 
AbsPoint P32 14 1 30.000 3.500 1.320; 
AbsPoint P33 14 1 30.000 2.500 0.120; 
AbsPoint P34 14 1 30.000 0.000 0.120; 
BCurve MC3 11 1 10 * 2 
{ P31 P32 P33 P34 }; 
CLoftSurf hull 10 1 10 1 20 1 0 3 
{ MC1 MC2 MC3 }; 
XContours stations 12 1 0 10 1.8 2.735; 
ZContours waterlines 13 1 0 0 0. 1.; 
EndModel

Table 3. Data sheet for parametric propeller design.

DESIGN DATA PROPELLER 0000 -R.H.
         DIAMETER =   12.00 INCHES SHIP   (  304.8 MILLIMETRES SHIP )
                                                                PROJECTED
                                              AFT.    AFT. RAKE   SKEW
 R/R      P/D    CHORD/D    T/D      CAM/D    RAKE/D  (DEGREES) (DEGREES)   R/R
 .200   1.5358    .1735    .0434    .00583   0.00000     0.00      0.00    .200
 .300   1.5125    .2283    .0357    .00933   0.00000     0.00      9.29    .300
 .400   1.4592    .2750    .0294    .01058   0.00000     0.00     18.79    .400
 .500   1.3858    .3125    .0240    .01067   0.00000     0.00     28.01    .500
 .600   1.2958    .3375    .0191    .00950   0.00000     0.00     36.75    .600
 .700   1.1975    .3475    .0146    .00800   0.00000     0.00     45.43    .700
 .800   1.0958    .3342    .0105    .00633   0.00000     0.00     54.23    .800
 .900    .9958    .2808    .0067    .00442   0.00000     0.00     63.11    .900
 .950    .9483    .2192    .0058    .00317   0.00000     0.00     67.76    .950
 .960    .9383    .2021    .0054    .00292   0.00000     0.00     68.72    .960
 .970    .9292    .1800    .0053    .00250   0.00000     0.00     69.68    .970
 .980    .9196    .1521    .0051    .00208   0.00000     0.00     70.65    .980
 .990    .9108    .1146    .0050    .00183   0.00000     0.00     71.61    .990
1.000    .9013   0.0000   0.0000   0.00000   0.00000     0.00     72.59   1.000
              SECTION CAMBER DISTRIBUTION            NACA A=0.8 MEANLINE
              SECTION THICKNESS DISTRIBUTION         NACA 66 (TMB MODIFIED)
              EXPANDED AREA RATIO                    .7253
              PROJECTED AREA RATIO                   .5701
              MEAN WIDTH RATIO                       .2848
              BLADE THICKNESS FRACTION               .0488
              RAKE ANGLE AT BLADE TIP               0.0000 (DEGREES)
              PROJECTED SKEW ANGLE AT BLADE TIP    72.5880 (DEGREES)
              LINEAR RATIO                          1.0000

Fig. 1. A C-lofted hull surface with 3 B-spline master curves, each supported by 4 points.

Fig. 2. Digraph of object dependencies for the hull example in Fig. 1/Table 1.

Fig. 3. Typical variations in spanwise and chordwise panel distributions available by relabeling the supporting curves of a wing surface.

Fig. 4. Panelization of a filleted wing-body junction using SubSurfs on the wing and body.

Fig. 5. Parametric variations in tension-leg platform geometry and panelization. Topologically similar panelizations are produced automatically as geometry is parametrically varied over wide ranges.

Fig. 6. Detail of a tension-leg platform panelization showing neat joins between pontoon, leg, and bottom panels.

Fig. 7. Panelization of sailing yacht hull, keel, and rudder combination. The hull panels are a SubSurf between an intersection snake along the waterline and a PolySnake along the ventral edge.

Fig. 8. Parametric submarine example, showing hull and sail variations, with instant repanelization by SubSurfs.

Fig. 9. Propeller model generated automatically from propeller data sheet giving chord, thickness, camber, skew, and rake at various radii (Table 3.)

Fig. 10. Closed-loop configuration optimization using MultiSurf as geometry engine and panelizer.

                                                                            

Back to Relational Geometry