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
Massachusetts Institute of Technology, Department of Civil and Environmental Engineering, Cambridge, MA 02139, USA
b
University College Cork, Department of Civil and Environmental Engineering, Cork, Ireland

a r t i c l e i n f o a b s t r a c t

Article history: This paper presents an object-oriented architecture for structural design software. The architecture’s
Received 11 July 2011 novel features are the representation of an artifact with distinct levels of idealization, a hierarchy of clas-
Accepted 13 February 2012 sification within each of these levels, and the appropriate separation of software components. These
Available online 12 March 2012
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 optimi-
Keywords: zation. The paper presents a design environment implemented on the basis of the architecture, and dem-
Structural design
onstrates the benefits of refocusing engineering software from analysis to design.
Design-analysis integration
Interactive optimization
Ó 2012 Elsevier Ltd. All rights reserved.
Software architecture
Object-oriented programming

1. Introduction system. By contrast, the geometric modeling tools typically used

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 intui-
tion 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 prac-
tice 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 unquestion-
ably 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
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 prob-
lem at hand.
Furthermore, although analysis software provides feedback
such as deflections or internal stresses, it does not propose struc-
tural forms to be analyzed. In response, the field of structural opti-
mization 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 impli-
cit 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, In order to achieve a strong engineering design sensibility,
Cambridge, MA 02139, USA. Tel.: +1 617 470 6939. software should combine the strengths of geometric modelers
E-mail address: clune@mit.edu (R. Clune). and analysis software, allowing creativity to flourish while

