Getting Started

Pymake can be used directly from the command line and within a python script. Examples of both use cases are given below.

Command Line Usage

When pymake is installed, a mfpymake (or mfpymake.exe for Windows) program is installed. mfpymake can be used to compile MODFLOW 6 in the bin/ subdirectory directly from the command line using the Intel Fortran compiler from a subdirectory at the same level as the src subdirectory by specifying:

mfpymake src/ mf6 -mc --subdirs -fc ifort --appdir bin

MODFLOW 6 would be To see help for running from command line, use the following statement.

mfpymake -h

The help message identifies required positional arguments and optional arguments that can be provided to override default values.

usage: mfpymake [-h] [-fc FC] [-cc CC] [-mc] [-dbl] [-dbg] [-sd] [-ff FFLAGS] [-cf CFLAGS]
                [-sl {-lc,-lm}] [-mf] [-dr] [-mfo] [-md MAKEFILEDIR] [-cs COMMONSRC]
                [-ef EXTRAFILES] [-exf EXCLUDEFILES] [-so] [-ad APPDIR] [-v] [--keep] [--zip ZIP]
                [--inplace] [--mesondir MESONDIR]
                srcdir target

This is the pymake program for building fortran, c, and c++ source
files, such as the source files that come with MODFLOW. The program
builds a target with the meson build system, using the build file the
target provides where there is one and writing one from the source
files it finds where there is not. A GNU makefile can be written for
the target as well, or instead of building it.

positional arguments:
  srcdir                Path source directory.
  target                Name of target to create. (can include path)

options:
  -h, --help            show this help message and exit
  -fc FC                Fortran compiler to use. A version suffix, for example gfortran-13, can be
                        included. Valid compilers are ifort, mpiifort, gfortran, and none.
                        (default is gfortran)
  -cc CC                C/C++ compiler to use. A version suffix, for example gcc-13, can be
                        included. Valid compilers are gcc, clang, clang++, icc, icl, mpiicc, g++,
                        cl, and none. (default is gcc)
  -mc, --makeclean      Clean temporary object, module, and source files when done. (default is
                        False)
  -dbl, --double        Force double precision. (default is False)
  -dbg, --debug         Create debug version. (default is False)
  -sd, --subdirs        Include source files in srcdir subdirectories. (default is None)
  -ff, --fflags FFLAGS  Additional Fortran compiler flags. Fortran compiler flags should be
                        enclosed in quotes and start with a blank space or separated from the name
                        (-ff or --fflags) with a equal sign (-ff='-O3'). (default is None)
  -cf, --cflags CFLAGS  Additional C/C++ compiler flags. C/C++ compiler flags should be enclosed
                        in quotes and start with a blank space or separated from the name (-cf or
                        --cflags) with a equal sign (-cf='-O3'). (default is None)
  -sl, --syslibs {-lc,-lm}
                        Linker system libraries. Linker libraries should be enclosed in quotes and
                        start with a blank space or separated from the name (-sl or --syslibs)
                        with a equal sign (-sl='-libgcc'). (default is None)
  -mf, --makefile       Create a GNU make makefile. (default is False)
  -dr, --dryrun         Deprecated name for --makefile-only, which replaced it when the pymake
                        build engine was removed. (default is False)
  -mfo, --makefile-only
                        Create a GNU make makefile without building the target. (default is False)
  -md, --makefiledir MAKEFILEDIR
                        GNU make makefile directory. (default is '.')
  -cs, --commonsrc COMMONSRC
                        Additional directory with common source files. (default is None)
  -ef, --extrafiles EXTRAFILES
                        List of extra source files to include in the compilation. extrafiles can
                        be either a list of files or the name of a text file that contains a list
                        of files. (default is None)
  -exf, --excludefiles EXCLUDEFILES
                        List of extra source files to exclude from the compilation. excludefiles
                        can be either a list of files or the name of a text file that contains a
                        list of files. (default is None)
  -so, --sharedobject   Create shared object or dll on Windows. (default is False)
  -ad, --appdir APPDIR  Target path that overrides path defined target path (default is None)
  -v, --verbose         Verbose output to terminal. (default is False)
  --keep                Keep existing executable. (default is False)
  --zip ZIP             Zip built executable. (default is None)
  --inplace             Source files in srcdir are used directly. (default is False)
  --mesondir MESONDIR   meson directory. (default is the directory the target is downloaded to)

Note that the source directory should not contain any bad
or duplicate source files as all source files in the source
directory, the common source file directory (srcdir2), and
the extra files (extrafiles) will be built and linked.
Files can be excluded by using the excludefiles command
line switch.

Examples:

Compile MODFLOW 6 from the root directory containing the
source files in subdirectories in the src/ subdirectory:

$ mfpymake src/ mf6 --subdirs

Compile MODFLOW 6 in the bin subdirectory using the Intel
Fortran compiler from the root directory containing the source
files in subdirectories in the the src/ subdirectory:

$ mfpymake src/ mf6 --subdirs -fc ifort --appdir bin

Note that command line arguments for Fortran flags, C/C++ flags, and syslib libraries should be enclosed in quotes and start with a space prior to the first value (-ff ' -O3') or use an equal sign separating the command line argument and the values (-ff='-O3'). The command line argument to use an -O3 optimization level when compiling MODFLOW 6 in the bin/ subdirectory with the Intel Fortran compiler would be:

mfpymake ../src/ mf6 -mc --subdirs -fc ifort -ff='-O3' --appdir bin

From Python

Script to compile MODFLOW 6

When using the pymake object (Pymake()) only the positional arguments (srcdir, target) need to be specified in the script.

import pymake

pm = pymake.Pymake()
pm.srcdir = "../src"
pm.target = "mf6"
pm.include_subdirs = True
pm.build()

It is suggested that optional variables required for successful compiling and linking be manually specified in the script to mininimize the potential for unsuccessful builds. For MODFLOW 6, subdirectories in the src subdirectory need to be included and ‘pm.include_subdirs = True’ has been specified in the script. Custom optimization levels and compiler flags could be specified to get consistent builds.

Non-default values for the optional arguments can specified as command line arguments. For example, MODFLOW 6 could be compiled using Intel compilers instead of the default GNU compilers with the script listed above by specifying:

python mymf6script.py -fc ifort -cc icc

Notes

If gfortran is used to compile MODFLOW-based codes, the openspec.f and FILESPEC.inc (MT3DMS) files will automatically be changed to the following so that binary files are created properly using standard Fortran:

c -- created by pymake_base.py
      CHARACTER*20 ACCESS,FORM,ACTION(2)
      DATA ACCESS/'STREAM'/
      DATA FORM/'UNFORMATTED'/
      DATA (ACTION(I),I=1,2)/'READ','READWRITE'/
c -- end of include file

Use of STREAM access does not delete an existing unformatted file before opening it for writing. As a result, data from previous runs may exist in the file if the model is run for a shorter period of time. This does not apply to MODFLOW 6 simulations.