An object-oriented architecture for extensible structural design software

Computers and Structures 100-101 (2012) 1–17

Contents lists available at SciVerse ScienceDirect

Computers and Structures journal homepage: www.elsevier.com/locate/compstruc

An object-oriented architecture for extensible structural design software Rory Clune a,⇑, Jerome J. Connor a, John A. Ochsendorf a, Denis Kelliher b a b

Massachusetts Institute of Technology, Department of Civil and Environmental Engineering, Cambridge, MA 02139, USA University College Cork, Department of Civil and Environmental Engineering, Cork, Ireland

a r t i c l e

i n f o

Article history: Received 11 July 2011 Accepted 13 February 2012 Available online 12 March 2012 Keywords: Structural design Design-analysis integration Interactive optimization Software architecture Object-oriented programming

a b s t r a c t This paper presents an object-oriented architecture for structural design software. The architecture’s novel features are the representation of an artifact with distinct levels of idealization, a hierarchy of classification within each of these levels, and the appropriate separation of software components. These enable seamless integration of geometric modeling and structural analysis in an interactive environment, extensibility of modeling and analysis capabilities, and integration of interactive multi-objective optimization. The paper presents a design environment implemented on the basis of the architecture, and demonstrates the benefits of refocusing engineering software from analysis to design. Ó 2012 Elsevier Ltd. All rights reserved.

1. Introduction In the field of structural engineering, there is a notable lack of software with a strong design sensibility. In practice, computer programs which were primarily intended to perform structural analyses are used as design software, and a sequential, iterative approach is used in the design process. Following this approach, an initial form is defined, typically by an architect, and an engineer conceptualizes potential structural systems on the basis of intuition and past experience. The engineer then models and analyzes these systems using structural analysis software, and assesses the results in order to evaluate and modify the design. After design modification, the analysis is explicitly run again, and the iterative process continues until an acceptable solution is reached. The design process using these commercially available tools, which are the prevalent norm in structural engineering practices today, is fundamentally the same as it was when computational mechanics first impacted structural engineering fifty years ago. Two examples of analysis software packages widely used in practice are ABAQUSÒ [1] and SAP2000Ò [2]. These programs run in batch mode, where the computer executes a series of sequential operations without any manual intervention. Though unquestionably useful for simulating and evaluating a finalized design, such tools do virtually nothing to encourage the pursuit of better design, and often restrict design exploration by making it tedious and time consuming to significantly change and reanalyze a structural

system. By contrast, the geometric modeling tools typically used by architects, such as RhinocerosÒ [3] and GenerativeComponentsÒ [4], encourage creativity and exploration of the design space, but don’t do enough to encourage rationality, structural or otherwise, of the resulting designs. Often, design modifications are made in geometric modeling programs and files are copied to the analysis software to evaluate design performance. In an industry where designers have limited time to work on a given problem, this cumbersome approach limits the extent to which they can explore the range of possible designs in pursuit of better solutions and better understanding of the problem at hand. Furthermore, although analysis software provides feedback such as deflections or internal stresses, it does not propose structural forms to be analyzed. In response, the field of structural optimization has seen some limited application in design. Among others, the work of Shea et al. [5] and Von Buelow [6] has made notable progress towards using optimization as a source of design creativity. The use of structural optimization in design, however, has been restricted for a number of reasons. Among them are the perceived inflexibility of existing optimization tools and an implicit lack of recognition that structural engineering design problems are always multi-objective, and almost always involve subjective goals such as aesthetics and constructability which are inherently difficult to express mathematically. 1.1. Desirable features of design software

⇑ Corresponding author. Address: 77 Massachusetts Avenue, Room 5-332A, Cambridge, MA 02139, USA. Tel.: +1 617 470 6939. E-mail address: [email protected] (R. Clune). 0045-7949/$ - see front matter Ó 2012 Elsevier Ltd. All rights reserved. doi:10.1016/j.compstruc.2012.02.002

In order to achieve a strong engineering design sensibility, software should combine the strengths of geometric modelers and analysis software, allowing creativity to flourish while

2

R. Clune et al. / Computers and Structures 100-101 (2012) 1–17

maintaining a strong focus on engineering rationality as both a constraint and a goal. Integration of these mostly disparate types of programs is therefore desirable. This integration has previously been sought through the development and promotion of interoperability standards and common data models [7] or through more fundamental integration of programs, which typically occurs when a smaller software company and its products are bought by a larger company [8,9]. A number of software architectures have been proposed to address integration [10]. Despite these efforts, the lack of software integration and interoperability remains a major obstacle to a more efficient workflow in engineering offices and to the development of design-centric structural engineering programs. We envisage an architecture for engineering design software which will allow for the seamless integration of analysis and modeling software. Rather than seeking to integrate existing packages, as has been the goal of much research in this area, this work addresses the question of how engineering software should be developed in the future to enable seamless integration. As part of an effort to create software with a stronger design sensibility, there has been significant interest in developing ‘live’ or ‘real-time’ structural analysis applications in which user interaction, visualization and computation appear to occur simultaneously. Examples include the Dr. Software [11] range of products, Arcade [12] and Active Statics [13]. This type of software environment, in which analysis capabilities are seamlessly integrated, allows the user to develop an intuition for the effects that design modifications have on structural performance. Although such currently available programs represent a move towards better design software, each has its limitations, ranging from a lack of real-world applicability to various constraints on the freedom of exploration and an inability to propose structural forms. In order to gain real traction in the design industry, this goal should be pursued in a way that will allow other analysis and modeling methods to integrate to a system after the initial connections and channels of communication between software components have been established. A program developed under such an architecture becomes an extensible framework whose default functionality can easily be added to. In addition to real-time analysis capabilities, this work sees the inclusion of optimization methods as important to the development of an interactive design environment. Most existing structural optimization applications typically seek to deliver a single optimal solution to the user, rather than harness the power of optimization as a tool for exploration of design alternatives. The fact that real-world design problems are almost always multi-objective [14] and, especially in the case of the design of civil structures, illdefined [15] motivates the use of multi-objective techniques and an exploration of ways in which designers can be given control over the pursuit of ill-defined objectives. We explore the use of optimization as a guide to design exploration, seamlessly embedded in a flexible design environment implemented on the basis of the developed software architecture.

