Abstract

A parallel reservoir simulation system is described. The basic algorithm allows masses or saturations to be used to define the state of the reservoir. The parallel structure and the way in which data is moved for computation and input/output is described. For good parallel performance the workload needs to be balanced between the processors when the simulation is running. However, in most practical cases the majority of cells are inactive, inactive cells being identified during the preliminary grid calculations. These also need to be distributed, to avoid a memory peak which would limit the maximum problem size. A method for re-factoring the simulation between the processors to avoid this is detailed.

The need to use modern object-orientated coding methods and obtain good numerical performance in parallel processors leads to the use of C++ and MPI for the core solver. A simple class structure which has proved effective for simulation code development is described.

For the supporting system there are requirements of portability and efficiency. Portability because simulation data is normally prepared and viewed on a different machine from that on which the simulation is run. Efficiency is important in the transfer of data between machines and when displaying large models in three dimensions. A Java based code has proved highly effective in meeting these requirements.

Traditionally, simulator input has taken the form of a keyword orientated text file. Modern users expect a more visual interface to their data. A system is described which combines the virtues of both approaches, being based on a set of tables and grid arrays. Data may entered and viewed flexibly, but the advantages of a formatted file are retained. Problems of the migration of legacy data to such new systems are considered, with possible solutions.

1. Introduction

This paper discusses some of the computational aspects of reservoir simulation. FORTRAN codes with batch input decks have been very successful as the basis of many simulators. FORTRAN is efficient and readily understood. The move to object orientated languages such as C++ should yield advantages in program construction. In the same way, modern user interfaces in languages like Java should allow a more flexible method of interaction with data than keyword by keyword modification.

The work described concerns the upgrading of an originally compositional simulator, MORE, (ref. 1) written in FORTRAN to an object orientated code in C++ within a new simulation system, referred to as Tempest. In the process new linear solvers, distributed parallelism and an optional new underlying set of solution variables were introduced. A new user interface was written in Java: this has major portability advantages and has proved very efficient. The presentation of the data as a set of elementary events is described: this makes machine filtering and flexible data presentation possible.

This content is only available via PDF.
You can access this article if you purchase or spend a download.