Makefile

Go to the documentation of this file.

#-------------------------------------------------------------------------------
# SVN version info:
# $Id: Makefile 11235 2021-06-08 12:38:54Z sbu062 $
# Build model automatically generating include files for PRNG and IEEE
# author Sergey Budaev <sbudaev@gmail.com>
#-------------------------------------------------------------------------------
##//! @file Makefile GNU Make build configuration.
##//! @brief Makefile to build the model executable from the source code.
##//! @details This is a standard GNU Make "Makefile" to build the model from
##//!          the sources. It also automatically generates some platform and
##//!          compiler specific include files for the `BASE_RANDOM` and the
##//!          IEEE math modules. See @ref intro_main "Working with the model"
##//!          section and the @ref README.md for details.
##//!
##//! ### Dependencies ###
##//! In addition to the GNU Make, this Makefile also depends on the
##//! `grep`, `cut`, `sed` and `awk` utilities that are installed on any
##//! Unix/Linux system, but usually absent on Windows. For Windows
##//! they can be obtained from several locations on the web, e.g.
##//! Cygwin or GnuWin32. See http://ahamodel.uib.no/doc/ar01s01.html for
##//! more information.
##//!
##//! ### Main adjustable parameters ###
##//! @param FC sets the default compiler type from the above. Normally GNU
##//!        gfortran.
##//! @param HOST_HPC_ROOT is the hostname to run the model executable in the
##//!        HPC batch mode. If the hostname the Makefile is called in is this
##//!        system, `make run` starts a new batch task. Otherwise, the model
##//!        executable is just started normally.
##//! @param SRC is the name of the main source code (can be several files).
##//! @param DRV is the source code of the model "driver", that is the main
##//!        Fortran program that produces the executable. It should be very
##//!        very small. The "driver" is a separate file from the AHA Model
##//!        modules.
##//! @param OUT is the executable file name that is actually run, on the
##//!        Windows platform must have the `.exe` suffix. By default, the
##//!        executable name is set to `MODEL.exe` for maximum portability.
##//! @param DOXYCFG the Doxygen documentation system configuration file name.
##//! @param DOXYPATH defines the Doxygen output directory where the
##//!        documentation is generated. This could be set manually or parsed
##//!        automatically using the `grep` command. Note that the output
##//!        directory is set in the `Doxyfile` as:
##//!        `OUTPUT_DIRECTORY = ./model_docs`.
##//! @param HEDTOOLS is the list of HEDTOOLS Fortran source files that are
##//!        used in the AHA Model. Note that `BASE_STRINGS` in the list must
##//!        go before `BASE_CSV_IO` because `BASE_CSV_IO` depends on
##//!        procedures from `BASE_STRINGS`.
##//! @param HEDTOOLSDIR defines the path to the HEDTOOLS source code.
##//! @param IEEEPATH defines the path to the IEEE non-intrinsic math modules
##//!        (part of HEDTOOLS).
##//! @param WINRM defines the command that is used to delete files and
##//!        directories on the Windows platform; can be set either `del` or
##//!        `rm`.
##//! @note  The native file delete command on the Windows platform is 'del' or
##//!        'erase'. However, if Cygwin is used, this native file removal
##//!        command may not call with a "command not found" error. In such a
##//!        case, use the Unix 'rm' tool provided by Cygwin.
##//!
##//! The source code of the @ref Makefile contains many other parameters and
##//! is well documented throughout.
##//! @cond
#  Doxygen note: block marked with cond .. endcond is excluded from Doxygen
#                processing. Therefore, everything below to the end of the
#                Makefile is not parsed. Makefile is not normally supported
#                by Doxygen.
 
#===============================================================================
 
# Supported Fortran compiler types
GF_FC = gfortran
IF_FC = ifort
SF_FC = f95
 
# Choose the default compiler type
FC = $(GF_FC)
 
# Graphics library to use, for example:
# PGPLOT, if installed by the system:
#   -lpgplot
# If PGPLOT is manually installed by the user into /usr/local/pgplot with
#   X11 development libraries in /usr/lib/x86_64-linux-gnu (as in a
#   Debian system), use this value for GRAPHLIB:
# -L/usr/local/pgplot -L/usr/lib/x86_64-linux-gnu -lpgplot -lX11
# --------------------------------------
# PLPLOT:
#   -lplplotf95d -lplplotf95cd -lplf95demolibd -I/usr/lib/fortran/modules/plplot
GRAPHLIB =
 
# Root of the host name to run in HPC cluster / batch mode, not directly
HOST_HPC_ROOT=fimm
 
# Define what version control system is used, This is a default value used if
# VCS_TYPE is not set from command line of environment variable.
VCS_TYPE ?= SVN
 
#===============================================================================
# Main building blocks, define the main program source, executable name (-o)
# and possible module (.mod) names.
 
# These names should be set for particular project,
# Most probably they should be edited manually for each specific project
# SRC is the name of the main source code (can be several files). Note that
#     Intel fortran doesn't like f95 file extension, use f90
# DRV is the source code of the model "driver", that is the main Fortran
#     program that produces the executable. It should be very very small.
#     The "driver" is a separate file from the modules.
# OUT is the executable file, on the Windows platform has the .exe suffix.
 
SRC = m_common.f90 m_fileio.f90 m_env.f90 m_genome.f90 m_hormon.f90 \
      m_body.f90 m_neuro.f90 m_behav.f90 m_indiv.f90 m_popul.f90 m_evolut.f90
 
DRV = mod_drv.f90
 
OUT = MODEL.exe
 
# Doxygen configuration file within the same directory.
DOXYCFG = Doxyfile
 
