Changeset 19518

Timestamp:

08/25/15 16:59:29 (10 years ago)

Author:

seroussi

Message:

NEW: added GroundedArea in possible outputs

Location:

issm/trunk-jpl

Files:

• externalpackages/cmake/install.sh (modified) (1 diff)
• m4/analyses.m4 (modified) (1 diff)
• src/c/classes/Elements/Element.h (modified) (1 diff)
• src/c/classes/Elements/Penta.cpp (modified) (1 diff)
• src/c/classes/Elements/Penta.h (modified) (1 diff)
• src/c/classes/Elements/Seg.h (modified) (1 diff)
• src/c/classes/Elements/Tetra.h (modified) (1 diff)
• src/c/classes/Elements/Tria.cpp (modified) (1 diff)
• src/c/classes/Elements/Tria.h (modified) (1 diff)
• src/c/classes/FemModel.cpp (modified) (2 diffs)
• src/c/classes/FemModel.h (modified) (1 diff)
• src/c/shared/Enum/EnumDefinitions.h (modified) (1 diff)
• src/c/shared/Enum/EnumToStringx.cpp (modified) (1 diff)
• src/c/shared/Enum/StringToEnumx.cpp (modified) (2 diffs)
• src/m/enum/EnumDefinitions.py (modified) (1 diff)
• src/m/enum/GroundedAreaEnum.m (added)
• test/NightlyRun/test208.m (modified) (1 diff)
• test/NightlyRun/test210.m (modified) (1 diff)
• test/NightlyRun/test314.m (modified) (1 diff)
• test/NightlyRun/test317.m (modified) (1 diff)

issm/trunk-jpl/externalpackages/cmake/install.sh

@@ -4 +4 @@
 
 #Some cleanup
-rm -rf install cmake-$VER
+rm -rf install cmake-3.3.1
 mkdir install
 
 #Download from ISSM server
-$ISSM_DIR/scripts/DownloadExternalPackage.py "http://issm.jpl.nasa.gov/files/externalpackages/cmake-$VER.tar.gz" "cmake-$VER.tar.gz"
+$ISSM_DIR/scripts/DownloadExternalPackage.py 'http://issm.jpl.nasa.gov/files/externalpackages/cmake-3.3.1.tar.gz' 'cmake-3.3.1.tar.gz'
 
 #Untar 
-tar -zxvf  cmake-$VER.tar.gz
+tar -zxvf  cmake-3.3.1.tar.gz
 
 #Move cmake into install directory
