On the Construction of Geometry - University of Michiganmdolab.engin.umich.edu/MDO_Workshop_2011/Agenda_files/Haimes_… · On the Construction of Geometry for Aircraft Conceptual

AEROSPACE COMPUTATIONAL DESIGN LABORATORY

On the Construction of Geometryfor

Aircraft Conceptual Modelsthat

Facilitate High-Fidelity Analysis

Bob Haimes ([email protected])

Aerospace Computational Design LaboratoryDepartment of Aeronautics & Astronautics

Massachusetts Institute of Technology

6th Research Consortium for Multidisciplinary System Design Workshop

University of Michigan — Ann Arbor, 27 July 2011


Outline• Introduction

– Definitions– Air Vehicle Design– High-Fidelity Analysis Requirements

• CAPRI – A Uniform Direct Interface– Geometry Import– Constructing Models for Design– Air Vehicle Design

• EGADS – A Solids Construction Interface– Overview– Objects– API– Example Usage

• Concluding Remarks


Introduction – DefinitionsGeometry Representations:• File Standards

– Stereo Lithography (STL)– IGES (disconnected curves and surfaces)– STEP (can maintain a “solid” model)

• Geometry Kernels (proprietary file formats)– ACIS– Parasolid– OpenCASCADE

• CAD Systems (proprietary file formats)– Catia, Pro/ENGINEER, SolidWorks, Unigraphics, etc…– Complete Environments

• Support for Assemblies• Structural Analysis


Introduction – Air Vehicle Design

Current Conceptual Design Tools (e.g., PASS):• Input

– Mission Requirements (Capacity, Range, Field length, …)

• Analysis & Optimization– Low Fidelity Physics, Empiricisms & Look-up Tables– Large Design space examined– Many configurations considered without access to High-Fidelity

• Output– Suggests 3D geometry Planform– Estimate of component/system location

The 3D Geometry is Realized by an Artist Rendering!



Gap Between Conceptual & Preliminary Phases

• Novel Concepts– Danger in Extrapolation

• No 3D Geometry– Someone must generate geometry from the Artist Rendering– How are the geometric details realized?– HiFi Analysis requires a complete 3D “Discipline” description

• No Feedback (Process related)– Must go forward with the one Concept– Will end up with a Suboptimal Vehicle as flaws in Low-Fidelity

assumptions are found– Engineering workarounds are required, which lead to additional

costs and time through minor redesigns



Current Conceptual Geometry Tools

• Component Based (wings, fuselage, …)– Parametric

• Home-grown Geometry Kernels– Usually limited to wire-frame representations– No Component/Component Intersection required– Examples: DesktopAreo’s RAGE, NASA’s VSP, pyPSG

• Use of existing Geometry Kernels– The kernel deals with the surface/surface intersection– Can export standard files (IGES)– Examples: TechnoSoft’s AML and AMRaven

• Uses Parasolid BUT does NOT produce Solid Models!

Not Connected to Conceptual Design Tools!


Introduction – Multidisciplinary Geometry

External Aerodynamics & Structural Layout

From an Assembly:OML, spars & ribs

Lazzara, D., Parham, J. and Haimes, R., “OnStructural Layout using Multifidelity Geometry inAircraft Conceptual Design”, AIAA Paper 2010-1316


Introduction – MDA & MDOAnalysis and Geometry Construction have

Developed Independently• 3D High-Fidelity Analysis Requirements:

– Closed watertight representation– Specification of materials/boundary conditions– Geometric fidelity depends on Analysis

• Current Geometric capture through Translation• Without Consistent Geometry control:

– What can be said about MDA where the Geometry is usedto couple the simulations (e.g. FSI)?

– What builds new Geometry in Design settings?

• Where is Automation?

Wish to Insert High-Fidelity into Conceptual Design


CAPRI – Uniform Direct Interface

Designed as a foundation to build applications;not just to expose the Geometry/Topology

CAD API

CAPRI API

ApplicationsNeutral Layer

Vendor Specific

Computational Analysis PRogramming Interface

CONTROL

Dynamic Load

CAD Services


CAPRI – Uniform Direct Interface

Solid Representation of Geometry – BRep

