My Work

[PhD] [OO & C++] [Tools] [Pra//ab] [Molecular Dynamics] [Diploma] [Gallery] [Info.Project]

PhD

Alanin 66 atoms

I started 1. January 1999 a PhD in Development, Analysis and Implementation of Parallel Algorithms for Scientific Computing at the Department of Informatics, University of Bergen. The first year consisted mostly of lab work (SISCI, FRONTIER) at Para//ab and defended my thesis November 6, 2002:

Framework Design, Parallelization and Force Computation in Molecular Dynamics, 2002 (PS|PDF)

The first part of the thesis is concerned with the optimization and extension of the particular MD prototype SPRINGS developed by Jan Petter Hansen. This work was carried out to get some valuable insight information about MD simulations and requirements from MD application users. SPRINGS is also used to investigate parallelization schemes for MD applications, especially the usage of new features of the MPI-2 standard, e.g., the one-sided communication mechanism.

The second and main part of the thesis consists of the design and development of a multi-purpose framework for MD applications, with emphasis on design and implementation of force algorithms. The requirements to a novel MD framework were motivated by the knowledge of MD obtained in the first part and the evaluation of advantages and drawbacks of existing MD programs. The main goal was to develop a flexible, extendable MD research platform, neither excluding run-time efficiency nor parallelism. The design of the framework and its implementation ProtoMol were realized in collaboration with J.A. Izaguirre and his students. Furthermore, some design aspects were introduced from previous work with the object- and component-oriented graphics framework BOOGA.

Advisor: Petter E. Bjørstad
Co-Advisor: Jan Petter Hansen, J.A. Izaguirre

ProtoMol

Summer 2000 I started a collaboration with J.A. Izaguirre at the University of Notre Dame to develop at object-oriented component based framework for Molecular Dynamics -- called ProtoMol. Based on this framework we developed novel (parallel) multilevel algorithms for fast electrostatics force computation using periodic and non-periodic boundary conditions.

ProtoMol is an object-oriented component based framework for molecular dynamics simulations. The framework supports the CHARMM 19 and 28a2 force fields and is able to process PDB, PSF, XYZ and DCD trajectory files. It is designed for high flexibility, easy extendibility and maintenance, and high performance demands, including parallelization. The technique of multiple time-stepping has been used to improve long-term efficiency, and the use of fast electrostatic force evaluation algorithms like plain Ewald , Particle Mesh Ewald , and Multigrid summation further improves performance. Longer time steps are possible using MOLLY, Langevin Molly and Hybrid Monte Carlo , Nose-Hoover, and Langevin integrators. In addition, ProtoMol has been designed to interact with VMD, a visualization engine developed by the University of Illinois that is used for displaying large biomolecular systems in three dimensions. ProtoMol is free distributed software, and the source code will be included.

As a core-developer I'm also in charge to survey the development of the framework ProtoMol giving OO-design and C++ advises to contributions.

Alanin

Water 423

BPTI (with Water)

Two Droplets

7 Spheres

ApoA1 (no Water)

Links: Notre Dame, CSE at Notre Dame, LCLS group, ProtoMol.


OO & C++

Links

  • SGI - Services & Support: Standard Template Library Programmer's Guide
  • Dinkum C++ Library
  • Stroustrup: C++
  • C++ User's Guide: 3 - Templates
  • Techniques for Scientific C++
  • GotW.ca Home Page
  • Programmers Heaven - C / C++ / C# Zone
  • thefreecountry.com: Free C/C++ Libraries and Source Code
  • C and C++ Style Guides
  • Code Cuts - Thinking in C++
  • object oriented programming OOP - Webopedia.com
  • Joseph M. Orost
  • Rational Software
  • C/C++ Program Perfometer - c, c++, c__
  • Coyote Gulch Productions - Algorithmic Conjurings - Beyond Assert
  • Doxygen
  • Using the MS Visual C++ Compiler with GNU/Wine
  • Short C++ Examples

    Vector


    Tools


    Para//ab

    During 1998 and as part of my PhD.-program I worked for Para//ab, the High Performance Computing Center at the University of Bergen, for several projects (SISCI, PARASOL, FRONTIER).
    The national high performance computational envirionment established in the NOTUR programme shall create scientific and technological innovations in the Norwegian society.

    The vision encompass the establishment of a national infrastructure for high-performance computing (HPC), with a leading edge computer system at NTNU and several alternative systems at the Universities in Oslo, Bergen, and Tromsų.

    The TTP5 is a cooperative project including scientists from UiB, NTNU and UiT. The project goal is to publish algorithms and programs connected to the most fundamental computational techniques of nano scientific origin.
    PARASOL is a long term research ESPRIT IV project (Domain 4, Task 4.2) which started on January 1st, 1996 and will last 3 years.
    Within the project new parallel algorithms for the direct solution of sparse systems of linear equations, for the iterative solution of such systems based on either multigrid or domain decomposition and for their preconditioning will be developed. These algorithms will be available in the public domain.
    FRONTIER is an ESPRIT IV project funded by the European Commission. It is concerned with multi-partnered collaborative design optimization. This is a key area for future European industrial competitiveness, which requires leading edge capabilities to improve design whilst significantly reducing costs and time to market.
    FRONTIER will utilize state of the art HPCN capabilities and will directly employ software which has resulted from previous HPCN projects under ESPRIT III. The project will also employ state of the art optimization technology, providing major advances in probabilistic and hybrid algorithms.
    The SISCI project addresses the need of HPCN applications for inexpensive and powerful parallel distributed execution platforms. While such hardware is becoming available from different vendors in form of workstation and PC clusters with fast interconnects, standard software support for parallel processing on these platforms is missing. SISCI is addressing workstation- and PC clusters connected by the SCI technology.


    Molecular Dynamics Calculation

    Autumn 1997
    Jan Petter Hansen and I started to develop a MD-simulation program (Molecular Dynamics) (Fortran 77, C/C++, X11) at Bergen (UiB) and in Karmoey (Norsk Hydro) to study the extrusion of aluminum.
    SPRINGS is based on short range potential interactions (Lennard-Jones) between particles. Our implementations does a spatial decomposition using the cell algorithm to achieve (nearly) linear time complexity. We implemented and successfully tested a fully distributed parallel version using MPI. The distribution of data uses MPI-2 one-sided communication to avoid synchronization. Performance results were presented at the Para2000 Conference in Bergen.


    Master's thesis (6.6.96 - 6.19.97): 'Objektorientierte Gebäudemodellierung' (An object-oriented modelling approach)

    Abstract

    The thesis presents an object-oriented approach for describing and modelling buildings by means of computer graphics. The approach is based on an object- and component-oriented graphics framework (BOOGA). Scenes of buildings are conventionally modelled by a set of primitives and some aggregates. The present approach, however, uses highly abstract objects which represent certain parts of real buildings. These objects form together a high-level hierarchical construction set and are responsible for providing decompositions into primitives where necessary. Dependencies and side effects are handled by the abstract objects themselves. First results show that the new approach leads to simple and flexible representations without losing the broadness necessary to describe real buildings. However, as its main application domain is urban planning, it does not attempt complete photorealism.

    Fig. 4: A pruned representation of a simple house.

    An Example

    The following short example shows the construction of a simple house. It is meant to illustrate how an implementation based on our approach can be used to model buildings in practice. In particular, it should indicate the simplicity as well as some of the potential of our approach. The scene, i.e. the house, is specified in BSDL (BOOGA Scene Description Language) which is similar to the specification language of RayShade.
    In a first step we define the base and the height of the desired house by means of the abstract object , which is the base and container of the whole building. By default the object (with no subobjects) creates only the walls (Figure 5). Then the geometry of the fronts is defined, i.e. we add front objects as subobjects. We define a flattened ridge with by additional points [0.3,1.25] and [0.7,1.25], which are relative to the actual default front (Figure 6). For the sides we use rectangular fronts with the same size as the one of the actual default front.
    // Geometry of the house
    // (height, vertex, vertex,...)
    building (20,[-10,-20, 0],[ 10,-20, 0],[ 10, 20, 0],[-10, 20, 0]){
      rock;  // Default texture of the house
      fronttri(0,0,[0.3,1.25],[0.7,1.25]);  // Back front
      frontrect(1,0,0,1);                   // Left front
      fronttri(2,0,[0.3,1.25],[0.7,1.25]);  // Front front
      frontrect(3,0,0,1);                   // Right front
    }
    
    Figure 5: Empty (default-)building.
    Figure 6: House with fronts.

    In a second step, the roof and a simple chimney are defined. For the roof we choose one which covers the whole base of the building and allows additional roof points. To get a more realistic result, a roof is modelled with a horizontal distance ledge by which the roof overhangs the base. The chimney is defined by two boxes and placed properly in the z-direction onto the roof using (Figure 7).

    building (20,[-10,-20, 0],[ 10,-20, 0],[ 10, 20, 0],[-10, 20, 0]){
      ...
      // (ledge, point, point,...)
      roofpoint(2,[0, 17,7.5],[0, 17,7.5]) {redroof;}
      snatch([5,6]){chimney;}   // The chimney at [5,6,z]
    }
    
    In a last step, we model a door and the windows, which depend on their parent fronts using objects (Figure 7). To place them onto the fronts, we use which allows a to generate copies of a given object and aling them. Additionally, we displace the copies relatively and cut out a suitable hole. The following description models the front of the house with a door and three windows. The other sides are modelled similarly.
      fronttri(2,0,[.3,1.25],[.7,1.25]){  // Front front
        \\ (from, to, column, row)
        faceitem([0,0.5],[1,1],2,1){ // 2. storey with two windows
          window;  // Window
          hole;  // Hole for the window
          displacement[0.5,0.4]; // Relative displacement of the window
        }
        faceitem([0,0],[1,0.5],1,1){  // 1. storey with a door
          hole;
          door;
          displacement[0.5,0];
        }
        faceitem([0.3,1],[.7,1.3],1,1){ // Top window
          windowSmall;
          hole;
          displacement[0.5,0.3];
        }
      }
    
    To refine the house, we attach a border between the two stories using . Figure 8 shows the final result. The representation of this scene is similar to that in Figure 4.
      // (ledge, borderwidth, borderheight, borderdepth)
      bottomborder(0.5,0.5,0.5,0.1){
        height(9); // Elevation from the base of the house
      }
    

    Figure 7: House with roof and chimney.
    Figure 8: The final house.

    Definition of a building

    Our abstract objects form together a hierarchic construction set. There are two main types of abstract objects. One object has the role of a root and represents the (initial) empty building. It defines only the basic geometry, i.e. base and height, and serves as a container for the other objects (class BuildingObject), which refine the building. The base of a building is always given by a polygon, possibly with holes that define inner courts. For a given height a default building is defined. It consist only of the walls of an extruded polygon (Fig. 1).

    Figure 1: Definition of a default building.

    Gallery

    The old part of Berne (Altstadt von Bern, Neuengasse 36) was generated from a digital orienteering map and was simplified with OCAD. The terrain was extracted from the digital map and the building were placed automaticly onto the terrain. The buildigs are definied only by the base and a simple roof.

    Department of Informatics, University of Berne.

    Department of Informatics, University of Bergen. The picture 1200x800, oversampling = 2, whitted was raytraced on the Origin 2000 using 16 nodes in 271.4[s].

    Texturing polygons

    Texturemapping using PolygonMapper.

    Texturemapping using PolygonMapper with reflections.

    Informatikprojekt (11.11.95 - 5.10.96): 'Computer-Animation für BOOGA'

    windmill.mpg
    MPEGe Lib 1.0 by Axel Knowles. MPEGe lib is a library designed to allow you to create MPEG movies from your application. It is really easy to use and hides a lot of the complexities of MPEG streams from the user (although lots of options are available to be changed).
    This short animation shows the new Morph3D BOOGA animation object, which interpolates to primitives or to lists containing primitives. Texture and transformation are also interpolated.


    Last update: . Back to Home Page