# Doxygen output directory, can be grepped from Configuration file.
# OUTPUT_DIRECTORY       = ./model_docs
# DOXYPATH = model_docs
DOXYPATH = $(shell $(GREP) ^OUTPUT_DIRECTORY Doxyfile | $(CUT) -d '=' -f 2)
 
#===============================================================================
# HEDTOOLS sources and module files:
# Warning: BASE_STRINGS must go before BASE_CSV_IO because BASE_CSV_IO now
#          depends on procedures from BASE_STRINGS.
 
HEDTOOLS = BASE_UTILS.f90 BASE_STRINGS.f90 BASE_CSV_IO.f90 BASE_LOGGER.f90 \
           BASE_RANDOM.f90
 
# Path to HEDTOOLS and IEEE non-intrinsic libs (part of HEDTOOLS).
HEDTOOLSDIR = ../HEDTOOLS
IEEEPATH = $(HEDTOOLSDIR)/IEEE
 
# Path to the unit tests using pfUnit framework.
PFUNIT_PATH = pfunit
 
#===============================================================================
# The name of the network server, where the data zip file is pushed by scp
# on `make zipsend` command. The server string must contain the complete
# destination in the scp notation (see `man scp`): [user@]host:]path
# e.g. budaev@bio0215550.klient.uib.no:/cygdrive/d/
# @note Note that the zip file as well as all files having the same root
#       names (including zip extension) are transferred, e.g. `model_1.zip`
#       along with `model_1.zip.md5` `model_1.zip.notes` `model_1.zip.txt`.
 
AHA_STORAGE_SERVER_STR = budaev@bio0215550.klient.uib.no:/cygdrive/d/AHA-ZDATA/
 
#===============================================================================
# Notification command for execution termination
 
AHA_NOTIFY_CMD_WIN = c:\python27\python.exe o:\bin\xsendnc.py sbu062@tegsvn.uib.no 'Model run terminated'
AHA_NOTIFY_CMD_UNIX = xsendnc.py sbu062@tegsvn.uib.no "Model run terminated on `hostname`"
 
#===============================================================================
# Accessory settings for the build environment
 
# The native file delete command on the Windows platform is 'del' or 'erase'.
# However, if Cygwin is used, this native file removal command may not call
# with a "command not found" error. In such a case, use the Unix 'rm' tool
# provided by Cygwin.
WINRM := rm -fr
 
#===============================================================================
# Define compiler options
 
# #### Options for GNU Fortran
# Note: link-time optimisations -flto do not work on Windows, falls with the
#       segmentation fault. On Linux, it builds without any problem, but seems
#       to break the LOGGER module output, it loses the logger unit and log
#       data go to fort.1. More testing is needed, -flto disabled so far.
GF_STATIC = -static-libgfortran -static -static-libgcc
GF_TRAPS = -ffpe-trap=
GF_RCHECKS = -Wall -fbounds-check
# Memory leaks sanitize checks for GCC using libasan, work on Linux and OSX
GF_MEMCHECK = -fsanitize=address -static-libasan
#GF_FFLAGS = $(GF_STATIC) $(GF_TRAPS) $(GF_RCHECKS) -O3
GF_FFLAGS = -O3 -march=native -funroll-loops -fforce-addr $(GF_STATIC)
GF_FFLAGS_WINDOWS = -O3 -funroll-loops -fforce-addr $(GF_STATIC)
#-ffpe-trap=zero,invalid,overflow,underflow
# GC_FFLAGS are for gcc C compiler (C may be used for IEEEs)
GC_FFLAGS = -O3
# On Windows might need  -mwindows
 
# #### Options for Intel Fortran
IF_ANNOTATE = -qopt-report-phase=vec -qopt-report-annotate=html
IF_REPORT_OPT = -qopt-report=3
IF_STATIC = -static
IF_TRAPS = -fpe3
IF_RCHECKS = -gen-interfaces -warn -check bounds,pointers,format,uninit
# Intel Fortran compiler options maximizing speed for the whole program: -fast
#   Linux: -ipo, -O3, -no-prec-div, -static, -fp-model fast=2, and -xHost
# Note: Build with -ipo crashes on building the the $(OBJ) main model target
#   with "Segmentation violation signal raised" (ifort 17.0.4 and earlier,
#   starting at SVN rev. 5010). For this reason, -ipo option is disabled here
#   (therefore -fast would not work either). When only the latest $(OUT)
#   target includes -ipo option, a warning appears
#     ipo: warning #11003: no IR in object file xxx
#   and IPO optimisation should not probably be there either.
#   Update: As to ifort 19.0.4.243 20190416, `IPO` works without `parallel`
# Base option: IF_FFLAGS = -sox -parallel -O3 -ipo
IF_FFLAGS = -sox -O3 -ipo $(IF_STATIC) -heap-arrays -fp-model fast=2 \
            -xHost -finline-functions $(IF_REPORT_OPT) $(IF_ANNOTATE)
# For Intel Fortran, options are somewhat different on Windows platform.
# Note: Windows stack size is insufficient for the large number of concurrent
#       threads and huge arrays used in the model. Therefore, stack overflow
#       error is issued (ifort 17) with the default build options. Stack size
#       available for the program is controlled by the /Fn option (n is in
#       bytes). Setting a huge value resolves the stack overflow issue on the
#       Windows platform. This can sometimes occur on the Linux and Mac OS X
#       platforms too. To fix it on Linux, issue this command:
#           ulimit -s unlimited
#       Increasing stack size on Mac OS X is described here:
#       https://developer.apple.com/library/content/qa/qa1419/_index.html.
#  Base option: /Qsox /Qparallel
 