pointNode (node)

(x,y,z) = g(t)curveEdge (edge)

Loop

(x,y,z) = f(u,v)surfaceFace (face)

Shell

Body (volume)

Assembly (model)

ParameterizationGeometric EntityTopological Entity

CAD Solids are open at machine precision – tolerances• Node points that bound Edges may not be on the curve• Edge curves that bound the Faces (through Loops) may

not be on the underlying surface


CAPRI – Geometry Import

Access to Analytic Geometry

• Evaluations– Given t or (u,v) (x,y,z)– Optional 1st and 2nd derivatives

• Inverse Evaluations– Given (x,y,z) t or (u,v)

• Primitives– Lines and circles– Planar, spherical, cylindrical, conic and toroidal surfaces

• Conversion to NURBS– May be an approximation

Must provide for Automation


CAPRI – Geometry ImportDual View: Solid/BRep and a Triangulation• Robust• Associative with BRep

– All vertices on geometry (with appropriate parameters)– Owning Face for triangles

• Correct– Logically (u,v)– Geometrically, with NO notion of physics/solver

• Watertight – closure for BRep• Adjustable

– Side length, dihedral angle, chordal distance (sag)• CAPRI’s scheme:

8th ICNGG (Hawaii, 2002) – watertight tessellation13th IMR (Williamsburg VA, 2004) – anisotropic triangulations

NOT just for Visualization


CAPRI – Geometry Import

Tessellation Examples


Constructing Models for DesignMaster-Model (Parametric CAD)• Feature Tree

– Reflects build “recipe”– Each Branch reflects an operation (CAD dependent):

• Constructive Solid Geometry Operations• Extrude, Rotate, Loft, Blend• Hole Cut, Boss• Fillet, Chamfer

– Branches may be suppressible

• Parameters– Drive Dimensionality– Adjustable (not driven) values may be modified

• Simple– CAPRI has less than 20 functions (in this part of the API)

LEN

HT

WID


Constructing Models for DesignShape Design• No Feature exposes knot/control points of resultant

surfaces as adjustable values• Sketches are used by many CSG Features• Sketch Features produce closed Contours:

– 2D primitives (lines, arcs, and etc.)– Associated dimensions– 2D Spline curves

• 3D Splines used as guide-curves for some operations

Exposing adjustable splines as multi-valued parameters 3D Shape modification becomes simple

• Can adjust: Spline Point Position, and optionallyTangency & Radius of Curvature (2D and 3D)


CAPRI – Shape Design


CAPRI – Air Vehicle Design

The CAPRI Approach – Variable Fidelity Design

• Parametric CAD System is the Conceptual “sketch pad”– Concepts are individual CAD models (i.e., monoplane, biplane)– Parameterization consistent with Conceptual Design Tool(s)– Allow for geometric prep WRT the Simulations to be used

• Use Higher-fidelity Analysis tools when required• Regenerate CAD model(s) via CAPRI based on updated

Design Parameters from Analyses and/or Optimizer• Allow for the choice on another Concept when

fundamental flaws are found

3D Geometry can be used in a consistent manner fromConceptual through Detailed Design and Manufacturing


CAPRI – Air Vehicle DesignCompelling BUT Not Adopted by the Conceptual

Design Community:

• CAD-phobic (& Myopic)– Why should I to go to CAD when I have everything I need?– Geometry is the CFDer’s Responsibility!

• Control of Geometry (does require a skilled CAD operator)– CAD can not produce the kind of Lofting I need!

• Desire for Lighter-weight License-free Geometry (HPC)• Enamored with their Own Tools!

– Includes Legacy FORTRAN– Recent NASA FAP NRA RFP for VSP– AIAA ASM 2011 39-AD-2 “Conceptual Aircraft Geometry Modeling”

How can we take the best of the CAPRI solution and move Conceptual Design towards High-Fidelity MDO?


EGADS: Electronic Geometry Aircraft Design System

Provide a “bottom up” and/or Constructive SolidGeometry foundation for building Aircraft

• Construct Components as Solids as Early as Possible

• Use OpenCASCADE as Geometry Kernel– Open Source solid modeling geometry kernel– Support for manifold and non-manifold data– Reading & writing IGES, STEP and native formats– But, C++ with ~17,000 methods!