The logical organization of a well-designed object-oriented code, and the benefits of the reusability of such code, make the object oriented approach valid for the architecture of an extensible software framework. C# is the language chosen for this work, and the majority of the architectural concepts are presented in Unified Modeling Language (UML) diagrams [17]. A full discussion of the fundamental OOP concepts used in this work, which include inheritance, polymorphism, interface implementation, and event publishing and subscription, can be found in Booch et al. [18]. Since the 1990’s, much of the published work in the field has focused on extending the architecture of existing Finite Element Method (FEM) programs for use in design, as reviewed in Mackie [19]. As FEM is the dominant analysis method used in modern structural software, this is unsurprising. Heng and Mackie [20] thoroughly review useful software design patterns from the literature. In order to be applicable to the type of design software of interest to this work, however, the object-oriented approach to structural mechanics needs to become more than just an extension or a reworking of existing FEM analysis software which does not enable significant new functionality for conceptual design. This paper does not provide a comprehensive review of the field of structural software architecture; the previously mentioned reviews serve that purpose well in the context of FEM software for structural engineering. In addition, Mocko et al. [10] provide a thorough review of research towards integration of design and analysis components, examining a broad range of proposed software architectures. The features that address integration of analysis and design components serve as precedents. The more recent approach of Delalondre et al. [21] to formalizing the relationships between multiple models of a given artifact at various fidelities and scales is also noteworthy. The work of Daubi and Dagli [22] on extensible software architectures is also of interest, though the focus is somewhat different than that of this work. 1.3. Structure of paper Section 2 motivates and describes the principal features of the developed software architecture which enable integration of modeling and analysis components, generation of real-time analysis results, and extensibility of software developed using the architecture. Section 3 describes the implementation of a design tool based on the architecture, proving the feasibility of the presented concepts. It describes two case studies of design problems that illustrate the software’s advantages compared to currently available engineering software. Section 4 describes the extension of the architecture and the developed design environment to include interactive optimization, and presents a case study that uses optimization as part of the solution to a truss design problem. Finally, Section 5 summarizes the main contributions of the work and draws conclusions. 2. Proposed software architecture

1.2. Important software architecture precedents With the emergence in the early 1990’s of Object-Oriented Programming (OOP) as a widely accepted approach for software development, a number of researchers described the benefits of rethinking the conventional approach to the architecture of structural analysis software. Notably, Miller [16], reflecting on several years of research on the topic, envisaged a ‘‘comprehensive redevelopment of structural engineering software’’ which would take advantage of existing and emerging features of OOP to develop ‘‘unified software tools applicable at all stages of the creation of a structure’’. This comprehensive redevelopment has yet to occur in a way that has had a meaningful impact on design in practice.

This section presents the features of the proposed software architecture that enable seamless integration of modeling and analysis components, real-time response generation, and extensibility. The novel features of the architecture that enable this functionality are the establishment and clear separation of three abstract levels of representation of structures and the particular hierarchy within each level of representation, which groups common functionality and communication between components at a base class level. The section presents the details of these architectural features, their novelty compared to previous work, and the functionality they enable, which is further explored and demonstrated in Section 3.

R. Clune et al. / Computers and Structures 100-101 (2012) 1–17

2.1. Seamless integration of modeling and analysis components The proposed architecture addresses the challenge of integrating modeling and analysis capabilities through its unique structure, which combines varying abstractness of representation with hierarchies which group common functionality and communication between levels of abstraction at a base class level. This varying abstraction of representation is a reflection of the fact that good design software must integrate independent modeling and analysis capabilities, and that the level of representation required for geometric modeling is less abstract than that required for performing structural analysis. Clearly structuring the architecture to reflect this reality is the first step towards facilitating integration. Fig. 1 shows the increase in abstraction, first pictorially, and then on a UML diagram. The first and least abstract of the three levels of representation is the Artifact class, containing information relating to the physical makeup of the structure, such as dimensions, materials and connection details. Eventually, a fully developed Artifact class should contain enough information to enable physical realization of the structure. The next level of representation of an artifact, Structural Model classes, contains an idealized model, or abstraction, of a real artifact. The Structural Model abstracts the Artifact class as an aggregation of understood and analyzable components, such as beams, plates, and supports. Many different types of Structural Model can be used to abstractly represent an artifact. A discrete tessellated structural artifact could, for example, be modeled either as a pinjointed truss or as a rigid-jointed frame. The most abstract types of representation considered, Mathematical Model classes, contain the mathematical methods required to analyze Structural Models, and are treated in the architecture as mathematical abstractions of Structural Models. They consist of the mathematical formulations (equations, matrices, etc.) that describe a Structural Model, and the methods to manipulate and solve these formulations in order to predict the artifact’s behavior. A number of Mathematical Models can analyze a single Structural Model, and a single type of Mathematical Model could potentially be used to analyze multiple Structural Models. The second key feature of the architecture which allows the integration of analysis and modeling capabilities is the use of a

3