-mv cmake-$VER/* install
-rm -rf cmake-$VER
+mv cmake-3.3.1/* install
+rm -rf cmake-3.3.1
 
 #Compile cmake

issm/trunk-jpl/m4/analyses.m4

@@ -11 +11 @@
 
 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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-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-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 }}}
 dnl with-Gia{{{
+
 AC_ARG_WITH([Gia],
+
         AS_HELP_STRING([--with-Gia = YES], [compile with Gia capabilities (default is yes)]),
+
         [GIA=$withval],[GIA=yes])
+
 AC_MSG_CHECKING(for Gia capability compilation)
 
+
 HAVE_GIA=no 
+
 if test "x$GIA" = "xyes"; then
+
         HAVE_GIA=yes
+
         AC_DEFINE([_HAVE_GIA_],[1],[with Gia capability])
-fi
+
+fi
+
 AM_CONDITIONAL([GIA], [test x$HAVE_GIA = xyes])
+
 AC_MSG_RESULT($HAVE_GIA)
+
 dnl }}}
 dnl with-Meshdeformation{{{
+
 AC_ARG_WITH([Meshdeformation],
+
         AS_HELP_STRING([--with-Meshdeformation = YES], [compile with Meshdeformation capabilities (default is yes)]),
+
         [MESHDEFORMATION=$withval],[MESHDEFORMATION=yes])
+
 AC_MSG_CHECKING(for Meshdeformation capability compilation)
 
+
 HAVE_MESHDEFORMATION=no 
+
 if test "x$MESHDEFORMATION" = "xyes"; then
+
         HAVE_MESHDEFORMATION=yes
+
         AC_DEFINE([_HAVE_MESHDEFORMATION_],[1],[with Meshdeformation capability])
-fi
+
+fi
+
 AM_CONDITIONAL([MESHDEFORMATION], [test x$HAVE_MESHDEFORMATION = xyes])
+
 AC_MSG_RESULT($HAVE_MESHDEFORMATION)
+
 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-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-LsfReinitialization{{{
+
 AC_ARG_WITH([LsfReinitialization],
+
         AS_HELP_STRING([--with-LsfReinitialization = YES], [compile with LsfReinitialization capabilities (default is yes)]),
+
         [LSFREINITIALIZATION=$withval],[LSFREINITIALIZATION=yes])
+
 AC_MSG_CHECKING(for LsfReinitialization capability compilation)
 
+
 HAVE_LSFREINITIALIZATION=no 
+
 if test "x$LSFREINITIALIZATION" = "xyes"; then
+
         HAVE_LSFREINITIALIZATION=yes
+
         AC_DEFINE([_HAVE_LSFREINITIALIZATION_],[1],[with LsfReinitialization capability])
-fi
+
+fi
+
 AM_CONDITIONAL([LSFREINITIALIZATION], [test x$HAVE_LSFREINITIALIZATION = xyes])
+
 AC_MSG_RESULT($HAVE_LSFREINITIALIZATION)
+
 dnl }}}
 

issm/trunk-jpl/src/c/classes/Elements/Element.h

@@ -211 +211 @@
                 virtual void       GetVerticesCoordinatesBase(IssmDouble** xyz_list)=0;
                 virtual void       GetVerticesCoordinatesTop(IssmDouble** xyz_list)=0;
+                virtual IssmDouble GroundedArea(void)=0;
                 virtual IssmDouble IceMass(void)=0;
                 virtual IssmDouble IceVolume(void)=0;

issm/trunk-jpl/src/c/classes/Elements/Penta.cpp

@@ -1163 +1163 @@
 
 }/*}}}*/
+IssmDouble Penta::GroundedArea(void){/*{{{*/
+
+        /*Intermediaries*/
+        int         domaintype;
+        IssmDouble  phi,base_area;
+        IssmDouble  xyz_list[NUMVERTICES][3];
+
+        if(!IsIceInElement() || !IsOnBase())return 0.;
+
+        /*Get problem dimension*/
+        this->FindParam(&domaintype,DomainTypeEnum);
+        if(domaintype!=Domain3DEnum) _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
+
+        ::GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
+        phi=this->GetGroundedPortion(&xyz_list[0][0]);
+        base_area= 1./2.*fabs((xyz_list[0][0]-xyz_list[2][0])*(xyz_list[1][1]-xyz_list[0][1]) - (xyz_list[0][0]-xyz_list[1][0])*(xyz_list[2][1]-xyz_list[0][1]));
+
+        /*Clean up and return*/
+        return phi*base_area;
+}
+/*}}}*/
 IssmDouble Penta::IceMass(void){/*{{{*/
 

issm/trunk-jpl/src/c/classes/Elements/Penta.h

@@ -86 +86 @@
                 void           GetVerticesCoordinatesBase(IssmDouble** pxyz_list);
                 void           GetVerticesCoordinatesTop(IssmDouble** pxyz_list);
+                IssmDouble     GroundedArea(void);
                 IssmDouble     IceMass(void);
                 IssmDouble     IceVolume(void);

issm/trunk-jpl/src/c/classes/Elements/Seg.h

@@ -77 +77 @@
                 void        GetVerticesCoordinatesBase(IssmDouble** pxyz_list){_error_("not implemented yet");};
                 void        GetVerticesCoordinatesTop(IssmDouble** pxyz_list){_error_("not implemented yet");};
+                IssmDouble  GroundedArea(void){_error_("not implemented yet");};
                 IssmDouble  IceMass(void){_error_("not implemented yet");};
                 IssmDouble  IceVolume(void){_error_("not implemented yet");};

issm/trunk-jpl/src/c/classes/Elements/Tetra.h

@@ -81 +81 @@
                 void        GetVerticesCoordinatesTop(IssmDouble** pxyz_list);
                 void        GradientIndexing(int* indexing,int control_index){_error_("not implemented yet");};
+                IssmDouble  GroundedArea(void){_error_("not implemented yet");};
                 bool        HasFaceOnBase();
                 bool        HasFaceOnSurface();

issm/trunk-jpl/src/c/classes/Elements/Tria.cpp

@@ -1593 +1593 @@
 
 }/*}}}*/
