Permalink
Fetching contributors…
Cannot retrieve contributors at this time
672 lines (595 sloc) 22.2 KB
#-------------------------------------------------------------------------------
# configure.ac: Athena configuration script template file. Run 'autoconf'
# to generate a new 'configure' script from this file.
#
# When configure is run, it uses the command line options and default settings
# to create custom versions of the following files:
# Makefile, Makeoption, src/Makefile, src/defs.h, src/*/Makefile,
#
# If new configure options are added to this file, they should also be
# added in show_config() in src/show_config.c, and to the diagnostic message
# output at the end of this file.
#
# This template adds the following options to the 'configure' script:
#
# PHYSICS "packages":
# --with-problem='name' (use prob/name.c as problem generator)
# --with-gas=[hydro,mhd] (hydro or mhd algorithm)
# --with-eos=[isothermal, adiabatic] (equation of state)
# --with-nscalars=n (number of advected scalars)
# --with-gravity=[fft,fft_disk,fft_obc,multigrid] (self-gravity)
# --with-particles=[feedback,passive] (dust particle integration)
# --with-coord=[cartesian,cylindrical] (coordinate system)
#
# PHYSICS "features":
# --enable-conduction (explicit thermal conduction)
# --enable-resistivity (explicit resistivity)
# --enable-special-relativity (special relativistic hydro or MHD)
# --enable-viscosity (explicit viscosity)
#
# ALGORITHM "packages":
# --with-order=[1,2,3,2p,3p] (order and type of spatial reconstruction)
# --with-flux=[roe,hlle,hllc,hlld,force,exact,two-shock] (flux function)
# --with-integrator=[ctu,vl] (unsplit integration algorithm)
# --with-cflags=[opt,debug,profile] (set compiler flags)
#
# ALGORITHM "features":
# --enable-fargo (enable FARGO algorithm)
# --enable-fft (compile and link with FFTW block decomposition)
# --enable-fofc (first-order flux correction in VL integrator)
# --enable-ghost (write out ghost cells in outputs/dumps)
# --enable-h-correction (turn on H-correction in multidimensions)
# --enable-mpi (parallelize with MPI)
# --enable-shearing box (include shearing box source terms)
# --enable-single (double or single precision)
# --enable-sts (super timestepping for explicit diffusion)
# --enable-smr (static mesh refinement)
# --enable-rotating_frame (enable ROTATING_FRAME algorithm)
# --enable-l1_inflow (enable inflow from L1 point)
#
#-------------------------------------------------------------------------------
# generic things
AC_INIT(src/athena.h)
AC_CONFIG_HEADER(src/config.h)
AC_PROG_CC
AC_PROG_INSTALL
#-------------------------------------------------------------------------------
# PHYSICS PACKAGE: name of problem generator from src/prob/name.c
# --with-problem=name (default is linear_wave)
AC_SUBST(PROBLEM)
AC_ARG_WITH(problem,
[--with-problem=PROB Problem generator from src/prob/name.c],
with_problem=$withval, with_problem="linear_wave")
PROBLEM=$with_problem
if test -e src/prob/$PROBLEM.c; then
rm -f src/problem.c
ln -s prob/$PROBLEM.c src/problem.c
else
ls src/prob
AC_MSG_ERROR([Invalid problem filename, valid names listed above])
fi
#-------------------------------------------------------------------------------
# PHYSICS PACKAGE: gas mode (hydro or mhd)
# --with-gas=hydro (default is mhd)
# mode also sets the default flux handling, since that depends on whether the
# problem is hydro or mhd (see option --with-flux= below)
AC_SUBST(GAS)
AC_ARG_WITH(gas,
[--with-gas=GAS Gas properties (mhd,hydro)],
with_gas=$withval, with_gas="mhd")
if test "$with_gas" = "hydro"; then
GAS="HYDRO"
flux_default="hllc"
elif test "$with_gas" = "mhd"; then
GAS="MHD"
flux_default="roe"
else
AC_MSG_ERROR([expected --with-gas=mhd or hydro])
fi
#-------------------------------------------------------------------------------
# PHYSICS PACKAGE: equation of state
# --with-eos=[adiabatic,isothermal] (default is adiabatic)
AC_SUBST(EOS)
AC_ARG_WITH(eos,
[--with-eos=EOS Equation of state (adiabatic,isothermal)],
with_eos=$withval, with_eos=adiabatic)
if test "$with_eos" = "adiabatic"; then
EOS="ADIABATIC"
elif test "$with_eos" = "isothermal"; then
EOS="ISOTHERMAL"
else
AC_MSG_ERROR([expected --with-eos=adiabatic or isothermal])
fi
#-------------------------------------------------------------------------------
# PHYSICS PACKAGE: nscalars
# --with-nscalars=n (n is any integer, default is 0)
# number of passively advected scalars
AC_SUBST(NSCALARS)
AC_ARG_WITH(nscalars,
[--with-nscalars=n (default is 0)],
nscalars=$withval, nscalars=0)
if test "$nscalars" = "0"; then
NSCALARS="0"
elif test "$nscalars" != "0"; then
NSCALARS=$nscalars
else
AC_MSG_ERROR([expected --with-nscalars=n])
fi
#-------------------------------------------------------------------------------
# PHYSICS PACKAGE: self-gravity
# --with-gravity= [fft,fft_disk,fft_obc,multigrid]
AC_SUBST(SELF_GRAVITY_DEFINE)
AC_SUBST(SELF_GRAVITY_ALGORITHM)
AC_ARG_WITH(gravity,
[--with-gravity=SELF_GRAVITY_ALGORITHM Algorithm for self gravity (fft, fft_disk, fft_obc, multigrid)],
gravity_algorithm=$withval, gravity_algorithm=none)
if test "$gravity_algorithm" = "fft"; then
SELF_GRAVITY_DEFINE="SELF_GRAVITY"
SELF_GRAVITY_USER="ON"
SELF_GRAVITY_ALGORITHM="SELF_GRAVITY_USING_FFT"
elif test "$gravity_algorithm" = "fft_disk"; then
SELF_GRAVITY_DEFINE="SELF_GRAVITY"
SELF_GRAVITY_USER="ON"
SELF_GRAVITY_ALGORITHM="SELF_GRAVITY_USING_FFT_DISK"
elif test "$gravity_algorithm" = "fft_obc"; then
SELF_GRAVITY_DEFINE="SELF_GRAVITY"
SELF_GRAVITY_USER="ON"
SELF_GRAVITY_ALGORITHM="SELF_GRAVITY_USING_FFT_OBC"
elif test "$gravity_algorithm" = "multigrid"; then
SELF_GRAVITY_DEFINE="SELF_GRAVITY"
SELF_GRAVITY_USER="ON"
SELF_GRAVITY_ALGORITHM="SELF_GRAVITY_USING_MULTIGRID"
elif test "$gravity_algorithm" = "none"; then
SELF_GRAVITY_DEFINE="NO_SELF_GRAVITY"
SELF_GRAVITY_USER="OFF"
SELF_GRAVITY_ALGORITHM="SELF_GRAVITY_NONE"
else
AC_MSG_ERROR([expected --with-gravity=fft, fft_disk, fft_obc, or multigrid])
fi
#-------------------------------------------------------------------------------
# PHYSICS PACKAGE: particles
# --with-particles=[feedback,passive]
AC_SUBST(PARTICLES_ALGORITHM)
AC_SUBST(FEEDBACK_DEFINE)
AC_ARG_WITH(particles,
[--with-particles=PARTICLES_ALGORITHM particle integration algorithm (feedback, passive)],
particles_algorithm=$withval, particles_algorithm=none)
if test "$particles_algorithm" = "feedback"; then
FEEDBACK_DEFINE="FEEDBACK"
PARTICLES_USER="feedback"
PARTICLES_ALGORITHM="PARTICLES"
elif test "$particles_algorithm" = "passive"; then
FEEDBACK_DEFINE="NO_FEEDBACK"
PARTICLES_USER="passive"
PARTICLES_ALGORITHM="PARTICLES"
elif test "$particles_algorithm" = "none"; then
FEEDBACK_DEFINE="NO_FEEDBACK"
PARTICLES_USER="OFF"
PARTICLES_ALGORITHM="NO_PARTICLES"
else
AC_MSG_ERROR([expected --with-particles=feedback or passive])
fi
#-------------------------------------------------------------------------------
# PACKAGE: coordinate system
# --with-coord=[cartesian,cylindrical] (default is cartesian)
AC_SUBST(COORD)
AC_ARG_WITH(coord,
[--with-coord=COORD Coordinate System (cartesian,cylindrical)],
with_coord=$withval, with_coord=cartesian)
if test "$with_coord" = "cartesian"; then
COORD="CARTESIAN"
elif test "$with_coord" = "cylindrical"; then
COORD="CYLINDRICAL"
else
AC_MSG_ERROR([expected --with-coord=cartesian or cylindrical])
fi
#-------------------------------------------------------------------------------
# PHYSICS FEATURE: cooling
# --enable-cooling
AC_SUBST(COOLING_MODE)
AC_ARG_ENABLE(cooling,
[--enable-cooling enable implicit cooling (default is no)],
coolingok=$enableval, coolingok=no)
if test "$coolingok" = "yes"; then
COOLING_MODE="OPERATOR_SPLIT_COOLING"
COOLING_MODE_USER="ON"
else
COOLING_MODE="NO_COOLING"
COOLING_MODE_USER="OFF"
fi
#-------------------------------------------------------------------------------
# PHYSICS FEATURE: explicit thermal conduction
# --enable-conduction
AC_SUBST(CONDUCTION_MODE)
AC_ARG_ENABLE(conduction,
[--enable-conduction enable thermal conduction (default is no)],
ok=$enableval, ok=no)
if test "$ok" = "yes"; then
CONDUCTION_MODE="THERMAL_CONDUCTION"
CONDUCTION_MODE_USER="ON"
else
CONDUCTION_MODE="NO_THERMAL_CONDUCTION"
CONDUCTION_MODE_USER="OFF"
fi
#-------------------------------------------------------------------------------
# PHYSICS FEATURE: explicit resistivity
# --enable-resistivity
AC_SUBST(RESISTIVITY_MODE)
AC_ARG_ENABLE(resistivity,
[--enable-resistivity enable resistivity (default is no)],
ok=$enableval, ok=no)
if test "$ok" = "yes"; then
RESISTIVITY_MODE="RESISTIVITY"
RESISTIVITY_MODE_USER="ON"
else
RESISTIVITY_MODE="NO_RESISTIVITY"
RESISTIVITY_MODE_USER="OFF"
fi
#-------------------------------------------------------------------------------
# PHYSICS FEATURE: special relativistic hydro or MHD
# --enable-special-relativity
AC_SUBST(SPECIAL_RELATIVITY_MODE)
AC_ARG_ENABLE(special-relativity,
[--enable-special-relativity enable special relativistic hydro or MHD (default is no)],
ok=$enableval, ok=no)
if test "$ok" = "yes"; then
SPECIAL_RELATIVITY_MODE="SPECIAL_RELATIVITY"
SPECIAL_RELATIVITY_MODE_USER="ON"
else
SPECIAL_RELATIVITY_MODE="NEWTONIAN"
SPECIAL_RELATIVITY_MODE_USER="OFF"
fi
#-------------------------------------------------------------------------------
# PHYSICS FEATURE: explicit viscosity
# --enable-viscosity
AC_SUBST(VISCOSITY_MODE)
AC_ARG_ENABLE(viscosity,
[--enable-viscosity enable viscosity (default is no)],
ok=$enableval, ok=no)
if test "$ok" = "yes"; then
VISCOSITY_MODE="VISCOSITY"
VISCOSITY_MODE_USER="ON"
else
VISCOSITY_MODE="NO_VISCOSITY"
VISCOSITY_MODE_USER="OFF"
fi
#-------------------------------------------------------------------------------
# ALGORITHM PACKAGE: set the order and type of the spatial reconstruction
# --with-order=[1,2,3] - #-order reconstruction in the characteristic vars
# --with-order=[2p,3p] - #-order reconstruction in the primitive vars
# --with-order=[3pck, 3pcl]
# (default is 2 -- 2nd-order reconstruction in the characteristic vars)
AC_SUBST(ORDER)
AC_SUBST(ACCURACY)
AC_ARG_WITH(order,
[--with-order=ORDER Order of Accuracy (1,2,3,2p,3p)],
with_order=$withval, with_order="3")
ORDER=$with_order
if test "$with_order" = "1"; then
ACCURACY="FIRST_ORDER"
elif test "$with_order" = "2"; then
ACCURACY="SECOND_ORDER_CHAR"
elif test "$with_order" = "2p"; then
ACCURACY="SECOND_ORDER_PRIM"
elif test "$with_order" = "3"; then
ACCURACY="THIRD_ORDER_CHAR"
elif test "$with_order" = "3p"; then
ACCURACY="THIRD_ORDER_PRIM"
elif test "$with_order" = "3pck"; then
ACCURACY="THIRD_ORDER_COMPACT_PRIM_KOREN"
elif test "$with_order" = "3pcl"; then
ACCURACY="THIRD_ORDER_COMPACT_PRIM_LIMO3"
else
AC_MSG_ERROR([expected --with-order=1, 2, 3, 2p, 3p, 3pck,3pcl])
fi
#-------------------------------------------------------------------------------
# ALGORITHM PACKAGE: flux function
# --with-flux=[roe,hlle,hllc,hlld,force,exact]
# (default is roe if gas=mhd, hllc if gas=hydro)
AC_SUBST(FLUX_NAME)
AC_SUBST(FLUX_DEF)
AC_ARG_WITH(flux,
[--with-flux=FLUX_NAME Flux function (roe, hllc (hydro only), hlld, hlle, force, exact (hydro only),two-shock (hydro only))],
with_flux=$withval, with_flux=$flux_default)
FLUX_NAME=$with_flux
if test "$with_flux" = "roe"; then
FLUX_DEF="ROE_FLUX"
elif test "$with_flux" = "hlle"; then
FLUX_DEF="HLLE_FLUX"
elif test "$with_flux" = "hllc"; then
FLUX_DEF="HLLC_FLUX"
elif test "$with_flux" = "hlld"; then
FLUX_DEF="HLLD_FLUX"
elif test "$with_flux" = "force"; then
FLUX_DEF="FORCE_FLUX"
elif test "$with_flux" = "exact"; then
FLUX_DEF="EXACT_FLUX"
elif test "$with_flux" = "two-shock"; then
FLUX_DEF="TWO_SHOCK_FLUX"
else
AC_MSG_ERROR([Invalid flux function, valid types are: roe, hlle, hllc hlld, force, exact, two-shock])
fi
#-------------------------------------------------------------------------------
# ALGORITHM PACKAGE: set the unsplit integration algorithm
# --with-integrator=[ctu,vl] (default is ctu)
AC_SUBST(INTEGRATOR)
AC_SUBST(INTEGRATOR_DEF)
AC_ARG_WITH(integrator,
[--with-integrator=INTEGRATOR Which unsplit integrator (ctu, vl)],
with_integrator=$withval, with_integrator="ctu")
INTEGRATOR=$with_integrator
if test "$with_integrator" = "ctu"; then
INTEGRATOR_DEF="CTU_INTEGRATOR"
elif test "$with_integrator" = "vl"; then
INTEGRATOR_DEF="VL_INTEGRATOR"
else
AC_MSG_ERROR([expected --with-integrator=ctu or vl])
fi
#-------------------------------------------------------------------------------
# ALGORITHM PACKAGE: set compiler options.
# --with-cflags=[opt,debug,profile] (default is opt)
AC_SUBST(DEBUG_MODE)
AC_SUBST(COMPILER_OPTS)
AC_ARG_WITH(cflags,
[--with-cflags=DEBUG_MODE Set debugging mode (opt,debug,profile)],
with_debug=$withval, with_debug="opt")
if test "$with_debug" = "debug"; then
COMPILER_OPTS="-g -Wall -W -std=c99 -pedantic"
DEBUG_MODE="DEBUG"
elif test "$with_debug" = "profile"; then
COMPILER_OPTS="-O3 -pg"
DEBUG_MODE="PROFILE"
elif test "$with_debug" = "opt"; then
COMPILER_OPTS="-O3"
DEBUG_MODE="OPTIMIZE"
else
AC_MSG_ERROR([expected --with-cflags=opt,debug, or profile])
fi
#-------------------------------------------------------------------------------
# ALGORITHM FEATURE: precision of floating point arithmetic
# --enable-single (default is double)
AC_SUBST(PRECISION)
AC_ARG_ENABLE(single,
[--enable-single single-precision (default is double)],
ok=$enableval, ok=no)
if test "$ok" = "yes"; then
PRECISION="SINGLE_PREC"
else
PRECISION="DOUBLE_PREC"
fi
#-------------------------------------------------------------------------------
# ALGORITHM FEATURE: write ghost cells in outputs/dumps
# --enable-ghost
AC_SUBST(WRITE_GHOST_MODE)
AC_ARG_ENABLE(ghost,
[--enable-ghost write ghost zones],
ok=$enableval, ok=no)
if test "$ok" = "yes"; then
WRITE_GHOST_MODE="WRITE_GHOST_CELLS"
WRITE_GHOST_MODE_USER="ON"
else
WRITE_GHOST_MODE="NO_WRITE_GHOST_CELLS"
WRITE_GHOST_MODE_USER="OFF"
fi
#-------------------------------------------------------------------------------
# ALGORITHM FEATURE: parallelize with MPI, --enable-mpi (default is no MPI)
AC_SUBST(MPI_MODE)
AC_ARG_ENABLE(mpi,
[--enable-mpi enable MPI parellelization],
ok=$enableval, ok=no)
if test "$ok" = "yes"; then
MPI_MODE="MPI_PARALLEL"
MPI_MODE_USER="ON"
else
MPI_MODE="NO_MPI_PARALLEL"
MPI_MODE_USER="OFF"
fi
#-------------------------------------------------------------------------------
# ALGORITHM FEATURE: turn on H-correction in multidimensional integrators
# --enable-h-correction
# Note that H-correction only works with Roe flux. Prints error message if
# H-correction is enabled with any other flux.
AC_SUBST(H_CORRECTION_MODE)
AC_ARG_ENABLE(h-correction,
[--enable-h-correction turn on H-correction],
ok=$enableval, ok=no)
if test "$ok" = "yes"; then
if test "$with_flux" = "roe"; then
H_CORRECTION_MODE="H_CORRECTION"
H_CORRECTION_MODE_USER="ON"
else
AC_MSG_ERROR([H-correction only works with Roe flux])
fi
else
H_CORRECTION_MODE="NO_H_CORRECTION"
H_CORRECTION_MODE_USER="OFF"
fi
#-------------------------------------------------------------------------------
# ALGORITHM FEATURE: turn on FFT libraries
# --enable-fft
AC_SUBST(FFT_MODE)
AC_ARG_ENABLE(fft,
[--enable-fft compile and link FFT interface code (requires FFTW)],
ok=$enableval, ok=no)
if test "$ok" = "yes"; then
FFT_MODE="FFT_ENABLED"
FFT_MODE_USER="ON"
else
FFT_MODE="NO_FFT"
FFT_MODE_USER="OFF"
fi
#-------------------------------------------------------------------------------
# ALGORITHM FEATURE: turn on shearing box evolution
# --enable-shearing-box
AC_SUBST(SHEARING_BOX_MODE)
AC_ARG_ENABLE(shearing-box,
[--enable-shearing-box turn on shearing-box],
ok=$enableval, ok=no)
if test "$ok" = "yes"; then
SHEARING_BOX_MODE="SHEARING_BOX"
SHEARING_BOX_MODE_USER="ON"
else
SHEARING_BOX_MODE="NO_SHEARING_BOX"
SHEARING_BOX_MODE_USER="OFF"
fi
#-------------------------------------------------------------------------------
# ALGORITHM FEATURE: turn on FARGO algorithm
# --enable-fargo
AC_SUBST(FARGO_MODE)
AC_ARG_ENABLE(fargo,
[--enable-fargo turn on fargo],
ok=$enableval, ok=no)
if test "$ok" = "yes"; then
FARGO_MODE="FARGO"
FARGO_MODE_USER="ON"
else
FARGO_MODE="NO_FARGO"
FARGO_MODE_USER="OFF"
fi
#-------------------------------------------------------------------------------
# ALGORITHM FEATURE: turn on super timestepping for explicit diffusion
# --enable-sts
AC_SUBST(TIMESTEPPING_MODE)
AC_ARG_ENABLE(sts,
[--enable-sts turn on super timestepping],
ok=$enableval, ok=no)
if test "$ok" = "yes"; then
TIMESTEPPING_MODE="STS"
TIMESTEPPING_MODE_USER="ON"
else
TIMESTEPPING_MODE="NO_STS"
TIMESTEPPING_MODE_USER="OFF"
fi
#-------------------------------------------------------------------------------
# ALGORITHM FEATURE: static mesh refinement
# --enable-smr (default is no SMR)
AC_SUBST(MESH_REFINEMENT)
AC_ARG_ENABLE(smr,
[--enable-smr static mesh refinement (default is no refinement)],
ok=$enableval, ok=no)
if test "$ok" = "yes"; then
MESH_REFINEMENT="STATIC_MESH_REFINEMENT"
SMR_MODE_USER="ON"
else
MESH_REFINEMENT="NO_MESH_REFINEMENT"
SMR_MODE_USER="OFF"
fi
#-------------------------------------------------------------------------------
# ALGORITHM FEATURE: first-order flux correction with VL integrator
# --enable-fofc
AC_SUBST(FOFC_MODE)
AC_ARG_ENABLE(fofc,
[--enable-fofc enable first-order flux correction],
ok=$enableval, ok=no)
if test "$ok" = "yes"; then
if test "$with_integrator" = "vl"; then
FOFC_MODE="FIRST_ORDER_FLUX_CORRECTION"
FOFC_MODE_USER="ON"
else
AC_MSG_ERROR([first-order flux correction only works with VL integrator!])
fi
else
FOFC_MODE="NO_FIRST_ORDER_FLUX_CORRECTION"
FOFC_MODE_USER="OFF"
fi
#-------------------------------------------------------------------------------
# ALGORITHM FEATURE: turn on ROTATING_FRAME algorithm.
# --enable-rotframe
AC_SUBST(ROTATING_FRAME_MODE)
AC_ARG_ENABLE(rotating_frame,
[--enable-rotating_frame turn on rotating_frame],
ok=$enableval, ok=no)
if test "$ok" = "yes"; then
ROTATING_FRAME_MODE="ROTATING_FRAME"
ROTATING_FRAME_MODE_USER="ON"
else
ROTATING_FRAME_MODE="NO_ROTATING_FRAME"
ROTATING_FRAME_MODE_USER="OFF"
fi
#-------------------------------------------------------------------------------
# ALGORITHM FEATURE: turn on inflow from L1 point algorithm.
# --enable-l1_inflow
AC_SUBST(L1_INFLOW_MODE)
AC_ARG_ENABLE(l1_inflow,
[--enable-l1_inflow turn on l1_inflow],
ok=$enableval, ok=no)
if test "$ok" = "yes"; then
L1_INFLOW_MODE="L1_INFLOW"
L1_INFLOW_MODE_USER="ON"
else
L1_INFLOW_MODE="NO_L1_INFLOW"
L1_INFLOW_MODE_USER="OFF"
fi
#-------------------------------------------------------------------------------
# check for compatibility of various options
if test "$with_coord" = "cylindrical"; then
if test "$gravity_algorithm" != "none"; then
AC_MSG_ERROR([Sorry, self-gravity and cylindrical coordinates are currently incompatible!])
elif test "$particles_algorithm" != "none"; then
AC_MSG_ERROR([Sorry, particles and cylindrical coordinates are currently incompatible!])
fi
fi
if test "$with_integrator" = "vl"; then
if test "$with_order" = "3"; then
AC_MSG_ERROR([Only use order=2p or 3p with VL integrator!])
elif test "$with_order" = "2"; then
AC_MSG_ERROR([Only use order=2p or 3p with VL integrator!])
fi
fi
#-------------------------------------------------------------------------------
# check for various library functions
AC_PROG_GCC_TRADITIONAL
AC_CHECK_FUNCS(strdup)
AC_C_BIGENDIAN
#-------------------------------------------------------------------------------
# date and time of configure, becomes a macro in defs.h
A_CONFIGURE_DATE="`date`"
AC_SUBST(A_CONFIGURE_DATE)
#-------------------------------------------------------------------------------
# write final diagnostic output
AC_SUBST(WARNING1)
AC_SUBST(WARNING2)
WARNING1="WARNING! This file has been automatically generated by configure."
WARNING2="Any changes to it will be overwritten the next time configure is run."
AC_CONFIG_FILES(Makefile Makeoptions src/Makefile src/defs.h src/fftsrc/Makefile src/gravity/Makefile src/integrators/Makefile src/microphysics/Makefile src/reconstruction/Makefile src/rsolvers/Makefile src/particles/Makefile)
AC_OUTPUT
echo ""
echo "Your Athena distribution has now been configured:"
echo ""
echo "--- Physics Options ---"
echo ""
echo "Problem: $PROBLEM"
echo "Gas properties: $GAS"
echo "Equation of State: $EOS"
echo "Coordinate System: $COORD"
echo "Advected scalar fields: $NSCALARS"
if test "$gravity_algorithm" = "none"; then
echo "Self-gravity: $SELF_GRAVITY_USER"
else
echo "Self-gravity: $SELF_GRAVITY_ALGORITHM"
fi
echo "Resistivity: $RESISTIVITY_MODE_USER"
echo "Viscosity: $VISCOSITY_MODE_USER"
echo "Thermal conduction: $CONDUCTION_MODE_USER"
echo "Cooling: $COOLING_MODE_USER"
echo "Particles: $PARTICLES_USER"
echo "Special Relativity: $SPECIAL_RELATIVITY_MODE_USER"
echo ""
echo "--- Algorithm Options ----"
echo ""
echo "Spatial Order: $ORDER ($ACCURACY)"
echo "Flux: $FLUX_NAME"
echo "unsplit integrator: $INTEGRATOR"
echo "Precision: $PRECISION"
echo "Compiler options: $COMPILER_OPTS"
echo "Ghost cell output: $WRITE_GHOST_MODE_USER"
echo "Parallel modes: MPI $MPI_MODE_USER"
echo "H-correction: $H_CORRECTION_MODE_USER"
echo "FFT: $FFT_MODE_USER"
echo "Shearing-box: $SHEARING_BOX_MODE_USER"
echo "FARGO: $FARGO_MODE_USER"
echo "Super timestepping: $TIMESTEPPING_MODE_USER"
echo "Static Mesh Refinement: $SMR_MODE_USER"
echo "first-order flux corr: $FOFC_MODE_USER"
echo "ROTATING_FRAME: $ROTATING_FRAME_MODE_USER"
echo "L1_INFLOW: $L1_INFLOW_MODE_USER"