#  Note: The following worked on W7 but O2 optimization resulted
#        in access violation crash on W10, O1 seems to work on W10
#  IF_FFLAGS_WINDOWS = /Qsox /Qparallel /Ot /static /heap-arrays /fp:fast=2 \
#                    /QxHost /Ob2 /warn /fpe:0 /F100000000
IF_FFLAGS_WINDOWS = /Qsox /O1 /static /heap-arrays /warn /fpe:0 /F100000000
 
#IF_FFLAGS = -sox -fast -parallel $(IF_STATIC) $(IF_TRAPS)
# -fpe3 no traps; -fpe0 all traps
# -O3
# Aggressive optimizations: -fast = -O3 –ipo –static
 
# #### Options for Sun/Oracle Solaris Studio
SF_STATIC = -Bstatic -dn
SF_TRAPS = -ftrap=%none
SF_RCHECKS = -C
SF_FFLAGS = -O1 -depend=yes
# NOTE: optimisations exceeding -O1 might not work with all CSV_IO routines
# SF_FFLAGS = -fast -autopar -depend=yes
# -fast = O5
# -ftrap=common is a macro for -ftrap=invalid,overflow,division.
# -ftrap=%all, %none, common
 
#-------------------------------------------------------------------------------
 
# DEBUG turns off all optimisations and keeps debug symbols. Note that
# SNaNs are initialising all values in case of intel Fortran (-init=snan).
ifdef DEBUG
  GF_FFLAGS = -O0 -g -ffpe-trap=zero,invalid,overflow,underflow \
              -Warray-temporaries $(GF_RCHECKS)
  GF_FFLAGS_WINDOWS = $(GF_FFLAGS)
  IF_FFLAGS = -O0 -heap-arrays -gen-interfaces -g -debug all -fpe0 -traceback \
               -init=snan $(IF_RCHECKS)
  SF_FFLAGS = -O0 -g -ftrap=common
  IF_FFLAGS_WINDOWS = /Qsox /optimize:0 /fpe:0 /heap-arrays /debug:all       \
                      /traceback /Qinit:snan /gen-interfaces /check /warn    \
                      /F100000000
  RUNFLAG = DEBUG
endif
 
# PROFILE adds profiling options (-pg on GNU). Then running the program provides
#    a profiling report: gmon.out. It can be read with: gprof MODEL.exe
ifdef PROFILE
  GF_FFLAGS += -pg
endif
 
#-------------------------------------------------------------------------------
# Set other build options depending on the specific compiler
 
ifeq ($(FC),$(GF_FC))
  FFLAGS = $(GF_FFLAGS)
  STATIC = $(GF_STATIC)
  TRAPS = $(GF_TRAPS)
  RCHECKS = $(GF_RCHECKS)
  CC=gcc
endif
 
ifeq ($(FC),$(IF_FC))
  FFLAGS = $(IF_FFLAGS)
  STATIC = $(IF_STATIC)
  TRAPS = $(IF_TRAPS)
  RCHECKS = $(IF_RCHECKS)
endif
 
ifeq ($(FC),$(SF_FC))
  FFLAGS = $(SF_FFLAGS)
  STATIC = $(SF_STATIC)
  TRAPS = $(SF_TRAPS)
  RCHECKS = $(SF_RCHECKS)
endif
 
#===============================================================================
# Determine what is the build platform, Windows / non-Windows
 
# Use uname -- but it may not be installed on Windows. Probably the method
# based on ComSpec is safer. Note that the -c switch on grep suppresses normal
# output and just prints count.
##PLATFORM = $(shell uname)
##IS_WINDOWS = $(shell uname | grep -ci windows)
 
# A safer way to check platform if uname is not available, ComSpec on Windows
# Note that ComSpec is (may be?) case-sensitive, check with env.exe
# Quirk: - Microsoft Windows echo does not require escaping quotes parentheses
#          and other symbols and outputrs them as is into redirected shell
#          output, e.g. in  $(shell echo "bla bla bla" >> file.txt), i.e
#          file.txt gets "bla bla bla". Linux echo, in contrast deletes the
#          quites, which can create portability problems if a piece of code
#          (e.g. include file) is auto-generated in such a way.
#          One way to ensure identical behaviour on all platforms is to use
#          a third-party echo.exe program from Cygwin, GnuWin32 of Linux
#          subsystem on Windows 10 (WSL).
#        - Windows 10 does not seem to use third-party `echo.exe` (e.g. from
#          GNUwin32 or Linux subsystem if simple echo is referred under shell.
#          This requires redefining ECHO to refer to a specific `exe`
#          explicitly.
ifdef ComSpec
  PLATFORM_TYPE=Windows
  IS_WINDOWS=1
  WHICH_CMD=where
  NULLDEV=":NULL"
  RM := $(WINRM)
  MV := move
  GREP := grep
  CUT := cut
  UNAME := uname
  ECHO := "$(shell $(WHICH_CMD) echo.exe)"
else
  PLATFORM_TYPE=Unix
  IS_WINDOWS=0
  WHICH_CMD=which
  NULLDEV="/dev/null"
  RM := rm -fr
  MV := mv -f
  GREP := grep
  CUT := cut
  UNAME := uname
  ECHO := echo
endif
 
# Check if certain required executables exist and are callable in path. This is
# important on the Windows platform because such GNU command line utilities as
# uname and zip are not installed by default.
REQUIRED_EXECS = zip a2x md5sum ifort f95 gfortran svn $(CUT) $(GREP)
K := $(foreach exec,$(REQUIRED_EXECS),\
  $(if $(shell $(WHICH_CMD) $(exec) ),check executables,\
  $(warning ============ $(exec) unavailable in PATH ============)))
 
# Check if we build on Windows platform with GNU gfortran Compiler. Compiler
# may differ in this case. Notably, GCC -flto option crashes compiler.
# also, memory sanitizer GF_MEMCHECK is disabled on Windows
ifeq ($(PLATFORM_TYPE)$(FC),Windowsgfortran)
  GF_FFLAGS:=$(GF_FFLAGS_WINDOWS)