+IssmDouble Tria::GroundedArea(void){/*{{{*/
+
+        /*Intermediaries*/
+        int         domaintype;
+        IssmDouble  phi;
+        IssmDouble *xyz_list  = NULL;
+
+        if(!IsIceInElement())return 0.;
+
+        /*Get problem dimension*/
+        this->FindParam(&domaintype,DomainTypeEnum);
+        if(domaintype!=Domain2DhorizontalEnum && domaintype!=Domain3DEnum) _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
+
+        this->GetVerticesCoordinates(&xyz_list);
+        phi=this->GetGroundedPortion(xyz_list);
+
+        /*Clean up and return*/
+        xDelete<IssmDouble>(xyz_list);
+        return phi*this->GetArea();
+}
+/*}}}*/
 bool       Tria::HasEdgeOnBase(){/*{{{*/
 

issm/trunk-jpl/src/c/classes/Elements/Tria.h

@@ -89 +89 @@
                 void        GetVerticesCoordinatesBase(IssmDouble** pxyz_list);
                 void        GetVerticesCoordinatesTop(IssmDouble** pxyz_list);
+                IssmDouble  GroundedArea(void);
                 bool        HasEdgeOnBase();
                 bool        HasEdgeOnSurface();

issm/trunk-jpl/src/c/classes/FemModel.cpp

@@ -993 +993 @@
                                         case DivergenceEnum:               this->Divergencex(&double_result);               break;
                                         case MaxDivergenceEnum:            this->MaxDivergencex(&double_result);            break;
-                                        case IceMassEnum:                this->IceMassx(&double_result);                break;
+                                        case IceMassEnum:                  this->IceMassx(&double_result);                  break;
                                         case IceVolumeEnum:                this->IceVolumex(&double_result);                break;
                                         case IceVolumeAboveFloatationEnum: this->IceVolumeAboveFloatationx(&double_result); break;
+                                        case GroundedAreaEnum:             this->GroundedAreax(&double_result);             break;
                                         case MinVelEnum:                   this->MinVelx(&double_result);                   break;
                                         case MaxVelEnum:                   this->MaxVelx(&double_result);                   break;
@@ -1611 +1612 @@
 
 }/*}}}*/