• C/C++ and FORTRAN Interfaces– Single API with minor variations for FORTRAN– Always returns an integer code (success/error condition)– Requires C pointer access in FORTRAN

• Cray-pointer construct• C-pointers (2003 extension to FORTRAN 90)• Both supported by Intel FORTRAN and gfortran• API contains memory functions


EGADS – Overview• System Support (32 & 64 bit):

– Mac OSX with gcc, ifort and/or gfortran– LINUX with gcc, ifort and/or gfortran– Windows with Microsoft Visual Studio C++ and ifort

• Compiler version must match system used to build OpenCASCADE– No globals (but not thread-safe due to OpenCASCADE)– Various levels of output (0-none, through 3-debug)– Written in C and C++

• Open Source (LGPL v2.1)

• EGADS Objects– Treated as “blind” pointers -- an ego

• Makes the FORTRAN port tractable• Can access internals in C/C++

– egos are INTEGER*8 variables in FORTRAN• Allows for same source code regardless of pointer size• Requires “freeing” of internal lists of objects, super-egos (not in C/C++)


EGADS – Object Attributes• Attributes

– Are identified by a name (character string with no spaces or otherspecial characters)

– Each named attribute has a single type:• Integer• Real (double precision)• String (can have spaces and other special characters)

– And a length (for Integer and Real types)

• Object Attribution– Any Object (except for REFERENCE) may have multiple Attributes– Only Attributes on Topological Objects are copied– Only Attributes on Topological Objects are persistent -- and this is

available only for “.egads” file IO.

• SBOs and Intersection Functions– Attributes on Faces will be carried through to the resultant

fragments after intersections


EGADS – Objects: Geometry

• PCURVE -- Parameter Curves– 2D Curves in the Parametric space [u,v] of a Surface– Single “running” parameter t– [u,v] = f(t)

• CURVE– 3D Curves– Single “running” parameter t– [x,y,z] = f(t)

• SURFACE– 3D Surfaces of 2 parameters [u,v]– [x,y,z] = f(u,v)


EGADS – Objects: PCURVE/CURVE

Types:

• LINE• CIRCLE• ELLIPSE• PARABOLA• HYPERBOLA• TRIMMED (has Reference Geometry)• OFFSET (has Reference Geometry)• BEZIER• BSPLINE (including NURBS)


EGADS – Objects: SURFACE

Types:• PLANE• SPHERICAL• CONICAL• CYLINDRICAL• TOROIDAL• REVOLUTION• EXTRUSION• TRIMMED (has Reference Geometry)• OFFSET (has Reference Geometry)• BEZIER• BSPLINE (including NURBS)


EGADS – Objects: Topology

VertexNode

curveEdge

* see note belowWireLoop

surfaceFace

Shell

Solid (or lesser shape)Body

Compound ShapeModel

Geometric EntitiesOpenCASCADE termEGADS Topological Entity

• Topological entities have children (entities lower on the table) except for Nodes

* Loops may be geometry free or have associated PCurves (one for each Edge)and the surface where the PCurves reside



• NODE– Contains [x,y,z]

• EDGE– Has a 3D CURVE (if not DEGENERATE)– Has a t range (tmin to tmax, where tmin < tmax)– The positive orientation is going from tmin to tmax– Has a NODE for tmin and for tmax– Can be ONENODE (closed or periodic), TWONODE, or

DEGENERATE (which has a single NODE and a validrange which will be used for the associated PCurve)



• LOOP (without a reference SURFACE)– Free standing collection of EDGEs that can be used in a

non-manifold setting (for example in WireBodies)– Collections of EDGEs associated with a PLANE which

does not require PCurves in OpenCASCADE

– An ordered collection of EDGE objects with associatedsenses that define the connected Wire

– Segregates space by maintaining material to the left of therunning LOOP (or traversed right-handed pointing out ofthe intended volume)

– No EDGEs should be DEGENERATE– Can be OPEN or CLOSED (comes back on itself)



• LOOP (with a reference SURFACE)– Collections of EDGEs (like without a SURFACE) followed