else
  GF_RCHECKS := $(GF_RCHECKS) $(GF_MEMCHECK)
endif
 
# Check if we build on Windows platform with Intel Compiler. It is specific in
# two ways: (1) build options are different, start with slash and often have Q
# and (2) .obj is used as the extension for object files rather than .o
# here we check if with an emulated AND condition. Do this by simply
# concatenating two things into Windowsifort.
ifeq ($(PLATFORM_TYPE)$(FC),Windowsifort)
  OBJEXT=obj
  OBJ = $(addsuffix .$(OBJEXT), $(basename $(SRC)))
  IF_FFLAGS:=$(IF_FFLAGS_WINDOWS)
else
  OBJEXT=o
  OBJ = $(addsuffix .$(OBJEXT), $(basename $(SRC)))
endif
 
#===============================================================================
# HEDTOOLS object files:
# Warning: BASE_STRINGS must go before BASE_CSV_IO because BASE_CSV_IO now
#          depends on procedures from BASE_STRINGS. This should be set by
#          correct ordering of components in the HEDTOOLS variable.
 
HTOOLOBJ = $(addsuffix .$(OBJEXT), $(basename $(HEDTOOLS)))
 
#===============================================================================
# Generate the list of modules used in the source.
# First, get the list of module calls from the 'use' statements within the
# source code
# NOTE: Make turns $$ into $ in awk call, otherwise it goes empty.
#       The sort GNU make function produces a sorted list deleting duplicates.
MOD_LIST = $(sort $(shell $(GREP) -i "^ *use " $(SRC) | sed -e 's/,//g' | awk '{printf(" %s ",$$2) }'))
 
# Second, produce the final list of all .mod files that are to be generated.
# MOD_ALL is a list of Fortran modules generated by the main program as well
# as HEDTOOLS. So far MOD_ALL is not used for anything very important, only in
# cleaning temporary files, so can be set to .mod files remaining after make
# clean/distclean. Modules can be included into prerequisites?
# NOTE: The code automatically generating the list of modules uses the MOD_LIST
#       variable that gets the list of modules by applying Unix 'grep' to the
#       source code files; extracts basename (just in case) and adds the
#       '.mod' suffix to each file.
MOD_ALL = $(addsuffix .mod, $(basename $(call lowercase, $(MOD_LIST))))
 
#===============================================================================
# Auto-generated include file setting compiler/platform specific code for PRNG
# The module BASE_RANDOM includes some non-portable header code that
# depends on the compiler type. It is auto-generated here. The Fortran Module
# code contains INCLUDE statement. The appropriate include file is then
# auto-generated during the build process.
# The strategy of the build is two-step:
#    (1) Provide comment macro for the include file as well as the code adapted
#        for the specific compiler type and platform
#    (2) Select macro from the above list specific for the
#        compiler type
#    (3) build the BASE_RANDOM.o, the first statement is the include
#        auto-generation macro, then follow the compile instructions.
 
#  Header file setting compiler/platform specific code for PRNG module
AUTOGEN_HEADER_RAND = $(HEDTOOLSDIR)/BASE_RANDOM.inc
 
# Auto-generated include files, note that the first two lines do doxygen
# comments.
define AUTOGEN_COMMENT_RANDOM
  $(shell $(ECHO) "!> @file $(AUTOGEN_HEADER_RAND)"                               > $(AUTOGEN_HEADER_RAND))
  $(shell $(ECHO) "!! Autogenerated header for module RANDOM built with $(FC)"   >> $(AUTOGEN_HEADER_RAND))
  $(shell $(ECHO) "!! Sets compiler-specific code for random number generator"   >> $(AUTOGEN_HEADER_RAND))
  $(shell $(ECHO) "!+---------------------------------------------------------+" >> $(AUTOGEN_HEADER_RAND))
  $(shell $(ECHO) "!| WARNING: auto-generated file, do NOT edit               |" >> $(AUTOGEN_HEADER_RAND))
  $(shell $(ECHO) "!| Sets compiler-specific code for random number generator |" >> $(AUTOGEN_HEADER_RAND))
  $(shell $(ECHO) "!+---------------------------------------------------------+" >> $(AUTOGEN_HEADER_RAND))
endef
 
# Include file code for GNU
define AUTOGEN_CODE_GF
  $(shell $(ECHO) "! GNU Fortran compiler:" >> $(AUTOGEN_HEADER_RAND))
  $(shell $(ECHO) "use ISO_FORTRAN_ENV, only: int64" >> $(AUTOGEN_HEADER_RAND))
  $(shell $(ECHO) "implicit none" >> $(AUTOGEN_HEADER_RAND))
  $(shell $(ECHO) "integer, allocatable :: seed(:)" >> $(AUTOGEN_HEADER_RAND))
  $(shell $(ECHO) "integer :: i, n, un, istat, dt(8), pid" >> $(AUTOGEN_HEADER_RAND))
  $(shell $(ECHO) "integer(int64) :: t">> $(AUTOGEN_HEADER_RAND))
endef
 
# Include file code for Intel
define AUTOGEN_CODE_IF
  $(shell $(ECHO) "! Intel Fortran compiler:" >> $(AUTOGEN_HEADER_RAND))
  $(shell $(ECHO) "use ISO_FORTRAN_ENV, only: int64 " >> $(AUTOGEN_HEADER_RAND))
  $(shell $(ECHO) "use IFPORT, only : getpid" >> $(AUTOGEN_HEADER_RAND))
  $(shell $(ECHO) "implicit none" >> $(AUTOGEN_HEADER_RAND))
  $(shell $(ECHO) "integer, allocatable :: seed(:)" >> $(AUTOGEN_HEADER_RAND))
  $(shell $(ECHO) "integer :: i, n, un, istat, dt(8), pid" >> $(AUTOGEN_HEADER_RAND))
  $(shell $(ECHO) "integer(int64) :: t" >> $(AUTOGEN_HEADER_RAND))
