a general−purpose interactive simulation system

Alexandru Telea Fac. Wiskunde en Informatica

To Implementation

A General−Purpose InteractiveSimulation System

The Design Path From Specifications

Alexandru Telea

Fac. Wiskunde en Informatica

To An Object−Oriented Implementation


Presentation Top−Down Overview:

Interactive General−purpose

Goal: general−purpose, interactive simulation system

Simulation system

Laws Objects

OO Specification

C++ Specification

Steering

Modelling

Visualization

Extensible

OO Design

Generic

SubclassingInteractors

OO Interface

TheDependencyGraph

New ClassesClasses Ports


The Simulation System Concept:

(as compared to the imperative programming concept)

LawsObjectsA Simulation = +

Laws

Objects State variables=

An object groups related state variablesand treats them as an entity.

Example: a point, a vector, a field,a time−dependent PDE

Inter−object

Intra−object

Express constraintsbetween objects.

Express constraintsbetween state variablesof the same object.


The Interactivity Concept:

(as compared to the offline simulation concept)

Steering

Modelling

Visualization

Geometrical and physical problem modelling.

Geometries, scientificdata, animation.

Control a running simulation.

Interactivity


From Objects and Laws to Classes:

From the abstract object and law concepts we derive theconcrete OO (C++) implementation concepts:

Laws

Objects State variables

Intra−object laws

Inter−object laws

A C++ Class

C++ Class Ports

methods

data members

Overall: We implement objects and intra−object laws by C++ classes (data members and methods).

We implement inter−object laws by C++ class ports.


OO Modelling: Objects and Laws

Reasons for using OO modelling and C++:

Objects and laws map directlyon the (C++) class concept

Collections of objects and laws map directly on the (C++) class library concept

Objects

Laws

Class Concept

Class 1

Class 2

. . . . .

Class n

Class Library


The Class Library:

Is the central concept of reusing OO design.

A class library is a set of cooperating classes.

Class Library

Implement a set of concepts

Use a set of concepts

Users

Implementation

Interface

Developers


The Class:

Is the central concept of a class library.

A class groups together data and functions.

print()

read()

write()

compute()write(){

... do something with the data members ...

}

int a;float b,c;POINT p;

a b

c

CLASS

Class Interface

Class Implementation


Designing A Class:

Main rule of OO design:

✂

Interface

Implementation

separate design of interface from

design of implementation

separationlevel

Advantages:

✒ implementation changes don’t affect users

✒ minimize code rewriting and recompilation

✒ users program in terms of interfaces and NOT implementations

✂


Class Concepts: Encapsulation

Basic tool for hiding implementation details:

class A{public:

compute();private:

int a,b;}

user accessible

hidden to user

print()

read()compute()

a b

c

CLASS

Class Interface

Class Implementation

public part:

accessible to allusers

private part:

accessible onlyto developers

write()


Class Concepts: Inheritance

Powerful tool for code reuse and class specialization:

✒ implement a class in terms of other classes

code reuse

✒ add new features to an existing class

class specialization

B inherits from A

C inherits from B,D

class B : A{ ...}

class C : B,D{ ...}

A

BA

C

B D


Class Concepts: Inheritance (cont.)

Inheritance creates class hierarchies

(directed acyclic graphs of classes):

A

B

C D

E

base class

single inheritance (SI)

multiple inheritance (MI)

virtual inheritance (VI)


Class Concepts: Polymorphism

Is the key concept to extensible software:

Example: a class hierarchy of graphic shapes

?

A

ABC

concreteclasses

Shape

Rect

RectTxt RectMark

Ellipse Text

abstract class

}


Class and Object Relationships:

Classes and objects can participate in relationships:

has−a: a class A has−a B if B is a member of A.

is−a: a class A is−a B if A is derived from B.

uses−a: a class A uses−a B if it has a B* member(a pointer−to−B member)

A

B

is−a

Ahas−a

B bC cD dint func()

A

uses−aBB* ptr


Class Ports:

Classes are provided with ports to establish inter−classrelationships:

Example of inter−class constraints:

C1 :: d = C3 :: foo2

C1 :: b = C2 :: mem

Class C1

B b

C c

D d

Class C2

B mem

X foo

Y bar

Class C3

D foo2

N my_np o r t s l i n k


The Dependency Graph:

a g

e

d

c

b

f

Inter−class constraints establish a dependency graphat simulation level.

Example: having the following constraints between objects a,b,c,d,e,f:

b = f1(a) d = f2(b) e = f3(d) c = f4(a) f = f5(c) g = f6(c,f)

we obtain the equivalent dependency graph:


The Dependency Mechanism:

We create a constraint specification and management systemover the C++ simulation classes.

Constraint specification is done by ports.

Ports:

✒ are typed entities representing state parameters.✒ are attached to classes.✒ use class’s parameter read/write methods.✒ constraints are specified connecting ports of compatible types:

A

uses−aBB* ptr

A B

OutPort(type B*)

InPort(type B*)

connection

B

X aX has−a"B’s X = A’s X"

A

Xhas−aX a

A

Xhas−aX a

B

X aX has−a

OutPort(type X)

InPort(type X)

connection


Interactivity:

Interactivity The Dependency Graph

Direct Manipulation

The Class Interactors

Visualization

Interactivity has the following components:

✒ building the dependency graph ✒ object manipulation via

class interactors

✒ direct manipulation via cameras (OpenInventor)

✒ visualization via cameras(OpenGL, OpenInventor)


Building the Dependency Graph:The user can explicitly establish data dependencies byconnecting/disconnecting ports:

connection

"Domain"(G_DOMAIN*)

tddom

"This"(G_DOMAIN*)


Class Interactors: In order to interact with a class object, the system provides interactors.

Interactors:

✒ are GUI representations of classes.✒ allow reading/writing class members and calling class methods via GUI widgets.

object name

objectmethod

object ’has−a’ read/write member

object ’uses−a’members

object’has−a’read only members

object class type

object ports


Class Interactors(cont.):

✒ The ’uses−a’ relations established by interactors are automatically translated into explicit (by reference)

dependencies.

✒ A run−time type information (RTTI) component is used to check if dependencies are established between objects of the correct type.

✒ Class hierarchies are paralleled by interactor hierarchies:

✒ Class hierarchies are designed completely independent on interactor hierarchies (one−way loose coupling)

is−a

A_int

B_int

C_int D_int

E_int

A

B

is−a

C D

E

Class Hierarchy Interactor Hierarchy

uses−a


Simulation System Overview:

Legend:

System functional components (managers) Simulation specification (data) Simulation class libraries (problem−specific classes) Class interactor libraries (for the simulation classes)

A

B

C

DObject manager

Dependency manager

Interaction manager

Run manager

Simulation description (dependency graph)

ObjectsDependencies

Class libraries Class interactors


The General−Purpose Concept:

General−purpose Extensible

Generic

A general−purpose simulation system should easilyaccomodate applications coming from various scientific domains.

Easy introduction of newdomain−specific classes

A set of classes for generaluse in scientific simulationand visualization should beavailable


Visualization:

Here is an example of visualization using an OpenInventor−based camera:

a general−purpose interactive simulation system

Documents