Configuring PETSc and Eclipse Parallel Tools Platform (PTP) on macOS and Linux (C++ / Fortran)

The PETSc (Portable, Extensible Toolkit for Scientific Computation) framework provides high-performance data structures, sparse matrix operations, and scalable linear/nonlinear solvers for finite element and scientific modeling. Setting up PETSc within the Eclipse Parallel Tools Platform (PTP) IDE simplifies debugging and cross-compilation across macOS and Linux.

Platforms Verified: macOS Yosemite • Ubuntu 14.04 LTS • CentOS / RHEL (OpenMPI) • C++ and Fortran Compilers

1. Building PETSc with OpenMPI

Configure PETSc with shared libraries and debugging enabled:

./configure --with-shared-libraries=1 --with-debugging=1 PETSC_ARCH=debug
make PETSC_DIR=/path/to/petsc PETSC_ARCH=debug all
make PETSC_DIR=/path/to/petsc PETSC_ARCH=debug test

2. Eclipse Project Configuration

1. Environment Variables: In Project Properties → C/C++ Build → Environment, add:
   • PETSC_DIR: Absolute path to your PETSc root directory.
   • PETSC_ARCH: Set to debug for Debug configurations and release for Release.
2. Include Paths: Under C/C++ General → Paths and Symbols → Includes:

   ${PETSC_DIR}/include
   ${PETSC_DIR}/${PETSC_ARCH}/include

3. Linker Libraries & Path: Under C/C++ Build → Settings → Linker:
   • Libraries (-l): Add petsc
   • Library search path (-L): Add ${PETSC_DIR}/${PETSC_ARCH}/lib
   • Miscellaneous Linker flags: Add runtime path binding:

     -Wl,-rpath,"${PETSC_DIR}/${PETSC_ARCH}/lib"

4. Fortran Preprocessing Flags: If using gfortran, navigate to Fortran Build → Settings → Miscellaneous and add:

   -cpp -dM

3. Verification Test (C++)

#include <iostream>
#include "petsc.h"

int main(int argc, char *argv[]) {
    PetscInitialize(&argc, &argv, PETSC_NULL, PETSC_NULL);
    PetscPrintf(PETSC_COMM_WORLD, "PETSc successfully initialized in Eclipse!
");
    PetscFinalize();
    return 0;
}

Essential Fortran Tips: Implicit Typing, Common Blocks, and Array Bounds

When developing or maintaining scientific simulation and finite-element codes in Fortran, understanding memory sharing semantics and legacy typing rules prevents subtle computational bugs. Here are key fundamental tips to keep in mind:

Topics: Implicit precision typing • Common block limits • Explicit bounds declarations

1. Implicit Typing and Precision Control

By default in classic Fortran, variables starting with letters I through N default to integer, while all others default to single-precision real. You can enforce double precision across designated variable prefixes using:

IMPLICIT DOUBLE PRECISION (A-H, O-Z)

Modern recommendation: In Fortran 90 and newer, always specify IMPLICIT NONE at the top of every module and subroutine, explicitly declaring types and kinds (e.g. REAL(dp)) to avoid unintended variable scoping.

2. Blank vs. Named COMMON Blocks

• A Fortran program may contain only one blank (unnamed) COMMON block across all translation units.
• A program can declare any number of named COMMON blocks:

  COMMON /grid_params/ nx, ny, deltax, deltay

• Ensure that variable sizes and ordering within named COMMON blocks match identically across all subroutines that include them.

CFD: Generating Non-Uniform 2D Rectangular Grid Meshes in Fortran

In Computational Fluid Dynamics (CFD), resolving boundary layers and high-gradient shear regions requires non-uniform grid clustering near solid walls while keeping cell counts manageable in free-stream regions. Here is a Fortran routine to generate a geometrically stretched, symmetric 2D rectangular grid.

Domain: Rectangular 2D domain \([a, b] imes [c, d]\) • Method: Geometric progression expansion clustering toward boundaries

Mathematical Formulation

Given domain limits \(x \in [a, b]\) with \(n_x\) divisions and expansion ratio \(r_x\), the initial wall-adjacent step size \(\eta_x\) is computed from the geometric sum across the symmetric half-domain:

eta_x = (b - a) * (1 - exp_x) / (2 * (1 - exp_x**(n_x / 2)))
eta_y = (d - c) * (1 - exp_y) / (2 * (1 - exp_y**(n_y / 2)))

Fortran Source Code

! ====================================================================
! 2D Non-Uniform Symmetric Rectangular Grid Generator
! ====================================================================
      exp_x = 1.05   ! x-axis expansion factor
      exp_y = 1.10   ! y-axis expansion factor

      a = 0.0
      b = 1.0
      c = 0.0
      d = 1.0

! Uniform step sizes for reference
      del_x = (b - a) / n_x
      del_y = (d - c) / n_y

! Compute first wall-adjacent step sizes (eta_x, eta_y)
      eta_x = (b - a) * (1.0 - exp_x) / (2.0 * (1.0 - exp_x**(n_x / 2)))
      eta_y = (d - c) * (1.0 - exp_y) / (2.0 * (1.0 - exp_y**(n_y / 2)))

      x(1) = a
      y(1) = c

! --- X-Direction Mesh Generation ---
! Half 1: Wall to Center (Expanding)
      DO i = 2, n_x / 2 + 1
          x(i) = x(i - 1) + eta_x * exp_x**(i - 2)
      END DO

! Half 2: Center to Opposite Wall (Contracting)
      DO i = n_x / 2 + 2, n_x + 1
          x(i) = x(i - 1) + eta_x * exp_x**(n_x + 1 - i)
      END DO

! --- Y-Direction Mesh Generation ---
! Half 1: Wall to Center (Expanding)
      DO j = 2, n_y / 2 + 1
          y(j) = y(j - 1) + eta_y * exp_y**(j - 2)
      END DO

! Half 2: Center to Opposite Wall (Contracting)
      DO j = n_y / 2 + 2, n_y + 1
          y(j) = y(j - 1) + eta_y * exp_y**(n_y + 1 - j)
      END DO
! ====================================================================