endef
 
# Include file code for Oracle
define AUTOGEN_CODE_SF
  $(shell $(ECHO) "! Intel Oracle compiler:" >> $(AUTOGEN_HEADER_RAND))
  $(shell $(ECHO) "implicit none" >> $(AUTOGEN_HEADER_RAND))
  $(shell $(ECHO) "integer, allocatable :: seed(:)" >> $(AUTOGEN_HEADER_RAND))
  $(shell $(ECHO) "integer :: i, n, un, istat, dt(8), pid" >> $(AUTOGEN_HEADER_RAND))
  $(shell $(ECHO) "integer, parameter :: int64 = selected_int_kind(18)" >> $(AUTOGEN_HEADER_RAND))
  $(shell $(ECHO) "integer(int64) :: t" >> $(AUTOGEN_HEADER_RAND))
  $(shell $(ECHO) "include \"system.inc\"" >> $(AUTOGEN_HEADER_RAND))
endef
 
# Select autogeneration of include file for the specific compiler type
ifeq ($(FC),$(GF_FC))
  AUTOGEN_CODE_RANDOM=$(AUTOGEN_CODE_GF)
endif
 
ifeq ($(FC),$(IF_FC))
  AUTOGEN_CODE_RANDOM=$(AUTOGEN_CODE_IF)
endif
 
ifeq ($(FC),$(SF_FC))
  AUTOGEN_CODE_RANDOM=$(AUTOGEN_CODE_SF)
endif
 
#===============================================================================
# Determine compiler versions, we may need GCC version > 5 to use
# non-intrinsic IEEE math modules for gfortran < 5, GCC > 5 fully
# supports intrinsic IEEE math.
# IEEE should work with recent versions
 
# Check GCC version and need for non-intrinsic modules
GFORTVERSION = $(shell $(GF_FC) -dumpversion)
GFORT_LESS_5 = $(shell expr `echo $(GFORTVERSION) | $(CUT) -d. -f1` < 5)
ifeq ($(GFORT_LESS_5),1)
  COMPILE_NONINTRINSIC_IEEE=YES
else
  COMPILE_NONINTRINSIC_IEEE=NO
endif
 
# IEEE non-intrinsic modules, list of sources
IEEE_NON_INTRINSIC_SRC = precision_m.f90 IEEE_FEATURES.f90 IEEE_EXCEPTIONS.f90 \
                        IEEE_ARITHMETIC.f90 c_control.c
 
IEEEMOD = ieee_arithmetic.mod  ieee_exceptions.mod  ieee_features.mod  \
          precision.mod
 
# IEEE non-intrinsic objects
IEEEOBJ = precision_m.$(OBJEXT) c_control.$(OBJEXT) IEEE_FEATURES.$(OBJEXT) \
          IEEE_EXCEPTIONS.$(OBJEXT) IEEE_ARITHMETIC.$(OBJEXT)
 
# Macros to auto-generate F90 headers for IEEE modules -- AUTOGEN_HEADER_FILE
AUTOGEN_HEADER_IEEE = IEEE_wrap.inc
 
# Check if the source does include IEEE calls at all, disable non-intrinsic IEEE
# if the Fortran source does never refer to them
IEEE_GREPPED_SRC = $(shell $(GREP) -ci $(AUTOGEN_HEADER_IEEE) $(SRC))
ifeq ($(IEEE_GREPPED_SRC),0)
  COMPILE_NONINTRINSIC_IEEE=NO
endif
 
ifneq ($(FC),gfortran)
  COMPILE_NONINTRINSIC_IEEE=NO
endif
 
# Autogenerated include files
define AUTOGEN_COMMENT_HEADER_F90
  $(shell $(ECHO) "!> @file $(AUTOGEN_HEADER_IEEE)"                                >  $(AUTOGEN_HEADER_IEEE))
  $(shell $(ECHO) "!! Autogenerated header for IEEE math modules built with $(FC)" >> $(AUTOGEN_HEADER_IEEE))
  $(shell $(ECHO) "!! Calls intrinsic or non-intrinsic IEEE math modules"          >> $(AUTOGEN_HEADER_IEEE))
  $(shell $(ECHO) "!+-----------------------------------------------------+" >> $(AUTOGEN_HEADER_IEEE))
  $(shell $(ECHO) "!| WARNING: auto-generated file, do NOT edit           |" >> $(AUTOGEN_HEADER_IEEE))
  $(shell $(ECHO) "!| Calls intrinsic or non-intrinsic IEEE math modules  |" >> $(AUTOGEN_HEADER_IEEE))
  $(shell $(ECHO) "!+-----------------------------------------------------+" >> $(AUTOGEN_HEADER_IEEE))
endef
 
# Now only use IEEE_EXCEPTIONS are managed. Other modules may be added:
#  IEEE_FEATURES IEEE_ARITHMETIC IEEE_EXCEPTIONS
define AUTOGEN_INTRINSIC
  $(AUTOGEN_COMMENT_HEADER_F90)
  $(shell $(ECHO) "use, intrinsic :: IEEE_ARITHMETIC" >> $(AUTOGEN_HEADER_IEEE))
  $(shell $(ECHO) "use, intrinsic :: IEEE_EXCEPTIONS" >> $(AUTOGEN_HEADER_IEEE))
endef
 