hierarchy of inheritance within each level of abstraction. Artifact, Structural Model, and Mathematical Model are abstract base classes, and contain all attributes and methods common to their types. The functionality specific to actual models is contained in derived classes which inherit common functionality from base classes. The power of this approach is that communication and integration between the Artifact, Structural Model, and Mathematical Model classes can be established at the base level. In order to seamlessly integrate with the rest of the software, a particular derived class need only establish a connection to the relevant base class. This architecture accomplishes this using inheritance and by forcing derived classes to implement interfaces. Fig. 2 shows the essence of this approach to the design of structural software. Particular types of Structural Model and Mathematical Model classes are connected at a base class level in the hierarchy, and functionality and attributes specific to a particular modeling type exists at the derived class level. By contrast, the conventional approach to software integration shown in Fig. 3 groups functionality and attributes of a particular abstraction level in a single class, and makes direct connections between modeling and analysis components without the establishment of a strict hierarchy. In reality, there are several layers of abstract base classes in the hierarchy of the architecture; Fig. 2 presents a simplified representation. For example, Fig. 4 shows a slice through the hierarchy of Mathematical Models, with interfaces defined for the abstract base classes at all levels in the hierarchy. To elucidate the points of key importance to component integration, some of the less relevant members of classes have been omitted from this figure. By convention, the names of interfaces begin with the letter ‘i’ in order to distinguish them from classes. All classes other than the derived class (DirectStiffnessMethod2D in this case) are abstract, and interfaces are defined for each of the intermediate abstract classes. A derived class inherits the functionality of all its base classes, and is compelled to implement all of the interfaces associated with these base classes in order to conform to the architecture. Methods which must be implemented by derived classes are defined in the relevant base class as abstract, which mandates derived classes to provide an implementation. The derived class, DirectStiffnessMethod2D, is thus forced to provide definitions for methods and attributes that the other compo-

Fig. 1. Abstraction of the representation of the actual artifact increases from an Artifact class to a Mathematical Model class.

4

R. Clune et al. / Computers and Structures 100-101 (2012) 1–17

Fig. 2. A high-level UML classification of the proposed architectural approach, based on abstraction and inheritance.

Fig. 3. In contrast to Fig. 2, the conventional architectural approach contains all functionality and attributes in a single class, making direct connections without establishing a strict hierarchy.

Fig. 4. Inheritance and interface implementation at each hierarchical level within the Mathematical Model representation.

R. Clune et al. / Computers and Structures 100-101 (2012) 1–17

nents of the software expect it to provide. For example, when a Structural Model calls the Analyze() method of its Mathematical Model, the fact that all Mathematical Models implement the iMathematicalModel interface, which requires a definition of the Analyze() method, provides an implicit guarantee that this Analyze() method exists. This is the strategy by which the low-level modeling and analysis components of the software seamlessly integrate to the high-level framework of the architecture. The proposed approach allows for multiple Structural Model and Mathematical Model representations of a given artifact, and lays the framework for future extensions beyond the realm of structural design. In the same way that Structural Models abstractly represent an Artifact, model types specific to different engineering disciplines could provide different abstract representations of the same Artifact. These features of the architecture draw inspiration from the software design pattern of Model-Analysis Separation identified in Heng and Mackie [20], but the introduction of the Artifact layer of idealization and the particular structure of the hierarchy expands the software beyond the FEM programs of that research. Although the architectural approaches summarized in Mocko et al. [10] are somewhat similar, a significant difference is that the proposed architecture, rather than integrating existing packages via data transfer, requires all components to be implemented as derived classes of an appropriate Structural Model or Mathematical Model base, or to expose an API to such a derived class. 2.2. Real-time response generation and performance measurement The proposed software architecture enables the responsive simulation of a structure in a real-time design environment, where structural analyses can be run and results visualized automatically in response to design changes. The structural analysis packages typically found in design offices require an intermediate step, where the designer issues an explicit command to run an analysis after modifying a structural model. The architecture dramatically alters the way in which designers interact with software. It allows them to generate and analyze far more design alternatives in a given period of time than they could do with existing analysis software, and allows them to gain a more intuitive understanding of structural behavior and the effect of design changes. The seamless integration of modeling and analysis components enables this automatic generation of analysis results from which performance measures can then be extracted. This enables responsive simulation of a structure in a real-time simulation environment, and is naturally managed using events and event handling in OOP. The event-related features of the C# language make it a natural one to develop a program which can provide real-time feedback to users. Functionality is provided at the base class level to publish an event when a model’s data is modified. An Environment object, which contains all code related to the user interface of the software, subscribes to the events published by the Structural Model, and renders the model after modification. The Structural Model class also provides an event handler for these events, which calls an analysis by all associated Mathematical Models. The updated analysis results are then available to the environment to display. Fig. 5, a UML classification diagram describing an implementation of the architecture presented in Section 3, shows these features. The Performance class is introduced to serve as an aggregator of performance measures which are evaluated by implemented modeling and analysis components. As shown in Fig. 5, the Performance class can then be accessed by the environment, via the Artifact class, and used as a convenient access point to the available performance measures for the design. The optimization components of the software, described in Section 4, also make use of the Perfor-

5

mance class. In future work, the Performance class will be extended to enable it to interrogate Structural Models and Mathematical Models to automatically extract their available performance measures, and to enable individual designers to create custom Performance objects consisting of parameters of interest. The design-centric functionality enabled by these architectural features and the benefits they offer designers compared to conventional analysis software are demonstrated and discussed in the case studies of Sections 3.2 and 3.3. 2.3. Extensibility A key feature that the proposed architecture brings to structural design software is the possibility of extending software after its initial development, by adding new modeling and analysis capabilities in the form of Structural Model and Mathematical Model classes. Extensible software developed using the architecture allows new analysis or modeling software developed to the specifications of the architecture to seamlessly integrate with existing components. Such software becomes a framework, whose default behavior can be overridden or extended. This is a strategy for addressing the problem of achieving software interoperability and integration in the engineering world. A general feature of the architecture, which enables this extensibility, is component separation. A strict separation is maintained between the user interface components of the software and the modeling and analysis components. In the particular implementation of the architecture developed as part of this work, shown in Fig. 5, the Environment class contains all the code necessary for manipulating and rendering models. The Artifact is an attribute of the Environment object, and the Structural Model and Mathematical Model classes are accessed by the Environment via this reference to the Artifact. This is essentially the Model-UI Separation pattern identified in Heng and Mackie [20], and it provides the benefits of flexibility and reduced complexity identified in that work. More importantly, because of the separation of the levels of abstraction, a developer can write a particular type of modeling class which implements the relevant interfaces specified by the architecture and inherits the functionality and attributes of the abstract base classes. In extending the architecture to include new mathematical or structural modeling methods, developers decide which base class represents the most appropriate category for their intended model class. They develop a class with new modeling or analysis capabilities, and the use of existing attributes and provision of certain methods in implementing the interfaces ensures the new class seamlessly integrates with the rest of the software to extend its functionality. For example, a new Mathematical Model class with analysis capabilities not present in the original software could be added with minimal effort and be used in the real-time simulation environment alongside pre-existing Structural Model and Artifact classes. This draws inspiration from the approach to extensibility of Dauby and Dagli [22], though the focus is somewhat different. The proposed architecture addresses a narrower range of vertical extensibility, working entirely within the domain of engineering models. This domain-specificity makes it practical to define a set of high-level base classes from which all future extensions can derive. Unlike Delalondre et al.’s [21] important work on integrating multiple analysis and modeling methods, the approach of this architecture requires the user to conform to a predefined data structure by inheriting attributes and implementing interfaces rather than using existing programs with data translators between their native data structures. Although this general inability to directly integrate existing software with predefined data structures limits immediate applicability to industry, the approach funda-