by a corresponding collection of PCurves that define the[u,v] trimming on the SURFACE

– DEGENERATE EDGEs are required when the [u,v]mapping collapses like at the apex of a cone (note thatthe PCurve is needed to be fully defined using theEDGE’s t range)

– An EDGE may be found in a LOOP twice (with oppositesenses) and with different PCurves. For example aclosed cylindrical surface at the seam -- one PCurvewould represent the beginning of the period where theother is the end of the periodic range.


EGADS – Objects: Topology• FACE

– A SURFACE bounded by one or more LOOPs with associatedsenses

– There must be only one outer LOOP (sense = 1) and anynumber of inner LOOPs (sense = -1)

– All LOOPs must be CLOSED– If the SURFACE is a PLANE, the LOOP(s) must not contain any

reference geometry– If the SURFACE is not a PLANE then the LOOP’s reference

Object must match that of the FACE– The orientation of the FACE is either SFORWARD (where the

SURFACE’s natural normal (UxV) matches the FACE) orSREVERSE when the orientations are apposed. Note that this iscoupled with the LOOP’s orientation (i.e. an outer LOOPtraverses the FACE in a right-handed manner defining theoutward direction)


EGADS – Objects: Topology• SHELL

– A collection of one of more connected FACEs that (ifCLOSED) segregates regions of 3-Space

– All FACEs must be properly oriented– SHELLs can be either OPEN or CLOSED

• SOLIDBODY– A collection of one or more CLOSED SHELLs with

associated senses– There must be only one outer SHELL (sense = 1)

and any number of inner SHELLs (sense = -1)


EGADS – Objects: Topology• BODY (including SOLIDBODY)

– Container used to aggregate Topology– Connected but non-manifold at the MODEL level– A WIREBODY contains a single LOOP– A FACEBODY contains a single FACE– A SHEETBODY contains a single SHELL

• MODEL– A collection of BODIES– Can be treated like Assemblies– This is Read and Written by EGADS


EGADS – Objects: TessellationDiscrete representation of another Object

• Geometry– Unconnected discretization of a range of the Object

• PolyLine for CURVEs at constant t increments• Regular Grid for SURFACEs at constant increments

• Body Topology– Connected and trimmed tessellation including:

• PolyLine for EDGEs• Triangulation for FACEs• Optional Quadrilateral Patching for FACEs

– Ownership and Geometric Parameters for Vertices– Adjustable Parameters for side length and curvature– Watertight


EGADS – Objects: TessellationWatertight Quadrilateral FACE Treatment

• Manual• Requires Existing Topologic Tessellation• Must be able to Isolate 4 “sides”

– Only single LOOPs– FACEs with more than 4 EDGEs are analyzed to see is

multiple EDGEs can be treated as a single “side”– Currently no DEGENERATE EDGEs

• Point counts on sides (based on EDGETessellation) are used:– TFI if opposites are equal– Templates otherwise

• EDGE Tessellation Adjustment Functions– When point counts don’t allow for Quadding


EGADS – Objects: Others

• TRANSFORM– Used when copying Objects to change the root

position and orientation

• REFERENCE– Allows of the management of Objects that refer to

other Objects (so that deletion does not invalidate thedata)

– This is an internal Object and is not usually seen bythe EGADS programmer.

• CONTEXT– Holds ‘globals’ including output level– Start of dual-threaded list of active egos– Pool of deleted objects


EGADS – The API• open

icode = EG_open(ego *context)icode = IG_open(I*8 context)

Opens and returns a CONTEXT object. Note that the Context is the beginning ofthe threaded list of objects.

• loadModelicode = EG_loadModel(ego context, int flags, char *name, ego *model)icode = IG_loadModel(I*8 context, I*4 flags, C** name, I*8 model)

Loads and returns a MODEL object from disk and put it in the CONTEXT.

flags: 1 - Don’t split closed and periodic entities

name: Load by extension– igs/iges– stp/step– brep (for native OpenCASCADE files)– egads (for native files with persistent Attributes, split ignored)


EGADS – The API• getTopology