0045-7949/$ - see front matter Ó 2012 Elsevier Ltd. All rights reserved.
doi:10.1016/j.compstruc.2012.02.002
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 interoper-
ability 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 pro-
posed 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 mod-
eling software. Rather than seeking to integrate existing packages,
as has been the goal of much research in this area, this work ad-
dresses the question of how engineering software should be devel-
oped 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 interac-
tion, visualization and computation appear to occur simulta-
neously. 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 inte-
grated, 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 mod-
eling 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 archi-
tecture becomes an extensible framework whose default function-
ality can easily be added to.
In addition to real-time analysis capabilities, this work sees the
inclusion of optimization methods as important to the develop-
ment of an interactive design environment. Most existing struc-
tural optimization applications typically seek to deliver a single
optimal solution to the user, rather than harness the power of opti-
mization 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, ill-
defined [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 embed-
ded in a flexible design environment implemented on the basis
of the developed software architecture.
1.2. Important software architecture precedents
With the emergence in the early 1990’s of Object-Oriented Pro-
gramming (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 struc-
tural analysis software. Notably, Miller [16], reflecting on several
years of research on the topic, envisaged a ‘‘comprehensive rede-
velopment 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.
The logical organization of a well-designed object-oriented
code, and the benefits of the reusability of such code, make the ob-
ject 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 fo-
cused 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 litera-
ture. 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 re-
views 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 soft-
ware architectures. The features that address integration of analy-
sis 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 mod-
eling and analysis components, generation of real-time analysis re-
sults, 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 pre-
sented 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 in-
clude interactive optimization, and presents a case study that uses
optimization as part of the solution to a truss design problem. Fi-
nally, Section 5 summarizes the main contributions of the work
and draws conclusions.
2. Proposed software architecture
This section presents the features of the proposed software
architecture that enable seamless integration of modeling and
analysis components, real-time response generation, and extensi-
bility. The novel features of the architecture that enable this func-
tionality 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 com-
mon functionality and communication between components at a
base class level. The section presents the details of these architec-
tural features, their novelty compared to previous work, and the
functionality they enable, which is further explored and demon-
strated 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 integrat-
ing modeling and analysis capabilities through its unique struc-
ture, which combines varying abstractness of representation with
hierarchies which group common functionality and communica-
tion 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 model-
ing 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 architec-
ture to reflect this reality is the first step towards facilitating inte-
gration. 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 con-
nection 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 arti-
fact. The Structural Model abstracts the Artifact class as an aggrega-
tion 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 pin-
jointed truss or as a rigid-jointed frame.
The most abstract types of representation considered, Mathe-
matical 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
Fig. 1. Abstraction of the representation of the actual artifact increases from an Artifact class to a Mathematical Model class.
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 clas-
ses which inherit common functionality from base classes. The
power of this approach is that communication and integration be-
tween the Artifact, Structural Model, and Mathematical Model classes
can be established at the base level. In order to seamlessly inte-
grate with the rest of the software, a particular derived class need
only establish a connection to the relevant base class. This archi-
tecture accomplishes this using inheritance and by forcing derived
classes to implement interfaces.
Fig. 2 shows the essence of this approach to the design of struc-
tural software. Particular types of Structural Model and Mathemat-
ical 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 represen-
tation. 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 conven-
tion, the names of interfaces begin with the letter ‘i’ in order to dis-
tinguish 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 pro-
vide definitions for methods and attributes that the other compo-
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 iMath-
ematicalModel interface, which requires a definition of the Ana-
lyze() method, provides an implicit guarantee that this Analyze()
method exists. This is the strategy by which the low-level model-
ing 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 ex-
pands 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 pack-
ages via data transfer, requires all components to be implemented
as derived classes of an appropriate Structural Model or Mathemat-
ical 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 sim-
ulation 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 gi-
ven period of time than they could do with existing analysis soft-
ware, 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 respon-
sive simulation of a structure in a real-time simulation environ-
ment, 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 soft-
ware, 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 mod-
eling 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 perfor-
mance 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 Mod-
els 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 conven-
tional 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 capabil-
ities in the form of Structural Model and Mathematical Model clas-
ses. Extensible software developed using the architecture allows
new analysis or modeling software developed to the specifications
of the architecture to seamlessly integrate with existing compo-
nents. Such software becomes a framework, whose default behav-
ior 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 exten-
sibility, 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 implementa-
tion 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 ab-
stract 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 provi-
sion 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 di-
rectly 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 poten-
tial 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 inter-
active 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 two-
dimensional truss structures. It is highly useful for developing
structural intuition and bringing physical considerations to the ini-
tial 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 StiffnessMethodMathematical-
Model, 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 ob-
ject. 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 cal-
culated as an overall indication of the structure’s deformation un-
der a given load case.
Before running an analysis, stability of the structure is evalu-
ated by testing for singularity of the stiffness matrix in the Direct-
StiffnessMethod2D 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 inde-
terminate structures, a simple heuristic algorithm iteratively mod-
ifies the cross-sections of the members and re-runs analyses until
each member’s cross-sectional area converges subject to the mag-
nitude 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).
! The environment detects the instability of the truss structure at
mj
X
n X
C ¼ cm V þ cc þ cF F i;j
i¼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, how-
ever, 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 Win-
dows 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 environ-
ment provides event handlers which render models in response
to events raised by a Structural Model object, as described in Sec-
tion 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 con-
venient background for the structural engineer, guiding the man-
ual 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 soft-
ware can also be used to easily develop a first-order understanding
of the structural behavior of an existing artifact, simply by import-
ing 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 im-
ported, as shown in Fig. 6, and the designer begins tracing the out-
line of the primary structural elements. The structure is loaded
under self weight, and a point load at each of the nodes along
Fig. 6. An imported image of Waterloo International Train Terminal guides manual generation of designs.
7
the approximately parabolic line of the roof represent additional
gravity loads other than those due to the primary members.
this early stage, but still estimates its cost.
ð1Þ
The designer quickly generates a two-dimensional truss repre-
sentation of the roof (Fig. 7), showing the structural action and giv-
ing 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 re-
sults and performance measures are automatically rendered in real
time. The use of an appropriate background images aids in under-
standing the context of the structure during this fluid process of
exploration.
The user moves the structure towards somewhat of an inver-
sion of the original concept, arrived at in Fig. 9. The original curve
between the two supports is maintained, but the rest of the struc-
ture 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 mea-
sures. The mass of the structure is reduced by 54%, and its compli-
ance 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 improve-
ments that can result from allowing designers to explore freely.
This is a dramatic improvement on the constraints that conven-
tional 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.
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
3.3. Case study: Truss design problem
The previous case study showed the software being used to
quickly develop a model of an existing structure and explore alter-
native 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 coor-
dinates 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)) gener-
ally 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 sub-
stantially more expensive than all the other designs. The ability to
track multiple performance parameters in real time enables design-
ers to account for and understand the complex tradeoffs and inter-
actions between often conflicting goals in a real-world design
exercise.
Finally, a modification of the near-Michell truss leads the de-
signer 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 de-
signer 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 struc-
tural design.
Fig. 10. A design problem to be solved in the environment.
9
3.4. Case study: Extensibility of software
As a test of the extensibility of the developed software dis-
cussed in Section 2.3, the prototype design environment is com-
piled 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 compo-
nents. 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 con-
nected, via the abstract base classes, to the Truss2D class. The ob-
ject 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 per-
form 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 orig-
inally 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 imple-
mented, and the Analyze() method of both the original and the
new Mathematical Models are called in sequence. The designer
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 funda-
mental modal frequency of the structure. Fig. 15 shows a change of
the backstay angle which caused a dramatic drop in the fundamen-
tal 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 show-
ing the undeformed geometry.
Although a somewhat basic first step, this exercise demon-
strates the ease with which software developed using this architec-
ture can be extended, making it an extensible framework whose
default functionality can be added to after development. The addi-
tion 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 state-
ment, the proposed software architecture is extended to integrate
optimization algorithms in the interactive design environment.
This enables the development of interactive optimization soft-
ware, where optimization is seen as a flexible tool that can be
called upon as part of a fluid design process rather than the stand-
alone 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 mod-
eled in the mathematical optimization problem statement.
It should be emphasized from the outset that none of the math-
ematical optimization theory or optimization algorithms presented
in this section are themselves novel. Nor is the optimization prob-
lem 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 pro-
gram, 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 Optimi-
zation Object, modifies the Structural Model, which triggers an auto-
matic 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 di-
rectly 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 ob-
jects 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 compo-
nents of the software, facilitating the future extension of the soft-
ware 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 con-
nected to the other components of the software via the Optimiza-
tion 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-dimen-
sional 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 as-
signed to each of the i objective functions to form an overall objec-
tive function given by Eq. (2).
X
k
min wi fi ðXÞ ð2Þ
x
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.

