Keywords: object-oriented programming, C++, boundary element method, photoelasticity.

This paper describes an experiment in the writing of an object-oriented boundary element (BE) system intended to serve two substantially different purposes. One is primarily a technology demonstrator illustrating perhaps the first truly object- oriented boundary element system for the solution of solid mechanics problems to find stresses etc. from a known set of tractions and boundary conditions. The second purpose is the more specific task of finding the set of boundary conditions (displacements and tractions) from a set of photoelastic data which relate to principal stress difference ( ) and principal stress orientation at chosen interior points, treating the situation as an inverse problem. Such an inverse BE system had already been implemented in FORTRAN in a somewhat preliminary form as a modified version of the BEACON procedural BE system [1].

The initial attempt [2] was to create a 'pure' object-oriented BE system using objects and classes for all but the simplest data types. The object-oriented design was refined using the class responsibility collaborators (CRC) [3] cards approach. The resulting design has the specific feature of separating the model database from the solution object and its sub-objects, and also enables different versions of the "Model_Builder" to be substituted, for example allowing the input to be interactive, file-based, or partially based upon graphical input data. The code for the forward BE system was completed in Microsoft Visual C++. The implementation of the system emphasised using container classes to represent all arrays, matrices vectors etc from existing publicly accessible code. This enabled a reasonably purist object-oriented approach to be taken to implementation, with arrays having built-in intelligence. But, experience of this initial attempt at the implementation showed that the execution of the program was exceedingly slow, and indeed was typically two or more orders of magnitude slower than the corresponding FORTRAN program. This was attributed to the use of container classes where non-intelligent arrays can be used instead, with only a little more care and programming effort.

One of the key themes throughout this paper is to find the optimal point along the scale from purely procedural to thoroughly object-oriented implementation of engineering software. The present design deals with the OOP as the software development technique or tool. One of the hallmarks in this OOP design is that it is "just object-oriented enough, and not a bit more" [4].

The present design retains the overall framework as the previous approach, i.e. the CModel_Builder, CBemModel and CBemAnalysis super classes but gives up the use of container classes at the implementation. Instead, it focuses on the construction at the BE Model class and its members: Element class and Node class etc. representing real-world entities. The CBemModel class is located in the centre as the database of the BE analysis system. The Node class contains not only the nodal co-ordinates, but also the identities of its connected elements, the traction, displacement, Cartesian stresses and principal stresses etc. The Element class contains the element nodes, the indices of the two adjacent elements, the boundary condition type and values, the type of co-ordinates (global or local), tractions and displacements. In this way, a clear picture is given of each node and element. These describe the key features of a BE approach and can only be properly implemented using object-oriented programming technology. The neighbourhood information is very useful at the stage of forming the system matrices and recovering solutions.

The CBemAnalysis class is a BE analysis tool and houses the common numerical solvers as its member functions and the system equation matrices as its member data or attributes. The conventional (forward) BE analysis is encapsulated in a class derived from CBemAnalysis class and the inverse BE analysis is wrapped in a class derived from the forward BE class.

The OOP design of BE analysis classes and its inheritance hierarchy guarantees the maximum reusability when the software system is extended from the conventional BE analysis to include the inverse BE approach. The routines in the analysis portion of BEISYS are mostly kept as the member functions rather than being wrapped into their own object-oriented classes. This contributes not only the advantages of OOP technique but also more readable code and faster implementation CPU times even compared to the corresponding FORTRAN code.

1

A.A. Becker, The Boundary Element Method in Engineering. McGraw-Hill, London, 1992.

2

D. Chen, I.A. Jones, A.A. Becker, "Framework for object-oriented boundary element programming". Proc. Modern Practice in Stress and Vibration Analysis, edited by A.A. Becker, Nottingham, 75-86, 2000.

3

I. Sommerville, Software Engineering. 6th Edition, Pearson Education Limited, Harlow England, 2001.

4

C. Sphar, Learn Microfoft Visual C++ 6.0 Now. Microsoft press, Washington, 1999.

purchase the full-text of this paper (price £20)

go to the previous paper
go to the next paper
return to the table of contents
return to the book description
purchase this book (price £122 +P&P)