icode = EG_getTopology(ego object, ego *ref, int *oclass, int *mtype, double *data, int *nchild, ego **pchldrn, int **psens)icode = IG_getTopology(I*8 object, I*8 ref, I*4 oclass, I*4 mtype, R*8 data, I*4 nchild, CPTR pchldrn, CPTR psens)

Returns information about the topological object:

ref is the reference geometry object (if none this is returned as NULL)oclass is NODE, EGDE, LOOP, FACE, SHELL, BODY or MODELmtype for EDGE is TWONODE, ONENODE or DEGENERATE for LOOP is OPEN or CLOSED for FACE is either SFORWARD or SREVERSE for SHELL is OPEN or CLOSED BODY is either WIREBODY, FACEBODY, SHEETBODY or SOLIDBODYdata will retrieve at most 4 doubles: for NODE this contains the [x,y,z] location EDGE is the t-start and t-end (the parametric bounds) FACE returns the [u,v] box (the limits first for u then for v)nchild number of children (lesser) topological objectspchldrn is a returned pointer to the block of children objects. FORTRAN only note: this pointer is freeable.psens is the returned pointer to a block of integer senses for the children.


EGADS – The API• makeTopology

icode = EG_makeTopology(ego context, ego ref, int oclass, int mtype, double *data, int nchild, ego *chldrn, int *senses, ego *topo)icode = IG_makeTopology(I*8 context, I*8 ref, I*4 oclass, I*4 mtype, R*8 data, I*4 nchild, I*8 chldrn, I*4 senses, I*8 topo)

Creates and returns a topological object:

context the CONTEXT object used to place the resultref reference geometry object required for EDGEs and FACEs (optional for LOOP)oclass is either NODE, EGDE, LOOP, FACE, SHELL, BODY or MODELmtype for EDGE is TWONODE, ONENODE or DEGENERATE for LOOP is OPEN or CLOSED for FACE is either SFORWARD or SREVERSE for SHELL is OPEN or CLOSED BODY is either WIREBODY, FACEBODY, SHEETBODY or SOLIDBODYdata may be NULL except for: NODE which contains the [x,y,z] location EDGE is the t-start and t-end (the parametric bounds)nchild number of children (lesser) topological objectschldrn a vector of children objects (nchild in length) if LOOP and has reference SURFACE, then 2*nchild in length (PCURVES follow)senses a vector of integer senses for the children (required for LOOPs only)topo the resultant returned topological object


EGADS – The API• makeGeometry

icode = EG_makeGeometry(ego contxt, int oclass, int mtype, ego rGeom, int *pinfo, double *prv, ego *geom)icode = IG_makeGeometry(I*8 contxt, I*4 oclass, I*4 mtype, I*8 rGeom, CPTR pinfo, CPTR prv, I*8 geom)

Creates a geometric object:

contxt the CONTEXT objectoclass PCURVE, CURVE or SURFACEmtype PCURVE/CURVE LINE, CIRCLE, ELLIPSE, PARABOLA, HYPERBOLA, TRIMMED, BEZIER, BSPLINE, OFFSET SURFACE PLANE, SPHERICAL, CYLINDER, REVOLUTION, TORIODAL, TRIMMED, BEZIER, BSPLINE, OFFSET, CONICAL, EXTRUSIONrGeom is the reference geometry object (if none use NULL)pinfo is a pointer to the block of integer information. Required for either BEZIER or BSPLINE.prv is the pointer to a block of double precision reals. The content and length depends on the oclass/mtype.geom is the resultant new geometry object


EGADS – The API• approximate

icode = EG_approximate(ego context, int mDeg, double tol, int *sizes, double *xyz, ego *geo)icode = IG_approximate(I*8 context, I*4 mDeg, R*8 tol, I*4 sizes, R*8 xyz, I*8 geo)

Computes and returns the resultant object created by approximating aBSpline. If the tolerance is zero for a SURFACE then the data is fit.

context the CONTEXT object used to place the resultmDeg is the maximum degree used for the approximation [3-8] Note: fits are always cubic.tol is the tolerance to use for the BSpline approximation proceduresizes a vector of 2 integers that specifies the size and dimensionality of the data. If the second is zero, then a CURVE is fit and the first integer is the length of the number of [x,y,z] triads. If the second integer is nonzero then the input data reflects a 2D map of coordinates.xyz the data to fit (3 times the number of points in length)geo the returned approximated (or fit) BSpline resultant object