6

R. Clune et al. / Computers and Structures 100-101 (2012) 1–17

Fig. 5. A UML classification diagram of the implemented design software, exhibiting all the architectural features described in Sections 2 and 4.

mentally redefines the underlying architecture of structural software in order to better meet the requirements of the design process. It has powerful implications for the architecture’s potential to serve as a model for future design-centric extensible software. 3. Prototype design software and case studies 3.1. Implementation of prototype design software To demonstrate the validity of the developed concepts, an interactive design environment for structures is implemented based on the proposed software architecture. Although basic, it provides all the functionality described previously for the specific case of twodimensional truss structures. It is highly useful for developing structural intuition and bringing physical considerations to the initial design stages, and further encourages an exploration of design spaces. It is a fully functional teaching tool for structural design, useful for practicing designers to explore how simple structures perform, and a powerful demonstration of the merits of this new approach to structural design. The design tool contains a single derived-level Structural Model class, Truss2D, which models structures as two-dimensional trusses with pin-jointed connections. A number of layers exist be-

tween Structural Model and Truss2D in the hierarchy, as can be seen in Fig. 5. A single class derived from StiffnessMethodMathematicalModel, named DirectStiffnessMethod2D, is included. The standard Direct Stiffness Method [23] performs a linear analysis of the discrete structural model. Nodal displacements, internal member forces, and support reactions are calculated by the DirectStiffnessMethod2D object and returned to the Truss2D object. The structure’s volume is determined as the sum of the cross sectional areas multiplied by the lengths of each member, and multiplied a material density to evaluate mass. Compliance is calculated as an overall indication of the structure’s deformation under a given load case. Before running an analysis, stability of the structure is evaluated by testing for singularity of the stiffness matrix in the DirectStiffnessMethod2D class. In the case of statically determinate structures, where the axial force distribution does not depend on the axial stiffness of the members, the required cross-sectional area of a member is set by the Truss2D class so that the axial stress in the member equals its material’s yield stress. For statically indeterminate structures, a simple heuristic algorithm iteratively modifies the cross-sections of the members and re-runs analyses until each member’s cross-sectional area converges subject to the magnitude of all axial stresses being less than or equal to a specified material yield stress.

R. Clune et al. / Computers and Structures 100-101 (2012) 1–17

The Truss2D model implements a cost model which calculates the cost of the truss structure as given in Eq (1).

C ¼ cm V þ

n X i¼1

cc þ

mj X

! cF F i;j

ð1Þ

j¼1

where C = cost of the truss, cm = cost of material per unit volume, V = volume of material, n = number of connection nodes, cc = basic cost of a connection, mi = number of members connected to node i, cF = cost of transferring a unit of axial load from a member to a connection, Fi,j = axial force in the jth member connected to node i. It should be noted that the cost model generates a somewhat simplistic estimate of connection costs by summing the absolute values of member forces in all members that meet at a connection and multiplying this by cF. The ease of application of this approach to any connection situation that may arise in truss modeling, however, makes it an appropriate estimation of connection cost to use in the early stages of design. A simple bespoke modeling environment is developed in a Windows Form using built-in Microsoft .NET graphics primitives. This environment instantiates an Artifact object through which the Structural and Mathematical Models can be accessed. The environment provides event handlers which render models in response to events raised by a Structural Model object, as described in Section 2.2. 3.2. Case study: Simulation and alternative design of Waterloo International Terminal roof The developed program can import image files to serve as a convenient background for the structural engineer, guiding the manual generation of structural models. This functionality allows engineers to rapidly build a model on top of an architect’s imported sketch as a means to quickly establish how a design performs, without requiring the development of a detailed model. The software can also be used to easily develop a first-order understanding of the structural behavior of an existing artifact, simply by importing a photograph of the artifact and quickly building a model using the image as a background guide. An image of Waterloo International Terminal in London is imported, as shown in Fig. 6, and the designer begins tracing the outline of the primary structural elements. The structure is loaded under self weight, and a point load at each of the nodes along

7

