Changeset 21657

Timestamp:

04/04/17 05:04:06 (8 years ago)

Author:

bdef

Message:

CHG: adding case in load for future matlab compatibility

Location:

issm/trunk-jpl

Files:

• etc/environment.sh (modified) (1 diff)
• externalpackages/valgrind/install-linux64.sh (modified) (1 diff)
• m4/analyses.m4 (modified) (1 diff)
• src/m/io/loadvars.py (modified) (2 diffs)
• test/Par/SquareSheetConstrained.py (modified) (4 diffs)

issm/trunk-jpl/etc/environment.sh

@@ -124 +124 @@
 pathappend "$SSH_DIR"
 
-VALGRIND_DIR="$ISSM_DIR/externalpackages/valgrind/install"
+VALGRIND_DIR="/usr/bin/valgrind"
 pathprepend "$VALGRIND_DIR/bin"
 

issm/trunk-jpl/externalpackages/valgrind/install-linux64.sh

@@ -2 +2 @@
 set -eu
 
+#old version (Kernel issue)
+# #Some cleanup
+# rm -rf install valgrind-3.10.0
+# mkdir install
+
+
+# #Download from ISSM server
+# # $ISSM_DIR/scripts/DownloadExternalPackage.py 'http://issm.jpl.nasa.gov/files/externalpackages/valgrind-3.10.0.tar.bz2' 'valgrind-3.10.0.tar.bz2'
+
+# #Untar 
+# tar -jxvf  valgrind-3.10.0.tar.bz2
+
+# #Move valgrind into install directory
+# mv valgrind-3.10.0/* install
+# rm -rf valgrind-3.10.0
+
+# #configure
+# cd install
+# ./configure  --prefix="$ISSM_DIR/externalpackages/valgrind/install"
+
+# #Compile valgrind
+# make  -j 4
+# make install
+
+# #final thing: if mpi is compiled in, soft link its target to a simpler name
+# cd lib
+# ln -s valgrind/libmpiwrap-*  ./libmpidebug.so
+
+#New way cloned on mac
+
 #Some cleanup
-rm -rf install valgrind-3.10.0
-mkdir install
+rm -rf install
 