+void FemModel::GroundedAreax(IssmDouble* pV){/*{{{*/
+
+        IssmDouble local_grounded_area= 0;
+        IssmDouble total_grounded_area;
+
+        for(int i=0;i<this->elements->Size();i++){
+                Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
+                local_grounded_area+=element->GroundedArea();
+        }
+        ISSM_MPI_Reduce(&local_grounded_area,&total_grounded_area,1,ISSM_MPI_DOUBLE,ISSM_MPI_SUM,0,IssmComm::GetComm() );
+        ISSM_MPI_Bcast(&total_grounded_area,1,ISSM_MPI_DOUBLE,0,IssmComm::GetComm());
+
+        /*Assign output pointers: */
+        *pV=total_grounded_area;
+
+}/*}}}*/
 void FemModel::IceMassx(IssmDouble* pM){/*{{{*/
 

issm/trunk-jpl/src/c/classes/FemModel.h

@@ -82 +82 @@
                 void Divergencex(IssmDouble* pdiv);
                 void MaxDivergencex(IssmDouble* pdiv);
+                void GroundedAreax(IssmDouble* pV);
                 void IceMassx(IssmDouble* pV);
                 void IceVolumex(IssmDouble* pV);

issm/trunk-jpl/src/c/shared/Enum/EnumDefinitions.h

@@ -828 +828 @@
         MaxVzEnum,
         MaxAbsVzEnum,
+        GroundedAreaEnum,
         IceMassEnum,
         IceVolumeEnum,

issm/trunk-jpl/src/c/shared/Enum/EnumToStringx.cpp

@@ -809 +809 @@
                 case MaxVzEnum : return "MaxVz";
                 case MaxAbsVzEnum : return "MaxAbsVz";
+                case GroundedAreaEnum : return "GroundedArea";
                 case IceMassEnum : return "IceMass";
                 case IceVolumeEnum : return "IceVolume";

issm/trunk-jpl/src/c/shared/Enum/StringToEnumx.cpp

@@ -827 +827 @@
               else if (strcmp(name,"MaxVz")==0) return MaxVzEnum;
               else if (strcmp(name,"MaxAbsVz")==0) return MaxAbsVzEnum;
+              else if (strcmp(name,"GroundedArea")==0) return GroundedAreaEnum;
               else if (strcmp(name,"IceMass")==0) return IceMassEnum;
               else if (strcmp(name,"IceVolume")==0) return IceVolumeEnum;
@@ -874 +875 @@
               else if (strcmp(name,"RestartFileName")==0) return RestartFileNameEnum;
               else if (strcmp(name,"ToolkitsOptionsAnalyses")==0) return ToolkitsOptionsAnalysesEnum;
-              else if (strcmp(name,"ToolkitsOptionsStrings")==0) return ToolkitsOptionsStringsEnum;
          else stage=8;
    }
    if(stage==8){
-              if (strcmp(name,"QmuErrName")==0) return QmuErrNameEnum;
+              if (strcmp(name,"ToolkitsOptionsStrings")==0) return ToolkitsOptionsStringsEnum;
+              else if (strcmp(name,"QmuErrName")==0) return QmuErrNameEnum;
               else if (strcmp(name,"QmuInName")==0) return QmuInNameEnum;
               else if (strcmp(name,"QmuOutName")==0) return QmuOutNameEnum;

issm/trunk-jpl/src/m/enum/EnumDefinitions.py

@@ -801 +801 @@
 def MaxVzEnum(): return StringToEnum("MaxVz")[0]
 def MaxAbsVzEnum(): return StringToEnum("MaxAbsVz")[0]
+def GroundedAreaEnum(): return StringToEnum("GroundedArea")[0]
 def IceMassEnum(): return StringToEnum("IceMass")[0]
 def IceVolumeEnum(): return StringToEnum("IceVolume")[0]

issm/trunk-jpl/test/NightlyRun/test208.m

@@ -5 +5 @@
 md=setflowequation(md,'SSA','all');
 md.cluster=generic('name',oshostname(),'np',3);
+md.transient.requested_outputs={'default','GroundedArea'}
 md=solve(md,TransientSolutionEnum());
 

issm/trunk-jpl/test/NightlyRun/test210.m

@@ -6 +6 @@
 md=setflowequation(md,'HO','all');
 md.cluster=generic('name',oshostname(),'np',3);
+md.verbose=verbose('solution',true,'module',true);
+md.transient.requested_outputs={'default','GroundedArea'};
 md=solve(md,TransientSolutionEnum());
 

issm/trunk-jpl/test/NightlyRun/test314.m

@@ -1 +1 @@
 %Test Name: SquareSheetConstrainedTranSIA2d
-md=triangle(model(),'../Exp/Square.exp',150000.);
+md=triangle(model(),'../Exp/Square.exp',400000.);
 md=setmask(md,'','');
 md=parameterize(md,'../Par/SquareSheetConstrained.par');
 md=setflowequation(md,'SIA','all');
-md.cluster=generic('name',oshostname(),'np',3);
+md.cluster=generic('name',oshostname(),'np',1);
+md.transient.requested_outputs={'default','GroundedArea','IceVolume'}
+md.timestepping.final_time=1;
 md=solve(md,TransientSolutionEnum());
 

issm/trunk-jpl/test/NightlyRun/test317.m

@@ -3 +3 @@
 md=setmask(md,'','');
 md=parameterize(md,'../Par/SquareSheetConstrained.par');
-md=extrude(md,3,1.);
+md=extrude(md,10,1.);
 md=setflowequation(md,'HO','all');
 md.cluster=generic('name',oshostname(),'np',3);
+md.transient.requested_outputs={'default','GroundedArea'};
 md=solve(md,TransientSolutionEnum());