Index: /issm/trunk-jpl/m4/analyses.m4 =================================================================== --- /issm/trunk-jpl/m4/analyses.m4 (revision 27153) +++ /issm/trunk-jpl/m4/analyses.m4 (revision 27154) @@ -11,1068 +11,590 @@ dnl with-HydrologyTws{{{ - AC_ARG_WITH([HydrologyTws], - AS_HELP_STRING([--with-HydrologyTws = YES], [compile with HydrologyTws capabilities (default is yes)]), - [HYDROLOGYTWS=$withval],[HYDROLOGYTWS=yes]) - AC_MSG_CHECKING(for HydrologyTws capability compilation) - HAVE_HYDROLOGYTWS=no - if test "x$HYDROLOGYTWS" = "xyes"; then - HAVE_HYDROLOGYTWS=yes - AC_DEFINE([_HAVE_HYDROLOGYTWS_],[1],[with HydrologyTws capability]) - -fi - +fi AM_CONDITIONAL([HYDROLOGYTWS], [test x$HAVE_HYDROLOGYTWS = xyes]) - AC_MSG_RESULT($HAVE_HYDROLOGYTWS) - dnl }}} dnl with-AdjointBalancethickness2{{{ - AC_ARG_WITH([AdjointBalancethickness2], - AS_HELP_STRING([--with-AdjointBalancethickness2 = YES], [compile with AdjointBalancethickness2 capabilities (default is yes)]), - [ADJOINTBALANCETHICKNESS2=$withval],[ADJOINTBALANCETHICKNESS2=yes]) - AC_MSG_CHECKING(for AdjointBalancethickness2 capability compilation) - HAVE_ADJOINTBALANCETHICKNESS2=no - if test "x$ADJOINTBALANCETHICKNESS2" = "xyes"; then - HAVE_ADJOINTBALANCETHICKNESS2=yes - AC_DEFINE([_HAVE_ADJOINTBALANCETHICKNESS2_],[1],[with AdjointBalancethickness2 capability]) - -fi - +fi AM_CONDITIONAL([ADJOINTBALANCETHICKNESS2], [test x$HAVE_ADJOINTBALANCETHICKNESS2 = xyes]) - AC_MSG_RESULT($HAVE_ADJOINTBALANCETHICKNESS2) - dnl }}} dnl with-AdjointBalancethickness{{{ - AC_ARG_WITH([AdjointBalancethickness], - AS_HELP_STRING([--with-AdjointBalancethickness = YES], [compile with AdjointBalancethickness capabilities (default is yes)]), - [ADJOINTBALANCETHICKNESS=$withval],[ADJOINTBALANCETHICKNESS=yes]) - AC_MSG_CHECKING(for AdjointBalancethickness capability compilation) - HAVE_ADJOINTBALANCETHICKNESS=no - if test "x$ADJOINTBALANCETHICKNESS" = "xyes"; then - HAVE_ADJOINTBALANCETHICKNESS=yes - AC_DEFINE([_HAVE_ADJOINTBALANCETHICKNESS_],[1],[with AdjointBalancethickness capability]) - -fi - +fi AM_CONDITIONAL([ADJOINTBALANCETHICKNESS], [test x$HAVE_ADJOINTBALANCETHICKNESS = xyes]) - AC_MSG_RESULT($HAVE_ADJOINTBALANCETHICKNESS) - dnl }}} dnl with-AdjointHoriz{{{ - AC_ARG_WITH([AdjointHoriz], - AS_HELP_STRING([--with-AdjointHoriz = YES], [compile with AdjointHoriz capabilities (default is yes)]), - [ADJOINTHORIZ=$withval],[ADJOINTHORIZ=yes]) - AC_MSG_CHECKING(for AdjointHoriz capability compilation) - HAVE_ADJOINTHORIZ=no - if test "x$ADJOINTHORIZ" = "xyes"; then - HAVE_ADJOINTHORIZ=yes - AC_DEFINE([_HAVE_ADJOINTHORIZ_],[1],[with AdjointHoriz capability]) - -fi - +fi AM_CONDITIONAL([ADJOINTHORIZ], [test x$HAVE_ADJOINTHORIZ = xyes]) - AC_MSG_RESULT($HAVE_ADJOINTHORIZ) - +dnl }}} +dnl with-Age{{{ +AC_ARG_WITH([Age], + AS_HELP_STRING([--with-Age = YES], [compile with Age capabilities (default is yes)]), + [AGE=$withval],[AGE=yes]) +AC_MSG_CHECKING(for Age capability compilation) + +HAVE_AGE=no +if test "x$AGE" = "xyes"; then + HAVE_AGE=yes + AC_DEFINE([_HAVE_AGE_],[1],[with Age capability]) +fi +AM_CONDITIONAL([AGE], [test x$HAVE_AGE = xyes]) +AC_MSG_RESULT($HAVE_AGE) dnl }}} dnl with-Balancethickness2{{{ - AC_ARG_WITH([Balancethickness2], - AS_HELP_STRING([--with-Balancethickness2 = YES], [compile with Balancethickness2 capabilities (default is yes)]), - [BALANCETHICKNESS2=$withval],[BALANCETHICKNESS2=yes]) - AC_MSG_CHECKING(for Balancethickness2 capability compilation) - HAVE_BALANCETHICKNESS2=no - if test "x$BALANCETHICKNESS2" = "xyes"; then - HAVE_BALANCETHICKNESS2=yes - AC_DEFINE([_HAVE_BALANCETHICKNESS2_],[1],[with Balancethickness2 capability]) - -fi - +fi AM_CONDITIONAL([BALANCETHICKNESS2], [test x$HAVE_BALANCETHICKNESS2 = xyes]) - AC_MSG_RESULT($HAVE_BALANCETHICKNESS2) - dnl }}} dnl with-Balancethickness{{{ - AC_ARG_WITH([Balancethickness], - AS_HELP_STRING([--with-Balancethickness = YES], [compile with Balancethickness capabilities (default is yes)]), - [BALANCETHICKNESS=$withval],[BALANCETHICKNESS=yes]) - AC_MSG_CHECKING(for Balancethickness capability compilation) - HAVE_BALANCETHICKNESS=no - if test "x$BALANCETHICKNESS" = "xyes"; then - HAVE_BALANCETHICKNESS=yes - AC_DEFINE([_HAVE_BALANCETHICKNESS_],[1],[with Balancethickness capability]) - -fi - +fi AM_CONDITIONAL([BALANCETHICKNESS], [test x$HAVE_BALANCETHICKNESS = xyes]) - AC_MSG_RESULT($HAVE_BALANCETHICKNESS) - dnl }}} dnl with-BalancethicknessSoft{{{ - AC_ARG_WITH([BalancethicknessSoft], - AS_HELP_STRING([--with-BalancethicknessSoft = YES], [compile with BalancethicknessSoft capabilities (default is yes)]), - [BALANCETHICKNESSSOFT=$withval],[BALANCETHICKNESSSOFT=yes]) - AC_MSG_CHECKING(for BalancethicknessSoft capability compilation) - HAVE_BALANCETHICKNESSSOFT=no - if test "x$BALANCETHICKNESSSOFT" = "xyes"; then - HAVE_BALANCETHICKNESSSOFT=yes - AC_DEFINE([_HAVE_BALANCETHICKNESSSOFT_],[1],[with BalancethicknessSoft capability]) - -fi - +fi AM_CONDITIONAL([BALANCETHICKNESSSOFT], [test x$HAVE_BALANCETHICKNESSSOFT = xyes]) - AC_MSG_RESULT($HAVE_BALANCETHICKNESSSOFT) - dnl }}} dnl with-Balancevelocity{{{ - AC_ARG_WITH([Balancevelocity], - AS_HELP_STRING([--with-Balancevelocity = YES], [compile with Balancevelocity capabilities (default is yes)]), - [BALANCEVELOCITY=$withval],[BALANCEVELOCITY=yes]) - AC_MSG_CHECKING(for Balancevelocity capability compilation) - HAVE_BALANCEVELOCITY=no - if test "x$BALANCEVELOCITY" = "xyes"; then - HAVE_BALANCEVELOCITY=yes - AC_DEFINE([_HAVE_BALANCEVELOCITY_],[1],[with Balancevelocity capability]) - -fi - +fi AM_CONDITIONAL([BALANCEVELOCITY], [test x$HAVE_BALANCEVELOCITY = xyes]) - AC_MSG_RESULT($HAVE_BALANCEVELOCITY) - dnl }}} dnl with-DamageEvolution{{{ - AC_ARG_WITH([DamageEvolution], - AS_HELP_STRING([--with-DamageEvolution = YES], [compile with DamageEvolution capabilities (default is yes)]), - [DAMAGEEVOLUTION=$withval],[DAMAGEEVOLUTION=yes]) - AC_MSG_CHECKING(for DamageEvolution capability compilation) - HAVE_DAMAGEEVOLUTION=no - if test "x$DAMAGEEVOLUTION" = "xyes"; then - HAVE_DAMAGEEVOLUTION=yes - AC_DEFINE([_HAVE_DAMAGEEVOLUTION_],[1],[with DamageEvolution capability]) - -fi - +fi AM_CONDITIONAL([DAMAGEEVOLUTION], [test x$HAVE_DAMAGEEVOLUTION = xyes]) - AC_MSG_RESULT($HAVE_DAMAGEEVOLUTION) - dnl }}} dnl with-DepthAverage{{{ - AC_ARG_WITH([DepthAverage], - AS_HELP_STRING([--with-DepthAverage = YES], [compile with DepthAverage capabilities (default is yes)]), - [DEPTHAVERAGE=$withval],[DEPTHAVERAGE=yes]) - AC_MSG_CHECKING(for DepthAverage capability compilation) - HAVE_DEPTHAVERAGE=no - if test "x$DEPTHAVERAGE" = "xyes"; then - HAVE_DEPTHAVERAGE=yes - AC_DEFINE([_HAVE_DEPTHAVERAGE_],[1],[with DepthAverage capability]) - -fi - +fi AM_CONDITIONAL([DEPTHAVERAGE], [test x$HAVE_DEPTHAVERAGE = xyes]) - AC_MSG_RESULT($HAVE_DEPTHAVERAGE) - dnl }}} dnl with-Enthalpy{{{ - AC_ARG_WITH([Enthalpy], - AS_HELP_STRING([--with-Enthalpy = YES], [compile with Enthalpy capabilities (default is yes)]), - [ENTHALPY=$withval],[ENTHALPY=yes]) - AC_MSG_CHECKING(for Enthalpy capability compilation) - HAVE_ENTHALPY=no - if test "x$ENTHALPY" = "xyes"; then - HAVE_ENTHALPY=yes - AC_DEFINE([_HAVE_ENTHALPY_],[1],[with Enthalpy capability]) - -fi - +fi AM_CONDITIONAL([ENTHALPY], [test x$HAVE_ENTHALPY = xyes]) - AC_MSG_RESULT($HAVE_ENTHALPY) - dnl }}} dnl with-Esa{{{ - AC_ARG_WITH([Esa], - AS_HELP_STRING([--with-Esa = YES], [compile with Esa capabilities (default is yes)]), - [ESA=$withval],[ESA=yes]) - AC_MSG_CHECKING(for Esa capability compilation) - HAVE_ESA=no - if test "x$ESA" = "xyes"; then - HAVE_ESA=yes - AC_DEFINE([_HAVE_ESA_],[1],[with Esa capability]) - -fi - +fi AM_CONDITIONAL([ESA], [test x$HAVE_ESA = xyes]) - AC_MSG_RESULT($HAVE_ESA) - dnl }}} dnl with-Extrapolation{{{ - AC_ARG_WITH([Extrapolation], - AS_HELP_STRING([--with-Extrapolation = YES], [compile with Extrapolation capabilities (default is yes)]), - [EXTRAPOLATION=$withval],[EXTRAPOLATION=yes]) - AC_MSG_CHECKING(for Extrapolation capability compilation) - HAVE_EXTRAPOLATION=no - if test "x$EXTRAPOLATION" = "xyes"; then - HAVE_EXTRAPOLATION=yes - AC_DEFINE([_HAVE_EXTRAPOLATION_],[1],[with Extrapolation capability]) - -fi - +fi AM_CONDITIONAL([EXTRAPOLATION], [test x$HAVE_EXTRAPOLATION = xyes]) - AC_MSG_RESULT($HAVE_EXTRAPOLATION) - dnl }}} dnl with-ExtrudeFromBase{{{ - AC_ARG_WITH([ExtrudeFromBase], - AS_HELP_STRING([--with-ExtrudeFromBase = YES], [compile with ExtrudeFromBase capabilities (default is yes)]), - [EXTRUDEFROMBASE=$withval],[EXTRUDEFROMBASE=yes]) - AC_MSG_CHECKING(for ExtrudeFromBase capability compilation) - HAVE_EXTRUDEFROMBASE=no - if test "x$EXTRUDEFROMBASE" = "xyes"; then - HAVE_EXTRUDEFROMBASE=yes - AC_DEFINE([_HAVE_EXTRUDEFROMBASE_],[1],[with ExtrudeFromBase capability]) - -fi - +fi AM_CONDITIONAL([EXTRUDEFROMBASE], [test x$HAVE_EXTRUDEFROMBASE = xyes]) - AC_MSG_RESULT($HAVE_EXTRUDEFROMBASE) - dnl }}} dnl with-ExtrudeFromTop{{{ - AC_ARG_WITH([ExtrudeFromTop], - AS_HELP_STRING([--with-ExtrudeFromTop = YES], [compile with ExtrudeFromTop capabilities (default is yes)]), - [EXTRUDEFROMTOP=$withval],[EXTRUDEFROMTOP=yes]) - AC_MSG_CHECKING(for ExtrudeFromTop capability compilation) - HAVE_EXTRUDEFROMTOP=no - if test "x$EXTRUDEFROMTOP" = "xyes"; then - HAVE_EXTRUDEFROMTOP=yes - AC_DEFINE([_HAVE_EXTRUDEFROMTOP_],[1],[with ExtrudeFromTop capability]) - -fi - +fi AM_CONDITIONAL([EXTRUDEFROMTOP], [test x$HAVE_EXTRUDEFROMTOP = xyes]) - AC_MSG_RESULT($HAVE_EXTRUDEFROMTOP) - dnl }}} dnl with-FreeSurfaceBase{{{ - AC_ARG_WITH([FreeSurfaceBase], - AS_HELP_STRING([--with-FreeSurfaceBase = YES], [compile with FreeSurfaceBase capabilities (default is yes)]), - [FREESURFACEBASE=$withval],[FREESURFACEBASE=yes]) - AC_MSG_CHECKING(for FreeSurfaceBase capability compilation) - HAVE_FREESURFACEBASE=no - if test "x$FREESURFACEBASE" = "xyes"; then - HAVE_FREESURFACEBASE=yes - AC_DEFINE([_HAVE_FREESURFACEBASE_],[1],[with FreeSurfaceBase capability]) - -fi - +fi AM_CONDITIONAL([FREESURFACEBASE], [test x$HAVE_FREESURFACEBASE = xyes]) - AC_MSG_RESULT($HAVE_FREESURFACEBASE) - dnl }}} dnl with-FreeSurfaceTop{{{ - AC_ARG_WITH([FreeSurfaceTop], - AS_HELP_STRING([--with-FreeSurfaceTop = YES], [compile with FreeSurfaceTop capabilities (default is yes)]), - [FREESURFACETOP=$withval],[FREESURFACETOP=yes]) - AC_MSG_CHECKING(for FreeSurfaceTop capability compilation) - HAVE_FREESURFACETOP=no - if test "x$FREESURFACETOP" = "xyes"; then - HAVE_FREESURFACETOP=yes - AC_DEFINE([_HAVE_FREESURFACETOP_],[1],[with FreeSurfaceTop capability]) - -fi - +fi AM_CONDITIONAL([FREESURFACETOP], [test x$HAVE_FREESURFACETOP = xyes]) - AC_MSG_RESULT($HAVE_FREESURFACETOP) - dnl }}} dnl with-GLheightadvection{{{ - AC_ARG_WITH([GLheightadvection], - AS_HELP_STRING([--with-GLheightadvection = YES], [compile with GLheightadvection capabilities (default is yes)]), - [GLHEIGHTADVECTION=$withval],[GLHEIGHTADVECTION=yes]) - AC_MSG_CHECKING(for GLheightadvection capability compilation) - HAVE_GLHEIGHTADVECTION=no - if test "x$GLHEIGHTADVECTION" = "xyes"; then - HAVE_GLHEIGHTADVECTION=yes - AC_DEFINE([_HAVE_GLHEIGHTADVECTION_],[1],[with GLheightadvection capability]) - -fi - +fi AM_CONDITIONAL([GLHEIGHTADVECTION], [test x$HAVE_GLHEIGHTADVECTION = xyes]) - AC_MSG_RESULT($HAVE_GLHEIGHTADVECTION) - dnl }}} dnl with-HydrologyDCEfficient{{{ - AC_ARG_WITH([HydrologyDCEfficient], - AS_HELP_STRING([--with-HydrologyDCEfficient = YES], [compile with HydrologyDCEfficient capabilities (default is yes)]), - [HYDROLOGYDCEFFICIENT=$withval],[HYDROLOGYDCEFFICIENT=yes]) - AC_MSG_CHECKING(for HydrologyDCEfficient capability compilation) - HAVE_HYDROLOGYDCEFFICIENT=no - if test "x$HYDROLOGYDCEFFICIENT" = "xyes"; then - HAVE_HYDROLOGYDCEFFICIENT=yes - AC_DEFINE([_HAVE_HYDROLOGYDCEFFICIENT_],[1],[with HydrologyDCEfficient capability]) - -fi - +fi AM_CONDITIONAL([HYDROLOGYDCEFFICIENT], [test x$HAVE_HYDROLOGYDCEFFICIENT = xyes]) - AC_MSG_RESULT($HAVE_HYDROLOGYDCEFFICIENT) - dnl }}} dnl with-HydrologyDCInefficient{{{ - AC_ARG_WITH([HydrologyDCInefficient], - AS_HELP_STRING([--with-HydrologyDCInefficient = YES], [compile with HydrologyDCInefficient capabilities (default is yes)]), - [HYDROLOGYDCINEFFICIENT=$withval],[HYDROLOGYDCINEFFICIENT=yes]) - AC_MSG_CHECKING(for HydrologyDCInefficient capability compilation) - HAVE_HYDROLOGYDCINEFFICIENT=no - if test "x$HYDROLOGYDCINEFFICIENT" = "xyes"; then - HAVE_HYDROLOGYDCINEFFICIENT=yes - AC_DEFINE([_HAVE_HYDROLOGYDCINEFFICIENT_],[1],[with HydrologyDCInefficient capability]) - -fi - +fi AM_CONDITIONAL([HYDROLOGYDCINEFFICIENT], [test x$HAVE_HYDROLOGYDCINEFFICIENT = xyes]) - AC_MSG_RESULT($HAVE_HYDROLOGYDCINEFFICIENT) - dnl }}} dnl with-HydrologyGlaDS{{{ - AC_ARG_WITH([HydrologyGlaDS], - AS_HELP_STRING([--with-HydrologyGlaDS = YES], [compile with HydrologyGlaDS capabilities (default is yes)]), - [HYDROLOGYGLADS=$withval],[HYDROLOGYGLADS=yes]) - AC_MSG_CHECKING(for HydrologyGlaDS capability compilation) - HAVE_HYDROLOGYGLADS=no - if test "x$HYDROLOGYGLADS" = "xyes"; then - HAVE_HYDROLOGYGLADS=yes - AC_DEFINE([_HAVE_HYDROLOGYGLADS_],[1],[with HydrologyGlaDS capability]) - -fi - +fi AM_CONDITIONAL([HYDROLOGYGLADS], [test x$HAVE_HYDROLOGYGLADS = xyes]) - AC_MSG_RESULT($HAVE_HYDROLOGYGLADS) - dnl }}} dnl with-HydrologyPism{{{ - AC_ARG_WITH([HydrologyPism], - AS_HELP_STRING([--with-HydrologyPism = YES], [compile with HydrologyPism capabilities (default is yes)]), - [HYDROLOGYPISM=$withval],[HYDROLOGYPISM=yes]) - AC_MSG_CHECKING(for HydrologyPism capability compilation) - HAVE_HYDROLOGYPISM=no - if test "x$HYDROLOGYPISM" = "xyes"; then - HAVE_HYDROLOGYPISM=yes - AC_DEFINE([_HAVE_HYDROLOGYPISM_],[1],[with HydrologyPism capability]) - -fi - +fi AM_CONDITIONAL([HYDROLOGYPISM], [test x$HAVE_HYDROLOGYPISM = xyes]) - AC_MSG_RESULT($HAVE_HYDROLOGYPISM) - dnl }}} dnl with-HydrologyShakti{{{ - AC_ARG_WITH([HydrologyShakti], - AS_HELP_STRING([--with-HydrologyShakti = YES], [compile with HydrologyShakti capabilities (default is yes)]), - [HYDROLOGYSHAKTI=$withval],[HYDROLOGYSHAKTI=yes]) - AC_MSG_CHECKING(for HydrologyShakti capability compilation) - HAVE_HYDROLOGYSHAKTI=no - if test "x$HYDROLOGYSHAKTI" = "xyes"; then - HAVE_HYDROLOGYSHAKTI=yes - AC_DEFINE([_HAVE_HYDROLOGYSHAKTI_],[1],[with HydrologyShakti capability]) - -fi - +fi AM_CONDITIONAL([HYDROLOGYSHAKTI], [test x$HAVE_HYDROLOGYSHAKTI = xyes]) - AC_MSG_RESULT($HAVE_HYDROLOGYSHAKTI) - dnl }}} dnl with-HydrologyShreve{{{ - AC_ARG_WITH([HydrologyShreve], - AS_HELP_STRING([--with-HydrologyShreve = YES], [compile with HydrologyShreve capabilities (default is yes)]), - [HYDROLOGYSHREVE=$withval],[HYDROLOGYSHREVE=yes]) - AC_MSG_CHECKING(for HydrologyShreve capability compilation) - HAVE_HYDROLOGYSHREVE=no - if test "x$HYDROLOGYSHREVE" = "xyes"; then - HAVE_HYDROLOGYSHREVE=yes - AC_DEFINE([_HAVE_HYDROLOGYSHREVE_],[1],[with HydrologyShreve capability]) - -fi - +fi AM_CONDITIONAL([HYDROLOGYSHREVE], [test x$HAVE_HYDROLOGYSHREVE = xyes]) - AC_MSG_RESULT($HAVE_HYDROLOGYSHREVE) - dnl }}} dnl with-L2ProjectionBase{{{ - AC_ARG_WITH([L2ProjectionBase], - AS_HELP_STRING([--with-L2ProjectionBase = YES], [compile with L2ProjectionBase capabilities (default is yes)]), - [L2PROJECTIONBASE=$withval],[L2PROJECTIONBASE=yes]) - AC_MSG_CHECKING(for L2ProjectionBase capability compilation) - HAVE_L2PROJECTIONBASE=no - if test "x$L2PROJECTIONBASE" = "xyes"; then - HAVE_L2PROJECTIONBASE=yes - AC_DEFINE([_HAVE_L2PROJECTIONBASE_],[1],[with L2ProjectionBase capability]) - -fi - +fi AM_CONDITIONAL([L2PROJECTIONBASE], [test x$HAVE_L2PROJECTIONBASE = xyes]) - AC_MSG_RESULT($HAVE_L2PROJECTIONBASE) - dnl }}} dnl with-L2ProjectionEPL{{{ - AC_ARG_WITH([L2ProjectionEPL], - AS_HELP_STRING([--with-L2ProjectionEPL = YES], [compile with L2ProjectionEPL capabilities (default is yes)]), - [L2PROJECTIONEPL=$withval],[L2PROJECTIONEPL=yes]) - AC_MSG_CHECKING(for L2ProjectionEPL capability compilation) - HAVE_L2PROJECTIONEPL=no - if test "x$L2PROJECTIONEPL" = "xyes"; then - HAVE_L2PROJECTIONEPL=yes - AC_DEFINE([_HAVE_L2PROJECTIONEPL_],[1],[with L2ProjectionEPL capability]) - -fi - +fi AM_CONDITIONAL([L2PROJECTIONEPL], [test x$HAVE_L2PROJECTIONEPL = xyes]) - AC_MSG_RESULT($HAVE_L2PROJECTIONEPL) - dnl }}} dnl with-Levelset{{{ - AC_ARG_WITH([Levelset], - AS_HELP_STRING([--with-Levelset = YES], [compile with Levelset capabilities (default is yes)]), - [LEVELSET=$withval],[LEVELSET=yes]) - AC_MSG_CHECKING(for Levelset capability compilation) - HAVE_LEVELSET=no - if test "x$LEVELSET" = "xyes"; then - HAVE_LEVELSET=yes - AC_DEFINE([_HAVE_LEVELSET_],[1],[with Levelset capability]) - -fi - +fi AM_CONDITIONAL([LEVELSET], [test x$HAVE_LEVELSET = xyes]) - AC_MSG_RESULT($HAVE_LEVELSET) - dnl }}} dnl with-Love{{{ - AC_ARG_WITH([Love], - AS_HELP_STRING([--with-Love = YES], [compile with Love capabilities (default is yes)]), - [LOVE=$withval],[LOVE=yes]) - AC_MSG_CHECKING(for Love capability compilation) - HAVE_LOVE=no - if test "x$LOVE" = "xyes"; then - HAVE_LOVE=yes - AC_DEFINE([_HAVE_LOVE_],[1],[with Love capability]) - -fi - +fi AM_CONDITIONAL([LOVE], [test x$HAVE_LOVE = xyes]) - AC_MSG_RESULT($HAVE_LOVE) - dnl }}} dnl with-Masstransport{{{ - AC_ARG_WITH([Masstransport], - AS_HELP_STRING([--with-Masstransport = YES], [compile with Masstransport capabilities (default is yes)]), - [MASSTRANSPORT=$withval],[MASSTRANSPORT=yes]) - AC_MSG_CHECKING(for Masstransport capability compilation) - HAVE_MASSTRANSPORT=no - if test "x$MASSTRANSPORT" = "xyes"; then - HAVE_MASSTRANSPORT=yes - AC_DEFINE([_HAVE_MASSTRANSPORT_],[1],[with Masstransport capability]) - -fi - +fi AM_CONDITIONAL([MASSTRANSPORT], [test x$HAVE_MASSTRANSPORT = xyes]) - AC_MSG_RESULT($HAVE_MASSTRANSPORT) - dnl }}} dnl with-Melting{{{ - AC_ARG_WITH([Melting], - AS_HELP_STRING([--with-Melting = YES], [compile with Melting capabilities (default is yes)]), - [MELTING=$withval],[MELTING=yes]) - AC_MSG_CHECKING(for Melting capability compilation) - HAVE_MELTING=no - if test "x$MELTING" = "xyes"; then - HAVE_MELTING=yes - AC_DEFINE([_HAVE_MELTING_],[1],[with Melting capability]) - -fi - +fi AM_CONDITIONAL([MELTING], [test x$HAVE_MELTING = xyes]) - AC_MSG_RESULT($HAVE_MELTING) - dnl }}} dnl with-Oceantransport{{{ - AC_ARG_WITH([Oceantransport], - AS_HELP_STRING([--with-Oceantransport = YES], [compile with Oceantransport capabilities (default is yes)]), - [OCEANTRANSPORT=$withval],[OCEANTRANSPORT=yes]) - AC_MSG_CHECKING(for Oceantransport capability compilation) - HAVE_OCEANTRANSPORT=no - if test "x$OCEANTRANSPORT" = "xyes"; then - HAVE_OCEANTRANSPORT=yes - AC_DEFINE([_HAVE_OCEANTRANSPORT_],[1],[with Oceantransport capability]) - -fi - +fi AM_CONDITIONAL([OCEANTRANSPORT], [test x$HAVE_OCEANTRANSPORT = xyes]) - AC_MSG_RESULT($HAVE_OCEANTRANSPORT) - dnl }}} dnl with-Recovery{{{ - AC_ARG_WITH([Recovery], - AS_HELP_STRING([--with-Recovery = YES], [compile with Recovery capabilities (default is yes)]), - [RECOVERY=$withval],[RECOVERY=yes]) - AC_MSG_CHECKING(for Recovery capability compilation) - HAVE_RECOVERY=no - if test "x$RECOVERY" = "xyes"; then - HAVE_RECOVERY=yes - AC_DEFINE([_HAVE_RECOVERY_],[1],[with Recovery capability]) - -fi - +fi AM_CONDITIONAL([RECOVERY], [test x$HAVE_RECOVERY = xyes]) - AC_MSG_RESULT($HAVE_RECOVERY) - dnl }}} dnl with-Sampling{{{ - AC_ARG_WITH([Sampling], - AS_HELP_STRING([--with-Sampling = YES], [compile with Sampling capabilities (default is yes)]), - [SAMPLING=$withval],[SAMPLING=yes]) - AC_MSG_CHECKING(for Sampling capability compilation) - HAVE_SAMPLING=no - if test "x$SAMPLING" = "xyes"; then - HAVE_SAMPLING=yes - AC_DEFINE([_HAVE_SAMPLING_],[1],[with Sampling capability]) - -fi - +fi AM_CONDITIONAL([SAMPLING], [test x$HAVE_SAMPLING = xyes]) - AC_MSG_RESULT($HAVE_SAMPLING) - dnl }}} dnl with-Sealevelchange{{{ - AC_ARG_WITH([Sealevelchange], - AS_HELP_STRING([--with-Sealevelchange = YES], [compile with Sealevelchange capabilities (default is yes)]), - [SEALEVELCHANGE=$withval],[SEALEVELCHANGE=yes]) - AC_MSG_CHECKING(for Sealevelchange capability compilation) - HAVE_SEALEVELCHANGE=no - if test "x$SEALEVELCHANGE" = "xyes"; then - HAVE_SEALEVELCHANGE=yes - AC_DEFINE([_HAVE_SEALEVELCHANGE_],[1],[with Sealevelchange capability]) - -fi - +fi AM_CONDITIONAL([SEALEVELCHANGE], [test x$HAVE_SEALEVELCHANGE = xyes]) - AC_MSG_RESULT($HAVE_SEALEVELCHANGE) - dnl }}} dnl with-Smb{{{ - AC_ARG_WITH([Smb], - AS_HELP_STRING([--with-Smb = YES], [compile with Smb capabilities (default is yes)]), - [SMB=$withval],[SMB=yes]) - AC_MSG_CHECKING(for Smb capability compilation) - HAVE_SMB=no - if test "x$SMB" = "xyes"; then - HAVE_SMB=yes - AC_DEFINE([_HAVE_SMB_],[1],[with Smb capability]) - -fi - +fi AM_CONDITIONAL([SMB], [test x$HAVE_SMB = xyes]) - AC_MSG_RESULT($HAVE_SMB) - dnl }}} dnl with-Smooth{{{ - AC_ARG_WITH([Smooth], - AS_HELP_STRING([--with-Smooth = YES], [compile with Smooth capabilities (default is yes)]), - [SMOOTH=$withval],[SMOOTH=yes]) - AC_MSG_CHECKING(for Smooth capability compilation) - HAVE_SMOOTH=no - if test "x$SMOOTH" = "xyes"; then - HAVE_SMOOTH=yes - AC_DEFINE([_HAVE_SMOOTH_],[1],[with Smooth capability]) - -fi - +fi AM_CONDITIONAL([SMOOTH], [test x$HAVE_SMOOTH = xyes]) - AC_MSG_RESULT($HAVE_SMOOTH) - dnl }}} dnl with-Stressbalance{{{ - AC_ARG_WITH([Stressbalance], - AS_HELP_STRING([--with-Stressbalance = YES], [compile with Stressbalance capabilities (default is yes)]), - [STRESSBALANCE=$withval],[STRESSBALANCE=yes]) - AC_MSG_CHECKING(for Stressbalance capability compilation) - HAVE_STRESSBALANCE=no - if test "x$STRESSBALANCE" = "xyes"; then - HAVE_STRESSBALANCE=yes - AC_DEFINE([_HAVE_STRESSBALANCE_],[1],[with Stressbalance capability]) - -fi - +fi AM_CONDITIONAL([STRESSBALANCE], [test x$HAVE_STRESSBALANCE = xyes]) - AC_MSG_RESULT($HAVE_STRESSBALANCE) - dnl }}} dnl with-StressbalanceSIA{{{ - AC_ARG_WITH([StressbalanceSIA], - AS_HELP_STRING([--with-StressbalanceSIA = YES], [compile with StressbalanceSIA capabilities (default is yes)]), - [STRESSBALANCESIA=$withval],[STRESSBALANCESIA=yes]) - AC_MSG_CHECKING(for StressbalanceSIA capability compilation) - HAVE_STRESSBALANCESIA=no - if test "x$STRESSBALANCESIA" = "xyes"; then - HAVE_STRESSBALANCESIA=yes - AC_DEFINE([_HAVE_STRESSBALANCESIA_],[1],[with StressbalanceSIA capability]) - -fi - +fi AM_CONDITIONAL([STRESSBALANCESIA], [test x$HAVE_STRESSBALANCESIA = xyes]) - AC_MSG_RESULT($HAVE_STRESSBALANCESIA) - dnl }}} dnl with-StressbalanceVertical{{{ - AC_ARG_WITH([StressbalanceVertical], - AS_HELP_STRING([--with-StressbalanceVertical = YES], [compile with StressbalanceVertical capabilities (default is yes)]), - [STRESSBALANCEVERTICAL=$withval],[STRESSBALANCEVERTICAL=yes]) - AC_MSG_CHECKING(for StressbalanceVertical capability compilation) - HAVE_STRESSBALANCEVERTICAL=no - if test "x$STRESSBALANCEVERTICAL" = "xyes"; then - HAVE_STRESSBALANCEVERTICAL=yes - AC_DEFINE([_HAVE_STRESSBALANCEVERTICAL_],[1],[with StressbalanceVertical capability]) - -fi - +fi AM_CONDITIONAL([STRESSBALANCEVERTICAL], [test x$HAVE_STRESSBALANCEVERTICAL = xyes]) - AC_MSG_RESULT($HAVE_STRESSBALANCEVERTICAL) - dnl }}} dnl with-Thermal{{{ - AC_ARG_WITH([Thermal], - AS_HELP_STRING([--with-Thermal = YES], [compile with Thermal capabilities (default is yes)]), - [THERMAL=$withval],[THERMAL=yes]) - AC_MSG_CHECKING(for Thermal capability compilation) - HAVE_THERMAL=no - if test "x$THERMAL" = "xyes"; then - HAVE_THERMAL=yes - AC_DEFINE([_HAVE_THERMAL_],[1],[with Thermal capability]) - -fi - +fi AM_CONDITIONAL([THERMAL], [test x$HAVE_THERMAL = xyes]) - AC_MSG_RESULT($HAVE_THERMAL) - dnl }}} dnl with-UzawaPressure{{{ - AC_ARG_WITH([UzawaPressure], - AS_HELP_STRING([--with-UzawaPressure = YES], [compile with UzawaPressure capabilities (default is yes)]), - [UZAWAPRESSURE=$withval],[UZAWAPRESSURE=yes]) - AC_MSG_CHECKING(for UzawaPressure capability compilation) - HAVE_UZAWAPRESSURE=no - if test "x$UZAWAPRESSURE" = "xyes"; then - HAVE_UZAWAPRESSURE=yes - AC_DEFINE([_HAVE_UZAWAPRESSURE_],[1],[with UzawaPressure capability]) - -fi - +fi AM_CONDITIONAL([UZAWAPRESSURE], [test x$HAVE_UZAWAPRESSURE = xyes]) - AC_MSG_RESULT($HAVE_UZAWAPRESSURE) - dnl }}} Index: /issm/trunk-jpl/src/c/Makefile.am =================================================================== --- /issm/trunk-jpl/src/c/Makefile.am (revision 27153) +++ /issm/trunk-jpl/src/c/Makefile.am (revision 27154) @@ -401,5 +401,5 @@ endif #}}} -#GSL sources {{{ +# GSL sources {{{ if GSL issm_sources += ./toolkits/gsl/DenseGslSolve.cpp @@ -420,4 +420,7 @@ if ADJOINTHORIZ issm_sources += ./analyses/AdjointHorizAnalysis.cpp +endif +if AGE +issm_sources += ./analyses/AgeAnalysis.cpp endif if BALANCETHICKNESS Index: /issm/trunk-jpl/src/c/analyses/AgeAnalysis.cpp =================================================================== --- /issm/trunk-jpl/src/c/analyses/AgeAnalysis.cpp (revision 27154) +++ /issm/trunk-jpl/src/c/analyses/AgeAnalysis.cpp (revision 27154) @@ -0,0 +1,537 @@ +#include "./AgeAnalysis.h" +#include "../toolkits/toolkits.h" +#include "../classes/classes.h" +#include "../shared/shared.h" +#include "../modules/modules.h" + +/*Model processing*/ +void AgeAnalysis::CreateConstraints(Constraints* constraints,IoModel* iomodel){/*{{{*/ + + IoModelToConstraintsx(constraints,iomodel,"md.age.spcage",AgeAnalysisEnum,P1Enum); + +}/*}}}*/ +void AgeAnalysis::CreateLoads(Loads* loads, IoModel* iomodel){/*{{{*/ + + if(iomodel->domaintype==Domain2DhorizontalEnum) _error_("2d meshes not supported yet"); + +}/*}}}*/ +void AgeAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel,bool isamr){/*{{{*/ + + int finiteelement = P1Enum; + + if(iomodel->domaintype==Domain3DEnum) iomodel->FetchData(2,"md.mesh.vertexonbase","md.mesh.vertexonsurface"); + ::CreateNodes(nodes,iomodel,AgeAnalysisEnum,finiteelement); + iomodel->DeleteData(2,"md.mesh.vertexonbase","md.mesh.vertexonsurface"); +}/*}}}*/ +int AgeAnalysis::DofsPerNode(int** doflist,int domaintype,int approximation){/*{{{*/ + return 1; +}/*}}}*/ +void AgeAnalysis::UpdateElements(Elements* elements,Inputs* inputs,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/ + + /*Now, is the model 3d? otherwise, do nothing: */ + if(iomodel->domaintype==Domain2DhorizontalEnum)return; + + /*Update elements: */ + int finiteelement = P1Enum; + int counter=0; + for(int i=0;inumberofelements;i++){ + if(iomodel->my_elements[i]){ + Element* element=(Element*)elements->GetObjectByOffset(counter); + element->Update(inputs,i,iomodel,analysis_counter,analysis_type,finiteelement); + counter++; + } + } + + bool dakota_analysis, ismovingfront; + iomodel->FetchDataToInput(inputs,elements,"md.geometry.thickness",ThicknessEnum); + iomodel->FetchDataToInput(inputs,elements,"md.geometry.surface",SurfaceEnum); + iomodel->FetchDataToInput(inputs,elements,"md.geometry.base",BaseEnum); + iomodel->FetchDataToInput(inputs,elements,"md.mask.ice_levelset",MaskIceLevelsetEnum); + iomodel->FetchDataToInput(inputs,elements,"md.mask.ocean_levelset",MaskOceanLevelsetEnum); + if(iomodel->domaintype!=Domain2DhorizontalEnum){ + iomodel->FetchDataToInput(inputs,elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum); + iomodel->FetchDataToInput(inputs,elements,"md.mesh.vertexonsurface",MeshVertexonsurfaceEnum); + } + iomodel->FetchDataToInput(inputs,elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum); + iomodel->FetchDataToInput(inputs,elements,"md.mesh.vertexonsurface",MeshVertexonsurfaceEnum); + iomodel->FetchDataToInput(inputs,elements,"md.initialization.age",AgeEnum); + iomodel->FetchDataToInput(inputs,elements,"md.initialization.vx",VxEnum); + iomodel->FetchDataToInput(inputs,elements,"md.initialization.vy",VyEnum); + iomodel->FetchDataToInput(inputs,elements,"md.initialization.vz",VzEnum); + InputUpdateFromConstantx(inputs,elements,0.,VxMeshEnum); + InputUpdateFromConstantx(inputs,elements,0.,VyMeshEnum); + InputUpdateFromConstantx(inputs,elements,0.,VzMeshEnum); +}/*}}}*/ +void AgeAnalysis::UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/ + + int numoutputs; + char** requestedoutputs = NULL; + + parameters->AddObject(iomodel->CopyConstantObject("md.age.stabilization",AgeStabilizationEnum)); + + iomodel->FindConstant(&requestedoutputs,&numoutputs,"md.age.requested_outputs"); + parameters->AddObject(new IntParam(AgeNumRequestedOutputsEnum,numoutputs)); + if(numoutputs)parameters->AddObject(new StringArrayParam(AgeRequestedOutputsEnum,requestedoutputs,numoutputs)); + iomodel->DeleteData(&requestedoutputs,numoutputs,"md.age.requested_outputs"); + +}/*}}}*/ + +/*Finite Element Analysis*/ +void AgeAnalysis::Core(FemModel* femmodel){/*{{{*/ + _error_("not implemented"); +}/*}}}*/ +void AgeAnalysis::PreCore(FemModel* femmodel){/*{{{*/ + _error_("not implemented"); +}/*}}}*/ +ElementVector* AgeAnalysis::CreateDVector(Element* element){/*{{{*/ + /*Default, return NULL*/ + return NULL; +}/*}}}*/ +ElementMatrix* AgeAnalysis::CreateJacobianMatrix(Element* element){/*{{{*/ +_error_("Not implemented"); +}/*}}}*/ +ElementMatrix* AgeAnalysis::CreateKMatrix(Element* element){/*{{{*/ + + _error_("STOP"); + /* Check if ice in element */ + if(!element->IsIceInElement()) return NULL; + + /*compute all stiffness matrices for this element*/ + ElementMatrix* Ke1=CreateKMatrixVolume(element); + ElementMatrix* Ke2=CreateKMatrixShelf(element); + ElementMatrix* Ke =new ElementMatrix(Ke1,Ke2); + + /*clean-up and return*/ + delete Ke1; + delete Ke2; + return Ke; +}/*}}}*/ +ElementMatrix* AgeAnalysis::CreateKMatrixShelf(Element* element){/*{{{*/ + + /* Check if ice in element */ + if(!element->IsIceInElement()) return NULL; + + /*Initialize Element matrix and return if necessary*/ + if(!element->IsOnBase() || !element->IsAllFloating()) return NULL; + + IssmDouble dt,Jdet,D; + IssmDouble *xyz_list_base = NULL; + + /*Get basal element*/ + if(!element->IsOnBase() || !element->IsAllFloating()) return NULL; + + /*Fetch number of nodes for this finite element*/ + int numnodes = element->GetNumberOfNodes(); + + /*Initialize vectors*/ + ElementMatrix* Ke = element->NewElementMatrix(); + IssmDouble* basis = xNew(numnodes); + + /*Retrieve all inputs and parameters*/ + element->GetVerticesCoordinatesBase(&xyz_list_base); + element->FindParam(&dt,TimesteppingTimeStepEnum); + IssmDouble gravity = element->FindParam(ConstantsGEnum); + IssmDouble rho_water = element->FindParam(MaterialsRhoSeawaterEnum); + IssmDouble rho_ice = element->FindParam(MaterialsRhoIceEnum); + IssmDouble heatcapacity = element->FindParam(MaterialsHeatcapacityEnum); + IssmDouble mixed_layer_capacity= element->FindParam(MaterialsMixedLayerCapacityEnum); + + /* Start looping on the number of gaussian points: */ + Gauss* gauss=element->NewGaussBase(4); + while(gauss->next()){ + + element->JacobianDeterminantBase(&Jdet,xyz_list_base,gauss); + element->NodalFunctions(basis,gauss); + + D=gauss->weight*Jdet*rho_water*mixed_layer_capacity/(heatcapacity*rho_ice); + if(reCast(dt)) D=dt*D; + for(int i=0;ivalues[i*numnodes+j] += D*basis[i]*basis[j]; + } + + /*Clean up and return*/ + delete gauss; + xDelete(basis); + xDelete(xyz_list_base); + return Ke; +}/*}}}*/ +ElementMatrix* AgeAnalysis::CreateKMatrixVolume(Element* element){/*{{{*/ + + /* Check if ice in element */ + if(!element->IsIceInElement()) return NULL; + + /*Intermediaries */ + int stabilization; + IssmDouble Jdet,dt,u,v,w,um,vm,wm,vel; + IssmDouble h,hx,hy,hz,vx,vy,vz,D_scalar; + IssmDouble tau_parameter,diameter; + IssmDouble tau_parameter_anisotropic[2],tau_parameter_hor,tau_parameter_ver; + IssmDouble* xyz_list = NULL; + + /*Fetch number of nodes and dof for this finite element*/ + int numnodes = element->GetNumberOfNodes(); + + /*Initialize Element vector and other vectors*/ + ElementMatrix* Ke = element->NewElementMatrix(); + IssmDouble* basis = xNew(numnodes); + IssmDouble* dbasis = xNew(3*numnodes); + IssmDouble K[3][3]; + + /*Retrieve all inputs and parameters*/ + element->GetVerticesCoordinates(&xyz_list); + element->FindParam(&dt,TimesteppingTimeStepEnum); + element->FindParam(&stabilization,AgeStabilizationEnum); + IssmDouble rho_water = element->FindParam(MaterialsRhoSeawaterEnum); + IssmDouble rho_ice = element->FindParam(MaterialsRhoIceEnum); + IssmDouble gravity = element->FindParam(ConstantsGEnum); + IssmDouble heatcapacity = element->FindParam(MaterialsHeatcapacityEnum); + IssmDouble thermalconductivity = 1.; + IssmDouble kappa = thermalconductivity/(rho_ice*heatcapacity); + Input* vx_input = element->GetInput(VxEnum); _assert_(vx_input); + Input* vy_input = element->GetInput(VyEnum); _assert_(vy_input); + Input* vz_input = element->GetInput(VzEnum); _assert_(vz_input); + Input* vxm_input = element->GetInput(VxMeshEnum); _assert_(vxm_input); + Input* vym_input = element->GetInput(VyMeshEnum); _assert_(vym_input); + Input* vzm_input = element->GetInput(VzMeshEnum); _assert_(vzm_input); + + /* Start looping on the number of gaussian points: */ + Gauss* gauss=element->NewGauss(4); + while(gauss->next()){ + + element->JacobianDeterminant(&Jdet,xyz_list,gauss); + element->NodalFunctions(basis,gauss); + element->NodalFunctionsDerivatives(dbasis,xyz_list,gauss); + + D_scalar=gauss->weight*Jdet; + if(dt!=0.) D_scalar=D_scalar*dt; + + /*Conduction: */ + for(int i=0;ivalues[i*numnodes+j] += D_scalar*kappa*( + dbasis[0*numnodes+j]*dbasis[0*numnodes+i] + dbasis[1*numnodes+j]*dbasis[1*numnodes+i] + dbasis[2*numnodes+j]*dbasis[2*numnodes+i] + ); + } + } + + /*Advection: */ + vx_input->GetInputValue(&u,gauss); vxm_input->GetInputValue(&um,gauss); vx=u-um; + vy_input->GetInputValue(&v,gauss); vym_input->GetInputValue(&vm,gauss); vy=v-vm; + vz_input->GetInputValue(&w,gauss); vzm_input->GetInputValue(&wm,gauss); vz=w-wm; + for(int i=0;ivalues[i*numnodes+j] += D_scalar*( + vx*dbasis[0*numnodes+j]*basis[i] + vy*dbasis[1*numnodes+j]*basis[i] +vz*dbasis[2*numnodes+j]*basis[i] + ); + } + } + + /*Transient: */ + if(dt!=0.){ + D_scalar=gauss->weight*Jdet; + for(int i=0;ivalues[i*numnodes+j] += D_scalar*basis[j]*basis[i]; + D_scalar=D_scalar*dt; + } + + /*Artifficial diffusivity*/ + if(stabilization==1){ + element->ElementSizes(&hx,&hy,&hz); + vel=sqrt(vx*vx + vy*vy + vz*vz)+1.e-14; + h=sqrt( pow(hx*vx/vel,2) + pow(hy*vy/vel,2) + pow(hz*vz/vel,2)); + K[0][0]=h/(2.*vel)*fabs(vx*vx); K[0][1]=h/(2.*vel)*fabs(vx*vy); K[0][2]=h/(2.*vel)*fabs(vx*vz); + K[1][0]=h/(2.*vel)*fabs(vy*vx); K[1][1]=h/(2.*vel)*fabs(vy*vy); K[1][2]=h/(2.*vel)*fabs(vy*vz); + K[2][0]=h/(2.*vel)*fabs(vz*vx); K[2][1]=h/(2.*vel)*fabs(vz*vy); K[2][2]=h/(2.*vel)*fabs(vz*vz); + for(int i=0;i<3;i++) for(int j=0;j<3;j++) K[i][j] = D_scalar*K[i][j]; + + for(int i=0;ivalues[i*numnodes+j] += ( + dbasis[0*numnodes+i] *(K[0][0]*dbasis[0*numnodes+j] + K[0][1]*dbasis[1*numnodes+j]+ K[0][2]*dbasis[2*numnodes+j]) + + dbasis[1*numnodes+i] *(K[1][0]*dbasis[0*numnodes+j] + K[1][1]*dbasis[1*numnodes+j]+ K[1][2]*dbasis[2*numnodes+j]) + + dbasis[2*numnodes+i] *(K[2][0]*dbasis[0*numnodes+j] + K[2][1]*dbasis[1*numnodes+j]+ K[2][2]*dbasis[2*numnodes+j]) + ); + } + } + } + else if(stabilization==2){ + diameter=element->MinEdgeLength(xyz_list); + tau_parameter=element->StabilizationParameter(u-um,v-vm,w-wm,diameter,kappa); + for(int i=0;ivalues[i*numnodes+j]+=tau_parameter*D_scalar* + ((u-um)*dbasis[0*numnodes+i]+(v-vm)*dbasis[1*numnodes+i]+(w-wm)*dbasis[2*numnodes+i])* + ((u-um)*dbasis[0*numnodes+j]+(v-vm)*dbasis[1*numnodes+j]+(w-wm)*dbasis[2*numnodes+j]); + } + } + if(dt!=0.){ + D_scalar=gauss->weight*Jdet; + for(int i=0;ivalues[i*numnodes+j]+=tau_parameter*D_scalar*basis[j]*((u-um)*dbasis[0*numnodes+i]+(v-vm)*dbasis[1*numnodes+i]+(w-wm)*dbasis[2*numnodes+i]); + } + } + } + } + /*anisotropic SUPG*/ + else if(stabilization==3){ + element->NodalFunctionsDerivatives(dbasis,xyz_list,gauss); + element->ElementSizes(&hx,&hy,&hz); + element->StabilizationParameterAnisotropic(&tau_parameter_anisotropic[0],u-um,v-vm,w-wm,hx,hy,hz,kappa); + tau_parameter_hor=tau_parameter_anisotropic[0]; + tau_parameter_ver=tau_parameter_anisotropic[1]; + for(int i=0;ivalues[i*numnodes+j]+=D_scalar* + (sqrt(tau_parameter_hor)*(u-um)*dbasis[0*numnodes+i]+sqrt(tau_parameter_hor)*(v-vm)*dbasis[1*numnodes+i]+sqrt(tau_parameter_ver)*(w-wm)*dbasis[2*numnodes+i])* + (sqrt(tau_parameter_hor)*(u-um)*dbasis[0*numnodes+j]+sqrt(tau_parameter_hor)*(v-vm)*dbasis[1*numnodes+j]+sqrt(tau_parameter_ver)*(w-wm)*dbasis[2*numnodes+j]); + } + } + } + } + + /*Clean up and return*/ + xDelete(xyz_list); + xDelete(basis); + xDelete(dbasis); + delete gauss; + return Ke; +}/*}}}*/ +ElementVector* AgeAnalysis::CreatePVector(Element* element){/*{{{*/ + + _error_("STOP"); + + /* Check if ice in element */ + if(!element->IsIceInElement()) return NULL; + + /*compute all load vectors for this element*/ + ElementVector* pe1=CreatePVectorVolume(element); + ElementVector* pe2=CreatePVectorSheet(element); + ElementVector* pe3=CreatePVectorShelf(element); + ElementVector* pe =new ElementVector(pe1,pe2,pe3); + + /*clean-up and return*/ + delete pe1; + delete pe2; + delete pe3; + return pe; +}/*}}}*/ +ElementVector* AgeAnalysis::CreatePVectorSheet(Element* element){/*{{{*/ + + /* Check if ice in element */ + if(!element->IsIceInElement()) return NULL; + + /* Geothermal flux on ice sheet base and basal friction */ + if(!element->IsOnBase() || element->IsAllFloating()) return NULL; + + IssmDouble dt,Jdet,geothermalflux,vx,vy,vz; + IssmDouble alpha2,scalar,basalfriction,heatflux; + IssmDouble *xyz_list_base = NULL; + + /*Fetch number of nodes for this finite element*/ + int numnodes = element->GetNumberOfNodes(); + + /*Initialize vectors*/ + ElementVector* pe = element->NewElementVector(); + IssmDouble* basis = xNew(numnodes); + + /*Retrieve all inputs and parameters*/ + element->GetVerticesCoordinatesBase(&xyz_list_base); + element->FindParam(&dt,TimesteppingTimeStepEnum); + Input* vx_input = element->GetInput(VxEnum); _assert_(vx_input); + Input* vy_input = element->GetInput(VyEnum); _assert_(vy_input); + Input* vz_input = element->GetInput(VzEnum); _assert_(vz_input); + Input* geothermalflux_input = element->GetInput(BasalforcingsGeothermalfluxEnum); _assert_(geothermalflux_input); + IssmDouble rho_ice = element->FindParam(MaterialsRhoIceEnum); + IssmDouble heatcapacity = element->FindParam(MaterialsHeatcapacityEnum); + + /*Build friction element, needed later: */ + Friction* friction=new Friction(element,3); + + /* Start looping on the number of gaussian points: */ + Gauss* gauss = element->NewGaussBase(4); + while(gauss->next()){ + + element->JacobianDeterminantBase(&Jdet,xyz_list_base,gauss); + element->NodalFunctions(basis,gauss); + + geothermalflux_input->GetInputValue(&geothermalflux,gauss); + friction->GetAlpha2(&alpha2,gauss); + vx_input->GetInputValue(&vx,gauss); + vy_input->GetInputValue(&vy,gauss); + vz_input->GetInputValue(&vz,gauss); + vz = 0.;//FIXME + basalfriction = alpha2*(vx*vx + vy*vy + vz*vz); + heatflux = (basalfriction+geothermalflux)/(rho_ice*heatcapacity); + + scalar = gauss->weight*Jdet*heatflux; + if(dt!=0.) scalar=dt*scalar; + + for(int i=0;ivalues[i]+=scalar*basis[i]; + } + + /*Clean up and return*/ + delete gauss; + delete friction; + xDelete(basis); + xDelete(xyz_list_base); + return pe; +}/*}}}*/ +ElementVector* AgeAnalysis::CreatePVectorShelf(Element* element){/*{{{*/ + + /* Check if ice in element */ + if(!element->IsIceInElement()) return NULL; + + IssmDouble t_pmp,dt,Jdet,scalar_ocean,pressure; + IssmDouble *xyz_list_base = NULL; + + /*Get basal element*/ + if(!element->IsOnBase() || !element->IsAllFloating()) return NULL; + + /*Fetch number of nodes for this finite element*/ + int numnodes = element->GetNumberOfNodes(); + + /*Initialize vectors*/ + ElementVector* pe = element->NewElementVector(); + IssmDouble* basis = xNew(numnodes); + + /*Retrieve all inputs and parameters*/ + element->GetVerticesCoordinatesBase(&xyz_list_base); + element->FindParam(&dt,TimesteppingTimeStepEnum); + Input* pressure_input=element->GetInput(PressureEnum); _assert_(pressure_input); + IssmDouble gravity = element->FindParam(ConstantsGEnum); + IssmDouble rho_water = element->FindParam(MaterialsRhoSeawaterEnum); + IssmDouble rho_ice = element->FindParam(MaterialsRhoIceEnum); + IssmDouble heatcapacity = element->FindParam(MaterialsHeatcapacityEnum); + IssmDouble mixed_layer_capacity= element->FindParam(MaterialsMixedLayerCapacityEnum); + + /* Start looping on the number of gaussian points: */ + Gauss* gauss=element->NewGaussBase(4); + while(gauss->next()){ + + element->JacobianDeterminantBase(&Jdet,xyz_list_base,gauss); + element->NodalFunctions(basis,gauss); + + pressure_input->GetInputValue(&pressure,gauss); + t_pmp=element->TMeltingPoint(pressure); + + scalar_ocean=gauss->weight*Jdet*rho_water*mixed_layer_capacity*(t_pmp)/(heatcapacity*rho_ice); + if(reCast(dt)) scalar_ocean=dt*scalar_ocean; + + for(int i=0;ivalues[i]+=scalar_ocean*basis[i]; + } + + /*Clean up and return*/ + delete gauss; + xDelete(basis); + xDelete(xyz_list_base); + return pe; +}/*}}}*/ +ElementVector* AgeAnalysis::CreatePVectorVolume(Element* element){/*{{{*/ + + /* Check if ice in element */ + if(!element->IsIceInElement()) return NULL; + + /*Intermediaries*/ + int stabilization; + IssmDouble Jdet,phi,dt; + IssmDouble temperature; + IssmDouble tau_parameter,diameter,hx,hy,hz; + IssmDouble tau_parameter_anisotropic[2],tau_parameter_hor,tau_parameter_ver; + IssmDouble u,v,w; + IssmDouble scalar_def,scalar_transient; + IssmDouble* xyz_list = NULL; + + /*Fetch number of nodes and dof for this finite element*/ + int numnodes = element->GetNumberOfNodes(); + + /*Initialize Element vector*/ + ElementVector* pe = element->NewElementVector(); + IssmDouble* basis = xNew(numnodes); + IssmDouble* dbasis = xNew(3*numnodes); + + /*Retrieve all inputs and parameters*/ + element->GetVerticesCoordinates(&xyz_list); + IssmDouble rho_ice = element->FindParam(MaterialsRhoIceEnum); + IssmDouble heatcapacity = element->FindParam(MaterialsHeatcapacityEnum); + IssmDouble thermalconductivity = 1.; + IssmDouble kappa = thermalconductivity/(rho_ice*heatcapacity); + element->FindParam(&dt,TimesteppingTimeStepEnum); + element->FindParam(&stabilization,AgeStabilizationEnum); + Input* vx_input=element->GetInput(VxEnum); _assert_(vx_input); + Input* vy_input=element->GetInput(VyEnum); _assert_(vy_input); + Input* vz_input=element->GetInput(VzEnum); _assert_(vz_input); + Input* temperature_input = NULL; + if(reCast(dt)){temperature_input = element->GetInput(TemperatureEnum); _assert_(temperature_input);} + + /* Start looping on the number of gaussian points: */ + Gauss* gauss=element->NewGauss(4); + while(gauss->next()){ + + element->JacobianDeterminant(&Jdet,xyz_list,gauss); + element->NodalFunctions(basis,gauss); + element->ViscousHeating(&phi,xyz_list,gauss,vx_input,vy_input,vz_input); + + scalar_def=phi/(rho_ice*heatcapacity)*Jdet*gauss->weight; + if(reCast(dt)) scalar_def=scalar_def*dt; + + for(int i=0;ivalues[i]+=scalar_def*basis[i]; + + /* Build transient now */ + if(reCast(dt)){ + temperature_input->GetInputValue(&temperature, gauss); + scalar_transient=temperature*Jdet*gauss->weight; + for(int i=0;ivalues[i]+=scalar_transient*basis[i]; + } + + if(stabilization==2){ + element->NodalFunctionsDerivatives(dbasis,xyz_list,gauss); + diameter=element->MinEdgeLength(xyz_list); + vx_input->GetInputValue(&u,gauss); + vy_input->GetInputValue(&v,gauss); + vz_input->GetInputValue(&w,gauss); + + tau_parameter=element->StabilizationParameter(u,v,w,diameter,kappa); + + for(int i=0;ivalues[i]+=tau_parameter*scalar_def*(u*dbasis[0*numnodes+i]+v*dbasis[1*numnodes+i]+w*dbasis[2*numnodes+i]); + if(reCast(dt)){ + for(int i=0;ivalues[i]+=tau_parameter*scalar_transient*(u*dbasis[0*numnodes+i]+v*dbasis[1*numnodes+i]+w*dbasis[2*numnodes+i]); + } + } + /* anisotropic SUPG */ + else if(stabilization==3){ + element->NodalFunctionsDerivatives(dbasis,xyz_list,gauss); + element->ElementSizes(&hx,&hy,&hz); + vx_input->GetInputValue(&u,gauss); + vy_input->GetInputValue(&v,gauss); + vz_input->GetInputValue(&w,gauss); + element->StabilizationParameterAnisotropic(&tau_parameter_anisotropic[0],u,v,w,hx,hy,hz,kappa); + tau_parameter_hor=tau_parameter_anisotropic[0]; + tau_parameter_ver=tau_parameter_anisotropic[1]; + + for(int i=0;ivalues[i]+=scalar_def*(tau_parameter_hor*u*dbasis[0*numnodes+i]+tau_parameter_hor*v*dbasis[1*numnodes+i]+tau_parameter_ver*w*dbasis[2*numnodes+i]); + } + } + + /*Clean up and return*/ + xDelete(basis); + xDelete(dbasis); + xDelete(xyz_list); + delete gauss; + return pe; + +}/*}}}*/ +void AgeAnalysis::GetSolutionFromInputs(Vector* solution,Element* element){/*{{{*/ + element->GetSolutionFromInputsOneDof(solution,AgeEnum); +}/*}}}*/ +void AgeAnalysis::GradientJ(Vector* gradient,Element* element,int control_type,int control_interp,int control_index){/*{{{*/ + _error_("Not implemented yet"); +}/*}}}*/ +void AgeAnalysis::InputUpdateFromSolution(IssmDouble* solution,Element* element){/*{{{*/ + + element->InputUpdateFromSolutionOneDof(solution,AgeEnum); + +}/*}}}*/ +void AgeAnalysis::UpdateConstraints(FemModel* femmodel){/*{{{*/ + SetActiveNodesLSMx(femmodel); + + _error_("Should also automatically constrain surface/basal nodes where we have inflow"); +}/*}}}*/ Index: /issm/trunk-jpl/src/c/analyses/AgeAnalysis.h =================================================================== --- /issm/trunk-jpl/src/c/analyses/AgeAnalysis.h (revision 27154) +++ /issm/trunk-jpl/src/c/analyses/AgeAnalysis.h (revision 27154) @@ -0,0 +1,39 @@ +/*! \file AgeAnalysis.h + * \brief: header file for generic external result object + */ + +#ifndef _AGEANALYSIS_ +#define _AGEANALYSIS_ + +/*Headers*/ +#include "./Analysis.h" + +class AgeAnalysis: public Analysis{ + + public: + /*Model processing*/ + void CreateConstraints(Constraints* constraints,IoModel* iomodel); + void CreateLoads(Loads* loads, IoModel* iomodel); + void CreateNodes(Nodes* nodes,IoModel* iomodel,bool isamr=false); + int DofsPerNode(int** doflist,int domaintype,int approximation); + void UpdateElements(Elements* elements,Inputs* inputs,IoModel* iomodel,int analysis_counter,int analysis_type); + void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum); + + /*Finite element Analysis*/ + void Core(FemModel* femmodel); + void PreCore(FemModel* femmodel); + ElementVector* CreateDVector(Element* element); + ElementMatrix* CreateJacobianMatrix(Element* element); + ElementMatrix* CreateKMatrix(Element* element); + ElementMatrix* CreateKMatrixShelf(Element* element); + ElementMatrix* CreateKMatrixVolume(Element* element); + ElementVector* CreatePVector(Element* element); + ElementVector* CreatePVectorSheet(Element* element); + ElementVector* CreatePVectorShelf(Element* element); + ElementVector* CreatePVectorVolume(Element* element); + void GetSolutionFromInputs(Vector* solution,Element* element); + void GradientJ(Vector* gradient,Element* element,int control_type,int control_interp,int control_index); + void InputUpdateFromSolution(IssmDouble* solution,Element* element); + void UpdateConstraints(FemModel* femmodel); +}; +#endif Index: /issm/trunk-jpl/src/c/analyses/EnumToAnalysis.cpp =================================================================== --- /issm/trunk-jpl/src/c/analyses/EnumToAnalysis.cpp (revision 27153) +++ /issm/trunk-jpl/src/c/analyses/EnumToAnalysis.cpp (revision 27154) @@ -25,4 +25,7 @@ #ifdef _HAVE_ADJOINTHORIZ_ case AdjointHorizAnalysisEnum : return new AdjointHorizAnalysis(); + #endif + #ifdef _HAVE_AGE_ + case AgeAnalysisEnum : return new AgeAnalysis(); #endif #ifdef _HAVE_BALANCETHICKNESS2_ Index: /issm/trunk-jpl/src/c/analyses/analyses.h =================================================================== --- /issm/trunk-jpl/src/c/analyses/analyses.h (revision 27153) +++ /issm/trunk-jpl/src/c/analyses/analyses.h (revision 27154) @@ -11,4 +11,5 @@ #include "./AdjointBalancethickness2Analysis.h" #include "./AdjointHorizAnalysis.h" +#include "./AgeAnalysis.h" #include "./BalancethicknessAnalysis.h" #include "./Balancethickness2Analysis.h" Index: /issm/trunk-jpl/src/c/cores/transient_core.cpp =================================================================== --- /issm/trunk-jpl/src/c/cores/transient_core.cpp (revision 27153) +++ /issm/trunk-jpl/src/c/cores/transient_core.cpp (revision 27154) @@ -130,5 +130,5 @@ /*parameters: */ - bool isstressbalance,ismasstransport,isoceantransport,issmb,isthermal,isgroundingline,isesa,issampling;; + bool isstressbalance,ismasstransport,isage,isoceantransport,issmb,isthermal,isgroundingline,isesa,issampling; bool isslc,ismovingfront,isdamageevolution,ishydrology,isoceancoupling,isstochasticforcing,save_results; int step,sb_coupling_frequency; @@ -142,4 +142,5 @@ femmodel->parameters->FindParam(&isstressbalance,TransientIsstressbalanceEnum); femmodel->parameters->FindParam(&ismasstransport,TransientIsmasstransportEnum); + femmodel->parameters->FindParam(&isage,TransientIsageEnum); femmodel->parameters->FindParam(&isoceantransport,TransientIsoceantransportEnum); femmodel->parameters->FindParam(&issmb,TransientIssmbEnum); Index: /issm/trunk-jpl/src/c/shared/Enum/Enum.vim =================================================================== --- /issm/trunk-jpl/src/c/shared/Enum/Enum.vim (revision 27153) +++ /issm/trunk-jpl/src/c/shared/Enum/Enum.vim (revision 27154) @@ -17,4 +17,7 @@ syn keyword cConstant ParametersSTARTEnum syn keyword cConstant AdolcParamEnum +syn keyword cConstant AgeStabilizationEnum +syn keyword cConstant AgeNumRequestedOutputsEnum +syn keyword cConstant AgeRequestedOutputsEnum syn keyword cConstant AmrDeviatoricErrorGroupThresholdEnum syn keyword cConstant AmrDeviatoricErrorMaximumEnum @@ -290,4 +293,5 @@ syn keyword cConstant LoveComplexComputationEnum syn keyword cConstant LoveQuadPrecisionEnum +syn keyword cConstant LoveIntStepsPerLayerEnum syn keyword cConstant LoveMinIntegrationStepsEnum syn keyword cConstant LoveMaxIntegrationdrEnum @@ -576,4 +580,5 @@ syn keyword cConstant ToolkitsTypesEnum syn keyword cConstant TransientAmrFrequencyEnum +syn keyword cConstant TransientIsageEnum syn keyword cConstant TransientIsdamageevolutionEnum syn keyword cConstant TransientIsesaEnum @@ -612,4 +617,5 @@ syn keyword cConstant AdjointyShearEnum syn keyword cConstant AdjointzEnum +syn keyword cConstant AgeEnum syn keyword cConstant AirEnum syn keyword cConstant ApproximationEnum @@ -1230,4 +1236,5 @@ syn keyword cConstant AdjointBalancethicknessAnalysisEnum syn keyword cConstant AdjointHorizAnalysisEnum +syn keyword cConstant AgeAnalysisEnum syn keyword cConstant AggressiveMigrationEnum syn keyword cConstant AmrBamgEnum @@ -1632,5 +1639,4 @@ syn keyword cType Cfsurfacesquare syn keyword cType Channel -syn keyword cType classes syn keyword cType Constraint syn keyword cType Constraints @@ -1639,6 +1645,6 @@ syn keyword cType ControlInput syn keyword cType Covertree +syn keyword cType DataSetParam syn keyword cType DatasetInput -syn keyword cType DataSetParam syn keyword cType Definition syn keyword cType DependentObject @@ -1653,6 +1659,6 @@ syn keyword cType ElementInput syn keyword cType ElementMatrix +syn keyword cType ElementVector syn keyword cType Elements -syn keyword cType ElementVector syn keyword cType ExponentialVariogram syn keyword cType ExternalResult @@ -1661,10 +1667,9 @@ syn keyword cType Friction syn keyword cType Gauss -syn keyword cType GaussianVariogram -syn keyword cType gaussobjects syn keyword cType GaussPenta syn keyword cType GaussSeg syn keyword cType GaussTetra syn keyword cType GaussTria +syn keyword cType GaussianVariogram syn keyword cType GenericExternalResult syn keyword cType GenericOption @@ -1683,5 +1688,4 @@ syn keyword cType IssmDirectApplicInterface syn keyword cType IssmParallelDirectApplicInterface -syn keyword cType krigingobjects syn keyword cType Load syn keyword cType Loads @@ -1694,5 +1698,4 @@ syn keyword cType Matice syn keyword cType Matlitho -syn keyword cType matrixobjects syn keyword cType MatrixParam syn keyword cType Misfit @@ -1707,6 +1710,6 @@ syn keyword cType Observations syn keyword cType Option +syn keyword cType OptionUtilities syn keyword cType Options -syn keyword cType OptionUtilities syn keyword cType Param syn keyword cType Parameters @@ -1722,11 +1725,11 @@ syn keyword cType Regionaloutput syn keyword cType Results +syn keyword cType RiftStruct syn keyword cType Riftfront -syn keyword cType RiftStruct syn keyword cType SealevelGeometry syn keyword cType Seg syn keyword cType SegInput +syn keyword cType SegRef syn keyword cType Segment -syn keyword cType SegRef syn keyword cType SpcDynamic syn keyword cType SpcStatic @@ -1747,7 +1750,12 @@ syn keyword cType Vertex syn keyword cType Vertices +syn keyword cType classes +syn keyword cType gaussobjects +syn keyword cType krigingobjects +syn keyword cType matrixobjects syn keyword cType AdjointBalancethickness2Analysis syn keyword cType AdjointBalancethicknessAnalysis syn keyword cType AdjointHorizAnalysis +syn keyword cType AgeAnalysis syn keyword cType Analysis syn keyword cType Balancethickness2Analysis Index: /issm/trunk-jpl/src/c/shared/Enum/EnumDefinitions.h =================================================================== --- /issm/trunk-jpl/src/c/shared/Enum/EnumDefinitions.h (revision 27153) +++ /issm/trunk-jpl/src/c/shared/Enum/EnumDefinitions.h (revision 27154) @@ -11,4 +11,7 @@ /*Parameters{{{*/ AdolcParamEnum, + AgeStabilizationEnum, + AgeNumRequestedOutputsEnum, + AgeRequestedOutputsEnum, AmrDeviatoricErrorGroupThresholdEnum, AmrDeviatoricErrorMaximumEnum, @@ -571,4 +574,5 @@ ToolkitsTypesEnum, TransientAmrFrequencyEnum, + TransientIsageEnum, TransientIsdamageevolutionEnum, TransientIsesaEnum, @@ -609,4 +613,5 @@ AdjointyShearEnum, AdjointzEnum, + AgeEnum, AirEnum, ApproximationEnum, @@ -1230,4 +1235,5 @@ AdjointBalancethicknessAnalysisEnum, AdjointHorizAnalysisEnum, + AgeAnalysisEnum, AggressiveMigrationEnum, AmrBamgEnum, Index: /issm/trunk-jpl/src/c/shared/Enum/EnumToStringx.cpp =================================================================== --- /issm/trunk-jpl/src/c/shared/Enum/EnumToStringx.cpp (revision 27153) +++ /issm/trunk-jpl/src/c/shared/Enum/EnumToStringx.cpp (revision 27154) @@ -19,4 +19,7 @@ case ParametersSTARTEnum : return "ParametersSTART"; case AdolcParamEnum : return "AdolcParam"; + case AgeStabilizationEnum : return "AgeStabilization"; + case AgeNumRequestedOutputsEnum : return "AgeNumRequestedOutputs"; + case AgeRequestedOutputsEnum : return "AgeRequestedOutputs"; case AmrDeviatoricErrorGroupThresholdEnum : return "AmrDeviatoricErrorGroupThreshold"; case AmrDeviatoricErrorMaximumEnum : return "AmrDeviatoricErrorMaximum"; @@ -579,4 +582,5 @@ case ToolkitsTypesEnum : return "ToolkitsTypes"; case TransientAmrFrequencyEnum : return "TransientAmrFrequency"; + case TransientIsageEnum : return "TransientIsage"; case TransientIsdamageevolutionEnum : return "TransientIsdamageevolution"; case TransientIsesaEnum : return "TransientIsesa"; @@ -615,4 +619,5 @@ case AdjointyShearEnum : return "AdjointyShear"; case AdjointzEnum : return "Adjointz"; + case AgeEnum : return "Age"; case AirEnum : return "Air"; case ApproximationEnum : return "Approximation"; @@ -1233,4 +1238,5 @@ case AdjointBalancethicknessAnalysisEnum : return "AdjointBalancethicknessAnalysis"; case AdjointHorizAnalysisEnum : return "AdjointHorizAnalysis"; + case AgeAnalysisEnum : return "AgeAnalysis"; case AggressiveMigrationEnum : return "AggressiveMigration"; case AmrBamgEnum : return "AmrBamg"; Index: /issm/trunk-jpl/src/c/shared/Enum/Enumjl.vim =================================================================== --- /issm/trunk-jpl/src/c/shared/Enum/Enumjl.vim (revision 27153) +++ /issm/trunk-jpl/src/c/shared/Enum/Enumjl.vim (revision 27154) @@ -10,4 +10,7 @@ syn keyword juliaConstC ParametersSTARTEnum syn keyword juliaConstC AdolcParamEnum +syn keyword juliaConstC AgeStabilizationEnum +syn keyword juliaConstC AgeNumRequestedOutputsEnum +syn keyword juliaConstC AgeRequestedOutputsEnum syn keyword juliaConstC AmrDeviatoricErrorGroupThresholdEnum syn keyword juliaConstC AmrDeviatoricErrorMaximumEnum @@ -283,4 +286,5 @@ syn keyword juliaConstC LoveComplexComputationEnum syn keyword juliaConstC LoveQuadPrecisionEnum +syn keyword juliaConstC LoveIntStepsPerLayerEnum syn keyword juliaConstC LoveMinIntegrationStepsEnum syn keyword juliaConstC LoveMaxIntegrationdrEnum @@ -569,4 +573,5 @@ syn keyword juliaConstC ToolkitsTypesEnum syn keyword juliaConstC TransientAmrFrequencyEnum +syn keyword juliaConstC TransientIsageEnum syn keyword juliaConstC TransientIsdamageevolutionEnum syn keyword juliaConstC TransientIsesaEnum @@ -605,4 +610,5 @@ syn keyword juliaConstC AdjointyShearEnum syn keyword juliaConstC AdjointzEnum +syn keyword juliaConstC AgeEnum syn keyword juliaConstC AirEnum syn keyword juliaConstC ApproximationEnum @@ -1223,4 +1229,5 @@ syn keyword juliaConstC AdjointBalancethicknessAnalysisEnum syn keyword juliaConstC AdjointHorizAnalysisEnum +syn keyword juliaConstC AgeAnalysisEnum syn keyword juliaConstC AggressiveMigrationEnum syn keyword juliaConstC AmrBamgEnum Index: /issm/trunk-jpl/src/c/shared/Enum/StringToEnumx.cpp =================================================================== --- /issm/trunk-jpl/src/c/shared/Enum/StringToEnumx.cpp (revision 27153) +++ /issm/trunk-jpl/src/c/shared/Enum/StringToEnumx.cpp (revision 27154) @@ -19,4 +19,7 @@ if (strcmp(name,"ParametersSTART")==0) return ParametersSTARTEnum; else if (strcmp(name,"AdolcParam")==0) return AdolcParamEnum; + else if (strcmp(name,"AgeStabilization")==0) return AgeStabilizationEnum; + else if (strcmp(name,"AgeNumRequestedOutputs")==0) return AgeNumRequestedOutputsEnum; + else if (strcmp(name,"AgeRequestedOutputs")==0) return AgeRequestedOutputsEnum; else if (strcmp(name,"AmrDeviatoricErrorGroupThreshold")==0) return AmrDeviatoricErrorGroupThresholdEnum; else if (strcmp(name,"AmrDeviatoricErrorMaximum")==0) return AmrDeviatoricErrorMaximumEnum; @@ -134,11 +137,11 @@ else if (strcmp(name,"CumBslcOcean")==0) return CumBslcOceanEnum; else if (strcmp(name,"CumBslcIcePartition")==0) return CumBslcIcePartitionEnum; - else if (strcmp(name,"CumBslcHydroPartition")==0) return CumBslcHydroPartitionEnum; - else if (strcmp(name,"CumBslcOceanPartition")==0) return CumBslcOceanPartitionEnum; - else if (strcmp(name,"CumGmtslc")==0) return CumGmtslcEnum; else stage=2; } if(stage==2){ - if (strcmp(name,"CumGmslc")==0) return CumGmslcEnum; + if (strcmp(name,"CumBslcHydroPartition")==0) return CumBslcHydroPartitionEnum; + else if (strcmp(name,"CumBslcOceanPartition")==0) return CumBslcOceanPartitionEnum; + else if (strcmp(name,"CumGmtslc")==0) return CumGmtslcEnum; + else if (strcmp(name,"CumGmslc")==0) return CumGmslcEnum; else if (strcmp(name,"DamageC1")==0) return DamageC1Enum; else if (strcmp(name,"DamageC2")==0) return DamageC2Enum; @@ -257,11 +260,11 @@ else if (strcmp(name,"InputToExtrude")==0) return InputToExtrudeEnum; else if (strcmp(name,"InputToL2Project")==0) return InputToL2ProjectEnum; - else if (strcmp(name,"InputToSmooth")==0) return InputToSmoothEnum; - else if (strcmp(name,"InversionAlgorithm")==0) return InversionAlgorithmEnum; - else if (strcmp(name,"InversionControlParameters")==0) return InversionControlParametersEnum; else stage=3; } if(stage==3){ - if (strcmp(name,"InversionControlScalingFactors")==0) return InversionControlScalingFactorsEnum; + if (strcmp(name,"InputToSmooth")==0) return InputToSmoothEnum; + else if (strcmp(name,"InversionAlgorithm")==0) return InversionAlgorithmEnum; + else if (strcmp(name,"InversionControlParameters")==0) return InversionControlParametersEnum; + else if (strcmp(name,"InversionControlScalingFactors")==0) return InversionControlScalingFactorsEnum; else if (strcmp(name,"InversionCostFunctions")==0) return InversionCostFunctionsEnum; else if (strcmp(name,"InversionDxmin")==0) return InversionDxminEnum; @@ -380,11 +383,11 @@ else if (strcmp(name,"QmuMethods")==0) return QmuMethodsEnum; else if (strcmp(name,"RestartFileName")==0) return RestartFileNameEnum; - else if (strcmp(name,"Results")==0) return ResultsEnum; - else if (strcmp(name,"RootPath")==0) return RootPathEnum; - else if (strcmp(name,"Modelname")==0) return ModelnameEnum; else stage=4; } if(stage==4){ - if (strcmp(name,"SamplingAlpha")==0) return SamplingAlphaEnum; + if (strcmp(name,"Results")==0) return ResultsEnum; + else if (strcmp(name,"RootPath")==0) return RootPathEnum; + else if (strcmp(name,"Modelname")==0) return ModelnameEnum; + else if (strcmp(name,"SamplingAlpha")==0) return SamplingAlphaEnum; else if (strcmp(name,"SamplingNumRequestedOutputs")==0) return SamplingNumRequestedOutputsEnum; else if (strcmp(name,"SamplingRequestedOutputs")==0) return SamplingRequestedOutputsEnum; @@ -503,11 +506,11 @@ else if (strcmp(name,"SmbIsd18opd")==0) return SmbIsd18opdEnum; else if (strcmp(name,"SmbIsdelta18o")==0) return SmbIsdelta18oEnum; - else if (strcmp(name,"SmbIsdensification")==0) return SmbIsdensificationEnum; - else if (strcmp(name,"SmbIsdeltaLWup")==0) return SmbIsdeltaLWupEnum; - else if (strcmp(name,"SmbIsfirnwarming")==0) return SmbIsfirnwarmingEnum; else stage=5; } if(stage==5){ - if (strcmp(name,"SmbIsgraingrowth")==0) return SmbIsgraingrowthEnum; + if (strcmp(name,"SmbIsdensification")==0) return SmbIsdensificationEnum; + else if (strcmp(name,"SmbIsdeltaLWup")==0) return SmbIsdeltaLWupEnum; + else if (strcmp(name,"SmbIsfirnwarming")==0) return SmbIsfirnwarmingEnum; + else if (strcmp(name,"SmbIsgraingrowth")==0) return SmbIsgraingrowthEnum; else if (strcmp(name,"SmbIsmelt")==0) return SmbIsmeltEnum; else if (strcmp(name,"SmbIsmungsm")==0) return SmbIsmungsmEnum; @@ -591,4 +594,5 @@ else if (strcmp(name,"ToolkitsTypes")==0) return ToolkitsTypesEnum; else if (strcmp(name,"TransientAmrFrequency")==0) return TransientAmrFrequencyEnum; + else if (strcmp(name,"TransientIsage")==0) return TransientIsageEnum; else if (strcmp(name,"TransientIsdamageevolution")==0) return TransientIsdamageevolutionEnum; else if (strcmp(name,"TransientIsesa")==0) return TransientIsesaEnum; @@ -625,12 +629,13 @@ else if (strcmp(name,"Adjointy")==0) return AdjointyEnum; else if (strcmp(name,"AdjointyBase")==0) return AdjointyBaseEnum; - else if (strcmp(name,"AdjointyShear")==0) return AdjointyShearEnum; - else if (strcmp(name,"Adjointz")==0) return AdjointzEnum; - else if (strcmp(name,"Air")==0) return AirEnum; - else if (strcmp(name,"Approximation")==0) return ApproximationEnum; else stage=6; } if(stage==6){ - if (strcmp(name,"BalancethicknessMisfit")==0) return BalancethicknessMisfitEnum; + if (strcmp(name,"AdjointyShear")==0) return AdjointyShearEnum; + else if (strcmp(name,"Adjointz")==0) return AdjointzEnum; + else if (strcmp(name,"Age")==0) return AgeEnum; + else if (strcmp(name,"Air")==0) return AirEnum; + else if (strcmp(name,"Approximation")==0) return ApproximationEnum; + else if (strcmp(name,"BalancethicknessMisfit")==0) return BalancethicknessMisfitEnum; else if (strcmp(name,"BalancethicknessOmega0")==0) return BalancethicknessOmega0Enum; else if (strcmp(name,"BalancethicknessOmega")==0) return BalancethicknessOmegaEnum; @@ -747,13 +752,13 @@ else if (strcmp(name,"EsaRotationrate")==0) return EsaRotationrateEnum; else if (strcmp(name,"EsaStrainratexx")==0) return EsaStrainratexxEnum; - else if (strcmp(name,"EsaStrainratexy")==0) return EsaStrainratexyEnum; + else stage=7; + } + if(stage==7){ + if (strcmp(name,"EsaStrainratexy")==0) return EsaStrainratexyEnum; else if (strcmp(name,"EsaStrainrateyy")==0) return EsaStrainrateyyEnum; else if (strcmp(name,"EsaUmotion")==0) return EsaUmotionEnum; else if (strcmp(name,"EsaXmotion")==0) return EsaXmotionEnum; else if (strcmp(name,"EsaYmotion")==0) return EsaYmotionEnum; - else stage=7; - } - if(stage==7){ - if (strcmp(name,"EtaDiff")==0) return EtaDiffEnum; + else if (strcmp(name,"EtaDiff")==0) return EtaDiffEnum; else if (strcmp(name,"FlowequationBorderFS")==0) return FlowequationBorderFSEnum; else if (strcmp(name,"FrictionAs")==0) return FrictionAsEnum; @@ -870,13 +875,13 @@ else if (strcmp(name,"RadarPowerWolff")==0) return RadarPowerWolffEnum; else if (strcmp(name,"RheologyBAbsGradient")==0) return RheologyBAbsGradientEnum; - else if (strcmp(name,"RheologyBInitialguess")==0) return RheologyBInitialguessEnum; + else stage=8; + } + if(stage==8){ + if (strcmp(name,"RheologyBInitialguess")==0) return RheologyBInitialguessEnum; else if (strcmp(name,"RheologyBInitialguessMisfit")==0) return RheologyBInitialguessMisfitEnum; else if (strcmp(name,"RheologyBbarAbsGradient")==0) return RheologyBbarAbsGradientEnum; else if (strcmp(name,"Sample")==0) return SampleEnum; else if (strcmp(name,"SampleOld")==0) return SampleOldEnum; - else stage=8; - } - if(stage==8){ - if (strcmp(name,"SampleNoise")==0) return SampleNoiseEnum; + else if (strcmp(name,"SampleNoise")==0) return SampleNoiseEnum; else if (strcmp(name,"SamplingBeta")==0) return SamplingBetaEnum; else if (strcmp(name,"SamplingKappa")==0) return SamplingKappaEnum; @@ -993,13 +998,13 @@ else if (strcmp(name,"SmbDzMin")==0) return SmbDzMinEnum; else if (strcmp(name,"SmbDzTop")==0) return SmbDzTopEnum; - else if (strcmp(name,"SmbDzini")==0) return SmbDziniEnum; + else stage=9; + } + if(stage==9){ + if (strcmp(name,"SmbDzini")==0) return SmbDziniEnum; else if (strcmp(name,"SmbEAir")==0) return SmbEAirEnum; else if (strcmp(name,"SmbEC")==0) return SmbECEnum; else if (strcmp(name,"SmbECDt")==0) return SmbECDtEnum; else if (strcmp(name,"SmbECini")==0) return SmbECiniEnum; - else stage=9; - } - if(stage==9){ - if (strcmp(name,"SmbEla")==0) return SmbElaEnum; + else if (strcmp(name,"SmbEla")==0) return SmbElaEnum; else if (strcmp(name,"SmbEvaporation")==0) return SmbEvaporationEnum; else if (strcmp(name,"SmbFAC")==0) return SmbFACEnum; @@ -1116,13 +1121,13 @@ else if (strcmp(name,"ThicknessOld")==0) return ThicknessOldEnum; else if (strcmp(name,"ThicknessPositive")==0) return ThicknessPositiveEnum; - else if (strcmp(name,"ThicknessResidual")==0) return ThicknessResidualEnum; + else stage=10; + } + if(stage==10){ + if (strcmp(name,"ThicknessResidual")==0) return ThicknessResidualEnum; else if (strcmp(name,"TransientAccumulatedDeltaIceThickness")==0) return TransientAccumulatedDeltaIceThicknessEnum; else if (strcmp(name,"Vel")==0) return VelEnum; else if (strcmp(name,"VxAverage")==0) return VxAverageEnum; else if (strcmp(name,"VxBase")==0) return VxBaseEnum; - else stage=10; - } - if(stage==10){ - if (strcmp(name,"Vx")==0) return VxEnum; + else if (strcmp(name,"Vx")==0) return VxEnum; else if (strcmp(name,"VxMesh")==0) return VxMeshEnum; else if (strcmp(name,"VxObs")==0) return VxObsEnum; @@ -1239,13 +1244,13 @@ else if (strcmp(name,"Outputdefinition86")==0) return Outputdefinition86Enum; else if (strcmp(name,"Outputdefinition87")==0) return Outputdefinition87Enum; - else if (strcmp(name,"Outputdefinition88")==0) return Outputdefinition88Enum; + else stage=11; + } + if(stage==11){ + if (strcmp(name,"Outputdefinition88")==0) return Outputdefinition88Enum; else if (strcmp(name,"Outputdefinition89")==0) return Outputdefinition89Enum; else if (strcmp(name,"Outputdefinition8")==0) return Outputdefinition8Enum; else if (strcmp(name,"Outputdefinition90")==0) return Outputdefinition90Enum; else if (strcmp(name,"Outputdefinition91")==0) return Outputdefinition91Enum; - else stage=11; - } - if(stage==11){ - if (strcmp(name,"Outputdefinition92")==0) return Outputdefinition92Enum; + else if (strcmp(name,"Outputdefinition92")==0) return Outputdefinition92Enum; else if (strcmp(name,"Outputdefinition93")==0) return Outputdefinition93Enum; else if (strcmp(name,"Outputdefinition94")==0) return Outputdefinition94Enum; @@ -1263,4 +1268,5 @@ else if (strcmp(name,"AdjointBalancethicknessAnalysis")==0) return AdjointBalancethicknessAnalysisEnum; else if (strcmp(name,"AdjointHorizAnalysis")==0) return AdjointHorizAnalysisEnum; + else if (strcmp(name,"AgeAnalysis")==0) return AgeAnalysisEnum; else if (strcmp(name,"AggressiveMigration")==0) return AggressiveMigrationEnum; else if (strcmp(name,"AmrBamg")==0) return AmrBamgEnum; @@ -1361,5 +1367,8 @@ else if (strcmp(name,"FloatingAreaScaled")==0) return FloatingAreaScaledEnum; else if (strcmp(name,"FloatingMeltRate")==0) return FloatingMeltRateEnum; - else if (strcmp(name,"Free")==0) return FreeEnum; + else stage=12; + } + if(stage==12){ + if (strcmp(name,"Free")==0) return FreeEnum; else if (strcmp(name,"FreeSurfaceBaseAnalysis")==0) return FreeSurfaceBaseAnalysisEnum; else if (strcmp(name,"FreeSurfaceTopAnalysis")==0) return FreeSurfaceTopAnalysisEnum; @@ -1367,8 +1376,5 @@ else if (strcmp(name,"FrontalForcingsRignot")==0) return FrontalForcingsRignotEnum; else if (strcmp(name,"FrontalForcingsRignotAutoregression")==0) return FrontalForcingsRignotAutoregressionEnum; - else stage=12; - } - if(stage==12){ - if (strcmp(name,"Fset")==0) return FsetEnum; + else if (strcmp(name,"Fset")==0) return FsetEnum; else if (strcmp(name,"FullMeltOnPartiallyFloating")==0) return FullMeltOnPartiallyFloatingEnum; else if (strcmp(name,"GLheightadvectionAnalysis")==0) return GLheightadvectionAnalysisEnum; @@ -1484,5 +1490,8 @@ else if (strcmp(name,"MeshElements")==0) return MeshElementsEnum; else if (strcmp(name,"MeshX")==0) return MeshXEnum; - else if (strcmp(name,"MeshY")==0) return MeshYEnum; + else stage=13; + } + if(stage==13){ + if (strcmp(name,"MeshY")==0) return MeshYEnum; else if (strcmp(name,"MinVel")==0) return MinVelEnum; else if (strcmp(name,"MinVx")==0) return MinVxEnum; @@ -1490,8 +1499,5 @@ else if (strcmp(name,"MinVz")==0) return MinVzEnum; else if (strcmp(name,"MismipFloatingMeltRate")==0) return MismipFloatingMeltRateEnum; - else stage=13; - } - if(stage==13){ - if (strcmp(name,"Moulin")==0) return MoulinEnum; + else if (strcmp(name,"Moulin")==0) return MoulinEnum; else if (strcmp(name,"MpiDense")==0) return MpiDenseEnum; else if (strcmp(name,"Mpi")==0) return MpiEnum; @@ -1607,5 +1613,8 @@ else if (strcmp(name,"SubelementMigration")==0) return SubelementMigrationEnum; else if (strcmp(name,"SurfaceSlopeSolution")==0) return SurfaceSlopeSolutionEnum; - else if (strcmp(name,"TaylorHood")==0) return TaylorHoodEnum; + else stage=14; + } + if(stage==14){ + if (strcmp(name,"TaylorHood")==0) return TaylorHoodEnum; else if (strcmp(name,"Tetra")==0) return TetraEnum; else if (strcmp(name,"TetraInput")==0) return TetraInputEnum; @@ -1613,8 +1622,5 @@ else if (strcmp(name,"ThermalSolution")==0) return ThermalSolutionEnum; else if (strcmp(name,"ThicknessErrorEstimator")==0) return ThicknessErrorEstimatorEnum; - else stage=14; - } - if(stage==14){ - if (strcmp(name,"TotalCalvingFluxLevelset")==0) return TotalCalvingFluxLevelsetEnum; + else if (strcmp(name,"TotalCalvingFluxLevelset")==0) return TotalCalvingFluxLevelsetEnum; else if (strcmp(name,"TotalCalvingMeltingFluxLevelset")==0) return TotalCalvingMeltingFluxLevelsetEnum; else if (strcmp(name,"TotalFloatingBmb")==0) return TotalFloatingBmbEnum; Index: /issm/trunk-jpl/src/c/shared/Enum/Synchronize.sh =================================================================== --- /issm/trunk-jpl/src/c/shared/Enum/Synchronize.sh (revision 27153) +++ /issm/trunk-jpl/src/c/shared/Enum/Synchronize.sh (revision 27154) @@ -17,5 +17,5 @@ #Deal with Analyses -if false ; then +if false; then #Build EnumToAnalysis.cpp {{{ #Header