-#Download from ISSM server
-$ISSM_DIR/scripts/DownloadExternalPackage.py 'http://issm.jpl.nasa.gov/files/externalpackages/valgrind-3.10.0.tar.bz2' 'valgrind-3.10.0.tar.bz2'
-
-#Untar 
-tar -jxvf  valgrind-3.10.0.tar.bz2
-
-#Move valgrind into install directory
-mv valgrind-3.10.0/* install
-rm -rf valgrind-3.10.0
+#Download development version, the current release never supports the latest OS X releases
+svn co svn://svn.valgrind.org/valgrind/trunk install
 
 #configure
 cd install
-./configure  --prefix="$ISSM_DIR/externalpackages/valgrind/install"
+./autogen.sh
+./configure  --prefix="$ISSM_DIR/externalpackages/valgrind/install" --enable-only64bit
 
 #Compile valgrind
-make  -j 4
+
+make  -j 8
 make install
-
-#final thing: if mpi is compiled in, soft link its target to a simpler name
-cd lib
-ln -s valgrind/libmpiwrap-*  ./libmpidebug.so

issm/trunk-jpl/m4/analyses.m4

@@ -11 +11 @@
 
 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-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-HydrologySommers{{{
-
 AC_ARG_WITH([HydrologySommers],
-
         AS_HELP_STRING([--with-HydrologySommers = YES], [compile with HydrologySommers capabilities (default is yes)]),
-
         [HYDROLOGYSOMMERS=$withval],[HYDROLOGYSOMMERS=yes])
-
 AC_MSG_CHECKING(for HydrologySommers capability compilation)
 
-
 HAVE_HYDROLOGYSOMMERS=no 
-
 if test "x$HYDROLOGYSOMMERS" = "xyes"; then
-
         HAVE_HYDROLOGYSOMMERS=yes
-
         AC_DEFINE([_HAVE_HYDROLOGYSOMMERS_],[1],[with HydrologySommers capability])
-
-fi
-
+fi
 AM_CONDITIONAL([HYDROLOGYSOMMERS], [test x$HAVE_HYDROLOGYSOMMERS = xyes])
-
 AC_MSG_RESULT($HAVE_HYDROLOGYSOMMERS)
-
 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-Sealevelrise{{{
-
 AC_ARG_WITH([Sealevelrise],
-
         AS_HELP_STRING([--with-Sealevelrise = YES], [compile with Sealevelrise capabilities (default is yes)]),
-
         [SEALEVELRISE=$withval],[SEALEVELRISE=yes])
-
 AC_MSG_CHECKING(for Sealevelrise capability compilation)
 
-
 HAVE_SEALEVELRISE=no 
-
 if test "x$SEALEVELRISE" = "xyes"; then
-
         HAVE_SEALEVELRISE=yes
-
         AC_DEFINE([_HAVE_SEALEVELRISE_],[1],[with Sealevelrise capability])
-
-fi
-
+fi
 AM_CONDITIONAL([SEALEVELRISE], [test x$HAVE_SEALEVELRISE = xyes])
-
 AC_MSG_RESULT($HAVE_SEALEVELRISE)
-
 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-GiaIvins{{{
-
 AC_ARG_WITH([GiaIvins],
-
         AS_HELP_STRING([--with-GiaIvins = YES], [compile with GiaIvins capabilities (default is yes)]),
-
         [GIAIVINS=$withval],[GIAIVINS=yes])
-
 AC_MSG_CHECKING(for GiaIvins capability compilation)
 
-
 HAVE_GIAIVINS=no 
-
 if test "x$GIAIVINS" = "xyes"; then
-
         HAVE_GIAIVINS=yes
-
         AC_DEFINE([_HAVE_GIAIVINS_],[1],[with GiaIvins capability])
-
-fi
-
+fi
 AM_CONDITIONAL([GIAIVINS], [test x$HAVE_GIAIVINS = xyes])
-
 AC_MSG_RESULT($HAVE_GIAIVINS)
-
 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-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 }}}
 

issm/trunk-jpl/src/m/io/loadvars.py

@@ -228 +228 @@
                                 classe=str(group)+'.'+str(subgroup)
                                 class_dict[classe]=[str(getattr(NCData.groups[group].groups[subgroup],'classtype')),]
-                                if class_dict[classe][0] not in ['dict','list']:
+                                if class_dict[classe][0] not in ['dict','list','cell']:
                                         class_dict[classe].append(__import__(class_dict[classe][0]))
                                 class_tree[classe]=[group,subgroup]
@@ -235 +235 @@
                         try:
                                 class_dict[classe]=[str(getattr(NCData.groups[group],'classtype')),]
-                                if class_dict[classe][0] not in ['dict','list']:
+                                if class_dict[classe][0] not in ['dict','list','cell']:
                                         class_dict[classe].append(__import__(class_dict[classe][0]))
                                         class_tree[classe]=[group,]

issm/trunk-jpl/test/Par/SquareSheetConstrained.py

@@ -1 +1 @@
 import os.path
-import numpy
+import numpy as np
 import inspect
 from verbose import verbose
@@ -13 +13 @@
 hmin=300.
 hmax=1000.
-ymin=numpy.min(md.mesh.y)
-ymax=numpy.max(md.mesh.y)
-xmin=min(md.mesh.x)
-xmax=max(md.mesh.x)
+ymin=np.min(md.mesh.y)
+ymax=np.max(md.mesh.y)
+xmin=np.min(md.mesh.x)
+xmax=np.max(md.mesh.x)
 md.geometry.thickness=hmax+(hmin-hmax)*(md.mesh.y-ymin)/(ymax-ymin)+0.1*(hmin-hmax)*(md.mesh.x-xmin)/(xmax-xmin)
 md.geometry.base=-md.materials.rho_ice/md.materials.rho_water*md.geometry.thickness+20.
@@ -22 +22 @@
 
 #Initial velocity 
-x         = numpy.array(archread('../Data/SquareSheetConstrained.arch','x'))
-y         = numpy.array(archread('../Data/SquareSheetConstrained.arch','y'))
-vx        = numpy.array(archread('../Data/SquareSheetConstrained.arch','vx'));
-vy        = numpy.array(archread('../Data/SquareSheetConstrained.arch','vy'));
+x         = np.array(archread('../Data/SquareSheetConstrained.arch','x'))
+y         = np.array(archread('../Data/SquareSheetConstrained.arch','y'))
+vx        = np.array(archread('../Data/SquareSheetConstrained.arch','vx'));
+vy        = np.array(archread('../Data/SquareSheetConstrained.arch','vy'));
 index     = archread('../Data/SquareSheetConstrained.arch','index').astype(int);
 
-[md.initialization.vx]=InterpFromMeshToMesh2d(index,x,y,vx,md.mesh.x,md.mesh.y)
-[md.initialization.vy]=InterpFromMeshToMesh2d(index,x,y,vy,md.mesh.x,md.mesh.y)
-md.initialization.vz=numpy.zeros((md.mesh.numberofvertices))
-md.initialization.pressure=numpy.zeros((md.mesh.numberofvertices))
+md.initialization.vx=InterpFromMeshToMesh2d(index,x,y,vx,md.mesh.x,md.mesh.y)[0]
+md.initialization.vy=InterpFromMeshToMesh2d(index,x,y,vy,md.mesh.x,md.mesh.y)[0]
+md.initialization.vz=np.zeros((md.mesh.numberofvertices))
+md.initialization.pressure=np.zeros((md.mesh.numberofvertices))
 
 #Materials
-md.initialization.temperature=(273.-20.)*numpy.ones((md.mesh.numberofvertices))
+md.initialization.temperature=(273.-20.)*np.ones((md.mesh.numberofvertices))
 md.materials.rheology_B=paterson(md.initialization.temperature)
-md.materials.rheology_n=3.*numpy.ones((md.mesh.numberofelements))
+md.materials.rheology_n=3.*np.ones((md.mesh.numberofelements))
 
 #Calving
-md.calving.calvingrate=0.*numpy.ones((md.mesh.numberofvertices))
-md.levelset.spclevelset=float('NaN')*numpy.ones((md.mesh.numberofvertices))
+md.calving.calvingrate=np.zeros((md.mesh.numberofvertices))
+md.levelset.spclevelset=np.nan*np.ones((md.mesh.numberofvertices))
 
 #Friction
-md.friction.coefficient=20.*numpy.ones((md.mesh.numberofvertices))
-md.friction.coefficient[numpy.nonzero(md.mask.groundedice_levelset<0.)[0]]=0.
-md.friction.p=numpy.ones((md.mesh.numberofelements))
-md.friction.q=numpy.ones((md.mesh.numberofelements))
+md.friction.coefficient=20.*np.ones((md.mesh.numberofvertices))
+md.friction.coefficient[np.where(md.mask.groundedice_levelset<0.)[0]]=0.
+md.friction.p=np.ones((md.mesh.numberofelements))
+md.friction.q=np.ones((md.mesh.numberofelements))
 
 #Numerical parameters
@@ -57 +57 @@
 md.steadystate.reltol=0.05
 md.stressbalance.reltol=0.05
-md.stressbalance.abstol=float('NaN')
+md.stressbalance.abstol=np.nan
 md.timestepping.time_step=1.
 md.timestepping.final_time=3.
 
 #GIA:
-md.gia.lithosphere_thickness=100.*numpy.ones((md.mesh.numberofvertices)); # in km
-md.gia.mantle_viscosity=1.*10**21*numpy.ones((md.mesh.numberofvertices)); # in Pa.s
+md.gia.lithosphere_thickness=100.*np.ones((md.mesh.numberofvertices)); # in km
+md.gia.mantle_viscosity=1.*10**21*np.ones((md.mesh.numberofvertices)); # in Pa.s
 md.materials.lithosphere_shear_modulus=6.7*10**10;                          # in Pa
 md.materials.lithosphere_density=3.32;                                      # in g/cm^-3