the approximately parabolic line of the roof represent additional gravity loads other than those due to the primary members. The environment detects the instability of the truss structure at this early stage, but still estimates its cost. The designer quickly generates a two-dimensional truss representation of the roof (Fig. 7), showing the structural action and giving a first-order model of the roof’s behavior. The roof is loaded with self weight (green arrows) and with a point load at each of the nodes along the line of the arch (black arrows). Once stability is achieved, analysis results are displayed. Members colored red are in compression, and those colored blue are in tension. The cross-sectional thickness of the members is proportional to the magnitude of the axial force they carry, and displacements can be amplified to give designers an intuitive feel for structural action. The green meters in the bottom right of the interface display the values of mass, compliance and cost. Any design modifications to the structure cause analyses to run and results to be updated in real time. Having developed an intuition of how the structure behaves, the user can begin to explore design alternatives. Fig. 8 shows such a modification taking place. Analyses are continually run, and results and performance measures are automatically rendered in real time. The use of an appropriate background images aids in understanding the context of the structure during this fluid process of exploration. The user moves the structure towards somewhat of an inversion of the original concept, arrived at in Fig. 9. The original curve between the two supports is maintained, but the rest of the structure moves either above or below this curve, in opposition to its previous location. The resulting alternative design significantly outperforms the initial one on the available performance measures. The mass of the structure is reduced by 54%, and its compliance and cost are also reduced, by 81% and 40%, respectively. The resulting design is lighter, stiffer, and cheaper than the original. This example is illustrative of the freedom the software gives to the designer to explore alternatives, and of the design improvements that can result from allowing designers to explore freely. This is a dramatic improvement on the constraints that conventional structural analysis software imposes on designers. Although the design alternatives presented here could certainly be explored using available tools, the nature of designers’ interaction with the software, enabled by the proposed architecture, makes it far more likely that they will explore a rich variety of alternatives.

Fig. 6. An imported image of Waterloo International Train Terminal guides manual generation of designs.

8

R. Clune et al. / Computers and Structures 100-101 (2012) 1–17

Fig. 7. A two-dimensional truss model of the existing three-hinge arch structure is easily developed.

Fig. 8. Modification of a truss model by the designer in the fluid interactive environment, with real-time update of analysis results and performance parameters.

Fig. 9. The resulting alternative (user-generated) design – an inversion of the original three-hinged arch concept.

R. Clune et al. / Computers and Structures 100-101 (2012) 1–17

9

3.3. Case study: Truss design problem

3.4. Case study: Extensibility of software

The previous case study showed the software being used to quickly develop a model of an existing structure and explore alternative designs. Next, the software is used to explore solutions to the design problem shown in Fig. 10. The five point loads must be carried by a truss structure to the two green pin supports on the right. The position of the supports and the lateral distance of each load from the supports remain constant, but the vertical coordinates of the point loads can vary. Once stability is achieved by the Warren truss shown in Fig. 11, analysis results are displayed. All fourteen designs shown in Fig. 12, and the initial design shown in Fig. 11, were generated by a designer in less than five minutes total. At first, the designer maintains the parallel top and bottom chords of the truss, and varies the configuration and topology of the web members. The lightest of these parallel-chord designs is the modified K-truss (Fig. 12(c)). The conventional K truss (Fig. 12(d)) is the stiffest, and the through Warren truss (Fig. 12(a)) is the cheapest under the assumed cost model. The designer varies the shape of the top and bottom chords while maintaining the Pratt truss arrangement of the web members, and then varies the web members. These designs (Fig. 12(f)–(h)) generally perform no better than the parallel-chord designs, although they may be considered more aesthetically pleasing. The design moves towards a likeness of the well-known Michell truss. A very close approximation of the theoretical Michell truss is shown in Fig. 12(l). It is the lightest of all the designs, and by far the stiffest. Due to the large number of connections present, however, it is substantially more expensive than all the other designs. The ability to track multiple performance parameters in real time enables designers to account for and understand the complex tradeoffs and interactions between often conflicting goals in a real-world design exercise. Finally, a modification of the near-Michell truss leads the designer to a cantilevering cable-stayed bridge, a relatively cheap, although heavy and flexible, design (Fig. 12(n)). A comparison of the performance measure of the generated designs is provided in Table 1. This example illustrates the unprecedented freedom that a designer has to explore the design space in an intuitive way. A broad range of very different structural forms are easily generated in a short space of time, showing the software’s potential to encourage broad yet rational exploration at the conceptual stages of structural design.

As a test of the extensibility of the developed software discussed in Section 2.3, the prototype design environment is compiled to a dynamic-link library (DLL) and given to the fourth author of this paper, who played no direct role in the prototype software’s implementation and who did not have access to its source code. To enable this, several methods in the Artifact class are publicly exposed, which allow a developer to add additional modeling and analysis functionality to the pre-existing components. These methods accept Structural Model or Mathematical Model objects as arguments, and perform the necessary steps to integrate them to the environment. In this case, a new Mathematical Model class is written and connected, via the abstract base classes, to the Truss2D class. The object instantiated from this new class calculates natural frequencies and mode shapes of a truss, a significant extension to the original functionality, and displays the results in the environment. The stiffness matrix stored in the DirectStiffnessMethod2D class can be accessed by the new class via Truss2D and be used to perform an eigenvalue calculation. The mode shapes are represented as nodal displacements in the environment, and access to a text box is provided to display the modal frequencies. As with the originally present functionality, responses from the analysis run in the NaturalFrequency2D class are generated and displayed in real time. The DirectStiffnessMethod2D class is used, as before, to perform a linear static analysis and determine the mass, compliance, and cost of the structure. Fig. 13 shows a UML representation of the classes used in this extension. As the figure shows, the current implementation of the software requires new classes derived from Mathematical Models to implement only the iMathematicalModel interface (i.e. to provide definitions for Analyze() and Detect Stability() methods) in order to conform to the architecture, even if the abstract base class which the new class inherits sits at a lower level in the hierarchy than the Mathematical Model class. Although this is sufficient to demonstrate the applicability and merits of the approach, future implementations will make more specific demands of new classes depending on the level of the hierarchy from which the classes inherit. Fig. 14 shows a design for a cable-stayed bridge generated using the software’s original functionality. The extension is then implemented, and the Analyze() method of both the original and the new Mathematical Models are called in sequence. The designer

Fig. 10. A design problem to be solved in the environment.

10

R. Clune et al. / Computers and Structures 100-101 (2012) 1–17