X
k where xlb and xub are vectors of lower and upper bounds on the
min wi fi ðXÞ design variables.
i¼1
ð3Þ
The user is given control in the graphical user interface (GUI)
subject to xlb  x  xub 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 Design variables can be constrained in the GUI directly, allow-

Performance measures of user-generated designs. ing the designer to control the geometry of the resulting design
Mass (kg) Compliance (N mm) Cost ($) to as close a degree as desired. This is achieved either numerically
Fig. 11 135 2160 6040 or by drawing graphical exclusion and inclusion zones, which are
Fig. 12(a) 119 1810 5380⁄ then converted to upper and lower bounds by the software. Spec-
Fig. 12(b) 119 1810 6180 ified elements of the structure must lie either outside or inside of
Fig. 12(c) 114 1560 6040 these zones. The current implementation allows for these zones
Fig. 12(d) 120 1470 6200
Fig. 12(e) 137 2290 5900
to be associated only with nodes. Fig. 18 also shows the graphical
Fig. 12(f) 139 2490 5950 specification of an inclusion zone in the GUI of the implemented
Fig. 12(g) 148 3100 6240 design program. In this simple example, the top node of the truss
Fig. 12(h) 156 2670 6480 is constrained to lie inside the space enclosed by the rectangle dur-
Fig. 12(i) 148 2260 6250
ing optimization.
Fig. 12(j) 130 1720 5700
Fig. 12(k) 131 1830 5740
Fig. 12(l) 108⁄ 780⁄ 8250 4.3. Case study: Geometry optimization of a simply supported truss
Fig. 12(m) 137 1360 6010
Fig. 12(n) 158 2860 5750
In this example, the designer starts with a typical Pratt truss
*
indicates lowest (best) value attained. with parallel top and bottom chords. The truss is subjected to
downward-acting vertical point loads at each of the nodes in its
shows a series of track bars in the GUI which are used to modify top chord, as shown in Fig. 19. The implemented SQP algorithm
the relative weighting of components of the objective function. 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 de-
sign 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 com-
pared 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, exploration. Fig. 22 shows a result that the user has modified.
and optimization is fluidly integrated into the process of design 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)
Starting point – Fig. 19 2390 6280
After optimization– Fig. 21 1750 4370
Change 26.7% 30.4%
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 in-
stead 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 impracti-
cality of using optimization in structural design.
5. Conclusion
The software architecture presented here is a primary contribu-
tion of the work. The most important novel features of the archi-
tecture 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 com-
mon 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 environ-
ment which allows an efficient and extensive exploration of the
Fig. 22. User modification of optimization result in the live environment, resulting in a more practical design.
Table 3
Comparison between performance measures of truss design at starting point and after
user modification.
Cost ($)
Mass (kg) Compliance (N mm) Cost ($)
73,800
54,600 Starting Point – Fig. 19 2390 6280 73,800
User-modified – Fig. 22 1970 6060 61,180
26.5%
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 em-
ployed 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 compo-
nents (Structural Model objects) and analysis components (Mathe-
matical 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 soft-
ware 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 envi-
ronment without disrupting the original functionality.
This extensibility, and the resulting scalability, of the environ-
ment 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 partic-
ularly appealing to users in small and medium-sized design prac-
tices. 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 of-
fers to designers is the ability to use optimization in a fluid, simula-
tion-based, fully extensible design environment unlike any other
available today. Optimization is integrated as a flexible tool that
 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 optimiza-
tion 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 out-
lines a clear methodology, via the Optimization Object, for research-
ers 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 fea-
ture 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 con-
straint of engineering analysis. This is a unique and original ap-
proach 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. Alli-
ance 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 Design-
Analysis 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.