Object-oriented modelling and the dual reciprocity boundary element method, each apowerful technique able to handle many different engineering problems, have beencombined to create a new type of boundary element code that simplifies and speedsup all major steps of any engineering analysis: pre- and post-processing, choosing anadequate physical model, that is selecting the governing equations and boundaryconditions, computation and reviewing of results. This is made possible by theprinciples of object-oriented modelling called encapsulation, inheritance, andpolymorphism together with the corresponding implementation tools and the facilitiesof dynamic memory management, which allows to compute more unknowns andavoids memory wasting. The advantages of the chosen approach are demonstrated for2D Laplace, Poisson-type and diffusion problems, all solved by using one singleobject-oriented computer program including the analyzing steps mentioned beforewhich is especially beneficial for PC users.
1 Introduction
The fast progress in electronics and computer science does not exclude thesoftware development. More advanced methods like object-oriented modellingimplemented by 'Object-Oriented Programming (OOP) tools, incorporate manyadvantages compared to the more traditional style of software design, which issometimes called 'Procedure-Oriented Programming (POP)' [1]. The main differencebetween OOP using C/C++ or another object-oriented computer language and POPgenerally with FORTRAN 77 is that OOP models the world and its behaviour in thesame way it is seen through human eyes. Thus, a OOP program starts very generaland other details are added when the model gets more complex. On the other hand'POP is based on the concept of decomposition meaning that one programming task issubdivided into smaller tasks which are again subdivided, and so on. Finally the POPprogram consists of one main part and different layers of subroutines and functionsMajor disadvantages of the POP approach are that POP programs have less flexibilityand modularity, and they are generally more difficult to read, to understand to alterand to maintain. A change from POP to OOP makes sense or is even unavoidable ifcomplex non-linear problems are going to be solved by a computer code Here"complex" means a process containing many different dynamical components withvariable behaviour and relations so that modelling of such a system is almostimpossible by just using POP tools. Examples for these cases are relational databasesCAD or Windows programs [2]. On the other hand it is more reasonable to stay withPOP as long as more linear tasks with a pattern like "input of numbers -> computa-tions -> output of numbers" need to be solved. What to do with problems betweenPOP and OOP is discussable and depends finally on the personal opinion Acombination of both is also possible which is often not mentioned in references
The main advantage of object-oriented modelling is its ability to describeeffectively complex non-linear systems and to transfer the model to an object-orientedcomputer code without major changes, so that the gap between the designed modeland the computer implementation is very small during the whole modelling process,allowing very fast design and modifications to achieve convergence. This capabilityallows an increasing automation, that is a simplification and acceleration ofengineering model development, which is otherwise done over and over again forslightly changed or extended problems involving a high portion of repetitive work tosolve low-level problems [3]. In this application the implementation language andenvironment has been C++ under the MS Windows operating system for PCs [4].
2 Basic Concepts of Object-Oriented Modelling and
Programming
Object-oriented modelling is a method that seeks to mimic the way we formmodels of the world. To cope with complexities of life, we have evolved a wonderfulcapacity to generalize, classify and generate abstractions. Almost every noun in ourvocabulary represents a class of objects sharing some set of attributes or behavioraltraits. Object-oriented modelling exploits this natural tendency we have to classify andabstract things. For example, the object-oriented programming language C/C++ wasoriginally called "C with Classes". Object-oriented modelling is implemented byobject-oriented programming, which can be characterized by supporting and enforcingthe use of the following programming concepts that are essential for any application:1) Encapsulation is the combining of a data structure with the functions dedicated to
manipulate the data. Encapsulation is achieved by means of a new structuringand data-type mechanism - the class.
2) Inheritance means that newly built, derived classes inherit the data and functionsfrom one or more previously defined base classes, while possibly redefining oradding new data and functions. This creates a hierarchy of classes like aninheritance tree.
3) Polymoiphism means that a function with a given name is shared up and down theclass hierarchy, with each class in the hierarchy implementing the function ina way appropriate to itself
Encapsulation greatly facilitates the usage of complex data structures to model agroup- or semigroup structure, thus allowing to collect information of different typesthat belong together naturally into one class as a single unit, i.e. data of a boundarynode containing its number, coordinates, type and value of boundary condition (seeEq.(2)). Therefore, encapsulation increases the readability and maintainability of themodel and code [5]. It is also very benefical to use existing classes when defining newclasses. This can be achieved by composition, or by extension of already definedclasses using the concept of inheritance. The main purpose of inheritance is to allowsharing of code among classes. From one class, any desired number of class objectscan be initialized and used, a process similar to the casting of pieces from a singlemould. Each of these copies is autonomous, doing its job by its own, but if it needssome code or data from another class object, the concept of inheritance allows themto share it. Inheritance is of crucial importance for the realization of tree-structereddependencies between class objects. Sometimes, a set of class objects may share aroutine, but it can only be defined at a specific program level or stage. Thus, thisroutine can be initialized as a virtual function, but later defined at run-time when it is
required. This is part of the polymorphism concept which makes it possible to adoptan initialized function to the needs of an object class in the same inheritance tree byadding new features or overwriting existing ones. This process is also called dynamictype binding, which makes the object-oriented method so flexible and efficient. Allthree concepts are the foundation of object-oriented programming, allowing a fasttransfer from OOM to coding in a clear and simple manner. The described advantagesof object-oriented modelling and -programming can be summarized as follows [6]:
' fest and simple programming design by using the object-oriented programmingconcepts encapsulation, inheritance and polymorphism
' a ost no gap between a developed object-oriented model and its implemen-tation in an object-oriented computer program
" complete model in one shot, starting from data management via databases upto visualization of results (for time-dependent problems in movie style)
• high degree of modularity and flexibility• generally shorter and faster computer codes" greater clarity, readability and maintainability
3 An Object-Oriented Model for Boundary Element Software
using the Dual Reciprocity Boundary Element Method
3.1 General Concept
The designed object-oriented model follows a responsibility driven approach [7]that categorizes all involved objects into clients and servers, such that the serversprovide some services layed down in a server-specific contract, which can be invokedby clients, who do not have to know how the services are carried out Clients areidentified with state objects, which are able to hold information, and servers arerepresented by acting objects, which receive information from a set of state objectsperform their task, and transfer all their knowledge back to the same or another set ofstate objects, or, if necessary, to some other type of objects. A general strategy usedto design an object-oriented model is described in [8] with the following steps:1) Job description of the model: What is the overall goal? How should it be
accomplished?2) Finding objects and classes: What objects belong to the model domain? Are these
state- or acting objects?3) Identifying structures: How do all objects relate to each other? Is there inheritance?
How can the objects be collected into classes?4) Identifying guiding mechanisms: How does the model achieve its goal in detail?
How does it precisely work? What are the interdependencies between differentclasses and their objects?
5) Defining attributes: What are the attributes of all involved objects? How can theybe described? What conditions do they fulfill? What needs to be rememberedover time?
6) Dg/?Mmg jgrwcfj cOom/ What is the specific task of each object? How is thistask accomplished? What information is needed for each service to be carry out?
3.2 Step 1
The boundary element software should incorporate all major steps of any
engineering analysis: pre- and post-processing, choosing an adequate physical model,that is mainly deciding about the governing equations and boundary conditions,computation and reviewing of results, together with an interactive mouse-driven userplatform with the ability for visual interaction and multi-tasking, which allows to viewand work in at least two different windows at the same time. Data in- and output isgoing to be done mainly visually by drawing with the mouse and using pop-upwindows. Moreover, the program should provide other facilities like a file manager,an editor, and a help menu. The solution to the considered governing equation isobtained through the 'Dual Reciprocity Method (DRM)' [9], which is a "boundary-only" method that does not require a fundamental solution to the original partialdifferential equation and avoids domain integrals originating from the non-homogeneous parts in the governing equation. Therefore, it can be easily applied todifferent problems governed by Laplace. Poisson-type or diffusion equation with onlyminor changes to the overall algorithm
3.3 Steps 2 and 3
The relevant state objects are:• nodes at points P, with 3D coordinates x, , y, , z, = 0, collected in a base class called
Node^ = (;,*,, ;y, , %) , (1)
where the third coordinate can be used later for i.e. displaying the result. Eq.(l)can be used in the same way for internal nodes, IntNode , = Node , .
• information about n boundary nodes with sufficient boundary conditions describedby a code and the corresponding value, collected in a class derived from Eq.(l)named
BoundNode = { n , Node , Code , Value } . (2)
information about the type of governing equation to be solved, either Laplace,Poisson-type, or convection-diffusion problems, together with other needed data,collected in another base class called
information about the graphics in a window w e {1,2,3,...}, containing the graphicscoordinate center XQ and , scale, view angle, pensize, background- anddrawing colour, collected in a class derived from Eq.(l) and named
WinGraphics = { w , Node^ with a, = -*o , % = % , Z, = 0 ,
data to initialize and run an interactive graphical user platform with multi-taskingabilities. In this application it has been mostly supplied by the compiler libraryof [10]. Here the following object classes are of special importance:a) TApplication is the basis module for all multi-tasking applications and
responsible for i.e. initializing and creating the main window.b) TMDIFrame is the main part of the 'Multiple Document Interface (MDI)' that
i.e. initializes and creates child windows.c) T Window is the class that allows to design any type of window and to
The relevant acting objects are the servers of the state objects or clients and performall necessary tasks to reach the set goal. Many of them emerge from the model'sability of interaction and multi-tasking plus all required data management for pre- andpost-processing. These are represented by member functions of three user-definedclasses TMyApplication, TMDIMyFrame and TMy Window, derived from the beforeintroduced classes TApplication, TMDIFrame and TWindow together with other self-made attributes and services. The other acting objects originate from the computationpart and the review of results. They are organized in four classes SetupEq,CompUnknowns, FileOutput, and GraphOutpnt. The first three ones are derived fromEqs.(2,3), the latter one from class TMy Window and Eq.(4).
3.4 Steps 4 to 6
The best way to illustrate the interdependencies between different classes andtheir objects is an inheritance tree (Fig. 1) with base classes on the left-hand side andderived classes following on the right. Connection lines and arrows between the boxesindicate interaction and flow of information [Coad and Yourdan, 1991].
iTApplicatlor
I TMDIFrame
| TUindow
| Node i
| EqTypep
-iH^yApplicationl |FileOutput|
HHTMDIMyFramet
HH TMyUindoNr— it IH Bound Node, k
|GraphOutput|A f
|UinGraphicsJ1 f'
|CompUhknowns|
TH IntNode. SetupEq, |A
Figure 1: Inheritance tree of base- (on the left) and derived classes of thedesigned object-oriented model for the boundary element software
This figure illustrates apart from BoundNode^ and IntNode the predominant role ofclass TMy Window. Class objects of TMy Window play a key role for interaction andmulti-tasking using virtual functions introduced in Ch.2, which are essential for agraphical mouse-driven user platform and needed i.e. to select menu options or theposition of nodes. The total amount of virtual functions in the designed model is overfifty. For illustration purposes two of these functions are explained by the followingcode (indicated by a double line on the left):
25 y* L\M*c TWmdow { public: // Declaration of class TMy WindowTMy Wmdow(PTWmdowsObject AParent, int ChildNum); // Constructor~TMWmdow(void); // Destructor
//Declaration of virtual functions'
button up
void TMy Window: :WMRButtonDown(RTMessage Msg)< f mndow, NULL, TRUE); } // Function call to clear screenvoid TMy Window: :WMRButtonUp(RTMessage Msg){ DragDC = GetDC(H Window); // Get window context and store it in DragDC
int x = Msg.LP.Lo, y = Msg.LP.Hi;ReleaseDC(HWindow, DragDC); }
// Store window coordinates of mouse in x, y// Release window context
where pressing the right mouse button down clears the active window, and releasingthe same button stores the mouse coordinates of this window in the integer variablesx and y. These two virtual class member functions WMRButtonDown and -Up arecalled "Windows Message (WM) response functions" because they respond toincoming messages processed through [WM_FIRST+WM_RBUTTONDOWN] or [ . . . -UP] and react accordingly, which means in this example clearing the screen andstoring the mouse coordinates. The final outlook of the 'Object-oriented BoundaryElement Program (OBEP)' together with a list of menu options is given below. Thefirst version allows to solve 2D Laplace, Poisson-type and diffusion problems byapplying the DRM.
*»j OBJECT-ORIENTED BOUNDARY ELEMENT PROGRAM for Windows 1.0File Pre-Procesg Data Input Select Equation Bun Poct-Procesg Window Help
SOLUTION FOR DIFFUSION EQUATIOND Close ? *** Made by J. Friedrich [1995|
Figure 2: Interactive graphical user platform of OBEP with two open windows forpre- and post-processing plus a displayed pop-up window
Table 1: Menu options of OBEP (No. 1 to 15 indicate the using sequence)
File: New / Open / Save / SaveAs / Delete / ExitPre-Processing: Clear Screen / Select Pen / 1. Start Drawing Boundary / 2. Stop Drawing
Boundary / 3. Save Drawing / 4. Open DrawingData Input: 5. Start Input of Boundary Nodes / 6. Stop Input of Boundary Nodes / 7. Start
Input of Internal Nodes / 8. Stop Input of Internal Nodes / 9. Choose Coordinate System/10. Choose Approximating Function / Redraw Boundary and Nodes / Add BoundaryNode / Add Internal Node / Delete Node
Select Equation: 11 a. Laplace Equation /lib. Poisson Equation /lie. Diffusion EquationRun: 12. Choose Names of I/O Files / 13. Assemble Input File / 14. Run ComputationPost-Processing: 15. Show Output / Move dX / Move dY / Change View Angle / Scale /
Change GridWindow: Create / Cascade / Tile / Arrange Icons / Close All / Count Windows
3.5 Dynamic Memory Management
One major advantage of OOP using C/C++ is the dynamic memory allocationduring the program's execution time according to the actual problem size withoutwasting memory, whereas the POP with FORTAN 77 needs to fix the maximum size
of all arrays at the compilation time that remain as static parts in the machine's RAMduring run-time. But this has changed with the appearance of FORTAN 90 [5]Nevertheless, if OOP with C/C++ is still much more beneficial for a programmer likem the application considered here, keeping in mind that apart from other advantages
*™-T°AX!* ¥£ ** ***** s ware * *"**» in C/C++, then a transition fromf OK IAN to C/C++ becomes very easy by the recommendations of [11] which allowto compensate the most important drawbacks of C/C++ for FORTRAN users indexingstarts with zero in C/C++ instead of one, and matrix elements are stored internallvrow- instead of collumn-wise as in FORTRAN. A simple way how FORTRANprogrammers can overcome these difficulties is demonstrated by the following C++program to transform a vector where the C/C++ functions "calloc" and "free" allocateand free up array memory as needed.
„. - .float *x *v
// Parts of a C++ program to compute a vector X(n) = A(n,m)* Y(m)// Declaration of integer variables
,voidWarrung(vo,d){pnntf( \nNotenough memory on hard disk!"); //Waging function
t<*0; fi»e(x): free(y); free(a); } // Allocate memory for y and an ==v - mm* « 11 e memory
I - $ I tl ca oc(npzeof(float)): if(y==NULL) { WarningQ; return }a - (float *) calloc(n*m,sizeof(float)): if(g==NULL) {WarningO; return }
free(y); free(a); // Free up memory of y and a
4 Results and Performance
The first version of OBEP was tested against a number of benchmaik tests i epotential flow between two parallel walls or around a circular cylinder, torsion- or heat• ,n™ Problems. The results were identical to the ones described by [Partridge etaL 1992]. These tests have also helped to improve the program's clarity and quality
1 ™™" ' °*** ™*™ <=++ °RM ™le was compared to the corresponding4. FORTRAN program described in [9,p. 177f] to solve the heat diffusion equation fora square plate undergoing a thermal shock at T = 30° C by using one PC withdifferent compilers. Larger computers were not tested because they are no ones at theauthors department yet.
Table 2: Performance of a 486DX2-66 PC with 8 MB RAM for solving the heatdiffusion equation for a square plate with 73 unknowns using the DRM [9,p.l77f]=========Compiler Type**************
These results are similar to the findings of [6] that support the advantages of C/C++against FORTRAN for PCs Here we have a C++ / FORTRAN ratio of about 1/1.3for source file size, 1/4 for execution file size, and between 1/1 (MS) and 1/1.5(NDP)for execution time. Only the run-time of the C++ Windows program is about 3.5 timesslower than the DOS version because of the overall reduced speed under the MSWindows operating system.
5 Conclusions
The main advantage of the described appoach is the combining of all majorsteps of any engineering analysis together in one single Windows program, whichdecreases immensly the time spent on data preparation and interpretation of results.The created interactive mouse-driven user platform with the ability for visualinteraction and multi-tasking reduces time and effort spent for the undertaken analysis.Moreover, OOM simplifies the program's design and OOP its implementation. Due tothe good results gained so far, it is planned to extend the introduced approach alongthe following lines. Firstly, 3D problems are taken into consideration which demandsthe incorporation of more sophisticated object-oriented CAD facilities. Secondly, morecomplicated governing equations like the various forms of the Navier-Stokes equationsare of growing interest for many boundary element researchers, especially by using thedual reciprocity boundary element method [12]. Thirdly, the presented object-orientedapproach has a high potential for future simplifications of the overall modellingprocess by more "intelligent" higher level modelling- and programming tools.
References
1 Forde, B.W.R., R.O. Foschi and S.F. Stiemer (1990) "Object-Oriented Finite ElementAnalysis", Comp. and Structures Vol.34 No.3 pp.355-374
2 Hardwick, M., and D.L. Spooner (1989) "The ROSE Data Manager: Using ObjectTechnology to Support Interactive Engineering Applications", IEEE Trans. Knowledge andData Eng. Vol.1 No.2 pp.285-289
3 Fritzon, D., P. Fritzon, L. Viklund, and J. Herber (1994) "Object-oriented mathematicalmodelling applied to machine elements". Comp. and Structures Vol.51 No.3 pp. 241-253
4 Microsoft Corporation (1992) "User's Guide for the Microsoft Windows Operating System"5 Sanal, Z. (1994) "Finite Element Programming and C", Comp. and Structures Vol.51 No.6
pp. 671-6866 Fazio, P. and K. Gown (1987) "Structural Analysis Software and the C Programming
Language", Comp. and Structures Vol.25 No.3 pp.463-4657 Wirfs-Brock, R. and B. Wilkerson (1989) "Object-oriented design: a responsibility driven
approach", in OOPSLA '89 Proc. pp.71-758 Coad, P. and E. Yourdon (1991) "Object-Oriented Analysis", Yourdon Press Computing
Series, Prentice-Hall Publ. New Yersey9 Partridge, P.W., C.A. Brebbia and L.C Wrobel (1992) "The Dual Reciprocity Boundary
Element Method", Elsevier Science Publ., London10 Borland International (1991) "ObjectWindows for C++", Scotts Valley, California11 Ha, K.H. (1990) "C Language for Finite Element Programming", Comp. and Structures
Vol.37 No.5 pp.873-88012 Power, H. and L.C. Wrobel (1995) "Boundary Element Methods in Fluid Mechanics",