# Now only use IEEE_EXCEPTIONS are managed. Other modules may be added:
#  IEEE_FEATURES IEEE_ARITHMETIC IEEE_EXCEPTIONS
define AUTOGEN_NON_INTRINSIC
  $(AUTOGEN_COMMENT_HEADER_F90)
  $(shell $(ECHO) "use, non_intrinsic :: IEEE_ARITHMETIC" >> $(AUTOGEN_HEADER_IEEE))
  $(shell $(ECHO) "use, non_intrinsic :: IEEE_EXCEPTIONS" >> $(AUTOGEN_HEADER_IEEE))
endef
 
#-------------------------------------------------------------------------------
 
# Function to convert UPPERCASE to lowercase by Eric Melski, taken from
# https://stackoverflow.com/questions/664601/in-gnu-make-how-do-i-convert-a-variable-to-lower-case
# It looks a little clunky, but it gets the job done...
lowercase = $(subst A,a,$(subst B,b,$(subst C,c,$(subst D,d,$(subst E,e,$(subst F,f,$(subst G,g,$(subst H,h,$(subst I,i,$(subst J,j,$(subst K,k,$(subst L,l,$(subst M,m,$(subst N,n,$(subst O,o,$(subst P,p,$(subst Q,q,$(subst R,r,$(subst S,s,$(subst T,t,$(subst U,u,$(subst V,v,$(subst W,w,$(subst X,x,$(subst Y,y,$(subst Z,z,$1))))))))))))))))))))))))))
 
#-------------------------------------------------------------------------------
 
# Determine this makefile's path. Be sure to place this BEFORE `include`s
THIS_FILE := $(lastword $(MAKEFILE_LIST))
 
# This is the search paths for looking for components, separated by blanks
VPATH = $(HEDTOOLSDIR) $(IEEEPATH)
 
# Determine if we are running on HPC cluster
RUNHOST_HPC = $(shell hostname | $(GREP) -c $(HOST_HPC_ROOT))
 
# Determine current SVN version of the code
ifeq ($(VCS_TYPE),SVN)
  SVN_VER = $(shell svn info --show-item last-changed-revision)
endif
ifeq ($(VCS_TYPE),HG)
  SVN_VER = $(shell hg summary | $(GREP) parent: | $(CUT) -d " " -f 2 | $(CUT) -d ":" -f 2 )
endif
ifndef VCS_TYPE
  SVN_VER = "unknown"
endif
 
# Build the data zip file name: data are compressed for make zipdata
ZIPDATA_NAME = model_data_rev$(SVN_VER)_$(shell hostname).zip
 
#===============================================================================
# targets follow
#===============================================================================
 
# Default build target = executable
all: exec
 
docs: $(DOXYCFG)
  doxygen $(DOXYCFG)
 
# Short help on the options
# For Intel Fortran compiler on Windows, we have to call the batch file to setup
#   the build environment. This command is taken from the Command Prompt
#   shortcut in the Intel Parallel Studio menu:
#C:\Windows\SysWOW64\cmd.exe /E:ON /V:ON /K ""C:\Program Files (x86)\Intel\Composer XE 2013\bin\ipsxe-comp-vars.bat" intel64 vs2010"
#   This mitght be different on different systems, depending on the
#   installation options for Intel Parallel Studio and the Windows platform
#   type (e.g. 32 vs. 64 bit)
help:
  @echo ""
  @echo ------------------------------------------------------------------------
  @echo "Building model $(SRC) ------ via $(THIS_FILE)"
  @echo ------------------------------------------------------------------------
  @echo "BUILD:"
  @echo ""
  @echo "Normal build: make (uses $(FC) by default)"
  @echo ""
  @echo "Main (re)build (for different compiler type targets):"
  @echo "    make gnu, make intel, make sun"
  @echo ""
  @echo "Compile HEDTOOLS modelling tools: make tools"
  @echo ""
  @echo "Autogenerate documentation with Doxygen (config: $(DOXYCFG))"
  @echo "    make docs"
  @echo ""
  @echo "Produce system-specific include headers (PRNG and IEEE): make inc"
  @echo ""
  @echo "Produce debug symbols: define DEBUG, e.g.: make DEBUG=1"
  @echo "   profiling output (GNU): define PROFILE, e.g.: make PROFILE=1"
  @echo ""
  @echo "RUN:"
  @echo ""
  @echo "Run model: make run (make run_local to force local run)"
  @echo ""
  @echo "DATA:"
  @echo ""
  @echo "Compress output data: make zipdata (compress CSV: make gzipcsv)"
  @echo "Check zip file and produce md5 checksum: make zipcheck"
  @echo "Send zip data (and others) to the remote server AHA_STORAGE_SERVER_STR"
  @echo " = $(AHA_STORAGE_SERVER_STR): make zipsend"
  @echo ""
  @echo "UNIT TESTS:"
  @echo ""
  @echo "Run unit tests using pfunt test framework: make tests"
  @echo ""
  @echo "CLEAN UP:"
  @echo ""
  @echo "Cleaning: make clean, make cleandata (model data only),"
  @echo "          make distclean (everything, leaving the distro state!)"
  @echo ------------------------------------------------------------------------
  @echo "NOTES:"
  @echo " 1. IEEE non-intrinsic modules: make ieee, needed only for GCC < 5"
  @echo " 2. Intel Fortran compiler under Windows: set up environment for "
  @echo "    Microsoft Visual Studio 2010 x64 tools before calling make."
  @echo "    Call to the shortcuts from the Command Prompt menu under Intel "
  @echo "    Parallel Studio XE"
  @echo ------------------------------------------------------------------------
  @echo PROJECT: Rev: $(SVN_VER) \‍($(VCS_TYPE)\‍), $(PLATFORM_TYPE), HPC \‍($(HOST_HPC_ROOT)\‍) $(RUNHOST_HPC)
  @echo Source: $(SRC) -- $(OUT) -- $(OBJ)
  @echo ------------------------------------------------------------------------
 