Fig. 11. A stable cantilever structure, in the form of a Warren truss.

now has the modal frequencies and mode shapes of the bridge available in the real-time simulation environment. Modifications to the design reveal that changes in the backstay angle of the bridge have the most significant impact on the fundamental modal frequency of the structure. Fig. 15 shows a change of the backstay angle which caused a dramatic drop in the fundamental frequency, from 14.9 Hz (a) to 4.3 Hz (b). The first mode shape of the structure is shown in each case, with the dashed lines showing the undeformed geometry. Although a somewhat basic first step, this exercise demonstrates the ease with which software developed using this architecture can be extended, making it an extensible framework whose default functionality can be added to after development. The addition of natural frequencies and mode shapes increases the richness of the design environment, encouraging the designer to consider a broader range of performance measures at the earliest stages of conceptual design. 4. Extension to include interactive optimization A tool that allows designers to conveniently experiment with modifying and applying an optimization problem would encourage creativity in structural design, and would better enable those with little optimization training to understand the significance and effects of varying optimization problem statements. Recognizing the difficulty inherent in transferring the often ill-defined notions of what exactly constitutes a good design to a precise problem statement, the proposed software architecture is extended to integrate optimization algorithms in the interactive design environment. This enables the development of interactive optimization software, where optimization is seen as a flexible tool that can be called upon as part of a fluid design process rather than the standalone automated solution to a design problem typically pursued in the optimization literature. This allows the designer to exert an appropriate amount of control over the design process, accounting for aspects of the design problem that cannot be adequately modeled in the mathematical optimization problem statement. It should be emphasized from the outset that none of the mathematical optimization theory or optimization algorithms presented in this section are themselves novel. Nor is the optimization problem solved in Section 4.3’s case study, or any of the truss designs obtained, novel. What is instead novel about this work is the way in which the designer interacts with the optimization program, and the architectural features that enable this. The benefits of this type of interaction will be identified in reflecting on the case study.

4.1. Extension of software architecture The underlying approach to the extension of the developed architecture treats the optimization algorithm as a user of the system, just like the human designer. The algorithm, via an Optimization Object, modifies the Structural Model, which triggers an automatic analysis by the Mathematical Model via the events described in Section 2.2. The performance parameters of potential interest in structural optimization have already been logically aggregated in the Performance object described in Section 2.2, and these are used to form the objective function. The Optimization Object can also directly access the analysis results produced by the Mathematical Model, should the parameters provided in the Performance object prove insufficient. Fig. 16 shows the classes from which these objects are instantiated in a section of the overall UML classification diagram of the architecture. The Optimization Object serves as a convenient link between an algorithm and the analysis, modeling and visualization components of the software, facilitating the future extension of the software to include new algorithms by making them easily replaceable discrete parts of the software. The overall architecture, extended to include optimization capabilities, is shown in Fig. 17. 4.2. Extension of software prototype A sequential quadratic programming algorithm [24] is connected to the other components of the software via the Optimization Object. The algorithm is part of the IMSL C# Numerical Library [25]. In the current implementation, the algorithm is used to optimize the geometry of the Truss2D model. The two-dimensional nodal coordinates and the cross-sectional area of each truss member are the design variables, and they form the design vector x. The available performance metrics – mass, compliance and cost – are the potential objective functions fi(x) for optimization. The weighting method of multi-objective optimization [15] is used to combine multiple objectives into one. Relative weights wi are assigned to each of the i objective functions to form an overall objective function given by Eq. (2).

min x

k X

wi fi ðXÞ

ð2Þ

i¼1

The optimization problem is constrained by setting upper and lower bounds on each design variable resulting in the problem statement of Eq. (3).

R. Clune et al. / Computers and Structures 100-101 (2012) 1–17

11

Fig. 12. Fourteen designs manually generated in less than five minutes by a designer using the interactive environment.

min

k X

wi fi ðXÞ

i¼1

subject to xlb  x  xub

ð3Þ

where xlb and xub are vectors of lower and upper bounds on the design variables. The user is given control in the graphical user interface (GUI) over the relative weighting of each of the components. Fig. 18

12

R. Clune et al. / Computers and Structures 100-101 (2012) 1–17

Table 1 Performance measures of user-generated designs.

Fig. Fig. Fig. Fig. Fig. Fig. Fig. Fig. Fig. Fig. Fig. Fig. Fig. Fig. Fig. *

11 12(a) 12(b) 12(c) 12(d) 12(e) 12(f) 12(g) 12(h) 12(i) 12(j) 12(k) 12(l) 12(m) 12(n)

Mass (kg)

Compliance (N mm)

Cost ($)

135 119 119 114 120 137 139 148 156 148 130 131 108⁄ 137 158

2160 1810 1810 1560 1470 2290 2490 3100 2670 2260 1720 1830 780⁄ 1360 2860

6040 5380⁄ 6180 6040 6200 5900 5950 6240 6480 6250 5700 5740 8250 6010 5750

indicates lowest (best) value attained.

shows a series of track bars in the GUI which are used to modify the relative weighting of components of the objective function.

Design variables can be constrained in the GUI directly, allowing the designer to control the geometry of the resulting design to as close a degree as desired. This is achieved either numerically or by drawing graphical exclusion and inclusion zones, which are then converted to upper and lower bounds by the software. Specified elements of the structure must lie either outside or inside of these zones. The current implementation allows for these zones to be associated only with nodes. Fig. 18 also shows the graphical specification of an inclusion zone in the GUI of the implemented design program. In this simple example, the top node of the truss is constrained to lie inside the space enclosed by the rectangle during optimization. 4.3. Case study: Geometry optimization of a simply supported truss In this example, the designer starts with a typical Pratt truss with parallel top and bottom chords. The truss is subjected to downward-acting vertical point loads at each of the nodes in its top chord, as shown in Fig. 19. The implemented SQP algorithm described in Section 4.2 is then used to optimization the geometry