EGADS – The API• makeFace

icode = EG_makeFace(ego object, int mtype, double *data, ego *face)icode = IG_makeFace(I*8 object, I*4 mtype, R*8 data, I*8 face)

Creates a simple FACE from a LOOP or a SURFACE. This also creates anyrequired NODEs, EDGEs and LOOPs.

object either a LOOP (for a planar cap) or a SURFACE with [u,v] boundsmtype is either SFORWARD or SREVERSEdata may be NULL for LOOPs but must be the limits for a SURFACEface the resultant returned topological FACE object

• solidBooleanicode = EG_solidBoolean(ego src, ego tool, int oper, ego *model)icode = IG_solidBoolean(I*8 src, I*8 tool, I*4 oper, I*8 model)

Performs the Solid Boolean Operations (SBOs) on the source BODY Object (thathas the type SOLIDBODY). The tool object types depend on the operation.

src the source SOLIDBODY objecttool the tool object:

either a SOLIDBODY for all operators or a FACE/FACEBODY for Subtractionoper 1-Subtraction, 2-Intersection and 3-Fusionmodel the resultant MODEL object (this is because there may be multiple bodies from either the subtraction or intersection operation).


EGADS – The API

• saveModelicode = EG_saveModel(ego model, char *name)icode = IG_saveModel(I*8 model, C** name)

Saves the MODEL to disk based on the filename extension.

• closeicode = EG_close(ego context)icode = IG_close(I*8 context)

Cleans up and closes the CONTEXT.

The current API contains a total of 59 Functions!


EGADS – Example Usage

Planform of Mark Drela’s design concept which is based on a modifiedtube-and-wing structure that has a very wide fuselage to provide extra lift.The aircraft would be used for domestic flights to carry 180 passengers ina coach cabin roomier than that of a Boeing 737-800.

One of MIT’s Concepts for The NASA FAP N+3 Design



Artist’s Rendering of the D8 double bubble series design concept whichis based on a modified tube-and-wing structure that has a very widefuselage to provide extra lift and additional capacity.

One of MIT’s Concepts for The NASA FAP N+3 Design



• Input: Wire Frame Components• Operations:

– approximate– makeFace– solidBoolean (union)

• Output (can be STEP & IGES):– Triangulation for Cart3D– NMB file (native) for GridGen


Concluding RemarksCAD Model Construction• Parametric CAD requires a different “mind set”

– More like OO programming (NOT drafting)– Need not worry about the detailed shapes – malleable model

• Support for Multiple Disciplines through SBOs• Art Form – CAD Operator/Designer must know:

– Nuances of the CAD system– The design envelope – Robustness– The Geometric view required for each Discipline

EGADS Model Construction• Insert Construction Functions at the appropriate place

– Towards end of Component Build– Output (or use) Attributed Component in a CSG manner

• How best to Construct Multidisciplinary Geometry?• Can not be taken as far as CAD-based construction in

the Process!


Concluding RemarksThe Future• EGADS continues under a new NASA FAP SFW to

support OpenMDAO– Open Source– Define Geometric Data to be passed around the Framework– Build a simple CAD-like Parametric front-end

• John Dannenhoffer’s Overset Component-based Mesh Constructor• GUI• Component “features”

• Robustness of the SBOs in OpenCASCADE– Intersection Curves OK– Rebuilding Topology is at times Problematic

• Analytic Parametric Sensitivities– Need the Parametric Front-end– Need a way to interact with Construction Primitives that are used

to generate Geometry that is outside of the Front-End– Can always fall back to Finite Differences


Acknowlegements

EGADS was initially designed and mapped-out onMark Drela’s blackboard in late January 2011

In attendance was:Prof. Mark DrelaHarold Youngren (Guppy)Myself

Mark “found” the $$ to support the initial EGADSDevelopment

Documents

On the Construction of Geometry - University of Michiganmdolab.engin.umich.edu/MDO_Workshop_2011/Agenda_files/Haimes_… · On the Construction of Geometry for Aircraft Conceptual