# shortcut to build for GNU Fortran
.PHONY: gnu
gnu:
  @$(MAKE) -f $(THIS_FILE) FC=gfortran
 
# shortcut to build for Intel Fortran
.PHONY: intel
intel:
  @$(MAKE) -f $(THIS_FILE) FC=ifort
 
# shortcut to build for Solaris Studio Fortran
.PHONY: sun
sun:
  @$(MAKE) -f $(THIS_FILE) FC=f95
 
# Run through PBS job script on HPC, check if we are on cluster RUNHOST_HPC
#run: $(OUT) $(JOB) $(SRC)
run: $(OUT) $(SRC)
ifeq ($(RUNHOST_HPC),1)
  qsub $(JOB)
  @echo "NOTE: fimm job created"
  @echo "Batch commands:"
  @echo "  showq -u USER = show user's jobs'"
  @echo "  qstat = display all jobs"
  @echo "  qdel jobid = delete job"
  @echo "  qhold = pause job"
  @echo "  qrls = resume job"
  @echo "https://docs.hpc.uib.no/wiki/Job_execution_(Fimm)"
else
  @$(MAKE) -f $(THIS_FILE) run_local
endif
 
# Note -- this is local start/run on all supported systems.
# If the DEBUG flag was set when starting make, the executable also
# starts in the DEBUG mode (command line DEBUG flag).
run_local: $(OUT) $(SRC)
  $(info ====================================================================)
  $(info                    Executing model $(OUT) now)
  $(info ====================================================================)
ifeq ($(IS_WINDOWS),1)
  $(OUT) $(RUNFLAG)
  $(AHA_NOTIFY_CMD_WIN)
else
  ./$(OUT) $(RUNFLAG) ; $(AHA_NOTIFY_CMD_UNIX)
endif
 
# Main build the executable
exec: $(OUT)
 
# Build object files only without the final executable
objects: $(OBJ) $(HTOOLOBJ)
 
# Produce include file for PRNG module
inc: $(AUTOGEN_HEADER_RAND) $(AUTOGEN_HEADER_IEEE)
 
# Compile the HEDTOOLS modelling tools
tools: $(HTOOLOBJ)
 
# Compile the HEDTOOLS modelling tools
headtools: $(HTOOLOBJ)
 
# Run unit tests. Note that pFunit is non-essential and any build errors are
# ignored in this main Makefile.
.PHONY: tests
tests:
  @echo Running unit tests in $(PFUNIT_PATH). Warning: Any errors IGNORED.
  -$(MAKE) -C $(PFUNIT_PATH)
 
# Cleanup data files, quotes needed on Windows if file starts from blank
cleandata: neat
  -$(RM) HED*.txt ?HED*.txt HED18*.log behaviour gene*
  -$(RM) debug*  *.csv *.ps *.png *.svg *gz
ifeq ($(IS_WINDOWS),1)
  -$(RM) "?HED*.txt" "HED*.txt"
endif
 
# Return to default state, delete all generated files.
distclean: clean cleandata cleanzip
  -$(RM) $(AUTOGEN_HEADER_RAND) $(AUTOGEN_HEADER_IEEE) $(HTOOLOBJ) $(MOD_ALL) \
          $(IEEEOBJ) $(IEEEMOD) gmon.out *.mod *.log *.o *.obj *.pdb *.patch  \
          *.md5
  -$(RM) $(DOXYPATH)
  @echo Cleaning unit tests in $(PFUNIT_PATH).
  @echo NOTE: Any errors IGNORED.
  -$(MAKE) -C $(PFUNIT_PATH) distclean
 
# Clean obj etc for new build of the model, but we don't clean HEDTOOLS and
# any .mod files.
clean: neat
  -$(RM) $(OBJ) $(OUT) *.csv *.ps *.png
 
# Cean temporary files and conflict that remain from syncthing synchronisation.
neat:
  -$(RM) *conflict* .syncthing* ~syncthing* fort.* *.tmp *.orig *.lock \
         *.annot.html *.annot *.optrpt
 
# Compress all generation-based CSV data using gzip. This should
# normally be done automatically at run time if the environment variable
# AHA_ZIP_FILES=YES
gzipcsv:
  gzip agents*csv behaviours*csv food_*csv genomes*csv memory*csv \
       movements*csv timesteps*csv
 
# Compress all output data from the latest model run. This is a shortcut
# calling the actual zip target.
zipdata: $(ZIPDATA_NAME)
 
# Compress all output data from the latest model run. This is the actual zipper.
$(ZIPDATA_NAME):
  @echo Producing zipfile: $(ZIPDATA_NAME)
  -zip $(ZIPDATA_NAME) *.csv *.log *.ps *.gz *.patch
  @echo "NOTE: If the $(OUT) target is rebuilt at this stage, re-run model!"
  @echo "      To check zip run make zipcheck"
  @echo "      Produced $(ZIPDATA_NAME)"
 
# Check the integrity of the compressed data zip file and produce the md5
# checksum.
zipcheck: $(ZIPDATA_NAME)
  @echo Check zip and produce MD5 checksum file.
  @echo NOTE: Any errors are IGNORED.
  -zip -T $(ZIPDATA_NAME)
  -md5sum $(ZIPDATA_NAME) > $(ZIPDATA_NAME).md5
 