Fig. 13. UML diagram of software extension showing the added natural frequency solver which enriches the design environment’s functionality.

Fig. 14. Design of a cable-stayed bridge using original functionality only.

R. Clune et al. / Computers and Structures 100-101 (2012) 1–17

13

Fig. 15. Modification of bridge design using results from natural frequency and mode shape solver, which give additional insight. Fundamental frequency drops dramatically from (a) to (b).

Fig. 16. Optimization object and performance object in the UML classification diagram.

14

R. Clune et al. / Computers and Structures 100-101 (2012) 1–17

Fig. 17. UML classification diagram of the entire software framework, including optimization and performance objects.

Fig. 18. Intuitive graphical control of the optimization problem statement.

and member sizing of the truss. The design variables are the geometric coordinates of all nodes, except for those at support locations, and the cross-sectional areas of the truss members. The design variables can be manually constrained, as shown in Fig. 20. The designer right-clicks on a node, opening a contextual window in which bounds on geometry are set. The node is set to ‘fixed’, which removes its coordinates from the optimization design vector, preventing it from moving during optimization. In this example, the nodes of the lower chord are fixed in space. The top nodes are bounded to remain within a square equal to the size of one of the initial truss bays, centered on their starting location. This prevents the algorithm from causing two members to cross each other, which would be physically infeasible, and from locating two nodes at the same point, which could generate a member of zero length causing division by zero in the stiffness matrix. The relative weights in the multi-objective function are set using the track bars in the GUI. Mass, compliance and cost are the available objectives for minimization, following the model

described in Section 4.2. These are aggregated in the Structural Performance #1 class shown in Fig. 16. The mass of the structure is given a relative weight of 8, compliance a relative weight of 2, and cost a relative weight of 1. The optimization is run, and the result is shown in Fig. 21. The top nodes move to form an approximation of a parabolic top chord, with the side nodes moving outwards and closer to the supports. The three available performance measures for the truss are compared in Table 2. The mass of the truss is reduced by 26.7%, and the compliance is dramatically reduced by 30.4%. The reduction in mass of material used is primarily responsible for the 26.5% reduction in cost, although the reduction of forces at nodes also contributes. Once an optimization has been run, the user is free to continue to modify the structure in the design environment. This represents a significant advantage over precedent structural optimization packages. The result of the optimization is not a static snapshot of a finalized design, to be accepted or discarded by the designer.

R. Clune et al. / Computers and Structures 100-101 (2012) 1–17

15

Fig. 19. Starting point: A user-designed simply supported truss with diagonal bracing.

Fig. 20. Setting of optimization-related parameters for nodes in a pop-up window.

Fig. 21. Result of geometry optimization using multi-objective SQP. Mass, compliance, and cost are all reduced.

Rather, it exists in the live environment and can be freely modified, and optimization is fluidly integrated into the process of design

exploration. Fig. 22 shows a result that the user has modified. The horizontal coordinates of the nodes along the top chord are

16

R. Clune et al. / Computers and Structures 100-101 (2012) 1–17

Table 2 Comparison of performance measures of truss design before and after optimization. Mass (kg)

Compliance (N mm)

Cost ($)

Starting point – Fig. 19 After optimization– Fig. 21

2390 1750

6280 4370

73,800 54,600

Change

26.7%

30.4%

26.5%

modified to restore the verticality of the web members. In addition, the height of these nodes is modified to make the four outer (top chord) members the same length. Both of these steps make for a more practical, easily constructible structure – objectives which the optimization algorithm did not consider. The designer finds a practical solution which is still close to the mathematical optimum recommended by optimization. As expected when handing control from the algorithm to the designer, the improvements in performance measures (shown in Table 3) are less than those originally achieved by the optimization algorithm alone. The additional merits of the user-modified design, however, which the optimization did not consider, may well make this a worthwhile tradeoff. This example is illustrative of the proposed way of thinking about optimization as an integrated part of design exploration instead of a standalone solution to a design problem. By allowing the designer to use engineering judgment and intuition alongside mathematical optimization, subjective evaluation criteria such as constructability and practicality, which are crucial in structural engineering but difficult to express in an objective function, can be considered in an optimization-aided design process. In this way, the proposed architecture addresses the perceived impracticality of using optimization in structural design. 5. Conclusion The software architecture presented here is a primary contribution of the work. The most important novel features of the architecture are the establishment and clear separation of three abstract levels of representation of structures and the particular hierarchy within each level of representation, which groups common functionality and inter-level communication at a base class level. Previous software architectures, and the way in which the proposed architecture differs from these, are discussed in Sections 1.2 and 2. The intellectual concepts of the architecture have been tested and proven in the development of a fully scalable virtual environment which allows an efficient and extensive exploration of the

Table 3 Comparison between performance measures of truss design at starting point and after user modification. Mass (kg)

Compliance (N mm)

Cost ($)

Starting Point – Fig. 19 User-modified – Fig. 22

2390 1970

6280 6060

73,800 61,180

Change

17.5%

3.5%

17.1%

design space and offers three distinct and important advantages to designers compare to typically available structural analysis software. The first of these is the fluid nature of the interaction with the software, where system responses are generated and usefully employed in real time in response to design changes, without the need for the designer to explicitly run an analysis and enter a results visualization mode. This type of interaction in enabled by the seamless integration of separately developed modeling components (Structural Model objects) and analysis components (Mathematical Model objects). The benefits of this type of interaction to the designer are discussed in Sections 3.2 and 3.3. The second advantage offered to designers is the extensibility of the software beyond its initial functionality. By developing software on the basis of the proposed architecture, where components respecting object-oriented interfaces are implemented as objects derived from a set of integrated base classes, new modeling and analysis components can be added to the integrated design environment without disrupting the original functionality. This extensibility, and the resulting scalability, of the environment hold the key to its potential for commercial development and application to industry. Section 3.3 demonstrates the ease of extension of analysis capabilities beyond those initially provided; the same extension of structural modeling capabilities is equally feasible. This easily extensible approach makes the software particularly appealing to users in small and medium-sized design practices. They need not invest in a package with levels of sophistication that will likely never be required. Instead, they can specify what types of modeling and analysis they want for their specific line of business, and extend if this changes or expands in the future. It is this ease of extension that ensures that users with programming ability will be able to add separate analysis, modeling and optimization methods. The third and primary advantage that the developed software offers to designers is the ability to use optimization in a fluid, simulation-based, fully extensible design environment unlike any other available today. Optimization is integrated as a flexible tool that

