Journal of the Brazilian Society of Mechanical Sciences
Print version ISSN 01007386
J. Braz. Soc. Mech. Sci. vol.23 no.3 Rio de Janeiro 2001
http://dx.doi.org/10.1590/S010073862001000300002
Objectoriented Programming Applied to the Development of Structural Analysis and Optimization Software
Marco L. Bittencourt
Cláudio A. C. Silva
Departamento de Projeto Mecânico
Faculdade de Engenharia Mecânica
Universidade Estadual de Campinas
13083970 Campinas, SP. Brazil
mlb@fem.unicamp.br, cacs@fem.unicamp.br
Raúl A. Feijóo
Laboratório Nacional de Computação Científica (LNCC/CNPq)
Av. Getúlio Vargas 333
25651070 Petrópolis, RJ. Brazil
feij@lncc.br
This paper presents the development of a twodimensional interactive software environment for structural analysis and optimization based on objectoriented programming using the C++ language. The main feature of the software is the effective integration of several computational tools into graphical user interfaces implemented in the Windows98 and WindowsNT operating systems. The interfaces simplify data specification in the simulation and optimization of twodimensional linear elastic problems. NURBS have been used in the software modules to represent geometric and graphical data. Extensions to the analysis of threedimensional problems have been implemented and are also discussed in this paper.
Keywords: Objectoriented programming, finite element method, structural optimization, sensitivity analysis, C++
Introduction
The productivity of the software industry is still very small compared to the increasing development of the hardware industry in the last years. Objectoriented programming (OOP) has been used to improve the quality, productivity, and reusability of software components.
In this programming paradigm, the main agents or objects of the application must be identified. The objects have data and methods which describe their features and behavior. An objectoriented program is implemented as a set of classes and the objects are created by class instantiations. Two objects or instances of the same class are different only by the values stored in their variables. Therefore, classes are the basic modularization unit in an objectoriented environment.
Objects communicate themselves by the message mechanism. A message specifies only the action to be performed. Based on its methods, the receiving object must interpret the message, perform the respective set of operations, and return the result to the sending instance. A class encapsulates information that is accessed only by messages. A message with the same name can represent different operations through the polymorphism concept. For example, the message + can be an addition for a matrix class and also a concatenation for a string class.
The inheritance mechanism allows to implement class hierarchies in which lower level classes inherit data and methods of the higher level classes.
In this way, it is possible to extend and reuse classes in many applications by adding new variables and methods to describe more specific concepts in the class hierarchy.
In procedural languages, the program is decomposed in functions and procedures. In objectoriented programming, objects represent some behavior using data and methods. For example, vectors and matrices are common classes for linear algebra applications. Procedures for vector dotproduct and matrix multiplication are implemented as methods of those classes.
OOP concepts have been applied to structural analysis such as in some initial works [Bittencourt, 1990; Feijóo, Guimarães and Fancello, 1991; Filho and Devloo, 1991; Forde, Foschi and Stiemer, 1990; Miller, 1991; Scholz, 1992; Zimmermann, DuboisPelerin and Bomme, 1992] . One of the first objectoriented programs is discussed in [Forde et al., 1990] using the Object NAP language written with C and Pascal procedures. Concurrency, distributed processing, database, and finite element analysis software using the Flavors extension of the LISP language are presented in [Miller, 1991]. An extension of the Smalltalk class hierarchy to finite element analysis is given in [Zimmermann et al., 1992]. Due to the poor efficiency of the Smalltalk environment, a C++ version of the same program was developed in [DuboisPelerin, Zimmermann and Bomme, 1993]. An extension to plasticity problems is implemented in [Menétrey and Zimmermann, 1993]. In [Zeglinski, Han and Aitchison, 1994], class hierarchies for matrices (symmetric, sparse, column, etc) and finite element entities are described. A C++ environment with interpreter and execution modules and interactive specification of parameters for linear and nonlinear problems is presented in [Cardona, Klapka and Geradin, 1994]. Objectoriented aspects applied to numerical analysis, class graphical representation, database, and composite materials are presented in [Adeli and Yu, 1995; Yu and Adeli, 1993]. Artificial intelligence concepts for objectoriented structural analysis are discussed in [Adeli and Yu, 1995; Yu and Adeli, 1993; Tworzydlo and Oden, 1993; Tworzydlo and Oden, 1995]. Some recent applications of OOP in computational mechanics can be found in [Oñate, Idelsohn and E. Dvorkin, 1998].
A group of researchers has developed C++ classes for database, numerical analysis, finite elements, mesh generation, error estimation, adaptive analysis, multigrid methods, structural optimization, and data visualization (see [Bittencourt, 1996; Dari, 1994; Venere, 1996; Fancello, Guimarães, Feijóo and Venere, 1991; Feijóo et al., 1991; Galvão, 1995; Guimarães, Fancello, Feijóo and Feijóo, 1994; Silva and Bittencourt, 2000] and papers therein). In this paper, an interactive software environment for structural analysis and optimization of twodimensional linear elastic problems is presented. The extensions to threedimensional case are also discussed.
The main characteristics of the software environment are the userfriendly interfaces and an unique data structure to represent graphical information. NURBS (NonUniform Rational BSplines) curves have been used to implement the graphical data structure for the geometry definition, mesh generation, and data visualization. The graphical interfaces were implemented in Windows 98 and NT environments. The interfaces simplify the user's work in the definition of the discrete model, verification of results, and structural optimization of the mechanical component.
Initially, this paper presents objectoriented concepts such as modularization, abstraction, classes, and methods. A review of the concept of NURBS is also included. The main features of the twodimensional software environment are discussed. Finally, the extensions to 3D problems are addressed.
Objectoriented Programming Concepts
The OOP methodology consists of defining and implementing abstract data type hierarchies. Abstract types are defined by data and associated procedures to manipulate that data. In C++, abstract types are implemented by selfsufficient entities called classes. An object is an instance of some class. OOP is based on abstraction, encapsulation, modularization, inheritance, and polymorphism principles. These concepts are language independent.
Abstraction consists of extracting the most relevant features of the system to be modeled. It provides adequate generalization and eliminates irrelevant details. In OOP, abstraction means to list the defining characteristics of the classes. It also means to state the public interface of the classes, i.e., how their objects will interact with other objects.
The encapsulation concept means hidding the class internal implementation while the class interface is visible. Interaction among objects is controlled by the message mechanism. When an object receives a message, it performs an associated method. The implementation details are not known by the client code. This means that information is hidden outside the class and its derived classes. Information hiding is very useful. For example, if the class public interface is unaltered, the internal implementation can be changed without affecting how the other classes and application programs access that class.
When abstraction and encapsulation are used, a system can be composed by a set of weaklycoupled modules. Therefore, code updating and error detection are simplified. However, there is a suitable modularization level beyond that loss of efficiency begins.
The class information can be specialized using the inheritance principle. Subclasses inherit data and methods of their superclasses. In this way, it is possible to reuse codes in many applications with consequent reduction in development time and costs. The inheritance principle with C++ virtual classes introduces an important generalization feature.Pointers to higher level objects of the class hierarchy can represent lower levels ones in application programs. This characteristic allows to develop typeindependent code with dynamic binding at runtime. New classes can be added to the hierarchy and the application code will still work with this new type.
Polymorphism means that objects will answer differently for a same message. For instance, the message + may mean concatenation and sum, respectively, for string and matrix classes. Polymorphism and inheritance allows to achieve a fairly generic code that selects the methods to be performed at runtime.
NURBS
A point p in the Cartesian reference system with coordinates p = [X Y Z] can be represented in a 4D space using homogeneous coordinates. For that purpose, the homogeneous coordinate h is added to the point P such that P = [x y z h].
Rational Bsplines provide an unique and accurate formulation to represent common analytic forms such as lines, planes, polygons, conical sections, curves, free surfaces, and others. Nonuniform rational Bsplines are used in the implementation of the IGES standard for data exchange among CAD programs.
A rational Bspline curve is the projection on the physical threedimensional space of a nonrational curve defined in the 4D homogeneous coordinate space. The following general expression describes a rational Bspline [Rogers and Adams, 1990].
where are the control polygon vertexes of the nonrational Bspline defined in the 4D space and N_{i,k} _{}are the kthorder normalized Bspline base functions of degree k  1. The basis functions are given by the recursive CoxdeBoor's expression
The terms x_{i} are elements of the knot vector such that x_{i}< x_{i+1} and .
The projection is performed by dividing Eq. (1) by the homogeneous coordinate. The result is the general expression for a rational Bspline curve [Rogers and Adams, 1990].
where B_{i} are the threedimensional coordinates of the control points and R_{i,k }(t) are the rational base functions given by
From Eq. (1) and Eq. (2), it can be observed that the nonrational curves are a particular case of the general rational formulation. The following properties are valid for the rational curves [Rogers and Adams, 1990]:

for all rational base function, R_{i},_{k }_{³ }0 "t,

the sum of the rational functions is equal to 1 for all values of t

except for k = 1, each function has only one maximum value,

a kthorder rational Bspline curve (degree k  1) is C^{k}^{2} continuous,

the rational curve generally follows the form of the definition polygon,

a rational curve is located in the convex hull defined by the k vertexes of the control polygon,

any geometric transformation is applied to the control vertexes and the Bspline curve is invariant under this type of transformation.
Many geometrical entities can be obtained by manipulating the knot vector and the nondimensional parameter t. A comprehensive treatment of the rational Bspline formulation is presented in [Rogers and Adams, 1990; Farin, 1988].
Twodimensional Software Environments
The Finite Element Method (FEM) is the most used numerical technique for the solution of engineering problems. Finite element software can be used to design new projects or verify the mechanical behavior of components. It is also possible to optimize a component by defining design variables and performance criteria.
Several generalpurpose software packages are available. From the user's point of view, a strong knowledge of the problem formulation and numerical solution techniques is a very common requirement. In addition, a good experience in the use of the program is also important because sometimes the interface of commands is very complex. The user needs a solid knowledge basis for the effective application of the software to engineering problems. Such facts limit a larger dissemination of these programs. A wrong hypothesis gives results which are not related to the mechanical behavior of the component. Therefore, the program should be easy to use in such way that the engineer can spend most of the time in the definition and simulation of models for the given problem.
In general, the geometry definition and mesh generation are the most time demanding tasks in the numerical analysis of engineering problems. The current software packages integrate CAD and analysis programs. CAD tools are used for the definition of the geometry and mesh. The analysis program calculates the results. However, the resulting integration is not always robust or the user interface is very complex.
Therefore, robust and efficient algorithms for geometry and mesh generation, solution, adaptive error estimation, and mesh refinement integrated through simple command interfaces are fundamental prerequisites for finite element analysis of engineering problems.
Based on this context, the software environment SAFE was initially developed for the analysis of twodimensional elastic problems [Guimarães et al., 1994]. Figure (1) illustrates the main window and some of the modules of the program, such as the text editor for the specification of the structural and analysis parameters, mesh generator, visualization of results, and adaptive mesh refinement based on the ZienkiewiczZhu error estimator [Zienkiewicz and Zhu, 1987]
Keywords are used for the specification of the finite element attributes using two ascii data files with extensions .ara and .a2f [Guimarães et al., 1994]. The first file specifies the domain, mesh generation control parameters, and admissible error for the adaptive procedure. The .a2f file defines the material and geometric properties, element types, loads, boundary conditions, and names of nodal degrees of freedom. The mesh generation is performed by the program ARANHA [Fancello et al., 1991] using the information in the .ara file. After that, the parameters in the file .a2f are read and the file with extension .fem is generated and used by the solution module. These steps constitute the data generation part of the program.
In the analysis part, the finite element model given in the .fem file is solved and displacement and stress results are calculated. The adaptive procedure generates a new set of .ara and .a2f files. Finally, the visualization of the mesh, loads, boundary conditions, and scalar and vectorial results can be performed. Each module is an independent program and the communication among them is implemented by data files and databases.
Based on the developing experience of the SAFE program, the SAT (Structural Analysis Tools) environment was developed in which all data is specified interactively. Figure 2 shows the main window and interfaces of the software modules. The modules use a common NURBS data structure to represent geometric and graphical data as well operations and transformation (e.g., rotation, translation, zoom, fill, and others) [Galvão, 1995].
Initially, the project name is supplied which defines the database name used in the program. Some generic project arguments such as title, last modification date, author, and general observations can be included in the project file.
The GEOMETRY module is used for the interactive definition of the geometrical domain of the component. It is also possible to import DXF files. The main drawing primitives are line, arch, circle, and curves. Several editing and transformation tools are available such as copy, paste, delete, scale, rotation, translation, zoom, and trim. The main purpose of this module is to define the areas on which the finite elements will be generated. The data is recorded in a database and exported in the .ara format.
The MESH module uses the information about areas defined in the GEOMETRY module and adds mesh control parameters (e.g., element size and type) to generate the mesh using the ARANHA program [Fancello et al., 1991]. The other finite element model attributes (e.g., loads, material properties, and boundary conditions) are specified interactively by using dialog boxes. These attributes exported to the .a2f data file. The files .ara and .a2f are used to generate the .fem which is submitted to the SOLVER module. The SOLVER module calculates the results in terms of displacements and stresses for each load case.
The scalar and vectorial results can be presented numerically and graphically in the module VISUALIZATION. An animation procedure for the deformed geometry is also available. Finally, the OPTIMIZATION module performs the parameter and shape design optimization. Design variables, performance functionals, and objective function are defined interactively and the minimization problem is solved.
All programs use the ACDP library for database, error handling, data structures, and mathematical procedures [Guimarães and Feijóo, 1989]
The main features of the modules GEOMETRY, MESH, SOLVER, VISUALIZATION, and OPTIMIZATION will be presented in the following sections.
GEOMETRY Module
The GEOMETRY module supports the interactive definition of twodimensional geometries. Although much simpler, the module works like a CAD program. The boundary of the domain is drawn as a set of segments and the areas are defined by a closed loop of segments.
Drawing primitives such as lines, arcs, curves, and ellipsis are used to define the segments. Particularly, the curves can interpolate or fit a set of points or be free curves. The module also supports texts annotations on the drawing. The parameters of the primitives can be input using the mouse or dialog boxes. Many resources were implemented to simplify the definition of the geometry. The user has the option of turning on horizontal and vertical scrollbars, a drawing grid, and a toolbar which allows manipulation of drawing primitives. Figure 3 shows the dialog box to input line parameters, the scrollbars, the grid, and the toolbar.
Transformation (e.g., scale, rotation, translation), editing (e.g., zoom, cut, paste, copy, delete, undo, selection, entities numbering), drawing (e.g., divide, trim, fillet, group, ungroup) operations were also implemented.
Areas are defined by segments which are input using the mouse or a dialog box. It is possible to define domains with holes. Figure 3 shows the dialog box for area definition. Each geometric area will correspond to a different group of elements in the MESH module.
MESH Module
In the MESH module, a linear or quadratic triangular finite element mesh is generated automatically. Finite element attributes (e.g., loads, boundary conditions, and material and geometric properties) are also specified. The points, segments, and areas defined in the module GEOMETRY are loaded in this module.
The frontal mesh generator developed in [Fancello et al., 1991] generates uniform meshes by specifying an average element size. A nonuniform mesh can be also obtained by using a background grid with a different element size distribution on the nodes of the grid. Many mesh visualization resources were implemented such as node and element number detection, expanded mesh, element coloring based on element types and material properties, zoom, and others.
Figure 5 shows the dialog boxes to input material properties, loads, boundary conditions, and mesh parameters. Many other dialog boxes are available to input, edit, delete, and modify the attributes of the finite element model. The loads and boundary conditions are easily applied to geometric entities using the mouse or dialog boxes. They can also be visualized graphically.
SOLVER Module
The SOLVER module calculates the results in terms of displacements and stresses for each load case. Although the SAT environment was implemented to solve linear elastic problems, the finite element classes are not limited to linear elasticity. New problems can be easily added to the class hierarchy. For example, plasticity and fluid dynamics problems have been implemented using the class framework.
Figure 6 illustrates the organization levels of the finite element classes. No inheritance relationships are implied by this level structure. The first level implements basic data structures used extensively in the other levels. The classes manage dynamic memory allocation and implement direct and iterative procedures for the solution of systems of equations. The class Array is based on the concept of parameterized C++ classes [Bittencourt, 1998]. The second level has basic finite element classes (e.g., Material, Nodes, FiniteElement). The third level implements arrays of classes from the previous level. Finally, the fourth level contains the finite element model class FEModel with all analysis attributes, as well the derived solver classes (e.g., FELinearSolver, FENonLinearSolver, Multigrid). Therefore, the same finite element data structure can be used for different analysis types. In addition, an object of a finite element solver class has all data and methods required to manipulate and solve finite element problems.
VISUALIZATION Module
This module presents the results of the finite element analysis numerically and graphically for each load case. Analogously to the SOLVER module, this module was implemented to allow the visualization of results for different problems. For this purpose, the number and names of scalar and vector fields are recorded in the database and the user interface menus are dynamically set up based on that information.
Deformed shape, isoline, and isolayer plots are available in the VISUALIZATION module. An animation procedure was also implemented to illustrate the deformation of the original mesh. Tables of numerical results can be listed or saved in ascii files. An isolayer representation is illustrated in Fig. 2d.. Figure 7 shows graphical results for the deformed shape and the isoline distribution of the von Mises stress.
OPTIMIZATION Module
A large number of structural optimization problems can be expressed as
where f is the objective function, g_{i} and h_{i} are the constraint functionals, u is the solution of the structural state equation, and p Î is the design variable vector.
It can be observed in Eq. (5) that the functions f, g_{i} and h_{j} depend on the design variables implicitly, that is, they rely on the solution u and u º u (p). The region W where all the constraints are simultaneously satisfied is called feasible region and written as
Generally, the functionals f, g_{i}, and h_{j} are highly nonlinear and can involve a large number of design variables. However, it is required only that their first derivatives exist at every point of W to solve Eq. (5). Solving an optimization problem means to find a point p* Î W at which f has a minimum value. If p* exists, it is called an optimum design in the engineering context. This type of mathematical formulation of the design problem permits the introduction of systematic analysis and solution procedures such as the optimizationbased methods [Schmit, 1981; Vanderplaats, 1982; Arora, 1989].
An important class of optimization algorithms uses first order information of the performance functional gradients [Belegundu and Arora, 1985; Bazaraa, Sherali and Shetty, 1993]. For many important problems, the performance functionals depend on the structural problem solution and specific methods are needed for gradient evaluation. [Haftka and Grandhi, 1986; Haftka and Adelman, 1989]. The discrete and continuous design sensitivity analysis methods are commonly used [Choi and Seong, 1986; Haug, Choi and Komkov, 1986]. In the discrete case, the derivatives are evaluated from the discretized form of continuous equations. In the continuous case, sensitivity expressions are analytically obtained from the original continuous equations. These expressions are discretized and evaluated [Silva and Bittencourt, 2000].
The continuous formulation has advantages such as the determination of an analytical design sensitivity from the original equations of continuum media and independence of the structural analysis code. The sensitivity evaluation can be done as a post processing step from the usual finite element output.
Sensitivity expressions for parameter and shape optimization of linear elastic problems and an interior point minimization algorithm were implemented [Silva and Bittencourt, 1998; Silva and Bittencourt, 2000]. The OPTIMIZATION module has a graphical interface to define the design parameters and manage the structural optimization procedure. Figure 8 shows a dialog box to define the constraint functions. Results of parameter and shape optimization of twodimensional elastic problems are illustrated in Fig. 9. A procedure for topological optimization has been implemented in this module [Novotny, Fancello and de Cursi, 1998].
Extensions to 3D Problems
The previous software environments have been extended to 3D problems. Naturally, there are many difficult implementation issues such as a graphical representation, mesh generation, efficient solution methods, and adaptive procedures, and data visualization. In summary, everything is much more complex. However, the difficulties have been addressed.
The classes related to finite element analysis, numerical methods, sensitivity analysis, and optimization work with 2D and 3D problems. The ACIS library has been used to develop the 3D GEOMETRY module. This library is a set of C++ classes for solid modeling and data visualization. It has become a standard and many commercial software (e.g., Autocad and SolidEdge) have been implemented using ACIS.
Threedimensional mesh generation programs based on tetrahedral have been also implemented [Dari, 1994; V_enere, 1996]. Figure 10 shows some meshes for a fracture problem, cardiovascular hemodynamics simulation, and groundwater simulation. Figure 11 shows the visualization of the von Mises stress for the fracture problem.
The adaptive procedures have been extended to 3D problems as illustrated in Fig. 12. The solution of the system of equations for 3D problems are time consuming. It estimated that about 70% of the solution time of a nonlinear problem is spent in the solution of system of equations. Therefore, efficient numerical procedures have to be used. Nonnested multigrid methods were implemented for this purpose and the average behavior of the solution for 3D linear elastic problems is presented in Fig. 13 [Bittencourt, 1996]. It can be observed that the multigrid methods has an almost linear behavior as predicted theoretically. Finally, the sensitivity analysis classes have been extended to nonlinear problems.
Based on the current stage, the 3D software environment will be available in the near future.
Conclusions
Objectoriented programming has been used to develop reliable, efficient, and portable software modules with quality and productivity. These modules can be used as standalone programs or integrated in software environments. In this case, the communication among the modules is implemented by binary databases and ascii files.
The results obtained for the twodimension programs were quite satisfactory. In spite of dealing only with linear twodimensional elastic problems, the computational tools for geometry definition, mesh generation, solution, visualization of results, error estimation, and adaptive refinement are well integrated. The graphic interfaces allow a simple and intuitive execution of the several modules.
The preliminary implementation for 3D problems shows that it is possible to achieve similar results as for the 2D case. The basic idea is to implement robust and easy to use software tools applied to the solution of engineering problems. After the implementation of an initial software basis, the OOP features allow to increase the productivity in software development.
Acknowledgments
This work was partially supported by Conselho Nacional de Desenvolvimento Científico e Tecnológico (CNPq  Proc. 523.982/941, CNPqRHAE  Proc. 610.035/940, CNPqFINEP PRONEX 007/97), Fundação de Amparo a Pesquisa do Estado de São Paulo (FAPESP  Procs. 97/05400 and 97/111308). The authors are grateful for the software facilities provided by the TACSOM Group (http://www.lncc.br/~tacsom).
References
Adeli, H. and Yu, G. (1995), 'An integrated computing environment for solution of complex engineering problems using the objectoriented programming paradigm and a blackboard architeture', Computer & Structures 54(2), 255265. [ Links ]
Arora, J. (1989), Introduction to optimum design, Mechanical Engineering Series, McGrawHill, New York. [ Links ]
Bazaraa, M., Sherali, H. and Shetty, C. (1993), Nonlinear programming { theory and applications, 2nd edn, John Wiley & Sons, New York. [ Links ]
Belegundu, A. and Arora, J. (1985), 'A study of mathematical programming methods for structural optimization. part i: theory', International Journal for Numerical Methods in Engineering 21, 15831599. [ Links ]
Bittencourt, M. (1990), Análise estática e dinâmica por subestruturação e programação orientada por objetos, Master's thesis, Faculdade de Engenharia Mecnica, Universidade Estadual de Campinas. [ Links ]
Bittencourt, M. (1996), Métodos multigrid e iterativos adaptáveis aplicados em malhas nãoestruturadas, PhD thesis, Faculdade de Engenharia Mecânica, Universidade Estadual de Campinas. [ Links ]
Bittencourt, M. L. (1998), Using c++ templates to develop_finite element classes. Submitted for publication.
Cardona, A., Klapka, I. and Geradin, M. (1994), 'Design of a new finite element programming environment', Engineering Computations 11, 365381. [ Links ]
Choi, K. and Seong, H. (1986), 'A domain method for shape design sensitivity analysis of builtup structures', Computer Methods in Applied Mechanics and Engineering 57(1), 115. [ Links ]
Dari, E. (1994), Contribuciones a la triangulación automática de dominios tridimensionales, PhD thesis, Instituto Balseiro, Bariloche, Argentina. [ Links ]
DuboisPèlerin, Y., Zimmermann, T. and Bomme, P. (1993), 'Object oriented _finite element programming: Iii. an efficient implementation in c++', Computer Methods in Applied Mechanics and Engineering 108, 165183. [ Links ]
Fancello, E., Guimarães, A., Feijóo, R. and Venere, M. (1991), Geração automática de malhas usando programação orientada por objetos, in 'Anais do 11o. Congresso Brasileiro de Engenharia Mecânica', Sociedade Brasileira de Ciências Mecânicas, São Paulo, pp. 635638. [ Links ]
Farin, G. (1988), Curves and surfaces for computeraided geometric design, Academic Press, Orlando. [ Links ]
Feijóo, R., Guimarães, A. and Fancello, E. (1991), Algumas experiencias en la programación orientada por objetos y su aplicación en el método de los elementos finitos, Relatório de pesquisa 15/91, Laboratório de Nacional de Computação Científica, Rio de Janeiro, RJ. [ Links ]
Filho, J. and Devloo, P. (1991), 'Object oriented programming in scientific computations: the beginning of a new era', Engineering Computations 8, 818. [ Links ]
Forde, B., Foschi, R. and Stiemer, S. (1990), 'Objectoriented finite element analysis', Computer & Structures 34, 355374. [ Links ]
Galvão, M. (1995), Um ambiente baseado em nurbs para a definição de domínios aplicados à geração de malhas, Relatório técnico, Departamento de Projeto Mecânico, Faculdade de Engenharia Mecânica, Universidade Estadual de Campinas. [ Links ]
Guimarães, A., Fancello, E., Feijóo, G. and Feijòo, R. (1994), SAFE  sistema integrado para análise estrutural por elementos finitosversão 1.0, Technical report, Laboratório de Nacional de Computação Científica, Rio de Janeiro, RJ. [ Links ]
Guimarães, A. and Feijóo, R. (1989), O sistema ACDP, Research report 27/89, Laboratório de Nacional de Computação Científica, Rio de Janeiro, RJ. [ Links ]
Haftka, R. and Adelman, H. (1989), 'Recent developments in structural sensitivity analysis', Structural Optimization 1(3), 137151. [ Links ]
Haftka, R. and Grandhi, R. (1986), 'Structural shape optimization  a survey', Computer Methods in Applied Mechanics and Engineering 57(1), 91106. [ Links ]
Haug, E., Choi, K. and Komkov, V. (1986), Design sensitivity analysis of structural systems, Vol. 177 of Mathematics in Science and Engineering, Academic Press, Orlando. [ Links ]
Menétrey, P. and Zimmermann, T. (1993), 'Objectoriented nonlinear finite element analysis: application to j2 plasticity', Computer & Structures 49(5), 767777. [ Links ]
Miller, G. (1991), 'An objectoriented approach to structural analysis and design', Computer & Structures 40, 7582. [ Links ]
Novotny, A., Fancello, E. and de Cursi, J. S. (1998), 'An hadaptive topological optimization design in 2D elasticity', pp. 120. [ Links ]
Oñate, E., Idelsohn, I. and E. Dvorkin, e. (1998), in 'Computational mechanics new trends and applications', CIMNE, Barcelona. [ Links ]
Rogers, D. and Adams, J. (1990), Mathematical elements for computer graphics, McGrawHill. Schmit, A. (1981), 'Structural synthesis. its genesis and development', AIAA Journal 19(10), 12491263. [ Links ]
Scholz, S. (1992), 'Elements of an objectoriented fem++ program in C++', Computer & Struc tures 43(3), 517529. [ Links ]
Silva, C. and Bittencourt, M. (1998), An interactive objectoriented tool for structural optimiza tion, in 'IV World Conference on Computational Mechanics', Buenos Aires. [ Links ]
Silva, C. and Bittencourt, M. (2000), An objectoriented structural optimization program. Accepted for publication.
Tworzydlo, W. and Oden, J. (1993), 'Towards an automated environment in computational mechanics', Computer Methods in Applied Mechanics and Engineering 104, 87143. [ Links ]
Tworzydlo, W. and Oden, J. (1995), 'Knowledgebased methods and smart algorithms in computational mechanics', Engineering Fracture Mechanics 50(5), 759800. [ Links ]
Vanderplaats, G. (1982), 'Structural optimization  past, present and future', AIAA Journal 20(7), 9921000. [ Links ]
Vénere, M. (1996), Técnicas adaptativas para el método de elementos finitos en dos y tres dimensiones, PhD thesis, Instituto Balseiro, Bariloche, Argentina. [ Links ]
Yu, G. and Adeli, H. (1993), 'Objectoriented _nite element analysis using EER model', Journal of Structural Engineering 119(9), 27632781. [ Links ]
Zeglinski, G., Han, R. and Aitchison, P. (1994), 'Object oriented matrix classes for use in a finite element code using C++.', International Journal for Numerical Methods in Engineering 37, 39213937. [ Links ]
Zienkiewicz, O. and Zhu, J. (1987), 'A simple error estimator and adaptative procedure for practical engineering analysis', International Journal for Numerical Methods in Engineering 24, 337357. [ Links ]
Zimmermann, T., DuboisPélerin, Y. and Bomme, P. (1992), 'Objectoriented finite element programming: I. govening principles', Computer Methods in Applied Mechanics and Engineering 98, 291303. [ Links ]
Article received: January, 2000. Technical Editor: Atila P. Silva Freire