# Sending the data zip file to an external server for storage or data analysis.
# The data file is sent using scp command. Note that the zip file as well as
# all files having the same root names are transferred, e.g..
# model_1.zip along with model_1.zip.md5 model_1.zip.notes model_1.zip.txt
zipsend: $(ZIPDATA_NAME)
  @echo Sending $(ZIPDATA_NAME) to $(AHA_STORAGE_SERVER_STR)
  @echo NOTE: Any errors are IGNORED. Data transfer may take a long time!
  -scp $(ZIPDATA_NAME)* $(AHA_STORAGE_SERVER_STR)
 
# Clean any compressed data.
cleanzip:
  -$(RM) *zip *gz *bz2
 
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
# Automatic build follows, usually there is no need to edit the code below...
 
$(OUT): $(DRV) $(OBJ) $(HTOOLOBJ)
  @$(MAKE) -f $(THIS_FILE) inc
ifeq ($(COMPILE_NONINTRINSIC_IEEE),YES)
  $(FC) $(FFLAGS) -o $(OUT) $^ $(IEEEOBJ) $(GRAPHLIB)
else
  $(FC) $(FFLAGS) -o $(OUT) $^ $(GRAPHLIB)
endif
 
$(OBJ): $(SRC) $(HTOOLOBJ)
ifeq ($(COMPILE_NONINTRINSIC_IEEE),YES)
  @$(MAKE) -f $(THIS_FILE) ieee_need
else
  @$(MAKE) -f $(THIS_FILE) ieee_not_need
endif
  $(FC) $(FFLAGS) -c $^ $(GRAPHLIB)
 
#-------------------------------------------------------------------------------
# Build HEDTOOLS
 
# Produce tweaked include file for PRNG
$(AUTOGEN_HEADER_RAND): $(BASE_RANDOM.f90) $(THIS_FILE)
  $(AUTOGEN_COMMENT_RANDOM)
  $(AUTOGEN_CODE_RANDOM)
  @echo Generated include: $(AUTOGEN_HEADER_RAND) for $(FC) using $(ECHO)
 
# Compile HEDTOOLS modules. Note that the extension (.o or .obj)
# is set via $(OBJEXT). .obj is used on Intel Fortran on Windows.
# Also note that generic pattern rules are used here, with the
# include files as additional prerequisites.
# NOTE: generic pattern with include as prerequisite is disabled
#       here because it does not work for some reason from within
#       Code:Blocks, even though works on raw terminal
# --- GENERIC UNUSED ---
##%.$(OBJEXT) : %.f90 $(AUTOGEN_HEADER_RAND) $(AUTOGEN_HEADER_IEEE) $(THIS_FILE)
##  $(FC) $(FFLAGS) -c $<
# --- GENERIC UNUSED ---
# So far, use individual builds for each of the HEDTOOLS source files:
BASE_UTILS.$(OBJEXT): BASE_UTILS.f90
  $(FC) $(FFLAGS) -c $<
BASE_CSV_IO.$(OBJEXT): BASE_CSV_IO.f90
  $(FC) $(FFLAGS) -c $<
BASE_LOGGER.$(OBJEXT): BASE_LOGGER.f90
  $(FC) $(FFLAGS) -c $<
BASE_RANDOM.$(OBJEXT): BASE_RANDOM.f90 $(THIS_FILE)
  @$(MAKE) -f $(THIS_FILE) inc
  $(FC) $(FFLAGS) -c $<
BASE_STRINGS.$(OBJEXT): BASE_STRINGS.f90
  $(FC) $(FFLAGS) -c $<
 
#-------------------------------------------------------------------------------
# Build IEEE non-intrinsic modules for GNU Fortran if needed
 
# Generate IEEE include file
$(AUTOGEN_HEADER_IEEE): $(THIS_FILE)
ifeq ($(COMPILE_NONINTRINSIC_IEEE),YES)
  $(AUTOGEN_NON_INTRINSIC)
  @echo Generated include: $(AUTOGEN_HEADER_IEEE) for $(FC) v. $(GFORTVERSION) using $(ECHO)
else
  $(AUTOGEN_INTRINSIC)
  @echo Generated include: $(AUTOGEN_HEADER_IEEE) for $(FC) using $(ECHO)
endif
 
#-------------------------------------------------------------------------------
# Compile all IEEE non-intrinsic math modules if needed
ieee:
ifeq ($(COMPILE_NONINTRINSIC_IEEE),YES)
  @$(MAKE) -f $(THIS_FILE) ieee_need
else
  @$(MAKE) -f $(THIS_FILE) ieee_not_need
endif
 
# just issue note that we do not need IEEEs
ieee_not_need:
  @echo ------------------------------------------------------------------------
  @echo We do not need non-intrinsic IEEE modules: $(FC), $(GREP) test $(IEEE_GREPPED_SRC)
  @echo ------------------------------------------------------------------------
 
# build IEEEs assuming we do need them (GNU)
ieee_need: $(IEEEOBJ)
  @echo ------------------------------------------------------------------------
  @echo GNU Fortran version: $(GFORTVERSION). We NEED NON-INTRINSIC IEEE MODULES.
  @echo ------------------------------------------------------------------------
 
# specific components of IEEE modules are below
precision_m.$(OBJEXT): precision_m.f90
  $(FC) -c $(FFLAGS) $<
c_control.$(OBJEXT): c_control.c
  $(CC) -c $(GC_FFLAGS) $<
IEEE_FEATURES.$(OBJEXT): IEEE_FEATURES.f90
  $(FC) -c -fno-range-check $(FFLAGS) $<
IEEE_EXCEPTIONS.$(OBJEXT): IEEE_EXCEPTIONS.f90
  $(FC) -c -fno-range-check $(FFLAGS) $<
IEEE_ARITHMETIC.$(OBJEXT): IEEE_ARITHMETIC.f90
  $(FC) -c -fno-range-check $(FFLAGS) $<
 
##//! @endcond