Fig. 22. User modification of optimization result in the live environment, resulting in a more practical design.

R. Clune et al. / Computers and Structures 100-101 (2012) 1–17

can be combined with human experience, intuition, and preference in addressing a design problem, unlike the standalone automated solution of design problems traditionally pursued by the optimization community. In this way, the work brings increased relevancy and rejuvenation to the field of structural optimization by proposing solutions to identified limitations in the field’s application to the conceptual design of structures and by demonstrating a real implementation of these ideas in a developed piece of software. The paper describes the architectural features required to include optimization in such structural design software, and outlines a clear methodology, via the Optimization Object, for researchers wishing to incorporate new or existing algorithms into the framework. The ease of integration of optimization algorithms and analysis methods for response generation is an important feature of this architecture, and is a marked improvement over the ad hoc methods currently used to achieve such necessary integration. This architecture is a significant step towards the long-pursued goal of bringing structural engineering into the conceptual stage of the design process, encouraging greater integration of design teams. The creativity and freedom of form exploration associated with geometric modeling is combined with the rationality and constraint of engineering analysis. This is a unique and original approach to the problem, representing a major change in the way structural design software is built. If widely adopted, the approach could significantly change the way design is performed in practice and enable the development of flexible design software which can easily be extended after initial development. Acknowledgements This work was supported in part by the Singapore-M.I.T. Alliance Fellowship in Computational Engineering. References [1] Simulia. Abaqus FEA. url: http://www.simulia.com/products/abaqus_fea.html. Accessed: 10 Jun-2011. [2] Computers and Structures. SAP2000 Overview | CSI Website. url: http:// www.csiberkeley.com/sap2000. Accessed: 10-Jun-2011. [3] McNeel. Rhinoceros: Modeling tools for designers. url: http:// www.rhino3d.com/. Accessed: 10-Jun-2011.

17

[4] Bentley Systems. BIM and Beyond-Generative Design: GenerativeComponents. url: http://www.bentley.com/en-US/Products/GenerativeComponents. Accessed: 10-Jun-2011. [5] Shea K, Aish R, Gourtovaia M. Towards integrated performance-driven generative design tools. Automat Const 2005;14(2):253–64. [6] Von Buelow P. Suitability of genetic based exploration in the creative design process. Digit Creat 2008;19(1):51. [7] Bazjanac V, Crawley DB. The implementation of industry foundation classes in simulation tools for the building industry. Lawrence Berkeley National Laboratory; 1997. [8] Autodesk. Autodesk – Robobat Acquisition. url: http://usa.autodesk.com/adsk/ servlet/item?siteID=123112&id=10466421 Accessed: 10-Jun-2011. [9] Dassault Systèmes. Dassault Systèmes Completes the Acquisition of ABAQUS Inc. url: http://www.3ds.com/company/news-media/press-releases-detail/ release//single/965/ Accessed: 10-Jun-2011. [10] Mocko GM, Fenves SJ, N. I. of Standards and T. (US), A Survey of DesignAnalysis Integration Issues. Citeseer, 2003. [11] Dr. Software, Dr. Software - Real-Time Engineering Analysis Software. url: http://www.drsoftware-home.com/. Accessed: 10-Jun-2011. [12] Martini K. Non-linear structural analysis as real-time animation: borrowing from the arcade. In Proceedings of the computer-aided architectural design futures 2001 conference, 2001. p. 643–56. [13] Greenwold S. ‘‘Active Statics,’’ 2003. url: http://acg.media.mit.edu/people/ simong/statics/. Accessed: 10-Jun-2011. [14] Ray T. Applications of multi-objective evolutionary algorithms in engineering design. Applications of multi-objective evolutionary algorithms 2004;1:29. [15] Coello CAC. A comprehensive survey of evolutionary-based multiobjective optimization techniques. Know Informat Syst 1999;1(3):129–56. [16] Miller GR. An object-oriented approach to structural analysis and design. Comput Struct 1991;40(1):75–82. [17] Larman C. Applying UML and patterns: an introduction to object-oriented analysis and design and the unified process. Prentice Hall; 2002. [18] Booch G, Rumbaugh J, Jacobson I. Unified modeling language user guide. The (Addison-Wesley Object Technology Series). Addison-Wesley Professional; 2005. [19] Mackie RI. Object oriented programming for structural mechanics: a review. in Civil and structural engineering computing: 2001. Saxe-Coburg Publications; 2001. [20] Heng BCP, Mackie RI. Using design patterns in object-oriented finite element programming. Comput Struct 2009;87(15–16):952–61. [21] Delalondre F, Smith C, Shephard MS. Collaborative software infrastructure for adaptive multiple model simulation. Comput Meth Appl Mech Eng 2010;199(21–22):1352–70. [22] Dauby JP, Dagli CH. Using extensible modeling in systems engineering and architectural search. In: 2009 3rd annual IEEE systems conference, 2009. p. 426–430. [23] Turner MJ. The direct stiffness method of structural analysis. Boeing Airplane Company; 1959. [24] Spellucci P. An SQP method for general nonlinear programs using only equality constrained subproblems. Mathematical Programming 1998;82(3):413–48. [25] Rogue Wave, ‘‘IMSL Numerical Libraries,’’ 2011. url: http:// www.roguewave.com/products/imsl/. Accessed: 10-Jun-2011.