Changeset 13101

issm/branches/trunk-jpl-damage

Property svn:ignore

old	new
	1	projects
1	2	autom4te.cache
2	3	aclocal.m4

Property svn:mergeinfo changed
/issm/trunk-jpl merged: 12948-13099

issm/branches/trunk-jpl-damage/Makefile.am

r12878	r13101
1	1	EXTRA_DIST = reconf scripts test m4 examples cron etc doc packages contributors.txt
2		SUBDIRS = src ~~bin~~
	2	SUBDIRS = src
3	3	bin_SCRIPTS=config.h startup.m README.rtf
	4
	5	ACLOCAL_AMFLAGS = -I externalpackages/libtool/install/share/aclocal

issm/branches/trunk-jpl-damage/configs/config-macosx64-larour-ad.sh

-              r12878
+              r13101
 ./configure \
         --prefix=$ISSM_DIR \
+        --without-modules\
+        --without-thermal \
+        --without-control \
+        --without-hydrology \
+        --without-diagnostic \
+        --without-balanced \
+        --without-responses \
+        --without-slope \
+        --without-rifts \
+        --without-steadystate \
+        --without-transient \
+        --without-3d \
+        --without-groundingline \
+        --without-modules \
         --without-kriging  \
         --with-gsl-dir=$ISSM_DIR/externalpackages/gsl/install
         #--with-adolc-dir=$ISSM_DIR/externalpackages/adolc/install\
+        --with-gsl-dir=$ISSM_DIR/externalpackages/gsl/install \
+        --with-adolc-dir=$ISSM_DIR/externalpackages/adolc/install

issm/branches/trunk-jpl-damage/configure.ac

-              r12946
+              r13101
 AC_INIT([ISSM],[4.2.1],[issm@jpl.nasa.gov],[issm],[http://issm.jpl.nasa.gov]) #Initializing configure
 AC_CONFIG_AUX_DIR([./aux-config])         #Put config files in aux-config
+AC_CONFIG_MACRO_DIR([m4])                 #m4 macros are located in m4
+AC_CONFIG_MACRO_DIR([externalpackages/libtool/install/share/aclocal])                 #m4 macros are located in m4
+m4_include([m4/issm_options.m4])
 AC_CANONICAL_TARGET                       #Determine the system type
 #Compilers
 AC_PROG_CC([cccl cl icl gcc])
 …
 AC_PROG_CXX([cccl cl icl g++])
 AC_PROG_F77([ifort g77 gfortran])
 #Libraries and linking
 AC_F77_LIBRARY_LDFLAGS
 …
 AM_PROG_CC_C_O
 AM_PROG_AR
-AC_PROG_RANLIB
+# To produce shared libraries uncomment LT_INIT. In theory, Libtool can be initialized
+# even if all linking is static, since, if not shared libraries are to be produce, libtool
+# will act simply as a wrapper around AR and Ranlib.
+#LT_INIT
+#Libtool
+LT_INIT
 #Run issm_options.m4
 …
                         src/Makefile
                         src/c/Makefile
-                        src/py/Makefile
-                        src/py/model/Makefile
                         src/modules/Makefile
                         src/modules/python/Makefile
                         src/modules/matlab/Makefile
+                        src/m/Makefile
+                        bin/Makefile])
+                        src/m/Makefile])
 #End of configure.ac

issm/branches/trunk-jpl-damage/etc/environment.csh

-              r12878
+              r13101
 #ISSM_DIR and ISSM_ARCH should have been defined already in your shell settings file (.bashrc, .cshrc, etc ...)
-source $ISSM_DIR/etc/environment_variables.csh
+#Do we have any command line arguments? (such as MATLAB_DIR=otherdirthandefault), source them before exporting the variables
+#to environment.
+#foreach i ($@)
+#eval $i
+#end
+#CRON utilities
+setenv PATH {$PATH}:{$ISSM_DIR}/cron
+#SCRIPTS utilities
+#Load ISSM scripts
 setenv PATH {$PATH}:{$ISSM_DIR}/scripts
 #MATLAB
+setenv MATLAB_DIR {$MATLAB_DIR}
+setenv PATH {$MATLAB_DIR}/bin:{$PATH}
+setenv LD_LIBRARY_PATH {$LD_LIBRARY_PATH}:$MATLAB_DIR/lib
+set MATLAB_DIR="$ISSM_DIR/externalpackages/matlab/install"
+if (-d MATLAB_DIR) then
+        setenv MATLAB_DIR {$MATLAB_DIR}
+        setenv PATH {$MATLAB_DIR}/bin:{$PATH}
+        setenv LD_LIBRARY_PATH {$LD_LIBRARY_PATH}:{$MATLAB_DIR}/bin/glnxa64
+endif
 #MPI
+setenv MPI_DIR {$MPI_DIR}
+setenv PATH {$MPI_DIR}/bin:{$PATH}
+setenv LD_LIBRARY_PATH {$LD_LIBRARY_PATH}:$MPI_DIR/lib
+setenv MANPATH {$MANPATH}:$MPI_DIR/man
+setenv MPIRUN_NPROCS 8
+set MPI_DIR="$ISSM_DIR/externalpackages/mpich2/install"
+if (-d $MPI_DIR) then
+        setenv MPI_DIR {$MPI_DIR}
+        setenv PATH {$MPI_DIR}/bin:{$PATH}
+        setenv LD_LIBRARY_PATH {$LD_LIBRARY_PATH}:$MPI_DIR/lib
+        setenv MANPATH {$MANPATH}:$MPI_DIR/man
+endif
 #PETSC
+setenv PETSC_DIR {$PETSC_DIR}
+setenv LD_LIBRARY_PATH {$LD_LIBRARY_PATH}:$PETSC_DIR/lib/{$ISSM_ARCH}
+set PETSC_DIR="$ISSM_DIR/externalpackages/petsc/install"
+if (-d $PETSC_DIR) then
+        setenv PETSC_DIR {$PETSC_DIR}
+        setenv LD_LIBRARY_PATH {$LD_LIBRARY_PATH}:$PETSC_DIR/lib/{$ISSM_ARCH}
+endif
 #SLEPC
+setenv SLEPC_DIR {$SLEPC_DIR}
+setenv LD_LIBRARY_PATH {$LD_LIBRARY_PATH}:$SLEPC_DIR/lib/{$ISSM_ARCH}
+set SLEPC_DIR="$ISSM_DIR/externalpackages/slepc/install"
+if (-d $SLEPC_DIR) then
+        setenv LD_LIBRARY_PATH {$LD_LIBRARY_PATH}:$SLEPC_DIR/lib/{$ISSM_ARCH}
+endif
+#PETSC
+set TAO_DIR="$ISSM_DIR/externalpackages/tao/install"
+if (-d $TAO_DIR) then
+        setenv LD_LIBRARY_PATH {$LD_LIBRARY_PATH}:$TAO_DIR/lib/{$ISSM_ARCH}
+endif
 #Dakota
+setenv DAKOTA_DIR {$DAKOTA_DIR}
+setenv PATH {$PATH}:{$DAKOTA_DIR}/bin
+setenv MANPATH {$MANPATH}:{$MPI_DIR}/man:{$DAKOTA_DIR}/docs/man:{$DAKOTA_DIR}/docs/man-ref
+#Qhull
+setenv QHULL_DIR {$QHULL_DIR}
+setenv LD_LIBRARY_PATH {$LD_LIBRARY_PATH}:{$QHULL_DIR}/lib
+set DAKOTA_DIR="$ISSM_DIR/externalpackages/dakota/install"
+if (-d $DAKOTA_DIR) then
+        setenv PATH {$PATH}:{$DAKOTA_DIR}/bin
+        setenv MANPATH {$MANPATH}:{$MPI_DIR}/man:{$DAKOTA_DIR}/docs/man:{$DAKOTA_DIR}/docs/man-ref
+endif
 #Doxygen
+setenv DOXYGEN_DIR {$DOXYGEN_DIR}
+setenv MANPATH {$MANPATH}:{$DOXYGEN_DIR}/man
+setenv PATH {$PATH}:{$DOXYGEN_DIR}/bin
+#MTOC
+setenv MTOC_DIR {$MTOC_DIR}
+setenv PATH {$PATH}:{$MTOC_DIR}
+#MATLAB
+setenv MATLAB_DIR {$MATLAB_DIR}
+setenv LD_LIBRARY_PATH {$LD_LIBRARY_PATH}:{$MATLAB_DIR}/bin/glnxa64
+setenv PATH {$PATH}:{$MATLAB_DIR}/bin
+#TRIANGLE
+setenv TRIANGLE_DIR {$TRIANGLE_DIR}
+#METIS
+setenv METIS_DIR {$METIS_DIR}
+#BLAS
+setenv BLAS_DIR {$BLAS_DIR}
+#LAPACK
+setenv LAPACK_DIR {$LAPACK_DIR}
+#SCALAPACK
+setenv SCALAPACK_DIR {$SCALAPACK_DIR}
+#PLAPACK
+setenv PLAPACK_DIR {$PLAPACK_DIR}
+#BLACS
+setenv BLACS_DIR {$BLACS_DIR}
+#YAMS
+setenv YAMS_DIR {$YAMS_DIR}
+setenv PATH {$PATH}:{$YAMS_DIR}
+#TEX2IM
+setenv TEX2IM_DIR {$TEX2IM_DIR}
+setenv PATH {$PATH}:{$TEX2IM_DIR}
+#SOWING
+setenv SOWING_DIR {$SOWING_DIR}
+setenv PATH {$PATH}:{$SOWING_DIR}/bin
+setenv LD_LIBRARY_PATH {$LD_LIBRARY_PATH}:{$SOWING_DIR}/lib
+setenv MANPATH {$MANPATH}:{$SOWING_DIR}/man
+#Chaco
+setenv CHACO_DIR {$CHACO_DIR}
+setenv PATH {$PATH}:{$CHACO_DIR}
+#MeshPart
+setenv MESHPART_DIR {$MESHPART_DIR}
+setenv PATH {$PATH}:{$MESHPART_DIR}
+#SCOTCH
+setenv SCOTCH_DIR {$SCOTCH_DIR}
+setenv PATH {$PATH}:{$SCOTCH_DIR}
+setenv MANPATH {$MANPATH}:{$SCOTCH_DIR}/man
+set DOXYGEN_DIR="$ISSM_DIR/externalpackages/doxygen/install"
+if (-d $DOXYGEN_DIR) then
+        setenv MANPATH {$MANPATH}:{$DOXYGEN_DIR}/man
+        setenv PATH {$PATH}:{$DOXYGEN_DIR}/bin
+endif
 #AUTOCONF
+setenv AUTOCONF_DIR {$AUTOCONF_DIR}
+setenv PATH {$AUTOCONF_DIR}/bin:{$PATH}
+set AUTOCONF_DIR="$ISSM_DIR/externalpackages/autoconf/install"
+if (-d $AUTOCONF_DIR) then
+        setenv PATH {$AUTOCONF_DIR}/bin:{$PATH}
+endif
 #AUTOMAKE
+setenv AUTOMAKE_DIR {$AUTOMAKE_DIR}
+setenv PATH {$AUTOMAKE_DIR}/bin:{$PATH}
+#BORLAND
+setenv BORLAND_DIR {$BORLAND_DIR}
+setenv PATH {$PATH}:{$BORLAND_DIR}/Bin
+set AUTOMAKE_DIR="$ISSM_DIR/externalpackages/automake/install"
+if (-d $AUTOMAKE_DIR) then
+        setenv PATH {$AUTOMAKE_DIR}/bin:{$PATH}
+endif
 #SSH
+setenv SSH_DIR {$SSH_DIR}
+setenv PATH {$PATH}:{$SSH_DIR}
+set SSH_DIR="$ISSM_DIR/externalpackages/ssh"
+if (-d $SSH_DIR) then
+        setenv PATH {$PATH}:{$SSH_DIR}
+endif
 #VALGRIND
+setenv VALGRIND_DIR {$VALGRIND_DIR}
+setenv PATH {$PATH}:{$VALGRIND_DIR}
+set VALGRIND_DIR="$ISSM_DIR/externalpackages/valgrind/install/bin"
+if (-d $VALGRIND_DIR) then
+        setenv PATH {$PATH}:{$VALGRIND_DIR}
+endif
 #MERCURIAL
+#setenv PYTHONPATH {$PYTHONPATH}:{$MERCURIAL_DIR}/mercurial/pure/
+setenv PYTHONPATH {$MERCURIAL_DIR}/mercurial/pure/
+setenv PATH {$PATH}:{$MERCURIAL_DIR}
+set MERCURIAL_DIR="$ISSM_DIR/externalpackages/mercurial/install"
+if (-d $MERCURIAL_DIR) then
+        setenv PYTHONPATH {$MERCURIAL_DIR}/mercurial/pure/
+        setenv PATH {$PATH}:{$MERCURIAL_DIR}
+endif
 #GSL
+setenv GSL_DIR {$GSL_DIR}
+setenv LD_LIBRARY_PATH {$LD_LIBRARY_PATH}:{$GSL_DIR}/lib
+set GSL_DIR="$ISSM_DIR/externalpackages/gsl/install"
+if (-d $GSL_DIR) then
+        setenv LD_LIBRARY_PATH {$LD_LIBRARY_PATH}:{$GSL_DIR}/lib
+endif
 #CMAKE
+setenv PATH {$PATH}:{$CMAKE_DIR}/bin
+set CMAKE_DIR="$ISSM_DIR/externalpackages/cmake/install"
+if (-d $CMAKE_DIR) then
+        setenv PATH {$PATH}:{$CMAKE_DIR}/bin
+endif

issm/branches/trunk-jpl-damage/etc/environment.sh

-              r12946
+              r13101
 #ISSM_DIR and ISSM_ARCH should have been defined already in your shell settings file (.bashrc, .cshrc, etc ...)
+#FIXME: during installation packages are installed one by one but environment.sh was sourced
+#before so new packages are NOT in the path.
+#may resource environment.sh with:
+#if [ -z $(echo "$PATH" | grep "$MATLAB_DIR") ]; then export $PATH...; fi
 #Windows compilers:
 …
 fi
+source $ISSM_DIR/etc/environment_variables.sh
+#Do we have any command line arguments? (such as MATLAB_DIR=otherdirthandefault), source them after exporting the variables
+#to environment.
+for i in $@
+do
+        eval $i
+done
+#CRON utilities
+PATH="$PATH:$ISSM_DIR/cron"
+#scripts
+PATH="$PATH:$ISSM_DIR/scripts"
+##MATLAB
+export MATLAB_DIR
+PATH="$MATLAB_DIR/bin:$PATH" #take precedence over /usr/local/bin/matlab
+export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$MATLAB_DIR/lib"
+export LD_RUN_PATH="$LD_RUN_PATH:$MATLAB_DIR/lib"
+#export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$MATLAB_DIR/bin/glnxa64"
+#export LD_RUN_PATH="$LD_RUN_PATH:$MATLAB_DIR/bin/glnxa64"
+#MPI
+export MPI_DIR
+PATH="$MPI_DIR/bin:$PATH"
+export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$MPI_DIR/lib"
+export LD_RUN_PATH="$LD_RUN_PATH:$MPI_DIR/lib"
+export MANPATH="$MANPATH:$MPI_DIR/man"
+export MPIRUN_NPROCS=24
+#PETSC
+export PETSC_DIR
+export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$PETSC_DIR/lib/$ISSM_ARCH:$PETSC_DIR/lib"
+export LD_RUN_PATH="$LD_RUN_PATH:$PETSC_DIR/lib/$ISSM_ARCH"
+#SLEPC
+export SLEPC_DIR
+export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$SLEPC_DIR/lib/$ISSM_ARCH"
+export LD_RUN_PATH="$LD_RUN_PATH:$SLEPC_DIR/lib/$ISSM_ARCH"
+#Dakota
+export DAKOTA_DIR
+PATH="$PATH:$DAKOTA_DIR/bin"
+export MANPATH="$MANPATH:$MPI_DIR/man:$DAKOTA_DIR/docs/man:$DAKOTA_DIR/docs/man-ref"
+#Qhull
+export QHULL_DIR
+export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$QHULL_DIR/lib"
+export LD_RUN_PATH="$LD_RUN_PATH:$QHULL_DIR/lib"
+#Doxygen
+export DOXYGEN_DIR
+MANPATH="$MANPATH:$DOXYGEN_DIR/man"
+PATH="$PATH:$DOXYGEN_DIR/bin"
+#MTOC
+export MTOC_DIR
+PATH="$PATH:$MTOC_DIR"
+#TRIANGLE
+export TRIANGLE_DIR
+#METIS
+export METIS_DIR
+#BLAS
+export BLAS_DIR
+#LAPACK
+export LAPACK_DIR
+#SCALAPACK
+export SCALAPACK_DIR
+#PLAPACK
+export PLAPACK_DIR
+#BLACS
+export BLACS_DIR
+#YAMS
+export YAMS_DIR
+PATH="$PATH:$YAMS_DIR"
+#BAMG
+export BAMG_DIR
+PATH="$PATH:$BAMG_DIR"
+#TEX2IM
+export TEX2IM_DIR
+PATH="$PATH:$TEX2IM_DIR"
+#SOWING
+export SOWING_DIR
+PATH="$PATH:$SOWING_DIR/bin"
+export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$SOWING_DIR/lib"
+export LD_RUN_PATH="$LD_RUN_PATH:$SOWING_DIR/lib"
+export MANPATH="$MANPATH:$SOWING_DIR/man"
+#Chaco
+export CHACO_DIR
+PATH="$PATH:$CHACO_DIR"
+#MeshPart
+export MESHPART_DIR
+PATH="$PATH:$MESHPART_DIR"
+#SCOTCH
+export SCOTCH_DIR
+PATH="$PATH:$SCOTCH_DIR"
+export MANPATH="$MANPATH:$SCOTCH_DIR/man"
+#AUTOCONF
+export AUTOCONF_DIR
+PATH="$AUTOCONF_DIR/bin:$PATH"
+#AUTOMAKE
+export AUTOMAKE_DIR
+PATH="$AUTOMAKE_DIR/bin:$PATH"
+export LIBTOOL_DIR
+PATH="$LIBTOOL_DIR/bin:$PATH"
+#BORLAND
+export BORLAND_DIR
+PATH="$PATH:$BORLAND_DIR/Bin"
+#INTEL
+#export INTEL_DIR
+#PATH="$PATH:$INTEL_DIR"
+#source $ISSM_DIR/externalpackages/intel/intel.sh
+#SDK
+export SDK_DIR
+PATH="$PATH:$SDK_DIR"
+#SSH
+export SSH_DIR
+PATH="$PATH:$SSH_DIR"
+#VALGRIND
+export VALGRIND_DIR
+PATH="$PATH:$VALGRIND_DIR"
+#GRAPHVIZ
+export GRAPHVIZ_DIR
+PATH="$PATH:$GRAPHVIZ_DIR"
+#CPPCHECK
+export CPPCHECK_DIR
+PATH="$PATH:$CPPCHECK_DIR"
+#GDAL
+export GDAL_DIR
+PATH="$GDAL_DIR/bin:$PATH"
+export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$GDAL_DIR/lib"
+#MERCURIAL
+export PYTHONPATH="$PYTHONPATH:$MERCURIAL_DIR/mercurial/pure/"
+export PATH="$PATH:$MERCURIAL_DIR/"
+#BOOST
+export BOOSTROOT
+export BOOST_DIR
+export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$BOOST_DIR/lib"
+export DYLD_LIBRARY_PATH="$DYLD_LIBRARY_PATH:$BOOST_DIR/lib"
+export PATH="$PATH:$BOOST_DIR/bin"
+#XERCES
+export XERCESROOT
+export XERCESCROOT
+#xaifBooster
+export XAIFBOOSTERROOT
+export XAIFBOOSTER_HOME
+export XAIF_DIR
+export PLATFORM
+#angel
+export ANGELROOT
+#openanalysis
+export OPENANALYSISROOT
+export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$OPENANALYSISROOT/lib"
+#JAVA
+export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$JVM_DIR"
+#BBFTP
+export PATH="$PATH:$BBFTP_DIR/bin"
+#ADIC
+export PATH="$PATH:$ADIC_DIR/bin"
+export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$ADIC_DIR/lib"
+export LD_RUN_PATH="$LD_RUN_PATH:$ADIC_DIR/lib"
+#COLPACK
+export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$COLPACK_DIR/lib"
+export LD_RUN_PATH="$LD_RUN_PATH:$COLPACK_DIR/lib"
+#ECLIPSE
+export PATH="$PATH:$ECLIPSE_DIR"
+#FLAIM
+export FLAIM_DIR
+#APPSCAN
+export PATH="$PATH:$APPSCAN_DIR/install/bin"
+export PATH="$PATH:$APPSCAN_DIR/bin"
+#CPPCHECK
+export PATH="$PATH:$CPPCHECK_DIR/bin"
+#RATS
+export PATH="$PATH:$RATS_DIR/bin"
+#DYSON
+export PATH="$PATH:$DYSON_DIR"
+#CMAKE
+export PATH="$PATH:$CMAKE_DIR/bin"
+#SHAPELIB
+export PATH="$PATH:$SHAPELIB_DIR/exec"
+#CCCL
+export PATH="$PATH:$CCCL_DIR/bin"
+#PACKAGEMAKER
+export PATH="$PATH:$PACKAGEMAKER_DIR"
+#ANDROID_NDK:
+export ANDROID_NDK_DIR
+export PATH="$PATH:$ANDROID_NDK_DIR/"
+#ANDROID_DIR
+export ANDROID_DIR
+#ANDROID_SDK
+export PATH="$PATH:$ANDROID_SDK_DIR/"
+#ANDROID_ANT
+export PATH="$PATH:$ANDROID_ANT_DIR/"
+#GSL
+export PATH="$PATH:$GSL_DIR/bin"
+export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$GSL_DIR/lib"
+export LD_RUN_PATH="$LD_RUN_PATH:$GSL_DIR/lib"
+#GMAKE
+export PATH="$GMAKE_DIR/bin:$PATH"
+#PYTHON
+export PATH="$PYTHON_DIR/bin:$PATH"
+export PYTHONPATH="$PYTHONPATH:$ISSM_DIR/src/modules/python"
+export LD_LIBRARY_PATH=$ISSM_DIR/src/modules/python:$ISSM_DIR/externalpackages/python/install/lib:$LD_LIBRARY_PATH
+export PYTHONSTARTUP
+#MODELE
+export PATH="$MODELE_DIR/src/exec:$PATH"
+#GIT
+export PATH="$PATH:$GIT_DIR/install/bin"
+#NCVIEW
+export PATH="$PATH:$NCVIEW_DIR/install"
+#TCLX
+export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$TCLX_DIR"
+export LD_RUN_PATH="$LD_RUN_PATH:$TCLX_DIR"
+#TCL/TK
+#Some basic path, in case it is not included by default
 export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:/usr/local/lib"
 export LD_RUN_PATH="$LD_RUN_PATH:/usr/local/lib"
+#Load ISSM scripts
+export PATH="$PATH:$ISSM_DIR/scripts"
+#MATLAB
+MATLAB_DIR="$ISSM_DIR/externalpackages/matlab/install"
+#if [ -d "$MATLAB_DIR" ]; then
+        export MATLAB_DIR
+        export PATH="$MATLAB_DIR/bin:$PATH" #take precedence over /usr/local/bin/matlab
+        export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$MATLAB_DIR/lib"
+        export LD_RUN_PATH="$LD_RUN_PATH:$MATLAB_DIR/lib"
+#fi
+#MPI
+MPI_DIR="$ISSM_DIR/externalpackages/mpich2/install"
+#if [ -d "$MPI_DIR" ]; then
+        export MPI_DIR
+        export PATH="$MPI_DIR/bin:$PATH"
+        export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$MPI_DIR/lib"
+        export LD_RUN_PATH="$LD_RUN_PATH:$MPI_DIR/lib"
+        export MANPATH="$MANPATH:$MPI_DIR/man"
+#fi
+#PETSC
+PETSC_DIR="$ISSM_DIR/externalpackages/petsc/install"
+#if [ -d "$PETSC_DIR" ]; then
+        export PETSC_DIR
+        export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$PETSC_DIR/lib:$PETSC_DIR/lib"
+        export LD_RUN_PATH="$LD_RUN_PATH:$PETSC_DIR/lib"
+#fi
+#SLEPC
+SLEPC_DIR="$ISSM_DIR/externalpackages/slepc/install"
+if [ -d "$SLEPC_DIR" ]; then
+        export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$SLEPC_DIR/lib/$ISSM_ARCH"
+        export LD_RUN_PATH="$LD_RUN_PATH:$SLEPC_DIR/lib/$ISSM_ARCH"
+fi
+#PETSC
+TAO_DIR="$ISSM_DIR/externalpackages/tao/install"
+if [ -d "$TAO_DIR" ]; then
+        export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$TAO_DIR/lib:$TAO_DIR/lib"
+        export LD_RUN_PATH="$LD_RUN_PATH:$TAO_DIR/lib"
+fi
+#Dakota
+DAKOTA_DIR="$ISSM_DIR/externalpackages/dakota/install"
+if [ -d "$DAKOTA_DIR" ]; then
+        export PATH="$PATH:$DAKOTA_DIR/bin"
+        export MANPATH="$MANPATH:$MPI_DIR/man:$DAKOTA_DIR/docs/man:$DAKOTA_DIR/docs/man-ref"
+fi
+#Doxygen
+DOXYGEN_DIR="$ISSM_DIR/externalpackages/doxygen/install"
+if [ -d "$DOXYGEN_DIR" ]; then
+        export MANPATH="$MANPATH:$DOXYGEN_DIR/man"
+        export PATH="$PATH:$DOXYGEN_DIR/bin"
+fi
+#AUTOCONF
+AUTOCONF_DIR="$ISSM_DIR/externalpackages/autoconf/install"
+#if [ -d "$AUTOCONF_DIR" ]; then
+        export PATH="$AUTOCONF_DIR/bin:$PATH"
+#fi
+#AUTOMAKE
+AUTOMAKE_DIR="$ISSM_DIR/externalpackages/automake/install"
+#if [ -d "$AUTOMAKE_DIR" ]; then
+        export PATH="$AUTOMAKE_DIR/bin:$PATH"
+#fi
+#LIBTOOL
+LIBTOOL_DIR="$ISSM_DIR/externalpackages/libtool/install"
+#if [ -d "$LIBTOOL_DIR" ]; then
+        export PATH="$LIBTOOL_DIR/bin:$PATH"
+#fi
+#SDK
+SDK_DIR="C:/MicrosoftVisualStudio 9.0/Microsoft Visual C++ 2008 Express Edition with SP1 - ENU"
+if [ -d "$SDK_DIR" ]; then
+        export PATH="$PATH:$SDK_DIR"
+fi
+#SSH
+SSH_DIR="$ISSM_DIR/externalpackages/ssh"
+if [ -d "$SSH_DIR" ]; then
+        export PATH="$PATH:$SSH_DIR"
+fi
+#VALGRIND
+VALGRIND_DIR="$ISSM_DIR/externalpackages/valgrind/install"
+if [ -d "$VALGRIND_DIR" ]; then
+        export PATH="$VALGRIND_DIR/bin:$PATH"
+fi
+#CPPCHECK
+CPPCHECK_DIR="$ISSM_DIR/externalpackages/cppcheck/install"
+if [ -d "$CPPCHECK_DIR" ]; then
+        export PATH="$PATH:$CPPCHECK_DIR/bin"
+fi
+#GDAL
+GDAL_DIR="$ISSM_DIR/externalpackages/gdal/install"
+if [ -d "$GDAL_DIR" ]; then
+        export PATH="$GDAL_DIR/bin:$PATH"
+        export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$GDAL_DIR/lib"
+fi
+#MERCURIAL
+MERCURIAL_DIR="$ISSM_DIR/externalpackages/mercurial/install"
+if [ -d "$MERCURIAL_DIR" ]; then
+        export PYTHONPATH="$PYTHONPATH:$MERCURIAL_DIR/mercurial/pure/"
+        export PATH="$PATH:$MERCURIAL_DIR/"
+fi
+#BOOST
+BOOST_DIR="$ISSM_DIR/externalpackages/boost/install"
+BOOSTROOT="$ISSM_DIR/externalpackages/boost/install"
+if [ -d "$BOOST_DIR" ]; then
+        export BOOSTROOT
+        export BOOST_DIR
+        export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$BOOST_DIR/lib"
+        export DYLD_LIBRARY_PATH="$DYLD_LIBRARY_PATH:$BOOST_DIR/lib"
+        export PATH="$PATH:$BOOST_DIR/bin"
+fi
+#XERCES
+XERCESROOT="$ISSM_DIR/externalpackages/xerces/install"
+XERCESCROOT="$ISSM_DIR/externalpackages/xerces/src"
+if [ -d "$XERCESROOT" ]; then
+        export XERCESROOT
+        export XERCESCROOT
+fi
+#xaifBooster
+XAIF_DIR="$ISSM_DIR/externalpackages/xaifbooster/xaifBooster"
+XAIFBOOSTERROOT="$ISSM_DIR/externalpackages/xaifbooster/"
+XAIFBOOSTER_HOME="$ISSM_DIR/externalpackages/xaifbooster/xaifBooster"
+PLATFORM="x86-Linux"
+if [ -d "$XAIF_DIR" ]; then
+        export XAIFBOOSTERROOT
+        export XAIFBOOSTER_HOME
+        export XAIF_DIR
+        export PLATFORM
+fi
+#angel
+ANGELROOT="$ISSM_DIR/externalpackages/angel/angel"
+if [ -d "$ANGELROOT" ]; then
+        export ANGELROOT
+fi
+#openanalysis
+OPENANALYSISROOT="$ISSM_DIR/externalpackages/openanalysis/install"
+if [ -d "$OPENANALYSISROOT" ]; then
+        export OPENANALYSISROOT
+        export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$OPENANALYSISROOT/lib"
+fi
+#JAVA
+JVM_DIR="/usr/local/gcc/4.3.2/lib64/gcj-4.3.2-9/"
+if [ -d "$JVM_DIR" ]; then
+        export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$JVM_DIR"
+fi
+#BBFTP
+BBFTP_DIR="$ISSM_DIR/externalpackages/bbftp/install"
+if [ -d "$BBFTP_DIR" ]; then
+        export PATH="$PATH:$BBFTP_DIR/bin"
+fi
+#ADIC
+ADIC_DIR="$ISSM_DIR/externalpackages/adic/install"
+if [ -d "$ADIC_DIR" ]; then
+        export PATH="$PATH:$ADIC_DIR/bin"
+        export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$ADIC_DIR/lib"
+        export LD_RUN_PATH="$LD_RUN_PATH:$ADIC_DIR/lib"
+fi
+#COLPACK
+COLPACK_DIR="$ISSM_DIR/externalpackages/colpack/install"
+if [ -d "$COLPACK_DIR" ]; then
+        export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$COLPACK_DIR/lib"
+        export LD_RUN_PATH="$LD_RUN_PATH:$COLPACK_DIR/lib"
+fi
+#ECLIPSE
+ECLIPSE_DIR="$ISSM_DIR/externalpackages/eclipse/install"
+if [ -d "$ECLIPSE_DIR" ]; then
+        export PATH="$PATH:$ECLIPSE_DIR"
+fi
+#APPSCAN
+APPSCAN_DIR="$ISSM_DIR/externalpackages/appscan/install"
+if [ -d "$APPSCAN_DIR" ]; then
+        export PATH="$PATH:$APPSCAN_DIR/bin"
+fi
+#RATS
+RATS_DIR="$ISSM_DIR/externalpackages/rats/install"
+if [ -d "$RATS_DIR" ]; then
+        export PATH="$PATH:$RATS_DIR/bin"
+fi
+#DYSON
+DYSON_DIR="$ISSM_DIR/externalpackages/dyson/"
+if [ -d "$DYSON_DIR" ]; then
+        export PATH="$PATH:$DYSON_DIR"
+fi
+#CMAKE
+CMAKE_DIR="$ISSM_DIR/externalpackages/cmake/install"
+if [ -d "$CMAKE_DIR" ]; then
+        export PATH="$PATH:$CMAKE_DIR/bin"
+fi
+#SHAPELIB
+SHAPELIB_DIR="$ISSM_DIR/externalpackages/shapelib/install"
+if [ -d "$SHAPELIB_DIR" ]; then
+        export PATH="$PATH:$SHAPELIB_DIR/exec"
+fi
+#CCCL
+CCCL_DIR="$ISSM_DIR/externalpackages/cccl/install"
+if [ -d "$CCCL_DIR" ]; then
+        export PATH="$PATH:$CCCL_DIR/bin"
+fi
+#PACKAGEMAKER
+PACKAGEMAKER_DIR="$ISSM_DIR/externalpackages/packagemaker/install"
+if [ -d "$PACKAGEMAKER_DIR" ]; then
+        export PATH="$PATH:$PACKAGEMAKER_DIR"
+fi
+#ANDROID_NDK:
+ANDROID_NDK_DIR="$ISSM_DIR/externalpackages/android-ndk/install"
+if [ -d "$ANDROID_NDK_DIR" ]; then
+        export PATH="$PATH:$ANDROID_NDK_DIR/"
+fi
+#ANDROID_SDK
+ANDROID_SDK_DIR="$ANDROID_DIR/android-sdk/install-sdk"
+if [ -d "$ANDROID_SDK_DIR" ]; then
+        export PATH="$PATH:$ANDROID_SDK_DIR/"
+fi
+#GSL
+GSL_DIR="$ISSM_DIR/externalpackages/gsl/install"
+if [ -d "$GSL_DIR" ]; then
+        export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$GSL_DIR/lib"
+        export LD_RUN_PATH="$LD_RUN_PATH:$GSL_DIR/lib"
+fi
+#GMAKE
+GMAKE_DIR="$ISSM_DIR/externalpackages/gmake/install"
+if [ -d "$GMAKE_DIR" ]; then
+        export PATH="$GMAKE_DIR/bin:$PATH"
+fi
+#PYTHON
+PYTHON_DIR="$ISSM_DIR/externalpackages/python/install"
+if [ -d "$PYTHON_DIR" ]; then
+        PYTHONSTARTUP="$ISSM_DIR/startup.py"
+        export PATH="$PYTHON_DIR/bin:$PATH"
+        export PYTHONPATH="$PYTHONPATH:$ISSM_DIR/src/modules/python"
+        export LD_LIBRARY_PATH=$ISSM_DIR/src/modules/python:$ISSM_DIR/externalpackages/python/install/lib:$LD_LIBRARY_PATH
+        export PYTHONSTARTUP="$ISSM_DIR/startup.py"
+fi
+#MODELE
+MODELE_DIR="$ISSM_DIR/externalpackages/modelE/install"
+if [ -d "$MODELE_DIR" ]; then
+        export PATH="$MODELE_DIR/src/exec:$PATH"
+fi
+#GIT
+GIT_DIR="$ISSM_DIR/externalpackages/git/install"
+if [ -d "$GIT_DIR" ]; then
+        export PATH="$PATH:$GIT_DIR/bin"
+fi
+#NCVIEW
+NCVIEW_DIR="$ISSM_DIR/externalpackages/ncview/install"
+if [ -d "$NCVIEW_DIR" ]; then
+        export PATH="$PATH:$NCVIEW_DIR"
+fi
+#TCLX
+TCLX_DIR="$ISSM_DIR/externalpackages/tclx/install/lib/tclx8.4"
+if [ -d "$TCLX_DIR" ]; then
+        export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$TCLX_DIR"
+        export LD_RUN_PATH="$LD_RUN_PATH:$TCLX_DIR"
+fi
 #ASPELL
+export PATH="$ASPELL_DIR/install/bin:$PATH"
+ASPELL_DIR="$ISSM_DIR/externalpackages/aspell/install"
+if [ -d "$ASPELL_DIR" ]; then
+        export PATH="$ASPELL_DIR/bin:$PATH"
+fi
 #ESMF
+export ESMF_DIR=$ISSM_DIR/externalpackages/esmf/esmf
+export ESMF_COMPILER=gfortran
+export ESMF_COMM=mpich2
+ESMF_DIR="$ISSM_DIR/externalpackages/esmf/esmf"
+if [ -d "$ESMF_DIR" ]; then
+        export ESMF_COMPILER=gfortran
+        export ESMF_COMM=mpich2
+fi
 #HDF5
+export DYLD_LIBRARY_PATH="$DYLD_LIBRARY_PATH:$HDF5_DIR/lib"
+export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$HDF5_DIR/lib"
+export LIBRARY_PATH="$LIBRARY_PATH:$HDF5_DIR/lib"
+export C_INCLUDE_PATH="$C_INCLUDE_PATH:$HDF5_DIR/include"
+HDF5_DIR="$ISSM_DIR/externalpackages/hdf5/install"
+if [ -d "$HDF5_DIR" ]; then
+        export DYLD_LIBRARY_PATH="$DYLD_LIBRARY_PATH:$HDF5_DIR/lib"
+        export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$HDF5_DIR/lib"
+        export LIBRARY_PATH="$LIBRARY_PATH:$HDF5_DIR/lib"
+        export C_INCLUDE_PATH="$C_INCLUDE_PATH:$HDF5_DIR/include"
+fi
+#SVN
+SVN_DIR="$ISSM_DIR/externalpackages/svn/install"
+if [ -d "$SVN_DIR" ]; then
+        export PATH="$SVN_DIR/bin:$PATH"
+        export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$SVN_DIR/lib"
+        export LIBRARY_PATH="$LIBRARY_PATH:$SVN_DIR/lib"
+fi
+#APR
+APR_DIR="$ISSM_DIR/externalpackages/apr/install"
+if [ -d "$APR_DIR" ]; then
+        export PATH="$APR_DIR/bin:$PATH"
+        export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$APR_DIR/lib"
+        export LIBRARY_PATH="$LIBRARY_PATH:$APR_DIR/lib"
+fi
+#APR_UTIL
+APR_UTIL_DIR="$ISSM_DIR/externalpackages/apr-util/install"
+if [ -d "$APR_UTIL_DIR" ]; then
+        export PATH="$APR_UTIL_DIR/bin:$PATH"
+        export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$APR_UTIL_DIR/lib"
+        export LIBRARY_PATH="$LIBRARY_PATH:$APR_UTIL_DIR/lib"
+fi
+#SQLITE
+SQLITE_DIR="$ISSM_DIR/externalpackages/sqlite/install"
+if [ -d "$SQLITE_DIR" ]; then
+        export PATH="$SQLITE_DIR/bin:$PATH"
+        export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$SQLITE_DIR/lib"
+        export LIBRARY_PATH="$LIBRARY_PATH:$SQLITE_DIR/lib"
+fi

issm/branches/trunk-jpl-damage/externalpackages

Property svn:ignore

old	new
	1	archive
1	2	MITgcm
2	3	OpenAD

issm/branches/trunk-jpl-damage/externalpackages/adolc

Property svn:ignore

-              old
+              new
+trunk
 *.gz
 install*
 src
+src-*
 configure.sh
 .ignore.txt

issm/branches/trunk-jpl-damage/externalpackages/adolc/install.sh

-              r12878
+              r13101
 #Some cleanup
+rm -rf install ADOL-C-2.2.0 src
+rm -rf install ADOL-C-2.2.0 src trunk
+#Create install directories
+mkdir install src
 #Download from ISSM server
 $ISSM_DIR/scripts/DownloadExternalPackage.py 'http://issm.jpl.nasa.gov/files/externalpackages/ADOL-C-2.2.0.tar.gz' 'ADOL-C-2.2.0.tar.gz'
-#Create install directories
-mkdir install src
 #Untar
 …
 rm -rf ADOL-C-2.2.0
 #Compile ADOL-C
 cd src
 export CC=gcc
 export CXX=g++
 export CFLAGS="-arch x86_64"
 export CXXFLAGS="-arch x86_64"
+#export CC=gcc
+#export CXX=g++
+#export CFLAGS="-arch x86_64"
+#export CXXFLAGS="-arch x86_64"
 ./configure \
 …
 fi
 make install
+#Ok, bug with libtool: replace all LIBTOOL= by LIBTOOL=libtool
+#in all Makefiles
+for i in `find ./ -name Makefile `
+do
+        echo $i
+        cat $i | sed 's/LIBTOOL =/LIBTOOL = libtool/g' > $i.bak
+        mv $i.bak $i
+done
+#remake:
+if [ -z $1 ]; then
+        make
+else
+        make -j $1
+fi
+make install

issm/branches/trunk-jpl-damage/externalpackages/distribute

Property svn:ignore

old	new
	1	*.gz
1	2	distribute_setup.py

issm/branches/trunk-jpl-damage/externalpackages/matlab/install.sh

r12878	r13101
5	5
6	6	#Select or create a new simlink
7		ln -s /usr/local/pkgs/matlab-7.6/ install
	7	#ln -s /usr/local/pkgs/matlab-7.6/ install
8	8	#ln -s /discover/vis/mathworks/matlab_r2011b/ install
9	9	#ln -s /usr/local/matlab704/ install

issm/branches/trunk-jpl-damage/externalpackages/readline

Property svn:ignore

old	new
	1	*.gz
1	2	src
2	3	src-*

issm/branches/trunk-jpl-damage/externalpackages/swig

Property svn:ignore set to
install
*.gz

issm/branches/trunk-jpl-damage/externalpackages/swig/install.sh

-              r12258
+              r13101
 export LDFLAGS="-L$ISSM_DIR/externalpackages/pcre/install/.libs/"
 export LIBS="-lpcre"
 #Configure doxygen
+#Configure swig
 ./configure \
  --prefix="$ISSM_DIR/externalpackages/python/install" \
+ --prefix="$ISSM_DIR/externalpackages/swig/install" \
  --with-pcre-prefix="$ISSM_DIR/externalpackages/pcre/install" \
+ --with-pcre-exec-prefix="$ISSM_DIR/externalpackages/pcre/install"
+make
+ --with-pcre-exec-prefix="$ISSM_DIR/externalpackages/pcre/install" \
+ --with-python="$ISSM_DIR/externalpackages/python/install/bin/python"
+#Compile and install gdal
+if [ -z $1 ]; then
+        make
+else
+        make -j $1
+fi
 make install

issm/branches/trunk-jpl-damage/externalpackages/valgrind

Property svn:ignore

old	new
3	3	src
4	4	.ignore.txt
	5	*.bz2

issm/branches/trunk-jpl-damage/externalpackages/vim/addons/vim/syntax/Synchronize.sh

-              r12946
+              r13101
 cat c.vim | sed "/ISSM's Enums begin/,/vim: ts=8/d" > temp
 echo "\"ISSM's Enums begin" >> temp
 cat ../../../../../src/c/EnumDefinitions/EnumDefinitions.h | grep -e "[0-9]Enum," -e "[aA-zZ]Enum," | grep -v StringToEnum | sed -e "s/,//g" | awk '{ printf "syn keyword cConstant " $1 "\n"}' >> temp
+cat ../../../../../src/c/EnumDefinitions/EnumDefinitions.h | grep -e "[0-9]Enum," -e "[a-z]Enum," -e "[A-Z]Enum," | grep -v StringToEnum | sed -e "s/,//g" | awk '{ printf "syn keyword cConstant " $1 "\n"}' >> temp
 echo "\"ISSM's Enums end" >> temp
 cat c.vim | sed "1,/ISSM's Enums end/d" >> temp
 mv temp c.vim
+exit 1
 #Synchronize objects
 …
 echo "\"ISSM's objects begin" >> temp
 find ../../../../../src/c/classes -name "*.h" | sed -e "s/\// /g" -e "s/\.h//"| awk '{print  $(NF)}' | awk '{ printf "syn keyword cType " $1 "\n"}'>> temp
+echo "\"ISSM's objects end" >> temp
 cat c.vim | sed "1,/ISSM's objects end/d" >> temp

issm/branches/trunk-jpl-damage/externalpackages/vim/addons/vim/syntax/c.vim

-              r12946
+              r13101
 syn keyword     cType           Vec Mat SeqVec SeqMat
 "other ISSM's syntax
 syn keyword     cType           mxArray ErrorException QuadtreeBox IssmDouble IssmPDouble
+syn keyword     cType           mxArray ErrorException QuadtreeBox IssmDouble IssmPDouble Observations
 "ISSM's objects begin
+syn keyword cType AdjacentTriangle
+syn keyword cType BamgGeom
+syn keyword cType BamgMesh
+syn keyword cType bamgobjects
+syn keyword cType BamgOpts
+syn keyword cType BamgQuadtree
+syn keyword cType BamgVertex
+syn keyword cType CrackedEdge
+syn keyword cType Curve
+syn keyword cType Direction
+syn keyword cType DoubleAndInt
+syn keyword cType Edge
+syn keyword cType GeomEdge
+syn keyword cType Geometry
+syn keyword cType GeomSubDomain
+syn keyword cType GeomVertex
+syn keyword cType include
+syn keyword cType ListofIntersectionTriangles
+syn keyword cType macros
+syn keyword cType Mesh
+syn keyword cType Metric
+syn keyword cType R2
+syn keyword cType SetOfE4
+syn keyword cType SubDomain
+syn keyword cType Triangle
+syn keyword cType typedefs
+syn keyword cType VertexOnEdge
+syn keyword cType VertexOnGeom
+syn keyword cType VertexOnVertex
+syn keyword cType classes
+syn keyword cType DakotaPlugin
+syn keyword cType DofIndexing
+syn keyword cType FemModel
+syn keyword cType GaussPenta
 syn keyword cType gaussobjects
-syn keyword cType GaussPenta
 syn keyword cType GaussTria
+syn keyword cType Hook
+syn keyword cType IoModel
+syn keyword cType ExponentialVariogram
+syn keyword cType GaussianVariogram
+syn keyword cType krigingobjects
+syn keyword cType Observation
+syn keyword cType PowerVariogram
+syn keyword cType Quadtree
+syn keyword cType SphericalVariogram
+syn keyword cType Variogram
+syn keyword cType ElementMatrix
+syn keyword cType ElementVector
+syn keyword cType Matrix
+syn keyword cType matrixobjects
+syn keyword cType Vector
+syn keyword cType Constraint
+syn keyword cType objects
+syn keyword cType Material
+syn keyword cType Matice
+syn keyword cType Matpar
+syn keyword cType objects
+syn keyword cType Contour
+syn keyword cType DoubleInput
+syn keyword cType Input
+syn keyword cType ControlInput
+syn keyword cType DatasetInput
+syn keyword cType IntInput
+syn keyword cType BoolInput
+syn keyword cType TriaP1Input
+syn keyword cType TransientInput
+syn keyword cType PentaP1Input
+syn keyword cType KML_Icon
+syn keyword cType KML_Point
+syn keyword cType KML_LinearRing
+syn keyword cType KML_Feature
+syn keyword cType KMLFileReadUtils
+syn keyword cType KML_StyleSelector
+syn keyword cType KML_LatLonBox
+syn keyword cType KML_Attribute
+syn keyword cType KML_PolyStyle
+syn keyword cType KML_Object
+syn keyword cType KML_SubStyle
+syn keyword cType KML_LineString
+syn keyword cType KML_Overlay
+syn keyword cType KML_Container
+syn keyword cType KML_Polygon
+syn keyword cType KML_Geometry
+syn keyword cType KML_ColorStyle
+syn keyword cType KML_Placemark
+syn keyword cType KML_Unknown
+syn keyword cType KML_GroundOverlay
+syn keyword cType KML_Style
+syn keyword cType KML_Comment
+syn keyword cType KML_MultiGeometry
+syn keyword cType KML_LineStyle
+syn keyword cType KML_Folder
+syn keyword cType KML_Document
+syn keyword cType KML_File
+syn keyword cType DoubleVecParam
+syn keyword cType DoubleParam
+syn keyword cType DoubleMatArrayParam
+syn keyword cType DoubleMatParam
+syn keyword cType Param
+syn keyword cType FileParam
+syn keyword cType IntVecParam
+syn keyword cType IntParam
+syn keyword cType BoolParam
+syn keyword cType IntMatParam
+syn keyword cType VectorParam
+syn keyword cType DoubleTransientMatParam
+syn keyword cType MatrixParam
+syn keyword cType StringArrayParam
+syn keyword cType StringParam
+syn keyword cType TransientParam
+syn keyword cType OptionStruct
+syn keyword cType OptionDouble
+syn keyword cType OptionLogical
+syn keyword cType OptionUtilities
+syn keyword cType OptionChar
+syn keyword cType Option
+syn keyword cType OptionCell
+syn keyword cType Segment
+syn keyword cType Icefront
+syn keyword cType Friction
+syn keyword cType Riftfront
+syn keyword cType Numericalflux
+syn keyword cType Penpair
+syn keyword cType Load
+syn keyword cType Pengrid
+syn keyword cType Object
+syn keyword cType DoubleVecExternalResult
+syn keyword cType DoubleExternalResult
+syn keyword cType IntExternalResult
+syn keyword cType BoolExternalResult
+syn keyword cType DoubleMatExternalResult
+syn keyword cType PetscVecExternalResult
+syn keyword cType ExternalResult
+syn keyword cType StringExternalResult
+syn keyword cType Vertex
 syn keyword cType SpcDynamic
 syn keyword cType SpcStatic
 syn keyword cType SpcTransient
+syn keyword cType Contour
+syn keyword cType Constraint
+syn keyword cType TriaP1ElementResult
+syn keyword cType PentaP1ElementResult
+syn keyword cType DoubleElementResult
+syn keyword cType ElementResultLocal
 syn keyword cType BoolElementResult
-syn keyword cType DoubleElementResult
 syn keyword cType ElementResult
+syn keyword cType ElementResultLocal
+syn keyword cType PentaP1ElementResult
+syn keyword cType TriaP1ElementResult
+syn keyword cType Node
+syn keyword cType TriaRef
+syn keyword cType TriaHook
+syn keyword cType PentaRef
+syn keyword cType PentaHook
+syn keyword cType Tria
 syn keyword cType Element
 syn keyword cType Penta
+syn keyword cType PentaHook
+syn keyword cType PentaRef
+syn keyword cType Tria
+syn keyword cType TriaHook
+syn keyword cType TriaRef
+syn keyword cType BoolExternalResult
+syn keyword cType DoubleExternalResult
+syn keyword cType DoubleMatExternalResult
+syn keyword cType DoubleVecExternalResult
+syn keyword cType ExternalResult
+syn keyword cType IntExternalResult
+syn keyword cType PetscVecExternalResult
+syn keyword cType StringExternalResult
+syn keyword cType BoolInput
+syn keyword cType ControlInput
+syn keyword cType DatasetInput
+syn keyword cType DoubleInput
+syn keyword cType Input
+syn keyword cType IntInput
+syn keyword cType PentaP1Input
+syn keyword cType TransientInput
+syn keyword cType TriaP1Input
+syn keyword cType KML_Attribute
+syn keyword cType KML_ColorStyle
+syn keyword cType KML_Comment
+syn keyword cType KML_Container
+syn keyword cType KML_Document
+syn keyword cType KML_Feature
+syn keyword cType KML_File
+syn keyword cType KML_Folder
+syn keyword cType KML_Geometry
+syn keyword cType KML_GroundOverlay
+syn keyword cType KML_Icon
+syn keyword cType KML_LatLonBox
+syn keyword cType KML_LinearRing
+syn keyword cType KML_LineString
+syn keyword cType KML_LineStyle
+syn keyword cType KML_MultiGeometry
+syn keyword cType KML_Object
+syn keyword cType KML_Overlay
+syn keyword cType KML_Placemark
+syn keyword cType KML_Point
+syn keyword cType KML_Polygon
+syn keyword cType KML_PolyStyle
+syn keyword cType KML_Style
+syn keyword cType KML_StyleSelector
+syn keyword cType KML_SubStyle
+syn keyword cType KML_Unknown
+syn keyword cType KMLFileReadUtils
+syn keyword cType Friction
+syn keyword cType Icefront
+syn keyword cType Load
+syn keyword cType Numericalflux
+syn keyword cType Pengrid
+syn keyword cType Penpair
+syn keyword cType Riftfront
+syn keyword cType Material
+syn keyword cType Matice
+syn keyword cType Matpar
+syn keyword cType Node
+syn keyword cType Object
+syn keyword cType objects
+syn keyword cType Option
+syn keyword cType OptionCell
+syn keyword cType OptionChar
+syn keyword cType OptionDouble
+syn keyword cType OptionLogical
+syn keyword cType OptionStruct
+syn keyword cType OptionUtilities
+syn keyword cType BoolParam
+syn keyword cType DoubleMatArrayParam
+syn keyword cType DoubleMatParam
+syn keyword cType DoubleParam
+syn keyword cType DoubleTransientMatParam
+syn keyword cType DoubleVecParam
+syn keyword cType FileParam
+syn keyword cType IntMatParam
+syn keyword cType IntParam
+syn keyword cType IntVecParam
+syn keyword cType MatrixParam
+syn keyword cType Param
+syn keyword cType StringArrayParam
+syn keyword cType StringParam
+syn keyword cType TransientParam
+syn keyword cType VectorParam
+syn keyword cType Segment
+syn keyword cType Vertex
+syn keyword cType objects
+syn keyword cType classes
+syn keyword cType DofIndexing
+syn keyword cType Patch
+syn keyword cType Hook
+syn keyword cType Quadtree
+syn keyword cType Observation
+syn keyword cType ExponentialVariogram
+syn keyword cType GaussianVariogram
+syn keyword cType SphericalVariogram
+syn keyword cType PowerVariogram
+syn keyword cType krigingobjects
+syn keyword cType Variogram
+syn keyword cType DakotaPlugin
+syn keyword cType ElementVector
+syn keyword cType ElementMatrix
+syn keyword cType matrixobjects
+syn keyword cType Vector
+syn keyword cType Matrix
+syn keyword cType GeomSubDomain
+syn keyword cType Geometry
+syn keyword cType AdjacentTriangle
+syn keyword cType VertexOnEdge
+syn keyword cType BamgQuadtree
+syn keyword cType Edge
+syn keyword cType BamgVertex
+syn keyword cType SetOfE4
+syn keyword cType GeomEdge
+syn keyword cType Direction
+syn keyword cType VertexOnGeom
+syn keyword cType R2
+syn keyword cType Mesh
+syn keyword cType ListofIntersectionTriangles
+syn keyword cType Triangle
+syn keyword cType DoubleAndInt
+syn keyword cType VertexOnVertex
+syn keyword cType BamgOpts
+syn keyword cType BamgGeom
+syn keyword cType bamgobjects
+syn keyword cType CrackedEdge
+syn keyword cType SubDomain
+syn keyword cType BamgMesh
+syn keyword cType Metric
+syn keyword cType include
+syn keyword cType typedefs
+syn keyword cType Curve
+syn keyword cType macros
+syn keyword cType GeomVertex
 syn keyword cType OptArgs
+syn keyword cType Update
 syn keyword cType OptPars
 syn keyword cType BamgOpts

issm/branches/trunk-jpl-damage/externalpackages/vim/addons/vimrc

r10985	r13101
203	203	au BufRead,BufNewFile .c iabbr <silent> p1 printf("\n");<Left><Left><Left><Left><Left><C-R>=Eatchar('\s')<CR>
204	204	au BufRead,BufNewFile .c,*.h iabbr <silent> ER _error_("");<Left><Left><Left><C-R>=Eatchar('\s')<CR>
	205	au BufRead,BufNewFile *.py iabbr <silent> ER raise NameError('')<Left><Left><C-R>=Eatchar('\s')<CR>
	206	au BufRead,BufNewFile *.m iabbr <silent> ER error('');<Left><Left><Left><C-R>=Eatchar('\s')<CR>
205	207	au BufRead,BufNewFile .c ab VV VecView(ug,PETSC_VIEWER_STDOUT_WORLD);
206	208	au BufRead,BufNewFile .c ab AS _assert_();

issm/branches/trunk-jpl-damage/ltmain.sh

-              r11116
+              r13101
+# Generated from ltmain.m4sh.
+# ltmain.sh (GNU libtool) 2.2.6b
+# libtool (GNU libtool) 2.4.2
 # Written by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
+# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006, 2007 2008 Free Software Foundation, Inc.
+# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006,
+# 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
 # This is free software; see the source for copying conditions.  There is NO
 # warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 …
 # Provide generalized library-building support services.
+#
+#     --config             show all configuration variables
+#     --debug              enable verbose shell tracing
+# -n, --dry-run            display commands without modifying any files
+#     --features           display basic configuration information and exit
+#     --mode=MODE          use operation mode MODE
+#     --preserve-dup-deps  don't remove duplicate dependency libraries
+#     --quiet, --silent    don't print informational messages
+#     --tag=TAG            use configuration variables from tag TAG
+# -v, --verbose            print informational messages (default)
+#     --version            print version information
+# -h, --help               print short or long help message
+#       --config             show all configuration variables
+#       --debug              enable verbose shell tracing
+#   -n, --dry-run            display commands without modifying any files
+#       --features           display basic configuration information and exit
+#       --mode=MODE          use operation mode MODE
+#       --preserve-dup-deps  don't remove duplicate dependency libraries
+#       --quiet, --silent    don't print informational messages
+#       --no-quiet, --no-silent
+#                            print informational messages (default)
+#       --no-warn            don't display warning messages
+#       --tag=TAG            use configuration variables from tag TAG
+#   -v, --verbose            print more informational messages than default
+#       --no-verbose         don't print the extra informational messages
+#       --version            print version information
+#   -h, --help, --help-all   print short, long, or detailed help message
+#
 # MODE must be one of the following:
+#
 #       clean              remove files from the build directory
 #       compile            compile a source file into a libtool object
 #       execute            automatically set library path, then run a program
 #       finish             complete the installation of libtool libraries
 #       install            install libraries or executables
 #       link               create a library or an executable
 #       uninstall          remove libraries from an installed directory
+#         clean              remove files from the build directory
+#         compile            compile a source file into a libtool object
+#         execute            automatically set library path, then run a program
+#         finish             complete the installation of libtool libraries
+#         install            install libraries or executables
+#         link               create a library or an executable
+#         uninstall          remove libraries from an installed directory
+#
+# MODE-ARGS vary depending on the MODE.
+# MODE-ARGS vary depending on the MODE.  When passed as first option,
+# `--mode=MODE' may be abbreviated as `MODE' or a unique abbreviation of that.
 # Try `$progname --help --mode=MODE' for a more detailed description of MODE.
+#
 …
 # include the following information:
+#
 #       host-triplet:   $host
 #       shell:          $SHELL
 #       compiler:               $LTCC
 #       compiler flags:         $LTCFLAGS
 #       linker:         $LD (gnu? $with_gnu_ld)
 #       $progname:              (GNU libtool) 2.2.6b
 #       automake:               $automake_version
 #       autoconf:               $autoconf_version
+#         host-triplet: $host
+#         shell:                $SHELL
+#         compiler:             $LTCC
+#         compiler flags:               $LTCFLAGS
+#         linker:               $LD (gnu? $with_gnu_ld)
+#         $progname:    (GNU libtool) 2.4.2
+#         automake:     $automake_version
+#         autoconf:     $autoconf_version
+#
 # Report bugs to <bug-libtool@gnu.org>.
+PROGRAM=ltmain.sh
+# GNU libtool home page: <http://www.gnu.org/software/libtool/>.
+# General help using GNU software: <http://www.gnu.org/gethelp/>.
+PROGRAM=libtool
 PACKAGE=libtool
 VERSION=2.2.6b
+VERSION=2.4.2
 TIMESTAMP=""
 package_revision=1.3017
+package_revision=1.3337
 # Be Bourne compatible
 …
 DUALCASE=1; export DUALCASE # for MKS sh
+# A function that is used when there is no print builtin or printf.
+func_fallback_echo ()
+{
+  eval 'cat <<_LTECHO_EOF
+$1
+_LTECHO_EOF'
+}
 # NLS nuisances: We save the old values to restore during execute mode.
-# Only set LANG and LC_ALL to C if already set.
-# These must not be set unconditionally because not all systems understand
-# e.g. LANG=C (notably SCO).
 lt_user_locale=
 lt_safe_locale=
 …
         fi"
 done
+LC_ALL=C
+LANGUAGE=C
+export LANGUAGE LC_ALL
 $lt_unset CDPATH
+# Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
+# is ksh but when the shell is invoked as "sh" and the current value of
+# the _XPG environment variable is not equal to 1 (one), the special
+# positional parameter $0, within a function call, is the name of the
+# function.
+progpath="$0"
 : ${CP="cp -f"}
+: ${ECHO="echo"}
+: ${EGREP="/bin/grep -E"}
+: ${FGREP="/bin/grep -F"}
+: ${GREP="/bin/grep"}
+: ${LN_S="ln -s"}
+test "${ECHO+set}" = set || ECHO=${as_echo-'printf %s\n'}
 : ${MAKE="make"}
 : ${MKDIR="mkdir"}
 : ${MV="mv -f"}
 : ${RM="rm -f"}
-: ${SED="/bin/sed"}
 : ${SHELL="${CONFIG_SHELL-/bin/sh}"}
 : ${Xsed="$SED -e 1s/^X//"}
 …
 dirname="s,/[^/]*$,,"
 basename="s,^.*/,,"
+# func_dirname file append nondir_replacement
+# Compute the dirname of FILE.  If nonempty, add APPEND to the result,
+# otherwise set result to NONDIR_REPLACEMENT.
+func_dirname ()
+{
+    func_dirname_result=`$ECHO "${1}" | $SED "$dirname"`
+    if test "X$func_dirname_result" = "X${1}"; then
+      func_dirname_result="${3}"
+    else
+      func_dirname_result="$func_dirname_result${2}"
+    fi
+} # func_dirname may be replaced by extended shell implementation
+# func_basename file
+func_basename ()
+{
+    func_basename_result=`$ECHO "${1}" | $SED "$basename"`
+} # func_basename may be replaced by extended shell implementation
 # func_dirname_and_basename file append nondir_replacement
 …
 func_dirname_and_basename ()
+{
+  # Extract subdirectory from the argument.
+  func_dirname_result=`$ECHO "X${1}" | $Xsed -e "$dirname"`
+  if test "X$func_dirname_result" = "X${1}"; then
+    func_dirname_result="${3}"
+  else
+    func_dirname_result="$func_dirname_result${2}"
+    # Extract subdirectory from the argument.
+    func_dirname_result=`$ECHO "${1}" | $SED -e "$dirname"`
+    if test "X$func_dirname_result" = "X${1}"; then
+      func_dirname_result="${3}"
+    else
+      func_dirname_result="$func_dirname_result${2}"
+    fi
+    func_basename_result=`$ECHO "${1}" | $SED -e "$basename"`
+} # func_dirname_and_basename may be replaced by extended shell implementation
+# func_stripname prefix suffix name
+# strip PREFIX and SUFFIX off of NAME.
+# PREFIX and SUFFIX must not contain globbing or regex special
+# characters, hashes, percent signs, but SUFFIX may contain a leading
+# dot (in which case that matches only a dot).
+# func_strip_suffix prefix name
+func_stripname ()
+{
+    case ${2} in
+      .*) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%\\\\${2}\$%%"`;;
+      *)  func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%${2}\$%%"`;;
+    esac
+} # func_stripname may be replaced by extended shell implementation
+# These SED scripts presuppose an absolute path with a trailing slash.
+pathcar='s,^/\([^/]*\).*$,\1,'
+pathcdr='s,^/[^/]*,,'
+removedotparts=':dotsl
+                s@/\./@/@g
+                t dotsl
+                s,/\.$,/,'
+collapseslashes='s@/\{1,\}@/@g'
+finalslash='s,/*$,/,'
+# func_normal_abspath PATH
+# Remove doubled-up and trailing slashes, "." path components,
+# and cancel out any ".." path components in PATH after making
+# it an absolute path.
+#             value returned in "$func_normal_abspath_result"
+func_normal_abspath ()
+{
+  # Start from root dir and reassemble the path.
+  func_normal_abspath_result=
+  func_normal_abspath_tpath=$1
+  func_normal_abspath_altnamespace=
+  case $func_normal_abspath_tpath in
+    "")
+      # Empty path, that just means $cwd.
+      func_stripname '' '/' "`pwd`"
+      func_normal_abspath_result=$func_stripname_result
+      return
+    ;;
+    # The next three entries are used to spot a run of precisely
+    # two leading slashes without using negated character classes;
+    # we take advantage of case's first-match behaviour.
+    ///*)
+      # Unusual form of absolute path, do nothing.
+    ;;
+    //*)
+      # Not necessarily an ordinary path; POSIX reserves leading '//'
+      # and for example Cygwin uses it to access remote file shares
+      # over CIFS/SMB, so we conserve a leading double slash if found.
+      func_normal_abspath_altnamespace=/
+    ;;
+    /*)
+      # Absolute path, do nothing.
+    ;;
+    *)
+      # Relative path, prepend $cwd.
+      func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath
+    ;;
+  esac
+  # Cancel out all the simple stuff to save iterations.  We also want
+  # the path to end with a slash for ease of parsing, so make sure
+  # there is one (and only one) here.
+  func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
+        -e "$removedotparts" -e "$collapseslashes" -e "$finalslash"`
+  while :; do
+    # Processed it all yet?
+    if test "$func_normal_abspath_tpath" = / ; then
+      # If we ascended to the root using ".." the result may be empty now.
+      if test -z "$func_normal_abspath_result" ; then
+        func_normal_abspath_result=/
+      fi
+      break
+    fi
+    func_normal_abspath_tcomponent=`$ECHO "$func_normal_abspath_tpath" | $SED \
+        -e "$pathcar"`
+    func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
+        -e "$pathcdr"`
+    # Figure out what to do with it
+    case $func_normal_abspath_tcomponent in
+      "")
+        # Trailing empty path component, ignore it.
+      ;;
+      ..)
+        # Parent dir; strip last assembled component from result.
+        func_dirname "$func_normal_abspath_result"
+        func_normal_abspath_result=$func_dirname_result
+      ;;
+      *)
+        # Actual path component, append it.
+        func_normal_abspath_result=$func_normal_abspath_result/$func_normal_abspath_tcomponent
+      ;;
+    esac
+  done
+  # Restore leading double-slash if one was found on entry.
+  func_normal_abspath_result=$func_normal_abspath_altnamespace$func_normal_abspath_result
+}
+# func_relative_path SRCDIR DSTDIR
+# generates a relative path from SRCDIR to DSTDIR, with a trailing
+# slash if non-empty, suitable for immediately appending a filename
+# without needing to append a separator.
+#             value returned in "$func_relative_path_result"
+func_relative_path ()
+{
+  func_relative_path_result=
+  func_normal_abspath "$1"
+  func_relative_path_tlibdir=$func_normal_abspath_result
+  func_normal_abspath "$2"
+  func_relative_path_tbindir=$func_normal_abspath_result
+  # Ascend the tree starting from libdir
+  while :; do
+    # check if we have found a prefix of bindir
+    case $func_relative_path_tbindir in
+      $func_relative_path_tlibdir)
+        # found an exact match
+        func_relative_path_tcancelled=
+        break
+        ;;
+      $func_relative_path_tlibdir*)
+        # found a matching prefix
+        func_stripname "$func_relative_path_tlibdir" '' "$func_relative_path_tbindir"
+        func_relative_path_tcancelled=$func_stripname_result
+        if test -z "$func_relative_path_result"; then
+          func_relative_path_result=.
+        fi
+        break
+        ;;
+      *)
+        func_dirname $func_relative_path_tlibdir
+        func_relative_path_tlibdir=${func_dirname_result}
+        if test "x$func_relative_path_tlibdir" = x ; then
+          # Have to descend all the way to the root!
+          func_relative_path_result=../$func_relative_path_result
+          func_relative_path_tcancelled=$func_relative_path_tbindir
+          break
+        fi
+        func_relative_path_result=../$func_relative_path_result
+        ;;
+    esac
+  done
+  # Now calculate path; take care to avoid doubling-up slashes.
+  func_stripname '' '/' "$func_relative_path_result"
+  func_relative_path_result=$func_stripname_result
+  func_stripname '/' '/' "$func_relative_path_tcancelled"
+  if test "x$func_stripname_result" != x ; then
+    func_relative_path_result=${func_relative_path_result}/${func_stripname_result}
   fi
+  func_basename_result=`$ECHO "X${1}" | $Xsed -e "$basename"`
+}
+# Generated shell functions inserted here.
+# Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
+# is ksh but when the shell is invoked as "sh" and the current value of
+# the _XPG environment variable is not equal to 1 (one), the special
+# positional parameter $0, within a function call, is the name of the
+# function.
+progpath="$0"
+  # Normalisation. If bindir is libdir, return empty string,
+  # else relative path ending with a slash; either way, target
+  # file name can be directly appended.
+  if test ! -z "$func_relative_path_result"; then
+    func_stripname './' '' "$func_relative_path_result/"
+    func_relative_path_result=$func_stripname_result
+  fi
+}
 # The name of this program:
-# In the unlikely event $progname began with a '-', it would play havoc with
-# func_echo (imagine progname=-n), so we prepend ./ in that case:
 func_dirname_and_basename "$progpath"
 progname=$func_basename_result
-case $progname in
-  -*) progname=./$progname ;;
-esac
 # Make sure we have an absolute path for reexecution:
 …
   *)
      save_IFS="$IFS"
      IFS=:
+     IFS=${PATH_SEPARATOR-:}
      for progdir in $PATH; do
        IFS="$save_IFS"
 …
 # Same as above, but do not quote variable references.
 double_quote_subst='s/\(["`\\]\)/\\\1/g'
+# Sed substitution that turns a string into a regex matching for the
+# string literally.
+sed_make_literal_regex='s,[].[^$\\*\/],\\&,g'
+# Sed substitution that converts a w32 file name or path
+# which contains forward slashes, into one that contains
+# (escaped) backslashes.  A very naive implementation.
+lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
 # Re-`\' parameter expansions in output of double_quote_subst that were
 …
 func_echo ()
+{
     $ECHO "$progname${mode+: }$mode: $*"
+    $ECHO "$progname: ${opt_mode+$opt_mode: }$*"
+}
 …
+}
+# func_echo_all arg...
+# Invoke $ECHO with all args, space-separated.
+func_echo_all ()
+{
+    $ECHO "$*"
+}
 # func_error arg...
 # Echo program name prefixed message to standard error.
 func_error ()
+{
     $ECHO "$progname${mode+: }$mode: "${1+"$@"} 1>&2
+    $ECHO "$progname: ${opt_mode+$opt_mode: }"${1+"$@"} 1>&2
+}
 …
 func_warning ()
+{
     $opt_warning && $ECHO "$progname${mode+: }$mode: warning: "${1+"$@"} 1>&2
+    $opt_warning && $ECHO "$progname: ${opt_mode+$opt_mode: }warning: "${1+"$@"} 1>&2
     # bash bug again:
 …
         # ...otherwise throw away the child directory and loop
         my_directory_path=`$ECHO "X$my_directory_path" | $Xsed -e "$dirname"`
+        my_directory_path=`$ECHO "$my_directory_path" | $SED -e "$dirname"`
       done
       my_dir_list=`$ECHO "X$my_dir_list" | $Xsed -e 's,:*$,,'`
+      my_dir_list=`$ECHO "$my_dir_list" | $SED 's,:*$,,'`
       save_mkdir_p_IFS="$IFS"; IFS=':'
 …
     fi
     $ECHO "X$my_tmpdir" | $Xsed
+    $ECHO "$my_tmpdir"
+}
 …
     case $1 in
       *[\\\`\"\$]*)
         func_quote_for_eval_unquoted_result=`$ECHO "X$1" | $Xsed -e "$sed_quote_subst"` ;;
+        func_quote_for_eval_unquoted_result=`$ECHO "$1" | $SED "$sed_quote_subst"` ;;
       *)
         func_quote_for_eval_unquoted_result="$1" ;;
 …
     case $1 in
       *[\\\`\"]*)
         my_arg=`$ECHO "X$1" | $Xsed \
+        my_arg=`$ECHO "$1" | $SED \
             -e "$double_quote_subst" -e "$sed_double_backslash"` ;;
       *)
 …
+}
+# func_tr_sh
+# Turn $1 into a string suitable for a shell variable name.
+# Result is stored in $func_tr_sh_result.  All characters
+# not in the set a-zA-Z0-9_ are replaced with '_'. Further,
+# if $1 begins with a digit, a '_' is prepended as well.
+func_tr_sh ()
+{
+  case $1 in
+  [0-9]* | *[!a-zA-Z0-9_]*)
+    func_tr_sh_result=`$ECHO "$1" | $SED 's/^\([0-9]\)/_\1/; s/[^a-zA-Z0-9_]/_/g'`
+    ;;
+  * )
+    func_tr_sh_result=$1
+    ;;
+  esac
+}
 …
 func_version ()
+{
+    $SED -n '/^# '$PROGRAM' (GNU /,/# warranty; / {
+    $opt_debug
+    $SED -n '/(C)/!b go
+        :more
+        /\./!{
+          N
+          s/\n# / /
+          b more
+        }
+        :go
+        /^# '$PROGRAM' (GNU /,/# warranty; / {
         s/^# //
         s/^# *$//
 …
 func_usage ()
+{
+    $SED -n '/^# Usage:/,/# -h/ {
+    $opt_debug
+    $SED -n '/^# Usage:/,/^#  *.*--help/ {
         s/^# //
         s/^# *$//
 …
+        p
     }' < "$progpath"
     $ECHO
+    echo
     $ECHO "run \`$progname --help | more' for full usage"
     exit $?
+}
+# func_help
+# Echo long help message to standard output and exit.
+# func_help [NOEXIT]
+# Echo long help message to standard output and exit,
+# unless 'noexit' is passed as argument.
 func_help ()
+{
+    $opt_debug
     $SED -n '/^# Usage:/,/# Report bugs to/ {
+        :print
         s/^# //
         s/^# *$//
 …
         s*\$LD*'"$LD"'*
         s/\$with_gnu_ld/'"$with_gnu_ld"'/
         s/\$automake_version/'"`(automake --version) 2>/dev/null |$SED 1q`"'/
         s/\$autoconf_version/'"`(autoconf --version) 2>/dev/null |$SED 1q`"'/
+        s/\$automake_version/'"`(${AUTOMAKE-automake} --version) 2>/dev/null |$SED 1q`"'/
+        s/\$autoconf_version/'"`(${AUTOCONF-autoconf} --version) 2>/dev/null |$SED 1q`"'/
+        p
+     }' < "$progpath"
+    exit $?
+        d
+     }
+     /^# .* home page:/b print
+     /^# General help using/b print
+     ' < "$progpath"
+    ret=$?
+    if test -z "$1"; then
+      exit $ret
+    fi
+}
 …
 func_missing_arg ()
+{
+    func_error "missing argument for $1"
+    $opt_debug
+    func_error "missing argument for $1."
     exit_cmd=exit
+}
+# func_split_short_opt shortopt
+# Set func_split_short_opt_name and func_split_short_opt_arg shell
+# variables after splitting SHORTOPT after the 2nd character.
+func_split_short_opt ()
+{
+    my_sed_short_opt='1s/^\(..\).*$/\1/;q'
+    my_sed_short_rest='1s/^..\(.*\)$/\1/;q'
+    func_split_short_opt_name=`$ECHO "$1" | $SED "$my_sed_short_opt"`
+    func_split_short_opt_arg=`$ECHO "$1" | $SED "$my_sed_short_rest"`
+} # func_split_short_opt may be replaced by extended shell implementation
+# func_split_long_opt longopt
+# Set func_split_long_opt_name and func_split_long_opt_arg shell
+# variables after splitting LONGOPT at the `=' sign.
+func_split_long_opt ()
+{
+    my_sed_long_opt='1s/^\(--[^=]*\)=.*/\1/;q'
+    my_sed_long_arg='1s/^--[^=]*=//'
+    func_split_long_opt_name=`$ECHO "$1" | $SED "$my_sed_long_opt"`
+    func_split_long_opt_arg=`$ECHO "$1" | $SED "$my_sed_long_arg"`
+} # func_split_long_opt may be replaced by extended shell implementation
 exit_cmd=:
 …
-# Check that we have a working $ECHO.
-if test "X$1" = X--no-reexec; then
-  # Discard the --no-reexec flag, and continue.
-  shift
-elif test "X$1" = X--fallback-echo; then
-  # Avoid inline document here, it may be left over
+  :
-elif test "X`{ $ECHO '\t'; } 2>/dev/null`" = 'X\t'; then
-  # Yippee, $ECHO works!
+  :
-else
-  # Restart under the correct shell, and then maybe $ECHO will work.
-  exec $SHELL "$progpath" --no-reexec ${1+"$@"}
-fi
-if test "X$1" = X--fallback-echo; then
-  # used as fallback echo
-  shift
-  cat <<EOF
-$*
-EOF
-  exit $EXIT_SUCCESS
-fi
 magic="%%%MAGIC variable%%%"
 …
 # Global variables.
-# $mode is unset
 nonopt=
-execute_dlfiles=
 preserve_args=
 lo2o="s/\\.lo\$/.${objext}/"
 …
 extracted_serial=0
-opt_dry_run=false
-opt_duplicate_deps=false
-opt_silent=false
-opt_debug=:
 # If this variable is set in any of the actions, the command in it
 # will be execed at the end.  This prevents here-documents from being
 …
 exec_cmd=
+# func_append var value
+# Append VALUE to the end of shell variable VAR.
+func_append ()
+{
+    eval "${1}=\$${1}\${2}"
+} # func_append may be replaced by extended shell implementation
+# func_append_quoted var value
+# Quote VALUE and append to the end of shell variable VAR, separated
+# by a space.
+func_append_quoted ()
+{
+    func_quote_for_eval "${2}"
+    eval "${1}=\$${1}\\ \$func_quote_for_eval_result"
+} # func_append_quoted may be replaced by extended shell implementation
+# func_arith arithmetic-term...
+func_arith ()
+{
+    func_arith_result=`expr "${@}"`
+} # func_arith may be replaced by extended shell implementation
+# func_len string
+# STRING may not start with a hyphen.
+func_len ()
+{
+    func_len_result=`expr "${1}" : ".*" 2>/dev/null || echo $max_cmd_len`
+} # func_len may be replaced by extended shell implementation
+# func_lo2o object
+func_lo2o ()
+{
+    func_lo2o_result=`$ECHO "${1}" | $SED "$lo2o"`
+} # func_lo2o may be replaced by extended shell implementation
+# func_xform libobj-or-source
+func_xform ()
+{
+    func_xform_result=`$ECHO "${1}" | $SED 's/\.[^.]*$/.lo/'`
+} # func_xform may be replaced by extended shell implementation
 # func_fatal_configuration arg...
 # Echo program name prefixed message to standard error, followed by
 …
 func_features ()
+{
     $ECHO "host: $host"
+    echo "host: $host"
     if test "$build_libtool_libs" = yes; then
       $ECHO "enable shared libraries"
+      echo "enable shared libraries"
     else
       $ECHO "disable shared libraries"
+      echo "disable shared libraries"
     fi
     if test "$build_old_libs" = yes; then
       $ECHO "enable static libraries"
+      echo "enable static libraries"
     else
       $ECHO "disable static libraries"
+      echo "disable static libraries"
     fi
 …
       ;;
   esac
+}
-# Parse options once, thoroughly.  This comes as soon as possible in
-# the script to make things like `libtool --version' happen quickly.
+{
-  # Shorthand for --mode=foo, only valid as the first argument
-  case $1 in
-  clean|clea|cle|cl)
-    shift; set dummy --mode clean ${1+"$@"}; shift
-    ;;
-  compile|compil|compi|comp|com|co|c)
-    shift; set dummy --mode compile ${1+"$@"}; shift
-    ;;
-  execute|execut|execu|exec|exe|ex|e)
-    shift; set dummy --mode execute ${1+"$@"}; shift
-    ;;
-  finish|finis|fini|fin|fi|f)
-    shift; set dummy --mode finish ${1+"$@"}; shift
-    ;;
-  install|instal|insta|inst|ins|in|i)
-    shift; set dummy --mode install ${1+"$@"}; shift
-    ;;
-  link|lin|li|l)
-    shift; set dummy --mode link ${1+"$@"}; shift
-    ;;
-  uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
-    shift; set dummy --mode uninstall ${1+"$@"}; shift
-    ;;
-  esac
-  # Parse non-mode specific arguments:
-  while test "$#" -gt 0; do
-    opt="$1"
-    shift
-    case $opt in
-      --config)         func_config                                     ;;
-      --debug)          preserve_args="$preserve_args $opt"
-                        func_echo "enabling shell trace mode"
-                        opt_debug='set -x'
-                        $opt_debug
-                        ;;
-      -dlopen)          test "$#" -eq 0 && func_missing_arg "$opt" && break
-                        execute_dlfiles="$execute_dlfiles $1"
-                        shift
-                        ;;
-      --dry-run | -n)   opt_dry_run=:                                   ;;
-      --features)       func_features                                   ;;
-      --finish)         mode="finish"                                   ;;
-      --mode)           test "$#" -eq 0 && func_missing_arg "$opt" && break
-                        case $1 in
-                          # Valid mode arguments:
-                          clean)        ;;
-                          compile)      ;;
-                          execute)      ;;
-                          finish)       ;;
-                          install)      ;;
-                          link)         ;;
-                          relink)       ;;
-                          uninstall)    ;;
-                          # Catch anything else as an error
-                          *) func_error "invalid argument for $opt"
-                             exit_cmd=exit
-                             break
-                             ;;
-                        esac
-                        mode="$1"
-                        shift
-                        ;;
-      --preserve-dup-deps)
-                        opt_duplicate_deps=:                            ;;
-      --quiet|--silent) preserve_args="$preserve_args $opt"
-                        opt_silent=:
-                        ;;
-      --verbose| -v)    preserve_args="$preserve_args $opt"
-                        opt_silent=false
-                        ;;
-      --tag)            test "$#" -eq 0 && func_missing_arg "$opt" && break
-                        preserve_args="$preserve_args $opt $1"
-                        func_enable_tag "$1"    # tagname is set here
-                        shift
-                        ;;
-      # Separate optargs to long options:
-      -dlopen=*|--mode=*|--tag=*)
-                        func_opt_split "$opt"
-                        set dummy "$func_opt_split_opt" "$func_opt_split_arg" ${1+"$@"}
-                        shift
-                        ;;
-      -\?|-h)           func_usage                                      ;;
-      --help)           opt_help=:                                      ;;
-      --version)        func_version                                    ;;
-      -*)               func_fatal_help "unrecognized option \`$opt'"   ;;
-      *)                nonopt="$opt"
-                        break
-                        ;;
-    esac
-  done
-  case $host in
-    *cygwin* | *mingw* | *pw32* | *cegcc*)
-      # don't eliminate duplications in $postdeps and $predeps
-      opt_duplicate_compiler_generated_deps=:
-      ;;
-    *)
-      opt_duplicate_compiler_generated_deps=$opt_duplicate_deps
-      ;;
-  esac
-  # Having warned about all mis-specified options, bail out if
-  # anything was wrong.
-  $exit_cmd $EXIT_FAILURE
+}
 …
+# Shorthand for --mode=foo, only valid as the first argument
+case $1 in
+clean|clea|cle|cl)
+  shift; set dummy --mode clean ${1+"$@"}; shift
+  ;;
+compile|compil|compi|comp|com|co|c)
+  shift; set dummy --mode compile ${1+"$@"}; shift
+  ;;
+execute|execut|execu|exec|exe|ex|e)
+  shift; set dummy --mode execute ${1+"$@"}; shift
+  ;;
+finish|finis|fini|fin|fi|f)
+  shift; set dummy --mode finish ${1+"$@"}; shift
+  ;;
+install|instal|insta|inst|ins|in|i)
+  shift; set dummy --mode install ${1+"$@"}; shift
+  ;;
+link|lin|li|l)
+  shift; set dummy --mode link ${1+"$@"}; shift
+  ;;
+uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
+  shift; set dummy --mode uninstall ${1+"$@"}; shift
+  ;;
+esac
+# Option defaults:
+opt_debug=:
+opt_dry_run=false
+opt_config=false
+opt_preserve_dup_deps=false
+opt_features=false
+opt_finish=false
+opt_help=false
+opt_help_all=false
+opt_silent=:
+opt_warning=:
+opt_verbose=:
+opt_silent=false
+opt_verbose=false
+# Parse options once, thoroughly.  This comes as soon as possible in the
+# script to make things like `--version' happen as quickly as we can.
+{
+  # this just eases exit handling
+  while test $# -gt 0; do
+    opt="$1"
+    shift
+    case $opt in
+      --debug|-x)       opt_debug='set -x'
+                        func_echo "enabling shell trace mode"
+                        $opt_debug
+                        ;;
+      --dry-run|--dryrun|-n)
+                        opt_dry_run=:
+                        ;;
+      --config)
+                        opt_config=:
+func_config
+                        ;;
+      --dlopen|-dlopen)
+                        optarg="$1"
+                        opt_dlopen="${opt_dlopen+$opt_dlopen
+}$optarg"
+                        shift
+                        ;;
+      --preserve-dup-deps)
+                        opt_preserve_dup_deps=:
+                        ;;
+      --features)
+                        opt_features=:
+func_features
+                        ;;
+      --finish)
+                        opt_finish=:
+set dummy --mode finish ${1+"$@"}; shift
+                        ;;
+      --help)
+                        opt_help=:
+                        ;;
+      --help-all)
+                        opt_help_all=:
+opt_help=': help-all'
+                        ;;
+      --mode)
+                        test $# = 0 && func_missing_arg $opt && break
+                        optarg="$1"
+                        opt_mode="$optarg"
+case $optarg in
+  # Valid mode arguments:
+  clean|compile|execute|finish|install|link|relink|uninstall) ;;
+  # Catch anything else as an error
+  *) func_error "invalid argument for $opt"
+     exit_cmd=exit
+     break
+     ;;
+esac
+                        shift
+                        ;;
+      --no-silent|--no-quiet)
+                        opt_silent=false
+func_append preserve_args " $opt"
+                        ;;
+      --no-warning|--no-warn)
+                        opt_warning=false
+func_append preserve_args " $opt"
+                        ;;
+      --no-verbose)
+                        opt_verbose=false
+func_append preserve_args " $opt"
+                        ;;
+      --silent|--quiet)
+                        opt_silent=:
+func_append preserve_args " $opt"
+        opt_verbose=false
+                        ;;
+      --verbose|-v)
+                        opt_verbose=:
+func_append preserve_args " $opt"
+opt_silent=false
+                        ;;
+      --tag)
+                        test $# = 0 && func_missing_arg $opt && break
+                        optarg="$1"
+                        opt_tag="$optarg"
+func_append preserve_args " $opt $optarg"
+func_enable_tag "$optarg"
+                        shift
+                        ;;
+      -\?|-h)           func_usage                              ;;
+      --help)           func_help                               ;;
+      --version)        func_version                            ;;
+      # Separate optargs to long options:
+      --*=*)
+                        func_split_long_opt "$opt"
+                        set dummy "$func_split_long_opt_name" "$func_split_long_opt_arg" ${1+"$@"}
+                        shift
+                        ;;
+      # Separate non-argument short options:
+      -\?*|-h*|-n*|-v*)
+                        func_split_short_opt "$opt"
+                        set dummy "$func_split_short_opt_name" "-$func_split_short_opt_arg" ${1+"$@"}
+                        shift
+                        ;;
+      --)               break                                   ;;
+      -*)               func_fatal_help "unrecognized option \`$opt'" ;;
+      *)                set dummy "$opt" ${1+"$@"};     shift; break  ;;
+    esac
+  done
+  # Validate options:
+  # save first non-option argument
+  if test "$#" -gt 0; then
+    nonopt="$opt"
+    shift
+  fi
+  # preserve --debug
+  test "$opt_debug" = : || func_append preserve_args " --debug"
+  case $host in
+    *cygwin* | *mingw* | *pw32* | *cegcc*)
+      # don't eliminate duplications in $postdeps and $predeps
+      opt_duplicate_compiler_generated_deps=:
+      ;;
+    *)
+      opt_duplicate_compiler_generated_deps=$opt_preserve_dup_deps
+      ;;
+  esac
+  $opt_help || {
+    # Sanity checks first:
+    func_check_version_match
+    if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
+      func_fatal_configuration "not configured to build any kind of library"
+    fi
+    # Darwin sucks
+    eval std_shrext=\"$shrext_cmds\"
+    # Only execute mode is allowed to have -dlopen flags.
+    if test -n "$opt_dlopen" && test "$opt_mode" != execute; then
+      func_error "unrecognized option \`-dlopen'"
+      $ECHO "$help" 1>&2
+      exit $EXIT_FAILURE
+    fi
+    # Change the help message to a mode-specific one.
+    generic_help="$help"
+    help="Try \`$progname --help --mode=$opt_mode' for more information."
+  }
+  # Bail if the options were screwed
+  $exit_cmd $EXIT_FAILURE
+}
 ## ----------- ##
 ##    Main.    ##
 ## ----------- ##
-$opt_help || {
-  # Sanity checks first:
-  func_check_version_match
-  if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
-    func_fatal_configuration "not configured to build any kind of library"
-  fi
-  test -z "$mode" && func_fatal_error "error: you must specify a MODE."
-  # Darwin sucks
-  eval std_shrext=\"$shrext_cmds\"
-  # Only execute mode is allowed to have -dlopen flags.
-  if test -n "$execute_dlfiles" && test "$mode" != execute; then
-    func_error "unrecognized option \`-dlopen'"
-    $ECHO "$help" 1>&2
-    exit $EXIT_FAILURE
-  fi
-  # Change the help message to a mode-specific one.
-  generic_help="$help"
-  help="Try \`$progname --help --mode=$mode' for more information."
+}
 # func_lalib_p file
 …
 func_ltwrapper_scriptname ()
+{
+    func_ltwrapper_scriptname_result=""
+    if func_ltwrapper_executable_p "$1"; then
+        func_dirname_and_basename "$1" "" "."
+        func_stripname '' '.exe' "$func_basename_result"
+        func_ltwrapper_scriptname_result="$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper"
+    fi
+    func_dirname_and_basename "$1" "" "."
+    func_stripname '' '.exe' "$func_basename_result"
+    func_ltwrapper_scriptname_result="$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper"
+}
 …
+# func_resolve_sysroot PATH
+# Replace a leading = in PATH with a sysroot.  Store the result into
+# func_resolve_sysroot_result
+func_resolve_sysroot ()
+{
+  func_resolve_sysroot_result=$1
+  case $func_resolve_sysroot_result in
+  =*)
+    func_stripname '=' '' "$func_resolve_sysroot_result"
+    func_resolve_sysroot_result=$lt_sysroot$func_stripname_result
+    ;;
+  esac
+}
+# func_replace_sysroot PATH
+# If PATH begins with the sysroot, replace it with = and
+# store the result into func_replace_sysroot_result.
+func_replace_sysroot ()
+{
+  case "$lt_sysroot:$1" in
+  ?*:"$lt_sysroot"*)
+    func_stripname "$lt_sysroot" '' "$1"
+    func_replace_sysroot_result="=$func_stripname_result"
+    ;;
+  *)
+    # Including no sysroot.
+    func_replace_sysroot_result=$1
+    ;;
+  esac
+}
 # func_infer_tag arg
 # Infer tagged configuration to use if any are available and
 …
       CC_quoted=
       for arg in $CC; do
+        func_quote_for_eval "$arg"
+        CC_quoted="$CC_quoted $func_quote_for_eval_result"
+        func_append_quoted CC_quoted "$arg"
       done
+      CC_expanded=`func_echo_all $CC`
+      CC_quoted_expanded=`func_echo_all $CC_quoted`
       case $@ in
       # Blanks in the command may have been stripped by the calling shell,
       # but not from the CC environment variable when configure was run.
+      " $CC "* | "$CC "* | " `$ECHO $CC` "* | "`$ECHO $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$ECHO $CC_quoted` "* | "`$ECHO $CC_quoted` "*) ;;
+      " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
+      " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*) ;;
       # Blanks at the start of $base_compile will cause this to fail
       # if we don't check for them as well.
 …
             for arg in $CC; do
               # Double-quote args containing other shell metacharacters.
+              func_quote_for_eval "$arg"
+              CC_quoted="$CC_quoted $func_quote_for_eval_result"
+              func_append_quoted CC_quoted "$arg"
             done
+            CC_expanded=`func_echo_all $CC`
+            CC_quoted_expanded=`func_echo_all $CC_quoted`
             case "$@ " in
+              " $CC "* | "$CC "* | " `$ECHO $CC` "* | "`$ECHO $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$ECHO $CC_quoted` "* | "`$ECHO $CC_quoted` "*)
+            " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
+            " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*)
               # The compiler in the base compile command matches
               # the one in the tagged configuration.
 …
+}
+##################################################
+# FILE NAME AND PATH CONVERSION HELPER FUNCTIONS #
+##################################################
+# func_convert_core_file_wine_to_w32 ARG
+# Helper function used by file name conversion functions when $build is *nix,
+# and $host is mingw, cygwin, or some other w32 environment. Relies on a
+# correctly configured wine environment available, with the winepath program
+# in $build's $PATH.
+#
+# ARG is the $build file name to be converted to w32 format.
+# Result is available in $func_convert_core_file_wine_to_w32_result, and will
+# be empty on error (or when ARG is empty)
+func_convert_core_file_wine_to_w32 ()
+{
+  $opt_debug
+  func_convert_core_file_wine_to_w32_result="$1"
+  if test -n "$1"; then
+    # Unfortunately, winepath does not exit with a non-zero error code, so we
+    # are forced to check the contents of stdout. On the other hand, if the
+    # command is not found, the shell will set an exit code of 127 and print
+    # *an error message* to stdout. So we must check for both error code of
+    # zero AND non-empty stdout, which explains the odd construction:
+    func_convert_core_file_wine_to_w32_tmp=`winepath -w "$1" 2>/dev/null`
+    if test "$?" -eq 0 && test -n "${func_convert_core_file_wine_to_w32_tmp}"; then
+      func_convert_core_file_wine_to_w32_result=`$ECHO "$func_convert_core_file_wine_to_w32_tmp" |
+        $SED -e "$lt_sed_naive_backslashify"`
+    else
+      func_convert_core_file_wine_to_w32_result=
+    fi
+  fi
+}
+# end: func_convert_core_file_wine_to_w32
+# func_convert_core_path_wine_to_w32 ARG
+# Helper function used by path conversion functions when $build is *nix, and
+# $host is mingw, cygwin, or some other w32 environment. Relies on a correctly
+# configured wine environment available, with the winepath program in $build's
+# $PATH. Assumes ARG has no leading or trailing path separator characters.
+#
+# ARG is path to be converted from $build format to win32.
+# Result is available in $func_convert_core_path_wine_to_w32_result.
+# Unconvertible file (directory) names in ARG are skipped; if no directory names
+# are convertible, then the result may be empty.
+func_convert_core_path_wine_to_w32 ()
+{
+  $opt_debug
+  # unfortunately, winepath doesn't convert paths, only file names
+  func_convert_core_path_wine_to_w32_result=""
+  if test -n "$1"; then
+    oldIFS=$IFS
+    IFS=:
+    for func_convert_core_path_wine_to_w32_f in $1; do
+      IFS=$oldIFS
+      func_convert_core_file_wine_to_w32 "$func_convert_core_path_wine_to_w32_f"
+      if test -n "$func_convert_core_file_wine_to_w32_result" ; then
+        if test -z "$func_convert_core_path_wine_to_w32_result"; then
+          func_convert_core_path_wine_to_w32_result="$func_convert_core_file_wine_to_w32_result"
+        else
+          func_append func_convert_core_path_wine_to_w32_result ";$func_convert_core_file_wine_to_w32_result"
+        fi
+      fi
+    done
+    IFS=$oldIFS
+  fi
+}
+# end: func_convert_core_path_wine_to_w32
+# func_cygpath ARGS...
+# Wrapper around calling the cygpath program via LT_CYGPATH. This is used when
+# when (1) $build is *nix and Cygwin is hosted via a wine environment; or (2)
+# $build is MSYS and $host is Cygwin, or (3) $build is Cygwin. In case (1) or
+# (2), returns the Cygwin file name or path in func_cygpath_result (input
+# file name or path is assumed to be in w32 format, as previously converted
+# from $build's *nix or MSYS format). In case (3), returns the w32 file name
+# or path in func_cygpath_result (input file name or path is assumed to be in
+# Cygwin format). Returns an empty string on error.
+#
+# ARGS are passed to cygpath, with the last one being the file name or path to
+# be converted.
+#
+# Specify the absolute *nix (or w32) name to cygpath in the LT_CYGPATH
+# environment variable; do not put it in $PATH.
+func_cygpath ()
+{
+  $opt_debug
+  if test -n "$LT_CYGPATH" && test -f "$LT_CYGPATH"; then
+    func_cygpath_result=`$LT_CYGPATH "$@" 2>/dev/null`
+    if test "$?" -ne 0; then
+      # on failure, ensure result is empty
+      func_cygpath_result=
+    fi
+  else
+    func_cygpath_result=
+    func_error "LT_CYGPATH is empty or specifies non-existent file: \`$LT_CYGPATH'"
+  fi
+}
+#end: func_cygpath
+# func_convert_core_msys_to_w32 ARG
+# Convert file name or path ARG from MSYS format to w32 format.  Return
+# result in func_convert_core_msys_to_w32_result.
+func_convert_core_msys_to_w32 ()
+{
+  $opt_debug
+  # awkward: cmd appends spaces to result
+  func_convert_core_msys_to_w32_result=`( cmd //c echo "$1" ) 2>/dev/null |
+    $SED -e 's/[ ]*$//' -e "$lt_sed_naive_backslashify"`
+}
+#end: func_convert_core_msys_to_w32
+# func_convert_file_check ARG1 ARG2
+# Verify that ARG1 (a file name in $build format) was converted to $host
+# format in ARG2. Otherwise, emit an error message, but continue (resetting
+# func_to_host_file_result to ARG1).
+func_convert_file_check ()
+{
+  $opt_debug
+  if test -z "$2" && test -n "$1" ; then
+    func_error "Could not determine host file name corresponding to"
+    func_error "  \`$1'"
+    func_error "Continuing, but uninstalled executables may not work."
+    # Fallback:
+    func_to_host_file_result="$1"
+  fi
+}
+# end func_convert_file_check
+# func_convert_path_check FROM_PATHSEP TO_PATHSEP FROM_PATH TO_PATH
+# Verify that FROM_PATH (a path in $build format) was converted to $host
+# format in TO_PATH. Otherwise, emit an error message, but continue, resetting
+# func_to_host_file_result to a simplistic fallback value (see below).
+func_convert_path_check ()
+{
+  $opt_debug
+  if test -z "$4" && test -n "$3"; then
+    func_error "Could not determine the host path corresponding to"
+    func_error "  \`$3'"
+    func_error "Continuing, but uninstalled executables may not work."
+    # Fallback.  This is a deliberately simplistic "conversion" and
+    # should not be "improved".  See libtool.info.
+    if test "x$1" != "x$2"; then
+      lt_replace_pathsep_chars="s|$1|$2|g"
+      func_to_host_path_result=`echo "$3" |
+        $SED -e "$lt_replace_pathsep_chars"`
+    else
+      func_to_host_path_result="$3"
+    fi
+  fi
+}
+# end func_convert_path_check
+# func_convert_path_front_back_pathsep FRONTPAT BACKPAT REPL ORIG
+# Modifies func_to_host_path_result by prepending REPL if ORIG matches FRONTPAT
+# and appending REPL if ORIG matches BACKPAT.
+func_convert_path_front_back_pathsep ()
+{
+  $opt_debug
+  case $4 in
+  $1 ) func_to_host_path_result="$3$func_to_host_path_result"
+    ;;
+  esac
+  case $4 in
+  $2 ) func_append func_to_host_path_result "$3"
+    ;;
+  esac
+}
+# end func_convert_path_front_back_pathsep
+##################################################
+# $build to $host FILE NAME CONVERSION FUNCTIONS #
+##################################################
+# invoked via `$to_host_file_cmd ARG'
+#
+# In each case, ARG is the path to be converted from $build to $host format.
+# Result will be available in $func_to_host_file_result.
+# func_to_host_file ARG
+# Converts the file name ARG from $build format to $host format. Return result
+# in func_to_host_file_result.
+func_to_host_file ()
+{
+  $opt_debug
+  $to_host_file_cmd "$1"
+}
+# end func_to_host_file
+# func_to_tool_file ARG LAZY
+# converts the file name ARG from $build format to toolchain format. Return
+# result in func_to_tool_file_result.  If the conversion in use is listed
+# in (the comma separated) LAZY, no conversion takes place.
+func_to_tool_file ()
+{
+  $opt_debug
+  case ,$2, in
+    *,"$to_tool_file_cmd",*)
+      func_to_tool_file_result=$1
+      ;;
+    *)
+      $to_tool_file_cmd "$1"
+      func_to_tool_file_result=$func_to_host_file_result
+      ;;
+  esac
+}
+# end func_to_tool_file
+# func_convert_file_noop ARG
+# Copy ARG to func_to_host_file_result.
+func_convert_file_noop ()
+{
+  func_to_host_file_result="$1"
+}
+# end func_convert_file_noop
+# func_convert_file_msys_to_w32 ARG
+# Convert file name ARG from (mingw) MSYS to (mingw) w32 format; automatic
+# conversion to w32 is not available inside the cwrapper.  Returns result in
+# func_to_host_file_result.
+func_convert_file_msys_to_w32 ()
+{
+  $opt_debug
+  func_to_host_file_result="$1"
+  if test -n "$1"; then
+    func_convert_core_msys_to_w32 "$1"
+    func_to_host_file_result="$func_convert_core_msys_to_w32_result"
+  fi
+  func_convert_file_check "$1" "$func_to_host_file_result"
+}
+# end func_convert_file_msys_to_w32
+# func_convert_file_cygwin_to_w32 ARG
+# Convert file name ARG from Cygwin to w32 format.  Returns result in
+# func_to_host_file_result.
+func_convert_file_cygwin_to_w32 ()
+{
+  $opt_debug
+  func_to_host_file_result="$1"
+  if test -n "$1"; then
+    # because $build is cygwin, we call "the" cygpath in $PATH; no need to use
+    # LT_CYGPATH in this case.
+    func_to_host_file_result=`cygpath -m "$1"`
+  fi
+  func_convert_file_check "$1" "$func_to_host_file_result"
+}
+# end func_convert_file_cygwin_to_w32
+# func_convert_file_nix_to_w32 ARG
+# Convert file name ARG from *nix to w32 format.  Requires a wine environment
+# and a working winepath. Returns result in func_to_host_file_result.
+func_convert_file_nix_to_w32 ()
+{
+  $opt_debug
+  func_to_host_file_result="$1"
+  if test -n "$1"; then
+    func_convert_core_file_wine_to_w32 "$1"
+    func_to_host_file_result="$func_convert_core_file_wine_to_w32_result"
+  fi
+  func_convert_file_check "$1" "$func_to_host_file_result"
+}
+# end func_convert_file_nix_to_w32
+# func_convert_file_msys_to_cygwin ARG
+# Convert file name ARG from MSYS to Cygwin format.  Requires LT_CYGPATH set.
+# Returns result in func_to_host_file_result.
+func_convert_file_msys_to_cygwin ()
+{
+  $opt_debug
+  func_to_host_file_result="$1"
+  if test -n "$1"; then
+    func_convert_core_msys_to_w32 "$1"
+    func_cygpath -u "$func_convert_core_msys_to_w32_result"
+    func_to_host_file_result="$func_cygpath_result"
+  fi
+  func_convert_file_check "$1" "$func_to_host_file_result"
+}
+# end func_convert_file_msys_to_cygwin
+# func_convert_file_nix_to_cygwin ARG
+# Convert file name ARG from *nix to Cygwin format.  Requires Cygwin installed
+# in a wine environment, working winepath, and LT_CYGPATH set.  Returns result
+# in func_to_host_file_result.
+func_convert_file_nix_to_cygwin ()
+{
+  $opt_debug
+  func_to_host_file_result="$1"
+  if test -n "$1"; then
+    # convert from *nix to w32, then use cygpath to convert from w32 to cygwin.
+    func_convert_core_file_wine_to_w32 "$1"
+    func_cygpath -u "$func_convert_core_file_wine_to_w32_result"
+    func_to_host_file_result="$func_cygpath_result"
+  fi
+  func_convert_file_check "$1" "$func_to_host_file_result"
+}
+# end func_convert_file_nix_to_cygwin
+#############################################
+# $build to $host PATH CONVERSION FUNCTIONS #
+#############################################
+# invoked via `$to_host_path_cmd ARG'
+#
+# In each case, ARG is the path to be converted from $build to $host format.
+# The result will be available in $func_to_host_path_result.
+#
+# Path separators are also converted from $build format to $host format.  If
+# ARG begins or ends with a path separator character, it is preserved (but
+# converted to $host format) on output.
+#
+# All path conversion functions are named using the following convention:
+#   file name conversion function    : func_convert_file_X_to_Y ()
+#   path conversion function         : func_convert_path_X_to_Y ()
+# where, for any given $build/$host combination the 'X_to_Y' value is the
+# same.  If conversion functions are added for new $build/$host combinations,
+# the two new functions must follow this pattern, or func_init_to_host_path_cmd
+# will break.
+# func_init_to_host_path_cmd
+# Ensures that function "pointer" variable $to_host_path_cmd is set to the
+# appropriate value, based on the value of $to_host_file_cmd.
+to_host_path_cmd=
+func_init_to_host_path_cmd ()
+{
+  $opt_debug
+  if test -z "$to_host_path_cmd"; then
+    func_stripname 'func_convert_file_' '' "$to_host_file_cmd"
+    to_host_path_cmd="func_convert_path_${func_stripname_result}"
+  fi
+}
+# func_to_host_path ARG
+# Converts the path ARG from $build format to $host format. Return result
+# in func_to_host_path_result.
+func_to_host_path ()
+{
+  $opt_debug
+  func_init_to_host_path_cmd
+  $to_host_path_cmd "$1"
+}
+# end func_to_host_path
+# func_convert_path_noop ARG
+# Copy ARG to func_to_host_path_result.
+func_convert_path_noop ()
+{
+  func_to_host_path_result="$1"
+}
+# end func_convert_path_noop
+# func_convert_path_msys_to_w32 ARG
+# Convert path ARG from (mingw) MSYS to (mingw) w32 format; automatic
+# conversion to w32 is not available inside the cwrapper.  Returns result in
+# func_to_host_path_result.
+func_convert_path_msys_to_w32 ()
+{
+  $opt_debug
+  func_to_host_path_result="$1"
+  if test -n "$1"; then
+    # Remove leading and trailing path separator characters from ARG.  MSYS
+    # behavior is inconsistent here; cygpath turns them into '.;' and ';.';
+    # and winepath ignores them completely.
+    func_stripname : : "$1"
+    func_to_host_path_tmp1=$func_stripname_result
+    func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
+    func_to_host_path_result="$func_convert_core_msys_to_w32_result"
+    func_convert_path_check : ";" \
+      "$func_to_host_path_tmp1" "$func_to_host_path_result"
+    func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
+  fi
+}
+# end func_convert_path_msys_to_w32
+# func_convert_path_cygwin_to_w32 ARG
+# Convert path ARG from Cygwin to w32 format.  Returns result in
+# func_to_host_file_result.
+func_convert_path_cygwin_to_w32 ()
+{
+  $opt_debug
+  func_to_host_path_result="$1"
+  if test -n "$1"; then
+    # See func_convert_path_msys_to_w32:
+    func_stripname : : "$1"
+    func_to_host_path_tmp1=$func_stripname_result
+    func_to_host_path_result=`cygpath -m -p "$func_to_host_path_tmp1"`
+    func_convert_path_check : ";" \
+      "$func_to_host_path_tmp1" "$func_to_host_path_result"
+    func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
+  fi
+}
+# end func_convert_path_cygwin_to_w32
+# func_convert_path_nix_to_w32 ARG
+# Convert path ARG from *nix to w32 format.  Requires a wine environment and
+# a working winepath.  Returns result in func_to_host_file_result.
+func_convert_path_nix_to_w32 ()
+{
+  $opt_debug
+  func_to_host_path_result="$1"
+  if test -n "$1"; then
+    # See func_convert_path_msys_to_w32:
+    func_stripname : : "$1"
+    func_to_host_path_tmp1=$func_stripname_result
+    func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
+    func_to_host_path_result="$func_convert_core_path_wine_to_w32_result"
+    func_convert_path_check : ";" \
+      "$func_to_host_path_tmp1" "$func_to_host_path_result"
+    func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
+  fi
+}
+# end func_convert_path_nix_to_w32
+# func_convert_path_msys_to_cygwin ARG
+# Convert path ARG from MSYS to Cygwin format.  Requires LT_CYGPATH set.
+# Returns result in func_to_host_file_result.
+func_convert_path_msys_to_cygwin ()
+{
+  $opt_debug
+  func_to_host_path_result="$1"
+  if test -n "$1"; then
+    # See func_convert_path_msys_to_w32:
+    func_stripname : : "$1"
+    func_to_host_path_tmp1=$func_stripname_result
+    func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
+    func_cygpath -u -p "$func_convert_core_msys_to_w32_result"
+    func_to_host_path_result="$func_cygpath_result"
+    func_convert_path_check : : \
+      "$func_to_host_path_tmp1" "$func_to_host_path_result"
+    func_convert_path_front_back_pathsep ":*" "*:" : "$1"
+  fi
+}
+# end func_convert_path_msys_to_cygwin
+# func_convert_path_nix_to_cygwin ARG
+# Convert path ARG from *nix to Cygwin format.  Requires Cygwin installed in a
+# a wine environment, working winepath, and LT_CYGPATH set.  Returns result in
+# func_to_host_file_result.
+func_convert_path_nix_to_cygwin ()
+{
+  $opt_debug
+  func_to_host_path_result="$1"
+  if test -n "$1"; then
+    # Remove leading and trailing path separator characters from
+    # ARG. msys behavior is inconsistent here, cygpath turns them
+    # into '.;' and ';.', and winepath ignores them completely.
+    func_stripname : : "$1"
+    func_to_host_path_tmp1=$func_stripname_result
+    func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
+    func_cygpath -u -p "$func_convert_core_path_wine_to_w32_result"
+    func_to_host_path_result="$func_cygpath_result"
+    func_convert_path_check : : \
+      "$func_to_host_path_tmp1" "$func_to_host_path_result"
+    func_convert_path_front_back_pathsep ":*" "*:" : "$1"
+  fi
+}
+# end func_convert_path_nix_to_cygwin
 # func_mode_compile arg...
 func_mode_compile ()
 …
         -pie | -fpie | -fPIE)
           pie_flag="$pie_flag $arg"
+          func_append pie_flag " $arg"
           continue
           ;;
         -shared | -static | -prefer-pic | -prefer-non-pic)
           later="$later $arg"
+          func_append later " $arg"
           continue
           ;;
 …
           for arg in $args; do
             IFS="$save_ifs"
+            func_quote_for_eval "$arg"
+            lastarg="$lastarg $func_quote_for_eval_result"
+            func_append_quoted lastarg "$arg"
           done
           IFS="$save_ifs"
 …
           # Add the arguments to base_compile.
           base_compile="$base_compile $lastarg"
+          func_append base_compile " $lastarg"
           continue
           ;;
 …
       # Aesthetically quote the previous argument.
+      func_quote_for_eval "$lastarg"
+      base_compile="$base_compile $func_quote_for_eval_result"
+      func_append_quoted base_compile "$lastarg"
     done # for arg
 …
     *.ada | *.adb | *.ads | *.asm | \
     *.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \
     *.[fF][09]? | *.for | *.java | *.obj | *.sx)
+    *.[fF][09]? | *.for | *.java | *.go | *.obj | *.sx | *.cu | *.cup)
       func_xform "$libobj"
       libobj=$func_xform_result
 …
     # not support -o with -c
     if test "$compiler_c_o" = no; then
       output_obj=`$ECHO "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%\.[^.]*$%%'`.${objext}
+      output_obj=`$ECHO "$srcfile" | $SED 's%^.*/%%; s%\.[^.]*$%%'`.${objext}
       lockfile="$output_obj.lock"
     else
 …
         exit $EXIT_FAILURE
       fi
       removelist="$removelist $output_obj"
+      func_append removelist " $output_obj"
       $ECHO "$srcfile" > "$lockfile"
     fi
     $opt_dry_run || $RM $removelist
     removelist="$removelist $lockfile"
+    func_append removelist " $lockfile"
     trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15
+    if test -n "$fix_srcfile_path"; then
+      eval srcfile=\"$fix_srcfile_path\"
+    fi
+    func_to_tool_file "$srcfile" func_convert_file_msys_to_w32
+    srcfile=$func_to_tool_file_result
     func_quote_for_eval "$srcfile"
     qsrcfile=$func_quote_for_eval_result
 …
       if test -z "$output_obj"; then
         # Place PIC objects in $objdir
         command="$command -o $lobj"
+        func_append command " -o $lobj"
       fi
 …
       fi
       if test "$compiler_c_o" = yes; then
         command="$command -o $obj"
+        func_append command " -o $obj"
       fi
       # Suppress compiler output if we already did a PIC compilation.
       command="$command$suppress_output"
+      func_append command "$suppress_output"
       func_show_eval_locale "$command" \
         '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'
 …
 $opt_help || {
 test "$mode" = compile && func_mode_compile ${1+"$@"}
+  test "$opt_mode" = compile && func_mode_compile ${1+"$@"}
+}
 …
+{
     # We need to display help for each of the modes.
     case $mode in
+    case $opt_mode in
       "")
         # Generic help is extracted from the usage comments
 …
   -o OUTPUT-FILE    set the output file name to OUTPUT-FILE
   -no-suppress      do not suppress compiler output for multiple passes
   -prefer-pic       try to building PIC objects only
   -prefer-non-pic   try to building non-PIC objects only
+  -prefer-pic       try to build PIC objects only
+  -prefer-non-pic   try to build non-PIC objects only
   -shared           do not build a \`.o' file suitable for static linking
   -static           only build a \`.o' file suitable for static linking
+  -Wc,FLAG          pass FLAG directly to the compiler
 COMPILE-COMMAND is a command to be used in creating a \`standard' object file
 …
 The following components of INSTALL-COMMAND are treated specially:
   -inst-prefix PREFIX-DIR  Use PREFIX-DIR as a staging area for installation
+  -inst-prefix-dir PREFIX-DIR  Use PREFIX-DIR as a staging area for installation
 The rest of the components are interpreted as arguments to that command (only
 …
   -all-static       do not do any dynamic linking at all
   -avoid-version    do not add a version suffix if possible
+  -bindir BINDIR    specify path to binaries directory (for systems where
+                    libraries must be found in the PATH setting at runtime)
   -dlopen FILE      \`-dlpreopen' FILE if it cannot be dlopened at runtime
   -dlpreopen FILE   link in FILE and add its symbols to lt_preloaded_symbols
 …
                     specify library version info [each variable defaults to 0]
   -weak LIBNAME     declare that the target provides the LIBNAME interface
+  -Wc,FLAG
+  -Xcompiler FLAG   pass linker-specific FLAG directly to the compiler
+  -Wl,FLAG
+  -Xlinker FLAG     pass linker-specific FLAG directly to the linker
+  -XCClinker FLAG   pass link-specific FLAG to the compiler driver (CC)
 All other options (arguments beginning with \`-') are ignored.
 …
       *)
         func_fatal_help "invalid operation mode \`$mode'"
+        func_fatal_help "invalid operation mode \`$opt_mode'"
         ;;
     esac
     $ECHO
+    echo
     $ECHO "Try \`$progname --help' for more information about other modes."
+    exit $?
+}
+  # Now that we've collected a possible --mode arg, show help if necessary
+  $opt_help && func_mode_help
+}
+# Now that we've collected a possible --mode arg, show help if necessary
+if $opt_help; then
+  if test "$opt_help" = :; then
+    func_mode_help
+  else
+    {
+      func_help noexit
+      for opt_mode in compile link execute install finish uninstall clean; do
+        func_mode_help
+      done
+    } | sed -n '1p; 2,$s/^Usage:/  or: /p'
+    {
+      func_help noexit
+      for opt_mode in compile link execute install finish uninstall clean; do
+        echo
+        func_mode_help
+      done
+    } |
+    sed '1d
+      /^When reporting/,/^Report/{
+        H
+        d
+      }
+      $x
+      /information about other modes/d
+      /more detailed .*MODE/d
+      s/^Usage:.*--mode=\([^ ]*\) .*/Description of \1 mode:/'
+  fi
+  exit $?
+fi
 …
     # Handle -dlopen flags immediately.
     for file in $execute_dlfiles; do
+    for file in $opt_dlopen; do
       test -f "$file" \
         || func_fatal_help "\`$file' is not a file"
 …
       case $file in
       *.la)
+        func_resolve_sysroot "$file"
+        file=$func_resolve_sysroot_result
         # Check to see that this really is a libtool archive.
         func_lalib_unsafe_p "$file" \
 …
         if test -f "$dir/$objdir/$dlname"; then
           dir="$dir/$objdir"
+          func_append dir "/$objdir"
         else
           if test ! -f "$dir/$dlname"; then
 …
     do
       case $file in
       -*) ;;
+      -* | *.la | *.lo ) ;;
       *)
         # Do a test to see if this is really a libtool program.
 …
       esac
       # Quote arguments (to preserve shell metacharacters).
+      func_quote_for_eval "$file"
+      args="$args $func_quote_for_eval_result"
+      func_append_quoted args "$file"
     done
 …
       if test -n "$shlibpath_var"; then
         eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""
         $ECHO "export $shlibpath_var"
+        echo "export $shlibpath_var"
       fi
       $ECHO "$cmd$args"
 …
+}
 test "$mode" = execute && func_mode_execute ${1+"$@"}
+test "$opt_mode" = execute && func_mode_execute ${1+"$@"}
 …
+{
     $opt_debug
+    libdirs="$nonopt"
+    libs=
+    libdirs=
     admincmds=
+    for opt in "$nonopt" ${1+"$@"}
+    do
+      if test -d "$opt"; then
+        func_append libdirs " $opt"
+      elif test -f "$opt"; then
+        if func_lalib_unsafe_p "$opt"; then
+          func_append libs " $opt"
+        else
+          func_warning "\`$opt' is not a valid libtool archive"
+        fi
+      else
+        func_fatal_error "invalid argument \`$opt'"
+      fi
+    done
+    if test -n "$libs"; then
+      if test -n "$lt_sysroot"; then
+        sysroot_regex=`$ECHO "$lt_sysroot" | $SED "$sed_make_literal_regex"`
+        sysroot_cmd="s/\([ ']\)$sysroot_regex/\1/g;"
+      else
+        sysroot_cmd=
+      fi
+      # Remove sysroot references
+      if $opt_dry_run; then
+        for lib in $libs; do
+          echo "removing references to $lt_sysroot and \`=' prefixes from $lib"
+        done
+      else
+        tmpdir=`func_mktempdir`
+        for lib in $libs; do
+          sed -e "${sysroot_cmd} s/\([ ']-[LR]\)=/\1/g; s/\([ ']\)=/\1/g" $lib \
+            > $tmpdir/tmp-la
+          mv -f $tmpdir/tmp-la $lib
+        done
+        ${RM}r "$tmpdir"
+      fi
+    fi
     if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
-      for dir
-      do
-        libdirs="$libdirs $dir"
-      done
       for libdir in $libdirs; do
         if test -n "$finish_cmds"; then
 …
           # Do the single finish_eval.
           eval cmds=\"$finish_eval\"
           $opt_dry_run || eval "$cmds" || admincmds="$admincmds
+          $opt_dry_run || eval "$cmds" || func_append admincmds "
        $cmds"
         fi
 …
     $opt_silent && exit $EXIT_SUCCESS
+    $ECHO "X----------------------------------------------------------------------" | $Xsed
+    $ECHO "Libraries have been installed in:"
+    for libdir in $libdirs; do
+      $ECHO "   $libdir"
+    done
+    $ECHO
+    $ECHO "If you ever happen to want to link against installed libraries"
+    $ECHO "in a given directory, LIBDIR, you must either use libtool, and"
+    $ECHO "specify the full pathname of the library, or use the \`-LLIBDIR'"
+    $ECHO "flag during linking and do at least one of the following:"
+    if test -n "$shlibpath_var"; then
+      $ECHO "   - add LIBDIR to the \`$shlibpath_var' environment variable"
+      $ECHO "     during execution"
+    if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
+      echo "----------------------------------------------------------------------"
+      echo "Libraries have been installed in:"
+      for libdir in $libdirs; do
+        $ECHO "   $libdir"
+      done
+      echo
+      echo "If you ever happen to want to link against installed libraries"
+      echo "in a given directory, LIBDIR, you must either use libtool, and"
+      echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
+      echo "flag during linking and do at least one of the following:"
+      if test -n "$shlibpath_var"; then
+        echo "   - add LIBDIR to the \`$shlibpath_var' environment variable"
+        echo "     during execution"
+      fi
+      if test -n "$runpath_var"; then
+        echo "   - add LIBDIR to the \`$runpath_var' environment variable"
+        echo "     during linking"
+      fi
+      if test -n "$hardcode_libdir_flag_spec"; then
+        libdir=LIBDIR
+        eval flag=\"$hardcode_libdir_flag_spec\"
+        $ECHO "   - use the \`$flag' linker flag"
+      fi
+      if test -n "$admincmds"; then
+        $ECHO "   - have your system administrator run these commands:$admincmds"
+      fi
+      if test -f /etc/ld.so.conf; then
+        echo "   - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
+      fi
+      echo
+      echo "See any operating system documentation about shared libraries for"
+      case $host in
+        solaris2.[6789]|solaris2.1[0-9])
+          echo "more information, such as the ld(1), crle(1) and ld.so(8) manual"
+          echo "pages."
+          ;;
+        *)
+          echo "more information, such as the ld(1) and ld.so(8) manual pages."
+          ;;
+      esac
+      echo "----------------------------------------------------------------------"
     fi
-    if test -n "$runpath_var"; then
-      $ECHO "   - add LIBDIR to the \`$runpath_var' environment variable"
-      $ECHO "     during linking"
-    fi
-    if test -n "$hardcode_libdir_flag_spec"; then
-      libdir=LIBDIR
-      eval flag=\"$hardcode_libdir_flag_spec\"
-      $ECHO "   - use the \`$flag' linker flag"
-    fi
-    if test -n "$admincmds"; then
-      $ECHO "   - have your system administrator run these commands:$admincmds"
-    fi
-    if test -f /etc/ld.so.conf; then
-      $ECHO "   - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
-    fi
-    $ECHO
-    $ECHO "See any operating system documentation about shared libraries for"
-    case $host in
-      solaris2.[6789]|solaris2.1[0-9])
-        $ECHO "more information, such as the ld(1), crle(1) and ld.so(8) manual"
-        $ECHO "pages."
-        ;;
-      *)
-        $ECHO "more information, such as the ld(1) and ld.so(8) manual pages."
-        ;;
-    esac
-    $ECHO "X----------------------------------------------------------------------" | $Xsed
     exit $EXIT_SUCCESS
+}
 test "$mode" = finish && func_mode_finish ${1+"$@"}
+test "$opt_mode" = finish && func_mode_finish ${1+"$@"}
 …
     if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
        # Allow the use of GNU shtool's install command.
        $ECHO "X$nonopt" | $GREP shtool >/dev/null; then
+       case $nonopt in *shtool*) :;; *) false;; esac; then
       # Aesthetically quote it.
       func_quote_for_eval "$nonopt"
 …
     # Aesthetically quote it.
     func_quote_for_eval "$arg"
+    install_prog="$install_prog$func_quote_for_eval_result"
+    func_append install_prog "$func_quote_for_eval_result"
+    install_shared_prog=$install_prog
+    case " $install_prog " in
+      *[\\\ /]cp\ *) install_cp=: ;;
+      *) install_cp=false ;;
+    esac
     # We need to accept at least all the BSD install flags.
 …
     isdir=no
     stripme=
+    no_mode=:
     for arg
     do
+      arg2=
       if test -n "$dest"; then
         files="$files $dest"
+        func_append files " $dest"
         dest=$arg
         continue
 …
       -d) isdir=yes ;;
       -f)
+        case " $install_prog " in
+        *[\\\ /]cp\ *) ;;
+        *) prev=$arg ;;
+        esac
+        if $install_cp; then :; else
+          prev=$arg
+        fi
         ;;
       -g | -m | -o)
 …
         # If the previous option needed an argument, then skip it.
         if test -n "$prev"; then
+          if test "x$prev" = x-m && test -n "$install_override_mode"; then
+            arg2=$install_override_mode
+            no_mode=false
+          fi
           prev=
         else
 …
       # Aesthetically quote the argument.
       func_quote_for_eval "$arg"
+      install_prog="$install_prog $func_quote_for_eval_result"
+      func_append install_prog " $func_quote_for_eval_result"
+      if test -n "$arg2"; then
+        func_quote_for_eval "$arg2"
+      fi
+      func_append install_shared_prog " $func_quote_for_eval_result"
     done
 …
     test -n "$prev" && \
       func_fatal_help "the \`$prev' option requires an argument"
+    if test -n "$install_override_mode" && $no_mode; then
+      if $install_cp; then :; else
+        func_quote_for_eval "$install_override_mode"
+        func_append install_shared_prog " -m $func_quote_for_eval_result"
+      fi
+    fi
     if test -z "$files"; then
 …
       *.$libext)
         # Do the static libraries later.
         staticlibs="$staticlibs $file"
+        func_append staticlibs " $file"
         ;;
       *.la)
+        func_resolve_sysroot "$file"
+        file=$func_resolve_sysroot_result
         # Check to see that this really is a libtool archive.
         func_lalib_unsafe_p "$file" \
 …
           case "$current_libdirs " in
           *" $libdir "*) ;;
           *) current_libdirs="$current_libdirs $libdir" ;;
+          *) func_append current_libdirs " $libdir" ;;
           esac
         else
 …
           case "$future_libdirs " in
           *" $libdir "*) ;;
           *) future_libdirs="$future_libdirs $libdir" ;;
+          *) func_append future_libdirs " $libdir" ;;
           esac
         fi
 …
         func_dirname "$file" "/" ""
         dir="$func_dirname_result"
         dir="$dir$objdir"
+        func_append dir "$objdir"
         if test -n "$relink_command"; then
           # Determine the prefix the user has applied to our future dir.
           inst_prefix_dir=`$ECHO "X$destdir" | $Xsed -e "s%$libdir\$%%"`
+          inst_prefix_dir=`$ECHO "$destdir" | $SED -e "s%$libdir\$%%"`
           # Don't allow the user to place us outside of our expected
 …
           if test -n "$inst_prefix_dir"; then
             # Stick the inst_prefix_dir data into the link command.
             relink_command=`$ECHO "X$relink_command" | $Xsed -e "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
+            relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
           else
             relink_command=`$ECHO "X$relink_command" | $Xsed -e "s%@inst_prefix_dir@%%"`
+            relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
           fi
 …
           # Install the shared library and build the symlinks.
           func_show_eval "$install_prog $dir/$srcname $destdir/$realname" \
+          func_show_eval "$install_shared_prog $dir/$srcname $destdir/$realname" \
               'exit $?'
           tstripme="$stripme"
 …
         # Maybe install the static library, too.
         test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
+        test -n "$old_library" && func_append staticlibs " $dir/$old_library"
         ;;
 …
               func_source "$lib"
             fi
             libfile="$libdir/"`$ECHO "X$lib" | $Xsed -e 's%^.*/%%g'` ### testsuite: skip nested quoting test
+            libfile="$libdir/"`$ECHO "$lib" | $SED 's%^.*/%%g'` ### testsuite: skip nested quoting test
             if test -n "$libdir" && test ! -f "$libfile"; then
               func_warning "\`$lib' has not been installed in \`$libdir'"
 …
                 outputname="$tmpdir/$file"
                 # Replace the output file specification.
                 relink_command=`$ECHO "X$relink_command" | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g'`
+                relink_command=`$ECHO "$relink_command" | $SED 's%@OUTPUT@%'"$outputname"'%g'`
                 $opt_silent || {
 …
           else
             # Install the binary that we compiled earlier.
             file=`$ECHO "X$file$stripped_ext" | $Xsed -e "s%\([^/]*\)$%$objdir/\1%"`
+            file=`$ECHO "$file$stripped_ext" | $SED "s%\([^/]*\)$%$objdir/\1%"`
           fi
         fi
 …
       # Set up the ranlib parameters.
       oldlib="$destdir/$name"
+      func_to_tool_file "$oldlib" func_convert_file_msys_to_w32
+      tool_oldlib=$func_to_tool_file_result
       func_show_eval "$install_prog \$file \$oldlib" 'exit $?'
       if test -n "$stripme" && test -n "$old_striplib"; then
         func_show_eval "$old_striplib $oldlib" 'exit $?'
+        func_show_eval "$old_striplib $tool_oldlib" 'exit $?'
       fi
 …
+}
 test "$mode" = install && func_mode_install ${1+"$@"}
+test "$opt_mode" = install && func_mode_install ${1+"$@"}
 …
 #endif
+#if defined(__GNUC__) && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4))
+#pragma GCC diagnostic ignored \"-Wstrict-prototypes\"
+#endif
+/* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests.  */
+#if defined(_WIN32) || defined(__CYGWIN__) || defined(_WIN32_WCE)
+/* DATA imports from DLLs on WIN32 con't be const, because runtime
+   relocations are performed -- see ld's documentation on pseudo-relocs.  */
+# define LT_DLSYM_CONST
+#elif defined(__osf__)
+/* This system does not cope well with relocations in const data.  */
+# define LT_DLSYM_CONST
+#else
+# define LT_DLSYM_CONST const
+#endif
 /* External symbol declarations for the compiler. */\
+"
 …
           # Add our own program objects to the symbol list.
           progfiles=`$ECHO "X$objs$old_deplibs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
+          progfiles=`$ECHO "$objs$old_deplibs" | $SP2NL | $SED "$lo2o" | $NL2SP`
           for progfile in $progfiles; do
+            func_verbose "extracting global C symbols from \`$progfile'"
+            $opt_dry_run || eval "$NM $progfile | $global_symbol_pipe >> '$nlist'"
+            func_to_tool_file "$progfile" func_convert_file_msys_to_w32
+            func_verbose "extracting global C symbols from \`$func_to_tool_file_result'"
+            $opt_dry_run || eval "$NM $func_to_tool_file_result | $global_symbol_pipe >> '$nlist'"
           done
 …
               eval '$MV "$nlist"T "$nlist"'
               case $host in
                 *cygwin | *mingw* | *cegcc* )
+                *cygwin* | *mingw* | *cegcc* )
                   eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
                   eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
 …
           func_basename "$dlprefile"
           name="$func_basename_result"
+          $opt_dry_run || {
+            eval '$ECHO ": $name " >> "$nlist"'
+            eval "$NM $dlprefile 2>/dev/null | $global_symbol_pipe >> '$nlist'"
+          }
+          case $host in
+            *cygwin* | *mingw* | *cegcc* )
+              # if an import library, we need to obtain dlname
+              if func_win32_import_lib_p "$dlprefile"; then
+                func_tr_sh "$dlprefile"
+                eval "curr_lafile=\$libfile_$func_tr_sh_result"
+                dlprefile_dlbasename=""
+                if test -n "$curr_lafile" && func_lalib_p "$curr_lafile"; then
+                  # Use subshell, to avoid clobbering current variable values
+                  dlprefile_dlname=`source "$curr_lafile" && echo "$dlname"`
+                  if test -n "$dlprefile_dlname" ; then
+                    func_basename "$dlprefile_dlname"
+                    dlprefile_dlbasename="$func_basename_result"
+                  else
+                    # no lafile. user explicitly requested -dlpreopen <import library>.
+                    $sharedlib_from_linklib_cmd "$dlprefile"
+                    dlprefile_dlbasename=$sharedlib_from_linklib_result
+                  fi
+                fi
+                $opt_dry_run || {
+                  if test -n "$dlprefile_dlbasename" ; then
+                    eval '$ECHO ": $dlprefile_dlbasename" >> "$nlist"'
+                  else
+                    func_warning "Could not compute DLL name from $name"
+                    eval '$ECHO ": $name " >> "$nlist"'
+                  fi
+                  func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
+                  eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe |
+                    $SED -e '/I __imp/d' -e 's/I __nm_/D /;s/_nm__//' >> '$nlist'"
+                }
+              else # not an import lib
+                $opt_dry_run || {
+                  eval '$ECHO ": $name " >> "$nlist"'
+                  func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
+                  eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
+                }
+              fi
+            ;;
+            *)
+              $opt_dry_run || {
+                eval '$ECHO ": $name " >> "$nlist"'
+                func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
+                eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
+              }
+            ;;
+          esac
         done
 …
             eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
           else
             $ECHO '/* NONE */' >> "$output_objdir/$my_dlsyms"
+            echo '/* NONE */' >> "$output_objdir/$my_dlsyms"
           fi
           $ECHO >> "$output_objdir/$my_dlsyms" "\
+          echo >> "$output_objdir/$my_dlsyms" "\
 /* The mapping between symbol names and symbols.  */
 …
   void *address;
 } lt_dlsymlist;
+"
+          case $host in
+          *cygwin* | *mingw* | *cegcc* )
+            $ECHO >> "$output_objdir/$my_dlsyms" "\
+/* DATA imports from DLLs on WIN32 con't be const, because
+   runtime relocations are performed -- see ld's documentation
+   on pseudo-relocs.  */"
+            lt_dlsym_const= ;;
+          *osf5*)
+            echo >> "$output_objdir/$my_dlsyms" "\
+/* This system does not cope well with relocations in const data */"
+            lt_dlsym_const= ;;
+          *)
+            lt_dlsym_const=const ;;
+          esac
+          $ECHO >> "$output_objdir/$my_dlsyms" "\
+extern $lt_dlsym_const lt_dlsymlist
+extern LT_DLSYM_CONST lt_dlsymlist
 lt_${my_prefix}_LTX_preloaded_symbols[];
 $lt_dlsym_const lt_dlsymlist
+LT_DLSYM_CONST lt_dlsymlist
 lt_${my_prefix}_LTX_preloaded_symbols[] =
 {\
 …
             ;;
           esac
           $ECHO >> "$output_objdir/$my_dlsyms" "\
+          echo >> "$output_objdir/$my_dlsyms" "\
   {0, (void *) 0}
 };
 …
           # pic_flag when linking with -static.  The problem exists in
           # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
           *-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
+          *-*-freebsd2.*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
             pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;
           *-*-hpux*)
 …
           case $arg in
           -pie | -fpie | -fPIE) ;;
           *) symtab_cflags="$symtab_cflags $arg" ;;
+          *) func_append symtab_cflags " $arg" ;;
           esac
         done
 …
         *cygwin* | *mingw* | *cegcc* )
           if test -f "$output_objdir/$my_outputname.def"; then
             compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
             finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
+            compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
+            finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
           else
             compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
             finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
+            compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
+            finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
           fi
           ;;
         *)
           compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
           finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
+          compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
+          finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
           ;;
         esac
 …
       # Nullify the symbol file.
       compile_command=`$ECHO "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`
       finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`
+      compile_command=`$ECHO "$compile_command" | $SED "s% @SYMFILE@%%"`
+      finalize_command=`$ECHO "$finalize_command" | $SED "s% @SYMFILE@%%"`
     fi
+}
 …
 # Has to be a shell function in order to 'eat' the argument
 # that is supplied when $file_magic_command is called.
+# Despite the name, also deal with 64 bit binaries.
 func_win32_libid ()
+{
 …
     ;;
   *ar\ archive*) # could be an import, or static
+    # Keep the egrep pattern in sync with the one in _LT_CHECK_MAGIC_METHOD.
     if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null |
+       $EGREP 'file format pe-i386(.*architecture: i386)?' >/dev/null ; then
+      win32_nmres=`eval $NM -f posix -A $1 |
+       $EGREP 'file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' >/dev/null; then
+      func_to_tool_file "$1" func_convert_file_msys_to_w32
+      win32_nmres=`eval $NM -f posix -A \"$func_to_tool_file_result\" |
         $SED -n -e '
 ,100{
 …
+}
+# func_cygming_dll_for_implib ARG
+#
+# Platform-specific function to extract the
+# name of the DLL associated with the specified
+# import library ARG.
+# Invoked by eval'ing the libtool variable
+#    $sharedlib_from_linklib_cmd
+# Result is available in the variable
+#    $sharedlib_from_linklib_result
+func_cygming_dll_for_implib ()
+{
+  $opt_debug
+  sharedlib_from_linklib_result=`$DLLTOOL --identify-strict --identify "$1"`
+}
+# func_cygming_dll_for_implib_fallback_core SECTION_NAME LIBNAMEs
+#
+# The is the core of a fallback implementation of a
+# platform-specific function to extract the name of the
+# DLL associated with the specified import library LIBNAME.
+#
+# SECTION_NAME is either .idata$6 or .idata$7, depending
+# on the platform and compiler that created the implib.
+#
+# Echos the name of the DLL associated with the
+# specified import library.
+func_cygming_dll_for_implib_fallback_core ()
+{
+  $opt_debug
+  match_literal=`$ECHO "$1" | $SED "$sed_make_literal_regex"`
+  $OBJDUMP -s --section "$1" "$2" 2>/dev/null |
+    $SED '/^Contents of section '"$match_literal"':/{
+      # Place marker at beginning of archive member dllname section
+      s/.*/====MARK====/
+      p
+      d
+    }
+    # These lines can sometimes be longer than 43 characters, but
+    # are always uninteresting
+    /:[  ]*file format pe[i]\{,1\}-/d
+    /^In archive [^:]*:/d
+    # Ensure marker is printed
+    /^====MARK====/p
+    # Remove all lines with less than 43 characters
+    /^.\{43\}/!d
+    # From remaining lines, remove first 43 characters
+    s/^.\{43\}//' |
+    $SED -n '
+      # Join marker and all lines until next marker into a single line
+      /^====MARK====/ b para
+      H
+      $ b para
+      b
+      :para
+      x
+      s/\n//g
+      # Remove the marker
+      s/^====MARK====//
+      # Remove trailing dots and whitespace
+      s/[\. \t]*$//
+      # Print
+      /./p' |
+    # we now have a list, one entry per line, of the stringified
+    # contents of the appropriate section of all members of the
+    # archive which possess that section. Heuristic: eliminate
+    # all those which have a first or second character that is
+    # a '.' (that is, objdump's representation of an unprintable
+    # character.) This should work for all archives with less than
+    # 0x302f exports -- but will fail for DLLs whose name actually
+    # begins with a literal '.' or a single character followed by
+    # a '.'.
+    #
+    # Of those that remain, print the first one.
+    $SED -e '/^\./d;/^.\./d;q'
+}
+# func_cygming_gnu_implib_p ARG
+# This predicate returns with zero status (TRUE) if
+# ARG is a GNU/binutils-style import library. Returns
+# with nonzero status (FALSE) otherwise.
+func_cygming_gnu_implib_p ()
+{
+  $opt_debug
+  func_to_tool_file "$1" func_convert_file_msys_to_w32
+  func_cygming_gnu_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $EGREP ' (_head_[A-Za-z0-9_]+_[ad]l*|[A-Za-z0-9_]+_[ad]l*_iname)$'`
+  test -n "$func_cygming_gnu_implib_tmp"
+}
+# func_cygming_ms_implib_p ARG
+# This predicate returns with zero status (TRUE) if
+# ARG is an MS-style import library. Returns
+# with nonzero status (FALSE) otherwise.
+func_cygming_ms_implib_p ()
+{
+  $opt_debug
+  func_to_tool_file "$1" func_convert_file_msys_to_w32
+  func_cygming_ms_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $GREP '_NULL_IMPORT_DESCRIPTOR'`
+  test -n "$func_cygming_ms_implib_tmp"
+}
+# func_cygming_dll_for_implib_fallback ARG
+# Platform-specific function to extract the
+# name of the DLL associated with the specified
+# import library ARG.
+#
+# This fallback implementation is for use when $DLLTOOL
+# does not support the --identify-strict option.
+# Invoked by eval'ing the libtool variable
+#    $sharedlib_from_linklib_cmd
+# Result is available in the variable
+#    $sharedlib_from_linklib_result
+func_cygming_dll_for_implib_fallback ()
+{
+  $opt_debug
+  if func_cygming_gnu_implib_p "$1" ; then
+    # binutils import library
+    sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$7' "$1"`
+  elif func_cygming_ms_implib_p "$1" ; then
+    # ms-generated import library
+    sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$6' "$1"`
+  else
+    # unknown
+    sharedlib_from_linklib_result=""
+  fi
+}
 …
     f_ex_an_ar_dir="$1"; shift
     f_ex_an_ar_oldlib="$1"
+    func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" 'exit $?'
+    if test "$lock_old_archive_extraction" = yes; then
+      lockfile=$f_ex_an_ar_oldlib.lock
+      until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
+        func_echo "Waiting for $lockfile to be removed"
+        sleep 2
+      done
+    fi
+    func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" \
+                   'stat=$?; rm -f "$lockfile"; exit $stat'
+    if test "$lock_old_archive_extraction" = yes; then
+      $opt_dry_run || rm -f "$lockfile"
+    fi
     if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
+     :
 …
             darwin_files=
             for darwin_file in $darwin_filelist; do
               darwin_files=`find unfat-$$ -name $darwin_file -print | $NL2SP`
+              darwin_files=`find unfat-$$ -name $darwin_file -print | sort | $NL2SP`
               $LIPO -create -output "$darwin_file" $darwin_files
             done # $darwin_filelist
 …
         ;;
       esac
       my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
+      my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | sort | $NL2SP`
     done
     func_extract_archives_result="$my_oldobjs"
+}
-# func_emit_wrapper_part1 [arg=no]
+#
-# Emit the first part of a libtool wrapper script on stdout.
-# For more information, see the description associated with
-# func_emit_wrapper(), below.
-func_emit_wrapper_part1 ()
+{
-        func_emit_wrapper_part1_arg1=no
-        if test -n "$1" ; then
-          func_emit_wrapper_part1_arg1=$1
-        fi
-        $ECHO "\
-#! $SHELL
-# $output - temporary wrapper script for $objdir/$outputname
-# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
+#
-# The $output program cannot be directly executed until all the libtool
-# libraries that it depends on are installed.
+#
-# This wrapper script should never be moved out of the build directory.
-# If it is, it will not operate correctly.
-# Sed substitution that helps us do robust quoting.  It backslashifies
-# metacharacters that are still active within double-quoted strings.
-Xsed='${SED} -e 1s/^X//'
-sed_quote_subst='$sed_quote_subst'
-# Be Bourne compatible
-if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
-  emulate sh
-  NULLCMD=:
-  # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
-  # is contrary to our usage.  Disable this feature.
-  alias -g '\${1+\"\$@\"}'='\"\$@\"'
-  setopt NO_GLOB_SUBST
-else
-  case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
-fi
-BIN_SH=xpg4; export BIN_SH # for Tru64
-DUALCASE=1; export DUALCASE # for MKS sh
-# The HP-UX ksh and POSIX shell print the target directory to stdout
-# if CDPATH is set.
-(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
-relink_command=\"$relink_command\"
-# This environment variable determines our operation mode.
-if test \"\$libtool_install_magic\" = \"$magic\"; then
-  # install mode needs the following variables:
-  generated_by_libtool_version='$macro_version'
-  notinst_deplibs='$notinst_deplibs'
-else
-  # When we are sourced in execute mode, \$file and \$ECHO are already set.
-  if test \"\$libtool_execute_magic\" != \"$magic\"; then
-    ECHO=\"$qecho\"
-    file=\"\$0\"
-    # Make sure echo works.
-    if test \"X\$1\" = X--no-reexec; then
-      # Discard the --no-reexec flag, and continue.
-      shift
-    elif test \"X\`{ \$ECHO '\t'; } 2>/dev/null\`\" = 'X\t'; then
-      # Yippee, \$ECHO works!
+      :
-    else
-      # Restart under the correct shell, and then maybe \$ECHO will work.
-      exec $SHELL \"\$0\" --no-reexec \${1+\"\$@\"}
-    fi
-  fi\
+"
-        $ECHO "\
-  # Find the directory that this script lives in.
-  thisdir=\`\$ECHO \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`
-  test \"x\$thisdir\" = \"x\$file\" && thisdir=.
-  # Follow symbolic links until we get to the real thisdir.
-  file=\`ls -ld \"\$file\" | ${SED} -n 's/.*-> //p'\`
-  while test -n \"\$file\"; do
-    destdir=\`\$ECHO \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`
-    # If there was a directory component, then change thisdir.
-    if test \"x\$destdir\" != \"x\$file\"; then
-      case \"\$destdir\" in
-      [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
-      *) thisdir=\"\$thisdir/\$destdir\" ;;
-      esac
-    fi
-    file=\`\$ECHO \"X\$file\" | \$Xsed -e 's%^.*/%%'\`
-    file=\`ls -ld \"\$thisdir/\$file\" | ${SED} -n 's/.*-> //p'\`
-  done
+"
+}
-# end: func_emit_wrapper_part1
-# func_emit_wrapper_part2 [arg=no]
+#
-# Emit the second part of a libtool wrapper script on stdout.
-# For more information, see the description associated with
-# func_emit_wrapper(), below.
-func_emit_wrapper_part2 ()
+{
-        func_emit_wrapper_part2_arg1=no
-        if test -n "$1" ; then
-          func_emit_wrapper_part2_arg1=$1
-        fi
-        $ECHO "\
-  # Usually 'no', except on cygwin/mingw when embedded into
-  # the cwrapper.
-  WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_part2_arg1
-  if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
-    # special case for '.'
-    if test \"\$thisdir\" = \".\"; then
-      thisdir=\`pwd\`
-    fi
-    # remove .libs from thisdir
-    case \"\$thisdir\" in
-    *[\\\\/]$objdir ) thisdir=\`\$ECHO \"X\$thisdir\" | \$Xsed -e 's%[\\\\/][^\\\\/]*$%%'\` ;;
-    $objdir )   thisdir=. ;;
-    esac
-  fi
-  # Try to get the absolute directory name.
-  absdir=\`cd \"\$thisdir\" && pwd\`
-  test -n \"\$absdir\" && thisdir=\"\$absdir\"
+"
-        if test "$fast_install" = yes; then
-          $ECHO "\
-  program=lt-'$outputname'$exeext
-  progdir=\"\$thisdir/$objdir\"
-  if test ! -f \"\$progdir/\$program\" ||
-     { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
-       test \"X\$file\" != \"X\$progdir/\$program\"; }; then
-    file=\"\$\$-\$program\"
-    if test ! -d \"\$progdir\"; then
-      $MKDIR \"\$progdir\"
-    else
-      $RM \"\$progdir/\$file\"
-    fi"
-          $ECHO "\
-    # relink executable if necessary
-    if test -n \"\$relink_command\"; then
-      if relink_command_output=\`eval \$relink_command 2>&1\`; then :
-      else
-        $ECHO \"\$relink_command_output\" >&2
-        $RM \"\$progdir/\$file\"
-        exit 1
-      fi
-    fi
-    $MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
-    { $RM \"\$progdir/\$program\";
-      $MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
-    $RM \"\$progdir/\$file\"
-  fi"
-        else
-          $ECHO "\
-  program='$outputname'
-  progdir=\"\$thisdir/$objdir\"
+"
-        fi
-        $ECHO "\
-  if test -f \"\$progdir/\$program\"; then"
-        # Export our shlibpath_var if we have one.
-        if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
-          $ECHO "\
-    # Add our own library path to $shlibpath_var
-    $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
-    # Some systems cannot cope with colon-terminated $shlibpath_var
-    # The second colon is a workaround for a bug in BeOS R4 sed
-    $shlibpath_var=\`\$ECHO \"X\$$shlibpath_var\" | \$Xsed -e 's/::*\$//'\`
-    export $shlibpath_var
+"
-        fi
-        # fixup the dll searchpath if we need to.
-        if test -n "$dllsearchpath"; then
-          $ECHO "\
-    # Add the dll search path components to the executable PATH
-    PATH=$dllsearchpath:\$PATH
+"
-        fi
-        $ECHO "\
-    if test \"\$libtool_execute_magic\" != \"$magic\"; then
-      # Run the actual program with our arguments.
+"
-        case $host in
-        # Backslashes separate directories on plain windows
-        *-*-mingw | *-*-os2* | *-cegcc*)
-          $ECHO "\
-      exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
+"
-          ;;
-        *)
-          $ECHO "\
-      exec \"\$progdir/\$program\" \${1+\"\$@\"}
+"
-          ;;
-        esac
-        $ECHO "\
-      \$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
-      exit 1
-    fi
-  else
-    # The program doesn't exist.
-    \$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
-    \$ECHO \"This script is just a wrapper for \$program.\" 1>&2
-    $ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
-    exit 1
-  fi
-fi\
+"
+}
-# end: func_emit_wrapper_part2
 …
 func_emit_wrapper ()
+{
+        func_emit_wrapper_arg1=no
+        if test -n "$1" ; then
+          func_emit_wrapper_arg1=$1
+        fi
+        # split this up so that func_emit_cwrapperexe_src
+        # can call each part independently.
+        func_emit_wrapper_part1 "${func_emit_wrapper_arg1}"
+        func_emit_wrapper_part2 "${func_emit_wrapper_arg1}"
+}
+# func_to_host_path arg
+        func_emit_wrapper_arg1=${1-no}
+        $ECHO "\
+#! $SHELL
+# $output - temporary wrapper script for $objdir/$outputname
+# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
+#
+# Convert paths to host format when used with build tools.
+# Intended for use with "native" mingw (where libtool itself
+# is running under the msys shell), or in the following cross-
+# build environments:
+#    $build          $host
+#    mingw (msys)    mingw  [e.g. native]
+#    cygwin          mingw
+#    *nix + wine     mingw
+# where wine is equipped with the `winepath' executable.
+# In the native mingw case, the (msys) shell automatically
+# converts paths for any non-msys applications it launches,
+# but that facility isn't available from inside the cwrapper.
+# Similar accommodations are necessary for $host mingw and
+# $build cygwin.  Calling this function does no harm for other
+# $host/$build combinations not listed above.
+# The $output program cannot be directly executed until all the libtool
+# libraries that it depends on are installed.
+#
+# ARG is the path (on $build) that should be converted to
+# the proper representation for $host. The result is stored
+# in $func_to_host_path_result.
+func_to_host_path ()
+{
+  func_to_host_path_result="$1"
+  if test -n "$1" ; then
+    case $host in
+      *mingw* )
+        lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
+        case $build in
+          *mingw* ) # actually, msys
+            # awkward: cmd appends spaces to result
+            lt_sed_strip_trailing_spaces="s/[ ]*\$//"
+            func_to_host_path_tmp1=`( cmd //c echo "$1" |\
+              $SED -e "$lt_sed_strip_trailing_spaces" ) 2>/dev/null || echo ""`
+            func_to_host_path_result=`echo "$func_to_host_path_tmp1" |\
+              $SED -e "$lt_sed_naive_backslashify"`
+            ;;
+          *cygwin* )
+            func_to_host_path_tmp1=`cygpath -w "$1"`
+            func_to_host_path_result=`echo "$func_to_host_path_tmp1" |\
+              $SED -e "$lt_sed_naive_backslashify"`
+            ;;
+          * )
+            # Unfortunately, winepath does not exit with a non-zero
+            # error code, so we are forced to check the contents of
+            # stdout. On the other hand, if the command is not
+            # found, the shell will set an exit code of 127 and print
+            # *an error message* to stdout. So we must check for both
+            # error code of zero AND non-empty stdout, which explains
+            # the odd construction:
+            func_to_host_path_tmp1=`winepath -w "$1" 2>/dev/null`
+            if test "$?" -eq 0 && test -n "${func_to_host_path_tmp1}"; then
+              func_to_host_path_result=`echo "$func_to_host_path_tmp1" |\
+                $SED -e "$lt_sed_naive_backslashify"`
+            else
+              # Allow warning below.
+              func_to_host_path_result=""
+            fi
+            ;;
+        esac
+        if test -z "$func_to_host_path_result" ; then
+          func_error "Could not determine host path corresponding to"
+          func_error "  '$1'"
+          func_error "Continuing, but uninstalled executables may not work."
+          # Fallback:
+          func_to_host_path_result="$1"
+        fi
+        ;;
+# This wrapper script should never be moved out of the build directory.
+# If it is, it will not operate correctly.
+# Sed substitution that helps us do robust quoting.  It backslashifies
+# metacharacters that are still active within double-quoted strings.
+sed_quote_subst='$sed_quote_subst'
+# Be Bourne compatible
+if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
+  emulate sh
+  NULLCMD=:
+  # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
+  # is contrary to our usage.  Disable this feature.
+  alias -g '\${1+\"\$@\"}'='\"\$@\"'
+  setopt NO_GLOB_SUBST
+else
+  case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
+fi
+BIN_SH=xpg4; export BIN_SH # for Tru64
+DUALCASE=1; export DUALCASE # for MKS sh
+# The HP-UX ksh and POSIX shell print the target directory to stdout
+# if CDPATH is set.
+(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
+relink_command=\"$relink_command\"
+# This environment variable determines our operation mode.
+if test \"\$libtool_install_magic\" = \"$magic\"; then
+  # install mode needs the following variables:
+  generated_by_libtool_version='$macro_version'
+  notinst_deplibs='$notinst_deplibs'
+else
+  # When we are sourced in execute mode, \$file and \$ECHO are already set.
+  if test \"\$libtool_execute_magic\" != \"$magic\"; then
+    file=\"\$0\""
+    qECHO=`$ECHO "$ECHO" | $SED "$sed_quote_subst"`
+    $ECHO "\
+# A function that is used when there is no print builtin or printf.
+func_fallback_echo ()
+{
+  eval 'cat <<_LTECHO_EOF
+\$1
+_LTECHO_EOF'
+}
+    ECHO=\"$qECHO\"
+  fi
+# Very basic option parsing. These options are (a) specific to
+# the libtool wrapper, (b) are identical between the wrapper
+# /script/ and the wrapper /executable/ which is used only on
+# windows platforms, and (c) all begin with the string "--lt-"
+# (application programs are unlikely to have options which match
+# this pattern).
+#
+# There are only two supported options: --lt-debug and
+# --lt-dump-script. There is, deliberately, no --lt-help.
+#
+# The first argument to this parsing function should be the
+# script's $0 value, followed by "$@".
+lt_option_debug=
+func_parse_lt_options ()
+{
+  lt_script_arg0=\$0
+  shift
+  for lt_opt
+  do
+    case \"\$lt_opt\" in
+    --lt-debug) lt_option_debug=1 ;;
+    --lt-dump-script)
+        lt_dump_D=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%/[^/]*$%%'\`
+        test \"X\$lt_dump_D\" = \"X\$lt_script_arg0\" && lt_dump_D=.
+        lt_dump_F=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%^.*/%%'\`
+        cat \"\$lt_dump_D/\$lt_dump_F\"
+        exit 0
+      ;;
+    --lt-*)
+        \$ECHO \"Unrecognized --lt- option: '\$lt_opt'\" 1>&2
+        exit 1
+      ;;
+    esac
+  done
+  # Print the debug banner immediately:
+  if test -n \"\$lt_option_debug\"; then
+    echo \"${outputname}:${output}:\${LINENO}: libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\" 1>&2
+  fi
+}
+# Used when --lt-debug. Prints its arguments to stdout
+# (redirection is the responsibility of the caller)
+func_lt_dump_args ()
+{
+  lt_dump_args_N=1;
+  for lt_arg
+  do
+    \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[\$lt_dump_args_N]: \$lt_arg\"
+    lt_dump_args_N=\`expr \$lt_dump_args_N + 1\`
+  done
+}
+# Core function for launching the target application
+func_exec_program_core ()
+{
+"
+  case $host in
+  # Backslashes separate directories on plain windows
+  *-*-mingw | *-*-os2* | *-cegcc*)
+    $ECHO "\
+      if test -n \"\$lt_option_debug\"; then
+        \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir\\\\\$program\" 1>&2
+        func_lt_dump_args \${1+\"\$@\"} 1>&2
+      fi
+      exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
+"
+    ;;
+  *)
+    $ECHO "\
+      if test -n \"\$lt_option_debug\"; then
+        \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir/\$program\" 1>&2
+        func_lt_dump_args \${1+\"\$@\"} 1>&2
+      fi
+      exec \"\$progdir/\$program\" \${1+\"\$@\"}
+"
+    ;;
+  esac
+  $ECHO "\
+      \$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
+      exit 1
+}
+# A function to encapsulate launching the target application
+# Strips options in the --lt-* namespace from \$@ and
+# launches target application with the remaining arguments.
+func_exec_program ()
+{
+  case \" \$* \" in
+  *\\ --lt-*)
+    for lt_wr_arg
+    do
+      case \$lt_wr_arg in
+      --lt-*) ;;
+      *) set x \"\$@\" \"\$lt_wr_arg\"; shift;;
+      esac
+      shift
+    done ;;
+  esac
+  func_exec_program_core \${1+\"\$@\"}
+}
+  # Parse options
+  func_parse_lt_options \"\$0\" \${1+\"\$@\"}
+  # Find the directory that this script lives in.
+  thisdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*$%%'\`
+  test \"x\$thisdir\" = \"x\$file\" && thisdir=.
+  # Follow symbolic links until we get to the real thisdir.
+  file=\`ls -ld \"\$file\" | $SED -n 's/.*-> //p'\`
+  while test -n \"\$file\"; do
+    destdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*\$%%'\`
+    # If there was a directory component, then change thisdir.
+    if test \"x\$destdir\" != \"x\$file\"; then
+      case \"\$destdir\" in
+      [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
+      *) thisdir=\"\$thisdir/\$destdir\" ;;
+      esac
+    fi
+    file=\`\$ECHO \"\$file\" | $SED 's%^.*/%%'\`
+    file=\`ls -ld \"\$thisdir/\$file\" | $SED -n 's/.*-> //p'\`
+  done
+  # Usually 'no', except on cygwin/mingw when embedded into
+  # the cwrapper.
+  WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1
+  if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
+    # special case for '.'
+    if test \"\$thisdir\" = \".\"; then
+      thisdir=\`pwd\`
+    fi
+    # remove .libs from thisdir
+    case \"\$thisdir\" in
+    *[\\\\/]$objdir ) thisdir=\`\$ECHO \"\$thisdir\" | $SED 's%[\\\\/][^\\\\/]*$%%'\` ;;
+    $objdir )   thisdir=. ;;
     esac
   fi
+}
+# end: func_to_host_path
+# func_to_host_pathlist arg
+#
+# Convert pathlists to host format when used with build tools.
+# See func_to_host_path(), above. This function supports the
+# following $build/$host combinations (but does no harm for
+# combinations not listed here):
+#    $build          $host
+#    mingw (msys)    mingw  [e.g. native]
+#    cygwin          mingw
+#    *nix + wine     mingw
+#
+# Path separators are also converted from $build format to
+# $host format. If ARG begins or ends with a path separator
+# character, it is preserved (but converted to $host format)
+# on output.
+#
+# ARG is a pathlist (on $build) that should be converted to
+# the proper representation on $host. The result is stored
+# in $func_to_host_pathlist_result.
+func_to_host_pathlist ()
+{
+  func_to_host_pathlist_result="$1"
+  if test -n "$1" ; then
+    case $host in
+      *mingw* )
+        lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
+        # Remove leading and trailing path separator characters from
+        # ARG. msys behavior is inconsistent here, cygpath turns them
+        # into '.;' and ';.', and winepath ignores them completely.
+        func_to_host_pathlist_tmp2="$1"
+        # Once set for this call, this variable should not be
+        # reassigned. It is used in tha fallback case.
+        func_to_host_pathlist_tmp1=`echo "$func_to_host_pathlist_tmp2" |\
+          $SED -e 's|^:*||' -e 's|:*$||'`
+        case $build in
+          *mingw* ) # Actually, msys.
+            # Awkward: cmd appends spaces to result.
+            lt_sed_strip_trailing_spaces="s/[ ]*\$//"
+            func_to_host_pathlist_tmp2=`( cmd //c echo "$func_to_host_pathlist_tmp1" |\
+              $SED -e "$lt_sed_strip_trailing_spaces" ) 2>/dev/null || echo ""`
+            func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp2" |\
+              $SED -e "$lt_sed_naive_backslashify"`
+            ;;
+          *cygwin* )
+            func_to_host_pathlist_tmp2=`cygpath -w -p "$func_to_host_pathlist_tmp1"`
+            func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp2" |\
+              $SED -e "$lt_sed_naive_backslashify"`
+            ;;
+          * )
+            # unfortunately, winepath doesn't convert pathlists
+            func_to_host_pathlist_result=""
+            func_to_host_pathlist_oldIFS=$IFS
+            IFS=:
+            for func_to_host_pathlist_f in $func_to_host_pathlist_tmp1 ; do
+              IFS=$func_to_host_pathlist_oldIFS
+              if test -n "$func_to_host_pathlist_f" ; then
+                func_to_host_path "$func_to_host_pathlist_f"
+                if test -n "$func_to_host_path_result" ; then
+                  if test -z "$func_to_host_pathlist_result" ; then
+                    func_to_host_pathlist_result="$func_to_host_path_result"
+                  else
+                    func_to_host_pathlist_result="$func_to_host_pathlist_result;$func_to_host_path_result"
+                  fi
+                fi
+              fi
+              IFS=:
+            done
+            IFS=$func_to_host_pathlist_oldIFS
+            ;;
+        esac
+        if test -z "$func_to_host_pathlist_result" ; then
+          func_error "Could not determine the host path(s) corresponding to"
+          func_error "  '$1'"
+          func_error "Continuing, but uninstalled executables may not work."
+          # Fallback. This may break if $1 contains DOS-style drive
+          # specifications. The fix is not to complicate the expression
+          # below, but for the user to provide a working wine installation
+          # with winepath so that path translation in the cross-to-mingw
+          # case works properly.
+          lt_replace_pathsep_nix_to_dos="s|:|;|g"
+          func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp1" |\
+            $SED -e "$lt_replace_pathsep_nix_to_dos"`
+        fi
+        # Now, add the leading and trailing path separators back
+        case "$1" in
+          :* ) func_to_host_pathlist_result=";$func_to_host_pathlist_result"
+            ;;
+        esac
+        case "$1" in
+          *: ) func_to_host_pathlist_result="$func_to_host_pathlist_result;"
+            ;;
+        esac
+        ;;
+    esac
+  # Try to get the absolute directory name.
+  absdir=\`cd \"\$thisdir\" && pwd\`
+  test -n \"\$absdir\" && thisdir=\"\$absdir\"
+"
+        if test "$fast_install" = yes; then
+          $ECHO "\
+  program=lt-'$outputname'$exeext
+  progdir=\"\$thisdir/$objdir\"
+  if test ! -f \"\$progdir/\$program\" ||
+     { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
+       test \"X\$file\" != \"X\$progdir/\$program\"; }; then
+    file=\"\$\$-\$program\"
+    if test ! -d \"\$progdir\"; then
+      $MKDIR \"\$progdir\"
+    else
+      $RM \"\$progdir/\$file\"
+    fi"
+          $ECHO "\
+    # relink executable if necessary
+    if test -n \"\$relink_command\"; then
+      if relink_command_output=\`eval \$relink_command 2>&1\`; then :
+      else
+        $ECHO \"\$relink_command_output\" >&2
+        $RM \"\$progdir/\$file\"
+        exit 1
+      fi
+    fi
+    $MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
+    { $RM \"\$progdir/\$program\";
+      $MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
+    $RM \"\$progdir/\$file\"
+  fi"
+        else
+          $ECHO "\
+  program='$outputname'
+  progdir=\"\$thisdir/$objdir\"
+"
+        fi
+        $ECHO "\
+  if test -f \"\$progdir/\$program\"; then"
+        # fixup the dll searchpath if we need to.
+        #
+        # Fix the DLL searchpath if we need to.  Do this before prepending
+        # to shlibpath, because on Windows, both are PATH and uninstalled
+        # libraries must come first.
+        if test -n "$dllsearchpath"; then
+          $ECHO "\
+    # Add the dll search path components to the executable PATH
+    PATH=$dllsearchpath:\$PATH
+"
+        fi
+        # Export our shlibpath_var if we have one.
+        if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
+          $ECHO "\
+    # Add our own library path to $shlibpath_var
+    $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
+    # Some systems cannot cope with colon-terminated $shlibpath_var
+    # The second colon is a workaround for a bug in BeOS R4 sed
+    $shlibpath_var=\`\$ECHO \"\$$shlibpath_var\" | $SED 's/::*\$//'\`
+    export $shlibpath_var
+"
+        fi
+        $ECHO "\
+    if test \"\$libtool_execute_magic\" != \"$magic\"; then
+      # Run the actual program with our arguments.
+      func_exec_program \${1+\"\$@\"}
+    fi
+  else
+    # The program doesn't exist.
+    \$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
+    \$ECHO \"This script is just a wrapper for \$program.\" 1>&2
+    \$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
+    exit 1
   fi
+}
+# end: func_to_host_pathlist
+fi\
+"
+}
 # func_emit_cwrapperexe_src
 …
    This wrapper executable should never be moved out of the build directory.
    If it is, it will not operate correctly.
-   Currently, it simply execs the wrapper *script* "$SHELL $output",
-   but could eventually absorb all of the scripts functionality and
-   exec $objdir/$outputname directly.
 */
 EOF
             cat <<"EOF"
+#ifdef _MSC_VER
+# define _CRT_SECURE_NO_DEPRECATE 1
+#endif
 #include <stdio.h>
 #include <stdlib.h>
 …
 # include <process.h>
 # include <io.h>
-# define setmode _setmode
 #else
 # include <unistd.h>
 …
 # ifdef __CYGWIN__
 #  include <io.h>
-#  define HAVE_SETENV
-#  ifdef __STRICT_ANSI__
-char *realpath (const char *, char *);
-int putenv (char *);
-int setenv (const char *, const char *, int);
-#  endif
 # endif
 #endif
 …
 #include <sys/stat.h>
+/* declarations of non-ANSI functions */
+#if defined(__MINGW32__)
+# ifdef __STRICT_ANSI__
+int _putenv (const char *);
+# endif
+#elif defined(__CYGWIN__)
+# ifdef __STRICT_ANSI__
+char *realpath (const char *, char *);
+int putenv (char *);
+int setenv (const char *, const char *, int);
+# endif
+/* #elif defined (other platforms) ... */
+#endif
+/* portability defines, excluding path handling macros */
+#if defined(_MSC_VER)
+# define setmode _setmode
+# define stat    _stat
+# define chmod   _chmod
+# define getcwd  _getcwd
+# define putenv  _putenv
+# define S_IXUSR _S_IEXEC
+# ifndef _INTPTR_T_DEFINED
+#  define _INTPTR_T_DEFINED
+#  define intptr_t int
+# endif
+#elif defined(__MINGW32__)
+# define setmode _setmode
+# define stat    _stat
+# define chmod   _chmod
+# define getcwd  _getcwd
+# define putenv  _putenv
+#elif defined(__CYGWIN__)
+# define HAVE_SETENV
+# define FOPEN_WB "wb"
+/* #elif defined (other platforms) ... */
+#endif
 #if defined(PATH_MAX)
 # define LT_PATHMAX PATH_MAX
 …
 #endif
+#ifdef _MSC_VER
+# define S_IXUSR _S_IEXEC
+# define stat _stat
+# ifndef _INTPTR_T_DEFINED
+#  define intptr_t int
+# endif
+#endif
+/* path handling portability macros */
 #ifndef DIR_SEPARATOR
 # define DIR_SEPARATOR '/'
 …
 #endif /* PATH_SEPARATOR_2 */
-#ifdef __CYGWIN__
-# define FOPEN_WB "wb"
-#endif
 #ifndef FOPEN_WB
 # define FOPEN_WB "w"
 …
 } while (0)
+#undef LTWRAPPER_DEBUGPRINTF
+#if defined DEBUGWRAPPER
+# define LTWRAPPER_DEBUGPRINTF(args) ltwrapper_debugprintf args
+static void
+ltwrapper_debugprintf (const char *fmt, ...)
+{
+    va_list args;
+    va_start (args, fmt);
+    (void) vfprintf (stderr, fmt, args);
+    va_end (args);
+}
+#if defined(LT_DEBUGWRAPPER)
+static int lt_debug = 1;
 #else
+# define LTWRAPPER_DEBUGPRINTF(args)
+static int lt_debug = 0;
 #endif
 const char *program_name = NULL;
+const char *program_name = "libtool-wrapper"; /* in case xstrdup fails */
 void *xmalloc (size_t num);
 …
 int check_executable (const char *path);
 char *strendzap (char *str, const char *pat);
+void lt_fatal (const char *message, ...);
+void lt_debugprintf (const char *file, int line, const char *fmt, ...);
+void lt_fatal (const char *file, int line, const char *message, ...);
+static const char *nonnull (const char *s);
+static const char *nonempty (const char *s);
 void lt_setenv (const char *name, const char *value);
 char *lt_extend_str (const char *orig_value, const char *add, int to_end);
-void lt_opt_process_env_set (const char *arg);
-void lt_opt_process_env_prepend (const char *arg);
-void lt_opt_process_env_append (const char *arg);
-int lt_split_name_value (const char *arg, char** name, char** value);
 void lt_update_exe_path (const char *name, const char *value);
 void lt_update_lib_path (const char *name, const char *value);
+static const char *script_text_part1 =
+char **prepare_spawn (char **argv);
+void lt_dump_script (FILE *f);
 EOF
-            func_emit_wrapper_part1 yes |
-                $SED -e 's/\([\\"]\)/\\\1/g' \
-                     -e 's/^/  "/' -e 's/$/\\n"/'
-            echo ";"
             cat <<EOF
+static const char *script_text_part2 =
+EOF
+            func_emit_wrapper_part2 yes |
+                $SED -e 's/\([\\"]\)/\\\1/g' \
+                     -e 's/^/  "/' -e 's/$/\\n"/'
+            echo ";"
+            cat <<EOF
+const char * MAGIC_EXE = "$magic_exe";
+volatile const char * MAGIC_EXE = "$magic_exe";
 const char * LIB_PATH_VARNAME = "$shlibpath_var";
 EOF
             if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
               func_to_host_pathlist "$temp_rpath"
+              func_to_host_path "$temp_rpath"
               cat <<EOF
 const char * LIB_PATH_VALUE   = "$func_to_host_pathlist_result";
+const char * LIB_PATH_VALUE   = "$func_to_host_path_result";
 EOF
             else
 …
             if test -n "$dllsearchpath"; then
               func_to_host_pathlist "$dllsearchpath:"
+              func_to_host_path "$dllsearchpath:"
               cat <<EOF
 const char * EXE_PATH_VARNAME = "PATH";
 const char * EXE_PATH_VALUE   = "$func_to_host_pathlist_result";
+const char * EXE_PATH_VALUE   = "$func_to_host_path_result";
 EOF
             else
 …
 #define LTWRAPPER_OPTION_PREFIX         "--lt-"
+#define LTWRAPPER_OPTION_PREFIX_LENGTH  5
+static const size_t opt_prefix_len         = LTWRAPPER_OPTION_PREFIX_LENGTH;
 static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;
 static const char *dumpscript_opt       = LTWRAPPER_OPTION_PREFIX "dump-script";
+static const size_t env_set_opt_len     = LTWRAPPER_OPTION_PREFIX_LENGTH + 7;
+static const char *env_set_opt          = LTWRAPPER_OPTION_PREFIX "env-set";
+  /* argument is putenv-style "foo=bar", value of foo is set to bar */
+static const size_t env_prepend_opt_len = LTWRAPPER_OPTION_PREFIX_LENGTH + 11;
+static const char *env_prepend_opt      = LTWRAPPER_OPTION_PREFIX "env-prepend";
+  /* argument is putenv-style "foo=bar", new value of foo is bar${foo} */
+static const size_t env_append_opt_len  = LTWRAPPER_OPTION_PREFIX_LENGTH + 10;
+static const char *env_append_opt       = LTWRAPPER_OPTION_PREFIX "env-append";
+  /* argument is putenv-style "foo=bar", new value of foo is ${foo}bar */
+static const char *debug_opt            = LTWRAPPER_OPTION_PREFIX "debug";
 int
 …
   program_name = (char *) xstrdup (base_name (argv[0]));
+  LTWRAPPER_DEBUGPRINTF (("(main) argv[0]      : %s\n", argv[0]));
+  LTWRAPPER_DEBUGPRINTF (("(main) program_name : %s\n", program_name));
+  /* very simple arg parsing; don't want to rely on getopt */
+  newargz = XMALLOC (char *, argc + 1);
+  /* very simple arg parsing; don't want to rely on getopt
+   * also, copy all non cwrapper options to newargz, except
+   * argz[0], which is handled differently
+   */
+  newargc=0;
   for (i = 1; i < argc; i++)
+    {
 …
             cat <<"EOF"
+          printf ("%s", script_text_part1);
+          printf ("%s", script_text_part2);
+          lt_dump_script (stdout);
           return 0;
+        }
+      if (strcmp (argv[i], debug_opt) == 0)
+        {
+          lt_debug = 1;
+          continue;
+        }
+      if (strcmp (argv[i], ltwrapper_option_prefix) == 0)
+        {
+          /* however, if there is an option in the LTWRAPPER_OPTION_PREFIX
+             namespace, but it is not one of the ones we know about and
+             have already dealt with, above (inluding dump-script), then
+             report an error. Otherwise, targets might begin to believe
+             they are allowed to use options in the LTWRAPPER_OPTION_PREFIX
+             namespace. The first time any user complains about this, we'll
+             need to make LTWRAPPER_OPTION_PREFIX a configure-time option
+             or a configure.ac-settable value.
+           */
+          lt_fatal (__FILE__, __LINE__,
+                    "unrecognized %s option: '%s'",
+                    ltwrapper_option_prefix, argv[i]);
+        }
+      /* otherwise ... */
+      newargz[++newargc] = xstrdup (argv[i]);
+    }
+  newargz = XMALLOC (char *, argc + 1);
+  newargz[++newargc] = NULL;
+EOF
+            cat <<EOF
+  /* The GNU banner must be the first non-error debug message */
+  lt_debugprintf (__FILE__, __LINE__, "libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\n");
+EOF
+            cat <<"EOF"
+  lt_debugprintf (__FILE__, __LINE__, "(main) argv[0]: %s\n", argv[0]);
+  lt_debugprintf (__FILE__, __LINE__, "(main) program_name: %s\n", program_name);
   tmp_pathspec = find_executable (argv[0]);
   if (tmp_pathspec == NULL)
+    lt_fatal ("Couldn't find %s", argv[0]);
+  LTWRAPPER_DEBUGPRINTF (("(main) found exe (before symlink chase) at : %s\n",
+                          tmp_pathspec));
+    lt_fatal (__FILE__, __LINE__, "couldn't find %s", argv[0]);
+  lt_debugprintf (__FILE__, __LINE__,
+                  "(main) found exe (before symlink chase) at: %s\n",
+                  tmp_pathspec);
   actual_cwrapper_path = chase_symlinks (tmp_pathspec);
+  LTWRAPPER_DEBUGPRINTF (("(main) found exe (after symlink chase) at : %s\n",
+                          actual_cwrapper_path));
+  lt_debugprintf (__FILE__, __LINE__,
+                  "(main) found exe (after symlink chase) at: %s\n",
+                  actual_cwrapper_path);
   XFREE (tmp_pathspec);
   actual_cwrapper_name = xstrdup( base_name (actual_cwrapper_path));
+  actual_cwrapper_name = xstrdup (base_name (actual_cwrapper_path));
   strendzap (actual_cwrapper_path, actual_cwrapper_name);
 …
   tmp_pathspec = 0;
+  LTWRAPPER_DEBUGPRINTF (("(main) libtool target name: %s\n",
+                          target_name));
+  lt_debugprintf (__FILE__, __LINE__,
+                  "(main) libtool target name: %s\n",
+                  target_name);
 EOF
 …
   lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */
   lt_setenv ("DUALCASE", "1");  /* for MSK sh */
+  /* Update the DLL searchpath.  EXE_PATH_VALUE ($dllsearchpath) must
+     be prepended before (that is, appear after) LIB_PATH_VALUE ($temp_rpath)
+     because on Windows, both *_VARNAMEs are PATH but uninstalled
+     libraries must come first. */
+  lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);
   lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);
+  lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);
+  newargc=0;
+  for (i = 1; i < argc; i++)
+    {
+      if (strncmp (argv[i], env_set_opt, env_set_opt_len) == 0)
+        {
+          if (argv[i][env_set_opt_len] == '=')
+            {
+              const char *p = argv[i] + env_set_opt_len + 1;
+              lt_opt_process_env_set (p);
+            }
+          else if (argv[i][env_set_opt_len] == '\0' && i + 1 < argc)
+            {
+              lt_opt_process_env_set (argv[++i]); /* don't copy */
+            }
+          else
+            lt_fatal ("%s missing required argument", env_set_opt);
+          continue;
+        }
+      if (strncmp (argv[i], env_prepend_opt, env_prepend_opt_len) == 0)
+        {
+          if (argv[i][env_prepend_opt_len] == '=')
+            {
+              const char *p = argv[i] + env_prepend_opt_len + 1;
+              lt_opt_process_env_prepend (p);
+            }
+          else if (argv[i][env_prepend_opt_len] == '\0' && i + 1 < argc)
+            {
+              lt_opt_process_env_prepend (argv[++i]); /* don't copy */
+            }
+          else
+            lt_fatal ("%s missing required argument", env_prepend_opt);
+          continue;
+        }
+      if (strncmp (argv[i], env_append_opt, env_append_opt_len) == 0)
+        {
+          if (argv[i][env_append_opt_len] == '=')
+            {
+              const char *p = argv[i] + env_append_opt_len + 1;
+              lt_opt_process_env_append (p);
+            }
+          else if (argv[i][env_append_opt_len] == '\0' && i + 1 < argc)
+            {
+              lt_opt_process_env_append (argv[++i]); /* don't copy */
+            }
+          else
+            lt_fatal ("%s missing required argument", env_append_opt);
+          continue;
+        }
+      if (strncmp (argv[i], ltwrapper_option_prefix, opt_prefix_len) == 0)
+        {
+          /* however, if there is an option in the LTWRAPPER_OPTION_PREFIX
+             namespace, but it is not one of the ones we know about and
+             have already dealt with, above (inluding dump-script), then
+             report an error. Otherwise, targets might begin to believe
+             they are allowed to use options in the LTWRAPPER_OPTION_PREFIX
+             namespace. The first time any user complains about this, we'll
+             need to make LTWRAPPER_OPTION_PREFIX a configure-time option
+             or a configure.ac-settable value.
+           */
+          lt_fatal ("Unrecognized option in %s namespace: '%s'",
+                    ltwrapper_option_prefix, argv[i]);
+        }
+      /* otherwise ... */
+      newargz[++newargc] = xstrdup (argv[i]);
+    }
+  newargz[++newargc] = NULL;
+  LTWRAPPER_DEBUGPRINTF     (("(main) lt_argv_zero : %s\n", (lt_argv_zero ? lt_argv_zero : "<NULL>")));
+  lt_debugprintf (__FILE__, __LINE__, "(main) lt_argv_zero: %s\n",
+                  nonnull (lt_argv_zero));
   for (i = 0; i < newargc; i++)
+    {
+      LTWRAPPER_DEBUGPRINTF (("(main) newargz[%d]   : %s\n", i, (newargz[i] ? newargz[i] : "<NULL>")));
+      lt_debugprintf (__FILE__, __LINE__, "(main) newargz[%d]: %s\n",
+                      i, nonnull (newargz[i]));
+    }
 …
                 cat <<"EOF"
   /* execv doesn't actually work on mingw as expected on unix */
+  newargz = prepare_spawn (newargz);
   rval = _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);
   if (rval == -1)
+    {
       /* failed to start process */
+      LTWRAPPER_DEBUGPRINTF (("(main) failed to launch target \"%s\": errno = %d\n", lt_argv_zero, errno));
+      lt_debugprintf (__FILE__, __LINE__,
+                      "(main) failed to launch target \"%s\": %s\n",
+                      lt_argv_zero, nonnull (strerror (errno)));
       return 127;
+    }
 …
   void *p = (void *) malloc (num);
   if (!p)
     lt_fatal ("Memory exhausted");
+    lt_fatal (__FILE__, __LINE__, "memory exhausted");
   return p;
 …
   struct stat st;
   LTWRAPPER_DEBUGPRINTF (("(check_executable)  : %s\n",
                           path ? (*path ? path : "EMPTY!") : "NULL!"));
+  lt_debugprintf (__FILE__, __LINE__, "(check_executable): %s\n",
+                  nonempty (path));
   if ((!path) || (!*path))
     return 0;
 …
   struct stat st;
   LTWRAPPER_DEBUGPRINTF (("(make_executable)   : %s\n",
                           path ? (*path ? path : "EMPTY!") : "NULL!"));
+  lt_debugprintf (__FILE__, __LINE__, "(make_executable): %s\n",
+                  nonempty (path));
   if ((!path) || (!*path))
     return 0;
 …
   char *concat_name;
   LTWRAPPER_DEBUGPRINTF (("(find_executable)   : %s\n",
                           wrapper ? (*wrapper ? wrapper : "EMPTY!") : "NULL!"));
+  lt_debugprintf (__FILE__, __LINE__, "(find_executable): %s\n",
+                  nonempty (wrapper));
   if ((wrapper == NULL) || (*wrapper == '\0'))
 …
                   /* empty path: current directory */
                   if (getcwd (tmp, LT_PATHMAX) == NULL)
+                    lt_fatal ("getcwd failed");
+                    lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
+                              nonnull (strerror (errno)));
                   tmp_len = strlen (tmp);
                   concat_name =
 …
   /* Relative path | not found in path: prepend cwd */
   if (getcwd (tmp, LT_PATHMAX) == NULL)
+    lt_fatal ("getcwd failed");
+    lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
+              nonnull (strerror (errno)));
   tmp_len = strlen (tmp);
   concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
 …
   while (strlen (tmp_pathspec) && !has_symlinks)
+    {
+      LTWRAPPER_DEBUGPRINTF (("checking path component for symlinks: %s\n",
+                              tmp_pathspec));
+      lt_debugprintf (__FILE__, __LINE__,
+                      "checking path component for symlinks: %s\n",
+                      tmp_pathspec);
       if (lstat (tmp_pathspec, &s) == 0)
+        {
 …
       else
+        {
+          char *errstr = strerror (errno);
+          lt_fatal ("Error accessing file %s (%s)", tmp_pathspec, errstr);
+          lt_fatal (__FILE__, __LINE__,
+                    "error accessing file \"%s\": %s",
+                    tmp_pathspec, nonnull (strerror (errno)));
+        }
+    }
 …
   if (tmp_pathspec == 0)
+    {
+      lt_fatal ("Could not follow symlinks for %s", pathspec);
+      lt_fatal (__FILE__, __LINE__,
+                "could not follow symlinks for %s", pathspec);
+    }
   return xstrdup (tmp_pathspec);
 …
+}
+void
+lt_debugprintf (const char *file, int line, const char *fmt, ...)
+{
+  va_list args;
+  if (lt_debug)
+    {
+      (void) fprintf (stderr, "%s:%s:%d: ", program_name, file, line);
+      va_start (args, fmt);
+      (void) vfprintf (stderr, fmt, args);
+      va_end (args);
+    }
+}
 static void
+lt_error_core (int exit_status, const char *mode,
+lt_error_core (int exit_status, const char *file,
+               int line, const char *mode,
                const char *message, va_list ap)
+{
   fprintf (stderr, "%s: %s: ", program_name, mode);
+  fprintf (stderr, "%s:%s:%d: %s: ", program_name, file, line, mode);
   vfprintf (stderr, message, ap);
   fprintf (stderr, ".\n");
 …
 void
 lt_fatal (const char *message, ...)
+lt_fatal (const char *file, int line, const char *message, ...)
+{
   va_list ap;
   va_start (ap, message);
   lt_error_core (EXIT_FAILURE, "FATAL", message, ap);
+  lt_error_core (EXIT_FAILURE, file, line, "FATAL", message, ap);
   va_end (ap);
+}
+static const char *
+nonnull (const char *s)
+{
+  return s ? s : "(null)";
+}
+static const char *
+nonempty (const char *s)
+{
+  return (s && !*s) ? "(empty)" : nonnull (s);
+}
 …
 lt_setenv (const char *name, const char *value)
+{
   LTWRAPPER_DEBUGPRINTF (("(lt_setenv) setting '%s' to '%s'\n",
                           (name ? name : "<NULL>"),
                           (value ? value : "<NULL>")));
+  lt_debugprintf (__FILE__, __LINE__,
+                  "(lt_setenv) setting '%s' to '%s'\n",
+                  nonnull (name), nonnull (value));
+  {
 #ifdef HAVE_SETENV
 …
+}
-int
-lt_split_name_value (const char *arg, char** name, char** value)
+{
-  const char *p;
-  int len;
-  if (!arg || !*arg)
-    return 1;
-  p = strchr (arg, (int)'=');
-  if (!p)
-    return 1;
-  *value = xstrdup (++p);
-  len = strlen (arg) - strlen (*value);
-  *name = XMALLOC (char, len);
-  strncpy (*name, arg, len-1);
-  (*name)[len - 1] = '\0';
-  return 0;
+}
-void
-lt_opt_process_env_set (const char *arg)
+{
-  char *name = NULL;
-  char *value = NULL;
-  if (lt_split_name_value (arg, &name, &value) != 0)
+    {
-      XFREE (name);
-      XFREE (value);
-      lt_fatal ("bad argument for %s: '%s'", env_set_opt, arg);
+    }
-  lt_setenv (name, value);
-  XFREE (name);
-  XFREE (value);
+}
-void
-lt_opt_process_env_prepend (const char *arg)
+{
-  char *name = NULL;
-  char *value = NULL;
-  char *new_value = NULL;
-  if (lt_split_name_value (arg, &name, &value) != 0)
+    {
-      XFREE (name);
-      XFREE (value);
-      lt_fatal ("bad argument for %s: '%s'", env_prepend_opt, arg);
+    }
-  new_value = lt_extend_str (getenv (name), value, 0);
-  lt_setenv (name, new_value);
-  XFREE (new_value);
-  XFREE (name);
-  XFREE (value);
+}
-void
-lt_opt_process_env_append (const char *arg)
+{
-  char *name = NULL;
-  char *value = NULL;
-  char *new_value = NULL;
-  if (lt_split_name_value (arg, &name, &value) != 0)
+    {
-      XFREE (name);
-      XFREE (value);
-      lt_fatal ("bad argument for %s: '%s'", env_append_opt, arg);
+    }
-  new_value = lt_extend_str (getenv (name), value, 1);
-  lt_setenv (name, new_value);
-  XFREE (new_value);
-  XFREE (name);
-  XFREE (value);
+}
 void
 lt_update_exe_path (const char *name, const char *value)
+{
   LTWRAPPER_DEBUGPRINTF (("(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
                           (name ? name : "<NULL>"),
                           (value ? value : "<NULL>")));
+  lt_debugprintf (__FILE__, __LINE__,
+                  "(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
+                  nonnull (name), nonnull (value));
   if (name && *name && value && *value)
 …
 lt_update_lib_path (const char *name, const char *value)
+{
   LTWRAPPER_DEBUGPRINTF (("(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
                           (name ? name : "<NULL>"),
                           (value ? value : "<NULL>")));
+  lt_debugprintf (__FILE__, __LINE__,
+                  "(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
+                  nonnull (name), nonnull (value));
   if (name && *name && value && *value)
 …
+}
 EOF
+            case $host_os in
+              mingw*)
+                cat <<"EOF"
+/* Prepares an argument vector before calling spawn().
+   Note that spawn() does not by itself call the command interpreter
+     (getenv ("COMSPEC") != NULL ? getenv ("COMSPEC") :
+      ({ OSVERSIONINFO v; v.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
+         GetVersionEx(&v);
+         v.dwPlatformId == VER_PLATFORM_WIN32_NT;
+      }) ? "cmd.exe" : "command.com").
+   Instead it simply concatenates the arguments, separated by ' ', and calls
+   CreateProcess().  We must quote the arguments since Win32 CreateProcess()
+   interprets characters like ' ', '\t', '\\', '"' (but not '<' and '>') in a
+   special way:
+   - Space and tab are interpreted as delimiters. They are not treated as
+     delimiters if they are surrounded by double quotes: "...".
+   - Unescaped double quotes are removed from the input. Their only effect is
+     that within double quotes, space and tab are treated like normal
+     characters.
+   - Backslashes not followed by double quotes are not special.
+   - But 2*n+1 backslashes followed by a double quote become
+     n backslashes followed by a double quote (n >= 0):
+       \" -> "
+       \\\" -> \"
+       \\\\\" -> \\"
+ */
+#define SHELL_SPECIAL_CHARS "\"\\ \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"
+#define SHELL_SPACE_CHARS " \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"
+char **
+prepare_spawn (char **argv)
+{
+  size_t argc;
+  char **new_argv;
+  size_t i;
+  /* Count number of arguments.  */
+  for (argc = 0; argv[argc] != NULL; argc++)
+    ;
+  /* Allocate new argument vector.  */
+  new_argv = XMALLOC (char *, argc + 1);
+  /* Put quoted arguments into the new argument vector.  */
+  for (i = 0; i < argc; i++)
+    {
+      const char *string = argv[i];
+      if (string[0] == '\0')
+        new_argv[i] = xstrdup ("\"\"");
+      else if (strpbrk (string, SHELL_SPECIAL_CHARS) != NULL)
+        {
+          int quote_around = (strpbrk (string, SHELL_SPACE_CHARS) != NULL);
+          size_t length;
+          unsigned int backslashes;
+          const char *s;
+          char *quoted_string;
+          char *p;
+          length = 0;
+          backslashes = 0;
+          if (quote_around)
+            length++;
+          for (s = string; *s != '\0'; s++)
+            {
+              char c = *s;
+              if (c == '"')
+                length += backslashes + 1;
+              length++;
+              if (c == '\\')
+                backslashes++;
+              else
+                backslashes = 0;
+            }
+          if (quote_around)
+            length += backslashes + 1;
+          quoted_string = XMALLOC (char, length + 1);
+          p = quoted_string;
+          backslashes = 0;
+          if (quote_around)
+            *p++ = '"';
+          for (s = string; *s != '\0'; s++)
+            {
+              char c = *s;
+              if (c == '"')
+                {
+                  unsigned int j;
+                  for (j = backslashes + 1; j > 0; j--)
+                    *p++ = '\\';
+                }
+              *p++ = c;
+              if (c == '\\')
+                backslashes++;
+              else
+                backslashes = 0;
+            }
+          if (quote_around)
+            {
+              unsigned int j;
+              for (j = backslashes; j > 0; j--)
+                *p++ = '\\';
+              *p++ = '"';
+            }
+          *p = '\0';
+          new_argv[i] = quoted_string;
+        }
+      else
+        new_argv[i] = (char *) string;
+    }
+  new_argv[argc] = NULL;
+  return new_argv;
+}
+EOF
+                ;;
+            esac
+            cat <<"EOF"
+void lt_dump_script (FILE* f)
+{
+EOF
+            func_emit_wrapper yes |
+              $SED -n -e '
+s/^\(.\{79\}\)\(..*\)/\1\
+\2/
+h
+s/\([\\"]\)/\\\1/g
+s/$/\\n/
+s/\([^\n]*\).*/  fputs ("\1", f);/p
+g
+D'
+            cat <<"EOF"
+}
+EOF
+}
 # end: func_emit_cwrapperexe_src
+# func_win32_import_lib_p ARG
+# True if ARG is an import lib, as indicated by $file_magic_cmd
+func_win32_import_lib_p ()
+{
+    $opt_debug
+    case `eval $file_magic_cmd \"\$1\" 2>/dev/null | $SED -e 10q` in
+    *import*) : ;;
+    *) false ;;
+    esac
+}
 # func_mode_link arg...
 …
     avoid_version=no
+    bindir=
     dlfiles=
     dlprefiles=
 …
         case $prev in
+        bindir)
+          bindir="$arg"
+          prev=
+          continue
+          ;;
         dlfiles|dlprefiles)
           if test "$preload" = no; then
 …
           *)
             if test "$prev" = dlfiles; then
               dlfiles="$dlfiles $arg"
+              func_append dlfiles " $arg"
             else
               dlprefiles="$dlprefiles $arg"
+              func_append dlprefiles " $arg"
             fi
             prev=
 …
               case "$deplibs " in
                 *" $qarg.ltframework "*) ;;
                 *) deplibs="$deplibs $qarg.ltframework" # this is fixed later
+                *) func_append deplibs " $qarg.ltframework" # this is fixed later
                    ;;
               esac
 …
             for fil in `cat "$save_arg"`
             do
 #             moreargs="$moreargs $fil"
+#             func_append moreargs " $fil"
               arg=$fil
               # A libtool-controlled object.
 …
                   if test "$prev" = dlfiles; then
                     if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
                       dlfiles="$dlfiles $pic_object"
+                      func_append dlfiles " $pic_object"
                       prev=
                       continue
 …
                   if test "$prev" = dlprefiles; then
                     # Preload the old-style object.
                     dlprefiles="$dlprefiles $pic_object"
+                    func_append dlprefiles " $pic_object"
                     prev=
                   fi
 …
             case "$rpath " in
             *" $arg "*) ;;
             *) rpath="$rpath $arg" ;;
+            *) func_append rpath " $arg" ;;
             esac
           else
             case "$xrpath " in
             *" $arg "*) ;;
             *) xrpath="$xrpath $arg" ;;
+            *) func_append xrpath " $arg" ;;
             esac
           fi
 …
           ;;
         weak)
           weak_libs="$weak_libs $arg"
+          func_append weak_libs " $arg"
           prev=
           continue
           ;;
         xcclinker)
           linker_flags="$linker_flags $qarg"
           compiler_flags="$compiler_flags $qarg"
+          func_append linker_flags " $qarg"
+          func_append compiler_flags " $qarg"
           prev=
           func_append compile_command " $qarg"
 …
           ;;
         xcompiler)
           compiler_flags="$compiler_flags $qarg"
+          func_append compiler_flags " $qarg"
           prev=
           func_append compile_command " $qarg"
 …
           ;;
         xlinker)
           linker_flags="$linker_flags $qarg"
           compiler_flags="$compiler_flags $wl$qarg"
+          func_append linker_flags " $qarg"
+          func_append compiler_flags " $wl$qarg"
           prev=
           func_append compile_command " $wl$qarg"
 …
         ;;
+      -bindir)
+        prev=bindir
+        continue
+        ;;
       -dlopen)
         prev=dlfiles
 …
       -L*)
+        func_stripname '-L' '' "$arg"
+        dir=$func_stripname_result
+        if test -z "$dir"; then
+        func_stripname "-L" '' "$arg"
+        if test -z "$func_stripname_result"; then
           if test "$#" -gt 0; then
             func_fatal_error "require no space between \`-L' and \`$1'"
 …
           fi
         fi
+        func_resolve_sysroot "$func_stripname_result"
+        dir=$func_resolve_sysroot_result
         # We need an absolute path.
         case $dir in
 …
         esac
         case "$deplibs " in
+        *" -L$dir "*) ;;
+        *" -L$dir "* | *" $arg "*)
+          # Will only happen for absolute or sysroot arguments
+          ;;
         *)
+          deplibs="$deplibs -L$dir"
+          lib_search_path="$lib_search_path $dir"
+          # Preserve sysroot, but never include relative directories
+          case $dir in
+            [\\/]* | [A-Za-z]:[\\/]* | =*) func_append deplibs " $arg" ;;
+            *) func_append deplibs " -L$dir" ;;
+          esac
+          func_append lib_search_path " $dir"
           ;;
         esac
         case $host in
         *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
           testbindir=`$ECHO "X$dir" | $Xsed -e 's*/lib$*/bin*'`
+          testbindir=`$ECHO "$dir" | $SED 's*/lib$*/bin*'`
           case :$dllsearchpath: in
           *":$dir:"*) ;;
           ::) dllsearchpath=$dir;;
           *) dllsearchpath="$dllsearchpath:$dir";;
+          *) func_append dllsearchpath ":$dir";;
           esac
           case :$dllsearchpath: in
           *":$testbindir:"*) ;;
           ::) dllsearchpath=$testbindir;;
           *) dllsearchpath="$dllsearchpath:$testbindir";;
+          *) func_append dllsearchpath ":$testbindir";;
           esac
           ;;
 …
         if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
           case $host in
           *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc*)
+          *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc* | *-*-haiku*)
             # These systems don't actually have a C or math library (as such)
             continue
 …
           *-*-rhapsody* | *-*-darwin1.[012])
             # Rhapsody C and math libraries are in the System framework
             deplibs="$deplibs System.ltframework"
+            func_append deplibs " System.ltframework"
             continue
             ;;
 …
          esac
         fi
         deplibs="$deplibs $arg"
+        func_append deplibs " $arg"
         continue
         ;;
 …
       # classes, name mangling, and exception handling.
       # Darwin uses the -arch flag to determine output architecture.
       -model|-arch|-isysroot)
         compiler_flags="$compiler_flags $arg"
+      -model|-arch|-isysroot|--sysroot)
+        func_append compiler_flags " $arg"
         func_append compile_command " $arg"
         func_append finalize_command " $arg"
 …
         ;;
+      -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
+        compiler_flags="$compiler_flags $arg"
+      -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \
+      |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*)
+        func_append compiler_flags " $arg"
         func_append compile_command " $arg"
         func_append finalize_command " $arg"
         case "$new_inherited_linker_flags " in
             *" $arg "*) ;;
             * ) new_inherited_linker_flags="$new_inherited_linker_flags $arg" ;;
+            * ) func_append new_inherited_linker_flags " $arg" ;;
         esac
         continue
 …
         case $dir in
         [\\/]* | [A-Za-z]:[\\/]*) ;;
+        =*)
+          func_stripname '=' '' "$dir"
+          dir=$lt_sysroot$func_stripname_result
+          ;;
         *)
           func_fatal_error "only absolute run-paths are allowed"
 …
         case "$xrpath " in
         *" $dir "*) ;;
         *) xrpath="$xrpath $dir" ;;
+        *) func_append xrpath " $dir" ;;
         esac
         continue
 …
           IFS="$save_ifs"
           func_quote_for_eval "$flag"
           arg="$arg $wl$func_quote_for_eval_result"
           compiler_flags="$compiler_flags $func_quote_for_eval_result"
+          func_append arg " $func_quote_for_eval_result"
+          func_append compiler_flags " $func_quote_for_eval_result"
         done
         IFS="$save_ifs"
 …
           IFS="$save_ifs"
           func_quote_for_eval "$flag"
           arg="$arg $wl$func_quote_for_eval_result"
           compiler_flags="$compiler_flags $wl$func_quote_for_eval_result"
           linker_flags="$linker_flags $func_quote_for_eval_result"
+          func_append arg " $wl$func_quote_for_eval_result"
+          func_append compiler_flags " $wl$func_quote_for_eval_result"
+          func_append linker_flags " $func_quote_for_eval_result"
         done
         IFS="$save_ifs"
 …
         ;;
+      # -64, -mips[0-9] enable 64-bit mode on the SGI compiler
+      # -r[0-9][0-9]* specifies the processor on the SGI compiler
+      # -xarch=*, -xtarget=* enable 64-bit mode on the Sun compiler
+      # +DA*, +DD* enable 64-bit mode on the HP compiler
+      # -q* pass through compiler args for the IBM compiler
+      # -m*, -t[45]*, -txscale* pass through architecture-specific
+      # compiler args for GCC
+      # -F/path gives path to uninstalled frameworks, gcc on darwin
+      # -p, -pg, --coverage, -fprofile-* pass through profiling flag for GCC
+      # @file GCC response files
+      # Flags to be passed through unchanged, with rationale:
+      # -64, -mips[0-9]      enable 64-bit mode for the SGI compiler
+      # -r[0-9][0-9]*        specify processor for the SGI compiler
+      # -xarch=*, -xtarget=* enable 64-bit mode for the Sun compiler
+      # +DA*, +DD*           enable 64-bit mode for the HP compiler
+      # -q*                  compiler args for the IBM compiler
+      # -m*, -t[45]*, -txscale* architecture-specific flags for GCC
+      # -F/path              path to uninstalled frameworks, gcc on darwin
+      # -p, -pg, --coverage, -fprofile-*  profiling flags for GCC
+      # @file                GCC response files
+      # -tp=*                Portland pgcc target processor selection
+      # --sysroot=*          for sysroot support
+      # -O*, -flto*, -fwhopr*, -fuse-linker-plugin GCC link-time optimization
       -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
+      -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*)
+      -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*|-tp=*|--sysroot=*| \
+      -O*|-flto*|-fwhopr*|-fuse-linker-plugin)
         func_quote_for_eval "$arg"
         arg="$func_quote_for_eval_result"
         func_append compile_command " $arg"
         func_append finalize_command " $arg"
         compiler_flags="$compiler_flags $arg"
+        func_append compiler_flags " $arg"
         continue
         ;;
 …
       *.$objext)
         # A standard object.
         objs="$objs $arg"
+        func_append objs " $arg"
         ;;
 …
             if test "$prev" = dlfiles; then
               if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
                 dlfiles="$dlfiles $pic_object"
+                func_append dlfiles " $pic_object"
                 prev=
                 continue
 …
             if test "$prev" = dlprefiles; then
               # Preload the old-style object.
               dlprefiles="$dlprefiles $pic_object"
+              func_append dlprefiles " $pic_object"
               prev=
             fi
 …
       *.$libext)
         # An archive.
         deplibs="$deplibs $arg"
         old_deplibs="$old_deplibs $arg"
+        func_append deplibs " $arg"
+        func_append old_deplibs " $arg"
         continue
         ;;
 …
         # A libtool-controlled library.
+        func_resolve_sysroot "$arg"
         if test "$prev" = dlfiles; then
           # This library was specified with -dlopen.
           dlfiles="$dlfiles $arg"
+          func_append dlfiles " $func_resolve_sysroot_result"
           prev=
         elif test "$prev" = dlprefiles; then
           # The library was specified with -dlpreopen.
           dlprefiles="$dlprefiles $arg"
+          func_append dlprefiles " $func_resolve_sysroot_result"
           prev=
         else
           deplibs="$deplibs $arg"
+          func_append deplibs " $func_resolve_sysroot_result"
         fi
         continue
 …
     if test -n "$shlibpath_var"; then
       # get the directories listed in $shlibpath_var
       eval shlib_search_path=\`\$ECHO \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`
+      eval shlib_search_path=\`\$ECHO \"\${$shlibpath_var}\" \| \$SED \'s/:/ /g\'\`
     else
       shlib_search_path=
 …
     func_dirname "$output" "/" ""
     output_objdir="$func_dirname_result$objdir"
+    func_to_tool_file "$output_objdir/"
+    tool_output_objdir=$func_to_tool_file_result
     # Create the object directory.
     func_mkdir_p "$output_objdir"
 …
     # that are linked more than once (e.g. -la -lb -la)
     for deplib in $deplibs; do
       if $opt_duplicate_deps ; then
+      if $opt_preserve_dup_deps ; then
         case "$libs " in
         *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
+        *" $deplib "*) func_append specialdeplibs " $deplib" ;;
         esac
       fi
       libs="$libs $deplib"
+      func_append libs " $deplib"
     done
 …
         for pre_post_dep in $predeps $postdeps; do
           case "$pre_post_deps " in
           *" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;;
+          *" $pre_post_dep "*) func_append specialdeplibs " $pre_post_deps" ;;
           esac
           pre_post_deps="$pre_post_deps $pre_post_dep"
+          func_append pre_post_deps " $pre_post_dep"
         done
       fi
 …
           # Ignore non-libtool-libs
           dependency_libs=
+          func_resolve_sysroot "$lib"
           case $lib in
           *.la) func_source "$lib" ;;
+          *.la) func_source "$func_resolve_sysroot_result" ;;
           esac
 …
           # has declared as weak libs
           for deplib in $dependency_libs; do
+            deplib_base=`$ECHO "X$deplib" | $Xsed -e "$basename"`
+            func_basename "$deplib"
+            deplib_base=$func_basename_result
             case " $weak_libs " in
             *" $deplib_base "*) ;;
             *) deplibs="$deplibs $deplib" ;;
+            *) func_append deplibs " $deplib" ;;
             esac
           done
 …
         found=no
         case $deplib in
+        -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
+        -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \
+        |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*)
           if test "$linkmode,$pass" = "prog,link"; then
             compile_deplibs="$deplib $compile_deplibs"
             finalize_deplibs="$deplib $finalize_deplibs"
           else
             compiler_flags="$compiler_flags $deplib"
+            func_append compiler_flags " $deplib"
             if test "$linkmode" = lib ; then
                 case "$new_inherited_linker_flags " in
                     *" $deplib "*) ;;
                     * ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;
+                    * ) func_append new_inherited_linker_flags " $deplib" ;;
                 esac
             fi
 …
                 case "$new_inherited_linker_flags " in
                     *" $deplib "*) ;;
                     * ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;
+                    * ) func_append new_inherited_linker_flags " $deplib" ;;
                 esac
             fi
 …
             newdependency_libs="$deplib $newdependency_libs"
             func_stripname '-L' '' "$deplib"
+            newlib_search_path="$newlib_search_path $func_stripname_result"
+            func_resolve_sysroot "$func_stripname_result"
+            func_append newlib_search_path " $func_resolve_sysroot_result"
             ;;
           prog)
 …
             fi
             func_stripname '-L' '' "$deplib"
+            newlib_search_path="$newlib_search_path $func_stripname_result"
+            func_resolve_sysroot "$func_stripname_result"
+            func_append newlib_search_path " $func_resolve_sysroot_result"
             ;;
           *)
 …
           if test "$pass" = link; then
             func_stripname '-R' '' "$deplib"
+            dir=$func_stripname_result
+            func_resolve_sysroot "$func_stripname_result"
+            dir=$func_resolve_sysroot_result
             # Make sure the xrpath contains only unique directories.
             case "$xrpath " in
             *" $dir "*) ;;
             *) xrpath="$xrpath $dir" ;;
+            *) func_append xrpath " $dir" ;;
             esac
           fi
 …
           continue
           ;;
+        *.la) lib="$deplib" ;;
+        *.la)
+          func_resolve_sysroot "$deplib"
+          lib=$func_resolve_sysroot_result
+          ;;
         *.$libext)
           if test "$pass" = conv; then
 …
                   set dummy $deplibs_check_method; shift
                   match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
                   if eval "\$ECHO \"X$deplib\"" 2>/dev/null | $Xsed -e 10q \
+                  if eval "\$ECHO \"$deplib\"" 2>/dev/null | $SED 10q \
                     | $EGREP "$match_pattern_regex" > /dev/null; then
                     valid_a_lib=yes
 …
               esac
               if test "$valid_a_lib" != yes; then
                 $ECHO
+                echo
                 $ECHO "*** Warning: Trying to link with static lib archive $deplib."
                 $ECHO "*** I have the capability to make that library automatically link in when"
                 $ECHO "*** you link to this library.  But I can only do this if you have a"
                 $ECHO "*** shared version of the library, which you do not appear to have"
                 $ECHO "*** because the file extensions .$libext of this argument makes me believe"
                 $ECHO "*** that it is just a static archive that I should not use here."
+                echo "*** I have the capability to make that library automatically link in when"
+                echo "*** you link to this library.  But I can only do this if you have a"
+                echo "*** shared version of the library, which you do not appear to have"
+                echo "*** because the file extensions .$libext of this argument makes me believe"
+                echo "*** that it is just a static archive that I should not use here."
               else
                 $ECHO
+                echo
                 $ECHO "*** Warning: Linking the shared library $output against the"
                 $ECHO "*** static library $deplib is not portable!"
 …
               # If there is no dlopen support or we're linking statically,
               # we need to preload.
               newdlprefiles="$newdlprefiles $deplib"
+              func_append newdlprefiles " $deplib"
               compile_deplibs="$deplib $compile_deplibs"
               finalize_deplibs="$deplib $finalize_deplibs"
             else
               newdlfiles="$newdlfiles $deplib"
+              func_append newdlfiles " $deplib"
             fi
           fi
 …
         # Convert "-framework foo" to "foo.ltframework"
         if test -n "$inherited_linker_flags"; then
           tmp_inherited_linker_flags=`$ECHO "X$inherited_linker_flags" | $Xsed -e 's/-framework \([^ $]*\)/\1.ltframework/g'`
+          tmp_inherited_linker_flags=`$ECHO "$inherited_linker_flags" | $SED 's/-framework \([^ $]*\)/\1.ltframework/g'`
           for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do
             case " $new_inherited_linker_flags " in
               *" $tmp_inherited_linker_flag "*) ;;
               *) new_inherited_linker_flags="$new_inherited_linker_flags $tmp_inherited_linker_flag";;
+              *) func_append new_inherited_linker_flags " $tmp_inherited_linker_flag";;
             esac
           done
         fi
         dependency_libs=`$ECHO "X $dependency_libs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
+        dependency_libs=`$ECHO " $dependency_libs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
         if test "$linkmode,$pass" = "lib,link" ||
            test "$linkmode,$pass" = "prog,scan" ||
            { test "$linkmode" != prog && test "$linkmode" != lib; }; then
           test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
           test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
+          test -n "$dlopen" && func_append dlfiles " $dlopen"
+          test -n "$dlpreopen" && func_append dlprefiles " $dlpreopen"
         fi
 …
             fi
             # It is a libtool convenience library, so add in its objects.
             convenience="$convenience $ladir/$objdir/$old_library"
             old_convenience="$old_convenience $ladir/$objdir/$old_library"
+            func_append convenience " $ladir/$objdir/$old_library"
+            func_append old_convenience " $ladir/$objdir/$old_library"
           elif test "$linkmode" != prog && test "$linkmode" != lib; then
             func_fatal_error "\`$lib' is not a convenience library"
 …
           for deplib in $dependency_libs; do
             deplibs="$deplib $deplibs"
             if $opt_duplicate_deps ; then
+            if $opt_preserve_dup_deps ; then
               case "$tmp_libs " in
               *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
+              *" $deplib "*) func_append specialdeplibs " $deplib" ;;
               esac
             fi
             tmp_libs="$tmp_libs $deplib"
+            func_append tmp_libs " $deplib"
           done
           continue
 …
         # Get the name of the library we link against.
         linklib=
+        for l in $old_library $library_names; do
+          linklib="$l"
+        done
+        if test -n "$old_library" &&
+           { test "$prefer_static_libs" = yes ||
+             test "$prefer_static_libs,$installed" = "built,no"; }; then
+          linklib=$old_library
+        else
+          for l in $old_library $library_names; do
+            linklib="$l"
+          done
+        fi
         if test -z "$linklib"; then
           func_fatal_error "cannot find name of link library for \`$lib'"
 …
             # dependent libraries so libltdl's deplib preloader doesn't
             # bomb out in the load deplibs phase.
             dlprefiles="$dlprefiles $lib $dependency_libs"
+            func_append dlprefiles " $lib $dependency_libs"
           else
             newdlfiles="$newdlfiles $lib"
+            func_append newdlfiles " $lib"
           fi
           continue
 …
         # Find the relevant object directory and library name.
         if test "X$installed" = Xyes; then
           if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
+          if test ! -f "$lt_sysroot$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
             func_warning "library \`$lib' was moved."
             dir="$ladir"
 …
             libdir="$abs_ladir"
           else
             dir="$libdir"
             absdir="$libdir"
+            dir="$lt_sysroot$libdir"
+            absdir="$lt_sysroot$libdir"
           fi
           test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
 …
             absdir="$abs_ladir"
             # Remove this search path later
             notinst_path="$notinst_path $abs_ladir"
+            func_append notinst_path " $abs_ladir"
           else
             dir="$ladir/$objdir"
             absdir="$abs_ladir/$objdir"
             # Remove this search path later
             notinst_path="$notinst_path $abs_ladir"
+            func_append notinst_path " $abs_ladir"
           fi
         fi # $installed = yes
 …
             func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'"
           fi
+          # Prefer using a static library (so that no silly _DYNAMIC symbols
+          # are required to link).
+          if test -n "$old_library"; then
+            newdlprefiles="$newdlprefiles $dir/$old_library"
+            # Keep a list of preopened convenience libraries to check
+            # that they are being used correctly in the link pass.
+            test -z "$libdir" && \
+                dlpreconveniencelibs="$dlpreconveniencelibs $dir/$old_library"
+          # Otherwise, use the dlname, so that lt_dlopen finds it.
+          elif test -n "$dlname"; then
+            newdlprefiles="$newdlprefiles $dir/$dlname"
+          else
+            newdlprefiles="$newdlprefiles $dir/$linklib"
+          fi
+          case "$host" in
+            # special handling for platforms with PE-DLLs.
+            *cygwin* | *mingw* | *cegcc* )
+              # Linker will automatically link against shared library if both
+              # static and shared are present.  Therefore, ensure we extract
+              # symbols from the import library if a shared library is present
+              # (otherwise, the dlopen module name will be incorrect).  We do
+              # this by putting the import library name into $newdlprefiles.
+              # We recover the dlopen module name by 'saving' the la file
+              # name in a special purpose variable, and (later) extracting the
+              # dlname from the la file.
+              if test -n "$dlname"; then
+                func_tr_sh "$dir/$linklib"
+                eval "libfile_$func_tr_sh_result=\$abs_ladir/\$laname"
+                func_append newdlprefiles " $dir/$linklib"
+              else
+                func_append newdlprefiles " $dir/$old_library"
+                # Keep a list of preopened convenience libraries to check
+                # that they are being used correctly in the link pass.
+                test -z "$libdir" && \
+                  func_append dlpreconveniencelibs " $dir/$old_library"
+              fi
+            ;;
+            * )
+              # Prefer using a static library (so that no silly _DYNAMIC symbols
+              # are required to link).
+              if test -n "$old_library"; then
+                func_append newdlprefiles " $dir/$old_library"
+                # Keep a list of preopened convenience libraries to check
+                # that they are being used correctly in the link pass.
+                test -z "$libdir" && \
+                  func_append dlpreconveniencelibs " $dir/$old_library"
+              # Otherwise, use the dlname, so that lt_dlopen finds it.
+              elif test -n "$dlname"; then
+                func_append newdlprefiles " $dir/$dlname"
+              else
+                func_append newdlprefiles " $dir/$linklib"
+              fi
+            ;;
+          esac
         fi # $pass = dlpreopen
 …
         if test "$linkmode" = prog && test "$pass" != link; then
           newlib_search_path="$newlib_search_path $ladir"
+          func_append newlib_search_path " $ladir"
           deplibs="$lib $deplibs"
 …
             case $deplib in
             -L*) func_stripname '-L' '' "$deplib"
+                 newlib_search_path="$newlib_search_path $func_stripname_result"
+                 func_resolve_sysroot "$func_stripname_result"
+                 func_append newlib_search_path " $func_resolve_sysroot_result"
                  ;;
             esac
 …
               newdependency_libs="$deplib $newdependency_libs"
             fi
             if $opt_duplicate_deps ; then
+            if $opt_preserve_dup_deps ; then
               case "$tmp_libs " in
               *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
+              *" $deplib "*) func_append specialdeplibs " $deplib" ;;
               esac
             fi
             tmp_libs="$tmp_libs $deplib"
+            func_append tmp_libs " $deplib"
           done # for deplib
           continue
 …
               case "$temp_rpath:" in
               *"$absdir:"*) ;;
               *) temp_rpath="$temp_rpath$absdir:" ;;
+              *) func_append temp_rpath "$absdir:" ;;
               esac
             fi
 …
               case "$compile_rpath " in
               *" $absdir "*) ;;
               *) compile_rpath="$compile_rpath $absdir"
+              *) func_append compile_rpath " $absdir" ;;
               esac
               ;;
 …
               case "$finalize_rpath " in
               *" $libdir "*) ;;
               *) finalize_rpath="$finalize_rpath $libdir"
+              *) func_append finalize_rpath " $libdir" ;;
               esac
               ;;
 …
           *cygwin* | *mingw* | *cegcc*)
               # No point in relinking DLLs because paths are not encoded
               notinst_deplibs="$notinst_deplibs $lib"
+              func_append notinst_deplibs " $lib"
               need_relink=no
             ;;
           *)
             if test "$installed" = no; then
               notinst_deplibs="$notinst_deplibs $lib"
+              func_append notinst_deplibs " $lib"
               need_relink=yes
             fi
 …
           done
           if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then
             $ECHO
+            echo
             if test "$linkmode" = prog; then
               $ECHO "*** Warning: Linking the executable $output against the loadable module"
 …
               case "$compile_rpath " in
               *" $absdir "*) ;;
               *) compile_rpath="$compile_rpath $absdir"
+              *) func_append compile_rpath " $absdir" ;;
               esac
               ;;
 …
               case "$finalize_rpath " in
               *" $libdir "*) ;;
               *) finalize_rpath="$finalize_rpath $libdir"
+              *) func_append finalize_rpath " $libdir" ;;
               esac
               ;;
 …
           fi # test -n "$old_archive_from_expsyms_cmds"
           if test "$linkmode" = prog || test "$mode" != relink; then
+          if test "$linkmode" = prog || test "$opt_mode" != relink; then
             add_shlibpath=
             add_dir=
 …
                         $ECHO "*** Warning: lib $linklib is a module, not a shared library"
                         if test -z "$old_library" ; then
                           $ECHO
                           $ECHO "*** And there doesn't seem to be a static archive available"
                           $ECHO "*** The link will probably fail, sorry"
+                          echo
+                          echo "*** And there doesn't seem to be a static archive available"
+                          echo "*** The link will probably fail, sorry"
                         else
                           add="$dir/$old_library"
 …
                 add="$dir/$linklib"
               elif test "$hardcode_minus_L" = yes; then
                 add_dir="-L$dir"
+                add_dir="-L$absdir"
                 # Try looking first in the location we're being installed to.
                 if test -n "$inst_prefix_dir"; then
                   case $libdir in
                     [\\/]*)
                       add_dir="$add_dir -L$inst_prefix_dir$libdir"
+                      func_append add_dir " -L$inst_prefix_dir$libdir"
                       ;;
                   esac
 …
               case :$compile_shlibpath: in
               *":$add_shlibpath:"*) ;;
               *) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
+              *) func_append compile_shlibpath "$add_shlibpath:" ;;
               esac
             fi
 …
                 case :$finalize_shlibpath: in
                 *":$libdir:"*) ;;
                 *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
+                *) func_append finalize_shlibpath "$libdir:" ;;
                 esac
               fi
 …
           fi
           if test "$linkmode" = prog || test "$mode" = relink; then
+          if test "$linkmode" = prog || test "$opt_mode" = relink; then
             add_shlibpath=
             add_dir=
 …
               case :$finalize_shlibpath: in
               *":$libdir:"*) ;;
               *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
+              *) func_append finalize_shlibpath "$libdir:" ;;
               esac
               add="-l$name"
 …
                 case $libdir in
                   [\\/]*)
                     add_dir="$add_dir -L$inst_prefix_dir$libdir"
+                    func_append add_dir " -L$inst_prefix_dir$libdir"
                     ;;
                 esac
 …
             # Just print a warning and add the library to dependency_libs so
             # that the program can be linked against the static library.
             $ECHO
+            echo
             $ECHO "*** Warning: This system can not link to static lib archive $lib."
             $ECHO "*** I have the capability to make that library automatically link in when"
             $ECHO "*** you link to this library.  But I can only do this if you have a"
             $ECHO "*** shared version of the library, which you do not appear to have."
+            echo "*** I have the capability to make that library automatically link in when"
+            echo "*** you link to this library.  But I can only do this if you have a"
+            echo "*** shared version of the library, which you do not appear to have."
             if test "$module" = yes; then
               $ECHO "*** But as you try to build a module library, libtool will still create "
               $ECHO "*** a static module, that should work as long as the dlopening application"
               $ECHO "*** is linked with the -dlopen flag to resolve symbols at runtime."
+              echo "*** But as you try to build a module library, libtool will still create "
+              echo "*** a static module, that should work as long as the dlopening application"
+              echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
               if test -z "$global_symbol_pipe"; then
                 $ECHO
                 $ECHO "*** However, this would only work if libtool was able to extract symbol"
                 $ECHO "*** lists from a program, using \`nm' or equivalent, but libtool could"
                 $ECHO "*** not find such a program.  So, this module is probably useless."
                 $ECHO "*** \`nm' from GNU binutils and a full rebuild may help."
+                echo
+                echo "*** However, this would only work if libtool was able to extract symbol"
+                echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
+                echo "*** not find such a program.  So, this module is probably useless."
+                echo "*** \`nm' from GNU binutils and a full rebuild may help."
               fi
               if test "$build_old_libs" = no; then
 …
                    case " $xrpath " in
                    *" $temp_xrpath "*) ;;
                    *) xrpath="$xrpath $temp_xrpath";;
+                   *) func_append xrpath " $temp_xrpath";;
                    esac;;
               *) temp_deplibs="$temp_deplibs $libdir";;
+              *) func_append temp_deplibs " $libdir";;
               esac
             done
 …
           fi
           newlib_search_path="$newlib_search_path $absdir"
+          func_append newlib_search_path " $absdir"
           # Link against this library
           test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
 …
           for deplib in $dependency_libs; do
             newdependency_libs="$deplib $newdependency_libs"
+            if $opt_duplicate_deps ; then
+            case $deplib in
+              -L*) func_stripname '-L' '' "$deplib"
+                   func_resolve_sysroot "$func_stripname_result";;
+              *) func_resolve_sysroot "$deplib" ;;
+            esac
+            if $opt_preserve_dup_deps ; then
               case "$tmp_libs " in
+              *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
+              *" $func_resolve_sysroot_result "*)
+                func_append specialdeplibs " $func_resolve_sysroot_result" ;;
               esac
             fi
             tmp_libs="$tmp_libs $deplib"
+            func_append tmp_libs " $func_resolve_sysroot_result"
           done
 …
             # Add the search paths of all dependency libraries
             for deplib in $dependency_libs; do
+              path=
               case $deplib in
               -L*) path="$deplib" ;;
               *.la)
+                func_resolve_sysroot "$deplib"
+                deplib=$func_resolve_sysroot_result
                 func_dirname "$deplib" "" "."
                 dir="$func_dirname_result"
+                dir=$func_dirname_result
                 # We need an absolute path.
                 case $dir in
 …
                           darwin_install_name=`${OTOOL64} -L $depdepl  | awk '{if (NR == 2) {print $1;exit}}'`
                       fi
                       compiler_flags="$compiler_flags ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"
                       linker_flags="$linker_flags -dylib_file ${darwin_install_name}:${depdepl}"
+                      func_append compiler_flags " ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"
+                      func_append linker_flags " -dylib_file ${darwin_install_name}:${depdepl}"
                       path=
                     fi
 …
           finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"
         else
           compiler_flags="$compiler_flags "`$ECHO "X $new_inherited_linker_flags" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
+          compiler_flags="$compiler_flags "`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
         fi
       fi
 …
             case "$lib_search_path " in
             *" $dir "*) ;;
             *) lib_search_path="$lib_search_path $dir" ;;
+            *) func_append lib_search_path " $dir" ;;
             esac
           done
 …
               case " $tmp_libs " in
               *" $deplib "*) ;;
               *) tmp_libs="$tmp_libs $deplib" ;;
+              *) func_append tmp_libs " $deplib" ;;
               esac
               ;;
             *) tmp_libs="$tmp_libs $deplib" ;;
+            *) func_append tmp_libs " $deplib" ;;
             esac
           done
 …
         esac
         if test -n "$i" ; then
           tmp_libs="$tmp_libs $i"
+          func_append tmp_libs " $i"
         fi
       done
 …
       build_libtool_libs=no
       oldlibs="$output"
       objs="$objs$old_deplibs"
+      func_append objs "$old_deplibs"
       ;;
 …
           func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs"
         else
           $ECHO
+          echo
           $ECHO "*** Warning: Linking the shared library $output against the non-libtool"
           $ECHO "*** objects $objs is not portable!"
           libobjs="$libobjs $objs"
+          func_append libobjs " $objs"
         fi
       fi
 …
+          #
           case $version_type in
+          # correct linux to gnu/linux during the next big refactor
           darwin|linux|osf|windows|none)
             func_arith $number_major + $number_minor
 …
             revision="$number_revision"
             ;;
           freebsd-aout|freebsd-elf|sunos)
+          freebsd-aout|freebsd-elf|qnx|sunos)
             current="$number_major"
             revision="$number_minor"
 …
           ;;
         linux)
+        linux) # correct to gnu/linux during the next big refactor
           func_arith $current - $age
           major=.$func_arith_result
 …
           # Make executables depend on our current version.
           verstring="$verstring:${current}.0"
+          func_append verstring ":${current}.0"
           ;;
 …
       func_generate_dlsyms "$libname" "$libname" "yes"
       libobjs="$libobjs $symfileobj"
+      func_append libobjs " $symfileobj"
       test "X$libobjs" = "X " && libobjs=
       if test "$mode" != relink; then
+      if test "$opt_mode" != relink; then
         # Remove our outputs, but don't remove object files since they
         # may have been created when compiling PIC objects.
 …
                  fi
                fi
                removelist="$removelist $p"
+               func_append removelist " $p"
                ;;
             *) ;;
 …
       # Now set the variables for building old libraries.
       if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
         oldlibs="$oldlibs $output_objdir/$libname.$libext"
+        func_append oldlibs " $output_objdir/$libname.$libext"
         # Transform .lo files to .o files.
         oldobjs="$objs "`$ECHO "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`
+        oldobjs="$objs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; $lo2o" | $NL2SP`
       fi
       # Eliminate all temporary directories.
       #for path in $notinst_path; do
       # lib_search_path=`$ECHO "X$lib_search_path " | $Xsed -e "s% $path % %g"`
       # deplibs=`$ECHO "X$deplibs " | $Xsed -e "s% -L$path % %g"`
       # dependency_libs=`$ECHO "X$dependency_libs " | $Xsed -e "s% -L$path % %g"`
+      # lib_search_path=`$ECHO "$lib_search_path " | $SED "s% $path % %g"`
+      # deplibs=`$ECHO "$deplibs " | $SED "s% -L$path % %g"`
+      # dependency_libs=`$ECHO "$dependency_libs " | $SED "s% -L$path % %g"`
       #done
 …
         temp_xrpath=
         for libdir in $xrpath; do
+          temp_xrpath="$temp_xrpath -R$libdir"
+          func_replace_sysroot "$libdir"
+          func_append temp_xrpath " -R$func_replace_sysroot_result"
           case "$finalize_rpath " in
           *" $libdir "*) ;;
           *) finalize_rpath="$finalize_rpath $libdir" ;;
+          *) func_append finalize_rpath " $libdir" ;;
           esac
         done
 …
         case " $dlprefiles $dlfiles " in
         *" $lib "*) ;;
         *) dlfiles="$dlfiles $lib" ;;
+        *) func_append dlfiles " $lib" ;;
         esac
       done
 …
         case "$dlprefiles " in
         *" $lib "*) ;;
         *) dlprefiles="$dlprefiles $lib" ;;
+        *) func_append dlprefiles " $lib" ;;
         esac
       done
 …
         if test -n "$rpath"; then
           case $host in
           *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc*)
+          *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc* | *-*-haiku*)
             # these systems don't actually have a c library (as such)!
             ;;
           *-*-rhapsody* | *-*-darwin1.[012])
             # Rhapsody C library is in the System framework
             deplibs="$deplibs System.ltframework"
+            func_append deplibs " System.ltframework"
             ;;
           *-*-netbsd*)
 …
             # Add libc to deplibs on all other systems if necessary.
             if test "$build_libtool_need_lc" = "yes"; then
               deplibs="$deplibs -lc"
+              func_append deplibs " -lc"
             fi
             ;;
 …
                   case " $predeps $postdeps " in
                   *" $i "*)
                     newdeplibs="$newdeplibs $i"
+                    func_append newdeplibs " $i"
                     i=""
                     ;;
 …
                   deplib_match=$1
                   if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
                     newdeplibs="$newdeplibs $i"
+                    func_append newdeplibs " $i"
                   else
                     droppeddeps=yes
                     $ECHO
+                    echo
                     $ECHO "*** Warning: dynamic linker does not accept needed library $i."
                     $ECHO "*** I have the capability to make that library automatically link in when"
                     $ECHO "*** you link to this library.  But I can only do this if you have a"
                     $ECHO "*** shared version of the library, which I believe you do not have"
                     $ECHO "*** because a test_compile did reveal that the linker did not use it for"
                     $ECHO "*** its dynamic dependency list that programs get resolved with at runtime."
+                    echo "*** I have the capability to make that library automatically link in when"
+                    echo "*** you link to this library.  But I can only do this if you have a"
+                    echo "*** shared version of the library, which I believe you do not have"
+                    echo "*** because a test_compile did reveal that the linker did not use it for"
+                    echo "*** its dynamic dependency list that programs get resolved with at runtime."
                   fi
                 fi
                 ;;
               *)
                 newdeplibs="$newdeplibs $i"
+                func_append newdeplibs " $i"
                 ;;
               esac
 …
                     case " $predeps $postdeps " in
                     *" $i "*)
                       newdeplibs="$newdeplibs $i"
+                      func_append newdeplibs " $i"
                       i=""
                       ;;
 …
                     deplib_match=$1
                     if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
                       newdeplibs="$newdeplibs $i"
+                      func_append newdeplibs " $i"
                     else
                       droppeddeps=yes
                       $ECHO
+                      echo
                       $ECHO "*** Warning: dynamic linker does not accept needed library $i."
                       $ECHO "*** I have the capability to make that library automatically link in when"
                       $ECHO "*** you link to this library.  But I can only do this if you have a"
                       $ECHO "*** shared version of the library, which you do not appear to have"
                       $ECHO "*** because a test_compile did reveal that the linker did not use this one"
                       $ECHO "*** as a dynamic dependency that programs can get resolved with at runtime."
+                      echo "*** I have the capability to make that library automatically link in when"
+                      echo "*** you link to this library.  But I can only do this if you have a"
+                      echo "*** shared version of the library, which you do not appear to have"
+                      echo "*** because a test_compile did reveal that the linker did not use this one"
+                      echo "*** as a dynamic dependency that programs can get resolved with at runtime."
                     fi
                   fi
                 else
                   droppeddeps=yes
                   $ECHO
+                  echo
                   $ECHO "*** Warning!  Library $i is needed by this library but I was not able to"
                   $ECHO "*** make it link in!  You will probably need to install it or some"
                   $ECHO "*** library that it depends on before this library will be fully"
                   $ECHO "*** functional.  Installing it before continuing would be even better."
+                  echo "*** make it link in!  You will probably need to install it or some"
+                  echo "*** library that it depends on before this library will be fully"
+                  echo "*** functional.  Installing it before continuing would be even better."
                 fi
                 ;;
               *)
                 newdeplibs="$newdeplibs $i"
+                func_append newdeplibs " $i"
                 ;;
               esac
 …
                 case " $predeps $postdeps " in
                 *" $a_deplib "*)
                   newdeplibs="$newdeplibs $a_deplib"
+                  func_append newdeplibs " $a_deplib"
                   a_deplib=""
                   ;;
 …
               if test -n "$a_deplib" ; then
                 libname=`eval "\\$ECHO \"$libname_spec\""`
+                if test -n "$file_magic_glob"; then
+                  libnameglob=`func_echo_all "$libname" | $SED -e $file_magic_glob`
+                else
+                  libnameglob=$libname
+                fi
+                test "$want_nocaseglob" = yes && nocaseglob=`shopt -p nocaseglob`
                 for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
+                  potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
+                  if test "$want_nocaseglob" = yes; then
+                    shopt -s nocaseglob
+                    potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
+                    $nocaseglob
+                  else
+                    potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
+                  fi
                   for potent_lib in $potential_libs; do
                       # Follow soft links.
 …
                         case $potliblink in
                         [\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
                         *) potlib=`$ECHO "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
+                        *) potlib=`$ECHO "$potlib" | $SED 's,[^/]*$,,'`"$potliblink";;
                         esac
                       done
 …
                          $SED -e 10q |
                          $EGREP "$file_magic_regex" > /dev/null; then
                         newdeplibs="$newdeplibs $a_deplib"
+                        func_append newdeplibs " $a_deplib"
                         a_deplib=""
                         break 2
 …
               if test -n "$a_deplib" ; then
                 droppeddeps=yes
                 $ECHO
+                echo
                 $ECHO "*** Warning: linker path does not have real file for library $a_deplib."
                 $ECHO "*** I have the capability to make that library automatically link in when"
                 $ECHO "*** you link to this library.  But I can only do this if you have a"
                 $ECHO "*** shared version of the library, which you do not appear to have"
                 $ECHO "*** because I did check the linker path looking for a file starting"
+                echo "*** I have the capability to make that library automatically link in when"
+                echo "*** you link to this library.  But I can only do this if you have a"
+                echo "*** shared version of the library, which you do not appear to have"
+                echo "*** because I did check the linker path looking for a file starting"
                 if test -z "$potlib" ; then
                   $ECHO "*** with $libname but no candidates were found. (...for file magic test)"
 …
             *)
               # Add a -L argument.
               newdeplibs="$newdeplibs $a_deplib"
+              func_append newdeplibs " $a_deplib"
               ;;
             esac
 …
                 case " $predeps $postdeps " in
                 *" $a_deplib "*)
                   newdeplibs="$newdeplibs $a_deplib"
+                  func_append newdeplibs " $a_deplib"
                   a_deplib=""
                   ;;
 …
                   for potent_lib in $potential_libs; do
                     potlib="$potent_lib" # see symlink-check above in file_magic test
                     if eval "\$ECHO \"X$potent_lib\"" 2>/dev/null | $Xsed -e 10q | \
+                    if eval "\$ECHO \"$potent_lib\"" 2>/dev/null | $SED 10q | \
                        $EGREP "$match_pattern_regex" > /dev/null; then
                       newdeplibs="$newdeplibs $a_deplib"
+                      func_append newdeplibs " $a_deplib"
                       a_deplib=""
                       break 2
 …
               if test -n "$a_deplib" ; then
                 droppeddeps=yes
                 $ECHO
+                echo
                 $ECHO "*** Warning: linker path does not have real file for library $a_deplib."
                 $ECHO "*** I have the capability to make that library automatically link in when"
                 $ECHO "*** you link to this library.  But I can only do this if you have a"
                 $ECHO "*** shared version of the library, which you do not appear to have"
                 $ECHO "*** because I did check the linker path looking for a file starting"
+                echo "*** I have the capability to make that library automatically link in when"
+                echo "*** you link to this library.  But I can only do this if you have a"
+                echo "*** shared version of the library, which you do not appear to have"
+                echo "*** because I did check the linker path looking for a file starting"
                 if test -z "$potlib" ; then
                   $ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"
 …
             *)
               # Add a -L argument.
               newdeplibs="$newdeplibs $a_deplib"
+              func_append newdeplibs " $a_deplib"
               ;;
             esac
 …
         none | unknown | *)
           newdeplibs=""
+          tmp_deplibs=`$ECHO "X $deplibs" | $Xsed \
+              -e 's/ -lc$//' -e 's/ -[LR][^ ]*//g'`
+          tmp_deplibs=`$ECHO " $deplibs" | $SED 's/ -lc$//; s/ -[LR][^ ]*//g'`
           if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
             for i in $predeps $postdeps ; do
               # can't use Xsed below, because $i might contain '/'
               tmp_deplibs=`$ECHO "X $tmp_deplibs" | $Xsed -e "s,$i,,"`
+              tmp_deplibs=`$ECHO " $tmp_deplibs" | $SED "s,$i,,"`
             done
           fi
           if $ECHO "X $tmp_deplibs" | $Xsed -e 's/[      ]//g' |
              $GREP . >/dev/null; then
             $ECHO
+          case $tmp_deplibs in
+          *[!\  \ ]*)
+            echo
             if test "X$deplibs_check_method" = "Xnone"; then
               $ECHO "*** Warning: inter-library dependencies are not supported in this platform."
+              echo "*** Warning: inter-library dependencies are not supported in this platform."
             else
               $ECHO "*** Warning: inter-library dependencies are not known to be supported."
+              echo "*** Warning: inter-library dependencies are not known to be supported."
             fi
             $ECHO "*** All declared inter-library dependencies are being dropped."
+            echo "*** All declared inter-library dependencies are being dropped."
             droppeddeps=yes
+          fi
+            ;;
+          esac
           ;;
         esac
 …
         *-*-rhapsody* | *-*-darwin1.[012])
           # On Rhapsody replace the C library with the System framework
           newdeplibs=`$ECHO "X $newdeplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
+          newdeplibs=`$ECHO " $newdeplibs" | $SED 's/ -lc / System.ltframework /'`
           ;;
         esac
 …
         if test "$droppeddeps" = yes; then
           if test "$module" = yes; then
             $ECHO
             $ECHO "*** Warning: libtool could not satisfy all declared inter-library"
+            echo
+            echo "*** Warning: libtool could not satisfy all declared inter-library"
             $ECHO "*** dependencies of module $libname.  Therefore, libtool will create"
             $ECHO "*** a static module, that should work as long as the dlopening"
             $ECHO "*** application is linked with the -dlopen flag."
+            echo "*** a static module, that should work as long as the dlopening"
+            echo "*** application is linked with the -dlopen flag."
             if test -z "$global_symbol_pipe"; then
               $ECHO
               $ECHO "*** However, this would only work if libtool was able to extract symbol"
               $ECHO "*** lists from a program, using \`nm' or equivalent, but libtool could"
               $ECHO "*** not find such a program.  So, this module is probably useless."
               $ECHO "*** \`nm' from GNU binutils and a full rebuild may help."
+              echo
+              echo "*** However, this would only work if libtool was able to extract symbol"
+              echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
+              echo "*** not find such a program.  So, this module is probably useless."
+              echo "*** \`nm' from GNU binutils and a full rebuild may help."
             fi
             if test "$build_old_libs" = no; then
 …
             fi
           else
             $ECHO "*** The inter-library dependencies that have been dropped here will be"
             $ECHO "*** automatically added whenever a program is linked with this library"
             $ECHO "*** or is declared to -dlopen it."
+            echo "*** The inter-library dependencies that have been dropped here will be"
+            echo "*** automatically added whenever a program is linked with this library"
+            echo "*** or is declared to -dlopen it."
             if test "$allow_undefined" = no; then
               $ECHO
               $ECHO "*** Since this library must not contain undefined symbols,"
               $ECHO "*** because either the platform does not support them or"
               $ECHO "*** it was explicitly requested with -no-undefined,"
               $ECHO "*** libtool will only create a static version of it."
+              echo
+              echo "*** Since this library must not contain undefined symbols,"
+              echo "*** because either the platform does not support them or"
+              echo "*** it was explicitly requested with -no-undefined,"
+              echo "*** libtool will only create a static version of it."
               if test "$build_old_libs" = no; then
                 oldlibs="$output_objdir/$libname.$libext"
 …
       case $host in
         *-*-darwin*)
           newdeplibs=`$ECHO "X $newdeplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
           new_inherited_linker_flags=`$ECHO "X $new_inherited_linker_flags" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
           deplibs=`$ECHO "X $deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
+          newdeplibs=`$ECHO " $newdeplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
+          new_inherited_linker_flags=`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
+          deplibs=`$ECHO " $deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
           ;;
       esac
 …
           case " $deplibs " in
           *" -L$path/$objdir "*)
             new_libs="$new_libs -L$path/$objdir" ;;
+            func_append new_libs " -L$path/$objdir" ;;
           esac
           ;;
 …
           case " $new_libs " in
           *" $deplib "*) ;;
           *) new_libs="$new_libs $deplib" ;;
+          *) func_append new_libs " $deplib" ;;
           esac
           ;;
         *) new_libs="$new_libs $deplib" ;;
+        *) func_append new_libs " $deplib" ;;
         esac
       done
 …
       # Test again, we may have decided not to build it any more
       if test "$build_libtool_libs" = yes; then
+        # Remove ${wl} instances when linking with ld.
+        # FIXME: should test the right _cmds variable.
+        case $archive_cmds in
+          *\$LD\ *) wl= ;;
+        esac
         if test "$hardcode_into_libs" = yes; then
           # Hardcode the library paths
 …
           dep_rpath=
           rpath="$finalize_rpath"
           test "$mode" != relink && rpath="$compile_rpath$rpath"
+          test "$opt_mode" != relink && rpath="$compile_rpath$rpath"
           for libdir in $rpath; do
             if test -n "$hardcode_libdir_flag_spec"; then
               if test -n "$hardcode_libdir_separator"; then
+                func_replace_sysroot "$libdir"
+                libdir=$func_replace_sysroot_result
                 if test -z "$hardcode_libdirs"; then
                   hardcode_libdirs="$libdir"
 …
                     ;;
                   *)
                     hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
+                    func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
                     ;;
                   esac
 …
               else
                 eval flag=\"$hardcode_libdir_flag_spec\"
                 dep_rpath="$dep_rpath $flag"
+                func_append dep_rpath " $flag"
               fi
             elif test -n "$runpath_var"; then
               case "$perm_rpath " in
               *" $libdir "*) ;;
               *) perm_rpath="$perm_rpath $libdir" ;;
+              *) func_append perm_rpath " $libdir" ;;
               esac
             fi
 …
              test -n "$hardcode_libdirs"; then
             libdir="$hardcode_libdirs"
+            if test -n "$hardcode_libdir_flag_spec_ld"; then
+              eval dep_rpath=\"$hardcode_libdir_flag_spec_ld\"
+            else
+              eval dep_rpath=\"$hardcode_libdir_flag_spec\"
+            fi
+            eval "dep_rpath=\"$hardcode_libdir_flag_spec\""
           fi
           if test -n "$runpath_var" && test -n "$perm_rpath"; then
 …
             rpath=
             for dir in $perm_rpath; do
               rpath="$rpath$dir:"
+              func_append rpath "$dir:"
             done
             eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
 …
         shlibpath="$finalize_shlibpath"
         test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
+        test "$opt_mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
         if test -n "$shlibpath"; then
           eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
 …
         for link
         do
           linknames="$linknames $link"
+          func_append linknames " $link"
         done
         # Use standard objects if they are pic
         test -z "$pic_flag" && libobjs=`$ECHO "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
+        test -z "$pic_flag" && libobjs=`$ECHO "$libobjs" | $SP2NL | $SED "$lo2o" | $NL2SP`
         test "X$libobjs" = "X " && libobjs=
 …
           $opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp"
           export_symbols="$output_objdir/$libname.uexp"
           delfiles="$delfiles $export_symbols"
+          func_append delfiles " $export_symbols"
         fi
 …
             cmds=$export_symbols_cmds
             save_ifs="$IFS"; IFS='~'
             for cmd in $cmds; do
+            for cmd1 in $cmds; do
               IFS="$save_ifs"
+              eval cmd=\"$cmd\"
+              func_len " $cmd"
+              len=$func_len_result
+              if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
+              # Take the normal branch if the nm_file_list_spec branch
+              # doesn't work or if tool conversion is not needed.
+              case $nm_file_list_spec~$to_tool_file_cmd in
+                *~func_convert_file_noop | *~func_convert_file_msys_to_w32 | ~*)
+                  try_normal_branch=yes
+                  eval cmd=\"$cmd1\"
+                  func_len " $cmd"
+                  len=$func_len_result
+                  ;;
+                *)
+                  try_normal_branch=no
+                  ;;
+              esac
+              if test "$try_normal_branch" = yes \
+                 && { test "$len" -lt "$max_cmd_len" \
+                      || test "$max_cmd_len" -le -1; }
+              then
                 func_show_eval "$cmd" 'exit $?'
+                skipped_export=false
+              elif test -n "$nm_file_list_spec"; then
+                func_basename "$output"
+                output_la=$func_basename_result
+                save_libobjs=$libobjs
+                save_output=$output
+                output=${output_objdir}/${output_la}.nm
+                func_to_tool_file "$output"
+                libobjs=$nm_file_list_spec$func_to_tool_file_result
+                func_append delfiles " $output"
+                func_verbose "creating $NM input file list: $output"
+                for obj in $save_libobjs; do
+                  func_to_tool_file "$obj"
+                  $ECHO "$func_to_tool_file_result"
+                done > "$output"
+                eval cmd=\"$cmd1\"
+                func_show_eval "$cmd" 'exit $?'
+                output=$save_output
+                libobjs=$save_libobjs
                 skipped_export=false
               else
 …
           tmp_export_symbols="$export_symbols"
           test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
           $opt_dry_run || eval '$ECHO "X$include_expsyms" | $Xsed | $SP2NL >> "$tmp_export_symbols"'
+          $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
         fi
 …
           # isn't a blessed tool.
           $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
           delfiles="$delfiles $export_symbols $output_objdir/$libname.filter"
+          func_append delfiles " $export_symbols $output_objdir/$libname.filter"
           export_symbols=$output_objdir/$libname.def
           $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
 …
           *" $test_deplib "*) ;;
           *)
             tmp_deplibs="$tmp_deplibs $test_deplib"
+            func_append tmp_deplibs " $test_deplib"
             ;;
           esac
 …
           else
             gentop="$output_objdir/${outputname}x"
             generated="$generated $gentop"
+            func_append generated " $gentop"
             func_extract_archives $gentop $convenience
             libobjs="$libobjs $func_extract_archives_result"
+            func_append libobjs " $func_extract_archives_result"
             test "X$libobjs" = "X " && libobjs=
           fi
 …
         if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
           eval flag=\"$thread_safe_flag_spec\"
           linker_flags="$linker_flags $flag"
+          func_append linker_flags " $flag"
         fi
         # Make a backup of the uninstalled library when relinking
         if test "$mode" = relink; then
+        if test "$opt_mode" = relink; then
           $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $?
         fi
 …
           fi
           save_output=$output
+          output_la=`$ECHO "X$output" | $Xsed -e "$basename"`
+          func_basename "$output"
+          output_la=$func_basename_result
           # Clear the reloadable object creation command queue and
 …
             output=${output_objdir}/${output_la}.lnkscript
             func_verbose "creating GNU ld script: $output"
             $ECHO 'INPUT (' > $output
+            echo 'INPUT (' > $output
             for obj in $save_libobjs
             do
+              $ECHO "$obj" >> $output
+              func_to_tool_file "$obj"
+              $ECHO "$func_to_tool_file_result" >> $output
             done
+            $ECHO ')' >> $output
+            delfiles="$delfiles $output"
+            echo ')' >> $output
+            func_append delfiles " $output"
+            func_to_tool_file "$output"
+            output=$func_to_tool_file_result
           elif test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X; then
             output=${output_objdir}/${output_la}.lnk
 …
             for obj
             do
+              $ECHO "$obj" >> $output
+              func_to_tool_file "$obj"
+              $ECHO "$func_to_tool_file_result" >> $output
             done
+            delfiles="$delfiles $output"
+            output=$firstobj\"$file_list_spec$output\"
+            func_append delfiles " $output"
+            func_to_tool_file "$output"
+            output=$firstobj\"$file_list_spec$func_to_tool_file_result\"
           else
             if test -n "$save_libobjs"; then
 …
                   if test "$k" -eq 1 ; then
                     # The first file doesn't have a previous command to add.
+                    eval concat_cmds=\"$reload_cmds $objlist $last_robj\"
+                    reload_objs=$objlist
+                    eval concat_cmds=\"$reload_cmds\"
                   else
                     # All subsequent reloadable object files will link in
                     # the last one created.
+                    eval concat_cmds=\"\$concat_cmds~$reload_cmds $objlist $last_robj~\$RM $last_robj\"
+                    reload_objs="$objlist $last_robj"
+                    eval concat_cmds=\"\$concat_cmds~$reload_cmds~\$RM $last_robj\"
                   fi
                   last_robj=$output_objdir/$output_la-${k}.$objext
 …
                   k=$func_arith_result
                   output=$output_objdir/$output_la-${k}.$objext
                   objlist=$obj
+                  objlist=" $obj"
                   func_len " $last_robj"
                   func_arith $len0 + $func_len_result
 …
               # files will link in the last one created.
               test -z "$concat_cmds" || concat_cmds=$concat_cmds~
+              eval concat_cmds=\"\${concat_cmds}$reload_cmds $objlist $last_robj\"
+              reload_objs="$objlist $last_robj"
+              eval concat_cmds=\"\${concat_cmds}$reload_cmds\"
               if test -n "$last_robj"; then
                 eval concat_cmds=\"\${concat_cmds}~\$RM $last_robj\"
               fi
               delfiles="$delfiles $output"
+              func_append delfiles " $output"
             else
 …
                 # Restore the uninstalled library and exit
                 if test "$mode" = relink; then
+                if test "$opt_mode" = relink; then
                   ( cd "$output_objdir" && \
                     $RM "${realname}T" && \
 …
               tmp_export_symbols="$export_symbols"
               test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
               $opt_dry_run || eval '$ECHO "X$include_expsyms" | $Xsed | $SP2NL >> "$tmp_export_symbols"'
+              $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
             fi
 …
               # isn't a blessed tool.
               $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
               delfiles="$delfiles $export_symbols $output_objdir/$libname.filter"
+              func_append delfiles " $export_symbols $output_objdir/$libname.filter"
               export_symbols=$output_objdir/$libname.def
               $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
 …
         if test -n "$dlprefiles"; then
           gentop="$output_objdir/${outputname}x"
           generated="$generated $gentop"
+          func_append generated " $gentop"
           func_extract_archives $gentop $dlprefiles
           libobjs="$libobjs $func_extract_archives_result"
+          func_append libobjs " $func_extract_archives_result"
           test "X$libobjs" = "X " && libobjs=
         fi
 …
             # Restore the uninstalled library and exit
             if test "$mode" = relink; then
+            if test "$opt_mode" = relink; then
               ( cd "$output_objdir" && \
                 $RM "${realname}T" && \
 …
         # Restore the uninstalled library and exit
         if test "$mode" = relink; then
+        if test "$opt_mode" = relink; then
           $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $?
 …
         if test -n "$whole_archive_flag_spec"; then
           eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"
           reload_conv_objs=$reload_objs\ `$ECHO "X$tmp_whole_archive_flags" | $Xsed -e 's|,| |g'`
+          reload_conv_objs=$reload_objs\ `$ECHO "$tmp_whole_archive_flags" | $SED 's|,| |g'`
         else
           gentop="$output_objdir/${obj}x"
           generated="$generated $gentop"
+          func_append generated " $gentop"
           func_extract_archives $gentop $convenience
 …
       fi
+      # If we're not building shared, we need to use non_pic_objs
+      test "$build_libtool_libs" != yes && libobjs="$non_pic_objects"
       # Create the old-style object.
       reload_objs="$objs$old_deplibs "`$ECHO "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}$'/d' -e '/\.lib$/d' -e "$lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test
+      reload_objs="$objs$old_deplibs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; /\.lib$/d; $lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test
       output="$obj"
 …
       *-*-rhapsody* | *-*-darwin1.[012])
         # On Rhapsody replace the C library is the System framework
         compile_deplibs=`$ECHO "X $compile_deplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
         finalize_deplibs=`$ECHO "X $finalize_deplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
+        compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's/ -lc / System.ltframework /'`
+        finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's/ -lc / System.ltframework /'`
         ;;
       esac
 …
           case ${MACOSX_DEPLOYMENT_TARGET-10.0} in
 .[0123])
               compile_command="$compile_command ${wl}-bind_at_load"
               finalize_command="$finalize_command ${wl}-bind_at_load"
+              func_append compile_command " ${wl}-bind_at_load"
+              func_append finalize_command " ${wl}-bind_at_load"
             ;;
           esac
         fi
         # Time to change all our "foo.ltframework" stuff back to "-framework foo"
         compile_deplibs=`$ECHO "X $compile_deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
         finalize_deplibs=`$ECHO "X $finalize_deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
+        compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
+        finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
         ;;
       esac
 …
           case " $compile_deplibs " in
           *" -L$path/$objdir "*)
             new_libs="$new_libs -L$path/$objdir" ;;
+            func_append new_libs " -L$path/$objdir" ;;
           esac
           ;;
 …
           case " $new_libs " in
           *" $deplib "*) ;;
           *) new_libs="$new_libs $deplib" ;;
+          *) func_append new_libs " $deplib" ;;
           esac
           ;;
         *) new_libs="$new_libs $deplib" ;;
+        *) func_append new_libs " $deplib" ;;
         esac
       done
 …
       compile_command="$compile_command $compile_deplibs"
       finalize_command="$finalize_command $finalize_deplibs"
+      func_append compile_command " $compile_deplibs"
+      func_append finalize_command " $finalize_deplibs"
       if test -n "$rpath$xrpath"; then
 …
           case "$finalize_rpath " in
           *" $libdir "*) ;;
           *) finalize_rpath="$finalize_rpath $libdir" ;;
+          *) func_append finalize_rpath " $libdir" ;;
           esac
         done
 …
                 ;;
               *)
                 hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
+                func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
                 ;;
               esac
 …
           else
             eval flag=\"$hardcode_libdir_flag_spec\"
             rpath="$rpath $flag"
+            func_append rpath " $flag"
           fi
         elif test -n "$runpath_var"; then
           case "$perm_rpath " in
           *" $libdir "*) ;;
           *) perm_rpath="$perm_rpath $libdir" ;;
+          *) func_append perm_rpath " $libdir" ;;
           esac
         fi
 …
           *":$libdir:"*) ;;
           ::) dllsearchpath=$libdir;;
           *) dllsearchpath="$dllsearchpath:$libdir";;
+          *) func_append dllsearchpath ":$libdir";;
           esac
           case :$dllsearchpath: in
           *":$testbindir:"*) ;;
           ::) dllsearchpath=$testbindir;;
           *) dllsearchpath="$dllsearchpath:$testbindir";;
+          *) func_append dllsearchpath ":$testbindir";;
           esac
           ;;
 …
                 ;;
               *)
                 hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
+                func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
                 ;;
               esac
 …
           else
             eval flag=\"$hardcode_libdir_flag_spec\"
             rpath="$rpath $flag"
+            func_append rpath " $flag"
           fi
         elif test -n "$runpath_var"; then
           case "$finalize_perm_rpath " in
           *" $libdir "*) ;;
           *) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;
+          *) func_append finalize_perm_rpath " $libdir" ;;
           esac
         fi
 …
       if test -n "$libobjs" && test "$build_old_libs" = yes; then
         # Transform all the library objects into standard objects.
         compile_command=`$ECHO "X$compile_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
         finalize_command=`$ECHO "X$finalize_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
+        compile_command=`$ECHO "$compile_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
+        finalize_command=`$ECHO "$finalize_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
       fi
 …
       wrappers_required=yes
       case $host in
+      *cegcc* | *mingw32ce*)
+        # Disable wrappers for cegcc and mingw32ce hosts, we are cross compiling anyway.
+        wrappers_required=no
+        ;;
       *cygwin* | *mingw* )
         if test "$build_libtool_libs" != yes; then
           wrappers_required=no
         fi
-        ;;
-      *cegcc)
-        # Disable wrappers for cegcc, we are cross compiling anyway.
-        wrappers_required=no
         ;;
       *)
 …
       if test "$wrappers_required" = no; then
         # Replace the output file specification.
         compile_command=`$ECHO "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
+        compile_command=`$ECHO "$compile_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
         link_command="$compile_command$compile_rpath"
 …
         exit_status=0
         func_show_eval "$link_command" 'exit_status=$?'
+        if test -n "$postlink_cmds"; then
+          func_to_tool_file "$output"
+          postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
+          func_execute_cmds "$postlink_cmds" 'exit $?'
+        fi
         # Delete the generated files.
 …
           rpath=
           for dir in $perm_rpath; do
             rpath="$rpath$dir:"
+            func_append rpath "$dir:"
           done
           compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
 …
           rpath=
           for dir in $finalize_perm_rpath; do
             rpath="$rpath$dir:"
+            func_append rpath "$dir:"
           done
           finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
 …
         link_command="$compile_var$compile_command$compile_rpath"
         # Replace the output file specification.
         link_command=`$ECHO "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
+        link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
         # Delete the old output file.
         $opt_dry_run || $RM $output
         # Link the executable and exit
         func_show_eval "$link_command" 'exit $?'
+        if test -n "$postlink_cmds"; then
+          func_to_tool_file "$output"
+          postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
+          func_execute_cmds "$postlink_cmds" 'exit $?'
+        fi
         exit $EXIT_SUCCESS
       fi
 …
           link_command="$finalize_var$compile_command$finalize_rpath"
           if test "$fast_install" = yes; then
             relink_command=`$ECHO "X$compile_var$compile_command$compile_rpath" | $Xsed -e 's%@OUTPUT@%\$progdir/\$file%g'`
+            relink_command=`$ECHO "$compile_var$compile_command$compile_rpath" | $SED 's%@OUTPUT@%\$progdir/\$file%g'`
           else
             # fast_install is set to needless
 …
       # Replace the output file specification.
       link_command=`$ECHO "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
+      link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
       # Delete the old output files.
 …
       func_show_eval "$link_command" 'exit $?'
+      if test -n "$postlink_cmds"; then
+        func_to_tool_file "$output_objdir/$outputname"
+        postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
+        func_execute_cmds "$postlink_cmds" 'exit $?'
+      fi
       # Now create the wrapper script.
 …
         done
         relink_command="(cd `pwd`; $relink_command)"
+        relink_command=`$ECHO "X$relink_command" | $Xsed -e "$sed_quote_subst"`
+      fi
+      # Quote $ECHO for shipping.
+      if test "X$ECHO" = "X$SHELL $progpath --fallback-echo"; then
+        case $progpath in
+        [\\/]* | [A-Za-z]:[\\/]*) qecho="$SHELL $progpath --fallback-echo";;
+        *) qecho="$SHELL `pwd`/$progpath --fallback-echo";;
+        esac
+        qecho=`$ECHO "X$qecho" | $Xsed -e "$sed_quote_subst"`
+      else
+        qecho=`$ECHO "X$ECHO" | $Xsed -e "$sed_quote_subst"`
+        relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
       fi
 …
           oldobjs="$old_deplibs $non_pic_objects"
           if test "$preload" = yes && test -f "$symfileobj"; then
             oldobjs="$oldobjs $symfileobj"
+            func_append oldobjs " $symfileobj"
           fi
         fi
 …
       if test -n "$addlibs"; then
         gentop="$output_objdir/${outputname}x"
         generated="$generated $gentop"
+        func_append generated " $gentop"
         func_extract_archives $gentop $addlibs
         oldobjs="$oldobjs $func_extract_archives_result"
+        func_append oldobjs " $func_extract_archives_result"
       fi
 …
         if test -n "$dlprefiles"; then
           gentop="$output_objdir/${outputname}x"
           generated="$generated $gentop"
+          func_append generated " $gentop"
           func_extract_archives $gentop $dlprefiles
           oldobjs="$oldobjs $func_extract_archives_result"
+          func_append oldobjs " $func_extract_archives_result"
         fi
 …
+          :
         else
           $ECHO "copying selected object files to avoid basename conflicts..."
+          echo "copying selected object files to avoid basename conflicts..."
           gentop="$output_objdir/${outputname}x"
           generated="$generated $gentop"
+          func_append generated " $gentop"
           func_mkdir_p "$gentop"
           save_oldobjs=$oldobjs
 …
               done
               func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"
               oldobjs="$oldobjs $gentop/$newobj"
+              func_append oldobjs " $gentop/$newobj"
               ;;
             *) oldobjs="$oldobjs $obj" ;;
+            *) func_append oldobjs " $obj" ;;
             esac
           done
         fi
+        func_to_tool_file "$oldlib" func_convert_file_msys_to_w32
+        tool_oldlib=$func_to_tool_file_result
         eval cmds=\"$old_archive_cmds\"
 …
         len=$func_len_result
         if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
+          cmds=$old_archive_cmds
+        elif test -n "$archiver_list_spec"; then
+          func_verbose "using command file archive linking..."
+          for obj in $oldobjs
+          do
+            func_to_tool_file "$obj"
+            $ECHO "$func_to_tool_file_result"
+          done > $output_objdir/$libname.libcmd
+          func_to_tool_file "$output_objdir/$libname.libcmd"
+          oldobjs=" $archiver_list_spec$func_to_tool_file_result"
           cmds=$old_archive_cmds
         else
 …
       # Quote the link command for shipping.
       relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
       relink_command=`$ECHO "X$relink_command" | $Xsed -e "$sed_quote_subst"`
+      relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
       if test "$hardcode_automatic" = yes ; then
         relink_command=
 …
                 func_basename "$deplib"
                 name="$func_basename_result"
+                eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
+                func_resolve_sysroot "$deplib"
+                eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $func_resolve_sysroot_result`
                 test -z "$libdir" && \
                   func_fatal_error "\`$deplib' is not a valid libtool archive"
                 newdependency_libs="$newdependency_libs $libdir/$name"
+                func_append newdependency_libs " ${lt_sysroot:+=}$libdir/$name"
                 ;;
+              *) newdependency_libs="$newdependency_libs $deplib" ;;
+              -L*)
+                func_stripname -L '' "$deplib"
+                func_replace_sysroot "$func_stripname_result"
+                func_append newdependency_libs " -L$func_replace_sysroot_result"
+                ;;
+              -R*)
+                func_stripname -R '' "$deplib"
+                func_replace_sysroot "$func_stripname_result"
+                func_append newdependency_libs " -R$func_replace_sysroot_result"
+                ;;
+              *) func_append newdependency_libs " $deplib" ;;
               esac
             done
 …
                 test -z "$libdir" && \
                   func_fatal_error "\`$lib' is not a valid libtool archive"
                 newdlfiles="$newdlfiles $libdir/$name"
+                func_append newdlfiles " ${lt_sysroot:+=}$libdir/$name"
                 ;;
               *) newdlfiles="$newdlfiles $lib" ;;
+              *) func_append newdlfiles " $lib" ;;
               esac
             done
 …
                 test -z "$libdir" && \
                   func_fatal_error "\`$lib' is not a valid libtool archive"
                 newdlprefiles="$newdlprefiles $libdir/$name"
+                func_append newdlprefiles " ${lt_sysroot:+=}$libdir/$name"
                 ;;
               esac
 …
                 *) abs=`pwd`"/$lib" ;;
               esac
               newdlfiles="$newdlfiles $abs"
+              func_append newdlfiles " $abs"
             done
             dlfiles="$newdlfiles"
 …
                 *) abs=`pwd`"/$lib" ;;
               esac
               newdlprefiles="$newdlprefiles $abs"
+              func_append newdlprefiles " $abs"
             done
             dlprefiles="$newdlprefiles"
 …
           $RM $output
           # place dlname in correct position for cygwin
+          # In fact, it would be nice if we could use this code for all target
+          # systems that can't hard-code library paths into their executables
+          # and that have no shared library path variable independent of PATH,
+          # but it turns out we can't easily determine that from inspecting
+          # libtool variables, so we have to hard-code the OSs to which it
+          # applies here; at the moment, that means platforms that use the PE
+          # object format with DLL files.  See the long comment at the top of
+          # tests/bindir.at for full details.
           tdlname=$dlname
           case $host,$output,$installed,$module,$dlname in
+            *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll) tdlname=../bin/$dlname ;;
+            *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll)
+              # If a -bindir argument was supplied, place the dll there.
+              if test "x$bindir" != x ;
+              then
+                func_relative_path "$install_libdir" "$bindir"
+                tdlname=$func_relative_path_result$dlname
+              else
+                # Otherwise fall back on heuristic.
+                tdlname=../bin/$dlname
+              fi
+              ;;
           esac
           $ECHO > $output "\
 …
+}
 { test "$mode" = link || test "$mode" = relink; } &&
+{ test "$opt_mode" = link || test "$opt_mode" = relink; } &&
     func_mode_link ${1+"$@"}
 …
     do
       case $arg in
       -f) RM="$RM $arg"; rmforce=yes ;;
       -*) RM="$RM $arg" ;;
       *) files="$files $arg" ;;
+      -f) func_append RM " $arg"; rmforce=yes ;;
+      -*) func_append RM " $arg" ;;
+      *) func_append files " $arg" ;;
       esac
     done
 …
     rmdirs=
-    origobjdir="$objdir"
     for file in $files; do
       func_dirname "$file" "" "."
       dir="$func_dirname_result"
       if test "X$dir" = X.; then
         objdir="$origobjdir"
+        odir="$objdir"
       else
         objdir="$dir/$origobjdir"
+        odir="$dir/$objdir"
       fi
       func_basename "$file"
       name="$func_basename_result"
       test "$mode" = uninstall && objdir="$dir"
       # Remember objdir for removal later, being careful to avoid duplicates
       if test "$mode" = clean; then
+      test "$opt_mode" = uninstall && odir="$dir"
+      # Remember odir for removal later, being careful to avoid duplicates
+      if test "$opt_mode" = clean; then
         case " $rmdirs " in
           *" $objdir "*) ;;
           *) rmdirs="$rmdirs $objdir" ;;
+          *" $odir "*) ;;
+          *) func_append rmdirs " $odir" ;;
         esac
       fi
 …
           # Delete the libtool libraries and symlinks.
           for n in $library_names; do
             rmfiles="$rmfiles $objdir/$n"
+            func_append rmfiles " $odir/$n"
           done
           test -n "$old_library" && rmfiles="$rmfiles $objdir/$old_library"
           case "$mode" in
+          test -n "$old_library" && func_append rmfiles " $odir/$old_library"
+          case "$opt_mode" in
           clean)
+            case "  $library_names " in
+            # "  " in the beginning catches empty $dlname
+            case " $library_names " in
             *" $dlname "*) ;;
             *) rmfiles="$rmfiles $objdir/$dlname" ;;
+            *) test -n "$dlname" && func_append rmfiles " $odir/$dlname" ;;
             esac
             test -n "$libdir" && rmfiles="$rmfiles $objdir/$name $objdir/${name}i"
+            test -n "$libdir" && func_append rmfiles " $odir/$name $odir/${name}i"
             ;;
           uninstall)
 …
           if test -n "$pic_object" &&
              test "$pic_object" != none; then
             rmfiles="$rmfiles $dir/$pic_object"
+            func_append rmfiles " $dir/$pic_object"
           fi
 …
           if test -n "$non_pic_object" &&
              test "$non_pic_object" != none; then
             rmfiles="$rmfiles $dir/$non_pic_object"
+            func_append rmfiles " $dir/$non_pic_object"
           fi
         fi
 …
       *)
         if test "$mode" = clean ; then
+        if test "$opt_mode" = clean ; then
           noexename=$name
           case $file in
 …
             # $file with .exe has already been added to rmfiles,
             # add $file without .exe
             rmfiles="$rmfiles $file"
+            func_append rmfiles " $file"
             ;;
           esac
 …
               relink_command=
               func_source $func_ltwrapper_scriptname_result
               rmfiles="$rmfiles $func_ltwrapper_scriptname_result"
+              func_append rmfiles " $func_ltwrapper_scriptname_result"
             else
               relink_command=
 …
             # note $name still contains .exe if it was in $file originally
             # as does the version of $file that was added into $rmfiles
             rmfiles="$rmfiles $objdir/$name $objdir/${name}S.${objext}"
+            func_append rmfiles " $odir/$name $odir/${name}S.${objext}"
             if test "$fast_install" = yes && test -n "$relink_command"; then
               rmfiles="$rmfiles $objdir/lt-$name"
+              func_append rmfiles " $odir/lt-$name"
             fi
             if test "X$noexename" != "X$name" ; then
               rmfiles="$rmfiles $objdir/lt-${noexename}.c"
+              func_append rmfiles " $odir/lt-${noexename}.c"
             fi
           fi
 …
       func_show_eval "$RM $rmfiles" 'exit_status=1'
     done
-    objdir="$origobjdir"
     # Try to remove the ${objdir}s in the directories where we deleted files
 …
+}
 { test "$mode" = uninstall || test "$mode" = clean; } &&
+{ test "$opt_mode" = uninstall || test "$opt_mode" = clean; } &&
     func_mode_uninstall ${1+"$@"}
 test -z "$mode" && {
+test -z "$opt_mode" && {
   help="$generic_help"
   func_fatal_help "you must specify a MODE"
 …
 test -z "$exec_cmd" && \
   func_fatal_help "invalid operation mode \`$mode'"
+  func_fatal_help "invalid operation mode \`$opt_mode'"
 if test -n "$exec_cmd"; then

issm/branches/trunk-jpl-damage/m4

Property svn:ignore

old	new
1		svn-commit.tmp
	1

issm/branches/trunk-jpl-damage/m4/issm_options.m4

-              r12946
+              r13101
         dnl }}}
     dnl shared build {{{
+    AC_ARG_ENABLE([shared],                                                dnl feature
+        AS_HELP_STRING([--enable-shared], [produce libISSM.so.0]),         dnl help string
+        [enable_shared=$enableval],                                        dnl action if given
+        [enable_shared=no])                                                dnl action if not given
+    AM_CONDITIONAL([SHARED], [test $enable_shared = yes])
+    AC_ARG_ENABLE([sharedlibs],                                                dnl feature
+        AS_HELP_STRING([--enable-sharedlibs], [produce libISSM.so.0]),         dnl help string
+        [enable_sharedlibs=$enableval],                                        dnl action if given
+        [enable_sharedlibs=no])                                                dnl action if not given
+    AM_CONDITIONAL([SHAREDLIBS], [test x$enable_sharedlibs = xyes])
+    dnl }}}
+    dnl shared build {{{
+    AC_ARG_ENABLE([version],                                                dnl feature
+        AS_HELP_STRING([--enable-version], [produce libISSM.so.0]),         dnl help string
+        [enable_version=$enableval],                                        dnl action if given
+        [enable_version=no])                                                dnl action if not given
+    AM_CONDITIONAL([VERSION], [test x$enable_VERSION = xyes])
     dnl }}}
 …
                 MATLABWRAPPEREXT=$MEXEXT
                 AC_SUBST([MATLABWRAPPEREXT])
                 AC_SUBST([MEXLIB])
+            AC_SUBST([MEXLIB])
                 AC_SUBST([MEXLINK])
         fi
 …
         AC_MSG_RESULT($HAVE_ADOLC)
         dnl }}}
+        dnl adolc-version{{{
+        AC_ARG_WITH([adolc-version],
+                AS_HELP_STRING([--with-adolc-version=number], [adolc version.]),
+                [ADOLC_VERSION=$withval],[ADOLC_VERSION=2])
+        AC_MSG_CHECKING(for adolc-version)
+        AC_DEFINE_UNQUOTED([_ADOLC_VERSION_],$ADOLC_VERSION,[ADOLC version])
+        AC_MSG_RESULT($ADOLC_VERSION)
+        dnl }}}
         dnl adic2{{{
         AC_ARG_WITH([adic2-dir],
 …
                                 ;;
                         esac
                         METISINCL=-I"$METIS_ROOT/include"
                         AC_DEFINE([_METIS_VERSION_],[5],[ Metis version number])
 …
         AC_MSG_CHECKING(for mpi)
         AC_ARG_WITH([mpi-lib],
                 AS_HELP_STRING([--with-mpi-lib = otions],[mpi options, for ex: "-L$MPIROOT -lmpich]),
+                AS_HELP_STRING([--with-mpi-lib = options],[mpi options, for ex: "-L$MPIROOT -lmpich]),
                 [MPILIB=$withval],[MPILIB=""])
 …
                 else
                         HAVE_MPI=yes
                         MPIINCL=-I"$MPI_INCLUDE/"
+                        MPIINCL=-I"$MPI_INCLUDE"
                         AC_DEFINE([_HAVE_MPI_],[1],[with Mpi in ISSM src])
                         AC_DEFINE([HAVE_MPI],[1],[Mpi Flag for Dakota (DO NOT REMOVE)])
 …
                         *cygwin*)
                         if test "$PETSC_MAJOR" = "2" ; then
                                 PETSCLIB="-link -LIBPATH:\"$PETSC_ROOT/$PETSC_ARCH/lib\" -LIBPATH:\"$PETSC_ROOT/lib\" -LIBPATH:\"$PETSC_ROOT/lib/$PETSC_ARCH\" libpetscksp.lib  libpetscdm.lib  libpetscmat.lib  libpetscvec.lib libpetscsnes.lib libpetscts.lib libmpiuni.lib libpetsc.lib"
+                                PETSCLIB="-link -LIBPATH:\"$PETSC_ROOT/lib\" -LIBPATH:\"$PETSC_ROOT/lib\" -LIBPATH:\"$PETSC_ROOT/lib/$PETSC_ARCH\" libpetscksp.lib  libpetscdm.lib  libpetscmat.lib  libpetscvec.lib libpetscsnes.lib libpetscts.lib libmpiuni.lib libpetsc.lib"
                         else
                                 PETSCLIB="-link -LIBPATH:\"$PETSC_ROOT/$PETSC_ARCH/lib\" -LIBPATH:\"$PETSC_ROOT/lib\" -LIBPATH:\"$PETSC_ROOT/lib/$PETSC_ARCH\" libpetsc.lib"
+                                PETSCLIB="-link -LIBPATH:\"$PETSC_ROOT/lib\" -LIBPATH:\"$PETSC_ROOT/lib\" -LIBPATH:\"$PETSC_ROOT/lib/$PETSC_ARCH\" libpetsc.lib"
                         fi
                         ;;
                         *linux*)
                         if test "$PETSC_MAJOR" = "2" ; then
                         PETSCLIB="-L$PETSC_ROOT/$PETSC_ARCH/lib -L$PETSC_ROOT/lib -L$PETSC_ROOT/lib/$PETSC_ARCH -lpetscksp -lpetscdm -lpetscmat -lpetscvec -lpetsc  -lpetscsnes -lpetscts"
+                        PETSCLIB="-L$PETSC_ROOT/lib -L$PETSC_ROOT/lib -L$PETSC_ROOT/lib/$PETSC_ARCH -lpetscksp -lpetscdm -lpetscmat -lpetscvec -lpetsc  -lpetscsnes -lpetscts"
                         else
                         PETSCLIB="-L$PETSC_ROOT/$PETSC_ARCH/lib -L$PETSC_ROOT/lib -L$PETSC_ROOT/lib/$PETSC_ARCH -lpetsc -ldl"
+                        PETSCLIB="-L$PETSC_ROOT/lib -L$PETSC_ROOT/lib -L$PETSC_ROOT/lib/$PETSC_ARCH -lpetsc -ldl"
                         fi
                         ;;
                         *darwin*)
                         if test "$PETSC_MAJOR" = "2" ; then
                         PETSCLIB="-L$PETSC_ROOT/$PETSC_ARCH/lib -L$PETSC_ROOT/lib/$PETSC_ARCH/ -L$PETSC_ROOT/lib -L$PETSC_ROOT/lib/$PETSC_ARCH -lpetscksp -lpetscdm -lpetscmat -lpetscvec -lpetscsnes -lpetscts -lpetsc"
+                        PETSCLIB="-L$PETSC_ROOT/lib -L$PETSC_ROOT/lib/$PETSC_ARCH/ -L$PETSC_ROOT/lib -L$PETSC_ROOT/lib/$PETSC_ARCH -lpetscksp -lpetscdm -lpetscmat -lpetscvec -lpetscsnes -lpetscts -lpetsc"
                         else
                         PETSCLIB="-L$PETSC_ROOT/$PETSC_ARCH/lib -L$PETSC_ROOT/lib/$PETSC_ARCH/ -L$PETSC_ROOT/lib -L$PETSC_ROOT/lib/$PETSC_ARCH -lpetsc"
+                        PETSCLIB="-L$PETSC_ROOT/lib -L$PETSC_ROOT/lib/$PETSC_ARCH/ -L$PETSC_ROOT/lib -L$PETSC_ROOT/lib/$PETSC_ARCH -lpetsc"
                         fi
                         ;;

issm/branches/trunk-jpl-damage/scripts/automakererun.sh

r12878	r13101
9	9
10	10	cd $ISSM_DIR
11		autoreconf -iv -I m4
	11	autoreconf -iv -I externalpackages/libtool/install/share/aclocal

issm/branches/trunk-jpl-damage/scripts/historyISSM.m

-              r11577
+              r13101
 md.mesh.numberofelements
 md=mesh(md,'DomainOutline.exp',5000);
-md=setmask(md,'','');
 md=setflowequation(md,'macayeal','all');
-md=setflowequation(md,'pattyn','all','stokes','all');
 md=solve(md,TransientSolutionEnum);
-md=solve(md,BalancedthicknessSolutionEnum);
 md=solve(md,DiagnosticSolutionEnum);
 md=loadresultsfromcluster(md);

issm/branches/trunk-jpl-damage/src/Makefile.am

r12878	r13101
1		EXTRA_DIST = perl ~~pro~~ py
	1	EXTRA_DIST = perl pro py
2	2	SUBDIRS = c modules m

issm/branches/trunk-jpl-damage/src/ad/todo

-              r12878
+              r13101
 Replace memcpy, realloc with x layers.  Replace all calls to malloc and free in the code.
+Questions:
+set of active IssmDouble variables different from set of independent variables activated with <<=?
+same thing dependent variables?

issm/branches/trunk-jpl-damage/src/c/Container/DataSet.cpp

-              r12878
+              r13101
         vector<Object*>::iterator object;
         if(this==NULL)_error2_("trying to echo a NULL dataset");
+        if(this==NULL)_error_("trying to echo a NULL dataset");
         _pprintLine_("DataSet echo: " << objects.size() << " objects");
 …
         vector<Object*>::iterator object;
         if(this==NULL)_error2_("trying to echo a NULL dataset");
+        if(this==NULL)_error_("trying to echo a NULL dataset");
         _pprintLine_("DataSet echo: " << objects.size() << " objects");
 …
         _assert_(this);
         if(!sorted)_error2_("trying to binary search on a non-sorted dataset!");
+        if(!sorted)_error_("trying to binary search on a non-sorted dataset!");
         /*Carry out a binary search on the sorted_ids: */
         if(!binary_search(&id_offset,eid, sorted_ids,objects.size())){
                 _error2_("could not find object with id " << eid << " in DataSet " << EnumToStringx(enum_type));
+                _error_("could not find object with id " << eid << " in DataSet " << EnumToStringx(enum_type));
+        }
 …
         /*Only sort if we are not already sorted: */
         if(!sorted){
                 _error2_("not implemented yet!");
+        }
+}
 /*}}}*/
+                _error_("not implemented yet!");
+        }
+}
+/*}}}*/

issm/branches/trunk-jpl-damage/src/c/Container/Elements.cpp

-              r12878
+              r13101
                 /*see what the first element of this partition has in stock (this is common to all partitions)*/
                 if(my_rank==minrank){
                         if(this->Size()==0) _error2_("Cannot write results because there is no element??");
+                        if(this->Size()==0) _error_("Cannot write results because there is no element??");
                         Element* element=(Element*)this->GetObjectByOffset(0);
                         element->ListResultsInfo(&resultsenums,&resultssizes,&resultstimes,&resultssteps,&numberofresults);
 …
                         if(resultssizes[i]==P1Enum)      vectorsize=numberofvertices;
                         else if(resultssizes[i]==P0Enum) vectorsize=numberofelements;
                         else _error2_("Unkown result size: " << EnumToStringx(resultssizes[i]));
+                        else _error_("Unkown result size: " << EnumToStringx(resultssizes[i]));
                         vector=new Vector(vectorsize);

issm/branches/trunk-jpl-damage/src/c/Container/Inputs.cpp

-              r12878
+              r13101
                 /*we could not find an input with the correct enum type. No defaults values were provided,
                  * error out: */
                 _error2_("could not find input with enum type " << enum_type << " (" << EnumToStringx(enum_type) << ")");
+                _error_("could not find input with enum type " << enum_type << " (" << EnumToStringx(enum_type) << ")");
+        }
 …
                 /*we could not find an input with the correct enum type. No defaults values were provided,
                  * error out: */
                 _error2_("could not find input with enum type " << enum_type << " (" << EnumToStringx(enum_type) << ")");
+                _error_("could not find input with enum type " << enum_type << " (" << EnumToStringx(enum_type) << ")");
+        }
 …
                 /*we could not find an input with the correct enum type. No defaults values were provided,
                  * error out: */
                 _error2_("could not find input with enum type " << enum_type << " (" << EnumToStringx(enum_type) << ")");
+                _error_("could not find input with enum type " << enum_type << " (" << EnumToStringx(enum_type) << ")");
+        }
 …
                 /*we could not find an input with the correct enum type. No defaults values were provided,
                  * error out: */
                 _error2_("could not find input with enum type " << enum_type << " (" << EnumToStringx(enum_type) << ")");
+                _error_("could not find input with enum type " << enum_type << " (" << EnumToStringx(enum_type) << ")");
+        }
 …
         /*some checks: */
         if(!constrain_input) _error2_("input " << EnumToStringx(constrain_enum) << " could not be found!");
+        if(!constrain_input) _error_("input " << EnumToStringx(constrain_enum) << " could not be found!");
         /*Apply ContrainMin: */
 …
+        }
         else{
                 _error2_("Input " << EnumToStringx(enumtype) << " not found");
+                _error_("Input " << EnumToStringx(enumtype) << " not found");
+        }
 …
+        }
         else{
                 _error2_("Input " << EnumToStringx(enumtype) << " not found");
+                _error_("Input " << EnumToStringx(enumtype) << " not found");
+        }
 …
+        }
         else{
                 _error2_("Input " << EnumToStringx(enumtype) << " not found");
+                _error_("Input " << EnumToStringx(enumtype) << " not found");
+        }
 …
+        }
         else{
                 _error2_("Input " << EnumToStringx(enumtype) << " not found");
+                _error_("Input " << EnumToStringx(enumtype) << " not found");
+        }
 …
         /*Make a copy of the original input: */
         original=(Input*)this->GetInput(original_enum);
         if(!original)_error2_("could not find input with enum: " << EnumToStringx(original_enum));
+        if(!original)_error_("could not find input with enum: " << EnumToStringx(original_enum));
         copy=(Input*)original->copy();
 …
         /*some checks: */
         if(!xinput) _error2_("input " << EnumToStringx(MeshXEnum) << " could not be found!");
         if(!yinput) _error2_("input " << EnumToStringx(MeshYEnum) << " could not be found!");
+        if(!xinput) _error_("input " << EnumToStringx(MeshXEnum) << " could not be found!");
+        if(!yinput) _error_("input " << EnumToStringx(MeshYEnum) << " could not be found!");
         /*Apply AXPY: */

issm/branches/trunk-jpl-damage/src/c/Container/Observations.cpp

-              r12946
+              r13101
         options->Get(&maxtrimming,"maxtrimming",+1.e+21);
         options->Get(&minspacing,"minspacing",0.01);
         if(minspacing<=0) _error2_("minspacing must > 0");
+        if(minspacing<=0) _error_("minspacing must > 0");
         /*Get Minimum box size*/
         if(options->GetOption("boxlength")){
                 options->Get(&minlength,"boxlength");
                 if(minlength<=0)_error2_("boxlength should be a positive number");
                 maxdepth=int(log(max(xmax-xmin,ymax-ymin)/minlength +1)/log(2.0));
+                if(minlength<=0)_error_("boxlength should be a positive number");
+                maxdepth=reCast<int,IssmDouble>(log(max(xmax-xmin,ymax-ymin)/minlength +1)/log(2.0));
+        }
         else{
 …
         SolverxSeq(&GinvZ, Gamma,obs,n_obs);    // Gamma^-1 Z
 #else
         _error2_("GSL is required");
+        _error_("GSL is required");
 #endif

issm/branches/trunk-jpl-damage/src/c/Container/Options.cpp

r12878	r13101
47	47
48	48	/Also, check the option name/
49		if(!in_option->name) _error2_("input option has an empty name");
50		if(strchr(in_option->name,'.')) _error2_("Option \"" << in_option->name << "\" has a protected character \".\"");
51		if(strchr(in_option->name,'[')) _error2_("Option \"" << in_option->name << "\" has a protected character \"[\"");
52		if(strchr(in_option->name,']')) _error2_("Option \"" << in_option->name << "\" has a protected character \"]\"");
	49	if(!in_option->name) _error_("input option has an empty name");
	50	if(strchr(in_option->name,'.')) _error_("Option \"" << in_option->name << "\" has a protected character \".\"");
	51	if(strchr(in_option->name,'[')) _error_("Option \"" << in_option->name << "\" has a protected character \"[\"");
	52	if(strchr(in_option->name,']')) _error_("Option \"" << in_option->name << "\" has a protected character \"]\"");
53	53
54	54	/Finally, check that no option of the same name already exists in the dataset/
…	…
57	57	option=(Option)(object);
58	58	if (!strcmp(option->name,in_option->name)){
59		_error2_("Options \"" << in_option->name << "\" found multiple times");
	59	_error_("Options \"" << in_option->name << "\" found multiple times");
60	60	break;
61	61	}
…	…
83	83	/Else, the Option does not exist, no default provided/
84	84	else{
85		_error2_("option of name \"" << name << "\" not found, and no default value has been provided");
	85	_error_("option of name \"" << name << "\" not found, and no default value has been provided");
86	86	}
87	87	}
…	…
121	121	/Else, the Option does not exist, no default provided/
122	122	else{
123		_error2_("option of name \"" << name << "\" not found, and no default value has been provided");
	123	_error_("option of name \"" << name << "\" not found, and no default value has been provided");
124	124	}
125	125	}
…	…
159	159	/Else, the Option does not exist, no default provided/
160	160	else{
161		_error2_("option of name \"" << name << "\" not found, and no default value has been provided");
	161	_error_("option of name \"" << name << "\" not found, and no default value has been provided");
162	162	}
163	163	}
…	…
199	199	/Else, the Option does not exist, no default provided/
200	200	else{
201		_error2_("option of name \"" << name << "\" not found, and no default value has been provided");
	201	_error_("option of name \"" << name << "\" not found, and no default value has been provided");
202	202	}
203	203
…	…
264	264	/Else: not supported/
265	265	else{
266		_error2_("Cannot recover field \"" << name << "\" for an option of type " << EnumToStringx(option->ObjectEnum()));
	266	_error_("Cannot recover field \"" << name << "\" for an option of type " << EnumToStringx(option->ObjectEnum()));
267	267	}
268	268	}
…	…
290	290	/Else, the Option does not exist, no default provided/
291	291	else{
292		_error2_("option of name \"" << name << "\" not found, and no default value has been provided");
	292	_error_("option of name \"" << name << "\" not found, and no default value has been provided");
293	293	}
294	294	}
…	…
324	324	/Else: not supported/
325	325	else{
326		_error2_("Cannot recover field \"" << name << "\" for an option of type " << EnumToStringx(option->ObjectEnum()));
	326	_error_("Cannot recover field \"" << name << "\" for an option of type " << EnumToStringx(option->ObjectEnum()));
327	327	}
328	328	}

issm/branches/trunk-jpl-damage/src/c/Container/Parameters.cpp

r12878	r13101
65	65	}
66	66	}
67		_error2_("could not find parameter " << EnumToStringx(enum_type));
	67	_error_("could not find parameter " << EnumToStringx(enum_type));
68	68	}
69	69	/}}}/
…	…
82	82	}
83	83	}
84		_error2_("could not find parameter " << EnumToStringx(enum_type));
	84	_error_("could not find parameter " << EnumToStringx(enum_type));
85	85	}
86	86	/}}}/
…	…
99	99	}
100	100	}
101		_error2_("could not find parameter " << EnumToStringx(enum_type));
	101	_error_("could not find parameter " << EnumToStringx(enum_type));
102	102	}
103	103	/}}}/
…	…
116	116	}
117	117	}
118		_error2_("could not find parameter " << EnumToStringx(enum_type));
	118	_error_("could not find parameter " << EnumToStringx(enum_type));
119	119	}
120	120	/}}}/
…	…
133	133	}
134	134	}
135		_error2_("could not find parameter " << EnumToStringx(enum_type));
	135	_error_("could not find parameter " << EnumToStringx(enum_type));
136	136
137	137	}
…	…
151	151	}
152	152	}
153		_error2_("could not find parameter " << EnumToStringx(enum_type));
	153	_error_("could not find parameter " << EnumToStringx(enum_type));
154	154
155	155	}
…	…
169	169	}
170	170	}
171		_error2_("could not find parameter " << EnumToStringx(enum_type));
	171	_error_("could not find parameter " << EnumToStringx(enum_type));
172	172
173	173	}
…	…
187	187	}
188	188	}
189		_error2_("could not find parameter " << EnumToStringx(enum_type));
	189	_error_("could not find parameter " << EnumToStringx(enum_type));
190	190
191	191	}
…	…
205	205	}
206	206	}
207		_error2_("could not find parameter " << EnumToStringx(enum_type));
	207	_error_("could not find parameter " << EnumToStringx(enum_type));
208	208
209	209	}
…	…
223	223	}
224	224	}
225		_error2_("could not find parameter " << EnumToStringx(enum_type));
	225	_error_("could not find parameter " << EnumToStringx(enum_type));
226	226
227	227	}
…	…
241	241	}
242	242	}
243		_error2_("could not find parameter " << EnumToStringx(enum_type));
	243	_error_("could not find parameter " << EnumToStringx(enum_type));
244	244	}
245	245	/}}}/
…	…
258	258	}
259	259	}
260		_error2_("could not find parameter " << EnumToStringx(enum_type));
	260	_error_("could not find parameter " << EnumToStringx(enum_type));
261	261
262	262	}
…	…
276	276	}
277	277	}
278		_error2_("could not find parameter " << EnumToStringx(enum_type));
	278	_error_("could not find parameter " << EnumToStringx(enum_type));
279	279
280	280	}
…	…
294	294	}
295	295	}
296		_error2_("could not find parameter " << EnumToStringx(enum_type));
	296	_error_("could not find parameter " << EnumToStringx(enum_type));
297	297	}
298	298	/}}}/

issm/branches/trunk-jpl-damage/src/c/EnumDefinitions/EnumDefinitions.h

-              r12946
+              r13101
 enum definitions{
         /*Model fields {{{1*/
-        AutodiffForwardEnum,
         AutodiffIsautodiffEnum,
-        AutodiffReverseEnum,
         BalancethicknessSpcthicknessEnum,
         BalancethicknessStabilizationEnum,
 …
         FlowequationElementEquationEnum,
         FlowequationIshutterEnum,
+        FlowequationIsl1l2Enum,
         FlowequationIsmacayealpattynEnum,
         FlowequationIsstokesEnum,
 …
         /*Approximations {{{1*/
         ApproximationEnum,
+        NoneApproximationEnum,
         HutterApproximationEnum,
         MacAyealApproximationEnum,
         MacAyealPattynApproximationEnum,
         MacAyealStokesApproximationEnum,
         NoneApproximationEnum,
+        L1L2ApproximationEnum,
         PattynApproximationEnum,
         PattynStokesApproximationEnum,
 …
         NumericalfluxEnum,
         ParamEnum,
+        L1L2IceFrontEnum,
         PattynIceFrontEnum,
         PengridEnum,
 …
         EnthalpyPicardEnum,
         ThicknessAbsGradientEnum,
+        ThicknessAlongGradientEnum,
+        ThicknessAcrossGradientEnum,
         StepResponsesEnum,
         IntMatParamEnum,
 …
         StressTensoryzEnum,
         StressTensorzzEnum,
-        IceVolumeEnum, //FIXME reposition
-        TotalSmbEnum,  //FIXME reposition
-        ThicknessAlongGradientEnum,
-        ThicknessAcrossGradientEnum,
         /*}}}*/
         /*Element Interpolations{{{1*/
 …
         MaxVzEnum,
         MaxAbsVzEnum,
+        IceVolumeEnum,
+        TotalSmbEnum,
         /*}}}*/
         /*Convergence{{{1*/

issm/branches/trunk-jpl-damage/src/c/EnumDefinitions/Synchronize.sh

-              r12878
+              r13101
 cat <<END >> $ISSM_DIR/src/c/modules/StringToEnumx/StringToEnumx.cpp
         /*If we reach this point, the string provided has not been found*/
         _error2_("Enum " << name << " not found");
+        _error_("Enum " << name << " not found");
+}
 END
 …
 #Add header to pythonenum file{{{
 cat <<END > $ISSM_DIR/src/m/enum/EnumDefinitions.py
+from StringToEnum import StringToEnum
 """
 …
         """
         return StringToEnum('$NAME')
+        return StringToEnum('$NAME')[0]
 END

issm/branches/trunk-jpl-damage/src/c/Makefile.am

-              r12946
+              r13101
 INCLUDES = @DAKOTAINCL@ @SHAPELIBINCL@ @PETSCINCL@ @SLEPCINCL@ @MPIINCL@ @MATLABINCL@ @METISINCL@ @CHACOINCL@ @SCOTCHINCL@ @PLAPACKINCL@ @BLASLAPACKINCL@ @MKLINCL@ @MUMPSINCL@ @TRIANGLEINCL@ @SPAIINCL@ @HYPREINCL@ @PROMETHEUSINCL@ @SUPERLUINCL@ @SPOOLESINCL@ @PASTIXINCL@ @MLINCL@ @TAOINCL@ @ADIC2INCL@ @ADOLCINCL@ @GSLINCL@ @BOOSTINCL@ @PYTHONINCL@ @PYTHON_NUMPYINCL@
+AM_CPPFLAGS = @DAKOTAINCL@ @SHAPELIBINCL@ @PETSCINCL@ @SLEPCINCL@ @MPIINCL@ @MATLABINCL@ @METISINCL@ @CHACOINCL@ @SCOTCHINCL@ @PLAPACKINCL@ @BLASLAPACKINCL@ @MKLINCL@ @MUMPSINCL@ @TRIANGLEINCL@ @SPAIINCL@ @HYPREINCL@ @PROMETHEUSINCL@ @SUPERLUINCL@ @SPOOLESINCL@ @PASTIXINCL@ @MLINCL@ @TAOINCL@ @ADIC2INCL@ @ADOLCINCL@ @GSLINCL@ @BOOSTINCL@ @PYTHONINCL@ @PYTHON_NUMPYINCL@
 EXEEXT=$(ISSMEXT)
 …
 lib_LIBRARIES = libISSMCore.a libISSMOverload.a
+#if SHARED
 #lib_LTLIBRARIES = libISSMCore.la libISSMOverload.la libISSM.la
 #endif
+if SHAREDLIBS
+lib_LTLIBRARIES = libISSMCore.la libISSMOverload.la libISSM.la
+endif
 if PYTHON
 lib_LIBRARIES += libISSMPython.a
 endif
 if MATLAB
+if SHAREDLIBS
+lib_LTLIBRARIES += libISSMMatlab.la
+endif
 lib_LIBRARIES += libISSMMatlab.a
 endif
 if MODULES
+if SHAREDLIBS
+lib_LTLIBRARIES += libISSMModules.la
+endif
 lib_LIBRARIES += libISSMModules.a
 endif
 …
                                         ./shared/Numerics/isnan.h\
                                         ./shared/Numerics/isnan.cpp\
+                                        ./shared/Numerics/cubic.cpp\
                                         ./shared/Numerics/extrema.cpp\
                                         ./shared/Numerics/XZvectorsToCoordinateSystem.cpp\
 …
                                           ./modules/Dakotax/SpawnCore.cpp\
                                           ./modules/Dakotax/DescriptorIndex.cpp\
-                                          ./modules/AverageOntoPartitionx/AverageOntoPartitionx.cpp\
                                           ./modules/ModelProcessorx/Dakota/CreateParametersDakota.cpp\
-                                          ./modules/AverageOntoPartitionx/AverageOntoPartitionx.h\
                                           ./modules/Dakotax/SpawnCoreParallel.cpp
 #}}}
 …
 libISSMCore_a_CXXFLAGS = $(ALLCXXFLAGS)
+#if SHARED
 #libISSM_la_SOURCES = solutions/issm.cpp
 #libISSM_la_LIBADD = libISSMCore.la libISSMOverload.la
+#
 #libISSMCore_la_SOURCES  = $(issm_sources)
 #libISSMCore_la_LIBADD = $(PETSCLIB) $(TAOLIB) $(PLAPACKLIB) $(MUMPSLIB) $(SUPERLULIB) $(SPOOLESLIB) $(SCALAPACKLIB) $(BLACSLIB) $(HYPRELIB) $(SPAILIB) $(PROMETHEUSLIB) $(PASTIXLIB) $(MLLIB) $(DAKOTALIB) $(METISLIB) $(CHACOLIB) $(SCOTCHLIB) $(BLASLAPACKLIB) $(MKLLIB) $(MPILIB) $(MATHLIB) $(FORTRANLIB) $(GRAPHICSLIB) $(MULTITHREADINGLIB) $(OSLIBS) $(GSLLIB) $(ADOLCLIB)
+#
 #libISSMOverload_la_SOURCES = ./shared/String/stricmp.c
 #endif
+if SHAREDLIBS
+libISSM_la_SOURCES = solutions/issm.cpp
+libISSM_la_LIBADD = libISSMCore.la libISSMOverload.la
+libISSMCore_la_SOURCES  = $(issm_sources)
+libISSMCore_la_LIBADD = $(PETSCLIB) $(TAOLIB) $(PLAPACKLIB) $(MUMPSLIB) $(SUPERLULIB) $(SPOOLESLIB) $(SCALAPACKLIB) $(BLACSLIB) $(HYPRELIB) $(SPAILIB) $(PROMETHEUSLIB) $(PASTIXLIB) $(MLLIB) $(DAKOTALIB) $(METISLIB) $(CHACOLIB) $(SCOTCHLIB) $(BLASLAPACKLIB) $(MKLLIB) $(MPILIB) $(MATHLIB) $(FORTRANLIB) $(GRAPHICSLIB) $(MULTITHREADINGLIB) $(OSLIBS) $(GSLLIB) $(ADOLCLIB)
+libISSMOverload_la_SOURCES = ./shared/String/stricmp.c
+endif
 if MODULES
 …
 libISSMModules_a_SOURCES += $(kml_sources)
 libISSMModules_a_CXXFLAGS = $(ALLCXXFLAGS)
+libISSMModules_a_LIBADD = ./libISSMCore.a
+if SHAREDLIBS
+libISSMModules_la_SOURCES = $(libISSMModules_a_SOURCES)
+endif
 endif
 …
 libISSMMatlab_a_SOURCES = $(matlab_sources)
 libISSMMatlab_a_CXXFLAGS= $(ALLCXXFLAGS)
+endif
+if SHAREDLIBS
+libISSMMatlab_la_SOURCES = $(libISSMMatlab_a_SOURCES)
+endif
+endif
+if VERSION
+AM_LDFLAGS =
+else
+AM_LDFLAGS = -avoid-version
+endif
 #}}}
 #Overload library, to overload any non-standard symbols. {{{

issm/branches/trunk-jpl-damage/src/c/classes/DofIndexing.cpp

r12832	r13101
143	143	else this->sdoflist=NULL;
144	144	}
145		else _error2_("set of enum type " << EnumToStringx(setenum) << " not supported yet!");
	145	else _error_("set of enum type " << EnumToStringx(setenum) << " not supported yet!");
146	146	}
147	147	/}}}/

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

r12832	r13101
129	129	}
130	130	if(found!=-1) analysis_counter=found;
131		else _error2_("Could not find alias for analysis_type " << EnumToStringx(configuration_type) << " in list of FemModel analyses");
	131	else _error_("Could not find alias for analysis_type " << EnumToStringx(configuration_type) << " in list of FemModel analyses");
132	132
133	133	/Now, plug analysis_counter and analysis_type inside the parameters: /

issm/branches/trunk-jpl-damage/src/c/classes/Hook.cpp

-              r12832
+              r13101
                         this->objects[i]=(Object*)dataset->GetObjectById(this->offsets+i,this->ids[i]); //remember the offset for later on.
                         /*check the id is correct!: */
                         if (this->objects[i]->Id()!=this->ids[i]) _error2_("wrong id: " << this->objects[i]->Id() << " vs " << this->ids[i] << "  in resolved pointer!");
+                        if (this->objects[i]->Id()!=this->ids[i]) _error_("wrong id: " << this->objects[i]->Id() << " vs " << this->ids[i] << "  in resolved pointer!");
+                }
+        }
 …
         /*first, check that we only have one T object in our object list: */
         if (this->num!=1) _error2_("trying to delivery a single hook object when hook holds " << this->num << " objects" << "\n");
+        if (this->num!=1) _error_("trying to delivery a single hook object when hook holds " << this->num << " objects" << "\n");
         /*check NULL: */
         if (this->objects==NULL) _error2_("hook is not pointing to any object, objects pointer is NULL");
+        if (this->objects==NULL) _error_("hook is not pointing to any object, objects pointer is NULL");
         return *objects;
 …
         /*Else, check that we are requesting a half of num*/
         if (numindices>this->num) _error2_("Cannot spawn hook with " << numindices << " objects from a Hook of " << this->num << " objects");
+        if (numindices>this->num) _error_("Cannot spawn hook with " << numindices << " objects from a Hook of " << this->num << " objects");
         /*go pickup the correct objects, ids and offsets :*/
         output->num=numindices;
         if(output->num<1) _error2_("Trying to spawn an empty ElementProperties!");
+        if(output->num<1) _error_("Trying to spawn an empty ElementProperties!");
         output->objects=xNew<Object*>(output->num);

issm/branches/trunk-jpl-damage/src/c/classes/IoModel.cpp

-              r12832
+              r13101
                 /*Get first Enum*/
                 if(fread(&record_enum,sizeof(int),1,this->fid)==0){
                         _error2_("Marshalled file is empty");
+                        _error_("Marshalled file is empty");
+                }
                 else{
 …
                                 _printLine_("=========================================================================");
                                 _printLine_("");
                                 _error2_("Enums not consistent (See error message above)");
+                                _error_("Enums not consistent (See error message above)");
+                        }
+                }
 …
         /*Find constant*/
         Param* param=(Param*)this->constants->FindParamObject(constant_enum);
         if(!param) _error2_("Constant " << EnumToStringx(constant_enum) << " not found in iomodel");
+        if(!param) _error_("Constant " << EnumToStringx(constant_enum) << " not found in iomodel");
         return (Param*)param->copy();
 …
                                         case 1:
                                                 /*Read the boolean and broadcast it to other cpus:*/
                                                 if(fread(&booleanint,sizeof(int),1,this->fid)!=1) _error2_("could not read boolean ");
+                                                if(fread(&booleanint,sizeof(int),1,this->fid)!=1) _error_("could not read boolean ");
                                                 #ifdef _HAVE_MPI_
                                                 MPI_Bcast(&booleanint,1,MPI_INT,0,MPI_COMM_WORLD);
 …
                                         case 2:
                                                 /*Read the integer and broadcast it to other cpus:*/
                                                 if(fread(&integer,sizeof(int),1,this->fid)!=1) _error2_("could not read integer ");
+                                                if(fread(&integer,sizeof(int),1,this->fid)!=1) _error_("could not read integer ");
                                                 #ifdef _HAVE_MPI_
                                                 MPI_Bcast(&integer,1,MPI_INT,0,MPI_COMM_WORLD);
 …
                                         case 3:
                                                 /*Read the scalar and broadcast it to other cpus:*/
                                                 if(fread(&scalar,sizeof(IssmPDouble),1,this->fid)!=1) _error2_("could not read scalar ");
+                                                if(fread(&scalar,sizeof(IssmPDouble),1,this->fid)!=1) _error_("could not read scalar ");
                                                 #ifdef _HAVE_MPI_
                                                 MPI_Bcast(&scalar,1,MPI_DOUBLE,0,MPI_COMM_WORLD);
 …
                                         case 4:
                                                 /*We have to read a string from disk. First read the dimensions of the string, then the string: */
                                                 if(fread(&string_size,sizeof(int),1,this->fid)!=1) _error2_("could not read length of string ");
+                                                if(fread(&string_size,sizeof(int),1,this->fid)!=1) _error_("could not read length of string ");
                                                 #ifdef _HAVE_MPI_
                                                 MPI_Bcast(&string_size,1,MPI_INT,0,MPI_COMM_WORLD);
 …
                                                         /*Read string, then broadcast: */
                                                         if(fread(string,string_size*sizeof(char),1,this->fid)!=1)_error2_(" could not read string ");
+                                                        if(fread(string,string_size*sizeof(char),1,this->fid)!=1)_error_(" could not read string ");
                                                         #ifdef _HAVE_MPI_
                                                         MPI_Bcast(string,string_size,MPI_CHAR,0,MPI_COMM_WORLD);
 …
                                         default:
                                                 _error2_("unknown record type:" << record_code);
+                                                _error_("unknown record type:" << record_code);
                                                 break;;
+                                }
 …
                                 default:
                                         _error2_("unknown record type:" << record_code);
+                                        _error_("unknown record type:" << record_code);
                                         break;;
+                                }
 …
         fid=this->SetFilePointerToData(&code,NULL,data_enum);
         if(code!=1)_error2_("expecting a boolean for enum " << EnumToStringx(data_enum));
+        if(code!=1)_error_("expecting a boolean for enum " << EnumToStringx(data_enum));
         /*We have to read a boolean from disk. */
         if(my_rank==0){
                 if(fread(&booleanint,sizeof(int),1,fid)!=1) _error2_("could not read boolean ");
+                if(fread(&booleanint,sizeof(int),1,fid)!=1) _error_("could not read boolean ");
+        }
         #ifdef _HAVE_MPI_
 …
         fid=this->SetFilePointerToData(&code,NULL,data_enum);
         if(code!=2)_error2_("expecting an integer for enum " << EnumToStringx(data_enum));
+        if(code!=2)_error_("expecting an integer for enum " << EnumToStringx(data_enum));
         /*We have to read a integer from disk. First read the dimensions of the integer, then the integer: */
         if(my_rank==0){
                 if(fread(&integer,sizeof(int),1,fid)!=1) _error2_("could not read integer ");
+                if(fread(&integer,sizeof(int),1,fid)!=1) _error_("could not read integer ");
+        }
 …
         fid=this->SetFilePointerToData(&code,NULL,data_enum);
         if(code!=3)_error2_("expecting a IssmDouble for enum " << EnumToStringx(data_enum));
+        if(code!=3)_error_("expecting a IssmDouble for enum " << EnumToStringx(data_enum));
         /*We have to read a scalar from disk. First read the dimensions of the scalar, then the scalar: */
         if(my_rank==0){
                 if(fread(&scalar,sizeof(IssmPDouble),1,fid)!=1)_error2_("could not read scalar ");
+                if(fread(&scalar,sizeof(IssmPDouble),1,fid)!=1)_error_("could not read scalar ");
+        }
         #ifdef _HAVE_MPI_
 …
         fid=this->SetFilePointerToData(&code,NULL,data_enum);
         if(code!=4)_error2_("expecting a string for enum " << EnumToStringx(data_enum));
+        if(code!=4)_error_("expecting a string for enum " << EnumToStringx(data_enum));
         /*Now fetch: */
 …
         /*We have to read a string from disk. First read the dimensions of the string, then the string: */
         if(my_rank==0){
                 if(fread(&string_size,sizeof(int),1,fid)!=1) _error2_("could not read length of string ");
+                if(fread(&string_size,sizeof(int),1,fid)!=1) _error_("could not read length of string ");
+        }
 …
                 /*Read string on node 0, then broadcast: */
                 if(my_rank==0){
                         if(fread(string,string_size*sizeof(char),1,fid)!=1)_error2_(" could not read string ");
+                        if(fread(string,string_size*sizeof(char),1,fid)!=1)_error_(" could not read string ");
+                }
                 #ifdef _HAVE_MPI_
 …
         fid=this->SetFilePointerToData(&code,&vector_type,data_enum);
         if((code!=5) && (code!=6) && (code!=7))_error2_("expecting a IssmDouble, integer or boolean matrix for enum " << EnumToStringx(data_enum));
+        if((code!=5) && (code!=6) && (code!=7))_error_("expecting a IssmDouble, integer or boolean matrix for enum " << EnumToStringx(data_enum));
         /*Now fetch: */
 …
         /*numberofelements: */
         if(my_rank==0){
                 if(fread(&M,sizeof(int),1,fid)!=1) _error2_("could not read number of rows for matrix ");
+                if(fread(&M,sizeof(int),1,fid)!=1) _error_("could not read number of rows for matrix ");
+        }
 …
         if(my_rank==0){
                 if(fread(&N,sizeof(int),1,fid)!=1) _error2_("could not read number of columns for matrix ");
+                if(fread(&N,sizeof(int),1,fid)!=1) _error_("could not read number of columns for matrix ");
+        }
         #ifdef _HAVE_MPI_
 …
                 /*Read matrix on node 0, then broadcast: */
                 if(my_rank==0){
                         if(fread(matrix,M*N*sizeof(IssmPDouble),1,fid)!=1) _error2_("could not read matrix ");
+                        if(fread(matrix,M*N*sizeof(IssmPDouble),1,fid)!=1) _error_("could not read matrix ");
+                }
 …
         /*Set file pointer to beginning of the data: */
         fid=this->SetFilePointerToData(&code,&vector_type,data_enum);
         if((code!=5) && (code!=6) && (code!=7))_error2_("expecting a IssmDouble, integer or boolean matrix for enum " << EnumToStringx(data_enum));
+        if((code!=5) && (code!=6) && (code!=7))_error_("expecting a IssmDouble, integer or boolean matrix for enum " << EnumToStringx(data_enum));
         /*Now fetch: */
 …
         /*numberofelements: */
         if(my_rank==0){
                 if(fread(&M,sizeof(int),1,fid)!=1) _error2_("could not read number of rows for matrix ");
+                if(fread(&M,sizeof(int),1,fid)!=1) _error_("could not read number of rows for matrix ");
+        }
         #ifdef _HAVE_MPI_
 …
         if(my_rank==0){
                 if(fread(&N,sizeof(int),1,fid)!=1) _error2_("could not read number of columns for matrix ");
+                if(fread(&N,sizeof(int),1,fid)!=1) _error_("could not read number of columns for matrix ");
+        }
         #ifdef _HAVE_MPI_
 …
                 /*Read matrix on node 0, then broadcast: */
                 if(my_rank==0){
                         if(fread(matrix,M*N*sizeof(IssmPDouble),1,fid)!=1) _error2_("could not read matrix ");
+                        if(fread(matrix,M*N*sizeof(IssmPDouble),1,fid)!=1) _error_("could not read matrix ");
+                }
                 #ifdef _HAVE_MPI_
 …
         fid=this->SetFilePointerToData(&code,NULL,data_enum);
         if(code!=9)_error2_("expecting a string array for enum " << EnumToStringx(data_enum));
+        if(code!=9)_error_("expecting a string array for enum " << EnumToStringx(data_enum));
         /*We have to read a bunch of strings from disk. First read the number of strings, and allocate: */
         if(my_rank==0){
                 if(fread(&numstrings,sizeof(int),1,fid)!=1) _error2_("could not read length of string array");
+                if(fread(&numstrings,sizeof(int),1,fid)!=1) _error_("could not read length of string array");
+        }
         #ifdef _HAVE_MPI_
 …
                         if(my_rank==0){
                                 if(fread(&string_size,sizeof(int),1,fid)!=1) _error2_("could not read length of string ");
+                                if(fread(&string_size,sizeof(int),1,fid)!=1) _error_("could not read length of string ");
+                        }
                         #ifdef _HAVE_MPI_
 …
                                 /*Read string on node 0, then broadcast: */
                                 if(my_rank==0){
                                         if(fread(string,string_size*sizeof(char),1,fid)!=1)_error2_(" could not read string ");
+                                        if(fread(string,string_size*sizeof(char),1,fid)!=1)_error_(" could not read string ");
+                                }
                                 #ifdef _HAVE_MPI_
 …
         /*Set file pointer to beginning of the data: */
         fid=this->SetFilePointerToData(&code,NULL,data_enum);
         if(code!=8)_error2_("expecting a IssmDouble mat array for enum " << EnumToStringx(data_enum));
+        if(code!=8)_error_("expecting a IssmDouble mat array for enum " << EnumToStringx(data_enum));
         /*Now fetch: */
         if(my_rank==0){
                 if(fread(&numrecords,sizeof(int),1,fid)!=1) _error2_("could not read number of records in matrix array ");
+                if(fread(&numrecords,sizeof(int),1,fid)!=1) _error_("could not read number of records in matrix array ");
+        }
         #ifdef _HAVE_MPI_
 …
                         if(my_rank==0){
                                 if(fread(&M,sizeof(int),1,fid)!=1) _error2_("could not read number of rows in " << i << "th matrix of matrix array");
+                                if(fread(&M,sizeof(int),1,fid)!=1) _error_("could not read number of rows in " << i << "th matrix of matrix array");
+                        }
                         #ifdef _HAVE_MPI_
 …
                         if(my_rank==0){
                                 if(fread(&N,sizeof(int),1,fid)!=1) _error2_("could not read number of columns in " << i << "th matrix of matrix array");
+                                if(fread(&N,sizeof(int),1,fid)!=1) _error_("could not read number of columns in " << i << "th matrix of matrix array");
+                        }
                         #ifdef _HAVE_MPI_
 …
                                 /*Read matrix on node 0, then broadcast: */
                                 if(my_rank==0){
                                         if(fread(matrix,M*N*sizeof(IssmPDouble),1,fid)!=1) _error2_("could not read matrix ");
+                                        if(fread(matrix,M*N*sizeof(IssmPDouble),1,fid)!=1) _error_("could not read matrix ");
+                                }
 …
+                          }
                 default:
                           _error2_("Option of format " << code << " not supported yet");
+                          _error_("Option of format " << code << " not supported yet");
+        }
 …
                 _assert_(dataenum<MaximumNumberOfEnums);
                 if(this->data[dataenum]){
                         _error2_("Info: trying to fetch " << EnumToStringx(dataenum) << " but previous pointer has not been freed (DeleteData has not been called)");
+                        _error_("Info: trying to fetch " << EnumToStringx(dataenum) << " but previous pointer has not been freed (DeleteData has not been called)");
+                }
                 #endif
 …
                         break; /*}}}*/
                 default: /*{{{*/
                         _error2_("data code " << code << " not supported yet!");
+                        _error_("data code " << code << " not supported yet!");
                         break;
                         /*}}}*/
 …
 #ifdef _HAVE_MPI_
         MPI_Bcast(&found,1,MPI_INT,0,MPI_COMM_WORLD);
         if(!found)_error2_("could not find data with name" << " " << EnumToStringx(data_enum) << " ");
+        if(!found)_error_("could not find data with name" << " " << EnumToStringx(data_enum) << " ");
 #endif

issm/branches/trunk-jpl-damage/src/c/classes/bamg/BamgOpts.cpp

-              r12821
+              r13101
         int i;
         if (this->anisomax<1) _error2_("'anisomax' option should be >=1");
         if (this->coeff==0) _error2_("'coeff' should be positive");
         if (this->errg<0) _error2_("'errg' option should be >0");
         if (this->gradation<1) _error2_("'gradation' option should be >=1");
         if (this->Hessiantype!=0  && this->Hessiantype!=1) _error2_("'Hessiantype' supported options are 0 and 1");
         if (this->maxnbv<3) _error2_("'maxnbv' option should be >3");
         if (this->maxsubdiv<=1) _error2_("'maxsubdiv' should be >1");
         if (this->Metrictype!=0   && this->Metrictype!=1 && this->Metrictype!=2) _error2_("'Metrictype' supported options are 0, 1 and 2");
         if (this->nbjacobi<=0) _error2_("'nbjacobi' option should be >0");
         if (this->nbsmooth<=0) _error2_("'nbsmooth' option should be >0");
+        if (this->anisomax<1) _error_("'anisomax' option should be >=1");
+        if (this->coeff==0) _error_("'coeff' should be positive");
+        if (this->errg<0) _error_("'errg' option should be >0");
+        if (this->gradation<1) _error_("'gradation' option should be >=1");
+        if (this->Hessiantype!=0  && this->Hessiantype!=1) _error_("'Hessiantype' supported options are 0 and 1");
+        if (this->maxnbv<3) _error_("'maxnbv' option should be >3");
+        if (this->maxsubdiv<=1) _error_("'maxsubdiv' should be >1");
+        if (this->Metrictype!=0   && this->Metrictype!=1 && this->Metrictype!=2) _error_("'Metrictype' supported options are 0, 1 and 2");
+        if (this->nbjacobi<=0) _error_("'nbjacobi' option should be >0");
+        if (this->nbsmooth<=0) _error_("'nbsmooth' option should be >0");
         if (this->Crack!=0  && this->Crack!=1) _error2_("'Crack' supported options are 0 and 1");
         if (this->KeepVertices!=0 && this->KeepVertices!=1) _error2_("'KeepVertices' supported options are 0 and 1");
         if (this->geometricalmetric!=0  && this->geometricalmetric!=1) _error2_("'geometricalmetric' supported options are 0 and 1");
+        if (this->Crack!=0  && this->Crack!=1) _error_("'Crack' supported options are 0 and 1");
+        if (this->KeepVertices!=0 && this->KeepVertices!=1) _error_("'KeepVertices' supported options are 0 and 1");
+        if (this->geometricalmetric!=0  && this->geometricalmetric!=1) _error_("'geometricalmetric' supported options are 0 and 1");
         if (this->hmin<=0) _error2_("'hmin' option should be >0");
         if (this->hmax<=0 || this->hmax<this->hmin) _error2_("'hmax' option should be between 0 and hmin=" << this->hmin);
         if (this->hminVertices && this->hminVerticesSize[1]!=1) _error2_("'hminVertices' should be a column");
         if (this->hmaxVertices && this->hmaxVerticesSize[1]!=1) _error2_("'hmaxVertices' should be a column");
         if (this->hVertices && this->hVerticesSize[1]!=1) _error2_("'hVertices' should be a column");
         if (this->metric && (this->metricSize[1]!=1 && this->metricSize[1]!=3)) _error2_("'metric' should have either 1 (iso) or 3 (aniso) columns.");
+        if (this->hmin<=0) _error_("'hmin' option should be >0");
+        if (this->hmax<=0 || this->hmax<this->hmin) _error_("'hmax' option should be between 0 and hmin=" << this->hmin);
+        if (this->hminVertices && this->hminVerticesSize[1]!=1) _error_("'hminVertices' should be a column");
+        if (this->hmaxVertices && this->hmaxVerticesSize[1]!=1) _error_("'hmaxVertices' should be a column");
+        if (this->hVertices && this->hVerticesSize[1]!=1) _error_("'hVertices' should be a column");
+        if (this->metric && (this->metricSize[1]!=1 && this->metricSize[1]!=3)) _error_("'metric' should have either 1 (iso) or 3 (aniso) columns.");
         if (this->field){
                 if (this->errSize[0]!=1 || this->errSize[1]!=this->fieldSize[1]) _error2_("'err' should be of size " << 1 << " x " << this->fieldSize[1]);
                 for (i=0;i<this->fieldSize[1];i++) {if (this->err[i]<=0) _error2_("'err' option should be >0");};
+                if (this->errSize[0]!=1 || this->errSize[1]!=this->fieldSize[1]) _error_("'err' should be of size " << 1 << " x " << this->fieldSize[1]);
+                for (i=0;i<this->fieldSize[1];i++) {if (this->err[i]<=0) _error_("'err' option should be >0");};
+        }

issm/branches/trunk-jpl-damage/src/c/classes/bamg/BamgQuadtree.h

-              r12835
+              r13101
                                         };
                                         /*Object functions*/
                                         void    Echo()       {_error2_("not implemented yet"); };
                                         void    DeepEcho()   {_error2_("not implemented yet"); };
                                         int     Id()         {_error2_("not implemented yet"); };
                                         int     MyRank()     {_error2_("not implemented yet"); };
                                         int     ObjectEnum() {_error2_("not implemented yet"); };
                                         Object *copy()       {_error2_("not implemented yet"); };
+                                        void    Echo()       {_error_("not implemented yet"); };
+                                        void    DeepEcho()   {_error_("not implemented yet"); };
+                                        int     Id()         {_error_("not implemented yet"); };
+                                        int     MyRank()     {_error_("not implemented yet"); };
+                                        int     ObjectEnum() {_error_("not implemented yet"); };
+                                        Object *copy()       {_error_("not implemented yet"); };
                         };

issm/branches/trunk-jpl-damage/src/c/classes/bamg/BamgVertex.cpp

-              r12821
+              r13101
+                }
                 else{
                         _error2_("Metrictype " << Metrictype << " not supported yet (use 0,1 or 2(default))");
+                        _error_("Metrictype " << Metrictype << " not supported yet (use 0,1 or 2(default))");
+                }
 …
                         j = NextEdge[jc];
                         if (k>=2000){
                                 _error2_("k>=2000 (Maximum number of iterations reached)");
+                                _error_("k>=2000 (Maximum number of iterations reached)");
+                        }
                 } while ( tbegin != tria);
 …
                                 j = NextEdge[jc];
                                 if (k>=2000){
                                         _error2_("k>=2000");
+                                        _error_("k>=2000");
+                                }
                         }while ( tbegin != tria);

issm/branches/trunk-jpl-damage/src/c/classes/bamg/Edge.cpp

r12821	r13101
45	45
46	46	/some shecks/
47		if (!(adj[0]==&e \|\| adj[1]==&e)){ _error2_("Intersection bug"); }
	47	if (!(adj[0]==&e \|\| adj[1]==&e)){ _error_("Intersection bug"); }
48	48	_assert_(adj[0]==&e \|\| adj[1]==&e);
49	49

issm/branches/trunk-jpl-damage/src/c/classes/bamg/Geometry.cpp

-              r12821
+              r13101
                 //some checks
                 if (bamggeom->Vertices==NULL) _error2_("the domain provided does not contain any vertex");
                 if (bamggeom->Edges==NULL) _error2_("the domain provided does not contain any edge");
+                if (bamggeom->Vertices==NULL) _error_("the domain provided does not contain any vertex");
+                if (bamggeom->Edges==NULL) _error_("the domain provided does not contain any edge");
                 //Vertices
                 if (bamggeom->Vertices){
                         if(verbose>5) _printLine_("      processing Vertices");
                         if (bamggeom->VerticesSize[1]!=3) _error2_("Vertices should have 3 columns");
+                        if (bamggeom->VerticesSize[1]!=3) _error_("Vertices should have 3 columns");
                         vertices = new GeomVertex[nbv];
                         for (i=0;i<nbv;i++) {
 …
                          */
                         coefIcoor=(MaxICoor)/(Max(pmax.x-pmin.x,pmax.y-pmin.y));
                         if(coefIcoor<=0) _error2_("coefIcoor should be positive");
+                        if(coefIcoor<=0) _error_("coefIcoor should be positive");
+                }
                 else{
                         _error2_("No BamgVertex provided");
+                        _error_("No BamgVertex provided");
+                }
 …
                         if(verbose>5) _printLine_("      processing Edges");
                         if (bamggeom->EdgesSize[1]!=3) _error2_("Edges should have 3 columns");
+                        if (bamggeom->EdgesSize[1]!=3) _error_("Edges should have 3 columns");
                         edges = new GeomEdge[nbe];
 …
+                }
                 else{
                         _error2_("No edges provided");
+                        _error_("No edges provided");
+                }
 …
                 if (bamggeom->TangentAtEdges){
                         if(verbose>5) _printString_("      processing TangentAtEdges");
                         if (bamggeom->TangentAtEdgesSize[1]!=4) _error2_("TangentAtEdges should have 4 columns");
+                        if (bamggeom->TangentAtEdgesSize[1]!=4) _error_("TangentAtEdges should have 4 columns");
                         int n,i,j,k;
                         R2 tg;
 …
                                 tg.x=bamggeom->TangentAtEdges[k*4+2];
                                 tg.y=bamggeom->TangentAtEdges[k*4+3];
                                 if (i<0 || i>=nbe) _error2_("TangentAtEdges first index exceeds matrix dimension");
                                 if (j!=0 && j!=1)  _error2_("TangentAtEdges second index should be 1 or 2 only");
+                                if (i<0 || i>=nbe) _error_("TangentAtEdges first index exceeds matrix dimension");
+                                if (j!=0 && j!=1)  _error_("TangentAtEdges second index should be 1 or 2 only");
                                 edges[i].tg[j] = tg;
+                        }
 …
                 if(bamggeom->Corners){
                         if(verbose>5) _printString_("      processing Corners");
                         if (bamggeom->CornersSize[1]!=1) _error2_("Corners should have 1 column");
+                        if (bamggeom->CornersSize[1]!=1) _error_("Corners should have 1 column");
                         n=bamggeom->CornersSize[0];
                         for (i=0;i<n;i++) {
                                 j=(int)bamggeom->Corners[i]-1; //for C indexing
                                 if (j>nbv-1 || j<0) _error2_("Bad corner definition: should in [0 " << nbv << "]");
+                                if (j>nbv-1 || j<0) _error_("Bad corner definition: should in [0 " << nbv << "]");
                                 /*Required => at the same time SetRequired and SetCorner*/
                                 vertices[j].SetCorner();
 …
                 if(bamggeom->RequiredVertices){
                         if(verbose>5) _printLine_("      processing RequiredVertices");
                         if (bamggeom->RequiredVerticesSize[1]!=1) _error2_("RequiredVertices should have 1 column");
+                        if (bamggeom->RequiredVerticesSize[1]!=1) _error_("RequiredVertices should have 1 column");
                         n=bamggeom->RequiredVerticesSize[0];
                         for (i=0;i<n;i++) {
                                 j=(int)bamggeom->RequiredVertices[i]-1; //for C indexing
                                 if (j>nbv-1 || j<0) _error2_("Bad RequiredVerticess  definition: should in [0 " << nbv << "]");
+                                if (j>nbv-1 || j<0) _error_("Bad RequiredVerticess  definition: should in [0 " << nbv << "]");
                                 vertices[j].SetRequired();
+                        }
 …
                 if(bamggeom->RequiredEdges){
                         if(verbose>5) _printLine_("      processing RequiredEdges");
                         if (bamggeom->RequiredEdgesSize[1]!=1) _error2_("RequiredEdges should have 1 column");
+                        if (bamggeom->RequiredEdgesSize[1]!=1) _error_("RequiredEdges should have 1 column");
                         n=bamggeom->RequiredEdgesSize[0];
                         for (i=0;i<n;i++) {
                                 j=(int)bamggeom->RequiredEdges[i]-1; //for C indexing
                                 if (j>nbe-1 || j<0) _error2_("Bad RequiredEdges definition: should in [0 " << nbe << "]");
+                                if (j>nbe-1 || j<0) _error_("Bad RequiredEdges definition: should in [0 " << nbe << "]");
                                 edges[j].SetRequired();
+                        }
 …
                 if(bamggeom->SubDomains){
                         if(verbose>5) _printLine_("      processing SubDomains");
                         if (bamggeom->SubDomainsSize[1]!=4) _error2_("SubDomains should have 4 columns");
+                        if (bamggeom->SubDomainsSize[1]!=4) _error_("SubDomains should have 4 columns");
                         nbsubdomains=bamggeom->SubDomainsSize[0];
                         subdomains = new GeomSubDomain[nbsubdomains];
 …
                                 i2=(int)bamggeom->SubDomains[i*4+2];
                                 i3=(int)bamggeom->SubDomains[i*4+3];
                                 if (i0!=2) _error2_("Bad Subdomain definition: first number should be 2 (for Edges)");
                                 if (i1>nbe || i1<=0) _error2_("Bad Subdomain definition: second number should in [1 " << nbe << "] (edge number)");
+                                if (i0!=2) _error_("Bad Subdomain definition: first number should be 2 (for Edges)");
+                                if (i1>nbe || i1<=0) _error_("Bad Subdomain definition: second number should in [1 " << nbe << "] (edge number)");
                                 subdomains[i].edge=edges + (i1-1);
                                 subdomains[i].direction = (int) i2;
 …
                                 delete [] head_v;
                                 delete [] eangle;
                                 _error2_("two points of the geometry are very closed to each other (see reference numbers above)");
+                                _error_("two points of the geometry are very closed to each other (see reference numbers above)");
+                        }
 …
                                 delete [] head_v;
                                 delete [] eangle;
                                 _error2_("Length of edge " << i << " is 0");
+                                _error_("Length of edge " << i << " is 0");
+                        }
                         //compute angle in [-Pi Pi]
 …
                                 long i1 = n1/2 ,j1=n1%2;
                                 if( edges[i1].v[j1] != edges[i].v[j]) _error2_("Problem while processing edges: check the edge list");
+                                if( edges[i1].v[j1] != edges[i].v[j]) _error_("Problem while processing edges: check the edge list");
                                 edges[i1].Adj[j1] = edges + i;
 …
                 GeomEdge* on=e.GeomEdgeHook;
                 if (!on){
                         _error2_("ProjectOnCurve error message: edge provided should be on geometry");
+                        _error_("ProjectOnCurve error message: edge provided should be on geometry");
+                }
                 if (!e[0].GeomEdgeHook ||  !e[1].GeomEdgeHook){
                         _error2_("ProjectOnCurve error message: at least one of the vertex of the edge provided is not on geometry");
+                        _error_("ProjectOnCurve error message: at least one of the vertex of the edge provided is not on geometry");
+                }
 …
                                         _printLine_(" 2)  code bug : be sure that we call   Mesh::SetVertexFieldOn() before");
                                         _printLine_("To solve the problem do a coarsening of the geometrical mesh or change the constant value of mxe (dangerous)");
                                         _error2_("see above");
+                                        _error_("see above");
+                                }
                                 NbTry++;
 …
                                 _printLine_(" 2)  code bug : be sure that we call   Mesh::SetVertexFieldOn() before");
                                 _printLine_("To solve the problem do a coarsening of the geometrical mesh or change the constant value of mxe (dangerous)");
                                 _error2_("see above");
+                                _error_("see above");
+                        }
                         GeomEdge* tmpge = eg1;

issm/branches/trunk-jpl-damage/src/c/classes/bamg/ListofIntersectionTriangles.cpp

r12821	r13101
38	38	// check Size
39	39	if (Size<=0){
40		_error2_("Size<=0");
	40	_error_("Size<=0");
41	41	}
42	42
…	…
268	268	k=(t)(0) ? (( (t)(1) ? ( (*t)(2) ? -1 : 2) : 1 )) : 0;
269	269	if (k<0){
270		_error2_("k<0");
	270	_error_("k<0");
271	271	}
272	272	ocut = OppositeEdge[k];
…	…
312	312	double dij = detj-deti;
313	313	if (i+j+k != 0 + 1 +2){
314		_error2_("i+j+k != 0 + 1 +2");
	314	_error_("i+j+k != 0 + 1 +2");
315	315	}
316	316	ba[j] = detj/dij;
…	…
384	384	}
385	385	else {
386		_error2_("Bug Split Edge");
	386	_error_("Bug Split Edge");
387	387	}
388	388	}

issm/branches/trunk-jpl-damage/src/c/classes/bamg/ListofIntersectionTriangles.h

r12821	r13101
34	34	double c01=lEnd-lBegin, c0=(lEnd-s)/c01, c1=(s-lBegin)/c01;
35	35	if (lBegin>s \|\| s>lEnd){
36		_error2_("lBegin>s \|\| s>lEnd");
	36	_error_("lBegin>s \|\| s>lEnd");
37	37	}
38	38	return e->F(sBeginc0+sEndc1);

issm/branches/trunk-jpl-damage/src/c/classes/bamg/Mesh.cpp

-              r12946
+              r13101
                           delete [] kk;
                           delete [] refv;
                           _error2_("imaxnbv != nbv");
+                          _error_("imaxnbv != nbv");
+                  }
                   for (i=0;i<Tho.nbt;i++)
 …
                                 if (i0<0 || i1<0 || i2<0){
                                         delete [] refv;
                                         _error2_("i0<0 || i1<0 || i2< 0");
+                                        _error_("i0<0 || i1<0 || i2< 0");
+                                }
                                 if (i0>=Tho.nbv || i1>=Tho.nbv || i2>=Tho.nbv){
                                         _error2_("i0>=Tho.nbv || i1>=Tho.nbv || i2>=Tho.nbv");
+                                        _error_("i0>=Tho.nbv || i1>=Tho.nbv || i2>=Tho.nbv");
+                                }
                                 triangles[nbt] = Triangle(this,kk[i0],kk[i1],kk[i2]);
 …
+                          }
                   if (kt!=nbt){
                           _error2_("kt!=nbt");
+                          _error_("kt!=nbt");
+                  }
                   if (nbt==0 && nbv==0) {
                           _error2_("All triangles have been removed");
+                          _error_("All triangles have been removed");
+                  }
                   delete [] kk;
 …
                   if (!nbsubdomains){
                           _error2_("nbsubdomains==0");
+                          _error_("nbsubdomains==0");
+                  }
                   if (!subdomains[0].head || !subdomains[0].head->link){
                           _error2_("!subdomains[0].head || !subdomains[0].head->link");
+                          _error_("!subdomains[0].head || !subdomains[0].head->link");
+                  }
 …
+                        }
+                }
                 if(isorphan) _error2_("Orphan found in mesh, see ids above");
+                if(isorphan) _error_("Orphan found in mesh, see ids above");
                 /*Clean up*/
 …
+                }
                 else{
                         if(verbose>5) _error2_("no Vertices found in the initial mesh");
+                        if(verbose>5) _error_("no Vertices found in the initial mesh");
+                }
 …
+                }
                 else{
                         if(verbose>5) _error2_("no Triangles found in the initial mesh");
+                        if(verbose>5) _error_("no Triangles found in the initial mesh");
+                }
 …
                                 //Check value
                                 if(!(i>=0 && j>=0 && i<nbe && j<Gh.nbe)) {
                                         _error2_("ReadMesh error: EdgesOnGeomEdge edge provided (line " << i1+1 << ": [" << i+1 << " " << j+1 << "]) is incorrect (must be positive, [0<i<nbe=" << nbe << " 0<j<Gh.nbe=" << Gh.nbe << "]");
+                                        _error_("ReadMesh error: EdgesOnGeomEdge edge provided (line " << i1+1 << ": [" << i+1 << " " << j+1 << "]) is incorrect (must be positive, [0<i<nbe=" << nbe << " 0<j<Gh.nbe=" << Gh.nbe << "]");
+                                }
                                 edges[i].GeomEdgeHook=Gh.edges+j;
 …
                                 head=(int)bamgmesh->SubDomains[i*3+1]-1;//C indexing
                                 direction=(int)bamgmesh->SubDomains[i*3+2];
                                 if (i3!=23) _error2_("Bad Subdomain definition: first number should be 3");
                                 if (head<0 || head>=nbt) _error2_("Bad Subdomain definition: head should in [1 " << nbt << "] (triangle number)");
+                                if (i3!=23) _error_("Bad Subdomain definition: first number should be 3");
+                                if (head<0 || head>=nbt) _error_("Bad Subdomain definition: head should in [1 " << nbt << "] (triangle number)");
                                 subdomains[i].head = triangles+head;
+                        }
 …
                                 for (j=0;j<3;j++){
                                         int v=GetId(triangles[i][j]); //jth vertex of the ith triangle
                                         if (k>3*nbt-1 || k<0) _error2_("k = " << k << ", nbt = " << nbt);
+                                        if (k>3*nbt-1 || k<0) _error_("k = " << k << ", nbt = " << nbt);
                                         next_1[k]=head_1[v];
                                         if (v>nbv-1 || v<0)   _error2_("v = " << v << ", nbv = " << nbv);
+                                        if (v>nbv-1 || v<0)   _error_("v = " << v << ", nbv = " << nbv);
                                         head_1[v]=k++;
                                         connectivitysize_1[v]+=1;
 …
+                                }
                                 if (!stop){
                                         _error2_("Element holding segment [" << i1+1 << " " << i2+1 << "] not found...");
+                                        _error_("Element holding segment [" << i1+1 << " " << i2+1 << "] not found...");
+                                }
+                        }
 …
                                 const VertexOnGeom &v=VerticesOnGeomEdge[i];
                                 if (!v.OnGeomEdge()){
                                         _error2_("A vertices supposed to be OnGeomEdge is actually not");
+                                        _error_("A vertices supposed to be OnGeomEdge is actually not");
+                                }
                                 bamgmesh->VerticesOnGeomEdge[i*3+0]=GetId((BamgVertex*)v)+1; //back to Matlab indexing
 …
                         for (j=0;j<2;j++){
                                 int v=(int)bamgmesh->IssmEdges[i*i2+j]-1; //back to C indexing
                                 if (k>2*i1-1 || k<0) _error2_("Index exceed matrix dimensions (k=" << k << " not in [0 " << 2*i1-1 << "]");
+                                if (k>2*i1-1 || k<0) _error_("Index exceed matrix dimensions (k=" << k << " not in [0 " << 2*i1-1 << "]");
                                 next_2[k]=head_2[v];
                                 if (v>nbv-1 || v<0)   _error2_("Index exceed matrix dimensions (v=" << v << " not in [0 " << nbv-1 << "])");
+                                if (v>nbv-1 || v<0)   _error_("Index exceed matrix dimensions (v=" << v << " not in [0 " << nbv-1 << "])");
                                 head_2[v]=k++;
                                 connectivitysize_2[v]+=1;
 …
                 //check that hmax is positive
                 if (hmax<=0){
                         _error2_("hmax<=0");
+                        _error_("hmax<=0");
+                }
 …
                                 if (ht<=0 || hn<=0){
                                         _error2_("ht<=0 || hn<=0");
+                                        _error_("ht<=0 || hn<=0");
+                                }
                                 EigenMetric Vp(1/(ht*ht),1/(hn*hn),tg);
 …
+                }
                 else{
                         _error2_("Hessiantype " << Hessiantype << " not supported yet (1->use Green formula, 0-> double P2 projection)");
+                        _error_("Hessiantype " << Hessiantype << " not supported yet (1->use Green formula, 0-> double P2 projection)");
+                }
+        }
 …
                 //some checks
                 if (( infvertexindex <0 ) && (detOld <0) ||  ( infvertexindex >=0  ) && (detOld >0) ){
                         _error2_("inconsistent configuration (Contact ISSM developers)");
+                        _error_("inconsistent configuration (Contact ISSM developers)");
+                }
 …
+                        }
                         else{
                                 _error2_("Cannot add a vertex more than once. Check duplicates");
+                                _error_("Cannot add a vertex more than once. Check duplicates");
+                        }
+                }
 …
                 tt[2]= &triangles[nbt++];
                 if (nbt>maxnbt) _error2_("Not enough triangles");
+                if (nbt>maxnbt) _error_("Not enough triangles");
                 *tt[1]=*tt[2]=*t;
 …
                         if (!rswap) {
                                 _error2_("swap the point s is on a edge");
+                                _error_("swap the point s is on a edge");
+                        }
+                }
 …
                 //check that the mesh is not empty
                 if (nbt<=0 || nbv <=0 ) {
                         _error2_("nbt or nbv is negative (Mesh empty?)");
+                        _error_("nbt or nbv is negative (Mesh empty?)");
+                }
 …
                 if (nbe !=  edge4->nb()){
                         delete [] st;
                         _error2_("Some Double edge in the mesh, the number is " << nbe << ", nbe4=" << edge4->nb());
+                        _error_("Some Double edge in the mesh, the number is " << nbe << ", nbe4=" << edge4->nb());
+                }
                 //keep nbe in nbeold
 …
                                         //check that it is not an edge on boundary (should not already exist)
                                         if (triangles[i].TriangleAdj(j) || triangles[st[k]/3].TriangleAdj((int) (st[k]%3))){
                                                 _error2_("problem in Geometry reconstruction: an edge on boundary is duplicated (double element?)");
+                                                _error_("problem in Geometry reconstruction: an edge on boundary is duplicated (double element?)");
+                                        }
                                         //OK, the element is not on boundary, is belongs to 2 triangles -> build Adjacent triangles list
 …
                                         _printLine_("Edge " << (-st[k]+2)%3 << " of triangle " << (-st[k]+2)/3);
                                         _printLine_("Edge " << triangles[(-st[k]+2)/3].NuEdgeTriangleAdj((int)((-st[k]+2)%3)) << " of triangle " << GetId(triangles[(-st[k]+2)/3].TriangleAdj((int)((-st[k]+2)%3))));
                                         _error2_("An edge belongs to more than 2 triangles");
+                                        _error_("An edge belongs to more than 2 triangles");
+                                }
+                        }
 …
                         //check that we have been through all edges
                         if (k!=nbe){
                                 _error2_("problem in edge construction process: k!=nbe (should not happen)");
+                                _error_("problem in edge construction process: k!=nbe (should not happen)");
+                        }
                         //delete edgessave
 …
                                         //check that we have the correct vertex
                                         if (v!=edges[i0 ].v[j0]){
                                                 _error2_("v!=edges[i0 ].v[j0]: this should not happen as the vertex belongs to this edge");
+                                                _error_("v!=edges[i0 ].v[j0]: this should not happen as the vertex belongs to this edge");
+                                        }
 …
                 //check that nbsubdomains is empty
                 if (nbsubdomains){
                         _error2_("nbsubdomains should be 0");
+                        _error_("nbsubdomains should be 0");
+                }
                 nbsubdomains=0;
 …
                 if (k!= nbsubdomains){
                         delete [] colorT;
                         _error2_("k!= nbsubdomains");
+                        _error_("k!= nbsubdomains");
+                }
                 //delete colorT and st
 …
                 if (Gh.coefIcoor<=0){
                         delete [] colorV;
                         _error2_("Gh.coefIcoor<=0 in infered Geometry (this should not happen)");
+                        _error_("Gh.coefIcoor<=0 in infered Geometry (this should not happen)");
+                }
 …
                                 delete [] len;
                                 delete [] colorV;
                                 _error2_("problem in Edge4 construction: k != i");
+                                _error_("problem in Edge4 construction: k != i");
+                        }
+                }
 …
+                        }
                         else
                          _error2_("%i should be >=0");
+                         _error_("%i should be >=0");
+                  }
 …
                 /*Check size*/
                 if (bamgopts->fieldSize[0] != nbv) _error2_("'field' should have " << nbv << " rows");
+                if (bamgopts->fieldSize[0] != nbv) _error_("'field' should have " << nbv << " rows");
                 //initialization of some variables
 …
                 /*Check size*/
                 if (bamgopts->fieldSize[0] != nbv) _error2_("'field' should have " << nbv << " rows");
+                if (bamgopts->fieldSize[0] != nbv) _error_("'field' should have " << nbv << " rows");
                 //initialization of some variables
 …
                                 if (splitvertex[i1]==3 || splitvertex[i2]==3){
                                         delete [] splitvertex;
                                         _error2_("Crossing rifts not supported yet");
+                                        _error_("Crossing rifts not supported yet");
+                                }
+                        }
 …
                                 //_printLine_(element_renu[GetId(ta.t)] << " -> " << GetId((*ta.t)[0])+1 << " " << GetId((*ta.t)[1])+1 << " " << GetId((*ta.t)[2])+1 << ", edge [" << i1 << "->" << j1 << " " << i2 << "->" << j2 << "]");
                                 ta = Next(ta).Adj();
                                 if (count++>50) _error2_("Maximum number of iteration exceeded");
+                                if (count++>50) _error_("Maximum number of iteration exceeded");
                         }while ((tbegin != ta));
+                }
 …
                 for(i=0;i<NbCrackedEdges;i++){
                         if (Edgeflags[i]!=2){
                                 _error2_("A problem occured: at least one crack edge (number " << i+1 << ") does not belong to 2 elements");
+                                _error_("A problem occured: at least one crack edge (number " << i+1 << ") does not belong to 2 elements");
+                        }
+                }
 …
+                        }
                         if (k!=0) {
                                 _error2_("there is " << k << " triangles of mes = 0");
+                                _error_("there is " << k << " triangles of mes = 0");
+                        }
 …
                                 if (nbswp) nbfe++;
                                 if ( nbswp < 0 && k < 5){
                                         _error2_("Missing Edge " << i << ", v0=" << GetId(edges[i][0]) << ",v1=" << GetId(edges[i][1]));
+                                        _error_("Missing Edge " << i << ", v0=" << GetId(edges[i][0]) << ",v1=" << GetId(edges[i][1]));
+                                }
+                        }
                         if (k!=0) {
                                 _error2_("There are " << k << " lost edges, the boundary might be crossing");
+                                _error_("There are " << k << " lost edges, the boundary might be crossing");
+                        }
                         for (int j=0;j<nbv;j++){
 …
                         if (nbt == nbtout ||  !NbSubDomTot) {
                                 delete [] HeapArete;
                                 _error2_("The boundary is not close: all triangles are outside");
+                                _error_("The boundary is not close: all triangles are outside");
+                        }
 …
                                                 if (k!=nbsubdomains){
                                                         delete [] mark;
                                                         _error2_("k!=nbsubdomains");
+                                                        _error_("k!=nbsubdomains");
+                                                }
                                                 if(OutSide)
 …
                                                          subdomains[i].head=t=ta;
                                                         if(t<triangles || t >= triangles+nbt || t->det < 0 || t->link == 0) {
                                                                 _error2_("bad definition of SubSomain " << i);
+                                                                _error_("bad definition of SubSomain " << i);
+                                                        }
                                                         long it = GetId(t);
 …
                                                                 kkk++;
                                                                 if (mark[GetId(tt)]>=0){
                                                                         _error2_("mark[GetId(tt)]>=0");
+                                                                        _error_("mark[GetId(tt)]>=0");
+                                                                }
                                                                 mark[GetId(tt)]=i;
 …
                                                 ta = Previous(Adj(ta));
                                                 if(t == (Triangle *) ta) {
                                                         _error2_("bad definition of SubSomain " << i);
+                                                        _error_("bad definition of SubSomain " << i);
+                                                }
+                                        }
 …
                         //if i is higher than nbv, it means that all the determinants are 0,
                         //all vertices are aligned!
                         if  (++i>=nbv) _error2_("all the vertices are aligned");
+                        if  (++i>=nbv) _error_("all the vertices are aligned");
+                }
                 // exchange i et 2 in "orderedvertices" so that
 …
                                 long  j=vj.ReferenceNumber;
                                 if (&vj!=orderedvertices[j]){
                                         _error2_("&vj!= orderedvertices[j]");
+                                        _error_("&vj!= orderedvertices[j]");
+                                }
                                 if(i!=j){
 …
                                 if (tcvj && !tcvj->link){
                                         tcvj->Echo();
                                         _error2_("problem inserting point in InsertNewPoints (tcvj=" << tcvj << " and tcvj->link=" << tcvj->link << ")");
+                                        _error_("problem inserting point in InsertNewPoints (tcvj=" << tcvj << " and tcvj->link=" << tcvj->link << ")");
+                                }
                                 quadtree->Add(vj);
 …
                 if (!Gh.nbe){
                         _error2_("!Gh.nbe");
+                        _error_("!Gh.nbe");
+                }
                 Edge **e= new (Edge* [Gh.nbe]);
 …
+                        }
+                }
                 if(kk) _error2_("See above");
+                if(kk) _error_("See above");
                 return e;
 …
                                 //check i
                                 if (i<0 || i>=nbt ){
                                         _error2_("Index problem in NewPoints (i=" << i << " not in [0 " << nbt-1 << "])");
+                                        _error_("Index problem in NewPoints (i=" << i << " not in [0 " << nbt-1 << "])");
+                                }
                                 //change first_np_or_next_t[i]
 …
+                                        }
                                         if (ta.EdgeVertex(0)!=s){
                                                 _error2_("ta.EdgeVertex(0)!=s");
+                                                _error_("ta.EdgeVertex(0)!=s");
+                                        }
                                         ta = Next(Adj(ta));
 …
+                }
                 else {
                         _error2_("ProjectOnCurve On BamgVertex " << BTh.GetId(vA) << " forget call to SetVertexFieldOnBTh");
+                        _error_("ProjectOnCurve On BamgVertex " << BTh.GetId(vA) << " forget call to SetVertexFieldOnBTh");
+                }
 …
+                }
                 else {
                         _error2_("ProjectOnCurve On BamgVertex " << BTh.GetId(vB) << " forget call to SetVertexFieldOnBTh");
+                        _error_("ProjectOnCurve On BamgVertex " << BTh.GetId(vB) << " forget call to SetVertexFieldOnBTh");
+                }
                 Edge * e = &BhAB;
                 if (!pA || !pB || !e){
                         _error2_("!pA || !pB || !e");
+                        _error_("!pA || !pB || !e");
+                }
                 // be carefull the back ground edge e is on same geom edge
 …
                 //check Is a background Mesh;
                 if (e<BTh.edges || e>=BTh.edges+BTh.nbe){
                         _error2_("e<BTh.edges || e>=BTh.edges+BTh.nbe");
+                        _error_("e<BTh.edges || e>=BTh.edges+BTh.nbe");
+                }
                 // walk on BTh edge
 …
+                  }
                 else{ // do the search by walking
                         _error2_("case not supported yet");
+                        _error_("case not supported yet");
+                  }
 …
+                  }
                 _error2_("Big bug...");
+                _error_("Big bug...");
                 return 0; // just for the compiler
+        }
 …
+        }
         if (kk != nbe){
                 _error2_("There are " << kk-nbe << " double edges in the mesh");
+                _error_("There are " << kk-nbe << " double edges in the mesh");
+        }
 …
                         //An edge belongs to 2 triangles
                         else {
                                 _error2_("The edge (" << GetId(triangles[i][VerticesOfTriangularEdge[j][0]]) << " , " << GetId(triangles[i][VerticesOfTriangularEdge[j][1]]) << ") belongs to more than 2 triangles");
+                                _error_("The edge (" << GetId(triangles[i][VerticesOfTriangularEdge[j][0]]) << " , " << GetId(triangles[i][VerticesOfTriangularEdge[j][1]]) << ") belongs to more than 2 triangles");
+                        }
+                }
 …
+        }
         if(k) {
                 _error2_(k << " boundary edges (from the geometry) are not defined as mesh edges");
+                _error_(k << " boundary edges (from the geometry) are not defined as mesh edges");
+        }
 …
         for (i=2;det(orderedvertices[0]->i,orderedvertices[1]->i,orderedvertices[i]->i)==0;)
          if  (++i>=nbvb) {
                  _error2_("ReconstructExistingMesh: All the vertices are aligned");
+                 _error_("ReconstructExistingMesh: All the vertices are aligned");
+         }
         //Move this vertex (i) to the 2d position in orderedvertices
 …
+        }
         if(nbloss) {
                 _error2_("we lost " << nbloss << " existing edges other " << knbe);
+                _error_("we lost " << nbloss << " existing edges other " << knbe);
+        }
 …
         subdomains = savesubdomains;
         if (k) {
                 _error2_("number of triangles edges alone = " << k);
+                _error_("number of triangles edges alone = " << k);
+        }
         FindSubDomain();
 …
                                                 _printLine_("This edge is on geometry and has no adjacent edge (open curve) and one of the tip is not required");
                                                 _error2_("See above (might be cryptic...)");
+                                                _error_("See above (might be cryptic...)");
+                                        }
+                                }
 …
                         t=t0=subdomains[i].head;
                         if (!t0){ // not empty sub domain
                                 _error2_("!t0");
+                                _error_("!t0");
+                        }
                         do {
                                 long kt = GetId(t);
                                 if (kt<0 || kt >= nbt ){
                                         _error2_("kt<0 || kt >= nbt");
+                                        _error_("kt<0 || kt >= nbt");
+                                }
                                 if (renu[kt]!=-1){
                                         _error2_("renu[kt]!=-1");
+                                        _error_("renu[kt]!=-1");
+                                }
                                 renu[kt]=k++;
 …
+                }
                 if (k != nbt){
                         _error2_("k != nbt");
+                        _error_("k != nbt");
+                }
                 // do the change on all the pointeur
 …
         coefIcoor= (MaxICoor)/(Max(pmax.x-pmin.x,pmax.y-pmin.y));
         if (coefIcoor<=0){
                 _error2_("coefIcoor should be positive, a problem in the geometry is likely");
+                _error_("coefIcoor should be positive, a problem in the geometry is likely");
+        }
 …
+        }
         if (number_of_errors) _error2_("Fatal error: some triangles have negative areas, see above");
+        if (number_of_errors) _error_("Fatal error: some triangles have negative areas, see above");
+}
 /*}}}*/
 …
                         register Triangle* t= vertices[i].t;
                         if (!t){
                                 _error2_("!t");
+                                _error_("!t");
+                        }
                         BamgVertex & vi = vertices[i];
 …
                                 ta=Previous(Adj(ta));
                                 if (vertices+i != ta.EdgeVertex(1)){
                                         _error2_("vertices+i != ta.EdgeVertex(1)");
+                                        _error_("vertices+i != ta.EdgeVertex(1)");
+                                }
                                 BamgVertex & vj = *(ta.EdgeVertex(0));
 …
                                         j= &vj-vertices;
                                         if (j<0 || j >= nbv){
                                                 _error2_("j<0 || j >= nbv");
+                                                _error_("j<0 || j >= nbv");
+                                        }
                                         R2 Aij = (R2) vj - (R2) vi;
 …
                                         // the first PB is to now a background edge between the 2 vertices
                                         if (!edgesGtoB){
                                                 _error2_("!edgesGtoB");
+                                                _error_("!edgesGtoB");
+                                        }
                                         ong= ProjectOnCurve(*edgesGtoB[Gh.GetId(edges[i].GeomEdgeHook)],
 …
                         Triangle & t = triangles[i];
                         if (!t.link){
                                 _error2_("!t.link");
+                                _error_("!t.link");
+                        }
                         for(int j=0;j<3;j++)
 …
                                                                                 ||   (cc=Area2( t[0].r , t[1].r , A.r    )) < 0.0)){
                                                         _printLine_(ke + nbvold << " not in triangle " << i << " In= " << !!t.link << " " << aa << " " << bb << " " << cc << " " << dd);
                                                         _error2_("Number of triangles with P2 interpolation Problem");
+                                                        _error_("Number of triangles with P2 interpolation Problem");
+                                                }
+                                        }
 …
                                                                                 ||   (cc=Area2( tt[0].r , tt[1].r , A.r     )) < 0)){
                                                         _printLine_(ke + nbvold << " not in triangle " << ii << " In= " << !!tt.link << " " << aa << " " << bb << " " << cc << " " << dd);
                                                         _error2_("Number of triangles with P2 interpolation Problem");
+                                                        _error_("Number of triangles with P2 interpolation Problem");
+                                                }
+                                        }
 …
                                                   } // tt
                                                 else
                                                  _error2_("Bug...");
+                                                 _error_("Bug...");
                                           } // ke<0
                                         else
 …
+                          }
                         if (nbinvisible>=2){
                                 _error2_("nbinvisible>=2");
+                                _error_("nbinvisible>=2");
+                        }
                         switch (nbsplitedge) {
 …
+                        }
                         if (ksplit[i]<40){
                                 _error2_("ksplit[i]<40");
+                                _error_("ksplit[i]<40");
+                        }
+                  }
 …
                         int  ke=(int) (ksplit[i]%10);
                         if (kk>=7 || kk<=0){
                                 _error2_("kk>=7 || kk<=0");
+                                _error_("kk>=7 || kk<=0");
+                        }
 …
                         if (nbmkadj>=10){
                                 _error2_("nbmkadj>=10");
+                                _error_("nbmkadj>=10");
+                        }
                         // --------------------------
 …
                                                         t1=t0;
                                                         if (kedge[3*i+i0]<0){
                                                                 _error2_("kedge[3*i+i0]<0");
+                                                                _error_("kedge[3*i+i0]<0");
+                                                        }
                                                         BamgVertex * v3 = vertices + kedge[3*i+k0];
 …
                                                         t2=t1=t0;
                                                         if (kedge[3*i+k1]<0){
                                                                 _error2_("kedge[3*i+k1]<0");
+                                                                _error_("kedge[3*i+k1]<0");
+                                                        }
                                                         if (kedge[3*i+k2]<0){
                                                                 _error2_("kedge[3*i+k2]<0");
+                                                                _error_("kedge[3*i+k2]<0");
+                                                        }
 …
                                                         t3=t2=t1=t0;
                                                         if (kedge[3*i+k0] <0 || kedge[3*i+k1]<0 || kedge[3*i+k2]<0){
                                                                 _error2_("kedge[3*i+k0] <0 || kedge[3*i+k1]<0 || kedge[3*i+k2]<0");
+                                                                _error_("kedge[3*i+k0] <0 || kedge[3*i+k1]<0 || kedge[3*i+k2]<0");
+                                                        }
                                                         BamgVertex * v12 = vertices + kedge[3*i+k0];
 …
+                                }
                         if (nbmkadj>13){// 13 = 6 + 4 +
                                 _error2_("nbmkadj>13");
+                                _error_("nbmkadj>13");
+                        }
 …
                         quadtree->Add(vi);
                         if (!tcvi || tcvi->det<0){// internal
                                 _error2_("!tcvi || tcvi->det < 0");
+                                _error_("!tcvi || tcvi->det < 0");
+                        }
                         AddVertex(vi,tcvi,det3);
 …
                 /*Check that the quadtree does exist*/
                 if (!quadtree) _error2_("no starting triangle provided and no quadtree available");
+                if (!quadtree) _error_("no starting triangle provided and no quadtree available");
                 /*Call NearestVertex*/
 …
                 /*Check output (Vertex a)*/
                 if (!a)    _error2_("problem while trying to find nearest vertex from a given point. No output found");
                 if (!a->t) _error2_("no triangle is associated to vertex number " << GetId(a)+1 << " (orphan?)");
+                if (!a)    _error_("problem while trying to find nearest vertex from a given point. No output found");
+                if (!a->t) _error_("no triangle is associated to vertex number " << GetId(a)+1 << " (orphan?)");
                 _assert_(a>=vertices && a<vertices+nbv);
 …
                 /*Increase counter*/
                 if (++counter>=10000) _error2_("Maximum number of iteration reached (threshold = " << counter << ").");
+                if (++counter>=10000) _error_("Maximum number of iteration reached (threshold = " << counter << ").");
                 j= OppositeVertex[jj];
 …
                 //check that the subdomain is not empty
                 if (!t0){ _error2_("At least one subdomain is empty");}
+                if (!t0){ _error_("At least one subdomain is empty");}
                 //loop
 …
                 //allocate
                 VerticesOnGeomVertex = new VertexOnGeom[NbVerticesOnGeomVertex];
                 if(NbVerticesOnGeomVertex >= maxnbv) _error2_("too many vertices on geometry: " << NbVerticesOnGeomVertex << " >= " << maxnbv);
+                if(NbVerticesOnGeomVertex >= maxnbv) _error_("too many vertices on geometry: " << NbVerticesOnGeomVertex << " >= " << maxnbv);
                 _assert_(nbv==0);
                 //Build VerticesOnGeomVertex
 …
                                                                 NbNewPoints=0;
                                                                 NbEdgeCurve=0;
                                                                 if (nbvend>=maxnbv) _error2_("maximum number of vertices too low! Check the domain outline or increase maxnbv");
+                                                                if (nbvend>=maxnbv) _error_("maximum number of vertices too low! Check the domain outline or increase maxnbv");
                                                                 lcurve =0;
                                                                 s = lstep; //-1 initially, then length of each sub edge
 …
                 printf("\n");
                 if(NbVerticesOnGeomVertex >= maxnbv){
                         _error2_("too many vertices on geometry: " << NbVerticesOnGeomVertex << " >= " << maxnbv);
+                        _error_("too many vertices on geometry: " << NbVerticesOnGeomVertex << " >= " << maxnbv);
+                }
 …
                 if (bfind!=Gh.nbcurves){
                         delete [] bcurve;
                         _error2_("problem generating number of curves (" << Gh.nbcurves << " found in the geometry but " << bfind << " curve found in the mesh)");
+                        _error_("problem generating number of curves (" << Gh.nbcurves << " found in the geometry but " << bfind << " curve found in the mesh)");
+                }
 …
                                                                         double se= (sNew-L0)/LAB;
                                                                         if (se<0 || se>=1.000000001){
                                                                                 _error2_("Problem creating point on a boundary: se=" << se << " should be in [0 1]");
+                                                                                _error_("Problem creating point on a boundary: se=" << se << " should be in [0 1]");
+                                                                        }
                                                                         se = abscisseInterpole(v0.m,v1.m,AB,se,1);
                                                                         if (se<0 || se>1){
                                                                                 _error2_("Problem creating point on a boundary: se=" << se << " should be in [0 1]");
+                                                                                _error_("Problem creating point on a boundary: se=" << se << " should be in [0 1]");
+                                                                        }
                                                                         se = k1         ? se : 1. - se;
 …
+                                                        }
                                                         if (!ee.adj[k1]) {
                                                                 _error2_("adj edge " << BTh.GetId(ee) << ", nbe=" << nbe << ", Gh.vertices=" << Gh.vertices);
+                                                                _error_("adj edge " << BTh.GetId(ee) << ", nbe=" << nbe << ", Gh.vertices=" << Gh.vertices);
+                                                        }
                                                         pe = ee.adj[k1]; // next edge
 …
                         if(step==0){
                                 if(nbv+NbOfNewPoints > maxnbv) {
                                         _error2_("too many vertices on geometry: " << nbv+NbOfNewPoints << " >= " << maxnbv);
+                                        _error_("too many vertices on geometry: " << nbv+NbOfNewPoints << " >= " << maxnbv);
+                                }
                                 edges = new Edge[NbOfNewEdge];
 …
                 int dir=0;
                 if (k<0){
                         _error2_("k<0");
+                        _error_("k<0");
+                }
                 int kkk=0;
 …
                         kkk++;
                         if (kkk>=1000){
                                 _error2_("kkk>=1000");
+                                _error_("kkk>=1000");
+                        }
                         BamgVertex  &vI =  *edge.EdgeVertex(0);
 …
                                                         double IJ2 = IJ_IA + IJ_AJ;
                                                         if (IJ2==0){
                                                                 _error2_("IJ2==0");
+                                                                _error_("IJ2==0");
+                                                        }
                                                         a= IJ_AJ/IJ2;
 …
         int NbSwap =0;
         if (!a.t || !b.t){ // the 2 vertex is in a mesh
                 _error2_("!a.t || !b.t");
+                _error_("!a.t || !b.t");
+        }
         int k=0;
 …
                 vbegin =v2;
                 if (!v2){
                         _error2_("!v2");
+                        _error_("!v2");
+                }
                 det2 = det(*v2,a,b);
 …
                         tc = Previous(tc);
                         if (!v1 || !v2){
                                 _error2_("!v1 || !v2");
+                                _error_("!v1 || !v2");
+                        }
                         Icoor2 detss = 0,l=0,ks;
                         while ((ks=SwapForForcingEdge(  va,  vb, tc, detss, det1,det2,NbSwap)))
                          if(l++ > 10000000) {
                                  _error2_("Loop in forcing Egde, nb de swap=" << NbSwap << ", nb of try swap (" << l << ") too big");
+                                 _error_("Loop in forcing Egde, nb de swap=" << NbSwap << ", nb of try swap (" << l << ") too big");
+                         }
                         BamgVertex *aa = tc.EdgeVertex(0), *bb = tc.EdgeVertex(1);
 …
                 k++;
                 if (k>=2000){
                         _error2_("k>=2000");
+                        _error_("k>=2000");
+                }
                 if ( vbegin == v2 ) return -1;// error
 …
                 short a1=tt1,a2=tt2;// les 2 numero de l arete dans les 2 triangles
                 if ( a1<0 || a1>=3 ){
                         _error2_("a1<0 || a1>=3");
+                        _error_("a1<0 || a1>=3");
+                }
 …
                 Icoor2 detT = det1+det2;
                 if ((det1<=0 ) || (det2<=0)){
                         _error2_("(det1<=0 ) || (det2<=0)");
+                        _error_("(det1<=0 ) || (det2<=0)");
+                }
                 if ( (detsa>=0) || (detsb<=0) ){ // [a,b] cut infinite line va,bb
                         _error2_("(detsa>=0) || (detsb<=0)");
+                        _error_("(detsa>=0) || (detsb<=0)");
+                }
                 Icoor2 ndet1 = bamg::det(s1,sa,s2);

issm/branches/trunk-jpl-damage/src/c/classes/bamg/Metric.cpp

r12821	r13101
197	197	// warning for optimisation S is in [0:0.5] not in [0:1]
198	198	if (i>=512){
199		_error2_("i>=512");
	199	_error_("i>=512");
200	200	}
201	201	LastMetricInterpole.lab=l;
…	…
345	345	}
346	346	if (r>1 \|\| r<0){
347		_error2_("r>1 \|\| r<0");
	347	_error_("r>1 \|\| r<0");
348	348	}
349	349	return r ;

issm/branches/trunk-jpl-damage/src/c/classes/bamg/SetOfE4.cpp

r12821	r13101
50	50	//check that nbax <=NbOfEdges
51	51	if (nbax <=NbOfEdges ) {
52		_error2_("SetOfEdges4::add overflow: NbOfEdges=" << NbOfEdges << " > nbax=" << nbax);
	52	_error_("SetOfEdges4::add overflow: NbOfEdges=" << NbOfEdges << " > nbax=" << nbax);
53	53	}
54	54

issm/branches/trunk-jpl-damage/src/c/classes/bamg/SubDomain.cpp

-              r12821
+              r13101
                 *this = Th.subdomains[i];
                 if ( head-Th.triangles<0 || head-Th.triangles>=Th.nbt){
                         _error2_("head-Th.triangles<0 || head-Th.triangles>=Th.nbt");
+                        _error_("head-Th.triangles<0 || head-Th.triangles>=Th.nbt");
+                }
                 head = ThNew.triangles + Th.GetId(head) ;
                 if (edge-Th.edges<0 || edge-Th.edges>=Th.nbe);{
                         _error2_("edge-Th.edges<0 || edge-Th.edges>=Th.nbe");
+                        _error_("edge-Th.edges<0 || edge-Th.edges>=Th.nbe");
+                }
                 edge = ThNew.edges+ Th.GetId(edge);

issm/branches/trunk-jpl-damage/src/c/classes/bamg/Triangle.cpp

-              r12821
+              r13101
                 long nbv = Th->nbv;
                 if (i<0 || j<0 || k<0){
                         _error2_("i<0 || j<0 || k<0");
+                        _error_("i<0 || j<0 || k<0");
+                }
                 if (i>=nbv || j>=nbv || k>=nbv){
                         _error2_("i>=nbv || j>=nbv || k>=nbv");
+                        _error_("i>=nbv || j>=nbv || k>=nbv");
+                }
                 vertices[0]=v+i;
 …
                         //check number of iterations
                         if (k>=2000){
                                 _error2_("too many iteration in Triangle::FindBoundaryEdge (k>=2000)");
+                                _error_("too many iteration in Triangle::FindBoundaryEdge (k>=2000)");
+                        }
                 } while (this!= t);
 …
                 do {
                         while (t->swap(j,koption)){
                                 if (k>=20000) _error2_("k>=20000");
+                                if (k>=20000) _error_("k>=20000");
                                 NbSwap++;
                                 k++;

issm/branches/trunk-jpl-damage/src/c/classes/gauss/GaussPenta.cpp

r12832	r13101
119	119	}
120	120	else{
121		_error2_("Penta not supported yet");
	121	_error_("Penta not supported yet");
122	122	}
123	123
…	…
159	159	}
160	160	else{
161		_error2_("Tria not supported yet");
	161	_error_("Tria not supported yet");
162	162	}
163	163
…	…
221	221	}
222	222	else{
223		_error2_("Tria not supported yet (user provided indices " << index1 << " " << index2 << " " << index3 << " " << index4 << ")");
	223	_error_("Tria not supported yet (user provided indices " << index1 << " " << index2 << " " << index3 << " " << index4 << ")");
224	224	}
225	225
…	…
340	340	break;
341	341	default:
342		_error2_("vertex index should be in [0 5]");
	342	_error_("vertex index should be in [0 5]");
343	343
344	344	}
…	…
359	359	}
360	360	else{
361		_error2_("Tria not supported yet");
	361	_error_("Tria not supported yet");
362	362	}
363	363

issm/branches/trunk-jpl-damage/src/c/classes/gauss/GaussTria.cpp

-              r12832
+              r13101
+        }
         else
          _error2_("The 2 indices provided are not supported yet (user provided " << index1 << " and " << index2 << ")");
+         _error_("The 2 indices provided are not supported yet (user provided " << index1 << " and " << index2 << ")");
         /*Initialize static fields as undefined*/
 …
+        }
         else
          _error2_("The 2 indices provided are not supported yet (user provided " << index1 << " and " << index2 << ")");
+         _error_("The 2 indices provided are not supported yet (user provided " << index1 << " and " << index2 << ")");
+}
 …
 /*}}}*/
 /*FUNCTION GaussTria::GaussFromCoords{{{*/
 void GaussTria::GaussFromCoords(IssmPDouble x,IssmPDouble y,IssmPDouble* xyz_list){
+void GaussTria::GaussFromCoords(IssmDouble x,IssmDouble y,IssmDouble* xyz_list){
         /*Intermediaries*/
         IssmPDouble    area = 0;
         IssmPDouble    x1,y1,x2,y2,x3,y3;
+        IssmDouble    area = 0;
+        IssmDouble    x1,y1,x2,y2,x3,y3;
         /*in debugging mode: check that the default constructor has been called*/
 …
                         break;
                 default:
                         _error2_("vertex index should be in [0 2]");
+                        _error_("vertex index should be in [0 2]");
+        }

issm/branches/trunk-jpl-damage/src/c/classes/gauss/GaussTria.h

-              r12822
+              r13101
         public:
                 IssmPDouble weight;
                 IssmPDouble coord1;
                 IssmPDouble coord2;
                 IssmPDouble coord3;
+                IssmDouble coord1;
+                IssmDouble coord2;
+                IssmDouble coord3;
         public:
 …
                 int  end(void);
                 void Echo(void);
                 void GaussFromCoords(IssmPDouble x1,IssmPDouble y1,IssmPDouble* xyz_list);
+                void GaussFromCoords(IssmDouble x1,IssmDouble y1,IssmDouble* xyz_list);
                 void GaussPoint(int ig);
                 void GaussVertex(int iv);

issm/branches/trunk-jpl-damage/src/c/classes/kriging/ExponentialVariogram.cpp

r12821	r13101
39	39
40	40	/Checks/
41		if(nugget==sill) _error2_("nugget and sill cannot be equal (constant semivariogram not allowed)");
	41	if(nugget==sill) _error_("nugget and sill cannot be equal (constant semivariogram not allowed)");
42	42	}
43	43	/}}}/

issm/branches/trunk-jpl-damage/src/c/classes/kriging/ExponentialVariogram.h

-              r12821
+              r13101
                 /*Object virtual functions definitions*/
                 void  Echo();
                 void  DeepEcho(){_error2_("Not implemented yet");};
                 int   Id(){_error2_("Not implemented yet");};
                 int   MyRank(){_error2_("Not implemented yet");};
                 int   ObjectEnum(){_error2_("Not implemented yet");};
                 Object* copy(){_error2_("Not implemented yet");};
+                void  DeepEcho(){_error_("Not implemented yet");};
+                int   Id(){_error_("Not implemented yet");};
+                int   MyRank(){_error_("Not implemented yet");};
+                int   ObjectEnum(){_error_("Not implemented yet");};
+                Object* copy(){_error_("Not implemented yet");};
                 /*Variogram functions*/

issm/branches/trunk-jpl-damage/src/c/classes/kriging/GaussianVariogram.cpp

r12821	r13101
39	39
40	40	/Checks/
41		if(nugget==sill) _error2_("nugget and sill cannot be equal (constant semivariogram not allowed)");
	41	if(nugget==sill) _error_("nugget and sill cannot be equal (constant semivariogram not allowed)");
42	42	}
43	43	/}}}/

issm/branches/trunk-jpl-damage/src/c/classes/kriging/GaussianVariogram.h

-              r12832
+              r13101
                 /*Object virtual functions definitions*/
                 void  Echo();
                 void  DeepEcho(){_error2_("Not implemented yet");};
                 int   Id(){_error2_("Not implemented yet");};
                 int   MyRank(){_error2_("Not implemented yet");};
                 int   ObjectEnum(){_error2_("Not implemented yet");};
                 Object* copy(){_error2_("Not implemented yet");};
+                void  DeepEcho(){_error_("Not implemented yet");};
+                int   Id(){_error_("Not implemented yet");};
+                int   MyRank(){_error_("Not implemented yet");};
+                int   ObjectEnum(){_error_("Not implemented yet");};
+                Object* copy(){_error_("Not implemented yet");};
                 /*Variogram functions*/

issm/branches/trunk-jpl-damage/src/c/classes/kriging/Observation.h

-              r12832
+              r13101
                 /*Object virtual functions definitions*/
                 void    Echo();
                 void    DeepEcho()  {_error2_("Not implemented yet"); };
                 int     Id()        {_error2_("Not implemented yet"); };
                 int     MyRank()    {_error2_("Not implemented yet"); };
                 int     ObjectEnum(){_error2_("Not implemented yet"); };
                 Object *copy()      {_error2_("Not implemented yet"); };
+                void    DeepEcho()  {_error_("Not implemented yet"); };
+                int     Id()        {_error_("Not implemented yet"); };
+                int     MyRank()    {_error_("Not implemented yet"); };
+                int     ObjectEnum(){_error_("Not implemented yet"); };
+                Object *copy()      {_error_("Not implemented yet"); };
                 /*Management*/

issm/branches/trunk-jpl-damage/src/c/classes/kriging/PowerVariogram.cpp

-              r12821
+              r13101
         /*Checks*/
         if(power<=0 || power>=2) _error2_("power must be betwwen 0 and 2 (0 < power < 2)");
         if(slope<=0) _error2_("slope must be positive");
+        if(power<=0 || power>=2) _error_("power must be betwwen 0 and 2 (0 < power < 2)");
+        if(slope<=0) _error_("slope must be positive");
+}
 /*}}}*/

issm/branches/trunk-jpl-damage/src/c/classes/kriging/PowerVariogram.h

-              r12821
+              r13101
                 /*Object virtual functions definitions*/
                 void  Echo();
                 void  DeepEcho(){_error2_("Not implemented yet");};
                 int   Id(){_error2_("Not implemented yet");};
                 int   MyRank(){_error2_("Not implemented yet");};
                 int   ObjectEnum(){_error2_("Not implemented yet");};
                 Object* copy(){_error2_("Not implemented yet");};
+                void  DeepEcho(){_error_("Not implemented yet");};
+                int   Id(){_error_("Not implemented yet");};
+                int   MyRank(){_error_("Not implemented yet");};
+                int   ObjectEnum(){_error_("Not implemented yet");};
+                Object* copy(){_error_("Not implemented yet");};
                 /*Variogram functions*/

issm/branches/trunk-jpl-damage/src/c/classes/kriging/Quadtree.cpp

-              r12821
+              r13101
 /*FUNCTION Quadtree::Quadtree(){{{*/
 Quadtree::Quadtree(){
         _error2_("Constructor not supported");
+        _error_("Constructor not supported");
+}
 …
+        }
         else{
                 _error2_("Box is not full");
+                _error_("Box is not full");
+        }
 }/*}}}*/
 …
                         break;
                 default:
                         _error2_("Case " << index << " not supported");
+                        _error_("Case " << index << " not supported");
+        }
         newbox->length=master->length/2;
 …
                         break;
                 default:
                         _error2_("Case " << this->IsWithinRange(x,y,range) << " not supported");
+                        _error_("Case " << this->IsWithinRange(x,y,range) << " not supported");
+        }

issm/branches/trunk-jpl-damage/src/c/classes/kriging/Quadtree.h

-              r12821
+              r13101
                                 /*Object functions (Needed because the Quadtree uses a Container*/
                                 void    Echo();
                                 void    DeepEcho()  {_error2_("not implemented yet"); };
                                 int     Id()        {_error2_("not implemented yet"); };
                                 int     MyRank()    {_error2_("not implemented yet"); };
                                 int     ObjectEnum(){_error2_("not implemented yet"); };
                                 Object *copy()      {_error2_("not implemented yet"); };
+                                void    DeepEcho()  {_error_("not implemented yet"); };
+                                int     Id()        {_error_("not implemented yet"); };
+                                int     MyRank()    {_error_("not implemented yet"); };
+                                int     ObjectEnum(){_error_("not implemented yet"); };
+                                Object *copy()      {_error_("not implemented yet"); };
                                 /*Methods*/

issm/branches/trunk-jpl-damage/src/c/classes/kriging/SphericalVariogram.cpp

r12821	r13101
39	39
40	40	/Checks/
41		if(nugget==sill) _error2_("nugget and sill cannot be equal (constant semivariogram not allowed)");
	41	if(nugget==sill) _error_("nugget and sill cannot be equal (constant semivariogram not allowed)");
42	42	}
43	43	/}}}/

issm/branches/trunk-jpl-damage/src/c/classes/kriging/SphericalVariogram.h

-              r12821
+              r13101
                 /*Object virtual functions definitions*/
                 void  Echo();
                 void  DeepEcho(){_error2_("Not implemented yet");};
                 int   Id(){_error2_("Not implemented yet");};
                 int   MyRank(){_error2_("Not implemented yet");};
                 int   ObjectEnum(){_error2_("Not implemented yet");};
                 Object* copy(){_error2_("Not implemented yet");};
+                void  DeepEcho(){_error_("Not implemented yet");};
+                int   Id(){_error_("Not implemented yet");};
+                int   MyRank(){_error_("Not implemented yet");};
+                int   ObjectEnum(){_error_("Not implemented yet");};
+                Object* copy(){_error_("Not implemented yet");};
                 /*Variogram functions*/

issm/branches/trunk-jpl-damage/src/c/classes/matrix/ElementMatrix.cpp

-              r12832
+              r13101
 ElementMatrix::ElementMatrix(ElementMatrix* Ke){
         if(!Ke) _error2_("Input Element Matrix is a NULL pointer");
+        if(!Ke) _error_("Input Element Matrix is a NULL pointer");
         this->Init(Ke);
         return;
 …
         /*If one of the two matrix is NULL, we copy the other one*/
         if(!Ke1 && !Ke2){
                 _error2_("Two input element matrices are NULL");
+                _error_("Two input element matrices are NULL");
+        }
         else if(!Ke1){
 …
         /*General Case: Ke1 and Ke2 are not empty*/
         if(!Ke1->dofsymmetrical || !Ke2->dofsymmetrical) _error2_("merging 2 non dofsymmetrical matrices not implemented yet");
+        if(!Ke1->dofsymmetrical || !Ke2->dofsymmetrical) _error_("merging 2 non dofsymmetrical matrices not implemented yet");
         /*Initialize itransformation matrix Ke[P[i]] = Ke2[i]*/
 …
+        }
         else{
                 _error2_("non dofsymmetrical matrix AddToGlobal routine not support yet!");
+                _error_("non dofsymmetrical matrix AddToGlobal routine not support yet!");
+        }
 …
+        }
         else{
                 _error2_("non dofsymmetrical matrix AddToGlobal routine not support yet!");
+                _error_("non dofsymmetrical matrix AddToGlobal routine not support yet!");
+        }
 …
         for (int i=0;i<this->nrows;i++){
                 for(int j=0;j<this->ncols;j++){
                         if (xIsNan<IssmDouble>(this->values[i*this->ncols+j])) _error2_("NaN found in Element Matrix");
                         if (fabs(this->values[i*this->ncols+j])>1.e+50) _error2_("Element Matrix values exceeds 1.e+50");
+                        if (xIsNan<IssmDouble>(this->values[i*this->ncols+j])) _error_("NaN found in Element Matrix");
+                        if (fabs(this->values[i*this->ncols+j])>1.e+50) _error_("Element Matrix values exceeds 1.e+50");
+                }
+        }
 …
         /*Transpose indices*/
         if(!dofsymmetrical){
                 _error2_("not supported yet");
+                _error_("not supported yet");
+        }
 …
         int i,j;
         _printLine_("Element Matrix echo:");
         _printLine_("   nrows: " << nrows);
         _printLine_("   ncols: " << nrows);
+        _printLine_("   nrows: " << this->nrows);
+        _printLine_("   ncols: " << this->ncols);
         _printLine_("   dofsymmetrical: " << (dofsymmetrical?"true":"false"));
 …
         int i;
         if(this->nrows!=this->ncols)_error2_("need square matrix in input!");
+        if(this->nrows!=this->ncols)_error_("need square matrix in input!");
         for(i=0;i<this->nrows;i++){

issm/branches/trunk-jpl-damage/src/c/classes/matrix/ElementVector.cpp

-              r12832
+              r13101
         /*If one of the two matrix is NULL, we copy the other one*/
         if(!pe1 && !pe2){
                 _error2_("Two input element matrices are NULL");
+                _error_("Two input element matrices are NULL");
+        }
         else if(!pe1){
 …
 #ifdef _ISSM_DEBUG_
         for (int i=0;i<this->nrows;i++){
                 if (xIsNan<IssmDouble>(this->values[i])) _error2_("NaN found in Element Vector");
                 if (fabs( this->values[i])>1.e+50) _error2_("Element Vector values exceeds 1.e+50");
+                if (xIsNan<IssmDouble>(this->values[i])) _error_("NaN found in Element Vector");
+                if (fabs( this->values[i])>1.e+50) _error_("Element Vector values exceeds 1.e+50");
+        }
 #endif

issm/branches/trunk-jpl-damage/src/c/classes/matrix/Matrix.cpp

r12946	r13101
51	51	this->pmatrix=new PetscMat(M,N);
52	52	#else
53		_error2_("Petsc matrix format not usable, as Petsc has not been compiled!");
	53	_error_("Petsc matrix format not usable, as Petsc has not been compiled!");
54	54	#endif
55	55	}
…	…
57	57	this->smatrix=new SeqMat(M,N);
58	58	}
59		else _error2_("Matrix type: " << type << " not supported yet!");
	59	else _error_("Matrix type: " << type << " not supported yet!");
60	60
61	61	}
…	…
74	74	this->pmatrix=new PetscMat(M,N,sparsity);
75	75	#else
76		_error2_("Petsc matrix format not usable, as Petsc has not been compiled!");
	76	_error_("Petsc matrix format not usable, as Petsc has not been compiled!");
77	77	#endif
78	78	}
…	…
80	80	this->smatrix=new SeqMat(M,N,sparsity);
81	81	}
82		else _error2_("Matrix type: " << type << " not supported yet!");
	82	else _error_("Matrix type: " << type << " not supported yet!");
83	83	}
84	84	/}}}/
…	…
96	96	this->pmatrix=new PetscMat(serial_mat,M,N,sparsity);
97	97	#else
98		_error2_("Petsc matrix format not usable, as Petsc has not been compiled!");
	98	_error_("Petsc matrix format not usable, as Petsc has not been compiled!");
99	99	#endif
100	100	}
…	…
102	102	this->smatrix=new SeqMat(serial_mat,M,N,sparsity);
103	103	}
104		else _error2_("Matrix type: " << type << " not supported yet!");
	104	else _error_("Matrix type: " << type << " not supported yet!");
105	105
106	106	}
…	…
119	119	this->pmatrix=new PetscMat(M,N,connectivity,numberofdofspernode);
120	120	#else
121		_error2_("Petsc matrix format not usable, as Petsc has not been compiled!");
	121	_error_("Petsc matrix format not usable, as Petsc has not been compiled!");
122	122	#endif
123	123	}
…	…
125	125	this->smatrix=new SeqMat(M,N,connectivity,numberofdofspernode);
126	126	}
127		else _error2_("Matrix type: " << type << " not supported yet!");
	127	else _error_("Matrix type: " << type << " not supported yet!");
128	128
129	129	}
…	…
136	136	delete this->pmatrix;
137	137	#else
138		_error2_("Petsc matrix format not usable, as Petsc has not been compiled!");
	138	_error_("Petsc matrix format not usable, as Petsc has not been compiled!");
139	139	#endif
140	140	}
…	…
142	142	delete this->smatrix;
143	143	}
144		else _error2_("Matrix type: " << type << " not supported yet!");
	144	else _error_("Matrix type: " << type << " not supported yet!");
145	145
146	146	}
…	…
150	150	/FUNCTION Matrix::Echo{{{/
151	151	void Matrix::Echo(void){
	152	_assert_(this);
152	153
153	154	if(type==PetscMatType){
154	155	#ifdef _HAVE_PETSC_
155	156	this->pmatrix->Echo();
156		~~#else~~
157		~~_error2_("Petsc matrix format not usable, as Petsc has not been compiled!");~~
158	157	#endif
159	158	}
…	…
161	160	this->smatrix->Echo();
162	161	}
163		else _error2_("Matrix type: " << type << " not supported yet!");
	162	else _error_("Matrix type: " << type << " not supported yet!");
164	163
165	164	}
…	…
171	170	#ifdef _HAVE_PETSC_
172	171	this->pmatrix->Assemble();
173		~~#else~~
174		~~_error2_("Petsc matrix format not usable, as Petsc has not been compiled!");~~
175	172	#endif
176	173	}
…	…
179	176	}
180	177	else{
181		_error2_("Matrix type: " << type << " not supported yet!");
	178	_error_("Matrix type: " << type << " not supported yet!");
182	179	}
183	180	}
…	…
191	188	#ifdef _HAVE_PETSC_
192	189	norm=this->pmatrix->Norm(norm_type);
193		~~#else~~
194		~~_error2_("Petsc matrix format not usable, as Petsc has not been compiled!");~~
195	190	#endif
196	191	}
…	…
198	193	norm=this->smatrix->Norm(norm_type);
199	194	}
200		else _error2_("Matrix type: " << type << " not supported yet!");
	195	else _error_("Matrix type: " << type << " not supported yet!");
201	196
202	197	return norm;
…	…
209	204	#ifdef _HAVE_PETSC_
210	205	this->pmatrix->GetSize(pM,pN);
211		~~#else~~
212		~~_error2_("Petsc matrix format not usable, as Petsc has not been compiled!");~~
213	206	#endif
214	207	}
…	…
216	209	this->smatrix->GetSize(pM,pN);
217	210	}
218		else _error2_("Matrix type: " << type << " not supported yet!");
	211	else _error_("Matrix type: " << type << " not supported yet!");
219	212
220	213	}
…	…
226	219	#ifdef _HAVE_PETSC_
227	220	this->pmatrix->GetLocalSize(pM,pN);
228		~~#else~~
229		~~_error2_("Petsc matrix format not usable, as Petsc has not been compiled!");~~
230	221	#endif
231	222	}
…	…
233	224	this->smatrix->GetLocalSize(pM,pN);
234	225	}
235		else _error2_("Matrix type: " << type << " not supported yet!");
	226	else _error_("Matrix type: " << type << " not supported yet!");
236	227
237	228	}
…	…
243	234	#ifdef _HAVE_PETSC_
244	235	this->pmatrix->MatMult(X->pvector,AX->pvector);
245		~~#else~~
246		~~_error2_("Petsc matrix format not usable, as Petsc has not been compiled!");~~
247	236	#endif
248	237	}
…	…
250	239	this->smatrix->MatMult(X->svector,AX->svector);
251	240	}
252		else _error2_("Matrix type: " << type << " not supported yet!");
	241	else _error_("Matrix type: " << type << " not supported yet!");
253	242
254	243	}
…	…
264	253	#ifdef _HAVE_PETSC_
265	254	output->pmatrix=this->pmatrix->Duplicate();
266		~~#else~~
267		~~_error2_("Petsc matrix format not usable, as Petsc has not been compiled!");~~
268	255	#endif
269	256	}
…	…
271	258	output->smatrix=this->smatrix->Duplicate();
272	259	}
273		else _error2_("Matrix type: " << type << " not supported yet!");
	260	else _error_("Matrix type: " << type << " not supported yet!");
274	261
275	262	return output;
…	…
284	271	#ifdef _HAVE_PETSC_
285	272	output=this->pmatrix->ToSerial();
286		~~#else~~
287		~~_error2_("Petsc matrix format not usable, as Petsc has not been compiled!");~~
288	273	#endif
289	274	}
…	…
291	276	output=this->smatrix->ToSerial();
292	277	}
293		else _error2_("Matrix type: " << type << " not supported yet!");
	278	else _error_("Matrix type: " << type << " not supported yet!");
294	279
295	280
…	…
303	288	#ifdef _HAVE_PETSC_
304	289	this->pmatrix->SetValues(m,idxm,n,idxn,values,mode);
305		~~#else~~
306		~~_error2_("Petsc matrix format not usable, as Petsc has not been compiled!");~~
307	290	#endif
308	291	}
…	…
310	293	this->smatrix->SetValues(m,idxm,n,idxn,values,mode);
311	294	}
312		else _error2_("Matrix type: " << type << " not supported yet!");
	295	else _error_("Matrix type: " << type << " not supported yet!");
313	296	}
314	297	/}}}/
…	…
319	302	#ifdef _HAVE_PETSC_
320	303	this->pmatrix->Convert(newtype);
321		~~#else~~
322		~~_error2_("Petsc matrix format not usable, as Petsc has not been compiled!");~~
323	304	#endif
324	305	}
…	…
327	308	}
328	309	else{
329		_error2_("Matrix type: " << type << " not supported yet!");
330		}
331
332		}
333		/}}}/
	310	_error_("Matrix type: " << type << " not supported yet!");
	311	}
	312
	313	}
	314	/}}}/

issm/branches/trunk-jpl-damage/src/c/classes/matrix/Matrix.h

-              r12860
+              r13101
                 /*Matrix constructors, destructors {{{*/
                 Matrix();
+                #ifdef _HAVE_PETSC_
                 Matrix(int M,int N,int type=PetscMatType);
                 Matrix(int M,int N,IssmDouble sparsity,int type=PetscMatType);
                 Matrix(IssmDouble* serial_mat,int M,int N,IssmDouble sparsity,int type=PetscMatType);
                 Matrix(int M,int N,int connectivity,int numberofdofspernode,int type=PetscMatType);
+                #else
+                Matrix(int M,int N,int type=SeqMatType);
+                Matrix(int M,int N,IssmDouble sparsity,int type=SeqMatType);
+                Matrix(IssmDouble* serial_mat,int M,int N,IssmDouble sparsity,int type=SeqMatType);
+                Matrix(int M,int N,int connectivity,int numberofdofspernode,int type=SeqMatType);
+                #endif
                 ~Matrix();
                 /*}}}*/

issm/branches/trunk-jpl-damage/src/c/classes/matrix/Vector.cpp

-              r12946
+              r13101
                 this->pvector=new PetscVec(M,fromlocalsize);
                 #else
                 _error2_("Petsc matrix format not usable, as Petsc has not been compiled!");
+                _error_("Petsc matrix format not usable, as Petsc has not been compiled!");
                 #endif
+        }
 …
                 this->svector=new SeqVec(M,fromlocalsize);
+        }
         else _error2_("Vector type: " << type << " not supported yet!");
+        else _error_("Vector type: " << type << " not supported yet!");
+}
 …
                 this->pvector=new PetscVec(serial_vec,M);
                 #else
                 _error2_("Petsc matrix format not usable, as Petsc has not been compiled!");
+                _error_("Petsc matrix format not usable, as Petsc has not been compiled!");
                 #endif
+        }
 …
                 this->svector=new SeqVec(serial_vec,M);
+        }
         else _error2_("Vector type: " << type << " not supported yet!");
+        else _error_("Vector type: " << type << " not supported yet!");
+}
 …
                 delete this->pvector;
                 #else
                 _error2_("Petsc matrix format not usable, as Petsc has not been compiled!");
+                _error_("Petsc matrix format not usable, as Petsc has not been compiled!");
                 #endif
+        }
 …
                 delete this->svector;
+        }
         else _error2_("Vector type: " << type << " not supported yet!");
+        else _error_("Vector type: " << type << " not supported yet!");
+}
 /*}}}*/
 …
                 this->pvector->Echo();
                 #else
                 _error2_("Petsc matrix format not usable, as Petsc has not been compiled!");
+                _error_("Petsc matrix format not usable, as Petsc has not been compiled!");
                 #endif
+        }
 …
                 this->svector->Echo();
+        }
         else _error2_("Vector type: " << type << " not supported yet!");
+        else _error_("Vector type: " << type << " not supported yet!");
+}
 …
                 this->pvector->Assemble();
                 #else
                 _error2_("Petsc matrix format not usable, as Petsc has not been compiled!");
+                _error_("Petsc matrix format not usable, as Petsc has not been compiled!");
                 #endif
+        }
 …
                 this->svector->Assemble();
+        }
         else _error2_("Vector type: " << type << " not supported yet!");
+        else _error_("Vector type: " << type << " not supported yet!");
+}
 …
                 this->pvector->SetValues(ssize,list,values,mode);
                 #else
                 _error2_("Petsc matrix format not usable, as Petsc has not been compiled!");
+                _error_("Petsc matrix format not usable, as Petsc has not been compiled!");
                 #endif
+        }
 …
                 this->svector->SetValues(ssize,list,values,mode);
+        }
         else _error2_("Vector type: " << type << " not supported yet!");
+        else _error_("Vector type: " << type << " not supported yet!");
 …
                 this->pvector->SetValue(dof,value,mode);
                 #else
                 _error2_("Petsc matrix format not usable, as Petsc has not been compiled!");
+                _error_("Petsc matrix format not usable, as Petsc has not been compiled!");
                 #endif
+        }
 …
                 this->svector->SetValue(dof,value,mode);
+        }
         else _error2_("Vector type: " << type << " not supported yet!");
+        else _error_("Vector type: " << type << " not supported yet!");
+}
 …
                 this->pvector->GetValue(pvalue,dof);
                 #else
                 _error2_("Petsc matrix format not usable, as Petsc has not been compiled!");
+                _error_("Petsc matrix format not usable, as Petsc has not been compiled!");
                 #endif
+        }
 …
                 this->svector->GetValue(pvalue,dof);
+        }
         else _error2_("Vector type: " << type << " not supported yet!");
+        else _error_("Vector type: " << type << " not supported yet!");
+}
 …
                 this->pvector->GetSize(pM);
                 #else
                 _error2_("Petsc matrix format not usable, as Petsc has not been compiled!");
+                _error_("Petsc matrix format not usable, as Petsc has not been compiled!");
                 #endif
+        }
 …
                 this->svector->GetSize(pM);
+        }
         else _error2_("Vector type: " << type << " not supported yet!");
+        else _error_("Vector type: " << type << " not supported yet!");
+}
 …
                 this->pvector->GetLocalSize(pM);
                 #else
                 _error2_("Petsc matrix format not usable, as Petsc has not been compiled!");
+                _error_("Petsc matrix format not usable, as Petsc has not been compiled!");
                 #endif
+        }
 …
                 this->svector->GetLocalSize(pM);
+        }
         else _error2_("Vector type: " << type << " not supported yet!");
+        else _error_("Vector type: " << type << " not supported yet!");
+}
 …
                 output->pvector=this->pvector->Duplicate();
                 #else
                 _error2_("Petsc matrix format not usable, as Petsc has not been compiled!");
+                _error_("Petsc matrix format not usable, as Petsc has not been compiled!");
                 #endif
+        }
 …
                 output->svector=this->svector->Duplicate();
+        }
         else _error2_("Vector type: " << type << " not supported yet!");
+        else _error_("Vector type: " << type << " not supported yet!");
         return output;
 …
                 this->pvector->Set(value);
                 #else
                 _error2_("Petsc matrix format not usable, as Petsc has not been compiled!");
+                _error_("Petsc matrix format not usable, as Petsc has not been compiled!");
                 #endif
+        }
 …
                 this->svector->Set(value);
+        }
         else _error2_("Vector type: " << type << " not supported yet!");
+        else _error_("Vector type: " << type << " not supported yet!");
+}
 …
                 this->pvector->AXPY(X->pvector,a);
                 #else
                 _error2_("Petsc matrix format not usable, as Petsc has not been compiled!");
+                _error_("Petsc matrix format not usable, as Petsc has not been compiled!");
                 #endif
+        }
 …
                 this->svector->AXPY(X->svector,a);
+        }
         else _error2_("Vector type: " << type << " not supported yet!");
+        else _error_("Vector type: " << type << " not supported yet!");
+}
 …
                 this->pvector->AYPX(X->pvector,a);
                 #else
                 _error2_("Petsc matrix format not usable, as Petsc has not been compiled!");
+                _error_("Petsc matrix format not usable, as Petsc has not been compiled!");
                 #endif
+        }
 …
                 this->svector->AYPX(X->svector,a);
+        }
         else _error2_("Vector type: " << type << " not supported yet!");
+        else _error_("Vector type: " << type << " not supported yet!");
 …
                 vec_serial=this->pvector->ToMPISerial();
                 #else
                 _error2_("Petsc matrix format not usable, as Petsc has not been compiled!");
+                _error_("Petsc matrix format not usable, as Petsc has not been compiled!");
                 #endif
+        }
 …
                 vec_serial=this->svector->ToMPISerial();
+        }
         else _error2_("Vector type: " << type << " not supported yet!");
+        else _error_("Vector type: " << type << " not supported yet!");
         return vec_serial;
 …
                 this->pvector->Copy(to->pvector);
                 #else
                 _error2_("Petsc matrix format not usable, as Petsc has not been compiled!");
+                _error_("Petsc matrix format not usable, as Petsc has not been compiled!");
                 #endif
+        }
 …
                 this->svector->Copy(to->svector);
+        }
         else _error2_("Vector type: " << type << " not supported yet!");
+        else _error_("Vector type: " << type << " not supported yet!");
 …
                 norm=this->pvector->Norm(norm_type);
                 #else
                 _error2_("Petsc matrix format not usable, as Petsc has not been compiled!");
+                _error_("Petsc matrix format not usable, as Petsc has not been compiled!");
                 #endif
+        }
 …
                 norm=this->svector->Norm(norm_type);
+        }
         else _error2_("Vector type: " << type << " not supported yet!");
+        else _error_("Vector type: " << type << " not supported yet!");
         return norm;
 …
                 this->pvector->Scale(scale_factor);
                 #else
                 _error2_("Petsc matrix format not usable, as Petsc has not been compiled!");
+                _error_("Petsc matrix format not usable, as Petsc has not been compiled!");
                 #endif
+        }
 …
                 this->svector->Scale(scale_factor);
+        }
         else _error2_("Vector type: " << type << " not supported yet!");
+        else _error_("Vector type: " << type << " not supported yet!");
+}
 …
                 dot=this->pvector->Dot(vector->pvector);
                 #else
                 _error2_("Petsc matrix format not usable, as Petsc has not been compiled!");
+                _error_("Petsc matrix format not usable, as Petsc has not been compiled!");
                 #endif
+        }
 …
                 dot=this->svector->Dot(vector->svector);
+        }
         else _error2_("Vector type: " << type << " not supported yet!");
+        else _error_("Vector type: " << type << " not supported yet!");
         return dot;
 …
                 this->pvector->PointwiseDivide(x->pvector,y->pvector);
                 #else
                 _error2_("Petsc matrix format not usable, as Petsc has not been compiled!");
+                _error_("Petsc matrix format not usable, as Petsc has not been compiled!");
                 #endif
+        }
 …
                 this->svector->PointwiseDivide(x->svector,y->svector);
+        }
         else _error2_("Vector type: " << type << " not supported yet!");
+}
 /*}}}*/
+        else _error_("Vector type: " << type << " not supported yet!");
+}
+/*}}}*/

issm/branches/trunk-jpl-damage/src/c/classes/matrix/Vector.h

-              r12946
+              r13101
                 /*Vector constructors, destructors {{{*/
                 Vector();
+                #ifdef _HAVE_PETSC_
+                Vector(Vec petsc_vector);
                 Vector(int M,bool fromlocalsize=false,int type=PetscVecType);
                 Vector(IssmDouble* serial_vec,int pM,int type=PetscVecType);
+                #ifdef _HAVE_PETSC_
+                Vector(Vec petsc_vector);
+                #else
+                Vector(int M,bool fromlocalsize=false,int type=SeqVecType);
+                Vector(IssmDouble* serial_vec,int pM,int type=SeqVecType);
                 #endif
                 ~Vector();
                 /*}}}*/

issm/branches/trunk-jpl-damage/src/c/classes/objects/Constraints/SpcTransient.cpp

r12832	r13101
146	146	}
147	147
148		if(!found)_error2_("could not find time segment for constraint");
	148	if(!found)_error_("could not find time segment for constraint");
149	149
150	150	/Apply or relax constraint: /

issm/branches/trunk-jpl-damage/src/c/classes/objects/ElementResults/BoolElementResult.cpp

r12832	r13101
128	128	void BoolElementResult::GetVectorFromResults(Vector* vector,int* doflist,int* connectivitylist,int numdofs){
129	129
130		_error2_("cannot return vector on vertices");
	130	_error_("cannot return vector on vertices");
131	131	} /}}}/
132	132	/FUNCTION BoolElementResult::GetElementVectorFromResults{{{/

issm/branches/trunk-jpl-damage/src/c/classes/objects/ElementResults/PentaP1ElementResult.cpp

-              r12832
+              r13101
         IssmDouble data[6];
         if(numdofs!=6)_error2_("Result " << EnumToStringx(this->enum_type) << " is a PentaP1ElementResult and cannot write vector of " << numdofs << " dofs");
+        if(numdofs!=6)_error_("Result " << EnumToStringx(this->enum_type) << " is a PentaP1ElementResult and cannot write vector of " << numdofs << " dofs");
         for(int i=0;i<6;i++) data[i]=this->values[i]/(IssmDouble)connectivitylist[i];
         vector->SetValues(numdofs,doflist,&data[0],ADD_VAL);
 …
 void PentaP1ElementResult::GetElementVectorFromResults(Vector* vector,int dof){
         _error2_("Result " << EnumToStringx(enum_type) << " is a PentaP1ElementResult and should not write vector of size numberofelemenrs");
+        _error_("Result " << EnumToStringx(enum_type) << " is a PentaP1ElementResult and should not write vector of size numberofelemenrs");
 } /*}}}*/

issm/branches/trunk-jpl-damage/src/c/classes/objects/ElementResults/TriaP1ElementResult.cpp

-              r12832
+              r13101
         IssmDouble data[3];
         if(numdofs!=3)_error2_("Result " << EnumToStringx(this->enum_type) << " is a TriaP1ElementResult and cannot write vector of " << numdofs << " dofs");
+        if(numdofs!=3)_error_("Result " << EnumToStringx(this->enum_type) << " is a TriaP1ElementResult and cannot write vector of " << numdofs << " dofs");
         for(int i=0;i<3;i++) data[i]=this->values[i]/(IssmDouble)connectivitylist[i];
         vector->SetValues(numdofs,doflist,&data[0],ADD_VAL);
 …
 /*FUNCTION TriaP1ElementResult::GetElementVectorFromResults{{{*/
 void TriaP1ElementResult::GetElementVectorFromResults(Vector* vector,int dof){
         _error2_("Result " << EnumToStringx(enum_type) << " is a TriaP1ElementResult and should not write vector of size numberofelemenrs");
+        _error_("Result " << EnumToStringx(enum_type) << " is a TriaP1ElementResult and should not write vector of size numberofelemenrs");
 } /*}}}*/

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

-              r12946
+              r13101
         /*Build neighbors list*/
         if (xIsNan<IssmDouble>(iomodel->Data(MeshUpperelementsEnum)[index])) penta_elements_ids[1]=this->id; //upper penta is the same penta
         else                                    penta_elements_ids[1]=(int)(iomodel->Data(MeshUpperelementsEnum)[index]);
+        else                                    penta_elements_ids[1]=reCast<int,IssmDouble>((iomodel->Data(MeshUpperelementsEnum)[index]));
         if (xIsNan<IssmDouble>(iomodel->Data(MeshLowerelementsEnum)[index])) penta_elements_ids[0]=this->id; //lower penta is the same penta
         else                                    penta_elements_ids[0]=(int)(iomodel->Data(MeshLowerelementsEnum)[index]);
+        else                                    penta_elements_ids[0]=reCast<int,IssmDouble>((iomodel->Data(MeshLowerelementsEnum)[index]));
         this->InitHookNeighbors(penta_elements_ids);
         /*Build horizontalneighborsids list: */
         _assert_(iomodel->Data(MeshElementconnectivityEnum));
         for(i=0;i<3;i++) this->horizontalneighborsids[i]=(int)iomodel->Data(MeshElementconnectivityEnum)[3*index+i]-1;
+        for(i=0;i<3;i++) this->horizontalneighborsids[i]=reCast<int,IssmDouble>(iomodel->Data(MeshElementconnectivityEnum)[3*index+i])-1;
         //this->parameters: we still can't point to it, it may not even exist. Configure will handle this.
 …
 /*FUNCTION Penta::AverageOntoPartition {{{*/
 void  Penta::AverageOntoPartition(Vector* partition_contributions,Vector* partition_areas,IssmDouble* vertex_response,IssmDouble* qmu_part){
         _error2_("Not supported yet!");
+        _error_("Not supported yet!");
+}
 /*}}}*/
 …
         /*Check analysis_types*/
         if (analysis_type!=DiagnosticHorizAnalysisEnum) _error2_("Not supported yet!");
         if (approximation!=StokesApproximationEnum) _error2_("Not supported yet!");
+        if (analysis_type!=DiagnosticHorizAnalysisEnum) _error_("Not supported yet!");
+        if (approximation!=StokesApproximationEnum) _error_("Not supported yet!");
         /*retrieve some parameters: */
 …
 void  Penta::ComputeStrainRate(Vector* eps){
         _error2_("Not implemented yet");
+        _error_("Not implemented yet");
+}
 …
                 #endif
                 case BedSlopeXAnalysisEnum: case SurfaceSlopeXAnalysisEnum: case BedSlopeYAnalysisEnum: case SurfaceSlopeYAnalysisEnum:
                         Ke=CreateKMatrixSlope();
+                        Ke=CreateBasalMassMatrix();
                         break;
                 case PrognosticAnalysisEnum:
 …
                 #endif
                 default:
                         _error2_("analysis " << analysis_type << " (" << EnumToStringx(analysis_type) << ") not supported yet");
+                        _error_("analysis " << analysis_type << " (" << EnumToStringx(analysis_type) << ") not supported yet");
+        }
 …
+}
 /*}}}*/
 /*FUNCTION Penta::CreateKMatrixSlope {{{*/
 ElementMatrix* Penta::CreateKMatrixSlope(void){
+/*FUNCTION Penta::CreateBasalMassMatrix{{{*/
+ElementMatrix* Penta::CreateBasalMassMatrix(void){
         if (!IsOnBed()) return NULL;
         Tria* tria=(Tria*)SpawnTria(0,1,2); //nodes 0, 1 and 2 make the new tria.
         ElementMatrix* Ke=tria->CreateKMatrixSlope();
+        ElementMatrix* Ke=tria->CreateMassMatrix();
         delete tria->matice; delete tria;
 …
                 #endif
                 default:
                         _error2_("analysis " << analysis_type << " (" << EnumToStringx(analysis_type) << ") not supported yet");
+                        _error_("analysis " << analysis_type << " (" << EnumToStringx(analysis_type) << ") not supported yet");
+        }
 …
 #endif
                 default:
                         _error2_("analysis " << analysis_type << " (" << EnumToStringx(analysis_type) << ") not supported yet");
+                        _error_("analysis " << analysis_type << " (" << EnumToStringx(analysis_type) << ") not supported yet");
+        }
 …
                  return i;
+        }
         _error2_("Node provided not found among element nodes");
+        _error_("Node provided not found among element nodes");
+}
 …
         /*Recover input*/
         Input* input=inputs->GetInput(enumtype);
         if (!input) _error2_("Input " << EnumToStringx(enumtype) << " not found in element");
+        if (!input) _error_("Input " << EnumToStringx(enumtype) << " not found in element");
         /*Checks in debugging mode*/
 …
         Input* input=inputs->GetInput(enumtype);
         if(!input) _error2_("No input of type " << EnumToStringx(enumtype) << " found in tria");
+        if(!input) _error_("No input of type " << EnumToStringx(enumtype) << " found in tria");
         GaussPenta* gauss=new GaussPenta();
 …
         #endif
         default:
                 _error2_("analysis: " << analysis_type << " (" << EnumToStringx(analysis_type) << ") not supported yet");
+                _error_("analysis: " << analysis_type << " (" << EnumToStringx(analysis_type) << ") not supported yet");
+        }
+}
 …
         /*Check that both inputs have been found*/
         if (!vx_input || !vy_input){
                 _error2_("Input missing. Here are the input pointers we have for vx: " << vx_input << ", vy: " << vy_input << "\n");
+                _error_("Input missing. Here are the input pointers we have for vx: " << vx_input << ", vy: " << vy_input << "\n");
+        }
 …
         /*Check that both inputs have been found*/
         if (!vx_input || !vy_input || !vz_input){
                 _error2_("Input missing. Here are the input pointers we have for vx: " << vx_input << ", vy: " << vy_input << ", vz: " << vz_input << "\n");
+                _error_("Input missing. Here are the input pointers we have for vx: " << vx_input << ", vy: " << vy_input << ", vz: " << vz_input << "\n");
+        }
 …
         /*Get input (either in element or material)*/
         Input* input=inputs->GetInput(input_enum);
         if(!input) _error2_("Input " << EnumToStringx(input_enum) << " not found in element");
+        if(!input) _error_("Input " << EnumToStringx(input_enum) << " not found in element");
         /*We found the enum.  Use its values to fill into the vector, using the vertices ids: */
 …
         ElementResult* elementresult=(ElementResult*)this->results->GetObjectByOffset(offset);
         if(elementresult->InstanceEnum()!=enum_in){
                 _error_("Results of offset %i is %s, when %s was expected",offset,EnumToStringx(elementresult->InstanceEnum()),EnumToStringx(enum_in));
+                _error_("Results of offset "<<offset<<" is "<<EnumToStringx(elementresult->InstanceEnum())<<" when "<<EnumToStringx(enum_in)<<" was expected");
+        }
         if(interp==P1Enum){
 …
         /*Make a copy of the original input: */
         input=(Input*)this->inputs->GetInput(enum_type);
         if(!input)_error2_("could not find old input with enum: " << EnumToStringx(enum_type));
+        if(!input)_error_("could not find old input with enum: " << EnumToStringx(enum_type));
         /*ArtificialNoise: */
 …
                 new_inputs[i]=(Input*)this->inputs->GetInput(enums[2*i+0]);
                 old_inputs[i]=(Input*)this->inputs->GetInput(enums[2*i+1]);
                 if(!new_inputs[i])_error2_("could not find input with enum " << EnumToStringx(enums[2*i+0]));
                 if(!old_inputs[i])_error2_("could not find input with enum " << EnumToStringx(enums[2*i+0]));
+                if(!new_inputs[i])_error_("could not find input with enum " << EnumToStringx(enums[2*i+0]));
+                if(!old_inputs[i])_error_("could not find input with enum " << EnumToStringx(enums[2*i+0]));
+        }
 …
         if ((code==5) || (code==1)){ //boolean
                 this->inputs->AddInput(new BoolInput(name,(bool)scalar));
+                this->inputs->AddInput(new BoolInput(name,reCast<bool,IssmDouble>(scalar)));
+        }
         else if ((code==6) || (code==2)){ //integer
                 this->inputs->AddInput(new IntInput(name,(int)scalar));
+                this->inputs->AddInput(new IntInput(name,reCast<int,IssmDouble>(scalar)));
+        }
         else if ((code==7) || (code==3)){ //IssmDouble
                 this->inputs->AddInput(new DoubleInput(name,(IssmDouble)scalar));
+        }
         else _error2_("could not recognize nature of vector from code " << code);
+                this->inputs->AddInput(new DoubleInput(name,scalar));
+        }
+        else _error_("could not recognize nature of vector from code " << code);
+}
 …
                 for(i=0;i<6;i++){
                         _assert_(iomodel->Data(MeshElementsEnum));
                         penta_vertex_ids[i]=(int)iomodel->Data(MeshElementsEnum)[6*index+i]; //ids for vertices are in the elements array from Matlab
+                        penta_vertex_ids[i]=reCast<int,IssmDouble>(iomodel->Data(MeshElementsEnum)[6*index+i]); //ids for vertices are in the elements array from Matlab
+                }
 …
                         this->inputs->AddInput(transientinput);
+                }
                 else _error2_("nodal vector is either numberofnodes (" << numberofvertices << "), or numberofnodes+1 long. Field provided is " << M << " long. Enum " << EnumToStringx(vector_enum));
+                else _error_("nodal vector is either numberofnodes (" << numberofvertices << "), or numberofnodes+1 long. Field provided is " << M << " long. Enum " << EnumToStringx(vector_enum));
+        }
         else if(vector_type==2){ //element vector
 …
                         if (code==5){ //boolean
                                 this->inputs->AddInput(new BoolInput(vector_enum,(bool)vector[index]));
+                                this->inputs->AddInput(new BoolInput(vector_enum,reCast<bool,IssmDouble>(vector[index])));
+                        }
                         else if (code==6){ //integer
                                 this->inputs->AddInput(new IntInput(vector_enum,(int)vector[index]));
+                                this->inputs->AddInput(new IntInput(vector_enum,reCast<int,IssmDouble>(vector[index])));
+                        }
                         else if (code==7){ //IssmDouble
                                 this->inputs->AddInput(new DoubleInput(vector_enum,(IssmDouble)vector[index]));
+                                this->inputs->AddInput(new DoubleInput(vector_enum,vector[index]));
+                        }
                         else _error2_("could not recognize nature of vector from code " << code);
+                        else _error_("could not recognize nature of vector from code " << code);
+                }
                 else {
                         _error2_("transient elementary inputs not supported yet!");
+                        _error_("transient elementary inputs not supported yet!");
+                }
+        }
         else{
                 _error2_("Cannot add input for vector type " << vector_type << " (not supported)");
+                _error_("Cannot add input for vector type " << vector_type << " (not supported)");
+        }
 …
                  original_input=(Input*)penta->matice->inputs->GetInput(enum_type);
                 else
                  _error2_("object " << EnumToStringx(object_enum) << " not supported yet");
                 if(!original_input) _error2_("could not find input with enum " << EnumToStringx(enum_type));
+                 _error_("object " << EnumToStringx(object_enum) << " not supported yet");
+                if(!original_input) _error_("could not find input with enum " << EnumToStringx(enum_type));
                 /*If first time, initialize total_integrated_input*/
 …
                          total_integrated_input=new DoubleInput(average_enum_type,0.0);
                         else
                          _error2_("object " << EnumToStringx(original_input->ObjectEnum()) << " not supported yet");
+                         _error_("object " << EnumToStringx(original_input->ObjectEnum()) << " not supported yet");
+                }
 …
          this->matice->inputs->AddInput((Input*)depth_averaged_input);
         else
          _error2_("object " << EnumToStringx(object_enum) << " not supported yet");
+         _error_("object " << EnumToStringx(object_enum) << " not supported yet");
+}
 /*}}}*/
 …
+        }
         else{
                 _error2_("object of type " << EnumToStringx(object_type) << " not supported yet");
+                _error_("object of type " << EnumToStringx(object_type) << " not supported yet");
+        }
         for(i=0;i<num_inputs;i++){
                 if(!base_inputs[i]) _error2_("could not find input with enum " << EnumToStringx(enum_type) << " in object " << EnumToStringx(object_type));
+                if(!base_inputs[i]) _error_("could not find input with enum " << EnumToStringx(enum_type) << " in object " << EnumToStringx(object_type));
                 base_inputs[i]->Extrude();
+        }
 …
+                        }
                         else{
                                 _error2_("object of type " << EnumToStringx(object_type) << " not supported yet");
+                                _error_("object of type " << EnumToStringx(object_type) << " not supported yet");
+                        }
+                }
 …
         /*Make a copy of the original input: */
         input=(Input*)this->inputs->GetInput(enum_type);
         if(!input)_error2_("could not find old input with enum: " << EnumToStringx(enum_type));
+        if(!input)_error_("could not find old input with enum: " << EnumToStringx(enum_type));
         /*Scale: */
 …
         if (enum_type==MaterialsRheologyBbarEnum) input=this->matice->inputs->GetInput(MaterialsRheologyBEnum);
         else input=this->inputs->GetInput(enum_type);
         //if (!input) _error2_("Input " << EnumToStringx(enum_type) << " not found in penta->inputs"); why error out? if the requested input does not exist, we should still
+        //if (!input) _error_("Input " << EnumToStringx(enum_type) << " not found in penta->inputs"); why error out? if the requested input does not exist, we should still
         //try and output whatever we can instead of just failing.
         if(!input)return;
 …
         /*Recover vertices ids needed to initialize inputs*/
         for(i=0;i<6;i++){
                 penta_vertex_ids[i]=(int)iomodel->Data(MeshElementsEnum)[6*index+i]; //ids for vertices are in the elements array from Matlab
+                penta_vertex_ids[i]=reCast<int,IssmDouble>(iomodel->Data(MeshElementsEnum)[6*index+i]); //ids for vertices are in the elements array from Matlab
+        }
 …
         if (control_analysis && iomodel->Data(InversionControlParametersEnum)){
                 for(i=0;i<num_control_type;i++){
                         switch((int)iomodel->Data(InversionControlParametersEnum)[i]){
+                        switch(reCast<int,IssmDouble>(iomodel->Data(InversionControlParametersEnum)[i])){
                                 case BalancethicknessThickeningRateEnum:
                                         if (iomodel->Data(BalancethicknessThickeningRateEnum)){
 …
                                         /*Matice will take care of it*/ break;
                                 default:
                                         _error2_("Control " << EnumToStringx((int)iomodel->Data(InversionControlParametersEnum)[i]) << " not implemented yet");
+                                        _error_("Control " << EnumToStringx(reCast<int,IssmDouble>(iomodel->Data(InversionControlParametersEnum)[i])) << " not implemented yet");
+                        }
+                }
 …
         //Need to know the type of approximation for this element
         if(iomodel->Data(FlowequationElementEquationEnum)){
                 if (*(iomodel->Data(FlowequationElementEquationEnum)+index)==MacAyealApproximationEnum){
+                if (iomodel->Data(FlowequationElementEquationEnum)[index]==MacAyealApproximationEnum){
                         this->inputs->AddInput(new IntInput(ApproximationEnum,MacAyealApproximationEnum));
+                }
                 else if (*(iomodel->Data(FlowequationElementEquationEnum)+index)==PattynApproximationEnum){
+                else if (iomodel->Data(FlowequationElementEquationEnum)[index]==PattynApproximationEnum){
                         this->inputs->AddInput(new IntInput(ApproximationEnum,PattynApproximationEnum));
+                }
                 else if (*(iomodel->Data(FlowequationElementEquationEnum)+index)==MacAyealPattynApproximationEnum){
+                else if (iomodel->Data(FlowequationElementEquationEnum)[index]==MacAyealPattynApproximationEnum){
                         this->inputs->AddInput(new IntInput(ApproximationEnum,MacAyealPattynApproximationEnum));
+                }
                 else if (*(iomodel->Data(FlowequationElementEquationEnum)+index)==HutterApproximationEnum){
+                else if (iomodel->Data(FlowequationElementEquationEnum)[index]==HutterApproximationEnum){
                         this->inputs->AddInput(new IntInput(ApproximationEnum,HutterApproximationEnum));
+                }
+                else if (*(iomodel->Data(FlowequationElementEquationEnum)+index)==StokesApproximationEnum){
+                else if (iomodel->Data(FlowequationElementEquationEnum)[index]==L1L2ApproximationEnum){
+                        this->inputs->AddInput(new IntInput(ApproximationEnum,L1L2ApproximationEnum));
+                }
+                else if (iomodel->Data(FlowequationElementEquationEnum)[index]==StokesApproximationEnum){
                         this->inputs->AddInput(new IntInput(ApproximationEnum,StokesApproximationEnum));
+                }
                 else if (*(iomodel->Data(FlowequationElementEquationEnum)+index)==MacAyealStokesApproximationEnum){
+                else if (iomodel->Data(FlowequationElementEquationEnum)[index]==MacAyealStokesApproximationEnum){
                         this->inputs->AddInput(new IntInput(ApproximationEnum,MacAyealStokesApproximationEnum));
+                }
                 else if (*(iomodel->Data(FlowequationElementEquationEnum)+index)==PattynStokesApproximationEnum){
+                else if (iomodel->Data(FlowequationElementEquationEnum)[index]==PattynStokesApproximationEnum){
                         this->inputs->AddInput(new IntInput(ApproximationEnum,PattynStokesApproximationEnum));
+                }
                 else if (*(iomodel->Data(FlowequationElementEquationEnum)+index)==NoneApproximationEnum){
+                else if (iomodel->Data(FlowequationElementEquationEnum)[index]==NoneApproximationEnum){
                         this->inputs->AddInput(new IntInput(ApproximationEnum,NoneApproximationEnum));
+                }
                 else{
                         _error2_("Approximation type " << EnumToStringx((int)*(iomodel->Data(FlowequationElementEquationEnum)+index)) << " not supported yet");
+                        _error_("Approximation type " << EnumToStringx(reCast<int,IssmDouble>(iomodel->Data(FlowequationElementEquationEnum)[index])) << " not supported yet");
+                }
+        }
 …
         #endif
         default:
                 _error2_("analysis " << analysis_type << " (" << EnumToStringx(analysis_type) << ") not supported yet");
+                _error_("analysis " << analysis_type << " (" << EnumToStringx(analysis_type) << ") not supported yet");
+        }
+}
 …
         for(i=0;i<numdof2d;i++){
                 newthickness[i]=solution[doflist[i]];
                 if(xIsNan<IssmDouble>(newthickness[i])) _error2_("NaN found in solution vector");
+                if(xIsNan<IssmDouble>(newthickness[i])) _error_("NaN found in solution vector");
                 /*Constrain thickness to be at least 1m*/
                 if(newthickness[i]<minthickness) newthickness[i]=minthickness;
 …
                                 newbed[i]=oldbed[i]-rho_ice/rho_water*(newthickness[i]-oldthickness[i]); //bed = oldbed + di * dH
+                        }
                         else _error2_("Hydrostatic adjustment " << hydroadjustment << " (" << EnumToStringx(hydroadjustment) << ") not supported yet");
+                        else _error_("Hydrostatic adjustment " << hydroadjustment << " (" << EnumToStringx(hydroadjustment) << ") not supported yet");
+                }
+        }
 …
         for(int i=0;i<numdof;i++){
                 values[i]=solution[doflist[i]];
                 if(xIsNan<IssmDouble>(values[i])) _error2_("NaN found in solution vector");
+                if(xIsNan<IssmDouble>(values[i])) _error_("NaN found in solution vector");
+        }
 …
                 values[i]         =solution[doflist[i]];
                 values[i+numdof2d]=values[i];
                 if(xIsNan<IssmDouble>(values[i])) _error2_("NaN found in solution vector");
+                if(xIsNan<IssmDouble>(values[i])) _error_("NaN found in solution vector");
+        }
 …
                 case VertexEnum:
+                        /*New PentaVertexInpu*/
+                        IssmDouble values[6];
+                        /*Get values on the 6 vertices*/
+                        for (int i=0;i<6;i++){
+                                values[i]=vector[this->nodes[i]->GetVertexDof()];
+                        {
+                                /*New PentaVertexInpu*/
+                                IssmDouble values[6];
+                                /*Get values on the 6 vertices*/
+                                for (int i=0;i<6;i++){
+                                        values[i]=vector[this->nodes[i]->GetVertexDof()];
+                                }
+                                /*update input*/
+                                this->inputs->AddInput(new PentaP1Input(name,values));
+                                return;
+                                break;
+                        }
-                        /*update input*/
-                        this->inputs->AddInput(new PentaP1Input(name,values));
-                        return;
                 default:
                         _error2_("type " << type << " (" << EnumToStringx(type) << ") not implemented yet");
+                        _error_("type " << type << " (" << EnumToStringx(type) << ") not implemented yet");
+        }
+}
 …
 /*FUNCTION Penta::InputUpdateFromVector(int* vector, int name, int type);{{{*/
 void  Penta::InputUpdateFromVector(int* vector, int name, int type){
         _error2_("not supported yet!");
+        _error_("not supported yet!");
+}
 /*}}}*/
 /*FUNCTION Penta::InputUpdateFromVector(bool* vector, int name, int type);{{{*/
 void  Penta::InputUpdateFromVector(bool* vector, int name, int type){
         _error2_("not supported yet!");
+        _error_("not supported yet!");
+}
 /*}}}*/
 …
         for(i=0;i<NUMVERTICES;i++){
                 if (flags[nodes[i]->Sid()]){
+                if (reCast<bool,IssmDouble>(flags[nodes[i]->Sid()])){
                         shelf=true;
                         break;
 …
         for(i=0;i<NUMVERTICES;i++){
                 /*Ice shelf: if bed below bathymetry, impose it at the bathymetry and update surface, elso do nothing */
                 if(old_floating_ice[nodes[i]->Sid()]){
+                if(reCast<bool,IssmDouble>(old_floating_ice[nodes[i]->Sid()])){
                         if(b[i]<=ba[i]){
                                 b[i]=ba[i];
 …
                                         nodes[i]->inputs->AddInput(new BoolInput(MaskVertexongroundediceEnum,false));
+                                }
                                 else if(migration_style==SoftMigrationEnum && sheet_ungrounding[nodes[i]->Sid()]){
+                                else if(migration_style==SoftMigrationEnum && reCast<int,IssmDouble>(sheet_ungrounding[nodes[i]->Sid()])){
                                         s[i]=(1-density)*h[i];
                                         b[i]=-density*h[i];
 …
 void  Penta::SetClone(int* minranks){
         _error2_("not implemented yet");
+        _error_("not implemented yet");
+}
 /*}}}*/
 …
         /*Intermediaries*/
         IssmInt i,j;
         int     penta_type;
         int     penta_node_ids[6];
         int     penta_vertex_ids[6];
         IssmDouble  nodeinputs[6];
         IssmDouble  yts;
         int     stabilization;
         bool    dakota_analysis;
         bool    isstokes;
         IssmDouble  beta,heatcapacity,referencetemperature,meltingpoint,latentheat;
+        IssmInt    i,j;
+        int        penta_type;
+        int        penta_node_ids[6];
+        int        penta_vertex_ids[6];
+        IssmDouble nodeinputs[6];
+        IssmDouble yts;
+        int        stabilization;
+        bool       dakota_analysis;
+        bool       isstokes;
+        IssmDouble beta,heatcapacity,referencetemperature,meltingpoint,latentheat;
         /*Fetch parameters: */
 …
         /*Recover vertices ids needed to initialize inputs*/
         for(i=0;i<6;i++) penta_vertex_ids[i]=(int)iomodel->Data(MeshElementsEnum)[6*index+i]; //ids for vertices are in the elements array from Matlab
+        for(i=0;i<6;i++) penta_vertex_ids[i]=reCast<int,IssmDouble>(iomodel->Data(MeshElementsEnum)[6*index+i]); //ids for vertices are in the elements array from Matlab
         /*Recover nodes ids needed to initialize the node hook.*/
 …
                 //go recover node ids, needed to initialize the node hook.
                 //WARNING: We assume P1 elements here!!!!!
                 penta_node_ids[i]=iomodel->nodecounter+(int)iomodel->Data(MeshElementsEnum)[6*index+i]; //ids for vertices are in the elements array from Matlab
+                penta_node_ids[i]=iomodel->nodecounter+reCast<int,IssmDouble>(iomodel->Data(MeshElementsEnum)[6*index+i]); //ids for vertices are in the elements array from Matlab
+        }
 …
                                 this->inputs->AddInput(new PentaP1Input(EnthalpyEnum,nodeinputs));
+                        }
                         else _error2_("temperature and waterfraction required for the enthalpy solution");
+                        else _error_("temperature and waterfraction required for the enthalpy solution");
                         break;
 …
         /*Go through nodes, and whoever is on the potential_sheet_ungrounding, ends up in nodes_on_iceshelf: */
         for(i=0;i<NUMVERTICES;i++){
                 if (vertices_potentially_ungrounding[nodes[i]->Sid()]){
+                if (reCast<bool,IssmDouble>(vertices_potentially_ungrounding[nodes[i]->Sid()])){
                         vec_nodes_on_iceshelf->SetValue(nodes[i]->Sid(),1,INS_VAL);
 …
 /*FUNCTION Penta::SmearFunction {{{*/
 void  Penta::SmearFunction(Vector* smearedvector,IssmDouble (*WeightFunction)(IssmDouble distance,IssmDouble radius),IssmDouble radius){
         _error2_("not implemented yet");
+        _error_("not implemented yet");
+}
 /*}}}*/
 …
                         break;
                 case VelEnum:
+                        /*Get input:*/
+                        IssmDouble vel;
+                        Input* vel_input;
+                        vel_input=this->inputs->GetInput(VelEnum); _assert_(vel_input);
+                        vel_input->GetInputAverage(&vel);
+                        /*process units if requested: */
+                        if(process_units) vel=UnitConversion(vel,IuToExtEnum,VelEnum);
+                        /*Assign output pointers:*/
+                        *presponse=vel;
+                        {
+                                /*Get input:*/
+                                IssmDouble vel;
+                                Input* vel_input;
+                                vel_input=this->inputs->GetInput(VelEnum); _assert_(vel_input);
+                                vel_input->GetInputAverage(&vel);
+                                /*process units if requested: */
+                                if(process_units) vel=UnitConversion(vel,IuToExtEnum,VelEnum);
+                                /*Assign output pointers:*/
+                                *presponse=vel;
+                        }
+                        break;
                 default:
                         _error2_("Response type " << EnumToStringx(response_enum) << " not supported yet!");
+                        _error_("Response type " << EnumToStringx(response_enum) << " not supported yet!");
+        }
 …
                 kappa=matpar->GetEnthalpyDiffusionParameter(enthalpy,pressure);
                 D_scalar_conduct=gauss->weight*Jdet*kappa;
                 if(dt) D_scalar_conduct=D_scalar_conduct*dt;
+                if(reCast<bool,IssmDouble>(dt)) D_scalar_conduct=D_scalar_conduct*dt;
                 D[0][0]=D_scalar_conduct; D[0][1]=0; D[0][2]=0;
 …
                 D_scalar_advec=gauss->weight*Jdet;
                 if(dt) D_scalar_advec=D_scalar_advec*dt;
+                if(reCast<bool,IssmDouble>(dt)) D_scalar_advec=D_scalar_advec*dt;
                 D[0][0]=D_scalar_advec*vx;D[0][1]=0;                D[0][2]=0;
 …
                 /*Transient: */
                 if(dt){
+                if(reCast<bool,IssmDouble>(dt)){
                         GetNodalFunctionsP1(&L[0], gauss);
                         D_scalar_trans=gauss->weight*Jdet;
 …
                         K[2][0]=h/(2*vel)*vz*vx;  K[2][1]=h/(2*vel)*vz*vy; K[2][2]=h/(2*vel)*vz*vz;
                         D_scalar_stab=gauss->weight*Jdet;
                         if(dt) D_scalar_stab=D_scalar_stab*dt;
+                        if(reCast<bool,IssmDouble>(dt)) D_scalar_stab=D_scalar_stab*dt;
                         for(i=0;i<3;i++) for(j=0;j<3;j++) K[i][j] = D_scalar_stab*K[i][j];
 …
+                                }
+                        }
                         if(dt){
+                        if(reCast<bool,IssmDouble>(dt)){
                                 for(i=0;i<numdof;i++){
                                         for(j=0;j<numdof;j++){
 …
                 D_scalar=gauss->weight*Jdet2d*rho_water*mixed_layer_capacity*thermal_exchange_velocity/(rho_ice*heatcapacity);
                 if(dt) D_scalar=dt*D_scalar;
+                if(reCast<bool,IssmDouble>(dt)) D_scalar=dt*D_scalar;
                 TripleMultiply(&basis[0],numdof,1,0,
 …
                 D_scalar_conduct=gauss->weight*Jdet*kappa;
                 if(dt) D_scalar_conduct=D_scalar_conduct*dt;
+                if(reCast<bool,IssmDouble>(dt)) D_scalar_conduct=D_scalar_conduct*dt;
                 D[0][0]=D_scalar_conduct; D[0][1]=0; D[0][2]=0;
 …
                 D_scalar_advec=gauss->weight*Jdet;
                 if(dt) D_scalar_advec=D_scalar_advec*dt;
+                if(reCast<bool,IssmDouble>(dt)) D_scalar_advec=D_scalar_advec*dt;
                 D[0][0]=D_scalar_advec*vx;    D[0][1]=0;                    D[0][2]=0;
 …
                 /*Transient: */
                 if(dt){
+                if(reCast<bool,IssmDouble>(dt)){
                         GetNodalFunctionsP1(&L[0], gauss);
                         D_scalar_trans=gauss->weight*Jdet;
 …
                         D_scalar_stab=gauss->weight*Jdet;
                         if(dt) D_scalar_stab=D_scalar_stab*dt;
+                        if(reCast<bool,IssmDouble>(dt)) D_scalar_stab=D_scalar_stab*dt;
                         for(i=0;i<3;i++) for(j=0;j<3;j++) K[i][j] = D_scalar_stab*K[i][j];
 …
+                                }
+                        }
                         if(dt){
+                        if(reCast<bool,IssmDouble>(dt)){
                                 for(i=0;i<numdof;i++){
                                         for(j=0;j<numdof;j++){
 …
                 D_scalar=gauss->weight*Jdet2d*rho_water*mixed_layer_capacity*thermal_exchange_velocity/(heatcapacity*rho_ice);
                 if(dt) D_scalar=dt*D_scalar;
+                if(reCast<bool,IssmDouble>(dt)) D_scalar=dt*D_scalar;
                 TripleMultiply(&basis[0],numdof,1,0,
 …
         Input* enthalpy_input=NULL;
         Input* enthalpypicard_input=NULL;
         if(dt){
+        if(reCast<bool,IssmDouble>(dt)){
                 enthalpy_input=inputs->GetInput(EnthalpyEnum); _assert_(enthalpy_input);
+        }
 …
                 scalar_def=phi/rho_ice*Jdet*gauss->weight;
                 if(dt) scalar_def=scalar_def*dt;
+                if(reCast<bool,IssmDouble>(dt)) scalar_def=scalar_def*dt;
                 for(i=0;i<NUMVERTICES;i++)  pe->values[i]+=scalar_def*L[i];
                 /* Build transient now */
                 if(dt){
+                if(reCast<bool,IssmDouble>(dt)){
                         enthalpy_input->GetInputValue(&enthalpy, gauss);
                         scalar_transient=enthalpy*Jdet*gauss->weight;
 …
                         for(i=0;i<NUMVERTICES;i++)  pe->values[i]+=tau_parameter*scalar_def*(u*dbasis[0][i]+v*dbasis[1][i]+w*dbasis[2][i]);
                         if(dt){
+                        if(reCast<bool,IssmDouble>(dt)){
                                 for(i=0;i<NUMVERTICES;i++)  pe->values[i]+=tau_parameter*scalar_transient*(u*dbasis[0][i]+v*dbasis[1][i]+w*dbasis[2][i]);
+                        }
 …
                 scalar_ocean=gauss->weight*Jdet2d*rho_water*mixed_layer_capacity*thermal_exchange_velocity*(h_pmp)/(rho_ice*heatcapacity);
                 if(dt) scalar_ocean=dt*scalar_ocean;
+                if(reCast<bool,IssmDouble>(dt)) scalar_ocean=dt*scalar_ocean;
                 for(i=0;i<numdof;i++) pe->values[i]+=scalar_ocean*basis[i];
 …
                         scalar=gauss->weight*Jdet2d*(basalfriction+geothermalflux_value)/(rho_ice);
                         if(dt) scalar=dt*scalar;
+                        if(reCast<bool,IssmDouble>(dt)) scalar=dt*scalar;
                         for(i=0;i<numdof;i++) pe->values[i]+=scalar*basis[i];
 …
         Input* vz_input=inputs->GetInput(VzEnum); _assert_(vz_input);
         Input* temperature_input=NULL;
         if (dt) temperature_input=inputs->GetInput(TemperatureEnum); _assert_(inputs);
+        if (reCast<bool,IssmDouble>(dt)) temperature_input=inputs->GetInput(TemperatureEnum); _assert_(inputs);
         if (stabilization==2) diameter=MinEdgeLength(xyz_list);
 …
                 scalar_def=phi/(rho_ice*heatcapacity)*Jdet*gauss->weight;
                 if(dt) scalar_def=scalar_def*dt;
+                if(reCast<bool,IssmDouble>(dt)) scalar_def=scalar_def*dt;
                 for(i=0;i<NUMVERTICES;i++)  pe->values[i]+=scalar_def*L[i];
                 /* Build transient now */
                 if(dt){
+                if(reCast<bool,IssmDouble>(dt)){
                         temperature_input->GetInputValue(&temperature, gauss);
                         scalar_transient=temperature*Jdet*gauss->weight;
 …
                         for(i=0;i<NUMVERTICES;i++)  pe->values[i]+=tau_parameter*scalar_def*(u*dbasis[0][i]+v*dbasis[1][i]+w*dbasis[2][i]);
                         if(dt){
+                        if(reCast<bool,IssmDouble>(dt)){
                                 for(i=0;i<NUMVERTICES;i++)  pe->values[i]+=tau_parameter*scalar_transient*(u*dbasis[0][i]+v*dbasis[1][i]+w*dbasis[2][i]);
+                        }
 …
                 scalar_ocean=gauss->weight*Jdet2d*rho_water*mixed_layer_capacity*thermal_exchange_velocity*(t_pmp)/(heatcapacity*rho_ice);
                 if(dt) scalar_ocean=dt*scalar_ocean;
+                if(reCast<bool,IssmDouble>(dt)) scalar_ocean=dt*scalar_ocean;
                 for(i=0;i<numdof;i++) pe->values[i]+=scalar_ocean*basis[i];
 …
                         scalar=gauss->weight*Jdet2d*(basalfriction+geothermalflux_value)/(heatcapacity*rho_ice);
                         if(dt) scalar=dt*scalar;
+                        if(reCast<bool,IssmDouble>(dt)) scalar=dt*scalar;
                         for(i=0;i<numdof;i++) pe->values[i]+=scalar*basis[i];
 …
         const int    numdof=NDOF1*NUMVERTICES;
         int          i;
         int*         doflist=NULL;
         IssmDouble       values[numdof];
         IssmDouble       temp;
         GaussPenta   *gauss=NULL;
+        int         i;
+        int        *doflist = NULL;
+        IssmDouble  values[numdof];
+        IssmDouble  temp;
+        GaussPenta *gauss = NULL;
         /*Get dof list: */
 …
                 /*Check solution*/
                 if(xIsNan<IssmDouble>(values[i])) _error2_("NaN found in solution vector");
+                if(xIsNan<IssmDouble>(values[i])) _error_("NaN found in solution vector");
                 //if(values[i]<0)      _printLine_("temperature < 0°K found in solution vector");
                 //if(values[i]>275)    _printLine_("temperature > 275°K found in solution vector (Paterson's rheology associated is negative)");
 …
                                 break;
                         default:
                                 _error2_("Rheology law " << EnumToStringx(rheology_law) << " not supported yet");
+                                _error_("Rheology law " << EnumToStringx(rheology_law) << " not supported yet");
+                }
 …
                 /*Check solution*/
                 if(xIsNan<IssmDouble>(values[i])) _error2_("NaN found in solution vector");
+                if(xIsNan<IssmDouble>(values[i])) _error_("NaN found in solution vector");
+        }
 …
                 for(i=0;i<numdof;i++){
                         matpar->EnthalpyToThermal(&temperatures[i],&waterfraction[i],values[i],pressure[i]);
                         if(waterfraction[i]<0) _error2_("Negative water fraction found in solution vector");
                         //if(waterfraction[i]>1) _error2_("Water fraction >1 found in solution vector");
+                        if(waterfraction[i]<0) _error_("Negative water fraction found in solution vector");
+                        //if(waterfraction[i]>1) _error_("Water fraction >1 found in solution vector");
+                }
 …
                                 break;
                         default:
                                 _error2_("Rheology law " << EnumToStringx(rheology_law) << " not supported yet");
+                                _error_("Rheology law " << EnumToStringx(rheology_law) << " not supported yet");
+                }
 …
                 input=inputs->GetInput(enum_type);
+        }
         if (!input) _error2_("Input " << EnumToStringx(enum_type) << " not found");
         if (input->ObjectEnum()!=ControlInputEnum) _error2_("Input " << EnumToStringx(enum_type) << " is not a ControlInput");
+        if (!input) _error_("Input " << EnumToStringx(enum_type) << " not found");
+        if (input->ObjectEnum()!=ControlInputEnum) _error_("Input " << EnumToStringx(enum_type) << " is not a ControlInput");
         GradientIndexing(&doflist1[0],control_index);
 …
                 input=inputs->GetInput(enum_type);
+        }
         if (!input) _error2_("Input " << EnumToStringx(enum_type) << " not found");
         if (input->ObjectEnum()!=ControlInputEnum) _error2_("Input " << EnumToStringx(enum_type) << " is not a ControlInput");
+        if (!input) _error_("Input " << EnumToStringx(enum_type) << " not found");
+        if (input->ObjectEnum()!=ControlInputEnum) _error_("Input " << EnumToStringx(enum_type) << " is not a ControlInput");
         ((ControlInput*)input)->ScaleGradient(scale);
 …
                 input=inputs->GetInput(enum_type);
+        }
         if (!input) _error2_("Input " << EnumToStringx(enum_type) << " not found");
         if (input->ObjectEnum()!=ControlInputEnum) _error2_("Input " << EnumToStringx(enum_type) << " is not a ControlInput");
+        if (!input) _error_("Input " << EnumToStringx(enum_type) << " not found");
+        if (input->ObjectEnum()!=ControlInputEnum) _error_("Input " << EnumToStringx(enum_type) << " is not a ControlInput");
         GradientIndexing(&doflist1[0],control_index);
 …
                         return NULL;
                 default:
                         _error2_("Approximation " << EnumToStringx(approximation) << " not supported yet");
+                        _error_("Approximation " << EnumToStringx(approximation) << " not supported yet");
+        }
+}
 …
                         return CreatePVectorAdjointStokes();
                 default:
                         _error2_("Approximation " << EnumToStringx(approximation) << " not supported yet");
+                        _error_("Approximation " << EnumToStringx(approximation) << " not supported yet");
+        }
+}
 …
                                         break;
                                 default:
                                         _error2_("approximation " << EnumToStringx(approximation) << " not supported yet");
+                                        _error_("approximation " << EnumToStringx(approximation) << " not supported yet");
+                        }
                         break;
 …
                                         break;
                                 default:
                                         _error2_("approximation " << EnumToStringx(approximation) << " not supported yet");
+                                        _error_("approximation " << EnumToStringx(approximation) << " not supported yet");
+                        }
                         break;
                 default:
                         _error2_("control type " << EnumToStringx(control_type) << " not supported yet: ");
+                        _error_("control type " << EnumToStringx(control_type) << " not supported yet: ");
+        }
 …
                         break;
                 default:
                         _error2_("response " << EnumToStringx(responses[resp]) << " not supported yet");
+                        _error_("response " << EnumToStringx(responses[resp]) << " not supported yet");
+        }
         xDelete<int>(responses);
 …
+                }
                 if (input->ObjectEnum()!=ControlInputEnum) _error2_("input " << EnumToStringx(control_type[i]) << " is not a ControlInput");
+                if (input->ObjectEnum()!=ControlInputEnum) _error_("input " << EnumToStringx(control_type[i]) << " is not a ControlInput");
                 ((ControlInput*)input)->UpdateValue(scalar);
 …
                 /*Check solution*/
                 if(xIsNan<IssmDouble>(lambdax[i])) _error2_("NaN found in solution vector");
                 if(xIsNan<IssmDouble>(lambday[i])) _error2_("NaN found in solution vector");
                 if(xIsNan<IssmDouble>(lambdaz[i])) _error2_("NaN found in solution vector");
                 if(xIsNan<IssmDouble>(lambdap[i])) _error2_("NaN found in solution vector");
+                if(xIsNan<IssmDouble>(lambdax[i])) _error_("NaN found in solution vector");
+                if(xIsNan<IssmDouble>(lambday[i])) _error_("NaN found in solution vector");
+                if(xIsNan<IssmDouble>(lambdaz[i])) _error_("NaN found in solution vector");
+                if(xIsNan<IssmDouble>(lambdap[i])) _error_("NaN found in solution vector");
+        }
 …
                 /*Check solution*/
                 if(xIsNan<IssmDouble>(lambdax[i]))       _error2_("NaN found in solution vector");
                 if(xIsNan<IssmDouble>(lambday[i]))       _error2_("NaN found in solution vector");
+                if(xIsNan<IssmDouble>(lambdax[i]))       _error_("NaN found in solution vector");
+                if(xIsNan<IssmDouble>(lambday[i]))       _error_("NaN found in solution vector");
+        }
 …
 IssmDouble Penta::ThicknessAbsGradient(bool process_units,int weight_index){
         _error2_("Not implemented yet");
+        _error_("Not implemented yet");
+}
 /*}}}*/
 …
         /*If on water, return 0: */
         if(IsOnWater())return 0;
         _error2_("Not implemented yet");
+        _error_("Not implemented yet");
         tria=(Tria*)SpawnTria(0,1,2);
 …
         /*Get input (either in element or material)*/
         Input* input=inputs->GetInput(control_enum);
         if(!input) _error2_("Input " << EnumToStringx(control_enum) << " not found in element");
+        if(!input) _error_("Input " << EnumToStringx(control_enum) << " not found in element");
         /*Check that it is a ControlInput*/
         if (input->ObjectEnum()!=ControlInputEnum){
                 _error2_("input " << EnumToStringx(control_enum) << " is not a ControlInput");
+                _error_("input " << EnumToStringx(control_enum) << " is not a ControlInput");
+        }
 …
         if (input->ObjectEnum()!=ControlInputEnum){
                 _error2_("input " << EnumToStringx(control_enum) << " is not a ControlInput");
+                _error_("input " << EnumToStringx(control_enum) << " is not a ControlInput");
+        }
 …
                 default:
                         _error2_("type " << type << " (" << EnumToStringx(type) << ") not implemented yet");
+                        _error_("type " << type << " (" << EnumToStringx(type) << ") not implemented yet");
+        }
 …
 /*FUNCTION Penta::InputUpdateFromVectorDakota(int* vector, int name, int type);{{{*/
 void  Penta::InputUpdateFromVectorDakota(int* vector, int name, int type){
         _error2_("not supported yet!");
+        _error_("not supported yet!");
+}
 /*}}}*/
 /*FUNCTION Penta::InputUpdateFromVectorDakota(bool* vector, int name, int type);{{{*/
 void  Penta::InputUpdateFromVectorDakota(bool* vector, int name, int type){
         _error2_("not supported yet!");
+        _error_("not supported yet!");
+}
 /*}}}*/
 …
                 default:
                         _error2_("type " << type << " (" << EnumToStringx(type) << ") not implemented yet");
+                        _error_("type " << type << " (" << EnumToStringx(type) << ") not implemented yet");
+        }
 …
                 case MacAyealApproximationEnum:
                         return CreateKMatrixDiagnosticMacAyeal2d();
+                case L1L2ApproximationEnum:
+                        return CreateKMatrixDiagnosticL1L2();
                 case PattynApproximationEnum:
                         return CreateKMatrixDiagnosticPattyn();
 …
                         return CreateKMatrixDiagnosticPattynStokes();
                 default:
                         _error2_("Approximation " << EnumToStringx(approximation) << " not supported yet");
+                        _error_("Approximation " << EnumToStringx(approximation) << " not supported yet");
+        }
+}
 …
         /*Intermediaries*/
         int       connectivity[2];
         int       i,i0,i1,j0,j1;
         IssmDouble    one0,one1;
+        int         connectivity[2];
+        int         i,i0,i1,j0,j1;
+        IssmDouble  one0,one1;
         /*Initialize Element matrix*/
 …
         /*Intermediaries */
         int         i,j,ig,approximation;
         IssmDouble      Jdet;
         IssmDouble      viscosity, oldviscosity, newviscosity, viscosity_overshoot;
         IssmDouble      epsilon[5],oldepsilon[5]; /* epsilon=[exx,eyy,exy,exz,eyz];*/
         IssmDouble      epsilons[6]; //6 for stokes
         IssmDouble      xyz_list[NUMVERTICES][3];
         IssmDouble      B[3][numdof2d];
         IssmDouble      Bprime[3][numdof2d];
         IssmDouble      D[3][3]={0.0};            // material matrix, simple scalar matrix.
         IssmDouble      D_scalar;
         IssmDouble      Ke_gg_gaussian[numdof2d][numdof2d]; //stiffness matrix evaluated at the gaussian point.
         Tria*       tria=NULL;
         Penta*      pentabase=NULL;
         GaussPenta *gauss=NULL;
         GaussTria  *gauss_tria=NULL;
+        IssmDouble  Jdet;
+        IssmDouble  viscosity , oldviscosity, newviscosity, viscosity_overshoot;
+        IssmDouble  epsilon[5],oldepsilon[5];       /* epsilon=[exx,eyy,exy,exz,eyz];*/
+        IssmDouble  epsilons[6];                    //6 for stokes
+        IssmDouble  xyz_list[NUMVERTICES][3];
+        IssmDouble  B[3][numdof2d];
+        IssmDouble  Bprime[3][numdof2d];
+        IssmDouble  D[3][3]= {0.0};                 // material matrix, simple scalar matrix.
+        IssmDouble  D_scalar;
+        IssmDouble  Ke_gg_gaussian[numdof2d][numdof2d];
+        Tria       *tria       = NULL;
+        Penta      *pentabase  = NULL;
+        GaussPenta *gauss      = NULL;
+        GaussTria  *gauss_tria = NULL;
         /*Find penta on bed as this is a macayeal elements: */
 …
                         matice->GetViscosity3dStokes(&newviscosity,&epsilons[0]);
+                }
                 else _error2_("approximation " << approximation << " (" << EnumToStringx(approximation) << ") not supported yet");
+                else _error_("approximation " << approximation << " (" << EnumToStringx(approximation) << ") not supported yet");
                 D_scalar=2*newviscosity*gauss->weight*Jdet;
 …
         delete Ke2;
         delete Ke3;
+        return Ke;
+}
+/*}}}*/
+/*FUNCTION Penta::CreateKMatrixDiagnosticL1L2{{{*/
+ElementMatrix* Penta::CreateKMatrixDiagnosticL1L2(void){
+        /*compute all stiffness matrices for this element*/
+        ElementMatrix* Ke1=CreateKMatrixDiagnosticL1L2Viscous();
+        ElementMatrix* Ke2=CreateKMatrixDiagnosticL1L2Friction();
+        ElementMatrix* Ke =new ElementMatrix(Ke1,Ke2);
+        /*clean-up and return*/
+        delete Ke1;
+        delete Ke2;
+        return Ke;
+}
+/*}}}*/
+/*FUNCTION Penta::CreateKMatrixDiagnosticL1L2Viscous{{{*/
+ElementMatrix* Penta::CreateKMatrixDiagnosticL1L2Viscous(void){
+        /*Constants*/
+        const int    numdof2d=2*NUMVERTICES2D;
+        /*Intermediaries */
+        int         i,j;
+        IssmDouble  Jdet,viscosity;
+        IssmDouble  epsilon[5];       /* epsilon=[exx,eyy,exy,exz,eyz];*/
+        IssmDouble  xyz_list[NUMVERTICES][3];
+        IssmDouble  B[3][numdof2d];
+        IssmDouble  Bprime[3][numdof2d];
+        IssmDouble  Ke_gg_gaussian[numdof2d][numdof2d];
+        IssmDouble  D[3][3]= {0.0};                 // material matrix, simple scalar matrix.
+        Tria       *tria       = NULL;
+        Penta      *pentabase  = NULL;
+        GaussPenta *gauss      = NULL;
+        GaussTria  *gauss_tria = NULL;
+        /*Find penta on bed as this is a macayeal elements: */
+        pentabase=GetBasalElement();
+        tria=pentabase->SpawnTria(0,1,2); //nodes 0, 1 and 2 make the new tria.
+        /*Initialize Element matrix*/
+        ElementMatrix* Ke=new ElementMatrix(tria->nodes,NUMVERTICES2D,this->parameters,L1L2ApproximationEnum);
+        /*Retrieve all inputs and parameters*/
+        GetVerticesCoordinates(&xyz_list[0][0], nodes,NUMVERTICES);
+        Input* vx_input=inputs->GetInput(VxEnum);        _assert_(vx_input);
+        Input* vy_input=inputs->GetInput(VyEnum);        _assert_(vy_input);
+        Input* surf_input=inputs->GetInput(SurfaceEnum); _assert_(surf_input);
+        /* Start  looping on the number of gaussian points: */
+        gauss=new GaussPenta(5,5);
+        gauss_tria=new GaussTria();
+        for(int ig=gauss->begin();ig<gauss->end();ig++){
+                gauss->GaussPoint(ig);
+                gauss->SynchronizeGaussTria(gauss_tria);
+                GetJacobianDeterminant(&Jdet, &xyz_list[0][0],gauss);
+                tria->GetBMacAyeal(&B[0][0], &xyz_list[0][0], gauss_tria);
+                tria->GetBprimeMacAyeal(&Bprime[0][0], &xyz_list[0][0], gauss_tria);
+                /*Get viscosity for L1L2 model*/
+                GetL1L2Viscosity(&viscosity,&xyz_list[0][0],gauss,vx_input,vy_input,surf_input);
+                for(i=0;i<3;i++) D[i][i]=2*viscosity*gauss->weight*Jdet;
+                TripleMultiply( &B[0][0],3,numdof2d,1,
+                                        &D[0][0],3,3,0,
+                                        &Bprime[0][0],3,numdof2d,0,
+                                        &Ke_gg_gaussian[0][0],0);
+                for(i=0;i<numdof2d;i++) for(j=0;j<numdof2d;j++) Ke->values[i*numdof2d+j]+=Ke_gg_gaussian[i][j];
+        }
+        /*Transform Coordinate System*/
+        TransformStiffnessMatrixCoord(Ke,tria->nodes,NUMVERTICES2D,XYEnum);
+        /*Clean up and return*/
+        delete tria->matice;
+        delete tria;
+        delete gauss_tria;
+        delete gauss;
+        return Ke;
+}
+/*}}}*/
+/*FUNCTION Penta::CreateKMatrixDiagnosticL1L2Friction{{{*/
+ElementMatrix* Penta::CreateKMatrixDiagnosticL1L2Friction(void){
+        /*Initialize Element matrix and return if necessary*/
+        if(IsFloating() || !IsOnBed()) return NULL;
+        /*Build a tria element using the 3 nodes of the base of the penta. Then use
+         * the tria functionality to build a friction stiffness matrix on these 3
+         * nodes: */
+        Tria* tria=(Tria*)SpawnTria(0,1,2); //nodes 0, 1 and 2 make the new tria.
+        ElementMatrix* Ke=tria->CreateKMatrixDiagnosticMacAyealFriction();
+        delete tria->matice; delete tria;
+        /*clean-up and return*/
         return Ke;
+}
 …
                 case PattynApproximationEnum:
                         return CreatePVectorDiagnosticPattyn();
+                case L1L2ApproximationEnum:
+                        return CreatePVectorDiagnosticL1L2();
                 case HutterApproximationEnum:
                         return NULL;
 …
                         return CreatePVectorDiagnosticPattynStokes();
                 default:
                         _error2_("Approximation " << EnumToStringx(approximation) << " not supported yet");
+                        _error_("Approximation " << EnumToStringx(approximation) << " not supported yet");
+        }
+}
 …
 /*FUNCTION Penta::CreatePVectorDiagnosticMacAyeal{{{*/
 ElementVector* Penta::CreatePVectorDiagnosticMacAyeal(void){
+        if (!IsOnBed()) return NULL;
+        /*Call Tria function*/
+        Tria* tria=(Tria*)SpawnTria(0,1,2); //nodes 0, 1 and 2 make the new tria.
+        ElementVector* pe=tria->CreatePVectorDiagnosticMacAyeal();
+        delete tria->matice; delete tria;
+        /*Clean up and return*/
+        return pe;
+}
+/*}}}*/
+/*FUNCTION Penta::CreatePVectorDiagnosticL1L2{{{*/
+ElementVector* Penta::CreatePVectorDiagnosticL1L2(void){
         if (!IsOnBed()) return NULL;
 …
                         return NULL;
                 default:
                         _error2_("Approximation " << EnumToStringx(approximation) << " not supported yet");
+                        _error_("Approximation " << EnumToStringx(approximation) << " not supported yet");
+        }
+}
 …
         const int    numdof=NDOF2*NUMVERTICES;
         int          i;
         int          approximation;
         int*         doflist=NULL;
         IssmDouble       vx,vy;
         IssmDouble       values[numdof];
         GaussPenta*  gauss;
+        int         i;
+        int         approximation;
+        int        *doflist        = NULL;
+        IssmDouble  vx,vy;
+        IssmDouble  values[numdof];
+        GaussPenta *gauss;
         /*Get approximation enum and dof list: */
 …
+}
 /*}}}*/
+/*FUNCTION Penta::GetL1L2Viscosity{{{*/
+void Penta::GetL1L2Viscosity(IssmDouble* pviscosity,IssmDouble* xyz_list, GaussPenta* gauss, Input* vx_input, Input* vy_input,Input* surface_input){
+        /*Compute the L1L2 viscosity
+         *
+         *      1
+         * mu = - A^-1 (sigma'_e)^(1-n)
+         *      2
+         *
+         * sigma'_e^2 = |sigma'_//|^2 + |sigma'_perp|^2 (see Perego 2012 eq. 17,18)
+         *
+         * L1L2 assumptions:
+         *
+         * (1) |eps_b|_// = A (|sigma'_//|^2 + |sigma'_perp|^2)^((n-1)/2) |sigma'_//|
+         * (2) |sigma'_perp|^2 = |rho g (s-z) grad(s)|^2
+         *
+         * Assuming that n = 3, we have a polynom of degree 3 to solve (the only unkown is X=|sigma'_//|)
+         *
+         * A X^3 + A |rho g (s-z) grad(s)|^2 X - |eps_b|_// = 0     */
+        int        i;
+        IssmDouble z,s,viscosity,p,q,delta;
+        IssmDouble tau_perp,tau_par,eps_b,A;
+        IssmDouble epsilonvx[5]; /*exx eyy exy exz eyz*/
+        IssmDouble epsilonvy[5]; /*exx eyy exy exz eyz*/
+        IssmDouble epsilon[5];   /*exx eyy exy exz eyz*/
+        IssmDouble z_list[NUMVERTICES];
+        IssmDouble slope[3];
+        /*Check that both inputs have been found*/
+        if (!vx_input || !vy_input || !surface_input) _error_("Input missing");
+        /*Get tau_perp*/
+        for(i=0;i<NUMVERTICES;i++) z_list[i]=xyz_list[3*i+2];
+        surface_input->GetInputValue(&s,gauss);
+        surface_input->GetInputDerivativeValue(&slope[0],xyz_list,gauss);
+        PentaRef::GetInputValue(&z,&z_list[0],gauss);
+        tau_perp = matpar->GetRhoIce() * matpar->GetG() * fabs(s-z)*sqrt(slope[0]*slope[0]+slope[1]*slope[1]);
+        /* Get eps_b*/
+        vx_input->GetVxStrainRate3dPattyn(epsilonvx,xyz_list,gauss);
+        vy_input->GetVyStrainRate3dPattyn(epsilonvy,xyz_list,gauss);
+        for(i=0;i<5;i++) epsilon[i]=epsilonvx[i]+epsilonvy[i];
+        eps_b = sqrt(epsilon[0]*epsilon[0] + epsilon[1]*epsilon[1] + epsilon[0]*epsilon[1] + epsilon[2]*epsilon[2]);
+        if(eps_b==0.){
+                *pviscosity = 2.5e+17;
+                return;
+        }
+        /*Get A*/
+        _assert_(matice->GetN()==3.0);
+        A=matice->GetA();
+        /*Solve for tau_perp (http://fr.wikipedia.org/wiki/Méthode_de_Cardan)*/
+        p     = tau_perp *tau_perp;
+        q     = - eps_b/A;
+        delta = q *q + p*p*p*4./27.;
+        _assert_(delta>0);
+        tau_par = pow(0.5*(-q+sqrt(delta)),1./3.) - pow(0.5*(q+sqrt(delta)),1./3.);
+        /*Viscosity*/
+        viscosity = 1./(2.*A*(tau_par*tau_par + tau_perp*tau_perp));
+        _assert_(!isnan(viscosity));
+        _assert_(viscosity > 0.);
+        /*Assign output pointer*/
+        *pviscosity = viscosity;
+        return;
+}
+/*}}}*/
 /*FUNCTION Penta::InputUpdateFromSolutionDiagnosticHoriz {{{*/
 void  Penta::InputUpdateFromSolutionDiagnosticHoriz(IssmDouble* solution){
 …
                         return;
+                }
+        }
+        if (approximation==L1L2ApproximationEnum){
+                if (!IsOnBed()) return;
+                InputUpdateFromSolutionDiagnosticL1L2(solution);
+                return;
+        }
         else if (approximation==PattynApproximationEnum){
 …
                 /*Check solution*/
                 if(xIsNan<IssmDouble>(vx[i])) _error2_("NaN found in solution vector");
                 if(xIsNan<IssmDouble>(vy[i])) _error2_("NaN found in solution vector");
+                if(xIsNan<IssmDouble>(vx[i])) _error_("NaN found in solution vector");
+                if(xIsNan<IssmDouble>(vy[i])) _error_("NaN found in solution vector");
+        }
 …
                 /*Check solution*/
                 if(xIsNan<IssmDouble>(vx[i])) _error2_("NaN found in solution vector");
                 if(xIsNan<IssmDouble>(vy[i])) _error2_("NaN found in solution vector");
+                if(xIsNan<IssmDouble>(vx[i])) _error_("NaN found in solution vector");
+                if(xIsNan<IssmDouble>(vy[i])) _error_("NaN found in solution vector");
+        }
 …
                 /*Check solution*/
                 if(xIsNan<IssmDouble>(vx[i]))       _error2_("NaN found in solution vector");
                 if(xIsNan<IssmDouble>(vy[i]))       _error2_("NaN found in solution vector");
                 if(xIsNan<IssmDouble>(vzstokes[i])) _error2_("NaN found in solution vector");
                 if(xIsNan<IssmDouble>(pressure[i])) _error2_("NaN found in solution vector");
+                if(xIsNan<IssmDouble>(vx[i]))       _error_("NaN found in solution vector");
+                if(xIsNan<IssmDouble>(vy[i]))       _error_("NaN found in solution vector");
+                if(xIsNan<IssmDouble>(vzstokes[i])) _error_("NaN found in solution vector");
+                if(xIsNan<IssmDouble>(pressure[i])) _error_("NaN found in solution vector");
+        }
 …
         if (vzmacayeal_input){
                 if (vzmacayeal_input->ObjectEnum()!=PentaP1InputEnum){
                         _error2_("Cannot compute Vel as VzMacAyeal is of type " << EnumToStringx(vzmacayeal_input->ObjectEnum()));
+                        _error_("Cannot compute Vel as VzMacAyeal is of type " << EnumToStringx(vzmacayeal_input->ObjectEnum()));
+                }
                 GetInputListOnVertices(&vzmacayeal[0],VzMacAyealEnum);
+        }
         else{
                 _error2_("Cannot update solution as VzMacAyeal is not present");
+                _error_("Cannot update solution as VzMacAyeal is not present");
+        }
 …
         xDelete<int>(doflistm);
         xDelete<int>(doflists);
+}
+/*}}}*/
+/*FUNCTION Penta::InputUpdateFromSolutionDiagnosticL1L2 {{{*/
+void  Penta::InputUpdateFromSolutionDiagnosticL1L2(IssmDouble* solution){
+        const int    numdof=NDOF2*NUMVERTICES;
+        int     i;
+        IssmDouble  rho_ice,g;
+        IssmDouble  values[numdof];
+        IssmDouble  vx[NUMVERTICES];
+        IssmDouble  vy[NUMVERTICES];
+        IssmDouble  vz[NUMVERTICES];
+        IssmDouble  vel[NUMVERTICES];
+        IssmDouble  pressure[NUMVERTICES];
+        IssmDouble  surface[NUMVERTICES];
+        IssmDouble  xyz_list[NUMVERTICES][3];
+        int    *doflist = NULL;
+        Penta  *penta   = NULL;
+        /*Get dof list: */
+        GetDofList(&doflist,L1L2ApproximationEnum,GsetEnum);
+        /*Use the dof list to index into the solution vector: */
+        for(i=0;i<numdof;i++) values[i]=solution[doflist[i]];
+        /*Transform solution in Cartesian Space*/
+        TransformSolutionCoord(&values[0],nodes,NUMVERTICES2D,XYEnum); /*2D: only the first 3 nodes are taken*/
+        /*Ok, we have vx and vy in values, fill in vx and vy arrays and extrude */
+        for(i=0;i<3;i++){
+                vx[i]  =values[i*NDOF2+0];
+                vy[i]  =values[i*NDOF2+1];
+                vx[i+3]=vx[i];
+                vy[i+3]=vy[i];
+                /*Check solution*/
+                if(xIsNan<IssmDouble>(vx[i])) _error_("NaN found in solution vector");
+                if(xIsNan<IssmDouble>(vy[i])) _error_("NaN found in solution vector");
+        }
+        /*Get parameters fro pressure computation*/
+        rho_ice=matpar->GetRhoIce();
+        g=matpar->GetG();
+        /*Start looping over all elements above current element and update all inputs*/
+        penta=this;
+        for(;;){
+                /*Get node data: */
+                GetVerticesCoordinates(&xyz_list[0][0],penta->nodes,NUMVERTICES);
+                /*Now Compute vel*/
+                GetInputListOnVertices(&vz[0],VzEnum,0.0); //default is 0
+                for(i=0;i<NUMVERTICES;i++) vel[i]=pow( pow(vx[i],2.0) + pow(vy[i],2.0) + pow(vz[i],2.0) , 0.5);
+                /*Now compute pressure*/
+                GetInputListOnVertices(&surface[0],SurfaceEnum);
+                for(i=0;i<NUMVERTICES;i++) pressure[i]=rho_ice*g*(surface[i]-xyz_list[i][2]);
+                /*Now, we have to move the previous Vx and Vy inputs  to old
+                 * status, otherwise, we'll wipe them off: */
+                penta->inputs->ChangeEnum(VxEnum,VxPicardEnum);
+                penta->inputs->ChangeEnum(VyEnum,VyPicardEnum);
+                penta->inputs->ChangeEnum(PressureEnum,PressurePicardEnum);
+                /*Add vx and vy as inputs to the tria element: */
+                penta->inputs->AddInput(new PentaP1Input(VxEnum,vx));
+                penta->inputs->AddInput(new PentaP1Input(VyEnum,vy));
+                penta->inputs->AddInput(new PentaP1Input(VelEnum,vel));
+                penta->inputs->AddInput(new PentaP1Input(PressureEnum,pressure));
+                /*Stop if we have reached the surface*/
+                if (penta->IsOnSurface()) break;
+                /* get upper Penta*/
+                penta=penta->GetUpperElement(); _assert_(penta->Id()!=this->id);
+        }
+        /*Free ressources:*/
+        xDelete<int>(doflist);
+}
 /*}}}*/
 …
                 /*Check solution*/
                 if(xIsNan<IssmDouble>(vx[i])) _error2_("NaN found in solution vector");
                 if(xIsNan<IssmDouble>(vy[i])) _error2_("NaN found in solution vector");
+                if(xIsNan<IssmDouble>(vx[i])) _error_("NaN found in solution vector");
+                if(xIsNan<IssmDouble>(vy[i])) _error_("NaN found in solution vector");
+        }
 …
                 /*Check solution*/
                 if(xIsNan<IssmDouble>(vx[i]))       _error2_("NaN found in solution vector");
                 if(xIsNan<IssmDouble>(vy[i]))       _error2_("NaN found in solution vector");
                 if(xIsNan<IssmDouble>(vzstokes[i])) _error2_("NaN found in solution vector");
                 if(xIsNan<IssmDouble>(pressure[i])) _error2_("NaN found in solution vector");
+                if(xIsNan<IssmDouble>(vx[i]))       _error_("NaN found in solution vector");
+                if(xIsNan<IssmDouble>(vy[i]))       _error_("NaN found in solution vector");
+                if(xIsNan<IssmDouble>(vzstokes[i])) _error_("NaN found in solution vector");
+                if(xIsNan<IssmDouble>(pressure[i])) _error_("NaN found in solution vector");
+        }
 …
         if (vzpattyn_input){
                 if (vzpattyn_input->ObjectEnum()!=PentaP1InputEnum){
                         _error2_("Cannot compute Vel as VzPattyn is of type " << EnumToStringx(vzpattyn_input->ObjectEnum()));
+                        _error_("Cannot compute Vel as VzPattyn is of type " << EnumToStringx(vzpattyn_input->ObjectEnum()));
+                }
                 GetInputListOnVertices(&vzpattyn[0],VzPattynEnum);
+        }
         else{
                 _error2_("Cannot update solution as VzPattyn is not present");
+                _error_("Cannot update solution as VzPattyn is not present");
+        }
 …
                 /*Check solution*/
                 if(xIsNan<IssmDouble>(vx[i])) _error2_("NaN found in solution vector");
                 if(xIsNan<IssmDouble>(vy[i])) _error2_("NaN found in solution vector");
+                if(xIsNan<IssmDouble>(vx[i])) _error_("NaN found in solution vector");
+                if(xIsNan<IssmDouble>(vy[i])) _error_("NaN found in solution vector");
+        }
 …
                 /*Check solution*/
                 if(xIsNan<IssmDouble>(vz[i])) _error2_("NaN found in solution vector");
+                if(xIsNan<IssmDouble>(vz[i])) _error_("NaN found in solution vector");
+        }
 …
                 Input* vzstokes_input=inputs->GetInput(VzStokesEnum);
                 if (vzstokes_input){
                         if (vzstokes_input->ObjectEnum()!=PentaP1InputEnum) _error2_("Cannot compute Vel as VzStokes is of type " << EnumToStringx(vzstokes_input->ObjectEnum()));
+                        if (vzstokes_input->ObjectEnum()!=PentaP1InputEnum) _error_("Cannot compute Vel as VzStokes is of type " << EnumToStringx(vzstokes_input->ObjectEnum()));
                         GetInputListOnVertices(&vzstokes[0],VzStokesEnum);
+                }
                 else _error2_("Cannot compute Vz as VzStokes in not present in PattynStokes element");
+                else _error_("Cannot compute Vz as VzStokes in not present in PattynStokes element");
                 for(i=0;i<NUMVERTICES;i++){
                         vzpattyn[i]=vz[i];
 …
                 Input* vzstokes_input=inputs->GetInput(VzStokesEnum);
                 if (vzstokes_input){
                         if (vzstokes_input->ObjectEnum()!=PentaP1InputEnum) _error2_("Cannot compute Vel as VzStokes is of type " << EnumToStringx(vzstokes_input->ObjectEnum()));
+                        if (vzstokes_input->ObjectEnum()!=PentaP1InputEnum) _error_("Cannot compute Vel as VzStokes is of type " << EnumToStringx(vzstokes_input->ObjectEnum()));
                         GetInputListOnVertices(&vzstokes[0],VzStokesEnum);
+                }
                 else _error2_("Cannot compute Vz as VzStokes in not present in MacAyealStokes element");
+                else _error_("Cannot compute Vz as VzStokes in not present in MacAyealStokes element");
                 for(i=0;i<NUMVERTICES;i++){
                         vzmacayeal[i]=vz[i];
 …
                 /*Check solution*/
                 if(xIsNan<IssmDouble>(vx[i]))       _error2_("NaN found in solution vector");
                 if(xIsNan<IssmDouble>(vy[i]))       _error2_("NaN found in solution vector");
                 if(xIsNan<IssmDouble>(vz[i]))       _error2_("NaN found in solution vector");
                 if(xIsNan<IssmDouble>(pressure[i])) _error2_("NaN found in solution vector");
+                if(xIsNan<IssmDouble>(vx[i]))       _error_("NaN found in solution vector");
+                if(xIsNan<IssmDouble>(vy[i]))       _error_("NaN found in solution vector");
+                if(xIsNan<IssmDouble>(vz[i]))       _error_("NaN found in solution vector");
+                if(xIsNan<IssmDouble>(pressure[i])) _error_("NaN found in solution vector");
+        }

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

-              r12946
+              r13101
                 IssmDouble SurfaceAverageVelMisfit(bool process_units,int weight_index);
                 IssmDouble ThicknessAbsGradient(bool process_units,int weight_index);
                 IssmDouble ThicknessAlongGradient( bool process_units,int weight_index){_error2_("not supported");};
                 IssmDouble ThicknessAcrossGradient(bool process_units,int weight_index){_error2_("not supported");};
+                IssmDouble ThicknessAlongGradient( bool process_units,int weight_index){_error_("not supported");};
+                IssmDouble ThicknessAcrossGradient(bool process_units,int weight_index){_error_("not supported");};
                 void   InputControlUpdate(IssmDouble scalar,bool save_parameter);
                 #endif
 …
                 /*Penta specific routines:{{{*/
                 void      BedNormal(IssmDouble* bed_normal, IssmDouble xyz_list[3][3]);
+                ElementMatrix* CreateBasalMassMatrix(void);
                 ElementMatrix* CreateKMatrixPrognostic(void);
-                ElementMatrix* CreateKMatrixSlope(void);
                 ElementVector* CreatePVectorPrognostic(void);
                 ElementVector* CreatePVectorSlope(void);
 …
                 ElementMatrix* CreateKMatrixDiagnosticMacAyealPattyn(void);
                 ElementMatrix* CreateKMatrixDiagnosticMacAyealStokes(void);
+                ElementMatrix* CreateKMatrixDiagnosticL1L2(void);
+                ElementMatrix* CreateKMatrixDiagnosticL1L2Viscous(void);
+                ElementMatrix* CreateKMatrixDiagnosticL1L2Friction(void);
                 ElementMatrix* CreateKMatrixDiagnosticPattyn(void);
                 ElementMatrix* CreateKMatrixDiagnosticPattynViscous(void);
 …
                 void           InputUpdateFromSolutionDiagnosticMacAyealPattyn( IssmDouble* solutiong);
                 void           InputUpdateFromSolutionDiagnosticMacAyealStokes( IssmDouble* solutiong);
+                void           InputUpdateFromSolutionDiagnosticL1L2( IssmDouble* solutiong);
                 void           InputUpdateFromSolutionDiagnosticPattyn( IssmDouble* solutiong);
                 void           InputUpdateFromSolutionDiagnosticPattynStokes( IssmDouble* solutiong);
 …
                 ElementVector* CreatePVectorDiagnosticMacAyealPattyn(void);
                 ElementVector* CreatePVectorDiagnosticMacAyealStokes(void);
+                ElementVector* CreatePVectorDiagnosticL1L2(void);
                 ElementVector* CreatePVectorDiagnosticPattyn(void);
                 ElementVector* CreatePVectorDiagnosticPattynStokes(void);
 …
                 ElementVector* CreatePVectorDiagnosticVertVolume(void);
                 ElementVector* CreatePVectorDiagnosticVertBase(void);
+                void GetL1L2Viscosity(IssmDouble*, IssmDouble*, GaussPenta*, Input*, Input*, Input*);
                 #endif

issm/branches/trunk-jpl-damage/src/c/classes/objects/Elements/PentaRef.cpp

-              r12832
+              r13101
         /*Get Determinant*/
         Matrix3x3Determinant(Jdet,&J[0][0]);
         if(*Jdet<0) _error2_("negative jacobian determinant!");
+        if(*Jdet<0) _error_("negative jacobian determinant!");
+}
 …
         /*Jdet = norm( AB ^ AC ) / (2 * area of the reference triangle), with areaRef=sqrt(3) */
         *Jdet=SQRT3/6.0*pow(pow(((y2-y1)*(z3-z1)-(z2-z1)*(y3-y1)),2.0)+pow(((z2-z1)*(x3-x1)-(x2-x1)*(z3-z1)),2.0)+pow(((x2-x1)*(y3-y1)-(y2-y1)*(x3-x1)),2.0),0.5);
         if(*Jdet<0) _error2_("negative jacobian determinant!");
+        if(*Jdet<0) _error_("negative jacobian determinant!");
+}
 /*}}}*/
 …
         *Jdet=1.0/2.0*sqrt(pow(x2-x1,2.) + pow(y2-y1,2.) + pow(z2-z1,2.));
         if(*Jdet<0) _error2_("negative jacobian determinant!");
+        if(*Jdet<0) _error_("negative jacobian determinant!");
+}
 …
         /*Area of a trabezoid = altitude * (base1 + base2)/2 */
         *Jdet= pow(pow(x2-x1,2.) + pow(y2-y1,2.),0.5) * (z4-z1 + z3-z2)/8;
         if(*Jdet<0) _error2_("negative jacobian determinant!");
+        if(*Jdet<0) _error_("negative jacobian determinant!");
+}

issm/branches/trunk-jpl-damage/src/c/classes/objects/Elements/PentaRef.h

-              r12494
+              r13101
                 void GetLprimeStokesMacAyeal(IssmDouble* LprimeStokesMacAyeal, IssmDouble* xyz_list, GaussPenta* gauss);
                 void GetInputValue(IssmDouble* pvalue,IssmDouble* plist, GaussPenta* gauss);
                 void GetInputValue(IssmDouble* pvalue,IssmDouble* plist,GaussTria* gauss){_error2_("only PentaGauss are supported");};
+                void GetInputValue(IssmDouble* pvalue,IssmDouble* plist,GaussTria* gauss){_error_("only PentaGauss are supported");};
                 void GetInputDerivativeValue(IssmDouble* pvalues, IssmDouble* plist,IssmDouble* xyz_list, GaussPenta* gauss);
                 void GetInputDerivativeValue(IssmDouble* pvalues, IssmDouble* plist,IssmDouble* xyz_list, GaussTria* gauss){_error2_("only PentaGauss are supported");};
+                void GetInputDerivativeValue(IssmDouble* pvalues, IssmDouble* plist,IssmDouble* xyz_list, GaussTria* gauss){_error_("only PentaGauss are supported");};
 };

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

-              r12946
+              r13101
                  #endif
                 case BedSlopeXAnalysisEnum: case SurfaceSlopeXAnalysisEnum: case BedSlopeYAnalysisEnum: case SurfaceSlopeYAnalysisEnum:
                         Ke=CreateKMatrixSlope();
+                        Ke=CreateMassMatrix();
                         break;
                 case PrognosticAnalysisEnum:
 …
                 #endif
                 default:
                         _error2_("analysis " << analysis_type << " (" << EnumToStringx(analysis_type) << ") not supported yet");
+                        _error_("analysis " << analysis_type << " (" << EnumToStringx(analysis_type) << ") not supported yet");
+        }
 …
         /*Intermediaries */
         int        i,j,ig;
         IssmDouble     heatcapacity,latentheat;
         IssmDouble     Jdet,D_scalar;
         IssmDouble     xyz_list[NUMVERTICES][3];
         IssmDouble     L[3];
+        IssmDouble heatcapacity,latentheat;
+        IssmDouble Jdet,D_scalar;
+        IssmDouble xyz_list[NUMVERTICES][3];
+        IssmDouble L[3];
         GaussTria *gauss=NULL;
 …
                         return CreateKMatrixPrognostic_DG();
                 default:
                         _error2_("Element type " << EnumToStringx(GetElementType()) << " not supported yet");
+                        _error_("Element type " << EnumToStringx(GetElementType()) << " not supported yet");
+        }
 …
                 if(stabilization==2){
                         /*Streamline upwinding*/
                         vel=sqrt(pow(vx,2.)+pow(vy,2.))+1.e-8;
+                        vel=sqrt(vx*vx+vy*vy)+1.e-8;
                         K[0][0]=h/(2*vel)*vx*vx;
                         K[1][0]=h/(2*vel)*vy*vx;
 …
+}
 /*}}}*/
 /*FUNCTION Tria::CreateKMatrixSlope {{{*/
 ElementMatrix* Tria::CreateKMatrixSlope(void){
+/*FUNCTION Tria::CreateMassMatrix {{{*/
+ElementMatrix* Tria::CreateMassMatrix(void){
         /*constants: */
 …
         /* Intermediaries */
+        int        i,j,ig;
+        IssmDouble     DL_scalar,Jdet;
+        IssmDouble     xyz_list[NUMVERTICES][3];
+        IssmDouble     L[1][3];
+        GaussTria *gauss = NULL;
+        IssmDouble  D,Jdet;
+        IssmDouble  xyz_list[NUMVERTICES][3];
+        IssmDouble  L[1][3];
+        GaussTria  *gauss = NULL;
         /*Initialize Element matrix*/
 …
         /* Start looping on the number of gaussian points: */
         gauss=new GaussTria(2);
         for (ig=gauss->begin();ig<gauss->end();ig++){
+        for(int ig=gauss->begin();ig<gauss->end();ig++){
                 gauss->GaussPoint(ig);
                 GetJacobianDeterminant2d(&Jdet, &xyz_list[0][0],gauss);
                 DL_scalar=gauss->weight*Jdet;
+                D=gauss->weight*Jdet;
                 GetL(&L[0][0], &xyz_list[0][0], gauss,NDOF1);
                 TripleMultiply(&L[0][0],1,3,1,
                                         &DL_scalar,1,1,0,
+                                        &D,1,1,0,
                                         &L[0][0],1,3,0,
                                         &Ke->values[0],1);
 …
                 #endif
                 default:
                         _error2_("analysis " << analysis_type << " (" << EnumToStringx(analysis_type) << ") not supported yet");
+                        _error_("analysis " << analysis_type << " (" << EnumToStringx(analysis_type) << ") not supported yet");
+        }
 …
                         return CreatePVectorPrognostic_DG();
                 default:
                         _error2_("Element type " << EnumToStringx(GetElementType()) << " not supported yet");
+                        _error_("Element type " << EnumToStringx(GetElementType()) << " not supported yet");
+        }
+}
 …
 #endif
                 default:
                         _error2_("analysis " << analysis_type << " (" << EnumToStringx(analysis_type) << ") not supported yet");
+                        _error_("analysis " << analysis_type << " (" << EnumToStringx(analysis_type) << ") not supported yet");
+        }
 …
 /*FUNCTION Tria::ComputeBasalStress {{{*/
 void  Tria::ComputeBasalStress(Vector* eps){
         _error2_("Not Implemented yet");
+        _error_("Not Implemented yet");
+}
 /*}}}*/
 /*FUNCTION Tria::ComputeStrainRate {{{*/
 void  Tria::ComputeStrainRate(Vector* eps){
         _error2_("Not Implemented yet");
+        _error_("Not Implemented yet");
+}
 /*}}}*/
 …
                  return i;
+        }
         _error2_("Node provided not found among element nodes");
+        _error_("Node provided not found among element nodes");
+}
 /*}}}*/
 …
         /*Recover input*/
         Input* input=inputs->GetInput(enumtype);
         if (!input) _error2_("Input " << EnumToStringx(enumtype) << " not found in element");
+        if (!input) _error_("Input " << EnumToStringx(enumtype) << " not found in element");
         /*Checks in debugging mode*/
 …
         Input* input=inputs->GetInput(enumtype);
         if(!input) _error2_("No input of type " << EnumToStringx(enumtype) << " found in tria");
+        if(!input) _error_("No input of type " << EnumToStringx(enumtype) << " found in tria");
         GaussTria* gauss=new GaussTria();
 …
         #endif
         default:
                 _error2_("analysis: " << EnumToStringx(analysis_type) << " not supported yet");
+                _error_("analysis: " << EnumToStringx(analysis_type) << " not supported yet");
+        }
 …
         /*Check that both inputs have been found*/
         if (!vx_input || !vy_input){
                 _error2_("Input missing. Here are the input pointers we have for vx: " << vx_input << ", vy: " << vy_input << "\n");
+                _error_("Input missing. Here are the input pointers we have for vx: " << vx_input << ", vy: " << vy_input << "\n");
+        }
 …
         /*Get input (either in element or material)*/
         Input* input=inputs->GetInput(input_enum);
         if(!input) _error2_("Input " << EnumToStringx(input_enum) << " not found in element");
+        if(!input) _error_("Input " << EnumToStringx(input_enum) << " not found in element");
         /*We found the enum.  Use its values to fill into the vector, using the vertices ids: */
 …
         ElementResult* elementresult=(ElementResult*)this->results->GetObjectByOffset(offset);
         if(elementresult->InstanceEnum()!=enum_in){
                 _error_("Results of offset %i is %s, when %s was expected",offset,EnumToStringx(elementresult->InstanceEnum()),EnumToStringx(enum_in));
+                _error_("Results of offset "<<offset<<" is "<<EnumToStringx(elementresult->InstanceEnum())<<" when "<<EnumToStringx(enum_in)<<" was expected");
+        }
         if(interp==P1Enum){
 …
         /*Make a copy of the original input: */
         input=(Input*)this->inputs->GetInput(enum_type);
         if(!input)_error2_("could not find old input with enum: " << EnumToStringx(enum_type));
+        if(!input)_error_("could not find old input with enum: " << EnumToStringx(enum_type));
         /*ArtificialNoise: */
 …
                 new_inputs[i]=(Input*)this->inputs->GetInput(enums[2*i+0]);
                 old_inputs[i]=(Input*)this->inputs->GetInput(enums[2*i+1]);
                 if(!new_inputs[i])_error2_("could not find input with enum " << EnumToStringx(enums[2*i+0]));
                 if(!old_inputs[i])_error2_("could not find input with enum " << EnumToStringx(enums[2*i+0]));
+                if(!new_inputs[i])_error_("could not find input with enum " << EnumToStringx(enums[2*i+0]));
+                if(!old_inputs[i])_error_("could not find input with enum " << EnumToStringx(enums[2*i+0]));
+        }
 …
          oldinput=(Input*)this->matice->inputs->GetInput(enum_type);
         else
          _error2_("object " << EnumToStringx(object_enum) << " not supported yet");
         if(!oldinput)_error2_("could not find old input with enum: " << EnumToStringx(enum_type));
+         _error_("object " << EnumToStringx(object_enum) << " not supported yet");
+        if(!oldinput)_error_("could not find old input with enum: " << EnumToStringx(enum_type));
         newinput=(Input*)oldinput->copy();
 …
          this->matice->inputs->AddInput((Input*)newinput);
         else
          _error2_("object " << EnumToStringx(object_enum) << " not supported yet");
+         _error_("object " << EnumToStringx(object_enum) << " not supported yet");
+}
 /*}}}*/
 …
         /*Make a copy of the original input: */
         input=(Input*)this->inputs->GetInput(enum_type);
         if(!input)_error2_("could not find old input with enum: " << EnumToStringx(enum_type));
+        if(!input)_error_("could not find old input with enum: " << EnumToStringx(enum_type));
         /*Scale: */
 …
         if (enum_type==MaterialsRheologyBbarEnum || enum_type==MaterialsRheologyZbarEnum) input=this->matice->inputs->GetInput(enum_type);
         else input=this->inputs->GetInput(enum_type);
         //if (!input) _error2_("Input " << EnumToStringx(enum_type) << " not found in tria->inputs");
+        //if (!input) _error_("Input " << EnumToStringx(enum_type) << " not found in tria->inputs");
         if(!input)return;
 …
         /*Intermediaries*/
         int    i,j;
         int    tria_vertex_ids[3];
+        int        i,j;
+        int        tria_vertex_ids[3];
         IssmDouble nodeinputs[3];
         IssmDouble cmmininputs[3];
         IssmDouble cmmaxinputs[3];
         bool   control_analysis=false;
         int    num_control_type;
+        bool       control_analysis   = false;
+        int        num_control_type;
         IssmDouble yts;
         int    num_cm_responses;
+        int        num_cm_responses;
         /*Get parameters: */
 …
         if (control_analysis && iomodel->Data(InversionControlParametersEnum)){
                 for(i=0;i<num_control_type;i++){
                         switch((int)iomodel->Data(InversionControlParametersEnum)[i]){
+                        switch(reCast<int>(iomodel->Data(InversionControlParametersEnum)[i])){
                                 case BalancethicknessThickeningRateEnum:
                                         if (iomodel->Data(BalancethicknessThickeningRateEnum)){
 …
                                         /*Matice will take care of it*/ break;
                                 default:
                                         _error2_("Control " << EnumToStringx((int)iomodel->Data(InversionControlParametersEnum)[i]) << " not implemented yet");
+                                        _error_("Control " << EnumToStringx(reCast<int,IssmDouble>(iomodel->Data(InversionControlParametersEnum)[i])) << " not implemented yet");
+                        }
+                }
 …
                         break;
                 default:
                         _error2_("analysis " << analysis_type << " (" << EnumToStringx(analysis_type) << ") not supported yet");
+                        _error_("analysis " << analysis_type << " (" << EnumToStringx(analysis_type) << ") not supported yet");
+        }
+}
 …
         for(int i=0;i<numdof;i++){
                 values[i]=solution[doflist[i]];
                 if(xIsNan<IssmDouble>(values[i])) _error2_("NaN found in solution vector");
+                if(xIsNan<IssmDouble>(values[i])) _error_("NaN found in solution vector");
+        }
 …
         for(i=0;i<numdof;i++){
                 newthickness[i]=solution[doflist[i]];
                 if(xIsNan<IssmDouble>(newthickness[i])) _error2_("NaN found in solution vector");
+                if(xIsNan<IssmDouble>(newthickness[i])) _error_("NaN found in solution vector");
                 /*Constrain thickness to be at least 1m*/
                 if(newthickness[i]<minthickness) newthickness[i]=minthickness;
 …
                                 newbed[i]=oldbed[i]-rho_ice/rho_water*(newthickness[i]-oldthickness[i]); //bed = oldbed + di * dH
+                        }
                         else _error2_("Hydrostatic adjustment " << hydroadjustment << " (" << EnumToStringx(hydroadjustment) << ") not supported yet");
+                        else _error_("Hydrostatic adjustment " << hydroadjustment << " (" << EnumToStringx(hydroadjustment) << ") not supported yet");
+                }
+        }
 …
+                }
                 default:
                         _error2_("type " << type << " (" << EnumToStringx(type) << ") not implemented yet");
+                        _error_("type " << type << " (" << EnumToStringx(type) << ") not implemented yet");
+        }
+}
 …
 /*FUNCTION Tria::InputUpdateFromVector(int* vector, int name, int type);{{{*/
 void  Tria::InputUpdateFromVector(int* vector, int name, int type){
         _error2_("not supported yet!");
+        _error_("not supported yet!");
+}
 /*}}}*/
 /*FUNCTION Tria::InputUpdateFromVector(bool* vector, int name, int type);{{{*/
 void  Tria::InputUpdateFromVector(bool* vector, int name, int type){
         _error2_("not supported yet!");
+        _error_("not supported yet!");
+}
 /*}}}*/
 …
                 this->inputs->AddInput(new DoubleInput(name,reCast<int>(scalar)));
+        }
         else _error2_("could not recognize nature of vector from code " << code);
+        else _error_("could not recognize nature of vector from code " << code);
+}
 …
                         this->inputs->AddInput(transientinput);
+                }
                 else _error2_("nodal vector is either numberofnodes or numberofnodes+1 long. Field provided (" << EnumToStringx(vector_enum) << ") is " << M << " long");
+                else _error_("nodal vector is either numberofnodes or numberofnodes+1 long. Field provided (" << EnumToStringx(vector_enum) << ") is " << M << " long");
+        }
         else if(vector_type==2){ //element vector
 …
                                 this->inputs->AddInput(new DoubleInput(vector_enum,vector[index]));
+                        }
                         else _error2_("could not recognize nature of vector from code " << code);
+                        else _error_("could not recognize nature of vector from code " << code);
+                }
                 else {
                         _error2_("transient elementary inputs not supported yet!");
+                        _error_("transient elementary inputs not supported yet!");
+                }
+        }
         else{
                 _error2_("Cannot add input for vector type " << vector_type << " (not supported)");
+                _error_("Cannot add input for vector type " << vector_type << " (not supported)");
+        }
 …
 void  Tria::SetClone(int* minranks){
         _error2_("not implemented yet");
+        _error_("not implemented yet");
+}
 /*}}}*/
 /*FUNCTION Tria::SmearFunction {{{*/
 void  Tria::SmearFunction(Vector*  smearedvector,IssmDouble (*WeightFunction)(IssmDouble distance,IssmDouble radius),IssmDouble radius){
         _error2_("not implemented yet");
+        _error_("not implemented yet");
+}
 …
 IssmDouble Tria::SurfaceArea(void){
-        int    i;
         IssmDouble S;
         IssmDouble normal[3];
 …
         GetVerticesCoordinates(&xyz_list[0][0], nodes, NUMVERTICES);
         for (i=0;i<3;i++){
+        for(int i=0;i<3;i++){
                 v13[i]=xyz_list[0][i]-xyz_list[2][i];
                 v23[i]=xyz_list[1][i]-xyz_list[2][i];
 …
         normal[2]=v13[0]*v23[1]-v13[1]*v23[0];
         S = 0.5 * sqrt(pow(normal[0],(IssmDouble)2)+pow(normal[1],(IssmDouble)2)+pow(normal[2],(IssmDouble)2));
+        S = 0.5 * sqrt(normal[0]*normal[0] + normal[1]*normal[1] + normal[2]*normal[2]);
         /*Return: */
 …
 void Tria::SurfaceNormal(IssmDouble* surface_normal, IssmDouble xyz_list[3][3]){
-        int i;
         IssmDouble v13[3],v23[3];
         IssmDouble normal[3];
         IssmDouble normal_norm;
         for (i=0;i<3;i++){
+        for(int i=0;i<3;i++){
                 v13[i]=xyz_list[0][i]-xyz_list[2][i];
                 v23[i]=xyz_list[1][i]-xyz_list[2][i];
 …
         normal[2]=v13[0]*v23[1]-v13[1]*v23[0];
         normal_norm=sqrt( pow(normal[0],(IssmDouble)2)+pow(normal[1],(IssmDouble)2)+pow(normal[2],(IssmDouble)2) );
         *(surface_normal)=normal[0]/normal_norm;
         *(surface_normal+1)=normal[1]/normal_norm;
         *(surface_normal+2)=normal[2]/normal_norm;
+        normal_norm=sqrt( normal[0]*normal[0] + normal[1]*normal[1] + normal[2]*normal[2]);
+        *(surface_normal+0) = normal[0]/normal_norm;
+        *(surface_normal+1) = normal[1]/normal_norm;
+        *(surface_normal+2) = normal[2]/normal_norm;
+}
 /*}}}*/
 …
         this->MaxAbsVy(&maxabsvy,false);
         #else
                 _error2_("ISSM was not compiled with responses compiled in, exiting!");
+                _error_("ISSM was not compiled with responses compiled in, exiting!");
         #endif
 …
         /*First off, check that this segment belongs to this element: */
         if ((int)*(segment+4)!=this->id)_error2_("error message: segment with id " << (int)*(segment+4) << " does not belong to element with id:" << this->id);
+        if (reCast<int>(*(segment+4))!=this->id)_error_("error message: segment with id " << reCast<int>(*(segment+4)) << " does not belong to element with id:" << this->id);
         /*Recover segment node locations: */
 …
         normal[1]=sin(atan2(x1-x2,y2-y1));
         length=sqrt(pow(x2-x1,2.0)+pow(y2-y1,2));
+        length=sqrt(pow(x2-x1,2)+pow(y2-y1,2));
         Input* thickness_input=inputs->GetInput(ThicknessEnum); _assert_(thickness_input);
 …
                         *presponse=this->matice->GetZbar();
                         break;
                 case VelEnum:
+                case VelEnum:{
                         /*Get input:*/
 …
                         /*Assign output pointers:*/
+                        *presponse=vel;
+                        *presponse=vel;}
+                        break;
                 default:
                         _error2_("Response type " << EnumToStringx(response_enum) << " not supported yet!");
+                        _error_("Response type " << EnumToStringx(response_enum) << " not supported yet!");
+        }
 …
                 //velocity should be = 0. To achieve this result, we set alpha2_list to a very high value: */
                 surface_input->GetInputDerivativeValue(&slope[0],&xyz_list[0][0],gauss);
                 slope_magnitude=sqrt(pow(slope[0],2)+pow(slope[1],2));
+                slope_magnitude=sqrt(slope[0]*slope[0]+slope[1]*slope[1]);
                 if(slope_magnitude>MAXSLOPE) alpha2=pow((IssmDouble)10,MOUNTAINKEXPONENT);
                 else friction->GetAlpha2(&alpha2, gauss,VxEnum,VyEnum,VzEnum);
 …
                 /*Check solution*/
                 if(xIsNan<IssmDouble>(vx[i])) _error2_("NaN found in solution vector");
                 if(xIsNan<IssmDouble>(vy[i])) _error2_("NaN found in solution vector");
+                if(xIsNan<IssmDouble>(vx[i])) _error_("NaN found in solution vector");
+                if(xIsNan<IssmDouble>(vy[i])) _error_("NaN found in solution vector");
+        }
         /*Get Vz and compute vel*/
         GetInputListOnVertices(&vz[0],VzEnum,0);
         for(i=0;i<NUMVERTICES;i++) vel[i]=pow( pow(vx[i],2.0) + pow(vy[i],2.0) + pow(vz[i],2.0) , 0.5);
+        for(i=0;i<NUMVERTICES;i++) vel[i]=sqrt(vx[i]*vx[i] + vy[i]*vy[i] + vz[i]*vz[i]);
         /*For pressure: we have not computed pressure in this analysis, for this element. We are in 2D,
 …
                 /*Check solution*/
                 if(xIsNan<IssmDouble>(vx[i])) _error2_("NaN found in solution vector");
                 if(xIsNan<IssmDouble>(vy[i])) _error2_("NaN found in solution vector");
+                if(xIsNan<IssmDouble>(vx[i])) _error_("NaN found in solution vector");
+                if(xIsNan<IssmDouble>(vy[i])) _error_("NaN found in solution vector");
+        }
         /*Now Compute vel*/
         GetInputListOnVertices(&vz[0],VzEnum,0.0); //default is 0
         for(i=0;i<NUMVERTICES;i++) vel[i]=pow( pow(vx[i],2.0) + pow(vy[i],2.0) + pow(vz[i],2.0) , 0.5);
+        for(i=0;i<NUMVERTICES;i++) vel[i]=sqrt(vx[i]*vx[i] + vy[i]*vy[i] + vz[i]*vz[i]);
         /*For pressure: we have not computed pressure in this analysis, for this element. We are in 2D,
 …
                 if (input->ObjectEnum()!=ControlInputEnum){
                         _error2_("input " << EnumToStringx(control_type[i]) << " is not a ControlInput");
+                        _error_("input " << EnumToStringx(control_type[i]) << " is not a ControlInput");
+                }
 …
                 input=inputs->GetInput(enum_type);
+        }
         if (!input) _error2_("Input " << EnumToStringx(enum_type) << " not found");
         if (input->ObjectEnum()!=ControlInputEnum) _error2_("Input " << EnumToStringx(enum_type) << " is not a ControlInput");
+        if (!input) _error_("Input " << EnumToStringx(enum_type) << " not found");
+        if (input->ObjectEnum()!=ControlInputEnum) _error_("Input " << EnumToStringx(enum_type) << " is not a ControlInput");
         GradientIndexing(&doflist1[0],control_index);
 …
                 input=inputs->GetInput(enum_type);
+        }
         if (!input) _error2_("Input " << EnumToStringx(enum_type) << " not found");
         if (input->ObjectEnum()!=ControlInputEnum) _error2_("Input " << EnumToStringx(enum_type) << " is not a ControlInput");
+        if (!input) _error_("Input " << EnumToStringx(enum_type) << " not found");
+        if (input->ObjectEnum()!=ControlInputEnum) _error_("Input " << EnumToStringx(enum_type) << " is not a ControlInput");
         ((ControlInput*)input)->ScaleGradient(scale);
 …
                 input=inputs->GetInput(enum_type);
+        }
         if (!input) _error2_("Input " << EnumToStringx(enum_type) << " not found");
         if (input->ObjectEnum()!=ControlInputEnum) _error2_("Input " << EnumToStringx(enum_type) << " is not a ControlInput");
+        if (!input) _error_("Input " << EnumToStringx(enum_type) << " not found");
+        if (input->ObjectEnum()!=ControlInputEnum) _error_("Input " << EnumToStringx(enum_type) << " is not a ControlInput");
         GradientIndexing(&doflist1[0],control_index);
 …
                         break;
                 default:
                         _error2_("control type not supported yet: " << control_type);
+                        _error_("control type not supported yet: " << control_type);
+        }
 …
                         break;
                 default:
                         _error2_("response " << EnumToStringx(responses[resp]) << " not supported yet");
+                        _error_("response " << EnumToStringx(responses[resp]) << " not supported yet");
+        }
 …
                  *      S                obs            obs
                  */
                 misfit=1/S*pow( pow(vx-vxobs,2.) + pow(vy-vyobs,2.) ,0.5);
+                misfit=1/S*sqrt( pow(vx-vxobs,2) + pow(vy-vyobs,2));
                 if(process_units)UnitConversion(misfit,IuToExtEnum,SurfaceAverageVelMisfitEnum);
 …
                  *                            obs
                  */
                 velocity_mag    =sqrt(pow(vx,   2.)+pow(vy,   2.))+epsvel;
                 obs_velocity_mag=sqrt(pow(vxobs,2.)+pow(vyobs,2.))+epsvel;
                 misfit=4*pow(meanvel,2.)*pow(log(velocity_mag/obs_velocity_mag),2.);
+                velocity_mag    =sqrt(pow(vx,   2)+pow(vy,   2))+epsvel;
+                obs_velocity_mag=sqrt(pow(vxobs,2)+pow(vyobs,2))+epsvel;
+                misfit=4*pow(meanvel,2)*pow(log(velocity_mag/obs_velocity_mag),2);
                 if(process_units)UnitConversion(misfit,IuToExtEnum,SurfaceLogVelMisfitEnum);
 …
                  *                              obs                       obs
                  */
                 misfit=0.5*pow(meanvel,2.)*(
                                         pow(log((fabs(vx)+epsvel)/(fabs(vxobs)+epsvel)),2.) +
                                         pow(log((fabs(vy)+epsvel)/(fabs(vyobs)+epsvel)),2.) );
+                misfit=0.5*pow(meanvel,2)*(
+                                        pow(log((fabs(vx)+epsvel)/(fabs(vxobs)+epsvel)),2) +
+                                        pow(log((fabs(vy)+epsvel)/(fabs(vyobs)+epsvel)),2) );
                 if(process_units)UnitConversion(misfit,IuToExtEnum,SurfaceLogVxVyMisfitEnum);
 …
+                 *
                  */
                 misfit=0.5*( pow(vx-vxobs,2.) + pow(vy-vyobs,2.) );
+                misfit=0.5*( pow(vx-vxobs,2) + pow(vy-vyobs,2) );
                 if(process_units)UnitConversion(misfit,IuToExtEnum,SurfaceAverageVelMisfitEnum);
 …
                  *              obs                        obs
                  */
                 scalex=pow(meanvel/(vxobs+epsvel),2.); if(vxobs==0)scalex=0;
                 scaley=pow(meanvel/(vyobs+epsvel),2.); if(vyobs==0)scaley=0;
                 misfit=0.5*(scalex*pow((vx-vxobs),2.)+scaley*pow((vy-vyobs),2.));
+                scalex=pow(meanvel/(vxobs+epsvel),2); if(vxobs==0)scalex=0;
+                scaley=pow(meanvel/(vyobs+epsvel),2); if(vyobs==0)scaley=0;
+                misfit=0.5*(scalex*pow((vx-vxobs),2)+scaley*pow((vy-vyobs),2));
                 if(process_units)UnitConversion(misfit,IuToExtEnum,SurfaceRelVelMisfitEnum);
 …
                 /*Tikhonov regularization: J = 1/2 ((dp/dx)^2 + (dp/dy)^2) */
                 Jelem+=weight*1/2*(pow(dp[0],2.)+pow(dp[1],2.))*Jdet*gauss->weight;
+                Jelem+=weight*1/2*(dp[0]*dp[0]+dp[1]*dp[1])*Jdet*gauss->weight;
+        }
 …
         IssmDouble  xyz_list[NUMVERTICES][3];
         IssmDouble  dp[NDOF2];
         IssmDouble  vx,vy;
+        IssmDouble  vx,vy,vel;
         GaussTria  *gauss                    = NULL;
 …
                 vx_input->GetInputValue(&vx,gauss);
                 vy_input->GetInputValue(&vy,gauss);
+                vel = sqrt(vx*vx+vy*vy);
+                vx  = vx/(vel+1.e-9);
+                vy  = vy/(vel+1.e-9);
                 /*J = 1/2 ( vx*dH/dx + vy*dH/dy )^2 */
 …
         IssmDouble  xyz_list[NUMVERTICES][3];
         IssmDouble  dp[NDOF2];
         IssmDouble  vx,vy;
+        IssmDouble  vx,vy,vel;
         GaussTria  *gauss                    = NULL;
 …
                 vx_input->GetInputValue(&vx,gauss);
                 vy_input->GetInputValue(&vy,gauss);
+                vel = sqrt(vx*vx+vy*vy);
+                vx  = vx/(vel+1.e-9);
+                vy  = vy/(vel+1.e-9);
                 /*J = 1/2 ( -vy*dH/dx + vx*dH/dy )^2 */
 …
                 /*compute ThicknessAbsMisfit*/
                 Jelem+=0.5*pow(thickness-thicknessobs,2.0)*weight*Jdet*gauss->weight;
+                Jelem+=0.5*(thickness-thicknessobs)*(thickness-thicknessobs)*weight*Jdet*gauss->weight;
+        }
 …
         IssmDouble  dbasis[NDOF2][NUMVERTICES];
         IssmDouble  dH[2];
         IssmDouble  v[2];
+        IssmDouble  vx,vy,vel;
         GaussTria *gauss     = NULL;
         int       *responses = NULL;
 …
                         case ThicknessAlongGradientEnum:
                                 weights_input->GetInputValue(&weight, gauss,resp);
+                                vx_input->GetInputValue(&v[0],gauss);
+                                vy_input->GetInputValue(&v[1],gauss);
+                                for(i=0;i<numdof;i++) pe->values[i]+= - weight*(dH[0]*v[0]+dH[1]*v[1])*(dbasis[0][i]*v[0]+dbasis[1][i]*v[1])*Jdet*gauss->weight;
+                                vx_input->GetInputValue(&vx,gauss);
+                                vy_input->GetInputValue(&vy,gauss);
+                                vel = sqrt(vx*vx+vy*vy);
+                                vx  = vx/(vel+1.e-9);
+                                vy  = vy/(vel+1.e-9);
+                                for(i=0;i<numdof;i++) pe->values[i]+= - weight*(dH[0]*vx+dH[1]*vy)*(dbasis[0][i]*vx+dbasis[1][i]*vy)*Jdet*gauss->weight;
                                 break;
                         case ThicknessAcrossGradientEnum:
                                 weights_input->GetInputValue(&weight, gauss,resp);
+                                vx_input->GetInputValue(&v[0],gauss);
+                                vy_input->GetInputValue(&v[1],gauss);
+                                for(i=0;i<numdof;i++) pe->values[i]+= - weight*(dH[0]*(-v[1])+dH[1]*v[0])*(dbasis[0][i]*(-v[1])+dbasis[1][i]*v[0])*Jdet*gauss->weight;
+                                vx_input->GetInputValue(&vx,gauss);
+                                vy_input->GetInputValue(&vy,gauss);
+                                vel = sqrt(vx*vx+vy*vy);
+                                vx  = vx/(vel+1.e-9);
+                                vy  = vy/(vel+1.e-9);
+                                for(i=0;i<numdof;i++) pe->values[i]+= - weight*(dH[0]*(-vy)+dH[1]*vx)*(dbasis[0][i]*(-vy)+dbasis[1][i]*vx)*Jdet*gauss->weight;
                                 break;
                         default:
                                 _error2_("response " << EnumToStringx(responses[resp]) << " not supported yet");
+                                _error_("response " << EnumToStringx(responses[resp]) << " not supported yet");
+                }
+        }
 …
                                          */
                                         for (i=0;i<NUMVERTICES;i++){
                                                 scalex=pow(meanvel/(vxobs+epsvel),2.); if(vxobs==0)scalex=0;
                                                 scaley=pow(meanvel/(vyobs+epsvel),2.); if(vyobs==0)scaley=0;
+                                                scalex=pow(meanvel/(vxobs+epsvel),2); if(vxobs==0)scalex=0;
+                                                scaley=pow(meanvel/(vyobs+epsvel),2); if(vyobs==0)scaley=0;
                                                 dux=scalex*(vxobs-vx);
                                                 duy=scaley*(vyobs-vy);
 …
                                          */
                                         for (i=0;i<NUMVERTICES;i++){
                                                 velocity_mag    =sqrt(pow(vx,   2.)+pow(vy,   2.))+epsvel;
                                                 obs_velocity_mag=sqrt(pow(vxobs,2.)+pow(vyobs,2.))+epsvel;
                                                 scale=-8*pow(meanvel,2.)/pow(velocity_mag,2.)*log(velocity_mag/obs_velocity_mag);
+                                                velocity_mag    =sqrt(pow(vx,   2)+pow(vy,   2))+epsvel;
+                                                obs_velocity_mag=sqrt(pow(vxobs,2)+pow(vyobs,2))+epsvel;
+                                                scale=-8*pow(meanvel,2)/pow(velocity_mag,2)*log(velocity_mag/obs_velocity_mag);
                                                 dux=scale*vx;
                                                 duy=scale*vy;
 …
                                          */
                                         for (i=0;i<NUMVERTICES;i++){
                                                 scale=1./(S*2*sqrt(pow(vx-vxobs,2.)+pow(vy-vyobs,2.))+epsvel);
+                                                scale=1./(S*2*sqrt(pow(vx-vxobs,2)+pow(vy-vyobs,2))+epsvel);
                                                 dux=scale*(vxobs-vx);
                                                 duy=scale*(vyobs-vy);
 …
                                          */
                                         for (i=0;i<NUMVERTICES;i++){
                                                 dux = - pow(meanvel,2.) * log((fabs(vx)+epsvel)/(fabs(vxobs)+epsvel)) / (vx+epsvel);
                                                 duy = - pow(meanvel,2.) * log((fabs(vy)+epsvel)/(fabs(vyobs)+epsvel)) / (vy+epsvel);
+                                                dux = - meanvel*meanvel * log((fabs(vx)+epsvel)/(fabs(vxobs)+epsvel)) / (vx+epsvel);
+                                                duy = - meanvel*meanvel * log((fabs(vy)+epsvel)/(fabs(vyobs)+epsvel)) / (vy+epsvel);
                                                 pe->values[i*NDOF2+0]+=dux*weight*Jdet*gauss->weight*basis[i];
                                                 pe->values[i*NDOF2+1]+=duy*weight*Jdet*gauss->weight*basis[i];
 …
                                         break;
                                 default:
                                         _error2_("response " << EnumToStringx(responses[resp]) << " not supported yet");
+                                        _error_("response " << EnumToStringx(responses[resp]) << " not supported yet");
+                        }
+                }
 …
                                          */
                                         for (i=0;i<NUMVERTICES;i++){
                                                 scalex=pow(meanvel/(vxobs+epsvel),2.); if(vxobs==0)scalex=0;
                                                 scaley=pow(meanvel/(vyobs+epsvel),2.); if(vyobs==0)scaley=0;
+                                                scalex=pow(meanvel/(vxobs+epsvel),2); if(vxobs==0)scalex=0;
+                                                scaley=pow(meanvel/(vyobs+epsvel),2); if(vyobs==0)scaley=0;
                                                 dux=scalex*(vxobs-vx);
                                                 duy=scaley*(vyobs-vy);
 …
                                          */
                                         for (i=0;i<NUMVERTICES;i++){
                                                 velocity_mag    =sqrt(pow(vx,   2.)+pow(vy,   2.))+epsvel;
                                                 obs_velocity_mag=sqrt(pow(vxobs,2.)+pow(vyobs,2.))+epsvel;
                                                 scale=-8*pow(meanvel,2.)/pow(velocity_mag,2.)*log(velocity_mag/obs_velocity_mag);
+                                                velocity_mag    =sqrt(pow(vx,   2)+pow(vy,   2))+epsvel;
+                                                obs_velocity_mag=sqrt(pow(vxobs,2)+pow(vyobs,2))+epsvel;
+                                                scale=-8*pow(meanvel,2)/pow(velocity_mag,2)*log(velocity_mag/obs_velocity_mag);
                                                 dux=scale*vx;
                                                 duy=scale*vy;
 …
                                          */
                                         for (i=0;i<NUMVERTICES;i++){
                                                 scale=1./(S*2*sqrt(pow(vx-vxobs,2.)+pow(vy-vyobs,2.))+epsvel);
+                                                scale=1./(S*2*sqrt(pow(vx-vxobs,2)+pow(vy-vyobs,2))+epsvel);
                                                 dux=scale*(vxobs-vx);
                                                 duy=scale*(vyobs-vy);
 …
                                          */
                                         for (i=0;i<NUMVERTICES;i++){
                                                 dux = - pow(meanvel,2.) * log((fabs(vx)+epsvel)/(fabs(vxobs)+epsvel)) / (vx+epsvel);
                                                 duy = - pow(meanvel,2.) * log((fabs(vy)+epsvel)/(fabs(vyobs)+epsvel)) / (vy+epsvel);
+                                                dux = - meanvel*meanvel * log((fabs(vx)+epsvel)/(fabs(vxobs)+epsvel)) / (vx+epsvel);
+                                                duy = - meanvel*meanvel * log((fabs(vy)+epsvel)/(fabs(vyobs)+epsvel)) / (vy+epsvel);
                                                 pe->values[i*NDOF4+0]+=dux*weight*Jdet*gauss->weight*basis[i];
                                                 pe->values[i*NDOF4+1]+=duy*weight*Jdet*gauss->weight*basis[i];
 …
                                         break;
                                 default:
                                         _error2_("response " << EnumToStringx(responses[resp]) << " not supported yet");
+                                        _error_("response " << EnumToStringx(responses[resp]) << " not supported yet");
+                        }
+                }
 …
                 /*Tikhonov regularization: J = 1/2 ((dp/dx)^2 + (dp/dy)^2) */
                 Jelem+=weight*1/2*(pow(dp[0],2.)+pow(dp[1],2.))*Jdet*gauss->weight;
+                Jelem+=weight*1/2*(dp[0]*dp[0]+dp[1]*dp[1])*Jdet*gauss->weight;
+        }
 …
                         break;
                 default:
                         _error2_("Element type " << EnumToStringx(GetElementType()) << " not supported yet");
+                        _error_("Element type " << EnumToStringx(GetElementType()) << " not supported yet");
+        }
 …
                 /*Check solution*/
                 if(xIsNan<IssmDouble>(lambdax[i])) _error2_("NaN found in solution vector");
                 if(xIsNan<IssmDouble>(lambday[i])) _error2_("NaN found in solution vector");
+                if(xIsNan<IssmDouble>(lambdax[i])) _error_("NaN found in solution vector");
+                if(xIsNan<IssmDouble>(lambday[i])) _error_("NaN found in solution vector");
+        }
 …
         for(i=0;i<numdof;i++){
                 lambda[i]=values[i];
                 if(xIsNan<IssmDouble>(lambda[i])) _error2_("NaN found in solution vector");
+                if(xIsNan<IssmDouble>(lambda[i])) _error_("NaN found in solution vector");
+        }
 …
         /*Get input (either in element or material)*/
         if(control_enum==MaterialsRheologyBbarEnum){
+        if(control_enum==MaterialsRheologyBbarEnum || control_enum==MaterialsRheologyZbarEnum){
                 input=(Input*)matice->inputs->GetInput(control_enum); _assert_(input);
+        }
 …
         /*Check that it is a ControlInput*/
         if (input->ObjectEnum()!=ControlInputEnum){
                 _error2_("input " << EnumToStringx(control_enum) << " is not a ControlInput");
+                _error_("input " << EnumToStringx(control_enum) << " is not a ControlInput");
+        }
 …
         new_input = new TriaP1Input(control_enum,values);
         if(control_enum==MaterialsRheologyBbarEnum){
+        if(control_enum==MaterialsRheologyBbarEnum || control_enum==MaterialsRheologyZbarEnum){
                 input=(Input*)matice->inputs->GetInput(control_enum); _assert_(input);
+        }
 …
         if (input->ObjectEnum()!=ControlInputEnum){
                 _error2_("input " << EnumToStringx(control_enum) << " is not a ControlInput");
+                _error_("input " << EnumToStringx(control_enum) << " is not a ControlInput");
+        }
 …
         /* compute VelocityFactor */
         VelocityFactor= n_man*pow(CR,2)*rho_water*g/mu_water;
+        VelocityFactor= n_man*CR*CR*rho_water*g/mu_water;
         gauss=new GaussTria();
 …
                 /* Water velocity x and y components */
+        //      vx[iv]= - pow(w,2)/(12 * mu_water)*(rho_ice*g*dsdx+(rho_water-rho_ice)*g*dbdx);
+        //      vy[iv]= - pow(w,2)/(12 * mu_water)*(rho_ice*g*dsdy+(rho_water-rho_ice)*g*dbdy);
+                vx[iv]= - pow(w,2)/(VelocityFactor* mu_water)*(rho_ice*g*dsdx+(rho_water-rho_ice)*g*dbdx);
+                vy[iv]= - pow(w,2)/(VelocityFactor* mu_water)*(rho_ice*g*dsdy+(rho_water-rho_ice)*g*dbdy);
+        //      vx[iv]= - w*w/(12 * mu_water)*(rho_ice*g*dsdx+(rho_water-rho_ice)*g*dbdx);
+        //      vy[iv]= - w*w/(12 * mu_water)*(rho_ice*g*dsdy+(rho_water-rho_ice)*g*dbdy);
+                vx[iv]= - w*w/(VelocityFactor* mu_water)*(rho_ice*g*dsdx+(rho_water-rho_ice)*g*dbdx);
+                vy[iv]= - w*w/(VelocityFactor* mu_water)*(rho_ice*g*dsdy+(rho_water-rho_ice)*g*dbdy);
+        }
 …
                 /*Artificial diffusivity*/
                 vel=sqrt(pow(vx,2.)+pow(vy,2.));
+                vel=sqrt(vx*vx+vy*vy);
                 K[0][0]=diffusivity*h/(2*vel)*vx*vx;
                 K[1][0]=diffusivity*h/(2*vel)*vy*vx;
 …
                 old_watercolumn_input->GetInputValue(&old_watercolumn_g,gauss);
                 if(dt)for(i=0;i<numdof;i++) pe->values[i]+=Jdettria*gauss->weight*(old_watercolumn_g+dt*basal_melting_g)*basis[i];
+                if(reCast<int,IssmDouble>(dt))for(i=0;i<numdof;i++) pe->values[i]+=Jdettria*gauss->weight*(old_watercolumn_g+dt*basal_melting_g)*basis[i];
                 else  for(i=0;i<numdof;i++) pe->values[i]+=Jdettria*gauss->weight*basal_melting_g*basis[i];
+        }
 …
         /*Intermediaries*/
+        const int numdof = NDOF1*NUMVERTICES;
+        int       i;
+        int*      doflist=NULL;
+        IssmDouble    values[numdof];
+        const int   numdof         = NDOF1 *NUMVERTICES;
+        int        *doflist        = NULL;
+        IssmDouble  values[numdof];
         /*Get dof list: */
 …
         /*Use the dof list to index into the solution vector: */
         for(i=0;i<numdof;i++){
+        for(int i=0;i<numdof;i++){
                 values[i]=solution[doflist[i]];
+                if(xIsNan<IssmDouble>(values[i])) _error2_("NaN found in solution vector");
+                if (values[i]<pow((IssmDouble)10,(IssmDouble)-10))values[i]=pow((IssmDouble)10,(IssmDouble)-10); //correcting the water column to positive values
+                if(xIsNan<IssmDouble>(values[i])) _error_("NaN found in solution vector");
+                if (values[i]<10e-10) values[i]=10e-10; //correcting the water column to positive values
+        }
 …
                 default:
                         _error2_("type " << type << " (" << EnumToStringx(type) << ") not implemented yet");
+                        _error_("type " << type << " (" << EnumToStringx(type) << ") not implemented yet");
+        }
 …
 /*FUNCTION Tria::InputUpdateFromVectorDakota(int* vector, int name, int type);{{{*/
 void  Tria::InputUpdateFromVectorDakota(int* vector, int name, int type){
         _error2_("not supported yet!");
+        _error_("not supported yet!");
+}
 /*}}}*/
 /*FUNCTION Tria::InputUpdateFromVectorDakota(bool* vector, int name, int type);{{{*/
 void  Tria::InputUpdateFromVectorDakota(bool* vector, int name, int type){
         _error2_("not supported yet!");
+        _error_("not supported yet!");
+}
 /*}}}*/
 …
                 default:
                         _error2_("type " << type << " (" << EnumToStringx(type) << ") not implemented yet");
+                        _error_("type " << type << " (" << EnumToStringx(type) << ") not implemented yet");
+        }
 …
                         return CreateKMatrixBalancethickness_DG();
                 default:
                         _error2_("Element type " << EnumToStringx(GetElementType()) << " not supported yet");
+                        _error_("Element type " << EnumToStringx(GetElementType()) << " not supported yet");
+        }
 …
                 if(stabilization==1){
                         /*Streamline upwinding*/
                         vel=sqrt(pow(vx,2.)+pow(vy,2.));
+                        vel=sqrt(vx*vx+vy*vy);
                         K[0][0]=h/(2*vel)*vx*vx;
                         K[1][0]=h/(2*vel)*vy*vx;
 …
                         return CreatePVectorBalancethickness_DG();
                 default:
                         _error2_("Element type " << EnumToStringx(GetElementType()) << " not supported yet");
+                        _error_("Element type " << EnumToStringx(GetElementType()) << " not supported yet");
+        }
+}

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

-              r12946
+              r13101
                 void   InputToResult(int enum_type,int step,IssmDouble time);
                 void   DeleteResults(void);
                 void   MaterialUpdateFromTemperature(void){_error2_("not implemented yet");};
+                void   MaterialUpdateFromTemperature(void){_error_("not implemented yet");};
                 void   MigrateGroundingLine(IssmDouble* oldfloating,IssmDouble* sheet_ungrounding);
                 int    NodalValue(IssmDouble* pvalue, int index, int natureofdataenum,bool process_units);
 …
                 void   PatchSize(int* pnumrows, int* pnumvertices,int* pnumnodes);
                 void   ProcessResultsUnits(void);
                 void   ResetCoordinateSystem(void){_error2_("not implemented yet");};
+                void   ResetCoordinateSystem(void){_error_("not implemented yet");};
                 void     SmbGradients();
                 IssmDouble SurfaceArea(void);
 …
                 ElementMatrix* CreateKMatrixPrognostic_CG(void);
                 ElementMatrix* CreateKMatrixPrognostic_DG(void);
                 ElementMatrix* CreateKMatrixSlope(void);
+                ElementMatrix* CreateMassMatrix(void);
                 ElementVector* CreatePVectorBalancethickness(void);
                 ElementVector* CreatePVectorBalancethickness_DG(void);

issm/branches/trunk-jpl-damage/src/c/classes/objects/Elements/TriaRef.cpp

-              r12832
+              r13101
         *Jdet=1.0/2.0*sqrt(pow(x2-x1,2.) + pow(y2-y1,2.));
         if(*Jdet<0) _error2_("negative jacobian determinant!");
+        if(*Jdet<0) _error_("negative jacobian determinant!");
+}
 …
         /*Get Determinant*/
         Matrix2x2Determinant(Jdet,&J[0][0]);
         if(*Jdet<0) _error2_("negative jacobian determinant!");
+        if(*Jdet<0) _error_("negative jacobian determinant!");
+}
 …
         *Jdet=SQRT3/6.0*pow(pow(((y2-y1)*(z3-z1)-(z2-z1)*(y3-y1)),2.0)+pow(((z2-z1)*(x3-x1)-(x2-x1)*(z3-z1)),2.0)+pow(((x2-x1)*(y3-y1)-(y2-y1)*(x3-x1)),2.0),0.5);
         if(*Jdet<0) _error2_("negative jacobian determinant!");
+        if(*Jdet<0) _error_("negative jacobian determinant!");
+}

issm/branches/trunk-jpl-damage/src/c/classes/objects/Inputs/BoolInput.cpp

-              r12832
+              r13101
 /*}}}*/
 /*FUNCTION BoolInput::GetInputValue(int* pvalue){{{*/
 void BoolInput::GetInputValue(int* pvalue){_error2_("not supported yet!");}
+void BoolInput::GetInputValue(int* pvalue){_error_("not supported yet!");}
 /*}}}*/
 /*FUNCTION BoolInput::GetInputValue(IssmDouble* pvalue){{{*/
 void BoolInput::GetInputValue(IssmDouble* pvalue){_error2_("not supported yet!");}
+void BoolInput::GetInputValue(IssmDouble* pvalue){_error_("not supported yet!");}
 /*}}}*/
 /*FUNCTION BoolInput::GetInputValue(IssmDouble* pvalue,GaussTria* gauss){{{*/
 void BoolInput::GetInputValue(IssmDouble* pvalue,GaussTria* gauss){_error2_("not supported yet!");}
+void BoolInput::GetInputValue(IssmDouble* pvalue,GaussTria* gauss){_error_("not supported yet!");}
 /*}}}*/
 /*FUNCTION BoolInput::GetInputValue(IssmDouble* pvalue,GaussPenta* gauss){{{*/
 void BoolInput::GetInputValue(IssmDouble* pvalue,GaussPenta* gauss){_error2_("not supported yet!");}
+void BoolInput::GetInputValue(IssmDouble* pvalue,GaussPenta* gauss){_error_("not supported yet!");}
 /*}}}*/
 /*FUNCTION BoolInput::GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussTria* gauss){{{*/
 void BoolInput::GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussTria* gauss){_error2_("not supported yet!");}
+void BoolInput::GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussTria* gauss){_error_("not supported yet!");}
 /*}}}*/
 /*FUNCTION BoolInput::GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussPenta* gauss){{{*/
 void BoolInput::GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussPenta* gauss){_error2_("not supported yet!");}
+void BoolInput::GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussPenta* gauss){_error_("not supported yet!");}
 /*}}}*/
 /*FUNCTION BoolInput::ChangeEnum{{{*/
 …
                 default:
                         _error2_("not implemented yet");
+                        _error_("not implemented yet");
+        }
 …
 void BoolInput::GetVectorFromInputs(Vector* vector,int* doflist){
         _error2_("not supporte yet!");
+        _error_("not supporte yet!");
+}
 …
 void BoolInput::GetValuesPtr(IssmDouble** pvalues,int* pnum_values){
         _error2_("not supported yet!");
+        _error_("not supported yet!");
+}

issm/branches/trunk-jpl-damage/src/c/classes/objects/Inputs/BoolInput.h

-              r12832
+              r13101
                 int   InstanceEnum();
                 Input* SpawnTriaInput(int* indices);
                 Input* PointwiseDivide(Input* inputB){_error2_("not implemented yet");};
                 Input* PointwiseMin(Input* inputB){_error2_("not implemented yet");};
                 Input* PointwiseMax(Input* inputB){_error2_("not implemented yet");};
+                Input* PointwiseDivide(Input* inputB){_error_("not implemented yet");};
+                Input* PointwiseMin(Input* inputB){_error_("not implemented yet");};
+                Input* PointwiseMax(Input* inputB){_error_("not implemented yet");};
                 ElementResult* SpawnResult(int step, IssmDouble time);
                 void Configure(Parameters* parameters);
                 void AddTimeValues(IssmDouble* values,int step,IssmDouble time){_error2_("not supported yet");};
+                void AddTimeValues(IssmDouble* values,int step,IssmDouble time){_error_("not supported yet");};
                 /*}}}*/
                 /*numerics: {{{*/
 …
                 void GetInputValue(IssmDouble* pvalue,GaussTria* gauss);
                 void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss);
                 void GetInputValue(IssmDouble* pvalue,GaussTria* gauss,IssmDouble time){_error2_("not implemented yet");};
                 void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss,IssmDouble time){_error2_("not implemented yet");};
                 void GetInputValue(IssmDouble* pvalue,GaussTria* gauss ,int index){_error2_("not implemented yet");};
                 void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss ,int index){_error2_("not implemented yet");};
+                void GetInputValue(IssmDouble* pvalue,GaussTria* gauss,IssmDouble time){_error_("not implemented yet");};
+                void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss,IssmDouble time){_error_("not implemented yet");};
+                void GetInputValue(IssmDouble* pvalue,GaussTria* gauss ,int index){_error_("not implemented yet");};
+                void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss ,int index){_error_("not implemented yet");};
                 void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussTria* gauss);
                 void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussPenta* gauss);
                 void GetInputAverage(IssmDouble* pvalue){_error2_("not implemented yet");};
                 void GetVxStrainRate2d(IssmDouble* epsilonvx,IssmDouble* xyz_list, GaussTria* gauss){_error2_("not implemented yet");};
                 void GetVyStrainRate2d(IssmDouble* epsilonvy,IssmDouble* xyz_list, GaussTria* gauss){_error2_("not implemented yet");};
                 void GetVxStrainRate3d(IssmDouble* epsilonvx,IssmDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
                 void GetVyStrainRate3d(IssmDouble* epsilonvy,IssmDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
                 void GetVzStrainRate3d(IssmDouble* epsilonvz,IssmDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
                 void GetVxStrainRate3dPattyn(IssmDouble* epsilonvx,IssmDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
                 void GetVyStrainRate3dPattyn(IssmDouble* epsilonvy,IssmDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
+                void GetInputAverage(IssmDouble* pvalue){_error_("not implemented yet");};
+                void GetVxStrainRate2d(IssmDouble* epsilonvx,IssmDouble* xyz_list, GaussTria* gauss){_error_("not implemented yet");};
+                void GetVyStrainRate2d(IssmDouble* epsilonvy,IssmDouble* xyz_list, GaussTria* gauss){_error_("not implemented yet");};
+                void GetVxStrainRate3d(IssmDouble* epsilonvx,IssmDouble* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
+                void GetVyStrainRate3d(IssmDouble* epsilonvy,IssmDouble* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
+                void GetVzStrainRate3d(IssmDouble* epsilonvz,IssmDouble* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
+                void GetVxStrainRate3dPattyn(IssmDouble* epsilonvx,IssmDouble* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
+                void GetVyStrainRate3dPattyn(IssmDouble* epsilonvy,IssmDouble* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
                 void ChangeEnum(int newenumtype);
                 void SquareMin(IssmDouble* psquaremin, bool process_units,Parameters* parameters);
                 void ConstrainMin(IssmDouble minimum){_error2_("not implemented yet");};
                 IssmDouble InfinityNorm(void){_error2_("InfinityNorm not implemented for booleans");};
                 IssmDouble Max(void){_error2_("Max not implemented for booleans");};
                 IssmDouble MaxAbs(void){_error2_("Max not implemented for booleans");};
                 IssmDouble Min(void){_error2_("Min not implemented for booleans");};
                 IssmDouble MinAbs(void){_error2_("Min not implemented for booleans");};
+                void ConstrainMin(IssmDouble minimum){_error_("not implemented yet");};
+                IssmDouble InfinityNorm(void){_error_("InfinityNorm not implemented for booleans");};
+                IssmDouble Max(void){_error_("Max not implemented for booleans");};
+                IssmDouble MaxAbs(void){_error_("Max not implemented for booleans");};
+                IssmDouble Min(void){_error_("Min not implemented for booleans");};
+                IssmDouble MinAbs(void){_error_("Min not implemented for booleans");};
                 void Scale(IssmDouble scale_factor);
                 void ArtificialNoise(IssmDouble min,IssmDouble max){_error2_("not implemented yet");};
+                void ArtificialNoise(IssmDouble min,IssmDouble max){_error_("not implemented yet");};
                 void AXPY(Input* xinput,IssmDouble scalar);
                 void Constrain(IssmDouble cm_min, IssmDouble cm_max){_error2_("Constrain not implemented for booleans");};
+                void Constrain(IssmDouble cm_min, IssmDouble cm_max){_error_("Constrain not implemented for booleans");};
                 void Extrude(void);
                 void VerticallyIntegrate(Input* thickness_input){_error2_("not supported yet");};
+                void VerticallyIntegrate(Input* thickness_input){_error_("not supported yet");};
                 void GetVectorFromInputs(Vector* vector,int* doflist);
                 void GetValuesPtr(IssmDouble** pvalues,int* pnum_values);

issm/branches/trunk-jpl-damage/src/c/classes/objects/Inputs/ControlInput.cpp

-              r12832
+              r13101
                         break;
                 default:
                         _error2_("Input of Enum " << EnumToStringx(enum_input) << " not supported yet by ControlInput");
+                        _error_("Input of Enum " << EnumToStringx(enum_input) << " not supported yet by ControlInput");
+        }
         gradient   =NULL;
 …
 /*FUNCTION ControlInput::ScaleGradient{{{*/
 void ControlInput::ScaleGradient(IssmDouble scaling_factor){
         if(!gradient) _error2_("Gradient of ControlInput " << EnumToStringx(enum_type) << " not found");
+        if(!gradient) _error_("Gradient of ControlInput " << EnumToStringx(enum_type) << " not found");
         gradient->Scale(scaling_factor);
 }/*}}}*/
 …
                         break;
                 default:
                         _error2_("more than 3 controls not implemented yet (Gradient " << this->control_id << " was requested). EnumDefinitions.h needs to be updated.");
+                        _error_("more than 3 controls not implemented yet (Gradient " << this->control_id << " was requested). EnumDefinitions.h needs to be updated.");
+        }
 …
+         }
          else{
                  _error2_("Data " << data << " not supported yet");
+                 _error_("Data " << data << " not supported yet");
+         }
 }/*}}}*/
 …
 /*FUNCTION ControlInput::SaveValue{{{*/
 void ControlInput::SaveValue(void){
         if(!values) _error2_("Values of " << EnumToStringx(this->enum_type) << " not found");
+        if(!values) _error_("Values of " << EnumToStringx(this->enum_type) << " not found");
         if(savedvalues) delete this->savedvalues;
 …
 /*FUNCTION ControlInput::UpdateValue{{{*/
 void ControlInput::UpdateValue(IssmDouble scalar){
         if(!gradient)    _error2_("Gradient of " << EnumToStringx(this->enum_type) << " not found");
         if(!savedvalues) _error2_("Values of " << EnumToStringx(this->enum_type) << " not found");
+        if(!gradient)    _error_("Gradient of " << EnumToStringx(this->enum_type) << " not found");
+        if(!savedvalues) _error_("Values of " << EnumToStringx(this->enum_type) << " not found");
         if(values) delete this->values;

issm/branches/trunk-jpl-damage/src/c/classes/objects/Inputs/ControlInput.h

-              r12832
+              r13101
                 int    InstanceEnum();
                 Input* SpawnTriaInput(int* indices);
                 Input* PointwiseDivide(Input* inputB){_error2_("not implemented yet");};
                 Input* PointwiseMin(Input* inputB){_error2_("not implemented yet");};
                 Input* PointwiseMax(Input* inputB){_error2_("not implemented yet");};
+                Input* PointwiseDivide(Input* inputB){_error_("not implemented yet");};
+                Input* PointwiseMin(Input* inputB){_error_("not implemented yet");};
+                Input* PointwiseMax(Input* inputB){_error_("not implemented yet");};
                 ElementResult* SpawnResult(int step, IssmDouble time);
                 void AddTimeValues(IssmDouble* values,int step,IssmDouble time){_error2_("not supported yet");};
+                void AddTimeValues(IssmDouble* values,int step,IssmDouble time){_error_("not supported yet");};
                 void Configure(Parameters* parameters);
                 /*}}}*/
 …
                 void GetInputValue(IssmDouble* pvalue,GaussTria* gauss);
                 void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss);
                 void GetInputValue(IssmDouble* pvalue,GaussTria* gauss,IssmDouble time){_error2_("not implemented yet");};
                 void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss,IssmDouble time){_error2_("not implemented yet");};
                 void GetInputValue(IssmDouble* pvalue,GaussTria* gauss ,int index){_error2_("not implemented yet");};
                 void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss ,int index){_error2_("not implemented yet");};
+                void GetInputValue(IssmDouble* pvalue,GaussTria* gauss,IssmDouble time){_error_("not implemented yet");};
+                void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss,IssmDouble time){_error_("not implemented yet");};
+                void GetInputValue(IssmDouble* pvalue,GaussTria* gauss ,int index){_error_("not implemented yet");};
+                void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss ,int index){_error_("not implemented yet");};
                 void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussTria* gauss);
                 void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussPenta* gauss);
                 void GetInputAverage(IssmDouble* pvalue);
                 void GetVxStrainRate2d(IssmDouble* epsilonvx,IssmDouble* xyz_list, GaussTria* gauss){_error2_("not implemented yet");};
                 void GetVyStrainRate2d(IssmDouble* epsilonvy,IssmDouble* xyz_list, GaussTria* gauss){_error2_("not implemented yet");};
                 void GetVxStrainRate3d(IssmDouble* epsilonvx,IssmDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
                 void GetVyStrainRate3d(IssmDouble* epsilonvy,IssmDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
                 void GetVzStrainRate3d(IssmDouble* epsilonvz,IssmDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
                 void GetVxStrainRate3dPattyn(IssmDouble* epsilonvx,IssmDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
                 void GetVyStrainRate3dPattyn(IssmDouble* epsilonvy,IssmDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
                 void ChangeEnum(int newenumtype){_error2_("not implemented yet");};
                 void SquareMin(IssmDouble* psquaremin, bool process_units,Parameters* parameters){_error2_("not implemented yet");};
                 void ConstrainMin(IssmDouble minimum){_error2_("not implemented yet");};
                 void Scale(IssmDouble scale_factor){_error2_("not implemented yet");};
                 void ArtificialNoise(IssmDouble min,IssmDouble max){_error2_("not implemented yet");};
                 void AXPY(Input* xinput,IssmDouble scalar){_error2_("not implemented yet");};
+                void GetVxStrainRate2d(IssmDouble* epsilonvx,IssmDouble* xyz_list, GaussTria* gauss){_error_("not implemented yet");};
+                void GetVyStrainRate2d(IssmDouble* epsilonvy,IssmDouble* xyz_list, GaussTria* gauss){_error_("not implemented yet");};
+                void GetVxStrainRate3d(IssmDouble* epsilonvx,IssmDouble* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
+                void GetVyStrainRate3d(IssmDouble* epsilonvy,IssmDouble* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
+                void GetVzStrainRate3d(IssmDouble* epsilonvz,IssmDouble* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
+                void GetVxStrainRate3dPattyn(IssmDouble* epsilonvx,IssmDouble* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
+                void GetVyStrainRate3dPattyn(IssmDouble* epsilonvy,IssmDouble* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
+                void ChangeEnum(int newenumtype){_error_("not implemented yet");};
+                void SquareMin(IssmDouble* psquaremin, bool process_units,Parameters* parameters){_error_("not implemented yet");};
+                void ConstrainMin(IssmDouble minimum){_error_("not implemented yet");};
+                void Scale(IssmDouble scale_factor){_error_("not implemented yet");};
+                void ArtificialNoise(IssmDouble min,IssmDouble max){_error_("not implemented yet");};
+                void AXPY(Input* xinput,IssmDouble scalar){_error_("not implemented yet");};
                 void Constrain(void);
                 void Constrain(IssmDouble min,IssmDouble max);
                 IssmDouble InfinityNorm(void){_error2_("not implemented yet");};
                 IssmDouble Max(void){_error2_("not implemented yet");};
                 IssmDouble MaxAbs(void){_error2_("not implemented yet");};
                 IssmDouble Min(void){_error2_("not implemented yet");};
                 IssmDouble MinAbs(void){_error2_("not implemented yet");};
+                IssmDouble InfinityNorm(void){_error_("not implemented yet");};
+                IssmDouble Max(void){_error_("not implemented yet");};
+                IssmDouble MaxAbs(void){_error_("not implemented yet");};
+                IssmDouble Min(void){_error_("not implemented yet");};
+                IssmDouble MinAbs(void){_error_("not implemented yet");};
                 void Extrude(void);
                 void VerticallyIntegrate(Input* thickness_input);
                 void GetVectorFromInputs(Vector* vector,int* doflist,const char* data);
                 void GetVectorFromInputs(Vector* vector,int* doflist);
                 void GetValuesPtr(IssmDouble** pvalues,int* pnum_values){_error2_("not implemented yet");};
+                void GetValuesPtr(IssmDouble** pvalues,int* pnum_values){_error_("not implemented yet");};
                 ElementResult* SpawnGradient(int step, IssmDouble time);
                 void GetGradient(Vector* gradient_vec,int* doflist);

issm/branches/trunk-jpl-damage/src/c/classes/objects/Inputs/DatasetInput.cpp

r12832	r13101
115	115
116	116	/Get requested input within dataset/
117		if(index<0 \|\| index > inputs->Size()-1) _error2_("index requested (" << index << ") exceeds dataset size (" << inputs->Size() << ")");
	117	if(index<0 \|\| index > inputs->Size()-1) _error_("index requested (" << index << ") exceeds dataset size (" << inputs->Size() << ")");
118	118	Input* input=(Input*)this->inputs->GetObjectByOffset(index);
119	119

issm/branches/trunk-jpl-damage/src/c/classes/objects/Inputs/DatasetInput.h

-              r12832
+              r13101
                 int    InstanceEnum();
                 Input* SpawnTriaInput(int* indices);
                 Input* PointwiseDivide(Input* inputB){_error2_("not implemented yet");};
                 Input* PointwiseMin(Input* inputB){_error2_("not implemented yet");};
                 Input* PointwiseMax(Input* inputB){_error2_("not implemented yet");};
                 ElementResult* SpawnResult(int step, IssmDouble time){_error2_("not implemented yet");};
                 void AddTimeValues(IssmDouble* values,int step,IssmDouble time){_error2_("not supported yet");};
+                Input* PointwiseDivide(Input* inputB){_error_("not implemented yet");};
+                Input* PointwiseMin(Input* inputB){_error_("not implemented yet");};
+                Input* PointwiseMax(Input* inputB){_error_("not implemented yet");};
+                ElementResult* SpawnResult(int step, IssmDouble time){_error_("not implemented yet");};
+                void AddTimeValues(IssmDouble* values,int step,IssmDouble time){_error_("not supported yet");};
                 void Configure(Parameters* parameters);
                 /*}}}*/
                 /*numerics: {{{*/
                 void GetInputValue(bool* pvalue){_error2_("not implemented yet");};
                 void GetInputValue(int* pvalue){_error2_("not implemented yet");};
                 void GetInputValue(IssmDouble* pvalue){_error2_("not implemented yet");};
                 void GetInputValue(IssmDouble* pvalue,GaussTria* gauss){_error2_("not implemented yet");};
                 void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss){_error2_("not implemented yet");};
                 void GetInputValue(IssmDouble* pvalue,GaussTria* gauss,IssmDouble time){_error2_("not implemented yet");};
                 void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss,IssmDouble time){_error2_("not implemented yet");};
+                void GetInputValue(bool* pvalue){_error_("not implemented yet");};
+                void GetInputValue(int* pvalue){_error_("not implemented yet");};
+                void GetInputValue(IssmDouble* pvalue){_error_("not implemented yet");};
+                void GetInputValue(IssmDouble* pvalue,GaussTria* gauss){_error_("not implemented yet");};
+                void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss){_error_("not implemented yet");};
+                void GetInputValue(IssmDouble* pvalue,GaussTria* gauss,IssmDouble time){_error_("not implemented yet");};
+                void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss,IssmDouble time){_error_("not implemented yet");};
                 void GetInputValue(IssmDouble* pvalue,GaussTria* gauss ,int index);
                 void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss ,int index){_error2_("not implemented yet");};
                 void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussTria* gauss){_error2_("not implemented yet");};
                 void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
                 void GetInputAverage(IssmDouble* pvalue){_error2_("not implemented yet");};
                 void GetVxStrainRate2d(IssmDouble* epsilonvx,IssmDouble* xyz_list, GaussTria* gauss){_error2_("not implemented yet");};
                 void GetVyStrainRate2d(IssmDouble* epsilonvy,IssmDouble* xyz_list, GaussTria* gauss){_error2_("not implemented yet");};
                 void GetVxStrainRate3d(IssmDouble* epsilonvx,IssmDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
                 void GetVyStrainRate3d(IssmDouble* epsilonvy,IssmDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
                 void GetVzStrainRate3d(IssmDouble* epsilonvz,IssmDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
                 void GetVxStrainRate3dPattyn(IssmDouble* epsilonvx,IssmDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
                 void GetVyStrainRate3dPattyn(IssmDouble* epsilonvy,IssmDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
                 void ChangeEnum(int newenumtype){_error2_("not implemented yet");};
                 void SquareMin(IssmDouble* psquaremin, bool process_units,Parameters* parameters){_error2_("not implemented yet");};
                 void ConstrainMin(IssmDouble minimum){_error2_("not implemented yet");};
                 void Scale(IssmDouble scale_factor){_error2_("not implemented yet");};
                 void ArtificialNoise(IssmDouble min,IssmDouble max){_error2_("not implemented yet");};
                 void AXPY(Input* xinput,IssmDouble scalar){_error2_("not implemented yet");};
                 void Constrain(void){_error2_("not implemented yet");};
                 void Constrain(IssmDouble min,IssmDouble max){_error2_("not implemented yet");};
                 IssmDouble InfinityNorm(void){_error2_("not implemented yet");};
                 IssmDouble Max(void){_error2_("not implemented yet");};
                 IssmDouble MaxAbs(void){_error2_("not implemented yet");};
                 IssmDouble Min(void){_error2_("not implemented yet");};
                 IssmDouble MinAbs(void){_error2_("not implemented yet");};
                 void Extrude(void){_error2_("not implemented yet");};
                 void VerticallyIntegrate(Input* thickness_input){_error2_("not implemented yet");};
                 void GetVectorFromInputs(Vector* vector,int* doflist){_error2_("not implemented yet");};
                 void GetValuesPtr(IssmDouble** pvalues,int* pnum_values){_error2_("not implemented yet");};
                 ElementResult* SpawnGradient(int step, IssmDouble time){_error2_("not implemented yet");};
                 void GetGradient(Vector* gradient_vec,int* doflist){_error2_("not implemented yet");};
                 void ScaleGradient(IssmDouble scale){_error2_("not implemented yet");};
                 void SetGradient(Input* gradient_in){_error2_("not implemented yet");};
                 void UpdateValue(IssmDouble scalar){_error2_("not implemented yet");};
                 void SaveValue(void){_error2_("not implemented yet");};
+                void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss ,int index){_error_("not implemented yet");};
+                void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussTria* gauss){_error_("not implemented yet");};
+                void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
+                void GetInputAverage(IssmDouble* pvalue){_error_("not implemented yet");};
+                void GetVxStrainRate2d(IssmDouble* epsilonvx,IssmDouble* xyz_list, GaussTria* gauss){_error_("not implemented yet");};
+                void GetVyStrainRate2d(IssmDouble* epsilonvy,IssmDouble* xyz_list, GaussTria* gauss){_error_("not implemented yet");};
+                void GetVxStrainRate3d(IssmDouble* epsilonvx,IssmDouble* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
+                void GetVyStrainRate3d(IssmDouble* epsilonvy,IssmDouble* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
+                void GetVzStrainRate3d(IssmDouble* epsilonvz,IssmDouble* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
+                void GetVxStrainRate3dPattyn(IssmDouble* epsilonvx,IssmDouble* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
+                void GetVyStrainRate3dPattyn(IssmDouble* epsilonvy,IssmDouble* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
+                void ChangeEnum(int newenumtype){_error_("not implemented yet");};
+                void SquareMin(IssmDouble* psquaremin, bool process_units,Parameters* parameters){_error_("not implemented yet");};
+                void ConstrainMin(IssmDouble minimum){_error_("not implemented yet");};
+                void Scale(IssmDouble scale_factor){_error_("not implemented yet");};
+                void ArtificialNoise(IssmDouble min,IssmDouble max){_error_("not implemented yet");};
+                void AXPY(Input* xinput,IssmDouble scalar){_error_("not implemented yet");};
+                void Constrain(void){_error_("not implemented yet");};
+                void Constrain(IssmDouble min,IssmDouble max){_error_("not implemented yet");};
+                IssmDouble InfinityNorm(void){_error_("not implemented yet");};
+                IssmDouble Max(void){_error_("not implemented yet");};
+                IssmDouble MaxAbs(void){_error_("not implemented yet");};
+                IssmDouble Min(void){_error_("not implemented yet");};
+                IssmDouble MinAbs(void){_error_("not implemented yet");};
+                void Extrude(void){_error_("not implemented yet");};
+                void VerticallyIntegrate(Input* thickness_input){_error_("not implemented yet");};
+                void GetVectorFromInputs(Vector* vector,int* doflist){_error_("not implemented yet");};
+                void GetValuesPtr(IssmDouble** pvalues,int* pnum_values){_error_("not implemented yet");};
+                ElementResult* SpawnGradient(int step, IssmDouble time){_error_("not implemented yet");};
+                void GetGradient(Vector* gradient_vec,int* doflist){_error_("not implemented yet");};
+                void ScaleGradient(IssmDouble scale){_error_("not implemented yet");};
+                void SetGradient(Input* gradient_in){_error_("not implemented yet");};
+                void UpdateValue(IssmDouble scalar){_error_("not implemented yet");};
+                void SaveValue(void){_error_("not implemented yet");};
                 /*}}}*/

issm/branches/trunk-jpl-damage/src/c/classes/objects/Inputs/DoubleInput.cpp

-              r12832
+              r13101
 /*FUNCTION DoubleInput::GetInputValue(bool* pvalue) {{{*/
 void DoubleInput::GetInputValue(bool* pvalue){
         _error2_("Double input of enum " << EnumToStringx(enum_type) << " cannot return a boolean");
+        _error_("Double input of enum " << EnumToStringx(enum_type) << " cannot return a boolean");
+}
 …
 /*FUNCTION DoubleInput::GetInputValue(int* pvalue){{{*/
 void DoubleInput::GetInputValue(int* pvalue){
         _error2_("Double input of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot return an integer");
+        _error_("Double input of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot return an integer");
+}
 …
 /*}}}*/
 /*FUNCTION DoubleInput::GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussTria* gauss){{{*/
 void DoubleInput::GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussTria* gauss){_error2_("not supported yet!");}
+void DoubleInput::GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussTria* gauss){_error_("not supported yet!");}
 /*}}}*/
 /*FUNCTION DoubleInput::GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussPenta* gauss){{{*/
 void DoubleInput::GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussPenta* gauss){_error2_("not supported yet!");}
+void DoubleInput::GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussPenta* gauss){_error_("not supported yet!");}
 /*}}}*/
 /*FUNCTION DoubleInput::GetVxStrainRate2d(IssmDouble* epsilonvx,IssmDouble* xyz_list, GaussTria* gauss){{{*/
 …
                 default:
                         _error2_("not implemented yet");
+                        _error_("not implemented yet");
+        }
 …
 void DoubleInput::GetVectorFromInputs(Vector* vector,int* doflist){
         _error2_("not supporte yet!");
+        _error_("not supporte yet!");
+}
 …
 void DoubleInput::GetValuesPtr(IssmDouble** pvalues,int* pnum_values){
         _error2_("not supported yet!");
+        _error_("not supported yet!");
+}
 …
         /*Check that input provided is a thickness*/
         if (thickness_input->InstanceEnum()!=ThicknessEnum) _error2_("Input provided is not a Thickness (enum_type is " << EnumToStringx(thickness_input->InstanceEnum()) << ")");
+        if (thickness_input->InstanceEnum()!=ThicknessEnum) _error_("Input provided is not a Thickness (enum_type is " << EnumToStringx(thickness_input->InstanceEnum()) << ")");
         /*vertically integrate depending on type:*/
 …
                 default:
                         _error2_("not implemented yet");
+                        _error_("not implemented yet");
+        }
+}

issm/branches/trunk-jpl-damage/src/c/classes/objects/Inputs/DoubleInput.h

-              r12832
+              r13101
                 Input* PointwiseMax(Input* inputB);
                 ElementResult* SpawnResult(int step, IssmDouble time);
                 void AddTimeValues(IssmDouble* values,int step,IssmDouble time){_error2_("not supported yet");};
+                void AddTimeValues(IssmDouble* values,int step,IssmDouble time){_error_("not supported yet");};
                 void Configure(Parameters* parameters);
                 /*}}}*/
 …
                 void GetInputValue(IssmDouble* pvalue,GaussTria* gauss);
                 void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss);
                 void GetInputValue(IssmDouble* pvalue,GaussTria* gauss,IssmDouble time){_error2_("not implemented yet");};
                 void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss,IssmDouble time){_error2_("not implemented yet");};
                 void GetInputValue(IssmDouble* pvalue,GaussTria* gauss ,int index){_error2_("not implemented yet");};
                 void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss ,int index){_error2_("not implemented yet");};
+                void GetInputValue(IssmDouble* pvalue,GaussTria* gauss,IssmDouble time){_error_("not implemented yet");};
+                void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss,IssmDouble time){_error_("not implemented yet");};
+                void GetInputValue(IssmDouble* pvalue,GaussTria* gauss ,int index){_error_("not implemented yet");};
+                void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss ,int index){_error_("not implemented yet");};
                 void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussTria* gauss);
                 void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussPenta* gauss);
 …
                 void ConstrainMin(IssmDouble minimum);
                 void Scale(IssmDouble scale_factor);
                 void ArtificialNoise(IssmDouble min,IssmDouble max){_error2_("not implemented yet");};
+                void ArtificialNoise(IssmDouble min,IssmDouble max){_error_("not implemented yet");};
                 void AXPY(Input* xinput,IssmDouble scalar);
                 void Constrain(IssmDouble cm_min, IssmDouble cm_max);
                 IssmDouble InfinityNorm(void){_error2_("not implemented yet");};
+                IssmDouble InfinityNorm(void){_error_("not implemented yet");};
                 IssmDouble Max(void);
                 IssmDouble MaxAbs(void);
                 IssmDouble Min(void);
                 IssmDouble MinAbs(void);
                 void Extrude(void){_error2_("not supported yet");};
+                void Extrude(void){_error_("not supported yet");};
                 void VerticallyIntegrate(Input* thickness_input);
                 void GetVectorFromInputs(Vector* vector,int* doflist);

issm/branches/trunk-jpl-damage/src/c/classes/objects/Inputs/IntInput.cpp

-              r12832
+              r13101
 ElementResult* IntInput::SpawnResult(int step, IssmDouble time){
         _error2_("not supported yet!");
+        _error_("not supported yet!");
+}
 …
 /*Object functions*/
 /*FUNCTION IntInput::GetInputValue(bool* pvalue) {{{*/
 void IntInput::GetInputValue(bool* pvalue){_error2_("not supported yet!");}
+void IntInput::GetInputValue(bool* pvalue){_error_("not supported yet!");}
 /*}}}*/
 /*FUNCTION IntInput::GetInputValue(int* pvalue){{{*/
 …
 /*FUNCTION IntInput::GetInputValue(IssmDouble* pvalue){{{*/
 void IntInput::GetInputValue(IssmDouble* pvalue){
         _error2_("IntInput cannot return a IssmDouble in parallel");
+        _error_("IntInput cannot return a IssmDouble in parallel");
+}
 /*}}}*/
 /*FUNCTION IntInput::GetInputValue(IssmDouble* pvalue,GaussTria* gauss){{{*/
 void IntInput::GetInputValue(IssmDouble* pvalue,GaussTria* gauss){_error2_("not supported yet!");}
+void IntInput::GetInputValue(IssmDouble* pvalue,GaussTria* gauss){_error_("not supported yet!");}
 /*}}}*/
 /*FUNCTION IntInput::GetInputValue(IssmDouble* pvalue,GaussPenta* gauss){{{*/
 void IntInput::GetInputValue(IssmDouble* pvalue,GaussPenta* gauss){_error2_("not supported yet!");}
+void IntInput::GetInputValue(IssmDouble* pvalue,GaussPenta* gauss){_error_("not supported yet!");}
 /*}}}*/
 /*FUNCTION IntInput::GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussTria* gauss){{{*/
 void IntInput::GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussTria* gauss){_error2_("not supported yet!");}
+void IntInput::GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussTria* gauss){_error_("not supported yet!");}
 /*}}}*/
 /*FUNCTION IntInput::GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussPenta* gauss){{{*/
 void IntInput::GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussPenta* gauss){_error2_("not supported yet!");}
+void IntInput::GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussPenta* gauss){_error_("not supported yet!");}
 /*}}}*/
 /*FUNCTION IntInput::ChangeEnum{{{*/
 …
                 default:
                         _error2_("not implemented yet");
+                        _error_("not implemented yet");
+        }
 …
 void IntInput::GetVectorFromInputs(Vector* vector,int* doflist){
         _error2_("not supporte yet!");
+        _error_("not supporte yet!");
+}
 …
 void IntInput::GetValuesPtr(IssmDouble** pvalues,int* pnum_values){
         _error2_("not supported yet!");
+        _error_("not supported yet!");
+}

issm/branches/trunk-jpl-damage/src/c/classes/objects/Inputs/IntInput.h

-              r12832
+              r13101
                 int   InstanceEnum();
                 Input* SpawnTriaInput(int* indices);
                 Input* PointwiseDivide(Input* inputB){_error2_("not implemented yet");};
                 Input* PointwiseMin(Input* inputB){_error2_("not implemented yet");};
                 Input* PointwiseMax(Input* inputB){_error2_("not implemented yet");};
+                Input* PointwiseDivide(Input* inputB){_error_("not implemented yet");};
+                Input* PointwiseMin(Input* inputB){_error_("not implemented yet");};
+                Input* PointwiseMax(Input* inputB){_error_("not implemented yet");};
                 ElementResult* SpawnResult(int step, IssmDouble time);
                 void AddTimeValues(IssmDouble* values,int step,IssmDouble time){_error2_("not supported yet");};
+                void AddTimeValues(IssmDouble* values,int step,IssmDouble time){_error_("not supported yet");};
                 void Configure(Parameters* parameters);
                 /*}}}*/
 …
                 void GetInputValue(IssmDouble* pvalue,GaussTria* gauss);
                 void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss);
                 void GetInputValue(IssmDouble* pvalue,GaussTria* gauss,IssmDouble time){_error2_("not implemented yet");};
                 void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss,IssmDouble time){_error2_("not implemented yet");};
                 void GetInputValue(IssmDouble* pvalue,GaussTria* gauss ,int index){_error2_("not implemented yet");};
                 void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss ,int index){_error2_("not implemented yet");};
+                void GetInputValue(IssmDouble* pvalue,GaussTria* gauss,IssmDouble time){_error_("not implemented yet");};
+                void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss,IssmDouble time){_error_("not implemented yet");};
+                void GetInputValue(IssmDouble* pvalue,GaussTria* gauss ,int index){_error_("not implemented yet");};
+                void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss ,int index){_error_("not implemented yet");};
                 void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussTria* gauss);
                 void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussPenta* gauss);
                 void GetInputAverage(IssmDouble* pvalue){_error2_("not implemented yet");};
                 void GetVxStrainRate2d(IssmDouble* epsilonvx,IssmDouble* xyz_list, GaussTria* gauss){_error2_("not implemented yet");};
                 void GetVyStrainRate2d(IssmDouble* epsilonvy,IssmDouble* xyz_list, GaussTria* gauss){_error2_("not implemented yet");};
                 void GetVxStrainRate3d(IssmDouble* epsilonvx,IssmDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
                 void GetVyStrainRate3d(IssmDouble* epsilonvy,IssmDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
                 void GetVzStrainRate3d(IssmDouble* epsilonvz,IssmDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
                 void GetVxStrainRate3dPattyn(IssmDouble* epsilonvx,IssmDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
                 void GetVyStrainRate3dPattyn(IssmDouble* epsilonvy,IssmDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
+                void GetInputAverage(IssmDouble* pvalue){_error_("not implemented yet");};
+                void GetVxStrainRate2d(IssmDouble* epsilonvx,IssmDouble* xyz_list, GaussTria* gauss){_error_("not implemented yet");};
+                void GetVyStrainRate2d(IssmDouble* epsilonvy,IssmDouble* xyz_list, GaussTria* gauss){_error_("not implemented yet");};
+                void GetVxStrainRate3d(IssmDouble* epsilonvx,IssmDouble* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
+                void GetVyStrainRate3d(IssmDouble* epsilonvy,IssmDouble* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
+                void GetVzStrainRate3d(IssmDouble* epsilonvz,IssmDouble* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
+                void GetVxStrainRate3dPattyn(IssmDouble* epsilonvx,IssmDouble* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
+                void GetVyStrainRate3dPattyn(IssmDouble* epsilonvy,IssmDouble* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
                 void ChangeEnum(int newenumtype);
                 void SquareMin(IssmDouble* psquaremin, bool process_units,Parameters* parameters);
                 void ConstrainMin(IssmDouble minimum){_error2_("not implemented yet");};
+                void ConstrainMin(IssmDouble minimum){_error_("not implemented yet");};
                 void Scale(IssmDouble scale_factor);
                 void ArtificialNoise(IssmDouble min,IssmDouble max){_error2_("not implemented yet");};
+                void ArtificialNoise(IssmDouble min,IssmDouble max){_error_("not implemented yet");};
                 void AXPY(Input* xinput,IssmDouble scalar);
                 void Constrain(IssmDouble cm_min, IssmDouble cm_max);
                 IssmDouble InfinityNorm(void){_error2_("InfinityNorm not implemented for integers");};
                 IssmDouble Max(void){_error2_("Max not implemented for integers");};
                 IssmDouble MaxAbs(void){_error2_("Max not implemented for integers");};
                 IssmDouble Min(void){_error2_("Min not implemented for integers");};
                 IssmDouble MinAbs(void){_error2_("Min not implemented for integers");};
                 void Extrude(void){_error2_("not supported yet");};
                 void VerticallyIntegrate(Input* thickness_input){_error2_("not supported yet");};
+                IssmDouble InfinityNorm(void){_error_("InfinityNorm not implemented for integers");};
+                IssmDouble Max(void){_error_("Max not implemented for integers");};
+                IssmDouble MaxAbs(void){_error_("Max not implemented for integers");};
+                IssmDouble Min(void){_error_("Min not implemented for integers");};
+                IssmDouble MinAbs(void){_error_("Min not implemented for integers");};
+                void Extrude(void){_error_("not supported yet");};
+                void VerticallyIntegrate(Input* thickness_input){_error_("not supported yet");};
                 void GetVectorFromInputs(Vector* vector,int* doflist);
                 void GetValuesPtr(IssmDouble** pvalues,int* pnum_values);

issm/branches/trunk-jpl-damage/src/c/classes/objects/Inputs/PentaP1Input.cpp

-              r12832
+              r13101
                 case ControlInputEnum:{
                         ControlInput* cont_input=(ControlInput*)xinput;
                         if(cont_input->values->ObjectEnum()!=PentaP1InputEnum) _error2_("not supported yet");
+                        if(cont_input->values->ObjectEnum()!=PentaP1InputEnum) _error_("not supported yet");
                         PentaP1Input* cast_input=(PentaP1Input*)cont_input->values;
                         for(i=0;i<numnodes;i++)this->values[i]=this->values[i]+scalar*(cast_input->values[i]);}
                         return;
                 default:
                         _error2_("not implemented yet");
+                        _error_("not implemented yet");
+        }
 …
         /*Check that input provided is a thickness*/
         if (thickness_input->InstanceEnum()!=ThicknessEnum) _error2_("Input provided is not a Thickness (enum_type is " << EnumToStringx(thickness_input->InstanceEnum()) << ")");
+        if (thickness_input->InstanceEnum()!=ThicknessEnum) _error_("Input provided is not a Thickness (enum_type is " << EnumToStringx(thickness_input->InstanceEnum()) << ")");
         /*Get Thickness value pointer*/
 …
                 default:
                         _error2_("not implemented yet");
+                        _error_("not implemented yet");
+        }
+}
 …
         /*Check that inputB is of the same type*/
         if (inputB->ObjectEnum()!=PentaP1InputEnum) _error2_("Operation not permitted because inputB is of type " << EnumToStringx(inputB->ObjectEnum()));
+        if (inputB->ObjectEnum()!=PentaP1InputEnum) _error_("Operation not permitted because inputB is of type " << EnumToStringx(inputB->ObjectEnum()));
         xinputB=(PentaP1Input*)inputB;
 …
         /*Check that inputB is of the same type*/
         if (inputB->ObjectEnum()!=PentaP1InputEnum) _error2_("Operation not permitted because inputB is of type " << EnumToStringx(inputB->ObjectEnum()));
+        if (inputB->ObjectEnum()!=PentaP1InputEnum) _error_("Operation not permitted because inputB is of type " << EnumToStringx(inputB->ObjectEnum()));
         xinputB=(PentaP1Input*)inputB;
 …
         /*Check that inputB is of the same type*/
         if (inputB->ObjectEnum()!=PentaP1InputEnum) _error2_("Operation not permitted because inputB is of type " << EnumToStringx(inputB->ObjectEnum()));
+        if (inputB->ObjectEnum()!=PentaP1InputEnum) _error_("Operation not permitted because inputB is of type " << EnumToStringx(inputB->ObjectEnum()));
         xinputB=(PentaP1Input*)inputB;

issm/branches/trunk-jpl-damage/src/c/classes/objects/Inputs/PentaP1Input.h

-              r12704
+              r13101
                 Input* PointwiseMax(Input* inputB);
                 ElementResult* SpawnResult(int step, IssmDouble time);
                 void AddTimeValues(IssmDouble* values,int step,IssmDouble time){_error2_("not supported yet");};
+                void AddTimeValues(IssmDouble* values,int step,IssmDouble time){_error_("not supported yet");};
                 void Configure(Parameters* parameters);
                 /*}}}*/
                 /*numerics: {{{*/
                 void GetInputValue(bool* pvalue){_error2_("not implemented yet");};
                 void GetInputValue(int* pvalue){_error2_("not implemented yet");};
                 void GetInputValue(IssmDouble* pvalue){_error2_("not implemented yet");};
                 void GetInputValue(IssmDouble* pvalue,GaussTria* gauss){_error2_("not implemented yet");};
+                void GetInputValue(bool* pvalue){_error_("not implemented yet");};
+                void GetInputValue(int* pvalue){_error_("not implemented yet");};
+                void GetInputValue(IssmDouble* pvalue){_error_("not implemented yet");};
+                void GetInputValue(IssmDouble* pvalue,GaussTria* gauss){_error_("not implemented yet");};
                 void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss);
                 void GetInputValue(IssmDouble* pvalue,GaussTria* gauss,IssmDouble time){_error2_("not implemented yet");};
                 void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss,IssmDouble time){_error2_("not implemented yet");};
                 void GetInputValue(IssmDouble* pvalue,GaussTria* gauss ,int index){_error2_("not implemented yet");};
                 void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss ,int index){_error2_("not implemented yet");};
                 void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussTria* gauss){_error2_("not implemented yet");};
+                void GetInputValue(IssmDouble* pvalue,GaussTria* gauss,IssmDouble time){_error_("not implemented yet");};
+                void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss,IssmDouble time){_error_("not implemented yet");};
+                void GetInputValue(IssmDouble* pvalue,GaussTria* gauss ,int index){_error_("not implemented yet");};
+                void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss ,int index){_error_("not implemented yet");};
+                void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussTria* gauss){_error_("not implemented yet");};
                 void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussPenta* gauss);
                 void GetInputAverage(IssmDouble* pvalue);
                 void GetVxStrainRate2d(IssmDouble* epsilonvx,IssmDouble* xyz_list, GaussTria* gauss){_error2_("not implemented yet");};
                 void GetVyStrainRate2d(IssmDouble* epsilonvy,IssmDouble* xyz_list, GaussTria* gauss){_error2_("not implemented yet");};
+                void GetVxStrainRate2d(IssmDouble* epsilonvx,IssmDouble* xyz_list, GaussTria* gauss){_error_("not implemented yet");};
+                void GetVyStrainRate2d(IssmDouble* epsilonvy,IssmDouble* xyz_list, GaussTria* gauss){_error_("not implemented yet");};
                 void GetVxStrainRate3d(IssmDouble* epsilonvx,IssmDouble* xyz_list, GaussPenta* gauss);
                 void GetVyStrainRate3d(IssmDouble* epsilonvy,IssmDouble* xyz_list, GaussPenta* gauss);
 …
                 void ConstrainMin(IssmDouble minimum);
                 void Scale(IssmDouble scale_factor);
                 void ArtificialNoise(IssmDouble min,IssmDouble max){_error2_("not implemented yet");};
+                void ArtificialNoise(IssmDouble min,IssmDouble max){_error_("not implemented yet");};
                 void AXPY(Input* xinput,IssmDouble scalar);
                 void Constrain(IssmDouble cm_min, IssmDouble cm_max);

issm/branches/trunk-jpl-damage/src/c/classes/objects/Inputs/TransientInput.cpp

r12946	r13101
482	482	}
483	483	}
484		if(!found)_error2_("did not find time interval on which to interpolate forcing values!");
	484	if(!found)_error_("did not find time interval on which to interpolate forcing values!");
485	485
486	486	/Assign output pointer/

issm/branches/trunk-jpl-damage/src/c/classes/objects/Inputs/TransientInput.h

-              r12946
+              r13101
                 int    InstanceEnum();
                 Input* SpawnTriaInput(int* indices);
                 Input* PointwiseDivide(Input* forcingB){_error2_("not implemented yet");};
                 Input* PointwiseMin(Input* forcingB){_error2_("not implemented yet");};
                 Input* PointwiseMax(Input* forcingB){_error2_("not implemented yet");};
+                Input* PointwiseDivide(Input* forcingB){_error_("not implemented yet");};
+                Input* PointwiseMin(Input* forcingB){_error_("not implemented yet");};
+                Input* PointwiseMax(Input* forcingB){_error_("not implemented yet");};
                 ElementResult* SpawnResult(int step, IssmDouble time);
                 void Configure(Parameters* parameters);
                 /*}}}*/
                 /*numerics: {{{*/
                 void GetInputValue(bool* pvalue){_error2_("not implemented yet");};
                 void GetInputValue(int* pvalue){_error2_("not implemented yet");};
                 void GetInputValue(IssmDouble* pvalue){_error2_("not implemented yet");};
+                void GetInputValue(bool* pvalue){_error_("not implemented yet");};
+                void GetInputValue(int* pvalue){_error_("not implemented yet");};
+                void GetInputValue(IssmDouble* pvalue){_error_("not implemented yet");};
                 void GetInputValue(IssmDouble* pvalue,GaussTria* gauss);
                 void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss);
                 void GetInputValue(IssmDouble* pvalue,GaussTria* gauss,IssmDouble time);
                 void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss,IssmDouble time);
                 void GetInputValue(IssmDouble* pvalue,GaussTria* gauss ,int index){_error2_("not implemented yet");};
                 void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss ,int index){_error2_("not implemented yet");};
+                void GetInputValue(IssmDouble* pvalue,GaussTria* gauss ,int index){_error_("not implemented yet");};
+                void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss ,int index){_error_("not implemented yet");};
                 void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussTria* gauss);
                 void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
+                void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
                 void GetInputAverage(IssmDouble* pvalue);
                 void GetVxStrainRate2d(IssmDouble* epsilonvx,IssmDouble* xyz_list, GaussTria* gauss){_error2_("not implemented yet");};
                 void GetVyStrainRate2d(IssmDouble* epsilonvy,IssmDouble* xyz_list, GaussTria* gauss){_error2_("not implemented yet");};
                 void GetVxStrainRate3d(IssmDouble* epsilonvx,IssmDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
                 void GetVyStrainRate3d(IssmDouble* epsilonvy,IssmDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
                 void GetVzStrainRate3d(IssmDouble* epsilonvz,IssmDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
                 void GetVxStrainRate3dPattyn(IssmDouble* epsilonvx,IssmDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
                 void GetVyStrainRate3dPattyn(IssmDouble* epsilonvy,IssmDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
+                void GetVxStrainRate2d(IssmDouble* epsilonvx,IssmDouble* xyz_list, GaussTria* gauss){_error_("not implemented yet");};
+                void GetVyStrainRate2d(IssmDouble* epsilonvy,IssmDouble* xyz_list, GaussTria* gauss){_error_("not implemented yet");};
+                void GetVxStrainRate3d(IssmDouble* epsilonvx,IssmDouble* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
+                void GetVyStrainRate3d(IssmDouble* epsilonvy,IssmDouble* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
+                void GetVzStrainRate3d(IssmDouble* epsilonvz,IssmDouble* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
+                void GetVxStrainRate3dPattyn(IssmDouble* epsilonvx,IssmDouble* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
+                void GetVyStrainRate3dPattyn(IssmDouble* epsilonvy,IssmDouble* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
                 void ChangeEnum(int newenumtype);
                 void SquareMin(IssmDouble* psquaremin, bool process_units,Parameters* parameters);
                 void ConstrainMin(IssmDouble minimum){_error2_("not implemented yet");};
                 void Scale(IssmDouble scale_factor){_error2_("not implemented yet");};
                 void ArtificialNoise(IssmDouble min,IssmDouble max){_error2_("not implemented yet");};
                 void AXPY(Input* xforcing,IssmDouble scalar){_error2_("not implemented yet");};
                 void Constrain(IssmDouble cm_min, IssmDouble cm_max){_error2_("not implemented yet");};
+                void ConstrainMin(IssmDouble minimum){_error_("not implemented yet");};
+                void Scale(IssmDouble scale_factor){_error_("not implemented yet");};
+                void ArtificialNoise(IssmDouble min,IssmDouble max){_error_("not implemented yet");};
+                void AXPY(Input* xforcing,IssmDouble scalar){_error_("not implemented yet");};
+                void Constrain(IssmDouble cm_min, IssmDouble cm_max){_error_("not implemented yet");};
                 IssmDouble InfinityNorm(void);
                 IssmDouble Max(void);
 …
                 IssmDouble MinAbs(void);
                 void Extrude(void);
                 void VerticallyIntegrate(Input* thickness_forcing){_error2_("not supported yet");};
+                void VerticallyIntegrate(Input* thickness_forcing){_error_("not supported yet");};
                 void GetVectorFromInputs(Vector* vector,int* doflist);
                 void GetValuesPtr(IssmDouble** pvalues,int* pnum_values){_error2_("not supported yet");};
       void GetTimeValues(IssmDouble* values,IssmDouble time){_error2_("not implemented yet");};
+                void GetValuesPtr(IssmDouble** pvalues,int* pnum_values){_error_("not supported yet");};
+      void GetTimeValues(IssmDouble* values,IssmDouble time){_error_("not implemented yet");};
                 Input* GetTimeInput(IssmDouble time);
                 /*}}}*/

issm/branches/trunk-jpl-damage/src/c/classes/objects/Inputs/TriaP1Input.cpp

-              r12832
+              r13101
                 default :
                         _error2_("not implemented yet");
+                        _error_("not implemented yet");
+        }
 …
         /*Check that inputB is of the same type*/
         if (inputB->ObjectEnum()!=TriaP1InputEnum) _error2_("Operation not permitted because inputB is of type " << EnumToStringx(inputB->ObjectEnum()));
+        if (inputB->ObjectEnum()!=TriaP1InputEnum) _error_("Operation not permitted because inputB is of type " << EnumToStringx(inputB->ObjectEnum()));
         xinputB=(TriaP1Input*)inputB;
 …
         /*Check that inputB is of the same type*/
         if (inputB->ObjectEnum()!=TriaP1InputEnum) _error2_("Operation not permitted because inputB is of type " << EnumToStringx(inputB->ObjectEnum()));
+        if (inputB->ObjectEnum()!=TriaP1InputEnum) _error_("Operation not permitted because inputB is of type " << EnumToStringx(inputB->ObjectEnum()));
         xinputB=(TriaP1Input*)inputB;

issm/branches/trunk-jpl-damage/src/c/classes/objects/Inputs/TriaP1Input.h

-              r12704
+              r13101
                 int   InstanceEnum();
                 Input* SpawnTriaInput(int* indices);
                 Input* PointwiseDivide(Input* inputB){_error2_("not implemented yet");};
+                Input* PointwiseDivide(Input* inputB){_error_("not implemented yet");};
                 Input* PointwiseMin(Input* inputB);
                 Input* PointwiseMax(Input* inputB);
                 ElementResult* SpawnResult(int step, IssmDouble time);
                 void AddTimeValues(IssmDouble* values,int step,IssmDouble time){_error2_("not supported yet");};
+                void AddTimeValues(IssmDouble* values,int step,IssmDouble time){_error_("not supported yet");};
                 void Configure(Parameters* parameters);
                 /*}}}*/
                 /*numerics: {{{*/
                 void GetInputValue(bool* pvalue){_error2_("not implemented yet");}
                 void GetInputValue(int* pvalue){_error2_("not implemented yet");}
                 void GetInputValue(IssmDouble* pvalue){_error2_("not implemented yet");}
+                void GetInputValue(bool* pvalue){_error_("not implemented yet");}
+                void GetInputValue(int* pvalue){_error_("not implemented yet");}
+                void GetInputValue(IssmDouble* pvalue){_error_("not implemented yet");}
                 void GetInputValue(IssmDouble* pvalue,GaussTria* gauss);
                 void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss){_error2_("not implemented yet");};
                 void GetInputValue(IssmDouble* pvalue,GaussTria* gauss,IssmDouble time){_error2_("not implemented yet");};
                 void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss,IssmDouble time){_error2_("not implemented yet");};
                 void GetInputValue(IssmDouble* pvalue,GaussTria* gauss ,int index){_error2_("not implemented yet");};
                 void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss,int index){_error2_("not implemented yet");};
+                void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss){_error_("not implemented yet");};
+                void GetInputValue(IssmDouble* pvalue,GaussTria* gauss,IssmDouble time){_error_("not implemented yet");};
+                void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss,IssmDouble time){_error_("not implemented yet");};
+                void GetInputValue(IssmDouble* pvalue,GaussTria* gauss ,int index){_error_("not implemented yet");};
+                void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss,int index){_error_("not implemented yet");};
                 void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussTria* gauss);
                 void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
+                void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
                 void GetInputAverage(IssmDouble* pvalue);
                 void GetVxStrainRate2d(IssmDouble* epsilonvx,IssmDouble* xyz_list, GaussTria* gauss);
                 void GetVyStrainRate2d(IssmDouble* epsilonvy,IssmDouble* xyz_list, GaussTria* gauss);
                 void GetVxStrainRate3d(IssmDouble* epsilonvx,IssmDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
                 void GetVyStrainRate3d(IssmDouble* epsilonvy,IssmDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
                 void GetVzStrainRate3d(IssmDouble* epsilonvz,IssmDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
                 void GetVxStrainRate3dPattyn(IssmDouble* epsilonvx,IssmDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
                 void GetVyStrainRate3dPattyn(IssmDouble* epsilonvy,IssmDouble* xyz_list, GaussPenta* gauss){_error2_("not implemented yet");};
+                void GetVxStrainRate3d(IssmDouble* epsilonvx,IssmDouble* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
+                void GetVyStrainRate3d(IssmDouble* epsilonvy,IssmDouble* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
+                void GetVzStrainRate3d(IssmDouble* epsilonvz,IssmDouble* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
+                void GetVxStrainRate3dPattyn(IssmDouble* epsilonvx,IssmDouble* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
+                void GetVyStrainRate3dPattyn(IssmDouble* epsilonvy,IssmDouble* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
                 void ChangeEnum(int newenumtype);
 …
                 IssmDouble Min(void);
                 IssmDouble MinAbs(void);
                 void Extrude(void){_error2_("not supported yet");};
                 void VerticallyIntegrate(Input* thickness_input){_error2_("not supported yet");};
+                void Extrude(void){_error_("not supported yet");};
+                void VerticallyIntegrate(Input* thickness_input){_error_("not supported yet");};
                 void GetVectorFromInputs(Vector* vector,int* doflist);
                 void GetValuesPtr(IssmDouble** pvalues,int* pnum_values);

issm/branches/trunk-jpl-damage/src/c/classes/objects/KML/KMLFileReadUtils.cpp

-              r12946
+              r13101
         if (strncmp(&ktag[0],"<"        ,1) || strncmp(&ktag[strlen(ktag)-1],">",1))
                 _error2_("KMLFileTagName -- Missing tag delimiters in " << ktag << ".\n");
+                _error_("KMLFileTagName -- Missing tag delimiters in " << ktag << ".\n");
 /*  strtok modifies ktag, so work on copy  */
 …
                                                         NULL,NULL)) ||
                 (kstr[0] == '<'))
                 _error2_("KMLFileTokenParse -- Missing integer field for " << ktag << ".\n");
+                _error_("KMLFileTokenParse -- Missing integer field for " << ktag << ".\n");
         sscanf(kstr,"%d",pival);
 …
                         (kstr[1] != '/') ||
                         (strncmp(&(kstr[2]),&(ktag[1]),strlen(ktag)-1)))
                   {_error2_("KMLFileTokenParse -- Missing closing tag for " << ktag << ".\n");}
+                  {_error_("KMLFileTokenParse -- Missing closing tag for " << ktag << ".\n");}
                 else
                         xDelete<char>(kstr);
 …
                                                         NULL,NULL)) ||
                 (kstr[0] == '<'))
           {_error2_("KMLFileTokenParse -- Missing bool field for " << ktag << ".\n");}
+          {_error_("KMLFileTokenParse -- Missing bool field for " << ktag << ".\n");}
         sscanf(kstr,"%d",&ival);
 …
                         (kstr[1] != '/') ||
                         (strncmp(&(kstr[2]),&(ktag[1]),strlen(ktag)-1)))
                   {_error2_("KMLFileTokenParse -- Missing closing tag for " << ktag << ".\n");}
+                  {_error_("KMLFileTokenParse -- Missing closing tag for " << ktag << ".\n");}
                 else
                         xDelete<char>(kstr);
 …
                                                         NULL,NULL)) ||
                 (kstr[0] == '<'))
                 _error2_("KMLFileTokenParse -- Missing string field for " << ktag << ".\n");
+                _error_("KMLFileTokenParse -- Missing string field for " << ktag << ".\n");
         if (!pstr) {
 …
                         (kstr[1] != '/') ||
                         (strncmp(&(kstr[2]),&(ktag[1]),strlen(ktag)-1)))
                   {_error2_("KMLFileTokenParse -- Missing closing tag for " << ktag << ".\n");}
+                  {_error_("KMLFileTokenParse -- Missing closing tag for " << ktag << ".\n");}
                 else
                         xDelete<char>(kstr);
 …
                                                         NULL,NULL)) ||
                 (kstr[0] == '<'))
           {_error2_("KMLFileTokenParse -- Missing integer field for " << ktag << ".\n");}
+          {_error_("KMLFileTokenParse -- Missing integer field for " << ktag << ".\n");}
         sscanf(kstr,"%g",pfval);
 …
                         (kstr[1] != '/') ||
                         (strncmp(&(kstr[2]),&(ktag[1]),strlen(ktag)-1)))
                   {_error2_("KMLFileTokenParse -- Missing closing tag for " << ktag << ".\n");}
+                  {_error_("KMLFileTokenParse -- Missing closing tag for " << ktag << ".\n");}
                 else
                         xDelete<char>(kstr);
 …
                                                         NULL,NULL)) ||
                 (kstr[0] == '<'))
                 _error2_("KMLFileTokenParse -- Missing integer field for " << ktag << ".\n");
+                _error_("KMLFileTokenParse -- Missing integer field for " << ktag << ".\n");
         sscanf(kstr,"%lg",pdval);
 …
                         (kstr[1] != '/') ||
                         (strncmp(&(kstr[2]),&(ktag[1]),strlen(ktag)-1)))
                   {_error2_("KMLFileTokenParse -- Missing closing tag for " << ktag << ".\n");}
+                  {_error_("KMLFileTokenParse -- Missing closing tag for " << ktag << ".\n");}
                 else
                         xDelete<char>(kstr);
 …
                                                         NULL,NULL)) ||
                 (kstr[0] == '<'))
                 _error2_("KMLFileTokenParse -- Missing double [m] field for " << ktag << ".\n");
+                _error_("KMLFileTokenParse -- Missing double [m] field for " << ktag << ".\n");
         if (!*pdval)
 …
                 i++;
                 if (maxlen && (maxlen < i+1))
                         _error2_("KMLFileTokenParse -- Double [m] field too short for " << ktag << ".\n");
+                        _error_("KMLFileTokenParse -- Double [m] field too short for " << ktag << ".\n");
                 sscanf(ktok,"%lg",&((*pdval)[i]));
                 ktok=strtok(NULL,delim);
 …
                         (kstr[1] != '/') ||
                         (strncmp(&(kstr[2]),&(ktag[1]),strlen(ktag)-1)))
                   {_error2_("KMLFileTokenParse -- Missing closing tag for " << ktag << ".\n");}
+                  {_error_("KMLFileTokenParse -- Missing closing tag for " << ktag << ".\n");}
                 else
                         xDelete<char>(kstr);
 …
                                                         NULL,NULL)) ||
                 (kstr[0] == '<'))
                 _error2_("KMLFileTokenParse -- Missing double [m x n] field for " << ktag << ".\n");
+                _error_("KMLFileTokenParse -- Missing double [m x n] field for " << ktag << ".\n");
         if (!*pdval)
 …
                 i++;
                 if (maxlen && (maxlen*n < i+1))
                         _error2_("KMLFileTokenParse -- Double [m x n] field too short for " << ktag << ".\n");
+                        _error_("KMLFileTokenParse -- Double [m x n] field too short for " << ktag << ".\n");
                 j=(j+1) % n;
                 sscanf(ktok,"%lg",&((*pdval)[i]));
 …
                         (kstr[1] != '/') ||
                         (strncmp(&(kstr[2]),&(ktag[1]),strlen(ktag)-1)))
                   {_error2_("KMLFileTokenParse -- Missing closing tag for " << ktag << ".\n");}
+                  {_error_("KMLFileTokenParse -- Missing closing tag for " << ktag << ".\n");}
                 else
                         xDelete<char>(kstr);
 …
                 else if ((kstr[0] == '<') &&
                                  (kstr[1] == '/')) {
                         _error2_("KMLFileTagSkip -- Unexpected closing tag " << kstr << ".\n");
+                        _error_("KMLFileTagSkip -- Unexpected closing tag " << kstr << ".\n");
+                }
 …
+        }
         _error2_("KMLFileTokenParse -- Corresponding closing tag for " << ktag << " not found.\n");
+        _error_("KMLFileTokenParse -- Corresponding closing tag for " << ktag << " not found.\n");
         return(0);

issm/branches/trunk-jpl-damage/src/c/classes/objects/KML/KML_Attribute.h

-              r12832
+              r13101
                 virtual void  DeepEcho();
                 virtual void  DeepEcho(const char* indent);
                 int   Id(){_error2_("Not implemented yet.");};
                 int   MyRank(){_error2_("Not implemented yet.");};
                 void  Marshall(char** pmarshalled_dataset){_error2_("Not implemented yet.");};
                 int   MarshallSize(){_error2_("Not implemented yet.");};
                 void  Demarshall(char** pmarshalled_dataset){_error2_("Not implemented yet.");};
                 int   ObjectEnum(){_error2_("Not implemented yet.");};
                 Object* copy(){_error2_("Not implemented yet.");};
+                int   Id(){_error_("Not implemented yet.");};
+                int   MyRank(){_error_("Not implemented yet.");};
+                void  Marshall(char** pmarshalled_dataset){_error_("Not implemented yet.");};
+                int   MarshallSize(){_error_("Not implemented yet.");};
+                void  Demarshall(char** pmarshalled_dataset){_error_("Not implemented yet.");};
+                int   ObjectEnum(){_error_("Not implemented yet.");};
+                Object* copy(){_error_("Not implemented yet.");};
                 /*}}}*/

issm/branches/trunk-jpl-damage/src/c/classes/objects/KML/KML_ColorStyle.cpp

-              r12835
+              r13101
                 return;
         else if (!strncmp(kstr,"</",2))
           {_error2_("KML_ColorStyle::Read -- Unexpected closing tag " << kstr);}
+          {_error_("KML_ColorStyle::Read -- Unexpected closing tag " << kstr);}
         else if (strncmp(kstr,"<",1))
           {_error2_("KML_ColorStyle::Read -- Unexpected field \"" << kstr << "\"");}
+          {_error_("KML_ColorStyle::Read -- Unexpected field \"" << kstr << "\"");}
         else if (!strcmp(kstr,"<color>"))

issm/branches/trunk-jpl-damage/src/c/classes/objects/KML/KML_ColorStyle.h

-              r12832
+              r13101
                 void  Write(FILE* fid,const char* indent);
                 void  Read(FILE* fid,char* kstr);
                 int   Id(){_error2_("Not implemented yet.");};
                 int   MyRank(){_error2_("Not implemented yet.");};
                 void  Marshall(char** pmarshalled_dataset){_error2_("Not implemented yet.");};
                 int   MarshallSize(){_error2_("Not implemented yet.");};
                 void  Demarshall(char** pmarshalled_dataset){_error2_("Not implemented yet.");};
                 int   ObjectEnum(){_error2_("Not implemented yet.");};
                 Object* copy(){_error2_("Not implemented yet.");};
+                int   Id(){_error_("Not implemented yet.");};
+                int   MyRank(){_error_("Not implemented yet.");};
+                void  Marshall(char** pmarshalled_dataset){_error_("Not implemented yet.");};
+                int   MarshallSize(){_error_("Not implemented yet.");};
+                void  Demarshall(char** pmarshalled_dataset){_error_("Not implemented yet.");};
+                int   ObjectEnum(){_error_("Not implemented yet.");};
+                Object* copy(){_error_("Not implemented yet.");};
                 /*}}}*/

issm/branches/trunk-jpl-damage/src/c/classes/objects/KML/KML_Comment.h

-              r12832
+              r13101
                 virtual void  DeepEcho();
                 virtual void  DeepEcho(const char* indent);
                 int   Id(){_error2_("Not implemented yet.");};
                 int   MyRank(){_error2_("Not implemented yet.");};
                 void  Marshall(char** pmarshalled_dataset){_error2_("Not implemented yet.");};
                 int   MarshallSize(){_error2_("Not implemented yet.");};
                 void  Demarshall(char** pmarshalled_dataset){_error2_("Not implemented yet.");};
                 int   ObjectEnum(){_error2_("Not implemented yet.");};
                 Object* copy(){_error2_("Not implemented yet.");};
+                int   Id(){_error_("Not implemented yet.");};
+                int   MyRank(){_error_("Not implemented yet.");};
+                void  Marshall(char** pmarshalled_dataset){_error_("Not implemented yet.");};
+                int   MarshallSize(){_error_("Not implemented yet.");};
+                void  Demarshall(char** pmarshalled_dataset){_error_("Not implemented yet.");};
+                int   ObjectEnum(){_error_("Not implemented yet.");};
+                Object* copy(){_error_("Not implemented yet.");};
                 /*}}}*/

issm/branches/trunk-jpl-damage/src/c/classes/objects/KML/KML_Container.cpp

-              r12946
+              r13101
+        }
         else if (!strncmp(kstr,"</",2))
           {_error2_("KML_Container::Read -- Unexpected closing tag " << kstr );}
+          {_error_("KML_Container::Read -- Unexpected closing tag " << kstr );}
         else if (strncmp(kstr,"<",1))
           {_error2_("KML_Container::Read -- Unexpected field \"" << kstr << "\"");}
+          {_error_("KML_Container::Read -- Unexpected field \"" << kstr << "\"");}
         else if (!strncmp(kstr,"<Placemark",10)) {

issm/branches/trunk-jpl-damage/src/c/classes/objects/KML/KML_Container.h

-              r12832
+              r13101
                 void  Read(FILE* fid,char* kstr);
                 void  WriteExp(FILE* fid,const char* nstr,int sgn,double cm,double sp);
                 int   Id(){_error2_("Not implemented yet.");};
                 int   MyRank(){_error2_("Not implemented yet.");};
                 void  Marshall(char** pmarshalled_dataset){_error2_("Not implemented yet.");};
                 int   MarshallSize(){_error2_("Not implemented yet.");};
                 void  Demarshall(char** pmarshalled_dataset){_error2_("Not implemented yet.");};
                 int   ObjectEnum(){_error2_("Not implemented yet.");};
                 Object* copy(){_error2_("Not implemented yet.");};
+                int   Id(){_error_("Not implemented yet.");};
+                int   MyRank(){_error_("Not implemented yet.");};
+                void  Marshall(char** pmarshalled_dataset){_error_("Not implemented yet.");};
+                int   MarshallSize(){_error_("Not implemented yet.");};
+                void  Demarshall(char** pmarshalled_dataset){_error_("Not implemented yet.");};
+                int   ObjectEnum(){_error_("Not implemented yet.");};
+                Object* copy(){_error_("Not implemented yet.");};
                 /*}}}*/

issm/branches/trunk-jpl-damage/src/c/classes/objects/KML/KML_Document.cpp

-              r12946
+              r13101
+                }
                 else if (!strncmp(kstri,"</",2))
                   {_error2_("KML_Document::Read -- Unexpected closing tag " << kstri << ".\n");}
+                  {_error_("KML_Document::Read -- Unexpected closing tag " << kstri << ".\n");}
                 else if (strncmp(kstri,"<",1))
                   {_error2_("KML_Document::Read -- Unexpected field \"" << kstri << "\".\n");}
+                  {_error_("KML_Document::Read -- Unexpected field \"" << kstri << "\".\n");}
                 else if (!strncmp(kstri,"<",1))

issm/branches/trunk-jpl-damage/src/c/classes/objects/KML/KML_Document.h

-              r12832
+              r13101
                 void  Write(FILE* fid,const char* indent);
                 void  Read(FILE* fid,char* kstr);
                 int   Id(){_error2_("Not implemented yet.");};
                 int   MyRank(){_error2_("Not implemented yet.");};
                 void  Marshall(char** pmarshalled_dataset){_error2_("Not implemented yet.");};
                 int   MarshallSize(){_error2_("Not implemented yet.");};
                 void  Demarshall(char** pmarshalled_dataset){_error2_("Not implemented yet.");};
                 int   ObjectEnum(){_error2_("Not implemented yet.");};
                 Object* copy(){_error2_("Not implemented yet.");};
+                int   Id(){_error_("Not implemented yet.");};
+                int   MyRank(){_error_("Not implemented yet.");};
+                void  Marshall(char** pmarshalled_dataset){_error_("Not implemented yet.");};
+                int   MarshallSize(){_error_("Not implemented yet.");};
+                void  Demarshall(char** pmarshalled_dataset){_error_("Not implemented yet.");};
+                int   ObjectEnum(){_error_("Not implemented yet.");};
+                Object* copy(){_error_("Not implemented yet.");};
                 /*}}}*/

issm/branches/trunk-jpl-damage/src/c/classes/objects/KML/KML_Feature.cpp

-              r12835
+              r13101
                 return;
         else if (!strncmp(kstr,"</",2))
           {_error2_("KML_Feature::Read -- Unexpected closing tag " << kstr);}
+          {_error_("KML_Feature::Read -- Unexpected closing tag " << kstr);}
         else if (strncmp(kstr,"<",1))
           {_error2_("KML_Feature::Read -- Unexpected field \"" << kstr << "\"");}
+          {_error_("KML_Feature::Read -- Unexpected field \"" << kstr << "\"");}
         else if (!strncmp(kstr,"<Style", 6)) {

issm/branches/trunk-jpl-damage/src/c/classes/objects/KML/KML_Feature.h

-              r12832
+              r13101
                 void  Write(FILE* fid,const char* indent);
                 void  Read(FILE* fid,char* kstr);
                 int   Id(){_error2_("Not implemented yet.");};
                 int   MyRank(){_error2_("Not implemented yet.");};
                 void  Marshall(char** pmarshalled_dataset){_error2_("Not implemented yet.");};
                 int   MarshallSize(){_error2_("Not implemented yet.");};
                 void  Demarshall(char** pmarshalled_dataset){_error2_("Not implemented yet.");};
                 int   ObjectEnum(){_error2_("Not implemented yet.");};
                 Object* copy(){_error2_("Not implemented yet.");};
+                int   Id(){_error_("Not implemented yet.");};
+                int   MyRank(){_error_("Not implemented yet.");};
+                void  Marshall(char** pmarshalled_dataset){_error_("Not implemented yet.");};
+                int   MarshallSize(){_error_("Not implemented yet.");};
+                void  Demarshall(char** pmarshalled_dataset){_error_("Not implemented yet.");};
+                int   ObjectEnum(){_error_("Not implemented yet.");};
+                Object* copy(){_error_("Not implemented yet.");};
                 /*}}}*/

issm/branches/trunk-jpl-damage/src/c/classes/objects/KML/KML_File.cpp

-              r12946
+              r13101
+                }
                 else if (!strncmp(kstri,"</",2))
                   {_error2_("KML_File::Read -- Unexpected closing tag " << kstri << ".");}
+                  {_error_("KML_File::Read -- Unexpected closing tag " << kstri << ".");}
                 else if (strncmp(kstri,"<",1))
                   {_error2_("KML_File::Read -- Unexpected field \"" << kstri << "\"");}
+                  {_error_("KML_File::Read -- Unexpected field \"" << kstri << "\"");}
                 else if (!strncmp(kstri,"<",1))

issm/branches/trunk-jpl-damage/src/c/classes/objects/KML/KML_File.h

-              r12832
+              r13101
                 void  Read(FILE* fid,char* kstr);
                 void  WriteExp(FILE* fid,const char* nstr,int sgn,double cm,double sp);
                 int   Id(){_error2_("Not implemented yet.");};
                 int   MyRank(){_error2_("Not implemented yet.");};
                 void  Marshall(char** pmarshalled_dataset){_error2_("Not implemented yet.");};
                 int   MarshallSize(){_error2_("Not implemented yet.");};
                 void  Demarshall(char** pmarshalled_dataset){_error2_("Not implemented yet.");};
                 int   ObjectEnum(){_error2_("Not implemented yet.");};
                 Object* copy(){_error2_("Not implemented yet.");};
+                int   Id(){_error_("Not implemented yet.");};
+                int   MyRank(){_error_("Not implemented yet.");};
+                void  Marshall(char** pmarshalled_dataset){_error_("Not implemented yet.");};
+                int   MarshallSize(){_error_("Not implemented yet.");};
+                void  Demarshall(char** pmarshalled_dataset){_error_("Not implemented yet.");};
+                int   ObjectEnum(){_error_("Not implemented yet.");};
+                Object* copy(){_error_("Not implemented yet.");};
                 /*}}}*/

issm/branches/trunk-jpl-damage/src/c/classes/objects/KML/KML_Folder.cpp

-              r12946
+              r13101
+                }
                 else if (!strncmp(kstri,"</",2))
                   {_error2_("KML_Folder::Read -- Unexpected closing tag " << kstri << ".\n");}
+                  {_error_("KML_Folder::Read -- Unexpected closing tag " << kstri << ".\n");}
                 else if (strncmp(kstri,"<",1))
                   {_error2_("KML_Folder::Read -- Unexpected field \"" << kstri << "\".\n");}
+                  {_error_("KML_Folder::Read -- Unexpected field \"" << kstri << "\".\n");}
                 else if (!strncmp(kstri,"<",1))

issm/branches/trunk-jpl-damage/src/c/classes/objects/KML/KML_Folder.h

-              r12832
+              r13101
                 void  Write(FILE* fid,const char* indent);
                 void  Read(FILE* fid,char* kstr);
                 int   Id(){_error2_("Not implemented yet.");};
                 int   MyRank(){_error2_("Not implemented yet.");};
                 void  Marshall(char** pmarshalled_dataset){_error2_("Not implemented yet.");};
                 int   MarshallSize(){_error2_("Not implemented yet.");};
                 void  Demarshall(char** pmarshalled_dataset){_error2_("Not implemented yet.");};
                 int   ObjectEnum(){_error2_("Not implemented yet.");};
                 Object* copy(){_error2_("Not implemented yet.");};
+                int   Id(){_error_("Not implemented yet.");};
+                int   MyRank(){_error_("Not implemented yet.");};
+                void  Marshall(char** pmarshalled_dataset){_error_("Not implemented yet.");};
+                int   MarshallSize(){_error_("Not implemented yet.");};
+                void  Demarshall(char** pmarshalled_dataset){_error_("Not implemented yet.");};
+                int   ObjectEnum(){_error_("Not implemented yet.");};
+                Object* copy(){_error_("Not implemented yet.");};
                 /*}}}*/

issm/branches/trunk-jpl-damage/src/c/classes/objects/KML/KML_Geometry.cpp

-              r12835
+              r13101
                 return;
         else if (!strncmp(kstr,"</",2))
           {_error2_("KML_Geometry::Read -- Unexpected closing tag " << kstr << ".\n");}
+          {_error_("KML_Geometry::Read -- Unexpected closing tag " << kstr << ".\n");}
         else if (strncmp(kstr,"<",1))
           {_error2_("KML_Geometry::Read -- Unexpected field \"" << kstr << "\".\n");}
+          {_error_("KML_Geometry::Read -- Unexpected field \"" << kstr << "\".\n");}
         else if (!strncmp(kstr,"<",1))

issm/branches/trunk-jpl-damage/src/c/classes/objects/KML/KML_Geometry.h

-              r12832
+              r13101
                 void  Write(FILE* fid,const char* indent);
                 void  Read(FILE* fid,char* kstr);
                 int   Id(){_error2_("Not implemented yet.");};
                 int   MyRank(){_error2_("Not implemented yet.");};
                 void  Marshall(char** pmarshalled_dataset){_error2_("Not implemented yet.");};
                 int   MarshallSize(){_error2_("Not implemented yet.");};
                 void  Demarshall(char** pmarshalled_dataset){_error2_("Not implemented yet.");};
                 int   ObjectEnum(){_error2_("Not implemented yet.");};
                 Object* copy(){_error2_("Not implemented yet.");};
+                int   Id(){_error_("Not implemented yet.");};
+                int   MyRank(){_error_("Not implemented yet.");};
+                void  Marshall(char** pmarshalled_dataset){_error_("Not implemented yet.");};
+                int   MarshallSize(){_error_("Not implemented yet.");};
+                void  Demarshall(char** pmarshalled_dataset){_error_("Not implemented yet.");};
+                int   ObjectEnum(){_error_("Not implemented yet.");};
+                Object* copy(){_error_("Not implemented yet.");};
                 /*}}}*/

issm/branches/trunk-jpl-damage/src/c/classes/objects/KML/KML_GroundOverlay.cpp

-              r12946
+              r13101
+                }
                 else if (!strncmp(kstri,"</",2))
                   {_error2_("KML_GroundOverlay::Read -- Unexpected closing tag " << kstri << ".\n");}
+                  {_error_("KML_GroundOverlay::Read -- Unexpected closing tag " << kstri << ".\n");}
                 else if (strncmp(kstri,"<",1))
                   {_error2_("KML_GroundOverlay::Read -- Unexpected field \"" << kstri << "\".\n");}
+                  {_error_("KML_GroundOverlay::Read -- Unexpected field \"" << kstri << "\".\n");}
                 else if (!strcmp(kstri,"<altitude>"))

issm/branches/trunk-jpl-damage/src/c/classes/objects/KML/KML_GroundOverlay.h

-              r12832
+              r13101
                 void  Write(FILE* fid,const char* indent);
                 void  Read(FILE* fid,char* kstr);
                 int   Id(){_error2_("Not implemented yet.");};
                 int   MyRank(){_error2_("Not implemented yet.");};
                 void  Marshall(char** pmarshalled_dataset){_error2_("Not implemented yet.");};
                 int   MarshallSize(){_error2_("Not implemented yet.");};
                 void  Demarshall(char** pmarshalled_dataset){_error2_("Not implemented yet.");};
                 int   ObjectEnum(){_error2_("Not implemented yet.");};
                 Object* copy(){_error2_("Not implemented yet.");};
+                int   Id(){_error_("Not implemented yet.");};
+                int   MyRank(){_error_("Not implemented yet.");};
+                void  Marshall(char** pmarshalled_dataset){_error_("Not implemented yet.");};
+                int   MarshallSize(){_error_("Not implemented yet.");};
+                void  Demarshall(char** pmarshalled_dataset){_error_("Not implemented yet.");};
+                int   ObjectEnum(){_error_("Not implemented yet.");};
+                Object* copy(){_error_("Not implemented yet.");};
                 /*}}}*/

issm/branches/trunk-jpl-damage/src/c/classes/objects/KML/KML_Icon.cpp

-              r12946
+              r13101
+                }
                 else if (!strncmp(kstri,"</",2))
                   {_error2_("KML_Icon::Read -- Unexpected closing tag " << kstri << ".\n");}
+                  {_error_("KML_Icon::Read -- Unexpected closing tag " << kstri << ".\n");}
                 else if (strncmp(kstri,"<",1))
                   {_error2_("KML_Icon::Read -- Unexpected field \"" << kstri << "\".\n");}
+                  {_error_("KML_Icon::Read -- Unexpected field \"" << kstri << "\".\n");}
                 else if (!strcmp(kstri,"<href>"))

issm/branches/trunk-jpl-damage/src/c/classes/objects/KML/KML_Icon.h

-              r12832
+              r13101
                 void  Write(FILE* fid,const char* indent);
                 void  Read(FILE* fid,char* kstr);
                 int   Id(){_error2_("Not implemented yet.");};
                 int   MyRank(){_error2_("Not implemented yet.");};
                 void  Marshall(char** pmarshalled_dataset){_error2_("Not implemented yet.");};
                 int   MarshallSize(){_error2_("Not implemented yet.");};
                 void  Demarshall(char** pmarshalled_dataset){_error2_("Not implemented yet.");};
                 int   ObjectEnum(){_error2_("Not implemented yet.");};
                 Object* copy(){_error2_("Not implemented yet.");};
+                int   Id(){_error_("Not implemented yet.");};
+                int   MyRank(){_error_("Not implemented yet.");};
+                void  Marshall(char** pmarshalled_dataset){_error_("Not implemented yet.");};
+                int   MarshallSize(){_error_("Not implemented yet.");};
+                void  Demarshall(char** pmarshalled_dataset){_error_("Not implemented yet.");};
+                int   ObjectEnum(){_error_("Not implemented yet.");};
+                Object* copy(){_error_("Not implemented yet.");};
                 /*}}}*/

issm/branches/trunk-jpl-damage/src/c/classes/objects/KML/KML_LatLonBox.cpp

-              r12946
+              r13101
+                }
                 else if (!strncmp(kstri,"</",2))
                   {_error2_("KML_LatLonBox::Read -- Unexpected closing tag " << kstri << ".\n");}
+                  {_error_("KML_LatLonBox::Read -- Unexpected closing tag " << kstri << ".\n");}
                 else if (strncmp(kstri,"<",1))
                   {_error2_("KML_LatLonBox::Read -- Unexpected field \"" << kstri << "\".\n");}
+                  {_error_("KML_LatLonBox::Read -- Unexpected field \"" << kstri << "\".\n");}
                 else if (!strcmp(kstri,"<north>"))

issm/branches/trunk-jpl-damage/src/c/classes/objects/KML/KML_LatLonBox.h

-              r12832
+              r13101
                 void  Write(FILE* fid,const char* indent);
                 void  Read(FILE* fid,char* kstr);
                 int   Id(){_error2_("Not implemented yet.");};
                 int   MyRank(){_error2_("Not implemented yet.");};
                 void  Marshall(char** pmarshalled_dataset){_error2_("Not implemented yet.");};
                 int   MarshallSize(){_error2_("Not implemented yet.");};
                 void  Demarshall(char** pmarshalled_dataset){_error2_("Not implemented yet.");};
                 int   ObjectEnum(){_error2_("Not implemented yet.");};
                 Object* copy(){_error2_("Not implemented yet.");};
+                int   Id(){_error_("Not implemented yet.");};
+                int   MyRank(){_error_("Not implemented yet.");};
+                void  Marshall(char** pmarshalled_dataset){_error_("Not implemented yet.");};
+                int   MarshallSize(){_error_("Not implemented yet.");};
+                void  Demarshall(char** pmarshalled_dataset){_error_("Not implemented yet.");};
+                int   ObjectEnum(){_error_("Not implemented yet.");};
+                Object* copy(){_error_("Not implemented yet.");};
                 /*}}}*/

issm/branches/trunk-jpl-damage/src/c/classes/objects/KML/KML_LineString.cpp

-              r12946
+              r13101
+                }
                 else if (!strncmp(kstri,"</",2))
                   {_error2_("KML_LineString::Read -- Unexpected closing tag " << kstri << ".\n");}
+                  {_error_("KML_LineString::Read -- Unexpected closing tag " << kstri << ".\n");}
                 else if (strncmp(kstri,"<",1))
                   {_error2_("KML_LineString::Read -- Unexpected field \"" << kstri << "\".\n");}
+                  {_error_("KML_LineString::Read -- Unexpected field \"" << kstri << "\".\n");}
                 else if (!strcmp(kstri,"<extrude>"))

issm/branches/trunk-jpl-damage/src/c/classes/objects/KML/KML_LineString.h

-              r12832
+              r13101
                 void  Read(FILE* fid,char* kstr);
                 void  WriteExp(FILE* fid,const char* nstr,int sgn,double cm,double sp);
                 int   Id(){_error2_("Not implemented yet.");};
                 int   MyRank(){_error2_("Not implemented yet.");};
                 void  Marshall(char** pmarshalled_dataset){_error2_("Not implemented yet.");};
                 int   MarshallSize(){_error2_("Not implemented yet.");};
                 void  Demarshall(char** pmarshalled_dataset){_error2_("Not implemented yet.");};
                 int   ObjectEnum(){_error2_("Not implemented yet.");};
                 Object* copy(){_error2_("Not implemented yet.");};
+                int   Id(){_error_("Not implemented yet.");};
+                int   MyRank(){_error_("Not implemented yet.");};
+                void  Marshall(char** pmarshalled_dataset){_error_("Not implemented yet.");};
+                int   MarshallSize(){_error_("Not implemented yet.");};
+                void  Demarshall(char** pmarshalled_dataset){_error_("Not implemented yet.");};
+                int   ObjectEnum(){_error_("Not implemented yet.");};
+                Object* copy(){_error_("Not implemented yet.");};
                 /*}}}*/

issm/branches/trunk-jpl-damage/src/c/classes/objects/KML/KML_LineStyle.cpp

-              r12946
+              r13101
+                }
                 else if (!strncmp(kstri,"</",2))
                   {_error2_("KML_LineStyle::Read -- Unexpected closing tag " << kstri << ".\n");}
+                  {_error_("KML_LineStyle::Read -- Unexpected closing tag " << kstri << ".\n");}
                 else if (strncmp(kstri,"<",1))
                   {_error2_("KML_LineStyle::Read -- Unexpected field \"" << kstri << "\".\n");}
+                  {_error_("KML_LineStyle::Read -- Unexpected field \"" << kstri << "\".\n");}
                 else if (!strcmp(kstri,"<width>"))

issm/branches/trunk-jpl-damage/src/c/classes/objects/KML/KML_LineStyle.h

-              r12832
+              r13101
                 void  Write(FILE* fid,const char* indent);
                 void  Read(FILE* fid,char* kstr);
                 int   Id(){_error2_("Not implemented yet.");};
                 int   MyRank(){_error2_("Not implemented yet.");};
                 void  Marshall(char** pmarshalled_dataset){_error2_("Not implemented yet.");};
                 int   MarshallSize(){_error2_("Not implemented yet.");};
                 void  Demarshall(char** pmarshalled_dataset){_error2_("Not implemented yet.");};
                 int   ObjectEnum(){_error2_("Not implemented yet.");};
                 Object* copy(){_error2_("Not implemented yet.");};
+                int   Id(){_error_("Not implemented yet.");};
+                int   MyRank(){_error_("Not implemented yet.");};
+                void  Marshall(char** pmarshalled_dataset){_error_("Not implemented yet.");};
+                int   MarshallSize(){_error_("Not implemented yet.");};
+                void  Demarshall(char** pmarshalled_dataset){_error_("Not implemented yet.");};
+                int   ObjectEnum(){_error_("Not implemented yet.");};
+                Object* copy(){_error_("Not implemented yet.");};
                 /*}}}*/

issm/branches/trunk-jpl-damage/src/c/classes/objects/KML/KML_LinearRing.cpp

-              r12946
+              r13101
+                }
                 else if (!strncmp(kstri,"</",2))
                   {_error2_("KML_LinearRing::Read -- Unexpected closing tag " << kstri << ".\n");}
+                  {_error_("KML_LinearRing::Read -- Unexpected closing tag " << kstri << ".\n");}
                 else if (strncmp(kstri,"<",1))
                   {_error2_("KML_LinearRing::Read -- Unexpected field \"" << kstri << "\".\n");}
+                  {_error_("KML_LinearRing::Read -- Unexpected field \"" << kstri << "\".\n");}
                 else if (!strcmp(kstri,"<extrude>"))

issm/branches/trunk-jpl-damage/src/c/classes/objects/KML/KML_LinearRing.h

-              r12832
+              r13101
                 void  Read(FILE* fid,char* kstr);
                 void  WriteExp(FILE* fid,const char* nstr,int sgn,double cm,double sp);
                 int   Id(){_error2_("Not implemented yet.");};
                 int   MyRank(){_error2_("Not implemented yet.");};
                 void  Marshall(char** pmarshalled_dataset){_error2_("Not implemented yet.");};
                 int   MarshallSize(){_error2_("Not implemented yet.");};
                 void  Demarshall(char** pmarshalled_dataset){_error2_("Not implemented yet.");};
                 int   ObjectEnum(){_error2_("Not implemented yet.");};
                 Object* copy(){_error2_("Not implemented yet.");};
+                int   Id(){_error_("Not implemented yet.");};
+                int   MyRank(){_error_("Not implemented yet.");};
+                void  Marshall(char** pmarshalled_dataset){_error_("Not implemented yet.");};
+                int   MarshallSize(){_error_("Not implemented yet.");};
+                void  Demarshall(char** pmarshalled_dataset){_error_("Not implemented yet.");};
+                int   ObjectEnum(){_error_("Not implemented yet.");};
+                Object* copy(){_error_("Not implemented yet.");};
                 /*}}}*/

issm/branches/trunk-jpl-damage/src/c/classes/objects/KML/KML_MultiGeometry.cpp

-              r12946
+              r13101
+                }
                 else if (!strncmp(kstri,"</",2))
                   {_error2_("KML_MultiGeometry::Read -- Unexpected closing tag " << kstri << ".\n");}
+                  {_error_("KML_MultiGeometry::Read -- Unexpected closing tag " << kstri << ".\n");}
                 else if (strncmp(kstri,"<",1))
                   {_error2_("KML_MultiGeometry::Read -- Unexpected field \"" << kstri << "\".\n");}
+                  {_error_("KML_MultiGeometry::Read -- Unexpected field \"" << kstri << "\".\n");}
                 else if (!strncmp(kstri,"<Point", 6)) {

issm/branches/trunk-jpl-damage/src/c/classes/objects/KML/KML_MultiGeometry.h

-              r12832
+              r13101
                 void  Read(FILE* fid,char* kstr);
                 void  WriteExp(FILE* fid,const char* nstr,int sgn,double cm,double sp);
                 int   Id(){_error2_("Not implemented yet.");};
                 int   MyRank(){_error2_("Not implemented yet.");};
                 void  Marshall(char** pmarshalled_dataset){_error2_("Not implemented yet.");};
                 int   MarshallSize(){_error2_("Not implemented yet.");};
                 void  Demarshall(char** pmarshalled_dataset){_error2_("Not implemented yet.");};
                 int   ObjectEnum(){_error2_("Not implemented yet.");};
                 Object* copy(){_error2_("Not implemented yet.");};
+                int   Id(){_error_("Not implemented yet.");};
+                int   MyRank(){_error_("Not implemented yet.");};
+                void  Marshall(char** pmarshalled_dataset){_error_("Not implemented yet.");};
+                int   MarshallSize(){_error_("Not implemented yet.");};
+                void  Demarshall(char** pmarshalled_dataset){_error_("Not implemented yet.");};
+                int   ObjectEnum(){_error_("Not implemented yet.");};
+                Object* copy(){_error_("Not implemented yet.");};
                 /*}}}*/

issm/branches/trunk-jpl-damage/src/c/classes/objects/KML/KML_Object.cpp

-              r12946
+              r13101
                 return;
         else if (!strncmp(kstr,"</",2))
           {_error2_("KML_Object::Read -- Unexpected closing tag " << kstr << ".\n");}
+          {_error_("KML_Object::Read -- Unexpected closing tag " << kstr << ".\n");}
         else if (strncmp(kstr,"<",1))
           {_error2_("KML_Object::Read -- Unexpected field \"" << kstr << "\".\n");}
+          {_error_("KML_Object::Read -- Unexpected field \"" << kstr << "\".\n");}
         else if (!strncmp(kstr,"<Placemark",10)) {

issm/branches/trunk-jpl-damage/src/c/classes/objects/KML/KML_Object.h

-              r12832
+              r13101
                 virtual void  DeepEcho();
                 virtual void  DeepEcho(const char* indent);
                 int   Id(){_error2_("Not implemented yet.");};
                 int   MyRank(){_error2_("Not implemented yet.");};
                 void  Marshall(char** pmarshalled_dataset){_error2_("Not implemented yet.");};
                 int   MarshallSize(){_error2_("Not implemented yet.");};
                 void  Demarshall(char** pmarshalled_dataset){_error2_("Not implemented yet.");};
                 int   ObjectEnum(){_error2_("Not implemented yet.");};
                 Object* copy(){_error2_("Not implemented yet.");};
+                int   Id(){_error_("Not implemented yet.");};
+                int   MyRank(){_error_("Not implemented yet.");};
+                void  Marshall(char** pmarshalled_dataset){_error_("Not implemented yet.");};
+                int   MarshallSize(){_error_("Not implemented yet.");};
+                void  Demarshall(char** pmarshalled_dataset){_error_("Not implemented yet.");};
+                int   ObjectEnum(){_error_("Not implemented yet.");};
+                Object* copy(){_error_("Not implemented yet.");};
                 /*}}}*/

issm/branches/trunk-jpl-damage/src/c/classes/objects/KML/KML_Overlay.cpp

-              r12946
+              r13101
+        }
         else if (!strncmp(kstr,"</",2))
           {_error2_("KML_Overlay::Read -- Unexpected closing tag " << kstr << ".\n");}
+          {_error_("KML_Overlay::Read -- Unexpected closing tag " << kstr << ".\n");}
         else if (strncmp(kstr,"<",1))
           {_error2_("KML_Overlay::Read -- Unexpected field \"" << kstr << "\".\n");}
+          {_error_("KML_Overlay::Read -- Unexpected field \"" << kstr << "\".\n");}
         else if (!strcmp(kstr,"<color>"))

issm/branches/trunk-jpl-damage/src/c/classes/objects/KML/KML_Overlay.h

-              r12832
+              r13101
                 void  Write(FILE* fid,const char* indent);
                 void  Read(FILE* fid,char* kstr);
                 int   Id(){_error2_("Not implemented yet.");};
                 int   MyRank(){_error2_("Not implemented yet.");};
                 void  Marshall(char** pmarshalled_dataset){_error2_("Not implemented yet.");};
                 int   MarshallSize(){_error2_("Not implemented yet.");};
                 void  Demarshall(char** pmarshalled_dataset){_error2_("Not implemented yet.");};
                 int   ObjectEnum(){_error2_("Not implemented yet.");};
                 Object* copy(){_error2_("Not implemented yet.");};
+                int   Id(){_error_("Not implemented yet.");};
+                int   MyRank(){_error_("Not implemented yet.");};
+                void  Marshall(char** pmarshalled_dataset){_error_("Not implemented yet.");};
+                int   MarshallSize(){_error_("Not implemented yet.");};
+                void  Demarshall(char** pmarshalled_dataset){_error_("Not implemented yet.");};
+                int   ObjectEnum(){_error_("Not implemented yet.");};
+                Object* copy(){_error_("Not implemented yet.");};
                 /*}}}*/

issm/branches/trunk-jpl-damage/src/c/classes/objects/KML/KML_Placemark.cpp

-              r12946
+              r13101
+                }
                 else if (!strncmp(kstri,"</",2))
                   {_error2_("KML_Placemark::Read -- Unexpected closing tag " << kstri << ".\n");}
+                  {_error_("KML_Placemark::Read -- Unexpected closing tag " << kstri << ".\n");}
                 else if (strncmp(kstri,"<",1))
                   {_error2_("KML_Placemark::Read -- Unexpected field \"" << kstri << "\".\n");}
+                  {_error_("KML_Placemark::Read -- Unexpected field \"" << kstri << "\".\n");}
                 else if (!strncmp(kstri,"<Point", 6)) {

issm/branches/trunk-jpl-damage/src/c/classes/objects/KML/KML_Placemark.h

-              r12832
+              r13101
                 void  Read(FILE* fid,char* kstr);
                 void  WriteExp(FILE* fid,const char* nstr,int sgn,double cm,double sp);
                 int   Id(){_error2_("Not implemented yet.");};
                 int   MyRank(){_error2_("Not implemented yet.");};
                 void  Marshall(char** pmarshalled_dataset){_error2_("Not implemented yet.");};
                 int   MarshallSize(){_error2_("Not implemented yet.");};
                 void  Demarshall(char** pmarshalled_dataset){_error2_("Not implemented yet.");};
                 int   ObjectEnum(){_error2_("Not implemented yet.");};
                 Object* copy(){_error2_("Not implemented yet.");};
+                int   Id(){_error_("Not implemented yet.");};
+                int   MyRank(){_error_("Not implemented yet.");};
+                void  Marshall(char** pmarshalled_dataset){_error_("Not implemented yet.");};
+                int   MarshallSize(){_error_("Not implemented yet.");};
+                void  Demarshall(char** pmarshalled_dataset){_error_("Not implemented yet.");};
+                int   ObjectEnum(){_error_("Not implemented yet.");};
+                Object* copy(){_error_("Not implemented yet.");};
                 /*}}}*/

issm/branches/trunk-jpl-damage/src/c/classes/objects/KML/KML_Point.cpp

-              r12946
+              r13101
+                }
                 else if (!strncmp(kstri,"</",2))
                   {_error2_("KML_Point::Read -- Unexpected closing tag " << kstri << ".\n");}
+                  {_error_("KML_Point::Read -- Unexpected closing tag " << kstri << ".\n");}
                 else if (strncmp(kstri,"<",1))
                   {_error2_("KML_Point::Read -- Unexpected field \"" << kstri << "\".\n");}
+                  {_error_("KML_Point::Read -- Unexpected field \"" << kstri << "\".\n");}
                 else if (!strcmp(kstri,"<extrude>"))

issm/branches/trunk-jpl-damage/src/c/classes/objects/KML/KML_Point.h

-              r12832
+              r13101
                 void  Read(FILE* fid,char* kstr);
                 void  WriteExp(FILE* fid,const char* nstr,int sgn,double cm,double sp);
                 int   Id(){_error2_("Not implemented yet.");};
                 int   MyRank(){_error2_("Not implemented yet.");};
                 void  Marshall(char** pmarshalled_dataset){_error2_("Not implemented yet.");};
                 int   MarshallSize(){_error2_("Not implemented yet.");};
                 void  Demarshall(char** pmarshalled_dataset){_error2_("Not implemented yet.");};
                 int   ObjectEnum(){_error2_("Not implemented yet.");};
                 Object* copy(){_error2_("Not implemented yet.");};
+                int   Id(){_error_("Not implemented yet.");};
+                int   MyRank(){_error_("Not implemented yet.");};
+                void  Marshall(char** pmarshalled_dataset){_error_("Not implemented yet.");};
+                int   MarshallSize(){_error_("Not implemented yet.");};
+                void  Demarshall(char** pmarshalled_dataset){_error_("Not implemented yet.");};
+                int   ObjectEnum(){_error_("Not implemented yet.");};
+                Object* copy(){_error_("Not implemented yet.");};
                 /*}}}*/

issm/branches/trunk-jpl-damage/src/c/classes/objects/KML/KML_PolyStyle.cpp

-              r12946
+              r13101
+                }
                 else if (!strncmp(kstri,"</",2))
                   {_error2_("KML_PolyStyle::Read -- Unexpected closing tag " << kstri << ".\n");}
+                  {_error_("KML_PolyStyle::Read -- Unexpected closing tag " << kstri << ".\n");}
                 else if (strncmp(kstri,"<",1))
                   {_error2_("KML_PolyStyle::Read -- Unexpected field \"" << kstri << "\".\n");}
+                  {_error_("KML_PolyStyle::Read -- Unexpected field \"" << kstri << "\".\n");}
                 else if (!strcmp(kstri,"<fill>"))

issm/branches/trunk-jpl-damage/src/c/classes/objects/KML/KML_PolyStyle.h

-              r12832
+              r13101
                 void  Write(FILE* fid,const char* indent);
                 void  Read(FILE* fid,char* kstr);
                 int   Id(){_error2_("Not implemented yet.");};
                 int   MyRank(){_error2_("Not implemented yet.");};
                 void  Marshall(char** pmarshalled_dataset){_error2_("Not implemented yet.");};
                 int   MarshallSize(){_error2_("Not implemented yet.");};
                 void  Demarshall(char** pmarshalled_dataset){_error2_("Not implemented yet.");};
                 int   ObjectEnum(){_error2_("Not implemented yet.");};
                 Object* copy(){_error2_("Not implemented yet.");};
+                int   Id(){_error_("Not implemented yet.");};
+                int   MyRank(){_error_("Not implemented yet.");};
+                void  Marshall(char** pmarshalled_dataset){_error_("Not implemented yet.");};
+                int   MarshallSize(){_error_("Not implemented yet.");};
+                void  Demarshall(char** pmarshalled_dataset){_error_("Not implemented yet.");};
+                int   ObjectEnum(){_error_("Not implemented yet.");};
+                Object* copy(){_error_("Not implemented yet.");};
                 /*}}}*/

issm/branches/trunk-jpl-damage/src/c/classes/objects/KML/KML_Polygon.cpp

-              r12946
+              r13101
+                }
                 else if (!strncmp(kstri,"</",2))
                   {_error2_("KML_Polygon::Read -- Unexpected closing tag " << kstri << ".\n");}
+                  {_error_("KML_Polygon::Read -- Unexpected closing tag " << kstri << ".\n");}
                 else if (strncmp(kstri,"<",1))
                   {_error2_("KML_Polygon::Read -- Unexpected field \"" << kstri << "\".\n");}
+                  {_error_("KML_Polygon::Read -- Unexpected field \"" << kstri << "\".\n");}
                 else if (!strcmp(kstri,"<extrude>"))
 …
+                                }
                                 else if (!strncmp(kstrj,"</",2))
                                   {_error2_("KML_Polygon::Read -- Unexpected closing tag " << kstrj << ".\n");}
+                                  {_error_("KML_Polygon::Read -- Unexpected closing tag " << kstrj << ".\n");}
                                 else if (strncmp(kstrj,"<",1))
                                   {_error2_("KML_Polygon::Read -- Unexpected field \"" << kstrj << "\".\n");}
+                                  {_error_("KML_Polygon::Read -- Unexpected field \"" << kstrj << "\".\n");}
                                 else if (!strncmp(kstrj,"<LinearRing",11)) {
 …
+                                }
                                 else if (!strncmp(kstrj,"</",2))
                                   {_error2_("KML_Polygon::Read -- Unexpected closing tag " << kstrj << ".\n");}
+                                  {_error_("KML_Polygon::Read -- Unexpected closing tag " << kstrj << ".\n");}
                                 else if (strncmp(kstrj,"<",1))
                                   {_error2_("KML_Polygon::Read -- Unexpected field \"" << kstrj << "\".\n");}
+                                  {_error_("KML_Polygon::Read -- Unexpected field \"" << kstrj << "\".\n");}
                                 else if (!strncmp(kstrj,"<LinearRing",11)) {

issm/branches/trunk-jpl-damage/src/c/classes/objects/KML/KML_Polygon.h

-              r12832
+              r13101
                 void  Read(FILE* fid,char* kstr);
                 void  WriteExp(FILE* fid,const char* nstr,int sgn,double cm,double sp);
                 int   Id(){_error2_("Not implemented yet.");};
                 int   MyRank(){_error2_("Not implemented yet.");};
                 void  Marshall(char** pmarshalled_dataset){_error2_("Not implemented yet.");};
                 int   MarshallSize(){_error2_("Not implemented yet.");};
                 void  Demarshall(char** pmarshalled_dataset){_error2_("Not implemented yet.");};
                 int   ObjectEnum(){_error2_("Not implemented yet.");};
                 Object* copy(){_error2_("Not implemented yet.");};
+                int   Id(){_error_("Not implemented yet.");};
+                int   MyRank(){_error_("Not implemented yet.");};
+                void  Marshall(char** pmarshalled_dataset){_error_("Not implemented yet.");};
+                int   MarshallSize(){_error_("Not implemented yet.");};
+                void  Demarshall(char** pmarshalled_dataset){_error_("Not implemented yet.");};
+                int   ObjectEnum(){_error_("Not implemented yet.");};
+                Object* copy(){_error_("Not implemented yet.");};
                 /*}}}*/

issm/branches/trunk-jpl-damage/src/c/classes/objects/KML/KML_Style.cpp

-              r12946
+              r13101
+                }
                 else if (!strncmp(kstri,"</",2))
                   {_error2_("KML_Style::Read -- Unexpected closing tag " << kstri << ".\n");}
+                  {_error_("KML_Style::Read -- Unexpected closing tag " << kstri << ".\n");}
                 else if (strncmp(kstri,"<",1))
                   {_error2_("KML_Style::Read -- Unexpected field \"" << kstri << "\".\n");}
+                  {_error_("KML_Style::Read -- Unexpected field \"" << kstri << "\".\n");}
 //              else if (!strncmp(kstri,"<IconStyle",10)) {

issm/branches/trunk-jpl-damage/src/c/classes/objects/KML/KML_Style.h

-              r12832
+              r13101
                 void  Write(FILE* fid,const char* indent);
                 void  Read(FILE* fid,char* kstr);
                 int   Id(){_error2_("Not implemented yet.");};
                 int   MyRank(){_error2_("Not implemented yet.");};
                 void  Marshall(char** pmarshalled_dataset){_error2_("Not implemented yet.");};
                 int   MarshallSize(){_error2_("Not implemented yet.");};
                 void  Demarshall(char** pmarshalled_dataset){_error2_("Not implemented yet.");};
                 int   ObjectEnum(){_error2_("Not implemented yet.");};
                 Object* copy(){_error2_("Not implemented yet.");};
+                int   Id(){_error_("Not implemented yet.");};
+                int   MyRank(){_error_("Not implemented yet.");};
+                void  Marshall(char** pmarshalled_dataset){_error_("Not implemented yet.");};
+                int   MarshallSize(){_error_("Not implemented yet.");};
+                void  Demarshall(char** pmarshalled_dataset){_error_("Not implemented yet.");};
+                int   ObjectEnum(){_error_("Not implemented yet.");};
+                Object* copy(){_error_("Not implemented yet.");};
                 /*}}}*/

issm/branches/trunk-jpl-damage/src/c/classes/objects/KML/KML_StyleSelector.cpp

-              r12835
+              r13101
                 return;
         else if (!strncmp(kstr,"</",2))
           {_error2_("KML_StyleSelector::Read -- Unexpected closing tag " << kstr << ".\n");}
+          {_error_("KML_StyleSelector::Read -- Unexpected closing tag " << kstr << ".\n");}
         else if (strncmp(kstr,"<",1))
           {_error2_("KML_StyleSelector::Read -- Unexpected field \"" << kstr << "\".\n");}
+          {_error_("KML_StyleSelector::Read -- Unexpected field \"" << kstr << "\".\n");}
         else if (!strncmp(kstr,"<",1))

issm/branches/trunk-jpl-damage/src/c/classes/objects/KML/KML_StyleSelector.h

-              r12832
+              r13101
                 void  Write(FILE* fid,const char* indent);
                 void  Read(FILE* fid,char* kstr);
                 int   Id(){_error2_("Not implemented yet.");};
                 int   MyRank(){_error2_("Not implemented yet.");};
                 void  Marshall(char** pmarshalled_dataset){_error2_("Not implemented yet.");};
                 int   MarshallSize(){_error2_("Not implemented yet.");};
                 void  Demarshall(char** pmarshalled_dataset){_error2_("Not implemented yet.");};
                 int   ObjectEnum(){_error2_("Not implemented yet.");};
                 Object* copy(){_error2_("Not implemented yet.");};
+                int   Id(){_error_("Not implemented yet.");};
+                int   MyRank(){_error_("Not implemented yet.");};
+                void  Marshall(char** pmarshalled_dataset){_error_("Not implemented yet.");};
+                int   MarshallSize(){_error_("Not implemented yet.");};
+                void  Demarshall(char** pmarshalled_dataset){_error_("Not implemented yet.");};
+                int   ObjectEnum(){_error_("Not implemented yet.");};
+                Object* copy(){_error_("Not implemented yet.");};
                 /*}}}*/

issm/branches/trunk-jpl-damage/src/c/classes/objects/KML/KML_SubStyle.cpp

-              r12835
+              r13101
                 return;
         else if (!strncmp(kstr,"</",2))
           {_error2_("KML_SubStyle::Read -- Unexpected closing tag " << kstr << ".\n");}
+          {_error_("KML_SubStyle::Read -- Unexpected closing tag " << kstr << ".\n");}
         else if (strncmp(kstr,"<",1))
           {_error2_("KML_SubStyle::Read -- Unexpected field \"" << kstr << "\".\n");}
+          {_error_("KML_SubStyle::Read -- Unexpected field \"" << kstr << "\".\n");}
         else if (!strncmp(kstr,"<",1))

issm/branches/trunk-jpl-damage/src/c/classes/objects/KML/KML_SubStyle.h

-              r12832
+              r13101
                 void  Write(FILE* fid,const char* indent);
                 void  Read(FILE* fid,char* kstr);
                 int   Id(){_error2_("Not implemented yet.");};
                 int   MyRank(){_error2_("Not implemented yet.");};
                 void  Marshall(char** pmarshalled_dataset){_error2_("Not implemented yet.");};
                 int   MarshallSize(){_error2_("Not implemented yet.");};
                 void  Demarshall(char** pmarshalled_dataset){_error2_("Not implemented yet.");};
                 int   ObjectEnum(){_error2_("Not implemented yet.");};
                 Object* copy(){_error2_("Not implemented yet.");};
+                int   Id(){_error_("Not implemented yet.");};
+                int   MyRank(){_error_("Not implemented yet.");};
+                void  Marshall(char** pmarshalled_dataset){_error_("Not implemented yet.");};
+                int   MarshallSize(){_error_("Not implemented yet.");};
+                void  Demarshall(char** pmarshalled_dataset){_error_("Not implemented yet.");};
+                int   ObjectEnum(){_error_("Not implemented yet.");};
+                Object* copy(){_error_("Not implemented yet.");};
                 /*}}}*/

issm/branches/trunk-jpl-damage/src/c/classes/objects/KML/KML_Unknown.cpp

r12946	r13101
160	160	}
161	161	else if (!strncmp(kstri,"</",2))
162		{_error2_("KML_Unknown::Read -- Unexpected closing tag " << kstri << ".\n");}
	162	{_error_("KML_Unknown::Read -- Unexpected closing tag " << kstri << ".\n");}
163	163
164	164	else if (strncmp(kstri,"<",1)) {

issm/branches/trunk-jpl-damage/src/c/classes/objects/KML/KML_Unknown.h

-              r12832
+              r13101
                 void  Write(FILE* fid,const char* indent);
                 void  Read(FILE* fid,char* kstr);
                 int   Id(){_error2_("Not implemented yet.");};
                 int   MyRank(){_error2_("Not implemented yet.");};
                 void  Marshall(char** pmarshalled_dataset){_error2_("Not implemented yet.");};
                 int   MarshallSize(){_error2_("Not implemented yet.");};
                 void  Demarshall(char** pmarshalled_dataset){_error2_("Not implemented yet.");};
                 int   ObjectEnum(){_error2_("Not implemented yet.");};
                 Object* copy(){_error2_("Not implemented yet.");};
+                int   Id(){_error_("Not implemented yet.");};
+                int   MyRank(){_error_("Not implemented yet.");};
+                void  Marshall(char** pmarshalled_dataset){_error_("Not implemented yet.");};
+                int   MarshallSize(){_error_("Not implemented yet.");};
+                void  Demarshall(char** pmarshalled_dataset){_error_("Not implemented yet.");};
+                int   ObjectEnum(){_error_("Not implemented yet.");};
+                Object* copy(){_error_("Not implemented yet.");};
                 /*}}}*/

issm/branches/trunk-jpl-damage/src/c/classes/objects/Loads/Friction.cpp

-              r12832
+              r13101
                 vmag=sqrt(pow(vx,2)+pow(vy,2)+pow(vz,2));
+        }
         else _error2_("element_type "<< element_type << " not supported yet");
+        else _error_("element_type "<< element_type << " not supported yet");
         /*Checks that s-1>0 if v=0*/
         if(vmag==0 && (s-1)<0) _error2_("velocity is 0 and (s-1)=" << (s-1) << "<0, alpha_complement is Inf");
+        if(vmag==0 && (s-1)<0) _error_("velocity is 0 and (s-1)=" << (s-1) << "<0, alpha_complement is Inf");
         alpha2=pow(drag_coefficient,2)*pow(Neff,r)*pow(vmag,(s-1));
 …
                 vmag=sqrt(pow(vx,2)+pow(vy,2)+pow(vz,2));
+        }
         else _error2_("element_type "<< element_type << " not supported yet");
+        else _error_("element_type "<< element_type << " not supported yet");
         /*Checks that s-1>0 if v=0*/
         if(vmag==0 && (s-1)<0) _error2_("velocity is 0 and (s-1)=" << (s-1) << "<0, alpha_complement is Inf");
+        if(vmag==0 && (s-1)<0) _error_("velocity is 0 and (s-1)=" << (s-1) << "<0, alpha_complement is Inf");
         alpha2=pow(drag_coefficient,2)*pow(Neff,r)*pow(vmag,(s-1));
 …
                 vmag=sqrt(pow(vx,2)+pow(vy,2)+pow(vz,2));
+        }
         else _error2_("element_type "<< element_type << " not supported yet");
+        else _error_("element_type "<< element_type << " not supported yet");
         /*Checks that s-1>0 if v=0*/
         if(vmag==0 && (s-1)<0) _error2_("velocity is 0 and (s-1)=" << (s-1) << "<0, alpha_complement is Inf");
+        if(vmag==0 && (s-1)<0) _error_("velocity is 0 and (s-1)=" << (s-1) << "<0, alpha_complement is Inf");
         alpha_complement=pow(Neff,r)*pow(vmag,(s-1));            _assert_(!xIsNan<IssmDouble>(alpha_complement));
 …
                 vmag=sqrt(pow(vx,2)+pow(vy,2)+pow(vz,2));
+        }
         else _error2_("element_type "<< element_type << " not supported yet");
+        else _error_("element_type "<< element_type << " not supported yet");
         /*Checks that s-1>0 if v=0*/
         if(vmag==0 && (s-1)<0) _error2_("velocity is 0 and (s-1)=" << (s-1) << "<0, alpha_complement is Inf");
+        if(vmag==0 && (s-1)<0) _error_("velocity is 0 and (s-1)=" << (s-1) << "<0, alpha_complement is Inf");
         alpha_complement=pow(Neff,r)*pow(vmag,(s-1));            _assert_(!xIsNan<IssmDouble>(alpha_complement));
 …
         Input* input=inputs->GetInput(enum_type);
         if(!input) _error2_("input " << EnumToStringx(enum_type) << " not found");
+        if(!input) _error_("input " << EnumToStringx(enum_type) << " not found");
         input->GetInputValue(pvalue,gauss);
 …
         Input* input=inputs->GetInput(enum_type);
         if(!input) _error2_("input " << EnumToStringx(enum_type) << " not found");
+        if(!input) _error_("input " << EnumToStringx(enum_type) << " not found");
         input->GetInputValue(pvalue,gauss);

issm/branches/trunk-jpl-damage/src/c/classes/objects/Loads/Icefront.cpp

-              r12832
+              r13101
                 icefront_node_ids[3]=iomodel->nodecounter+reCast<int>(*(iomodel->Data(DiagnosticIcefrontEnum)+segment_width*i+3));
+        }
         else _error2_("in_icefront_type " << EnumToStringx(in_icefront_type) << " not supported yet!");
+        else _error_("in_icefront_type " << EnumToStringx(in_icefront_type) << " not supported yet!");
         if (in_icefront_type==PattynIceFrontEnum || in_icefront_type==StokesIceFrontEnum)
 …
                 #endif
                 default:
                         _error2_("analysis " << analysis_type << " (" << EnumToStringx(analysis_type) << ") not supported yet");
+                        _error_("analysis " << analysis_type << " (" << EnumToStringx(analysis_type) << ") not supported yet");
+        }
 …
             #endif
                 default:
                         _error2_("Icefront type " << EnumToStringx(type) << " not supported yet");
+                        _error_("Icefront type " << EnumToStringx(type) << " not supported yet");
+        }
+}
 …
                                 break;
                         default:
                                 _error2_("fill type " << EnumToStringx(fill) << " not supported yet");
+                                _error_("fill type " << EnumToStringx(fill) << " not supported yet");
+                }
                 ice_pressure=1.0/2.0*gravity*rho_ice*pow(thickness,2);
 …
                                 break;
                         default:
                                 _error2_("fill type " << EnumToStringx(fill) << " not supported yet");
+                                _error_("fill type " << EnumToStringx(fill) << " not supported yet");
+                }
                 ice_pressure=rho_ice*gravity*(surface-z_g);
 …
                                 break;
                         default:
                                 _error2_("fill type " << EnumToStringx(fill) << " not supported yet");
+                                _error_("fill type " << EnumToStringx(fill) << " not supported yet");
+                }
                 air_pressure=0;

issm/branches/trunk-jpl-damage/src/c/classes/objects/Loads/Icefront.h

r12494	r13101
64	64	void InputUpdateFromConstant(bool constant, int name);
65	65	void InputUpdateFromSolution(IssmDouble* solution);
66		void InputUpdateFromIoModel(int index, IoModel* iomodel){_error2_("not implemented yet");};
	66	void InputUpdateFromIoModel(int index, IoModel* iomodel){_error_("not implemented yet");};
67	67	/}}}/
68	68	/Load virtual functions definitions: {{{/

issm/branches/trunk-jpl-damage/src/c/classes/objects/Loads/Numericalflux.cpp

r12832	r13101
270	270	break;
271	271	default:
272		_error2_("analysis " << analysis_type << " (" << EnumToStringx(analysis_type) << ") not supported yet");
	272	_error_("analysis " << analysis_type << " (" << EnumToStringx(analysis_type) << ") not supported yet");
273	273	}
274	274
…	…
300	300	break;
301	301	default:
302		_error2_("analysis " << analysis_type << " (" << EnumToStringx(analysis_type) << ") not supported yet");
	302	_error_("analysis " << analysis_type << " (" << EnumToStringx(analysis_type) << ") not supported yet");
303	303	}
304	304
…	…
347	347	return CreateKMatrixPrognosticBoundary();
348	348	default:
349		_error2_("type not supported yet");
	349	_error_("type not supported yet");
350	350	}
351	351	}
…	…
500	500	return CreateKMatrixBalancethicknessBoundary();
501	501	default:
502		_error2_("type not supported yet");
	502	_error_("type not supported yet");
503	503	}
504	504	}
…	…
651	651	return CreateKMatrixAdjointBalancethicknessBoundary();
652	652	default:
653		_error2_("type not supported yet");
	653	_error_("type not supported yet");
654	654	}
655	655	}
…	…
683	683	return CreatePVectorPrognosticBoundary();
684	684	default:
685		_error2_("type not supported yet");
	685	_error_("type not supported yet");
686	686	}
687	687	}
…	…
751	751	vyaverage_input->GetInputValue(&vy,gauss);
752	752	spcthickness_input->GetInputValue(&thickness,gauss);
753		if(xIsNan<IssmDouble>(thickness)) _error2_("Cannot weakly apply constraint because NaN was provided");
	753	if(xIsNan<IssmDouble>(thickness)) _error_("Cannot weakly apply constraint because NaN was provided");
754	754
755	755	UdotN=vxnormal[0]+vynormal[1];
…	…
777	777	return CreatePVectorBalancethicknessBoundary();
778	778	default:
779		_error2_("type not supported yet");
	779	_error_("type not supported yet");
780	780	}
781	781	}

issm/branches/trunk-jpl-damage/src/c/classes/objects/Loads/Numericalflux.h

-              r12494
+              r13101
                 /*Update virtual functions resolution: {{{*/
                 void    InputUpdateFromVector(IssmDouble* vector, int name, int type){/*Do nothing*/}
                 void    InputUpdateFromVector(int* vector, int name, int type){_error2_("Not implemented yet!");}
                 void    InputUpdateFromVector(bool* vector, int name, int type){_error2_("Not implemented yet!");}
+                void    InputUpdateFromVector(int* vector, int name, int type){_error_("Not implemented yet!");}
+                void    InputUpdateFromVector(bool* vector, int name, int type){_error_("Not implemented yet!");}
                 void    InputUpdateFromMatrixDakota(IssmDouble* matrix, int nrows, int ncols, int name, int type){/*Do nothing*/}
                 void    InputUpdateFromVectorDakota(IssmDouble* vector, int name, int type){/*Do nothing*/}
                 void    InputUpdateFromVectorDakota(int* vector, int name, int type){_error2_("Not implemented yet!");}
                 void    InputUpdateFromVectorDakota(bool* vector, int name, int type){_error2_("Not implemented yet!");}
+                void    InputUpdateFromVectorDakota(int* vector, int name, int type){_error_("Not implemented yet!");}
+                void    InputUpdateFromVectorDakota(bool* vector, int name, int type){_error_("Not implemented yet!");}
                 void    InputUpdateFromConstant(IssmDouble constant, int name){/*Do nothing*/};
                 void    InputUpdateFromConstant(int constant, int name){/*Do nothing*/};
                 void    InputUpdateFromConstant(bool constant, int name){_error2_("Not implemented yet!");}
                 void    InputUpdateFromSolution(IssmDouble* solution){_error2_("Not implemented yet!");}
                 void  InputUpdateFromIoModel(int index, IoModel* iomodel){_error2_("not implemented yet");};
+                void    InputUpdateFromConstant(bool constant, int name){_error_("Not implemented yet!");}
+                void    InputUpdateFromSolution(IssmDouble* solution){_error_("Not implemented yet!");}
+                void  InputUpdateFromIoModel(int index, IoModel* iomodel){_error_("not implemented yet");};
                 /*}}}*/
                 /*Load virtual functions definitions: {{{*/
 …
                 void  CreateKMatrix(Matrix* Kff, Matrix* Kfs);
                 void  CreatePVector(Vector* pf);
                 void  CreateJacobianMatrix(Matrix* Jff){_error2_("Not implemented yet");};
                 void  PenaltyCreateJacobianMatrix(Matrix* Jff,IssmDouble kmax){_error2_("Not implemented yet");};
+                void  CreateJacobianMatrix(Matrix* Jff){_error_("Not implemented yet");};
+                void  PenaltyCreateJacobianMatrix(Matrix* Jff,IssmDouble kmax){_error_("Not implemented yet");};
                 void  PenaltyCreateKMatrix(Matrix* Kff, Matrix* kfs, IssmDouble kmax);
                 void  PenaltyCreatePVector(Vector* pf, IssmDouble kmax);

issm/branches/trunk-jpl-damage/src/c/classes/objects/Loads/Pengrid.cpp

-              r12832
+              r13101
                 #endif
                 default:
                         _error2_("analysis " << analysis_type << " (" << EnumToStringx(analysis_type) << ") not supported yet");
+                        _error_("analysis " << analysis_type << " (" << EnumToStringx(analysis_type) << ") not supported yet");
+        }
 …
                 #endif
                 default:
                         _error2_("analysis " << analysis_type << " (" << EnumToStringx(analysis_type) << ") not supported yet");
+                        _error_("analysis " << analysis_type << " (" << EnumToStringx(analysis_type) << ") not supported yet");
+        }
 …
+        }
         else{
                 _error2_("analysis: " << EnumToStringx(analysis_type) << " not supported yet");
+                _error_("analysis: " << EnumToStringx(analysis_type) << " not supported yet");
+        }
 …
+        }
         else{
                 if (dt) pe->values[0]=melting_offset*pow((IssmDouble)10,penalty_factor)*(temperature-t_pmp)/dt;
+                if (reCast<bool>(dt)) pe->values[0]=melting_offset*pow((IssmDouble)10,penalty_factor)*(temperature-t_pmp)/dt;
                 else    pe->values[0]=melting_offset*pow((IssmDouble)10,penalty_factor)*(temperature-t_pmp);
+        }
 …
 /*FUNCTION Pengrid::UpdateInputs {{{*/
 void  Pengrid::UpdateInputs(IssmDouble* solution){
         _error2_("not supported yet!");
+}
 /*}}}*/
+        _error_("not supported yet!");
+}
+/*}}}*/

issm/branches/trunk-jpl-damage/src/c/classes/objects/Loads/Pengrid.h

-              r12494
+              r13101
                 void  InputUpdateFromConstant(bool constant, int name);
                 void  InputUpdateFromSolution(IssmDouble* solution);
                 void  InputUpdateFromIoModel(int index, IoModel* iomodel){_error2_("not implemented yet");};
+                void  InputUpdateFromIoModel(int index, IoModel* iomodel){_error_("not implemented yet");};
                 /*}}}*/
                 /*Load virtual functions definitions: {{{*/
 …
                 void  CreateKMatrix(Matrix* Kff, Matrix* Kfs);
                 void  CreatePVector(Vector* pf);
                 void  CreateJacobianMatrix(Matrix* Jff){_error2_("Not implemented yet");};
                 void  PenaltyCreateJacobianMatrix(Matrix* Jff,IssmDouble kmax){_error2_("Not implemented yet");};
+                void  CreateJacobianMatrix(Matrix* Jff){_error_("Not implemented yet");};
+                void  PenaltyCreateJacobianMatrix(Matrix* Jff,IssmDouble kmax){_error_("Not implemented yet");};
                 void  PenaltyCreateKMatrix(Matrix* Kff, Matrix* kfs, IssmDouble kmax);
                 void  PenaltyCreatePVector(Vector* pf, IssmDouble kmax);

issm/branches/trunk-jpl-damage/src/c/classes/objects/Loads/Penpair.cpp

-              r12832
+              r13101
                         break;
                 default:
                         _error2_("analysis " << analysis_type << " (" << EnumToStringx(analysis_type) << ") not supported yet");
+                        _error_("analysis " << analysis_type << " (" << EnumToStringx(analysis_type) << ") not supported yet");
+        }
 …
                                 case MacAyealApproximationEnum: return PenaltyCreateKMatrixDiagnosticMacAyealPattyn(kmax);
                                 case PattynApproximationEnum:   return PenaltyCreateKMatrixDiagnosticMacAyealPattyn(kmax);
                                 default: _error2_("not supported yet");
+                                default: _error_("not supported yet");
+                        }
                 case PattynApproximationEnum:
 …
                                 case MacAyealApproximationEnum: return PenaltyCreateKMatrixDiagnosticMacAyealPattyn(kmax);
                                 case PattynApproximationEnum:   return PenaltyCreateKMatrixDiagnosticMacAyealPattyn(kmax);
                                 default: _error2_("not supported yet");
+                                default: _error_("not supported yet");
+                        }
                 case StokesApproximationEnum:
 …
                                 case StokesApproximationEnum: return PenaltyCreateKMatrixDiagnosticStokes(kmax);
                                 case NoneApproximationEnum: return   PenaltyCreateKMatrixDiagnosticStokes(kmax);
                                 default: _error2_("not supported yet");
+                                default: _error_("not supported yet");
+                        }
                 case NoneApproximationEnum:
 …
                                 case StokesApproximationEnum: return PenaltyCreateKMatrixDiagnosticStokes(kmax);
                                 case NoneApproximationEnum: return   PenaltyCreateKMatrixDiagnosticStokes(kmax);
                                 default: _error2_("not supported yet");
+                                default: _error_("not supported yet");
+                        }
                 default: _error2_("not supported yet");
+                default: _error_("not supported yet");
+        }
+}

issm/branches/trunk-jpl-damage/src/c/classes/objects/Loads/Penpair.h

-              r12494
+              r13101
                 void  InputUpdateFromVector(int* vector, int name, int type);
                 void  InputUpdateFromVector(bool* vector, int name, int type);
                 void  InputUpdateFromMatrixDakota(IssmDouble* matrix, int nrow, int ncols,int name, int type){_error2_("Not implemented yet!");}
                 void  InputUpdateFromVectorDakota(IssmDouble* vector, int name, int type){_error2_("Not implemented yet!");}
                 void  InputUpdateFromVectorDakota(int* vector, int name, int type){_error2_("Not implemented yet!");}
                 void  InputUpdateFromVectorDakota(bool* vector, int name, int type){_error2_("Not implemented yet!");}
+                void  InputUpdateFromMatrixDakota(IssmDouble* matrix, int nrow, int ncols,int name, int type){_error_("Not implemented yet!");}
+                void  InputUpdateFromVectorDakota(IssmDouble* vector, int name, int type){_error_("Not implemented yet!");}
+                void  InputUpdateFromVectorDakota(int* vector, int name, int type){_error_("Not implemented yet!");}
+                void  InputUpdateFromVectorDakota(bool* vector, int name, int type){_error_("Not implemented yet!");}
                 void  InputUpdateFromConstant(IssmDouble constant, int name);
                 void  InputUpdateFromConstant(int constant, int name);
                 void  InputUpdateFromConstant(bool constant, int name);
                 void  InputUpdateFromSolution(IssmDouble* solution){_error2_("Not implemented yet!");}
                 void  InputUpdateFromIoModel(int index, IoModel* iomodel){_error2_("not implemented yet");};
+                void  InputUpdateFromSolution(IssmDouble* solution){_error_("Not implemented yet!");}
+                void  InputUpdateFromIoModel(int index, IoModel* iomodel){_error_("not implemented yet");};
                 /*}}}*/
                         /*Load virtual functions definitions: {{{*/

issm/branches/trunk-jpl-damage/src/c/classes/objects/Loads/Riftfront.cpp

-              r12832
+              r13101
         /*Ok, retrieve all the data needed to add a penalty between the two nodes: */
         el1=(int)*(iomodel->Data(RiftsRiftstructEnum)+RIFTINFOSIZE*i+2);
         el2=(int)*(iomodel->Data(RiftsRiftstructEnum)+RIFTINFOSIZE*i+3);
         node1=(int)*(iomodel->Data(RiftsRiftstructEnum)+RIFTINFOSIZE*i+0);
         node2=(int)*(iomodel->Data(RiftsRiftstructEnum)+RIFTINFOSIZE*i+1);
+        el1=reCast<int,IssmDouble>(*(iomodel->Data(RiftsRiftstructEnum)+RIFTINFOSIZE*i+2));
+        el2=reCast<int,IssmDouble>(*(iomodel->Data(RiftsRiftstructEnum)+RIFTINFOSIZE*i+3)) ;
+        node1=reCast<int,IssmDouble>(*(iomodel->Data(RiftsRiftstructEnum)+RIFTINFOSIZE*i+0));
+        node2=reCast<int,IssmDouble>(*(iomodel->Data(RiftsRiftstructEnum)+RIFTINFOSIZE*i+1));
         /*id: */
 …
         this->length=*(iomodel->Data(RiftsRiftstructEnum)+RIFTINFOSIZE*i+6);
         this->fraction=*(iomodel->Data(RiftsRiftstructEnum)+RIFTINFOSIZE*i+9);
         this->state=(int)*(iomodel->Data(RiftsRiftstructEnum)+RIFTINFOSIZE*i+11);
+        this->state=reCast<int,IssmDouble>(*(iomodel->Data(RiftsRiftstructEnum)+RIFTINFOSIZE*i+11));
         //intialize inputs, and add as many inputs per element as requested:
 …
         riftfront_type=SegmentRiftfrontEnum;
         riftfront_fill = (int)*(iomodel->Data(RiftsRiftstructEnum)+RIFTINFOSIZE*i+7);
+        riftfront_fill = reCast<int,IssmDouble>(*(iomodel->Data(RiftsRiftstructEnum)+RIFTINFOSIZE*i+7));
         riftfront_friction=*(iomodel->Data(RiftsRiftstructEnum)+RIFTINFOSIZE*i+8);
         riftfront_fractionincrement=*(iomodel->Data(RiftsRiftstructEnum)+RIFTINFOSIZE*i+10);
         riftfront_shelf=(bool)iomodel->Data(MaskVertexonfloatingiceEnum)[node1-1];
+        riftfront_shelf=reCast<bool,IssmDouble>(iomodel->Data(MaskVertexonfloatingiceEnum)[node1-1]);
         this->inputs->AddInput(new IntInput(TypeEnum,riftfront_type));
 …
         /*update input*/
         _error2_("not implemented yet");
+        _error_("not implemented yet");
         //this->inputs->AddInput(new DoubleInput(name,constant));
 …
                         break;
                 default:
                         _error2_("analysis " << analysis_type << " (" << EnumToStringx(analysis_type) << ") not supported yet");
+                        _error_("analysis " << analysis_type << " (" << EnumToStringx(analysis_type) << ") not supported yet");
+        }
 …
                         break;
                 default:
                         _error2_("analysis " << analysis_type << " (" << EnumToStringx(analysis_type) << ") not supported yet");
+                        _error_("analysis " << analysis_type << " (" << EnumToStringx(analysis_type) << ") not supported yet");
+        }
 …
         /*enum of element? */
         if(elements[0]->ObjectEnum()!=TriaEnum)_error2_("only Tria element allowed for Riftfront load!");
+        if(elements[0]->ObjectEnum()!=TriaEnum)_error_("only Tria element allowed for Riftfront load!");
         tria1=(Tria*)elements[0];
         tria2=(Tria*)elements[1];
 …
         tria1->GetInputValue(&h[0],nodes[0],ThicknessEnum);
         tria2->GetInputValue(&h[1],nodes[1],ThicknessEnum);
         if (h[0]!=h[1])_error2_("different thicknesses not supported for rift fronts");
+        if (h[0]!=h[1])_error_("different thicknesses not supported for rift fronts");
         thickness=h[0];
 …
         /*enum of element? */
         if(elements[0]->ObjectEnum()!=TriaEnum)_error2_("only Tria element allowed for Riftfront load!");
+        if(elements[0]->ObjectEnum()!=TriaEnum)_error_("only Tria element allowed for Riftfront load!");
         tria1=(Tria*)elements[0];
         tria2=(Tria*)elements[1];
 …
         tria1->GetInputValue(&h[0],nodes[0],ThicknessEnum);
         tria2->GetInputValue(&h[1],nodes[1],ThicknessEnum);
         if (h[0]!=h[1])_error2_("different thicknesses not supported for rift fronts");
+        if (h[0]!=h[1])_error_("different thicknesses not supported for rift fronts");
         thickness=h[0];
         tria1->GetInputValue(&b[0],nodes[0],BedEnum);
         tria2->GetInputValue(&b[1],nodes[1],BedEnum);
         if (b[0]!=b[1])_error2_("different beds not supported for rift fronts");
+        if (b[0]!=b[1])_error_("different beds not supported for rift fronts");
         bed=b[0];
 …
         else if(fill==MelangeEnum){ //icefront finding itself against another icefront (pressure imbalance is fully compensated, ice vs ice)
                 if(!shelf) _error2_("fill type " << fill << " not supported on ice sheets yet.");
+                if(!shelf) _error_("fill type " << fill << " not supported on ice sheets yet.");
                 pressure_litho=rho_ice*gravity*pow(thickness,(IssmDouble)2)/(IssmDouble)2;
 …
+        }
         else{
                 _error2_("fill type " << fill << " not supported yet.");
+                _error_("fill type " << fill << " not supported yet.");
+        }
 …
         /*enum of element? */
         if(elements[0]->ObjectEnum()!=TriaEnum)_error2_("only Tria element allowed for Riftfront load!");
+        if(elements[0]->ObjectEnum()!=TriaEnum)_error_("only Tria element allowed for Riftfront load!");
         /*recover elements on both side of rift: */
 …
         this->inputs->GetInputValue(&converged,ConvergedEnum);
         if(converged){
+        if(reCast<int,IssmDouble>(converged)){
                 /*ok, material non-linearity has converged. If that was already the case, we keep
                  * constraining the rift front. If it was not, and this is the first time the material
 …
         /*enum of element? */
         if(elements[0]->ObjectEnum()!=TriaEnum)_error2_("only Tria element allowed for Riftfront load!");
+        if(elements[0]->ObjectEnum()!=TriaEnum)_error_("only Tria element allowed for Riftfront load!");
         /*recover elements on both side of rift: */
 …
         /*enum of element? */
         if(elements[0]->ObjectEnum()!=TriaEnum)_error2_("only Tria element allowed for Riftfront load!");
+        if(elements[0]->ObjectEnum()!=TriaEnum)_error_("only Tria element allowed for Riftfront load!");
         /*recover elements on both side of rift: */
 …
         /*enum of element? */
         if(elements[0]->ObjectEnum()!=TriaEnum)_error2_("only Tria element allowed for Riftfront load!");
+        if(elements[0]->ObjectEnum()!=TriaEnum)_error_("only Tria element allowed for Riftfront load!");
         /*recover elements on both side of rift: */
 …
         /*enum of element? */
         if(elements[0]->ObjectEnum()!=TriaEnum)_error2_("only Tria element allowed for Riftfront load!");
+        if(elements[0]->ObjectEnum()!=TriaEnum)_error_("only Tria element allowed for Riftfront load!");
         /*recover elements on both side of rift: */

issm/branches/trunk-jpl-damage/src/c/classes/objects/Loads/Riftfront.h

-              r12494
+              r13101
                 /*Update virtual functions resolution: {{{*/
                 void    InputUpdateFromVector(IssmDouble* vector, int name, int type);
                 void    InputUpdateFromVector(int* vector, int name, int type){_error2_("Not implemented yet!");}
                 void    InputUpdateFromVector(bool* vector, int name, int type){_error2_("Not implemented yet!");}
                 void    InputUpdateFromMatrixDakota(IssmDouble* matrix, int nrows,int ncols, int name, int type){_error2_("Not implemented yet!");}
                 void    InputUpdateFromVectorDakota(IssmDouble* vector, int name, int type){_error2_("Not implemented yet!");}
                 void    InputUpdateFromVectorDakota(int* vector, int name, int type){_error2_("Not implemented yet!");}
                 void    InputUpdateFromVectorDakota(bool* vector, int name, int type){_error2_("Not implemented yet!");}
+                void    InputUpdateFromVector(int* vector, int name, int type){_error_("Not implemented yet!");}
+                void    InputUpdateFromVector(bool* vector, int name, int type){_error_("Not implemented yet!");}
+                void    InputUpdateFromMatrixDakota(IssmDouble* matrix, int nrows,int ncols, int name, int type){_error_("Not implemented yet!");}
+                void    InputUpdateFromVectorDakota(IssmDouble* vector, int name, int type){_error_("Not implemented yet!");}
+                void    InputUpdateFromVectorDakota(int* vector, int name, int type){_error_("Not implemented yet!");}
+                void    InputUpdateFromVectorDakota(bool* vector, int name, int type){_error_("Not implemented yet!");}
                 void    InputUpdateFromConstant(IssmDouble constant, int name);
                 void    InputUpdateFromConstant(int constant, int name){_error2_("Not implemented yet!");}
+                void    InputUpdateFromConstant(int constant, int name){_error_("Not implemented yet!");}
                 void    InputUpdateFromConstant(bool constant, int name);
                 void    InputUpdateFromSolution(IssmDouble* solution){_error2_("Not implemented yet!");}
                 void  InputUpdateFromIoModel(int index, IoModel* iomodel){_error2_("not implemented yet");};
+                void    InputUpdateFromSolution(IssmDouble* solution){_error_("Not implemented yet!");}
+                void  InputUpdateFromIoModel(int index, IoModel* iomodel){_error_("not implemented yet");};
                 /*}}}*/
                 /*Load virtual functions definitions: {{{*/
 …
                 void  CreateKMatrix(Matrix* Kff, Matrix* Kfs);
                 void  CreatePVector(Vector* pf);
                 void  CreateJacobianMatrix(Matrix* Jff){_error2_("Not implemented yet");};
                 void  PenaltyCreateJacobianMatrix(Matrix* Jff,IssmDouble kmax){_error2_("Not implemented yet");};
+                void  CreateJacobianMatrix(Matrix* Jff){_error_("Not implemented yet");};
+                void  PenaltyCreateJacobianMatrix(Matrix* Jff,IssmDouble kmax){_error_("Not implemented yet");};
                 void  PenaltyCreateKMatrix(Matrix* Kff, Matrix* kfs, IssmDouble kmax);
                 void  PenaltyCreatePVector(Vector* pf, IssmDouble kmax);

issm/branches/trunk-jpl-damage/src/c/classes/objects/Materials/Matice.cpp

-              r12897
+              r13101
+}
 /*}}}*/
+/*FUNCTION Matice::GetA {{{*/
+IssmDouble Matice::GetA(){
+        /*
+         * A = 1/B^n
+         */
+        IssmDouble B,n;
+        inputs->GetInputAverage(&B,MaterialsRheologyBEnum);
+        n=this->GetN();
+        return pow(B,-n);
+}
+/*}}}*/
 /*FUNCTION Matice::GetB {{{*/
 IssmDouble Matice::GetB(){
 …
                         /*Get input (either in element or material)*/
                         Input* input=inputs->GetInput(input_enum);
                         if(!input) _error2_("Input " << EnumToStringx(input_enum) << " not found in material");
+                        if(!input) _error_("Input " << EnumToStringx(input_enum) << " not found in material");
                         /*We found the enum.  Use its values to fill into the vector, using the vertices ids: */
 …
                         break;
                 default: _error2_("element " << EnumToStringx(element->ObjectEnum()) << " not implemented yet");
+                default: _error_("element " << EnumToStringx(element->ObjectEnum()) << " not implemented yet");
+        }
+}
 …
                         if(A==0){
                                 /*Maxiviscositym viscosity for 0 shear areas: */
                                 viscosity=2.5*pow((IssmDouble)10,(IssmDouble)17);
+                                viscosity=2.5*pow(10.,17.);
+                        }
                         else{
 …
         /*Checks in debugging mode*/
         if(viscosity<=0) _error2_("Negative viscosity");
+        if(viscosity<=0) _error_("Negative viscosity");
         _assert_(B>0);
         _assert_(n>0);
 …
         /*Checks in debugging mode*/
         if(viscosity3d<=0) _error2_("Negative viscosity");
+        if(viscosity3d<=0) _error_("Negative viscosity");
         _assert_(B>0);
         _assert_(n>0);
 …
         /*Checks in debugging mode*/
         if(viscosity3d<=0) _error2_("Negative viscosity");
+        if(viscosity3d<=0) _error_("Negative viscosity");
         _assert_(B>0);
         _assert_(n>0);
 …
                                         return;
+                                }
                                 default: _error2_("element " << EnumToStringx(element->ObjectEnum()) << " not implemented yet");
+                        }
                 default: _error2_("type " << type << " (" << EnumToStringx(type) << ") not implemented yet");
+                                default: _error_("element " << EnumToStringx(element->ObjectEnum()) << " not implemented yet");
+                        }
+                default: _error_("type " << type << " (" << EnumToStringx(type) << ") not implemented yet");
+        }
+}
 …
                                         return;
+                                }
                                 default: _error2_("element " << EnumToStringx(element->ObjectEnum()) << " not implemented yet");
+                        }
                 default: _error2_("type " << type << " (" << EnumToStringx(type) << ") not implemented yet");
+                                default: _error_("element " << EnumToStringx(element->ObjectEnum()) << " not implemented yet");
+                        }
+                default: _error_("type " << type << " (" << EnumToStringx(type) << ") not implemented yet");
+        }
 …
                 if (control_analysis && iomodel->Data(InversionControlParametersEnum)){
                         for(i=0;i<num_control_type;i++){
                                 switch((int)iomodel->Data(InversionControlParametersEnum)[i]){
+                                switch(reCast<int>(iomodel->Data(InversionControlParametersEnum)[i])){
                                         case MaterialsRheologyBbarEnum:
                                                 if (iomodel->Data(MaterialsRheologyBEnum)){
                                                         _assert_(iomodel->Data(MaterialsRheologyBEnum));_assert_(iomodel->Data(InversionMinParametersEnum)); _assert_(iomodel->Data(InversionMaxParametersEnum));
                                                         for(j=0;j<num_vertices;j++)nodeinputs[j]=iomodel->Data(MaterialsRheologyBEnum)[int(iomodel->Data(MeshElementsEnum)[num_vertices*index+j]-1)];
                                                         for(j=0;j<num_vertices;j++)cmmininputs[j]=iomodel->Data(InversionMinParametersEnum)[int(iomodel->Data(MeshElementsEnum)[num_vertices*index+j]-1)*num_control_type+i];
                                                         for(j=0;j<num_vertices;j++)cmmaxinputs[j]=iomodel->Data(InversionMaxParametersEnum)[int(iomodel->Data(MeshElementsEnum)[num_vertices*index+j]-1)*num_control_type+i];
+                                                        for(j=0;j<num_vertices;j++)nodeinputs[j]=iomodel->Data(MaterialsRheologyBEnum)[reCast<int,IssmDouble>(iomodel->Data(MeshElementsEnum)[num_vertices*index+j]-1)];
+                                                        for(j=0;j<num_vertices;j++)cmmininputs[j]=iomodel->Data(InversionMinParametersEnum)[reCast<int,IssmDouble>(iomodel->Data(MeshElementsEnum)[num_vertices*index+j]-1)*num_control_type+i];
+                                                        for(j=0;j<num_vertices;j++)cmmaxinputs[j]=iomodel->Data(InversionMaxParametersEnum)[reCast<int,IssmDouble>(iomodel->Data(MeshElementsEnum)[num_vertices*index+j]-1)*num_control_type+i];
                                                         this->inputs->AddInput(new ControlInput(MaterialsRheologyBbarEnum,TriaP1InputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1));
+                                                }
 …
                 /*Get B*/
                 if (iomodel->Data(MaterialsRheologyBEnum)) {
                         for(i=0;i<num_vertices;i++) nodeinputs[i]=iomodel->Data(MaterialsRheologyBEnum)[int(iomodel->Data(MeshElementsEnum)[num_vertices*index+i]-1)];
+                        for(i=0;i<num_vertices;i++) nodeinputs[i]=iomodel->Data(MaterialsRheologyBEnum)[reCast<int,IssmDouble>(iomodel->Data(MeshElementsEnum)[num_vertices*index+i]-1)];
                         this->inputs->AddInput(new PentaP1Input(MaterialsRheologyBEnum,nodeinputs));
+                }
 …
                 if (control_analysis && iomodel->Data(InversionControlParametersEnum)){
                         for(i=0;i<num_control_type;i++){
                                 switch((int)iomodel->Data(InversionControlParametersEnum)[i]){
+                                switch(reCast<int>(iomodel->Data(InversionControlParametersEnum)[i])){
                                         case MaterialsRheologyBbarEnum:
                                                 if (iomodel->Data(MaterialsRheologyBEnum)){
                                                         _assert_(iomodel->Data(MaterialsRheologyBEnum));_assert_(iomodel->Data(InversionMinParametersEnum)); _assert_(iomodel->Data(InversionMaxParametersEnum));
                                                         for(j=0;j<num_vertices;j++)nodeinputs[j]=iomodel->Data(MaterialsRheologyBEnum)[int(iomodel->Data(MeshElementsEnum)[num_vertices*index+j]-1)];
                                                         for(j=0;j<num_vertices;j++)cmmininputs[j]=iomodel->Data(InversionMinParametersEnum)[int(iomodel->Data(MeshElementsEnum)[num_vertices*index+j]-1)*num_control_type+i];
                                                         for(j=0;j<num_vertices;j++)cmmaxinputs[j]=iomodel->Data(InversionMaxParametersEnum)[int(iomodel->Data(MeshElementsEnum)[num_vertices*index+j]-1)*num_control_type+i];
+                                                        for(j=0;j<num_vertices;j++)nodeinputs[j]=iomodel->Data(MaterialsRheologyBEnum)[reCast<int,IssmDouble>(iomodel->Data(MeshElementsEnum)[num_vertices*index+j]-1)];
+                                                        for(j=0;j<num_vertices;j++)cmmininputs[j]=iomodel->Data(InversionMinParametersEnum)[reCast<int,IssmDouble>(iomodel->Data(MeshElementsEnum)[num_vertices*index+j]-1)*num_control_type+i];
+                                                        for(j=0;j<num_vertices;j++)cmmaxinputs[j]=iomodel->Data(InversionMaxParametersEnum)[reCast<int,IssmDouble>(iomodel->Data(MeshElementsEnum)[num_vertices*index+j]-1)*num_control_type+i];
                                                         this->inputs->AddInput(new ControlInput(MaterialsRheologyBEnum,PentaP1InputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1));
+                                                }
 …
         #endif
         else{
                 _error2_("Mesh type not supported yet!");
+                _error_("Mesh type not supported yet!");
+        }

issm/branches/trunk-jpl-damage/src/c/classes/objects/Materials/Matice.h

r12897	r13101
66	66	void GetViscosityDerivativeEpsSquare(IssmDouble* pmu_prime, IssmDouble* pepsilon);
67	67	void GetViscosity2dDerivativeEpsSquare(IssmDouble* pmu_prime, IssmDouble* pepsilon);
	68	IssmDouble GetA();
68	69	IssmDouble GetB();
69	70	IssmDouble GetBbar();

issm/branches/trunk-jpl-damage/src/c/classes/objects/Materials/Matpar.h

-              r12494
+              r13101
                 void   InputUpdateFromConstant(bool constant, int name);
                 void   InputUpdateFromSolution(IssmDouble* solution);
                 void   InputUpdateFromIoModel(int index, IoModel* iomodel){_error2_("not implemented yet");};
+                void   InputUpdateFromIoModel(int index, IoModel* iomodel){_error_("not implemented yet");};
                 /*}}}*/
                 /*Material virtual functions resolution: {{{*/
                 void   InputDuplicate(int original_enum,int new_enum){_error2_("not implemented yet");};
+                void   InputDuplicate(int original_enum,int new_enum){_error_("not implemented yet");};
                 void   Configure(Elements* elements);
                 void   GetVectorFromInputs(Vector* vector,int input_enum){return;}

issm/branches/trunk-jpl-damage/src/c/classes/objects/Node.cpp

r12832	r13101
70	70
71	71	/spc all nodes on water/
72		if (!iomodel->Data(MaskVertexonwaterEnum)) _error2_("iomodel->nodeonwater is NULL");
	72	if (!iomodel->Data(MaskVertexonwaterEnum)) _error_("iomodel->nodeonwater is NULL");
73	73	if (reCast<IssmBool>(iomodel->Data(MaskVertexonwaterEnum)[io_index])){
74	74	for(k=1;k<=gsize;k++){
…	…
89	89	_assert_(iomodel->Data(MeshVertexonbedEnum));
90	90	_assert_(iomodel->Data(FlowequationVertexEquationEnum));
91		if (iomodel->Data(FlowequationVertexEquationEnum)[io_index]==MacAyealApproximationEnum && !~~iomodel->Data(MeshVertexonbedEnum)[io_index]~~){
	91	if (iomodel->Data(FlowequationVertexEquationEnum)[io_index]==MacAyealApproximationEnum && !reCast<int>(iomodel->Data(MeshVertexonbedEnum)[io_index])){
92	92	for(k=1;k<=gsize;k++) this->FreezeDof(k);
93	93	}
94		if (iomodel->Data(FlowequationVertexEquationEnum)[io_index]==MacAyealPattynApproximationEnum && iomodel->Data(FlowequationBordermacayealEnum)[io_index]){
95		if(!iomodel->Data(MeshVertexonbedEnum)[io_index]){
	94	if (iomodel->Data(FlowequationVertexEquationEnum)[io_index]==L1L2ApproximationEnum && !reCast<int>(iomodel->Data(MeshVertexonbedEnum)[io_index])){
	95	for(k=1;k<=gsize;k++) this->FreezeDof(k);
	96	}
	97	if (iomodel->Data(FlowequationVertexEquationEnum)[io_index]==MacAyealPattynApproximationEnum && reCast<int>(iomodel->Data(FlowequationBordermacayealEnum)[io_index])){
	98	if(!reCast<int>(iomodel->Data(MeshVertexonbedEnum)[io_index])){
96	99	for(k=1;k<=gsize;k++) this->FreezeDof(k);
97	100	}
98	101	}
99		if (iomodel->Data(FlowequationVertexEquationEnum)[io_index]==MacAyealStokesApproximationEnum && ~~iomodel->Data(FlowequationBordermacayealEnum)[io_index]~~){
100		if(!~~iomodel->Data(MeshVertexonbedEnum)[io_index]~~){
	102	if (iomodel->Data(FlowequationVertexEquationEnum)[io_index]==MacAyealStokesApproximationEnum && reCast<int>(iomodel->Data(FlowequationBordermacayealEnum)[io_index])){
	103	if(!reCast<int>(iomodel->Data(MeshVertexonbedEnum)[io_index])){
101	104	for(k=1;k<=2;k++) this->FreezeDof(k);
102	105	}
…	…
114	117	/Diagnostic Hutter/
115	118	if (analysis_type==DiagnosticHutterAnalysisEnum){
116		~~if (!iomodel->Data(FlowequationVertexEquationEnum)) _error2_("iomodel->vertices_type is NULL"~~);
	119	_assert_(iomodel->Data(FlowequationVertexEquationEnum));
117	120	/Constrain all nodes that are not Hutter/
118	121	if (reCast<int>(iomodel->Data(FlowequationVertexEquationEnum)[io_index])!=HutterApproximationEnum){
…	…
230	233	return indexing.sdoflist[dofindex];
231	234	}
232		else _error2_("set of enum type " << EnumToStringx(setenum) << " not supported yet!");
	235	else _error_("set of enum type " << EnumToStringx(setenum) << " not supported yet!");
233	236
234	237	}
…	…
302	305	else for(i=0;i<this->indexing.ssize;i++) outdoflist[i]=indexing.sdoflist[i];
303	306	}
304		else _error2_("set of enum type " << EnumToStringx(setenum) << " not supported yet!");
	307	else _error_("set of enum type " << EnumToStringx(setenum) << " not supported yet!");
305	308	}
306	309	}
…	…
342	345	}
343	346	}
344		else _error2_("set of enum type " << EnumToStringx(setenum) << " not supported yet!");
	347	else _error_("set of enum type " << EnumToStringx(setenum) << " not supported yet!");
345	348	}
346	349	else{
…	…
411	414	}
412	415	}
413		else _error2_("set of enum type " << EnumToStringx(setenum) << " not supported yet!");
	416	else _error_("set of enum type " << EnumToStringx(setenum) << " not supported yet!");
414	417	}
415	418	}
…	…
597	600	else if (setenum==FsetEnum) numdofs=this->indexing.fsize;
598	601	else if (setenum==SsetEnum) numdofs=this->indexing.ssize;
599		else _error2_("set of enum type " << EnumToStringx(setenum) << " not supported yet!");
	602	else _error_("set of enum type " << EnumToStringx(setenum) << " not supported yet!");
600	603	}
601	604	else{
…	…
627	630	else numdofs=this->indexing.ssize;
628	631	}
629		else _error2_("set of enum type " << EnumToStringx(setenum) << " not supported yet!");
	632	else _error_("set of enum type " << EnumToStringx(setenum) << " not supported yet!");
630	633	}
631	634	return numdofs;
…	…
834	837	}
835	838	}
836		else _error2_("VecMerge can only merge from the s or f-set onto the g-set!");
	839	else _error_("VecMerge can only merge from the s or f-set onto the g-set!");
837	840
838	841	/Free ressources:/
…	…
880	883	}
881	884	}
882		else _error2_("VecReduce can only merge from the s or f-set onto the g-set!");
	885	else _error_("VecReduce can only merge from the s or f-set onto the g-set!");
883	886
884	887	/Free ressources:/
…	…
927	930	dofcount+=this->indexing.ssize;
928	931	}
929		else _error2_("set of enum type " << EnumToStringx(setenum) << " not supported yet!");
	932	else _error_("set of enum type " << EnumToStringx(setenum) << " not supported yet!");
930	933
931	934
…	…
956	959	for(i=0;i<this->indexing.ssize;i++) indexing.sdoflist[i]+=dofcount;
957	960	}
958		else _error2_("set of enum type " << EnumToStringx(setenum) << " not supported yet!");
	961	else _error_("set of enum type " << EnumToStringx(setenum) << " not supported yet!");
959	962	}
960	963	/}}}/
…	…
972	975	else if(setenum==FsetEnum)for(j=0;j<this->indexing.fsize;j++) (truedofs+ncolssid+j)=indexing.fdoflist[j];
973	976	else if(setenum==SsetEnum)for(j=0;j<this->indexing.ssize;j++) (truedofs+ncolssid+j)=indexing.sdoflist[j];
974		else _error2_("set of enum type " << EnumToStringx(setenum) << " not supported yet!");
	977	else _error_("set of enum type " << EnumToStringx(setenum) << " not supported yet!");
975	978
976	979	}
…	…
991	994	else if(setenum==FsetEnum)for(j=0;j<this->indexing.fsize;j++) indexing.fdoflist[j]=(alltruedofs+ncolssid+j);
992	995	else if(setenum==SsetEnum)for(j=0;j<this->indexing.ssize;j++) indexing.sdoflist[j]=(alltruedofs+ncolssid+j);
993		else _error2_("set of enum type " << EnumToStringx(setenum) << " not supported yet!");
	996	else _error_("set of enum type " << EnumToStringx(setenum) << " not supported yet!");
994	997
995	998	}

issm/branches/trunk-jpl-damage/src/c/classes/objects/Node.h

-              r12832
+              r13101
                 int   MyRank();
                 int   ObjectEnum();
                 Object* copy(){_error2_("Not implemented yet (similar to Elements)");};
+                Object* copy(){_error_("Not implemented yet (similar to Elements)");};
                 /*}}}*/
                 /*Update virtual functions definitions: {{{*/
 …
                 void  InputUpdateFromConstant(int constant, int name);
                 void  InputUpdateFromConstant(bool constant, int name);
                 void  InputUpdateFromSolution(IssmDouble* solution){_error2_("Not implemented yet!");}
                 void  InputUpdateFromIoModel(int index, IoModel* iomodel){_error2_("Not implemented yet!");}
+                void  InputUpdateFromSolution(IssmDouble* solution){_error_("Not implemented yet!");}
+                void  InputUpdateFromIoModel(int index, IoModel* iomodel){_error_("Not implemented yet!");}
                 /*}}}*/
                 /*Node numerical routines {{{*/

issm/branches/trunk-jpl-damage/src/c/classes/objects/Options/Option.h

-              r12832
+              r13101
                 virtual void  DeepEcho();
                 virtual void  DeepEcho(char* indent);
                 int   Id(){_error2_("Not implemented yet");};
                 int   MyRank(){_error2_("Not implemented yet");};
+                int   Id(){_error_("Not implemented yet");};
+                int   MyRank(){_error_("Not implemented yet");};
                 int   ObjectEnum(){return OptionEnum;};
                 Object* copy(){_error2_("Not implemented yet");};
+                Object* copy(){_error_("Not implemented yet");};
                 /*}}}*/

issm/branches/trunk-jpl-damage/src/c/classes/objects/Options/OptionCell.h

-              r12832
+              r13101
                 void  DeepEcho();
                 void  DeepEcho(char* indent);
                 int   Id(){_error2_("Not implemented yet");};
                 int   MyRank(){_error2_("Not implemented yet");};
+                int   Id(){_error_("Not implemented yet");};
+                int   MyRank(){_error_("Not implemented yet");};
                 int   ObjectEnum(){return OptionCellEnum;};
                 Object* copy(){_error2_("Not implemented yet");};
+                Object* copy(){_error_("Not implemented yet");};
                 /*}}}*/
 …
                 int   NDims();
                 int*  Size();
                 void  Get(int* pvalue){_error2_("An OptionCell object cannot return a int");};
                 void  Get(IssmDouble* pvalue){_error2_("An OptionCell object cannot return a IssmDouble");};
                 void  Get(bool* pvalue){  _error2_("An OptionCell object cannot return a bool");};
                 void  Get(char** pvalue){ _error2_("An OptionCell object cannot return a string");};
                 void  Get(char*** ppvalue,int *pnumel){ _error2_("An OptionCell object cannot return a string vec");};
                 void  Get(IssmDouble** pvalue,int *pnumel){ _error2_("An OptionCell object cannot return a IssmDouble vec");};
+                void  Get(int* pvalue){_error_("An OptionCell object cannot return a int");};
+                void  Get(IssmDouble* pvalue){_error_("An OptionCell object cannot return a IssmDouble");};
+                void  Get(bool* pvalue){  _error_("An OptionCell object cannot return a bool");};
+                void  Get(char** pvalue){ _error_("An OptionCell object cannot return a string");};
+                void  Get(char*** ppvalue,int *pnumel){ _error_("An OptionCell object cannot return a string vec");};
+                void  Get(IssmDouble** pvalue,int *pnumel){ _error_("An OptionCell object cannot return a IssmDouble vec");};
                 void  Get(Options** pvalue);
                 void  Get(Options*** ppvalue,int *pnumel){ _error2_("An OptionCell object cannot return an Options DataSet vec");};
+                void  Get(Options*** ppvalue,int *pnumel){ _error_("An OptionCell object cannot return an Options DataSet vec");};
 };

issm/branches/trunk-jpl-damage/src/c/classes/objects/Options/OptionChar.cpp

r12832	r13101
153	153	/We should first check that the size is at least one/
154	154	if(this->NumEl()<=0){
155		_error2_("option \"" << this->name << "\" is empty and cannot return a string vector");
	155	_error_("option \"" << this->name << "\" is empty and cannot return a string vector");
156	156	}
157	157

issm/branches/trunk-jpl-damage/src/c/classes/objects/Options/OptionChar.h

-              r12832
+              r13101
                 void  DeepEcho();
                 void  DeepEcho(char* indent);
                 int   Id(){_error2_("Not implemented yet");};
                 int   MyRank(){_error2_("Not implemented yet");};
+                int   Id(){_error_("Not implemented yet");};
+                int   MyRank(){_error_("Not implemented yet");};
                 int   ObjectEnum(){return OptionCharEnum;};
                 Object* copy(){_error2_("Not implemented yet");};
+                Object* copy(){_error_("Not implemented yet");};
                 /*}}}*/
 …
                 int   NDims();
                 int*  Size();
                 void  Get(int* pvalue){_error2_("An OptionChar object cannot return a int");};
                 void  Get(IssmDouble* pvalue){_error2_("An OptionChar object cannot return a IssmDouble");};
                 void  Get(bool* pvalue){  _error2_("An OptionChar object cannot return a bool");};
+                void  Get(int* pvalue){_error_("An OptionChar object cannot return a int");};
+                void  Get(IssmDouble* pvalue){_error_("An OptionChar object cannot return a IssmDouble");};
+                void  Get(bool* pvalue){  _error_("An OptionChar object cannot return a bool");};
                 void  Get(char** pvalue);
                 void  Get(char*** ppvalue,int *pnumel);
                 void  Get(IssmDouble** pvalue,int *pnumel){ _error2_("An OptionChar object cannot return a IssmDouble vec");};
                 void  Get(Options** pvalue){ _error2_("An OptionChar object cannot return an Options DataSet");};
                 void  Get(Options*** ppvalue,int *pnumel){ _error2_("An OptionChar object cannot return an Options DataSet vec");};
+                void  Get(IssmDouble** pvalue,int *pnumel){ _error_("An OptionChar object cannot return a IssmDouble vec");};
+                void  Get(Options** pvalue){ _error_("An OptionChar object cannot return an Options DataSet");};
+                void  Get(Options*** ppvalue,int *pnumel){ _error_("An OptionChar object cannot return an Options DataSet vec");};
 };

issm/branches/trunk-jpl-damage/src/c/classes/objects/Options/OptionDouble.cpp

-              r12832
+              r13101
         /*We should first check that the size is one*/
         if(this->NumEl()!=1){
                 _error2_("option \"" << this->name << "\" has " << this->NumEl() << " elements and cannot return a single int");
+                _error_("option \"" << this->name << "\" has " << this->NumEl() << " elements and cannot return a single int");
+        }
 …
         /*We should first check that the size is one*/
         if(this->NumEl()!=1){
                 _error2_("option \"" << this->name << "\" has " << this->NumEl() << " elements and cannot return a single IssmDouble");
+                _error_("option \"" << this->name << "\" has " << this->NumEl() << " elements and cannot return a single IssmDouble");
+        }
 …
         /*We should first check that the size is at least one*/
         if(this->NumEl()<=0){
                 _error2_("option \"" << this->name << "\" is empty and cannot return a IssmDouble vector");
+                _error_("option \"" << this->name << "\" is empty and cannot return a IssmDouble vector");
+        }

issm/branches/trunk-jpl-damage/src/c/classes/objects/Options/OptionDouble.h

-              r12832
+              r13101
                 void  DeepEcho();
                 void  DeepEcho(char* indent);
                 int   Id(){_error2_("Not implemented yet");};
                 int   MyRank(){_error2_("Not implemented yet");};
+                int   Id(){_error_("Not implemented yet");};
+                int   MyRank(){_error_("Not implemented yet");};
                 int   ObjectEnum(){return OptionDoubleEnum;};
                 Object* copy(){_error2_("Not implemented yet");};
+                Object* copy(){_error_("Not implemented yet");};
                 /*}}}*/
 …
                 void  Get(int* pvalue);
                 void  Get(IssmDouble* pvalue);
                 void  Get(bool* pvalue){  _error2_("An OptionDouble object cannot return a bool");};
                 void  Get(char** pvalue){ _error2_("An OptionDouble object cannot return a string");};
                 void  Get(char*** ppvalue,int *pnumel){ _error2_("An OptionDouble object cannot return a string vec");};
+                void  Get(bool* pvalue){  _error_("An OptionDouble object cannot return a bool");};
+                void  Get(char** pvalue){ _error_("An OptionDouble object cannot return a string");};
+                void  Get(char*** ppvalue,int *pnumel){ _error_("An OptionDouble object cannot return a string vec");};
                 void  Get(IssmDouble** pvalue,int* pnumel);
                 void  Get(Options** pvalue){ _error2_("An OptionDouble object cannot return an Options DataSet");};
                 void  Get(Options*** ppvalue,int *pnumel){ _error2_("An OptionDouble object cannot return an Options DataSet vec");};
+                void  Get(Options** pvalue){ _error_("An OptionDouble object cannot return an Options DataSet");};
+                void  Get(Options*** ppvalue,int *pnumel){ _error_("An OptionDouble object cannot return an Options DataSet vec");};
 };

issm/branches/trunk-jpl-damage/src/c/classes/objects/Options/OptionLogical.cpp

r12832	r13101
125	125	/We should first check that the size is one/
126	126	if(this->NumEl()!=1){
127		_error2_("option \"" << this->name << "\" has " << this->NumEl() << " elements and cannot return a single bool");
	127	_error_("option \"" << this->name << "\" has " << this->NumEl() << " elements and cannot return a single bool");
128	128	}
129	129

issm/branches/trunk-jpl-damage/src/c/classes/objects/Options/OptionLogical.h

-              r12832
+              r13101
                 void  DeepEcho();
                 void  DeepEcho(char* indent);
                 int   Id(){_error2_("Not implemented yet");};
                 int   MyRank(){_error2_("Not implemented yet");};
+                int   Id(){_error_("Not implemented yet");};
+                int   MyRank(){_error_("Not implemented yet");};
                 int   ObjectEnum(){return OptionLogicalEnum;};
                 Object* copy(){_error2_("Not implemented yet");};
+                Object* copy(){_error_("Not implemented yet");};
                 /*}}}*/
 …
                 int   NDims();
                 int*  Size();
                 void  Get(int* pvalue){_error2_("An OptionLogical object cannot return a int");};
                 void  Get(IssmDouble* pvalue){_error2_("An OptionLogical object cannot return a IssmDouble");};
+                void  Get(int* pvalue){_error_("An OptionLogical object cannot return a int");};
+                void  Get(IssmDouble* pvalue){_error_("An OptionLogical object cannot return a IssmDouble");};
                 void  Get(bool* pvalue);
                 void  Get(char** pvalue){ _error2_("An OptionLogical object cannot return a string");};
                 void  Get(char*** ppvalue,int *pnumel){ _error2_("An OptionLogical object cannot return a string vec");};
                 void  Get(IssmDouble** pvalue,int *pnumel){ _error2_("An OptionLogical object cannot return a IssmDouble vec");};
                 void  Get(Options** pvalue){ _error2_("An OptionLogical object cannot return an Options DataSet");};
                 void  Get(Options*** ppvalue,int *pnumel){ _error2_("An OptionLogical object cannot return an Options DataSet vec");};
+                void  Get(char** pvalue){ _error_("An OptionLogical object cannot return a string");};
+                void  Get(char*** ppvalue,int *pnumel){ _error_("An OptionLogical object cannot return a string vec");};
+                void  Get(IssmDouble** pvalue,int *pnumel){ _error_("An OptionLogical object cannot return a IssmDouble vec");};
+                void  Get(Options** pvalue){ _error_("An OptionLogical object cannot return an Options DataSet");};
+                void  Get(Options*** ppvalue,int *pnumel){ _error_("An OptionLogical object cannot return an Options DataSet vec");};
 };

issm/branches/trunk-jpl-damage/src/c/classes/objects/Options/OptionStruct.cpp

-              r12832
+              r13101
         /*We should first check that the size is one*/
         if(this->NumEl()!=1){
                 _error2_("option \"" << this->name << "\" has " << this->NumEl() << " elements and cannot return a single options dataset");
+                _error_("option \"" << this->name << "\" has " << this->NumEl() << " elements and cannot return a single options dataset");
+        }
 …
         /*We should first check that the size is at least one*/
         if(this->NumEl()<=0){
                 _error2_("option \"" << this->name << "\" is empty and cannot return an options dataset vector");
+                _error_("option \"" << this->name << "\" is empty and cannot return an options dataset vector");
+        }

issm/branches/trunk-jpl-damage/src/c/classes/objects/Options/OptionStruct.h

-              r12832
+              r13101
                 void  DeepEcho();
                 void  DeepEcho(char* indent);
                 int   Id(){_error2_("Not implemented yet");};
                 int   MyRank(){_error2_("Not implemented yet");};
+                int   Id(){_error_("Not implemented yet");};
+                int   MyRank(){_error_("Not implemented yet");};
                 int   ObjectEnum(){return OptionStructEnum;};
                 Object* copy(){_error2_("Not implemented yet");};
+                Object* copy(){_error_("Not implemented yet");};
                 /*}}}*/
 …
                 int   NDims();
                 int*  Size();
                 void  Get(int* pvalue){_error2_("An OptionStruct object cannot return a int");};
                 void  Get(IssmDouble* pvalue){_error2_("An OptionStruct object cannot return a IssmDouble");};
                 void  Get(bool* pvalue){  _error2_("An OptionStruct object cannot return a bool");};
                 void  Get(char** pvalue){ _error2_("An OptionStruct object cannot return a string");};
                 void  Get(char*** ppvalue,int *pnumel){ _error2_("An OptionStruct object cannot return a string vec");};
                 void  Get(IssmDouble** pvalue,int *pnumel){ _error2_("An OptionStruct object cannot return a IssmDouble vec");};
+                void  Get(int* pvalue){_error_("An OptionStruct object cannot return a int");};
+                void  Get(IssmDouble* pvalue){_error_("An OptionStruct object cannot return a IssmDouble");};
+                void  Get(bool* pvalue){  _error_("An OptionStruct object cannot return a bool");};
+                void  Get(char** pvalue){ _error_("An OptionStruct object cannot return a string");};
+                void  Get(char*** ppvalue,int *pnumel){ _error_("An OptionStruct object cannot return a string vec");};
+                void  Get(IssmDouble** pvalue,int *pnumel){ _error_("An OptionStruct object cannot return a IssmDouble vec");};
                 void  Get(Options** pvalue);
                 void  Get(Options*** ppvalue,int *pnumel);

issm/branches/trunk-jpl-damage/src/c/classes/objects/Options/OptionUtilities.cpp

-              r12832
+              r13101
         /*check for index too large  */
         for (i=0;i<ndims;i++) aprod*=size[i];
         if (index >= aprod) _error2_("Index " << index << " exceeds number of elements " << aprod << ".");
+        if (index >= aprod) _error_("Index " << index << " exceeds number of elements " << aprod << ".");
         /*calculate the dimensions (being careful of integer division)  */
 …
         /*check for any dimension too large  */
         for (i=0;i<ndims;i++){
                 if (dims[i] >= size[i]) _error2_("Dimension " << i << " of " << dims[i] << " exceeds size of " << size[i] << ".");
+                if (dims[i] >= size[i]) _error_("Dimension " << i << " of " << dims[i] << " exceeds size of " << size[i] << ".");
+        }
 …
         /*check for index too large  */
         for (i=0; i<ndims; i++) aprod*=size[i];
         if (index >= aprod) _error2_("Index " << index << " exceeds number of elements " << aprod << ".");
+        if (index >= aprod) _error_("Index " << index << " exceeds number of elements " << aprod << ".");
         /*calculate the dimensions (being careful of integer division)  */
 …
         /*check for any dimension too large  */
         for (i=0; i<ndims; i++){
                 if (dims[i] >= size[i]) _error2_("Dimension " << i << " of " << dims[i] << " exceeds size of " << size[i] << ".");
+                if (dims[i] >= size[i]) _error_("Dimension " << i << " of " << dims[i] << " exceeds size of " << size[i] << ".");
+        }

issm/branches/trunk-jpl-damage/src/c/classes/objects/Params/BoolParam.h

-              r12832
+              r13101
                 int   InstanceEnum(){return enum_type;}
                 void  GetParameterValue(bool* pbool){*pbool=value;}
                 void  GetParameterValue(int* pinteger){_error2_("Param "<< EnumToStringx(enum_type) << ") cannot return an integer");}
                 void  GetParameterValue(int** pintarray,int* pM){_error2_("Param "<< EnumToStringx(enum_type) << ") cannot return an array of integers");}
                 void  GetParameterValue(int** pintarray,int* pM,int* pN){_error2_("Param "<< EnumToStringx(enum_type) << ") cannot return an array of integers");}
                 void  GetParameterValue(IssmDouble* pIssmDouble){_error2_("Param "<< EnumToStringx(enum_type) << ") cannot return a IssmDouble");}
                 void  GetParameterValue(IssmDouble* pdouble,IssmDouble time){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble for a given time");}
                 void  GetParameterValue(char** pstring){_error2_("Param "<< EnumToStringx(enum_type) << ") cannot return a string");}
                 void  GetParameterValue(char*** pstringarray,int* pM){_error2_("Param "<< EnumToStringx(enum_type) << ") cannot return a string array");}
                 void  GetParameterValue(IssmDouble** pIssmDoublearray,int* pM){_error2_("Param "<< EnumToStringx(enum_type) << ") cannot return a IssmDouble array");}
                 void  GetParameterValue(IssmDouble** pIssmDoublearray,int* pM, int* pN){_error2_("Param "<< EnumToStringx(enum_type) << ") cannot return a IssmDouble array");}
                 void  GetParameterValue(IssmDouble*** parray, int* pM,int** pmdims, int** pndims){_error2_("Param "<< EnumToStringx(enum_type) << ") cannot return a matrix array");}
                 void  GetParameterValue(Vector** pvec){_error2_("Param "<< EnumToStringx(enum_type) << ") cannot return a Vec");}
                 void  GetParameterValue(Matrix** pmat){_error2_("Param "<< EnumToStringx(enum_type) << ") cannot return a Mat");}
                 void  GetParameterValue(FILE** pfid){_error2_("Param "<< EnumToStringx(enum_type) << ") cannot return a FILE");}
+                void  GetParameterValue(int* pinteger){_error_("Param "<< EnumToStringx(enum_type) << ") cannot return an integer");}
+                void  GetParameterValue(int** pintarray,int* pM){_error_("Param "<< EnumToStringx(enum_type) << ") cannot return an array of integers");}
+                void  GetParameterValue(int** pintarray,int* pM,int* pN){_error_("Param "<< EnumToStringx(enum_type) << ") cannot return an array of integers");}
+                void  GetParameterValue(IssmDouble* pIssmDouble){_error_("Param "<< EnumToStringx(enum_type) << ") cannot return a IssmDouble");}
+                void  GetParameterValue(IssmDouble* pdouble,IssmDouble time){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble for a given time");}
+                void  GetParameterValue(char** pstring){_error_("Param "<< EnumToStringx(enum_type) << ") cannot return a string");}
+                void  GetParameterValue(char*** pstringarray,int* pM){_error_("Param "<< EnumToStringx(enum_type) << ") cannot return a string array");}
+                void  GetParameterValue(IssmDouble** pIssmDoublearray,int* pM){_error_("Param "<< EnumToStringx(enum_type) << ") cannot return a IssmDouble array");}
+                void  GetParameterValue(IssmDouble** pIssmDoublearray,int* pM, int* pN){_error_("Param "<< EnumToStringx(enum_type) << ") cannot return a IssmDouble array");}
+                void  GetParameterValue(IssmDouble*** parray, int* pM,int** pmdims, int** pndims){_error_("Param "<< EnumToStringx(enum_type) << ") cannot return a matrix array");}
+                void  GetParameterValue(Vector** pvec){_error_("Param "<< EnumToStringx(enum_type) << ") cannot return a Vec");}
+                void  GetParameterValue(Matrix** pmat){_error_("Param "<< EnumToStringx(enum_type) << ") cannot return a Mat");}
+                void  GetParameterValue(FILE** pfid){_error_("Param "<< EnumToStringx(enum_type) << ") cannot return a FILE");}
                 void  SetValue(bool boolean){this->value=boolean;}
                 void  SetValue(int integer){_error2_("Param "<< EnumToStringx(enum_type) << ") cannot hold an int");}
                 void  SetValue(IssmDouble scalar){_error2_("Param "<< EnumToStringx(enum_type) << ") cannot hold an IssmPDouble");}
                 void  SetValue(char* string){_error2_("Param "<< EnumToStringx(enum_type) << ") cannot hold a string");}
                 void  SetValue(char** stringarray,int M){_error2_("Param "<< EnumToStringx(enum_type) << ") cannot hold a string array");}
                 void  SetValue(IssmDouble* IssmDoublearray,int M){_error2_("Param "<< EnumToStringx(enum_type) << ") cannot hold a IssmDouble array");}
                 void  SetValue(IssmDouble* pIssmDoublearray,int M,int N){_error2_("Param "<< EnumToStringx(enum_type) << ") cannot hold a IssmDouble array");}
                 void  SetValue(int* intarray,int M){_error2_("Param "<< EnumToStringx(enum_type) << ") cannot hold a int array");}
                 void  SetValue(int* pintarray,int M,int N){_error2_("Param "<< EnumToStringx(enum_type) << ") cannot hold a int array");}
                 void  SetValue(Vector* vec){_error2_("Param "<< EnumToStringx(enum_type) << ") cannot hold a Vec");}
                 void  SetValue(Matrix* mat){_error2_("Param "<< EnumToStringx(enum_type) << ") cannot hold a Mat");}
                 void  SetValue(FILE* fid){_error2_("Param "<< EnumToStringx(enum_type) << ") cannot hold a FILE");}
                 void  SetValue(IssmDouble** array, int M, int* mdim_array, int* ndim_array){_error2_("Param "<< EnumToStringx(enum_type) << ") cannot hold an array of matrices");}
+                void  SetValue(int integer){_error_("Param "<< EnumToStringx(enum_type) << ") cannot hold an int");}
+                void  SetValue(IssmDouble scalar){_error_("Param "<< EnumToStringx(enum_type) << ") cannot hold an IssmPDouble");}
+                void  SetValue(char* string){_error_("Param "<< EnumToStringx(enum_type) << ") cannot hold a string");}
+                void  SetValue(char** stringarray,int M){_error_("Param "<< EnumToStringx(enum_type) << ") cannot hold a string array");}
+                void  SetValue(IssmDouble* IssmDoublearray,int M){_error_("Param "<< EnumToStringx(enum_type) << ") cannot hold a IssmDouble array");}
+                void  SetValue(IssmDouble* pIssmDoublearray,int M,int N){_error_("Param "<< EnumToStringx(enum_type) << ") cannot hold a IssmDouble array");}
+                void  SetValue(int* intarray,int M){_error_("Param "<< EnumToStringx(enum_type) << ") cannot hold a int array");}
+                void  SetValue(int* pintarray,int M,int N){_error_("Param "<< EnumToStringx(enum_type) << ") cannot hold a int array");}
+                void  SetValue(Vector* vec){_error_("Param "<< EnumToStringx(enum_type) << ") cannot hold a Vec");}
+                void  SetValue(Matrix* mat){_error_("Param "<< EnumToStringx(enum_type) << ") cannot hold a Mat");}
+                void  SetValue(FILE* fid){_error_("Param "<< EnumToStringx(enum_type) << ") cannot hold a FILE");}
+                void  SetValue(IssmDouble** array, int M, int* mdim_array, int* ndim_array){_error_("Param "<< EnumToStringx(enum_type) << ") cannot hold an array of matrices");}
                 void  UnitConversion(int direction_enum);

issm/branches/trunk-jpl-damage/src/c/classes/objects/Params/DoubleMatArrayParam.h

-              r12832
+              r13101
                 /*Param vritual function definitions: {{{*/
                 int   InstanceEnum(){return enum_type;}
                 void  GetParameterValue(bool* pbool){_error2_("Param "<< EnumToStringx(enum_type) << "cannot return a bool");}
                 void  GetParameterValue(int* pinteger){_error2_("Param "<< EnumToStringx(enum_type) << "cannot return an integer");}
                 void  GetParameterValue(int** pintarray,int* pM){_error2_("Param "<< EnumToStringx(enum_type) << "cannot return an array of integers");}
                 void  GetParameterValue(int** pintarray,int* pM,int* pN){_error2_("Param "<< EnumToStringx(enum_type) << "cannot return an array of integers");}
                 void  GetParameterValue(IssmDouble* pIssmDouble){_error2_("Param "<< EnumToStringx(enum_type) << "cannot return a IssmDouble");}
                 void  GetParameterValue(IssmDouble* pdouble,IssmDouble time){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble for a given time");}
                 void  GetParameterValue(char** pstring){_error2_("Param "<< EnumToStringx(enum_type) << "cannot return a string");}
                 void  GetParameterValue(char*** pstringarray,int* pM){_error2_("Param "<< EnumToStringx(enum_type) << "cannot return a string array");}
                 void  GetParameterValue(IssmDouble** pIssmDoublearray,int* pM){_error2_("Param "<< EnumToStringx(enum_type) << "cannot return a IssmDouble array");}
                 void  GetParameterValue(IssmDouble** pIssmDoublearray,int* pM, int* pN){_error2_("Param "<< EnumToStringx(enum_type) << "cannot return a IssmDouble array");}
+                void  GetParameterValue(bool* pbool){_error_("Param "<< EnumToStringx(enum_type) << "cannot return a bool");}
+                void  GetParameterValue(int* pinteger){_error_("Param "<< EnumToStringx(enum_type) << "cannot return an integer");}
+                void  GetParameterValue(int** pintarray,int* pM){_error_("Param "<< EnumToStringx(enum_type) << "cannot return an array of integers");}
+                void  GetParameterValue(int** pintarray,int* pM,int* pN){_error_("Param "<< EnumToStringx(enum_type) << "cannot return an array of integers");}
+                void  GetParameterValue(IssmDouble* pIssmDouble){_error_("Param "<< EnumToStringx(enum_type) << "cannot return a IssmDouble");}
+                void  GetParameterValue(IssmDouble* pdouble,IssmDouble time){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble for a given time");}
+                void  GetParameterValue(char** pstring){_error_("Param "<< EnumToStringx(enum_type) << "cannot return a string");}
+                void  GetParameterValue(char*** pstringarray,int* pM){_error_("Param "<< EnumToStringx(enum_type) << "cannot return a string array");}
+                void  GetParameterValue(IssmDouble** pIssmDoublearray,int* pM){_error_("Param "<< EnumToStringx(enum_type) << "cannot return a IssmDouble array");}
+                void  GetParameterValue(IssmDouble** pIssmDoublearray,int* pM, int* pN){_error_("Param "<< EnumToStringx(enum_type) << "cannot return a IssmDouble array");}
                 void  GetParameterValue(IssmDouble*** parray, int* pM,int** pmdims, int** pndims);
                 void  GetParameterValue(Vector** pvec){_error2_("Param "<< EnumToStringx(enum_type) << "cannot return a Vec");}
                 void  GetParameterValue(Matrix** pmat){_error2_("Param "<< EnumToStringx(enum_type) << "cannot return a Mat");}
                 void  GetParameterValue(FILE** pfid){_error2_("Param "<< EnumToStringx(enum_type) << "cannot return a FILE");}
+                void  GetParameterValue(Vector** pvec){_error_("Param "<< EnumToStringx(enum_type) << "cannot return a Vec");}
+                void  GetParameterValue(Matrix** pmat){_error_("Param "<< EnumToStringx(enum_type) << "cannot return a Mat");}
+                void  GetParameterValue(FILE** pfid){_error_("Param "<< EnumToStringx(enum_type) << "cannot return a FILE");}
                 void  SetValue(bool boolean){_error2_("Param "<< EnumToStringx(enum_type) << "cannot hold a boolean");}
                 void  SetValue(int integer){_error2_("Param "<< EnumToStringx(enum_type) << "cannot hold an integer");}
                 void  SetValue(IssmDouble scalar){_error2_("Param "<< EnumToStringx(enum_type) << "cannot hold a scalar");}
                 void  SetValue(char* string){_error2_("Param "<< EnumToStringx(enum_type) << "cannot hold a string");}
                 void  SetValue(char** stringarray,int M){_error2_("Param "<< EnumToStringx(enum_type) << "cannot hold a string array");}
                 void  SetValue(IssmDouble* IssmDoublearray,int M){_error2_("Param "<< EnumToStringx(enum_type) << "cannot hold a IssmDouble vec array");}
                 void  SetValue(IssmDouble* IssmDoublearray,int M,int N){_error2_("Param "<< EnumToStringx(enum_type) << "cannot hold a IssmDouble mat array");}
                 void  SetValue(int* intarray,int M){_error2_("Param "<< EnumToStringx(enum_type) << "cannot hold a int vec array");}
                 void  SetValue(int* intarray,int M,int N){_error2_("Param "<< EnumToStringx(enum_type) << "cannot hold a int mat array");}
                 void  SetValue(Vector* vec){_error2_("Param "<< EnumToStringx(enum_type) << "cannot hold a Vec");}
                 void  SetValue(Matrix* mat){_error2_("Param "<< EnumToStringx(enum_type) << "cannot hold a Mat");}
                 void  SetValue(FILE* fid){_error2_("Bool param of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot hold a FILE");}
+                void  SetValue(bool boolean){_error_("Param "<< EnumToStringx(enum_type) << "cannot hold a boolean");}
+                void  SetValue(int integer){_error_("Param "<< EnumToStringx(enum_type) << "cannot hold an integer");}
+                void  SetValue(IssmDouble scalar){_error_("Param "<< EnumToStringx(enum_type) << "cannot hold a scalar");}
+                void  SetValue(char* string){_error_("Param "<< EnumToStringx(enum_type) << "cannot hold a string");}
+                void  SetValue(char** stringarray,int M){_error_("Param "<< EnumToStringx(enum_type) << "cannot hold a string array");}
+                void  SetValue(IssmDouble* IssmDoublearray,int M){_error_("Param "<< EnumToStringx(enum_type) << "cannot hold a IssmDouble vec array");}
+                void  SetValue(IssmDouble* IssmDoublearray,int M,int N){_error_("Param "<< EnumToStringx(enum_type) << "cannot hold a IssmDouble mat array");}
+                void  SetValue(int* intarray,int M){_error_("Param "<< EnumToStringx(enum_type) << "cannot hold a int vec array");}
+                void  SetValue(int* intarray,int M,int N){_error_("Param "<< EnumToStringx(enum_type) << "cannot hold a int mat array");}
+                void  SetValue(Vector* vec){_error_("Param "<< EnumToStringx(enum_type) << "cannot hold a Vec");}
+                void  SetValue(Matrix* mat){_error_("Param "<< EnumToStringx(enum_type) << "cannot hold a Mat");}
+                void  SetValue(FILE* fid){_error_("Bool param of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot hold a FILE");}
                 void  SetValue(IssmDouble** array, int M, int* mdim_array, int* ndim_array);
                 void  UnitConversion(int direction_enum);

issm/branches/trunk-jpl-damage/src/c/classes/objects/Params/DoubleMatParam.cpp

r12832	r13101
109	109	/FUNCTION DoubleMatParam::GetParameterValue(int* pintarray,int* pM,int* pN){{{*/
110	110	void DoubleMatParam::GetParameterValue(int** pintarray,int* pM,int* pN){
111		_error2_("DoubleMat of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot return an array of int");
	111	_error_("DoubleMat of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot return an array of int");
112	112	}
113	113	/}}}/

issm/branches/trunk-jpl-damage/src/c/classes/objects/Params/DoubleMatParam.h

-              r12832
+              r13101
                 /*Param vritual function definitions: {{{*/
                 int   InstanceEnum(){return enum_type;}
                 void  GetParameterValue(bool* pbool){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a bool");}
                 void  GetParameterValue(int* pinteger){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return an integer");}
                 void  GetParameterValue(int** pintarray,int* pM){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return an array of integers");}
+                void  GetParameterValue(bool* pbool){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a bool");}
+                void  GetParameterValue(int* pinteger){_error_("Param "<< EnumToStringx(enum_type) << " cannot return an integer");}
+                void  GetParameterValue(int** pintarray,int* pM){_error_("Param "<< EnumToStringx(enum_type) << " cannot return an array of integers");}
                 void  GetParameterValue(int** pintarray,int* pM,int* pN);
                 void  GetParameterValue(IssmDouble* pIssmDouble){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble");}
                 void  GetParameterValue(IssmDouble* pdouble,IssmDouble time){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble for a given time");}
                 void  GetParameterValue(char** pstring){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a string");}
                 void  GetParameterValue(char*** pstringarray,int* pM){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a string array");}
                 void  GetParameterValue(IssmDouble** pIssmDoublearray,int* pM){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble array");}
+                void  GetParameterValue(IssmDouble* pIssmDouble){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble");}
+                void  GetParameterValue(IssmDouble* pdouble,IssmDouble time){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble for a given time");}
+                void  GetParameterValue(char** pstring){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a string");}
+                void  GetParameterValue(char*** pstringarray,int* pM){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a string array");}
+                void  GetParameterValue(IssmDouble** pIssmDoublearray,int* pM){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble array");}
                 void  GetParameterValue(IssmDouble** pIssmDoublearray,int* pM,int* pN);
                 void  GetParameterValue(IssmDouble*** parray, int* pM,int** pmdims, int** pndims){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a matrix array");}
                 void  GetParameterValue(Vector** pvec){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a Vec");}
                 void  GetParameterValue(Matrix** pmat){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a Mat");}
                 void  GetParameterValue(FILE** pfid){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a FILE");}
+                void  GetParameterValue(IssmDouble*** parray, int* pM,int** pmdims, int** pndims){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a matrix array");}
+                void  GetParameterValue(Vector** pvec){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a Vec");}
+                void  GetParameterValue(Matrix** pmat){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a Mat");}
+                void  GetParameterValue(FILE** pfid){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a FILE");}
                 void  SetValue(bool boolean){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a boolean");}
                 void  SetValue(int integer){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold an integer");}
                 void  SetValue(IssmDouble scalar){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a scalar");}
                 void  SetValue(char* string){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a string");}
                 void  SetValue(char** stringarray,int M){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a string array");}
                 void  SetValue(IssmDouble* IssmDoublearray,int M){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a IssmDouble vec array");}
+                void  SetValue(bool boolean){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a boolean");}
+                void  SetValue(int integer){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold an integer");}
+                void  SetValue(IssmDouble scalar){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a scalar");}
+                void  SetValue(char* string){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a string");}
+                void  SetValue(char** stringarray,int M){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a string array");}
+                void  SetValue(IssmDouble* IssmDoublearray,int M){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a IssmDouble vec array");}
                 void  SetValue(IssmDouble* IssmDoublearray,int M,int N);
                 void  SetValue(int* intarray,int M){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a int vec array");}
                 void  SetValue(int* intarray,int M,int N){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a int mat array");};
                 void  SetValue(Vector* vec){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a Vec");}
                 void  SetValue(Matrix* mat){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a Mat");}
                 void  SetValue(FILE* fid){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a FILE");}
                 void  SetValue(IssmDouble** array, int M, int* mdim_array, int* ndim_array){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold an array of matrices");}
+                void  SetValue(int* intarray,int M){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a int vec array");}
+                void  SetValue(int* intarray,int M,int N){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a int mat array");};
+                void  SetValue(Vector* vec){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a Vec");}
+                void  SetValue(Matrix* mat){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a Mat");}
+                void  SetValue(FILE* fid){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a FILE");}
+                void  SetValue(IssmDouble** array, int M, int* mdim_array, int* ndim_array){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold an array of matrices");}
                 void  UnitConversion(int direction_enum);

issm/branches/trunk-jpl-damage/src/c/classes/objects/Params/DoubleParam.cpp

-              r12832
+              r13101
 /*FUNCTION DoubleParam::GetParameterValue(int* pinteger){{{*/
 void DoubleParam::GetParameterValue(int* pinteger){
         _error2_("Double param of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot return an integer");
+        _error_("Double param of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot return an integer");
+}
 /*}}}*/
 /*FUNCTION DoubleParam::GetParameterValue(bool* pbool){{{*/
 void DoubleParam::GetParameterValue(bool* pbool){
         _error2_("Double param of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot return an bool");
+        _error_("Double param of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot return an bool");
+}
 /*}}}*/
 /*FUNCTION DoubleParam::GetParameterValue(int** pintarray,int* pM){{{*/
 void DoubleParam::GetParameterValue(int** pintarray,int* pM){
         _error2_("Double param of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot return an array of integers");
+        _error_("Double param of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot return an array of integers");
+}
 /*}}}*/
 /*FUNCTION DoubleParam::GetParameterValue(int** pintarray,int* pM,int* pN){{{*/
 void DoubleParam::GetParameterValue(int** pintarray,int* pM,int* pN){
         _error2_("Double param of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot return an array of integers");
+        _error_("Double param of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot return an array of integers");
+}
 /*}}}*/
 /*FUNCTION DoubleParam::GetParameterValue(IssmDouble** pIssmDoublearray,int* pM){{{*/
 void DoubleParam::GetParameterValue(IssmDouble** pIssmDoublearray,int* pM){
         _error2_("Double param of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot return an array of IssmDouble");
+        _error_("Double param of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot return an array of IssmDouble");
+}
 /*}}}*/
 /*FUNCTION DoubleParam::GetParameterValue(IssmDouble** pIssmDoublearray,int* pM,int* pN){{{*/
 void DoubleParam::GetParameterValue(IssmDouble** pIssmDoublearray,int* pM,int* pN){
         _error2_("Double param of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot return an array of IssmDouble");
+        _error_("Double param of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot return an array of IssmDouble");
+}
 /*}}}*/

issm/branches/trunk-jpl-damage/src/c/classes/objects/Params/DoubleParam.h

-              r12832
+              r13101
                 void  GetParameterValue(int** pintarray,int* pM,int* pN);
                 void  GetParameterValue(IssmDouble* pIssmDouble){*pIssmDouble=value;}
                 void  GetParameterValue(char** pstring){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a string");}
                 void  GetParameterValue(IssmDouble* pdouble,IssmDouble time){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble for a given time");}
                 void  GetParameterValue(char*** pstringarray,int* pM){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a string array");}
+                void  GetParameterValue(char** pstring){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a string");}
+                void  GetParameterValue(IssmDouble* pdouble,IssmDouble time){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble for a given time");}
+                void  GetParameterValue(char*** pstringarray,int* pM){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a string array");}
                 void  GetParameterValue(IssmDouble** pIssmDoublearray,int* pM);
                 void  GetParameterValue(IssmDouble** pIssmDoublearray,int* pM, int* pN);
                 void  GetParameterValue(IssmDouble*** parray, int* pM,int** pmdims, int** pndims){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a matrix array");}
                 void  GetParameterValue(Vector** pvec){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a Vec");}
                 void  GetParameterValue(Matrix** pmat){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a Mat");}
                 void  GetParameterValue(FILE** pfid){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a FILE");}
+                void  GetParameterValue(IssmDouble*** parray, int* pM,int** pmdims, int** pndims){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a matrix array");}
+                void  GetParameterValue(Vector** pvec){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a Vec");}
+                void  GetParameterValue(Matrix** pmat){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a Mat");}
+                void  GetParameterValue(FILE** pfid){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a FILE");}
                 void  SetValue(bool boolean){this->value=(IssmDouble)boolean;}
                 void  SetValue(int integer){this->value=(IssmDouble)integer;}
                 void  SetValue(IssmDouble scalar){this->value=(IssmDouble)scalar;}
                 void  SetValue(char* string){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a string");}
                 void  SetValue(char** stringarray,int M){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a string array");}
                 void  SetValue(IssmDouble* IssmDoublearray,int M){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a IssmDouble array");}
                 void  SetValue(IssmDouble* pIssmDoublearray,int M,int N){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a IssmDouble array");}
                 void  SetValue(int* intarray,int M){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a int array");}
                 void  SetValue(int* pintarray,int M,int N){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a int array");}
                 void  SetValue(Vector* vec){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a Vec");}
                 void  SetValue(Matrix* mat){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a Mat");}
                 void  SetValue(FILE* fid){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a FILE");}
                 void  SetValue(IssmDouble** array, int M, int* mdim_array, int* ndim_array){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold an array of matrices");}
+                void  SetValue(char* string){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a string");}
+                void  SetValue(char** stringarray,int M){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a string array");}
+                void  SetValue(IssmDouble* IssmDoublearray,int M){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a IssmDouble array");}
+                void  SetValue(IssmDouble* pIssmDoublearray,int M,int N){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a IssmDouble array");}
+                void  SetValue(int* intarray,int M){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a int array");}
+                void  SetValue(int* pintarray,int M,int N){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a int array");}
+                void  SetValue(Vector* vec){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a Vec");}
+                void  SetValue(Matrix* mat){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a Mat");}
+                void  SetValue(FILE* fid){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a FILE");}
+                void  SetValue(IssmDouble** array, int M, int* mdim_array, int* ndim_array){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold an array of matrices");}
                 void  UnitConversion(int direction_enum);

issm/branches/trunk-jpl-damage/src/c/classes/objects/Params/DoubleVecParam.cpp

r12832	r13101
124	124	/FUNCTION DoubleVecParam::GetParameterValue(int* pintarray,int* pM){{{*/
125	125	void DoubleVecParam::GetParameterValue(int** pintarray,int* pM){
126		_error2_("DoubleVec param of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot return an array of int");
	126	_error_("DoubleVec param of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot return an array of int");
127	127	}
128	128	/}}}/

issm/branches/trunk-jpl-damage/src/c/classes/objects/Params/DoubleVecParam.h

-              r12832
+              r13101
                 /*Param virtual functions definitions: {{{*/
                 int   InstanceEnum(){return enum_type;}
                 void  GetParameterValue(bool* pbool){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a bool");}
                 void  GetParameterValue(int* pinteger){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return an integer");}
+                void  GetParameterValue(bool* pbool){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a bool");}
+                void  GetParameterValue(int* pinteger){_error_("Param "<< EnumToStringx(enum_type) << " cannot return an integer");}
                 void  GetParameterValue(int** pintarray,int* pM);
                 void  GetParameterValue(int** pintarray,int* pM,int* pN){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return an array of integers");};
                 void  GetParameterValue(IssmDouble* pIssmDouble){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble");}
                 void  GetParameterValue(IssmDouble* pdouble,IssmDouble time){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble for a given time");}
                 void  GetParameterValue(char** pstring){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a string");}
                 void  GetParameterValue(char*** pstringarray,int* pM){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a string array");}
+                void  GetParameterValue(int** pintarray,int* pM,int* pN){_error_("Param "<< EnumToStringx(enum_type) << " cannot return an array of integers");};
+                void  GetParameterValue(IssmDouble* pIssmDouble){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble");}
+                void  GetParameterValue(IssmDouble* pdouble,IssmDouble time){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble for a given time");}
+                void  GetParameterValue(char** pstring){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a string");}
+                void  GetParameterValue(char*** pstringarray,int* pM){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a string array");}
                 void  GetParameterValue(IssmDouble** pIssmDoublearray,int* pM);
                 void  GetParameterValue(IssmDouble** pIssmDoublearray,int* pM, int* pN);
                 void  GetParameterValue(IssmDouble*** parray, int* pM,int** pmdims, int** pndims){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a matrix array");}
                 void  GetParameterValue(Vector** pvec){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a Vec");}
                 void  GetParameterValue(Matrix** pmat){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a Mat");}
                 void  GetParameterValue(FILE** pfid){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a FILE");}
+                void  GetParameterValue(IssmDouble*** parray, int* pM,int** pmdims, int** pndims){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a matrix array");}
+                void  GetParameterValue(Vector** pvec){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a Vec");}
+                void  GetParameterValue(Matrix** pmat){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a Mat");}
+                void  GetParameterValue(FILE** pfid){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a FILE");}
                 void  SetValue(bool boolean){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a boolean");}
                 void  SetValue(int integer){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold an integer");}
                 void  SetValue(IssmDouble scalar){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a scalar");}
                 void  SetValue(char* string){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a string");}
                 void  SetValue(char** stringarray,int M){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a string array");}
+                void  SetValue(bool boolean){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a boolean");}
+                void  SetValue(int integer){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold an integer");}
+                void  SetValue(IssmDouble scalar){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a scalar");}
+                void  SetValue(char* string){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a string");}
+                void  SetValue(char** stringarray,int M){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a string array");}
                 void  SetValue(IssmDouble* IssmDoublearray,int M);
                 void  SetValue(IssmDouble* pIssmDoublearray,int M,int N){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a IssmDouble mat array");}
                 void  SetValue(int* intarray,int M){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a int mat array");};
                 void  SetValue(int* pintarray,int M,int N){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a int mat array");}
                 void  SetValue(Vector* vec){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a Vec");}
                 void  SetValue(Matrix* mat){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a Mat");}
                 void  SetValue(FILE* fid){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a FILE");}
                 void  SetValue(IssmDouble** array, int M, int* mdim_array, int* ndim_array){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold an array of matrices");}
+                void  SetValue(IssmDouble* pIssmDoublearray,int M,int N){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a IssmDouble mat array");}
+                void  SetValue(int* intarray,int M){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a int mat array");};
+                void  SetValue(int* pintarray,int M,int N){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a int mat array");}
+                void  SetValue(Vector* vec){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a Vec");}
+                void  SetValue(Matrix* mat){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a Mat");}
+                void  SetValue(FILE* fid){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a FILE");}
+                void  SetValue(IssmDouble** array, int M, int* mdim_array, int* ndim_array){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold an array of matrices");}
                 void  UnitConversion(int direction_enum);

issm/branches/trunk-jpl-damage/src/c/classes/objects/Params/FileParam.h

-              r12832
+              r13101
                 /*Param vritual function definitions: {{{*/
                 int   InstanceEnum(){return enum_type;}
                 void  GetParameterValue(bool* pbool){  _error2_("Param "<< EnumToStringx(enum_type) << " cannot return a bool");}
                 void  GetParameterValue(int* pinteger){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble");}
                 void  GetParameterValue(int** pintarray,int* pM){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble");}
                 void  GetParameterValue(int** pintarray,int* pM,int* pN){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble");}
                 void  GetParameterValue(IssmDouble* pIssmDouble){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble");}
                 void  GetParameterValue(IssmDouble* pdouble,IssmDouble time){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble for a given time");}
                 void  GetParameterValue(char** pstring){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a string");}
                 void  GetParameterValue(char*** pstringarray,int* pM){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a string array");}
                 void  GetParameterValue(IssmDouble** pIssmDoublearray,int* pM){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble array");}
                 void  GetParameterValue(IssmDouble** pIssmDoublearray,int* pM, int* pN){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble array");}
                 void  GetParameterValue(IssmDouble*** parray, int* pM,int** pmdims, int** pndims){_error2_("File param of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot return a matrix array");}
                 void  GetParameterValue(Vector** pvec){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a Vec");}
                 void  GetParameterValue(Matrix** pmat){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a Mat");}
+                void  GetParameterValue(bool* pbool){  _error_("Param "<< EnumToStringx(enum_type) << " cannot return a bool");}
+                void  GetParameterValue(int* pinteger){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble");}
+                void  GetParameterValue(int** pintarray,int* pM){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble");}
+                void  GetParameterValue(int** pintarray,int* pM,int* pN){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble");}
+                void  GetParameterValue(IssmDouble* pIssmDouble){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble");}
+                void  GetParameterValue(IssmDouble* pdouble,IssmDouble time){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble for a given time");}
+                void  GetParameterValue(char** pstring){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a string");}
+                void  GetParameterValue(char*** pstringarray,int* pM){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a string array");}
+                void  GetParameterValue(IssmDouble** pIssmDoublearray,int* pM){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble array");}
+                void  GetParameterValue(IssmDouble** pIssmDoublearray,int* pM, int* pN){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble array");}
+                void  GetParameterValue(IssmDouble*** parray, int* pM,int** pmdims, int** pndims){_error_("File param of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot return a matrix array");}
+                void  GetParameterValue(Vector** pvec){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a Vec");}
+                void  GetParameterValue(Matrix** pmat){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a Mat");}
                 void  GetParameterValue(FILE** pfid){*pfid=value;};
                 void  SetValue(bool boolean){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a string");}
                 void  SetValue(int integer){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a string");}
                 void  SetValue(IssmDouble scalar){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a string");}
                 void  SetValue(char* string){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a string");}
                 void  SetValue(char** stringarray,int M){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a string array");}
                 void  SetValue(IssmDouble* IssmDoublearray,int M){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a IssmDouble array");}
                 void  SetValue(IssmDouble* pIssmDoublearray,int M,int N){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a IssmDouble array");}
                 void  SetValue(int* intarray,int M){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a int array");}
                 void  SetValue(int* pintarray,int M,int N){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a int array");}
                 void  SetValue(Vector* vec){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a Vec");}
                 void  SetValue(Matrix* mat){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a Mat");}
                 void  SetValue(FILE* fid){_error2_("File param of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot hold a FILE");}
                 void  SetValue(IssmDouble** array, int M, int* mdim_array, int* ndim_array){_error2_("File param of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot hold an array of matrices");}
+                void  SetValue(bool boolean){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a string");}
+                void  SetValue(int integer){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a string");}
+                void  SetValue(IssmDouble scalar){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a string");}
+                void  SetValue(char* string){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a string");}
+                void  SetValue(char** stringarray,int M){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a string array");}
+                void  SetValue(IssmDouble* IssmDoublearray,int M){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a IssmDouble array");}
+                void  SetValue(IssmDouble* pIssmDoublearray,int M,int N){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a IssmDouble array");}
+                void  SetValue(int* intarray,int M){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a int array");}
+                void  SetValue(int* pintarray,int M,int N){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a int array");}
+                void  SetValue(Vector* vec){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a Vec");}
+                void  SetValue(Matrix* mat){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a Mat");}
+                void  SetValue(FILE* fid){_error_("File param of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot hold a FILE");}
+                void  SetValue(IssmDouble** array, int M, int* mdim_array, int* ndim_array){_error_("File param of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot hold an array of matrices");}
                 void  UnitConversion(int direction_enum);

issm/branches/trunk-jpl-damage/src/c/classes/objects/Params/IntMatParam.h

-              r12832
+              r13101
                 /*Param vritual function definitions: {{{*/
                 int   InstanceEnum(){return enum_type;}
                 void  GetParameterValue(bool* pbool){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a bool");}
                 void  GetParameterValue(int* pinteger){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return an integer");}
                 void  GetParameterValue(int** pintarray,int* pM){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return an array of integers");}
+                void  GetParameterValue(bool* pbool){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a bool");}
+                void  GetParameterValue(int* pinteger){_error_("Param "<< EnumToStringx(enum_type) << " cannot return an integer");}
+                void  GetParameterValue(int** pintarray,int* pM){_error_("Param "<< EnumToStringx(enum_type) << " cannot return an array of integers");}
                 void  GetParameterValue(int** pintarray,int* pM,int* pN);
                 void  GetParameterValue(IssmDouble* pIssmDouble){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble");}
                 void  GetParameterValue(IssmDouble* pdouble,IssmDouble time){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble for a given time");}
                 void  GetParameterValue(char** pstring){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a string");}
                 void  GetParameterValue(char*** pstringarray,int* pM){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a string array");}
                 void  GetParameterValue(IssmDouble** pIssmDoublearray,int* pM){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble array");}
                 void  GetParameterValue(IssmDouble** pIssmDoublearray,int* pM,int* pN){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a matrix array");};
                 void  GetParameterValue(IssmDouble*** parray, int* pM,int** pmdims, int** pndims){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a matrix array");}
                 void  GetParameterValue(Vector** pvec){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a Vec");}
                 void  GetParameterValue(Matrix** pmat){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a Mat");}
                 void  GetParameterValue(FILE** pfid){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a FILE");}
+                void  GetParameterValue(IssmDouble* pIssmDouble){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble");}
+                void  GetParameterValue(IssmDouble* pdouble,IssmDouble time){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble for a given time");}
+                void  GetParameterValue(char** pstring){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a string");}
+                void  GetParameterValue(char*** pstringarray,int* pM){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a string array");}
+                void  GetParameterValue(IssmDouble** pIssmDoublearray,int* pM){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble array");}
+                void  GetParameterValue(IssmDouble** pIssmDoublearray,int* pM,int* pN){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a matrix array");};
+                void  GetParameterValue(IssmDouble*** parray, int* pM,int** pmdims, int** pndims){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a matrix array");}
+                void  GetParameterValue(Vector** pvec){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a Vec");}
+                void  GetParameterValue(Matrix** pmat){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a Mat");}
+                void  GetParameterValue(FILE** pfid){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a FILE");}
                 void  SetValue(bool boolean){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a boolean");}
                 void  SetValue(int integer){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold an integer");}
                 void  SetValue(IssmDouble scalar){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a scalar");}
                 void  SetValue(char* string){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a string");}
                 void  SetValue(char** stringarray,int M){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a string array");}
                 void  SetValue(IssmDouble* IssmDoublearray,int M){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a IssmDouble vec array");}
                 void  SetValue(IssmDouble* IssmDoublearray,int M,int N){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a IssmDouble vec array");};
                 void  SetValue(int* intarray,int M){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a int vec array");};
+                void  SetValue(bool boolean){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a boolean");}
+                void  SetValue(int integer){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold an integer");}
+                void  SetValue(IssmDouble scalar){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a scalar");}
+                void  SetValue(char* string){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a string");}
+                void  SetValue(char** stringarray,int M){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a string array");}
+                void  SetValue(IssmDouble* IssmDoublearray,int M){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a IssmDouble vec array");}
+                void  SetValue(IssmDouble* IssmDoublearray,int M,int N){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a IssmDouble vec array");};
+                void  SetValue(int* intarray,int M){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a int vec array");};
                 void  SetValue(int* intarray,int M,int N);
                 void  SetValue(Vector* vec){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a Vec");}
                 void  SetValue(Matrix* mat){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a Mat");}
                 void  SetValue(FILE* fid){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a FILE");}
                 void  SetValue(IssmDouble** array, int M, int* mdim_array, int* ndim_array){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold an array of matrices");}
+                void  SetValue(Vector* vec){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a Vec");}
+                void  SetValue(Matrix* mat){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a Mat");}
+                void  SetValue(FILE* fid){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a FILE");}
+                void  SetValue(IssmDouble** array, int M, int* mdim_array, int* ndim_array){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold an array of matrices");}
                 void  UnitConversion(int direction_enum);

issm/branches/trunk-jpl-damage/src/c/classes/objects/Params/IntParam.h

-              r12832
+              r13101
                 /*Param vritual function definitions: {{{*/
                 int   InstanceEnum(){return enum_type;}
                 void  GetParameterValue(bool* pbool){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a bool");}
+                void  GetParameterValue(bool* pbool){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a bool");}
                 void  GetParameterValue(int* pinteger){*pinteger=value;}
                 void  GetParameterValue(int** pintarray,int* pM){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return an array of integers");}
                 void  GetParameterValue(int** pintarray,int* pM,int* pN){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return an array of integers");}
                 void  GetParameterValue(IssmDouble* pIssmDouble){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble");}
                 void  GetParameterValue(IssmDouble* pdouble,IssmDouble time){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble for a given time");}
                 void  GetParameterValue(char** pstring){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a string");}
                 void  GetParameterValue(char*** pstringarray,int* pM){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a string array");}
                 void  GetParameterValue(IssmDouble** pIssmDoublearray,int* pM){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble array");}
                 void  GetParameterValue(IssmDouble** pIssmDoublearray,int* pM, int* pN){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble array");}
                 void  GetParameterValue(IssmDouble*** parray, int* pM,int** pmdims, int** pndims){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a matrix array");}
                 void  GetParameterValue(Vector** pvec){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a Vec");}
                 void  GetParameterValue(Matrix** pmat){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a Mat");}
                 void  GetParameterValue(FILE** pfid){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a FILE");}
+                void  GetParameterValue(int** pintarray,int* pM){_error_("Param "<< EnumToStringx(enum_type) << " cannot return an array of integers");}
+                void  GetParameterValue(int** pintarray,int* pM,int* pN){_error_("Param "<< EnumToStringx(enum_type) << " cannot return an array of integers");}
+                void  GetParameterValue(IssmDouble* pIssmDouble){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble");}
+                void  GetParameterValue(IssmDouble* pdouble,IssmDouble time){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble for a given time");}
+                void  GetParameterValue(char** pstring){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a string");}
+                void  GetParameterValue(char*** pstringarray,int* pM){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a string array");}
+                void  GetParameterValue(IssmDouble** pIssmDoublearray,int* pM){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble array");}
+                void  GetParameterValue(IssmDouble** pIssmDoublearray,int* pM, int* pN){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble array");}
+                void  GetParameterValue(IssmDouble*** parray, int* pM,int** pmdims, int** pndims){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a matrix array");}
+                void  GetParameterValue(Vector** pvec){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a Vec");}
+                void  GetParameterValue(Matrix** pmat){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a Mat");}
+                void  GetParameterValue(FILE** pfid){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a FILE");}
                 void  SetValue(bool boolean){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a bool");}
+                void  SetValue(bool boolean){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a bool");}
                 void  SetValue(int integer){this->value=integer;}
                 void  SetValue(int* intarray,int M){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold an int array");}
                 void  SetValue(int* intarray,int M,int N){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold an int array");}
                 void  SetValue(IssmDouble scalar){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold an IssmDouble");}
                 void  SetValue(char* string){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a string");}
                 void  SetValue(char** stringarray,int M){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a string array");}
                 void  SetValue(IssmDouble* IssmDoublearray,int M){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a IssmDouble array");}
                 void  SetValue(IssmDouble* pIssmDoublearray,int M,int N){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a IssmDouble array");}
                 void  SetValue(Vector* vec){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a Vec");}
                 void  SetValue(Matrix* mat){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a Mat");}
                 void  SetValue(FILE* fid){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a FILE");}
                 void  SetValue(IssmDouble** array, int M, int* mdim_array, int* ndim_array){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold an array of matrices");}
+                void  SetValue(int* intarray,int M){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold an int array");}
+                void  SetValue(int* intarray,int M,int N){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold an int array");}
+                void  SetValue(IssmDouble scalar){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold an IssmDouble");}
+                void  SetValue(char* string){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a string");}
+                void  SetValue(char** stringarray,int M){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a string array");}
+                void  SetValue(IssmDouble* IssmDoublearray,int M){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a IssmDouble array");}
+                void  SetValue(IssmDouble* pIssmDoublearray,int M,int N){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a IssmDouble array");}
+                void  SetValue(Vector* vec){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a Vec");}
+                void  SetValue(Matrix* mat){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a Mat");}
+                void  SetValue(FILE* fid){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a FILE");}
+                void  SetValue(IssmDouble** array, int M, int* mdim_array, int* ndim_array){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold an array of matrices");}
                 void  UnitConversion(int direction_enum);

issm/branches/trunk-jpl-damage/src/c/classes/objects/Params/IntVecParam.h

-              r12832
+              r13101
                 /*Param virtual functions definitions: {{{*/
                 int   InstanceEnum(){return enum_type;}
                 void  GetParameterValue(bool* pbool){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a bool");}
                 void  GetParameterValue(int* pinteger){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return an integer");}
+                void  GetParameterValue(bool* pbool){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a bool");}
+                void  GetParameterValue(int* pinteger){_error_("Param "<< EnumToStringx(enum_type) << " cannot return an integer");}
                 void  GetParameterValue(int** pintarray,int* pM);
                 void  GetParameterValue(int** pintarray,int* pM,int* pN){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a matrix");}
                 void  GetParameterValue(IssmDouble* pIssmDouble){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble");}
                 void  GetParameterValue(IssmDouble* pdouble,IssmDouble time){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble for a given time");}
                 void  GetParameterValue(char** pstring){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a string");}
                 void  GetParameterValue(char*** pstringarray,int* pM){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a string array");}
                 void  GetParameterValue(IssmDouble** pIssmDoublearray,int* pM){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble array (maybe in serial?)");}
                 void  GetParameterValue(IssmDouble** pIssmDoublearray,int* pM, int* pN){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble array");}
                 void  GetParameterValue(IssmDouble*** parray, int* pM,int** pmdims, int** pndims){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a matrix array");}
                 void  GetParameterValue(Vector** pvec){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a Vec");}
                 void  GetParameterValue(Matrix** pmat){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a Mat");}
                 void  GetParameterValue(FILE** pfid){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a FILE");}
+                void  GetParameterValue(int** pintarray,int* pM,int* pN){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a matrix");}
+                void  GetParameterValue(IssmDouble* pIssmDouble){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble");}
+                void  GetParameterValue(IssmDouble* pdouble,IssmDouble time){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble for a given time");}
+                void  GetParameterValue(char** pstring){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a string");}
+                void  GetParameterValue(char*** pstringarray,int* pM){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a string array");}
+                void  GetParameterValue(IssmDouble** pIssmDoublearray,int* pM){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble array (maybe in serial?)");}
+                void  GetParameterValue(IssmDouble** pIssmDoublearray,int* pM, int* pN){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble array");}
+                void  GetParameterValue(IssmDouble*** parray, int* pM,int** pmdims, int** pndims){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a matrix array");}
+                void  GetParameterValue(Vector** pvec){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a Vec");}
+                void  GetParameterValue(Matrix** pmat){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a Mat");}
+                void  GetParameterValue(FILE** pfid){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a FILE");}
                 void  SetValue(bool boolean){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a boolean");}
                 void  SetValue(int integer){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold an integer");}
                 void  SetValue(IssmDouble scalar){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a scalar");}
                 void  SetValue(char* string){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a string");}
                 void  SetValue(char** stringarray,int M){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a string array");}
                 void  SetValue(IssmDouble* IssmDoublearray,int M){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a IssmDouble mat array");}
                 void  SetValue(IssmDouble* pIssmDoublearray,int M,int N){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a IssmDouble mat array");}
+                void  SetValue(bool boolean){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a boolean");}
+                void  SetValue(int integer){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold an integer");}
+                void  SetValue(IssmDouble scalar){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a scalar");}
+                void  SetValue(char* string){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a string");}
+                void  SetValue(char** stringarray,int M){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a string array");}
+                void  SetValue(IssmDouble* IssmDoublearray,int M){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a IssmDouble mat array");}
+                void  SetValue(IssmDouble* pIssmDoublearray,int M,int N){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a IssmDouble mat array");}
                 void  SetValue(int* intarray,int M);
                 void  SetValue(int* pintarray,int M,int N){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a int mat array");}
                 void  SetValue(Vector* vec){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a Vec");}
                 void  SetValue(Matrix* mat){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a Mat");}
                 void  SetValue(FILE* fid){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a FILE");}
                 void  SetValue(IssmDouble** array, int M, int* mdim_array, int* ndim_array){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold an array of matrices");}
+                void  SetValue(int* pintarray,int M,int N){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a int mat array");}
+                void  SetValue(Vector* vec){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a Vec");}
+                void  SetValue(Matrix* mat){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a Mat");}
+                void  SetValue(FILE* fid){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a FILE");}
+                void  SetValue(IssmDouble** array, int M, int* mdim_array, int* ndim_array){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold an array of matrices");}
                 void  UnitConversion(int direction_enum);

issm/branches/trunk-jpl-damage/src/c/classes/objects/Params/MatrixParam.h

-              r12832
+              r13101
                 /*Param vritual function definitions: {{{*/
                 int   InstanceEnum(){return enum_type;}
                 void  GetParameterValue(bool* pbool){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a bool");}
                 void  GetParameterValue(int* pinteger){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return an integer");}
                 void  GetParameterValue(int** pintarray,int* pM){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return an array of integers");}
                 void  GetParameterValue(int** pintarray,int* pM,int* pN){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return an array of integers");}
                 void  GetParameterValue(IssmDouble* pIssmDouble){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble");}
                 void  GetParameterValue(IssmDouble* pdouble,IssmDouble time){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble for a given time");}
                 void  GetParameterValue(char** pstring){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a string");}
                 void  GetParameterValue(char*** pstringarray,int* pM){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a string array");}
                 void  GetParameterValue(IssmDouble** pIssmDoublearray,int* pM){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble array");}
                 void  GetParameterValue(IssmDouble** pIssmDoublearray,int* pM, int* pN){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble array");}
                 void  GetParameterValue(IssmDouble*** parray, int* pM,int** pmdims, int** pndims){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a matrix array");}
                 void  GetParameterValue(Vector** pvec){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a vec");}
+                void  GetParameterValue(bool* pbool){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a bool");}
+                void  GetParameterValue(int* pinteger){_error_("Param "<< EnumToStringx(enum_type) << " cannot return an integer");}
+                void  GetParameterValue(int** pintarray,int* pM){_error_("Param "<< EnumToStringx(enum_type) << " cannot return an array of integers");}
+                void  GetParameterValue(int** pintarray,int* pM,int* pN){_error_("Param "<< EnumToStringx(enum_type) << " cannot return an array of integers");}
+                void  GetParameterValue(IssmDouble* pIssmDouble){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble");}
+                void  GetParameterValue(IssmDouble* pdouble,IssmDouble time){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble for a given time");}
+                void  GetParameterValue(char** pstring){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a string");}
+                void  GetParameterValue(char*** pstringarray,int* pM){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a string array");}
+                void  GetParameterValue(IssmDouble** pIssmDoublearray,int* pM){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble array");}
+                void  GetParameterValue(IssmDouble** pIssmDoublearray,int* pM, int* pN){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble array");}
+                void  GetParameterValue(IssmDouble*** parray, int* pM,int** pmdims, int** pndims){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a matrix array");}
+                void  GetParameterValue(Vector** pvec){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a vec");}
                 void  GetParameterValue(Matrix** poutput);
                 void  GetParameterValue(FILE** pfid){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a FILE");}
+                void  GetParameterValue(FILE** pfid){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a FILE");}
                 void  SetValue(bool boolean){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a boolean");}
                 void  SetValue(int integer){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold an integer");}
                 void  SetValue(IssmDouble scalar){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a scalar");}
                 void  SetValue(char* string){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a string");}
                 void  SetValue(char** stringarray,int M){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a string array");}
                 void  SetValue(IssmDouble* IssmDoublearray,int M){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a IssmDouble array");}
                 void  SetValue(IssmDouble* pIssmDoublearray,int M,int N){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a IssmDouble array");}
                 void  SetValue(int* intarray,int M){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a int array");}
                 void  SetValue(int* pintarray,int M,int N){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a int array");}
                 void  SetValue(Vector* vec){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a Vec");}
+                void  SetValue(bool boolean){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a boolean");}
+                void  SetValue(int integer){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold an integer");}
+                void  SetValue(IssmDouble scalar){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a scalar");}
+                void  SetValue(char* string){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a string");}
+                void  SetValue(char** stringarray,int M){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a string array");}
+                void  SetValue(IssmDouble* IssmDoublearray,int M){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a IssmDouble array");}
+                void  SetValue(IssmDouble* pIssmDoublearray,int M,int N){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a IssmDouble array");}
+                void  SetValue(int* intarray,int M){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a int array");}
+                void  SetValue(int* pintarray,int M,int N){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a int array");}
+                void  SetValue(Vector* vec){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a Vec");}
                 void  SetValue(Matrix* mat);
                 void  SetValue(FILE* fid){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a FILE");}
                 void  SetValue(IssmDouble** array, int M, int* mdim_array, int* ndim_array){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold an array of matrices");}
+                void  SetValue(FILE* fid){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a FILE");}
+                void  SetValue(IssmDouble** array, int M, int* mdim_array, int* ndim_array){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold an array of matrices");}
                 void  UnitConversion(int direction_enum);

issm/branches/trunk-jpl-damage/src/c/classes/objects/Params/StringArrayParam.h

-              r12832
+              r13101
                 /*Param vritual function definitions: {{{*/
                 int   InstanceEnum(){return enum_type;}
                 void  GetParameterValue(bool* pbool){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a bool");}
                 void  GetParameterValue(int* pinteger){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return an integer");}
                 void  GetParameterValue(int** pintarray,int* pM){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return an array of integers");}
                 void  GetParameterValue(int** pintarray,int* pM,int* pN){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return an array of integers");}
                 void  GetParameterValue(IssmDouble* pIssmDouble){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble");}
                 void  GetParameterValue(IssmDouble* pdouble,IssmDouble time){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble for a given time");}
                 void  GetParameterValue(char** pstring){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a string");}
+                void  GetParameterValue(bool* pbool){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a bool");}
+                void  GetParameterValue(int* pinteger){_error_("Param "<< EnumToStringx(enum_type) << " cannot return an integer");}
+                void  GetParameterValue(int** pintarray,int* pM){_error_("Param "<< EnumToStringx(enum_type) << " cannot return an array of integers");}
+                void  GetParameterValue(int** pintarray,int* pM,int* pN){_error_("Param "<< EnumToStringx(enum_type) << " cannot return an array of integers");}
+                void  GetParameterValue(IssmDouble* pIssmDouble){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble");}
+                void  GetParameterValue(IssmDouble* pdouble,IssmDouble time){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble for a given time");}
+                void  GetParameterValue(char** pstring){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a string");}
                 void  GetParameterValue(char*** pstringarray,int* pM);
                 void  GetParameterValue(IssmDouble** pIssmDoublearray,int* pM){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble array");}
                 void  GetParameterValue(IssmDouble** pIssmDoublearray,int* pM, int* pN){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble array");}
                 void  GetParameterValue(IssmDouble*** parray, int* pM,int** pmdims, int** pndims){_error2_("Vec param of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot return a matrix array");}
                 void  GetParameterValue(Vector** pvec){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a Vec");}
                 void  GetParameterValue(Matrix** pmat){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a Mat");}
                 void  GetParameterValue(FILE** pfid){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a FILE");}
+                void  GetParameterValue(IssmDouble** pIssmDoublearray,int* pM){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble array");}
+                void  GetParameterValue(IssmDouble** pIssmDoublearray,int* pM, int* pN){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble array");}
+                void  GetParameterValue(IssmDouble*** parray, int* pM,int** pmdims, int** pndims){_error_("Vec param of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot return a matrix array");}
+                void  GetParameterValue(Vector** pvec){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a Vec");}
+                void  GetParameterValue(Matrix** pmat){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a Mat");}
+                void  GetParameterValue(FILE** pfid){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a FILE");}
                 void  SetValue(bool boolean){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a boolean");}
                 void  SetValue(int integer){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold an integer");}
                 void  SetValue(IssmDouble scalar){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a scalar");}
                 void  SetValue(char* string){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a string");}
+                void  SetValue(bool boolean){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a boolean");}
+                void  SetValue(int integer){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold an integer");}
+                void  SetValue(IssmDouble scalar){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a scalar");}
+                void  SetValue(char* string){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a string");}
                 void  SetValue(char** stringarray,int M);
                 void  SetValue(IssmDouble* IssmDoublearray,int M){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a IssmDouble array");}
                 void  SetValue(IssmDouble* pIssmDoublearray,int M,int N){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a IssmDouble array");}
                 void  SetValue(int* intarray,int M){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a int array");}
                 void  SetValue(int* pintarray,int M,int N){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a int array");}
                 void  SetValue(Vector* vec){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a Vec");}
                 void  SetValue(Matrix* mat){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a Mat");}
                 void  SetValue(FILE* fid){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a FILE");}
                 void  SetValue(IssmDouble** array, int M, int* mdim_array, int* ndim_array){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold an array of matrices");}
+                void  SetValue(IssmDouble* IssmDoublearray,int M){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a IssmDouble array");}
+                void  SetValue(IssmDouble* pIssmDoublearray,int M,int N){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a IssmDouble array");}
+                void  SetValue(int* intarray,int M){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a int array");}
+                void  SetValue(int* pintarray,int M,int N){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a int array");}
+                void  SetValue(Vector* vec){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a Vec");}
+                void  SetValue(Matrix* mat){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a Mat");}
+                void  SetValue(FILE* fid){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a FILE");}
+                void  SetValue(IssmDouble** array, int M, int* mdim_array, int* ndim_array){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold an array of matrices");}
                 void  UnitConversion(int direction_enum);

issm/branches/trunk-jpl-damage/src/c/classes/objects/Params/StringParam.h

-              r12832
+              r13101
                 /*Param vritual function definitions: {{{*/
                 int   InstanceEnum(){return enum_type;}
                 void  GetParameterValue(bool* pbool){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a bool");}
                 void  GetParameterValue(int* pinteger){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return an integer");}
                 void  GetParameterValue(int** pintarray,int* pM){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return an array of integers");}
                 void  GetParameterValue(int** pintarray,int* pM,int* pN){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return an array of integers");}
                 void  GetParameterValue(IssmDouble* pIssmDouble){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble");}
                 void  GetParameterValue(IssmDouble* pdouble,IssmDouble time){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble for a given time");}
+                void  GetParameterValue(bool* pbool){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a bool");}
+                void  GetParameterValue(int* pinteger){_error_("Param "<< EnumToStringx(enum_type) << " cannot return an integer");}
+                void  GetParameterValue(int** pintarray,int* pM){_error_("Param "<< EnumToStringx(enum_type) << " cannot return an array of integers");}
+                void  GetParameterValue(int** pintarray,int* pM,int* pN){_error_("Param "<< EnumToStringx(enum_type) << " cannot return an array of integers");}
+                void  GetParameterValue(IssmDouble* pIssmDouble){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble");}
+                void  GetParameterValue(IssmDouble* pdouble,IssmDouble time){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble for a given time");}
                 void  GetParameterValue(char** pstring);
                 void  GetParameterValue(char*** pstringarray,int* pM){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a string array");}
                 void  GetParameterValue(IssmDouble** pIssmDoublearray,int* pM){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble array");}
                 void  GetParameterValue(IssmDouble** pIssmDoublearray,int* pM, int* pN){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble array");}
                 void  GetParameterValue(IssmDouble*** parray, int* pM,int** pmdims, int** pndims){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a matrix array");}
                 void  GetParameterValue(Vector** pvec){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a Vec");}
                 void  GetParameterValue(Matrix** pmat){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a Mat");}
                 void  GetParameterValue(FILE** pfid){_error2_("Bool param of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot return a FILE");}
+                void  GetParameterValue(char*** pstringarray,int* pM){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a string array");}
+                void  GetParameterValue(IssmDouble** pIssmDoublearray,int* pM){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble array");}
+                void  GetParameterValue(IssmDouble** pIssmDoublearray,int* pM, int* pN){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble array");}
+                void  GetParameterValue(IssmDouble*** parray, int* pM,int** pmdims, int** pndims){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a matrix array");}
+                void  GetParameterValue(Vector** pvec){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a Vec");}
+                void  GetParameterValue(Matrix** pmat){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a Mat");}
+                void  GetParameterValue(FILE** pfid){_error_("Bool param of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot return a FILE");}
                 void  SetValue(bool boolean){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a boolean");}
                 void  SetValue(int integer){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold an integer");}
                 void  SetValue(IssmDouble scalar){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a scalar");}
+                void  SetValue(bool boolean){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a boolean");}
+                void  SetValue(int integer){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold an integer");}
+                void  SetValue(IssmDouble scalar){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a scalar");}
                 void  SetValue(char* string);
                 void  SetValue(char** stringarray,int M){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a string array");}
                 void  SetValue(IssmDouble* IssmDoublearray,int M){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a IssmDouble array");}
                 void  SetValue(IssmDouble* pIssmDoublearray,int M,int N){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a IssmDouble array");}
                 void  SetValue(int* intarray,int M){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a int array");}
                 void  SetValue(int* pintarray,int M,int N){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a int array");}
                 void  SetValue(Vector* vec){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a Vec");}
                 void  SetValue(Matrix* mat){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a Mat");}
                 void  SetValue(FILE* fid){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold a FILE");}
                 void  SetValue(IssmDouble** array, int M, int* mdim_array, int* ndim_array){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold an array of matrices");}
+                void  SetValue(char** stringarray,int M){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a string array");}
+                void  SetValue(IssmDouble* IssmDoublearray,int M){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a IssmDouble array");}
+                void  SetValue(IssmDouble* pIssmDoublearray,int M,int N){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a IssmDouble array");}
+                void  SetValue(int* intarray,int M){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a int array");}
+                void  SetValue(int* pintarray,int M,int N){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a int array");}
+                void  SetValue(Vector* vec){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a Vec");}
+                void  SetValue(Matrix* mat){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a Mat");}
+                void  SetValue(FILE* fid){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a FILE");}
+                void  SetValue(IssmDouble** array, int M, int* mdim_array, int* ndim_array){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold an array of matrices");}
                 void  UnitConversion(int direction_enum);

issm/branches/trunk-jpl-damage/src/c/classes/objects/Params/TransientParam.cpp

r12832	r13101
99	99	void TransientParam::GetParameterValue(IssmDouble* pdouble,IssmDouble time){
100	100
101		double output;
	101	IssmDouble output;
102	102	bool found;
103	103
…	…
136	136	}
137	137	}
138		if(!found)_error2_("did not find time interval on which to interpolate values");
	138	if(!found)_error_("did not find time interval on which to interpolate values");
139	139	*pdouble=output;
140	140	}

issm/branches/trunk-jpl-damage/src/c/classes/objects/Params/TransientParam.h

-              r12832
+              r13101
                 /*Param vritual function definitions: {{{*/
                 int   InstanceEnum(){return enum_type;}
                 void  GetParameterValue(bool* pbool){_error2_("Parameter " <<EnumToStringx(enum_type) << " cannot return a bool");}
                 void  GetParameterValue(int* pinteger){_error2_("Parameter " <<EnumToStringx(enum_type) << " cannot return an integer");}
                 void  GetParameterValue(int** pintarray,int* pM){_error2_("Parameter " <<EnumToStringx(enum_type) << " cannot return an array of integers");}
                 void  GetParameterValue(int** pintarray,int* pM,int* pN){_error2_("Parameter " <<EnumToStringx(enum_type) << " cannot return a array of integers");}
                 void  GetParameterValue(IssmDouble* pIssmDouble){_error2_("Parameter " <<EnumToStringx(enum_type) << " cannot return a IssmDouble");}
+                void  GetParameterValue(bool* pbool){_error_("Parameter " <<EnumToStringx(enum_type) << " cannot return a bool");}
+                void  GetParameterValue(int* pinteger){_error_("Parameter " <<EnumToStringx(enum_type) << " cannot return an integer");}
+                void  GetParameterValue(int** pintarray,int* pM){_error_("Parameter " <<EnumToStringx(enum_type) << " cannot return an array of integers");}
+                void  GetParameterValue(int** pintarray,int* pM,int* pN){_error_("Parameter " <<EnumToStringx(enum_type) << " cannot return a array of integers");}
+                void  GetParameterValue(IssmDouble* pIssmDouble){_error_("Parameter " <<EnumToStringx(enum_type) << " cannot return a IssmDouble");}
                 void  GetParameterValue(IssmDouble* pdouble,IssmDouble time);
                 void  GetParameterValue(char** pstring){_error2_("Parameter " <<EnumToStringx(enum_type) << " cannot return a string");}
                 void  GetParameterValue(char*** pstringarray,int* pM){_error2_("Parameter " <<EnumToStringx(enum_type) << " cannot return a string array");}
                 void  GetParameterValue(IssmDouble** pIssmDoublearray,int* pM){_error2_("Parameter " <<EnumToStringx(enum_type) << " cannot return a IssmDouble array");}
                 void  GetParameterValue(IssmDouble** pIssmDoublearray,int* pM,int* pN){_error2_("Parameter " <<EnumToStringx(enum_type) << " cannot return a IssmDouble array");}
                 void  GetParameterValue(IssmDouble*** parray, int* pM,int** pmdims, int** pndims){_error2_("Parameter " <<EnumToStringx(enum_type) << " cannot return a matrix array");}
                 void  GetParameterValue(Vector** pvec){_error2_("Parameter " <<EnumToStringx(enum_type) << " cannot return a Vec");}
                 void  GetParameterValue(Matrix** pmat){_error2_("Parameter " <<EnumToStringx(enum_type) << " cannot return a Mat");}
                 void  GetParameterValue(FILE** pfid){_error2_("Parameter " <<EnumToStringx(enum_type) << " cannot return a FILE");}
+                void  GetParameterValue(char** pstring){_error_("Parameter " <<EnumToStringx(enum_type) << " cannot return a string");}
+                void  GetParameterValue(char*** pstringarray,int* pM){_error_("Parameter " <<EnumToStringx(enum_type) << " cannot return a string array");}
+                void  GetParameterValue(IssmDouble** pIssmDoublearray,int* pM){_error_("Parameter " <<EnumToStringx(enum_type) << " cannot return a IssmDouble array");}
+                void  GetParameterValue(IssmDouble** pIssmDoublearray,int* pM,int* pN){_error_("Parameter " <<EnumToStringx(enum_type) << " cannot return a IssmDouble array");}
+                void  GetParameterValue(IssmDouble*** parray, int* pM,int** pmdims, int** pndims){_error_("Parameter " <<EnumToStringx(enum_type) << " cannot return a matrix array");}
+                void  GetParameterValue(Vector** pvec){_error_("Parameter " <<EnumToStringx(enum_type) << " cannot return a Vec");}
+                void  GetParameterValue(Matrix** pmat){_error_("Parameter " <<EnumToStringx(enum_type) << " cannot return a Mat");}
+                void  GetParameterValue(FILE** pfid){_error_("Parameter " <<EnumToStringx(enum_type) << " cannot return a FILE");}
                 void  SetValue(bool boolean){_error2_("Parameter " <<EnumToStringx(enum_type) << " cannot hold a boolean");}
                 void  SetValue(int integer){_error2_("Parameter " <<EnumToStringx(enum_type) << " cannot hold an integer");}
                 void  SetValue(IssmDouble scalar){_error2_("Parameter " <<EnumToStringx(enum_type) << " cannot hold a scalar");}
                 void  SetValue(char* string){_error2_("Parameter " <<EnumToStringx(enum_type) << " cannot hold a string");}
                 void  SetValue(char** stringarray,int M){_error2_("Parameter " <<EnumToStringx(enum_type) << " cannot hold a string array");}
                 void  SetValue(IssmDouble* IssmDoublearray,int M){_error2_("Parameter " <<EnumToStringx(enum_type) << " cannot hold a IssmDouble vec array");}
                 void  SetValue(IssmDouble* IssmDoublearray,int M,int N){_error2_("Parameter " <<EnumToStringx(enum_type) << " cannot hold a IssmDouble array");}
                 void  SetValue(int* intarray,int M){_error2_("Parameter " <<EnumToStringx(enum_type) << " cannot hold a int vec array");}
                 void  SetValue(int* intarray,int M,int N){_error2_("Parameter " <<EnumToStringx(enum_type) << " cannot hold a int mat array");};
                 void  SetValue(Vector* vec){_error2_("Parameter " <<EnumToStringx(enum_type) << " cannot hold a Vec");}
                 void  SetValue(Matrix* mat){_error2_("Parameter " <<EnumToStringx(enum_type) << " cannot hold a Mat");}
                 void  SetValue(FILE* fid){_error2_("Parameter " <<EnumToStringx(enum_type) << " cannot hold a FILE");}
                 void  SetValue(IssmDouble** array, int M, int* mdim_array, int* ndim_array){_error2_("Parameter " <<EnumToStringx(enum_type) << " cannot hold an array of matrices");}
+                void  SetValue(bool boolean){_error_("Parameter " <<EnumToStringx(enum_type) << " cannot hold a boolean");}
+                void  SetValue(int integer){_error_("Parameter " <<EnumToStringx(enum_type) << " cannot hold an integer");}
+                void  SetValue(IssmDouble scalar){_error_("Parameter " <<EnumToStringx(enum_type) << " cannot hold a scalar");}
+                void  SetValue(char* string){_error_("Parameter " <<EnumToStringx(enum_type) << " cannot hold a string");}
+                void  SetValue(char** stringarray,int M){_error_("Parameter " <<EnumToStringx(enum_type) << " cannot hold a string array");}
+                void  SetValue(IssmDouble* IssmDoublearray,int M){_error_("Parameter " <<EnumToStringx(enum_type) << " cannot hold a IssmDouble vec array");}
+                void  SetValue(IssmDouble* IssmDoublearray,int M,int N){_error_("Parameter " <<EnumToStringx(enum_type) << " cannot hold a IssmDouble array");}
+                void  SetValue(int* intarray,int M){_error_("Parameter " <<EnumToStringx(enum_type) << " cannot hold a int vec array");}
+                void  SetValue(int* intarray,int M,int N){_error_("Parameter " <<EnumToStringx(enum_type) << " cannot hold a int mat array");};
+                void  SetValue(Vector* vec){_error_("Parameter " <<EnumToStringx(enum_type) << " cannot hold a Vec");}
+                void  SetValue(Matrix* mat){_error_("Parameter " <<EnumToStringx(enum_type) << " cannot hold a Mat");}
+                void  SetValue(FILE* fid){_error_("Parameter " <<EnumToStringx(enum_type) << " cannot hold a FILE");}
+                void  SetValue(IssmDouble** array, int M, int* mdim_array, int* ndim_array){_error_("Parameter " <<EnumToStringx(enum_type) << " cannot hold an array of matrices");}
                 void  UnitConversion(int direction_enum);

issm/branches/trunk-jpl-damage/src/c/classes/objects/Params/VectorParam.h

-              r12832
+              r13101
                 /*Param vritual function definitions: {{{*/
                 int   InstanceEnum(){return enum_type;}
                 void  GetParameterValue(bool* pbool){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a bool");}
                 void  GetParameterValue(int* pinteger){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return an integer");}
                 void  GetParameterValue(int** pintarray,int* pM){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return an array of integers");}
                 void  GetParameterValue(int** pintarray,int* pM,int* pN){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return an array of integers");}
                 void  GetParameterValue(IssmDouble* pIssmDouble){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble");}
                 void  GetParameterValue(IssmDouble* pdouble,IssmDouble time){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble for a given time");}
                 void  GetParameterValue(char** pstring){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a string");}
                 void  GetParameterValue(char*** pstringarray,int* pM){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a string array");}
                 void  GetParameterValue(IssmDouble** pIssmDoublearray,int* pM){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble array");}
                 void  GetParameterValue(IssmDouble** pIssmDoublearray,int* pM, int* pN){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble array");}
                 void  GetParameterValue(IssmDouble*** parray, int* pM,int** pmdims, int** pndims){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a matrix array");}
                 void  GetParameterValue(Matrix** pmat){_error2_("Param "<< EnumToStringx(enum_type) << " cannot return a Mat");}
+                void  GetParameterValue(bool* pbool){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a bool");}
+                void  GetParameterValue(int* pinteger){_error_("Param "<< EnumToStringx(enum_type) << " cannot return an integer");}
+                void  GetParameterValue(int** pintarray,int* pM){_error_("Param "<< EnumToStringx(enum_type) << " cannot return an array of integers");}
+                void  GetParameterValue(int** pintarray,int* pM,int* pN){_error_("Param "<< EnumToStringx(enum_type) << " cannot return an array of integers");}
+                void  GetParameterValue(IssmDouble* pIssmDouble){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble");}
+                void  GetParameterValue(IssmDouble* pdouble,IssmDouble time){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble for a given time");}
+                void  GetParameterValue(char** pstring){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a string");}
+                void  GetParameterValue(char*** pstringarray,int* pM){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a string array");}
+                void  GetParameterValue(IssmDouble** pIssmDoublearray,int* pM){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble array");}
+                void  GetParameterValue(IssmDouble** pIssmDoublearray,int* pM, int* pN){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a IssmDouble array");}
+                void  GetParameterValue(IssmDouble*** parray, int* pM,int** pmdims, int** pndims){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a matrix array");}
+                void  GetParameterValue(Matrix** pmat){_error_("Param "<< EnumToStringx(enum_type) << " cannot return a Mat");}
                 void  GetParameterValue(Vector** poutput);
                 void  GetParameterValue(FILE** pfid){_error2_("Vector of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot return a FILE");}
+                void  GetParameterValue(FILE** pfid){_error_("Vector of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot return a FILE");}
                 void  SetValue(bool boolean){_error2_("Vector of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot hold a boolean");}
                 void  SetValue(int integer){_error2_("Vector of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot hold an integer");}
                 void  SetValue(IssmDouble scalar){_error2_("Vector of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot hold a scalar");}
                 void  SetValue(char* string){_error2_("Vector of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot hold a string");}
                 void  SetValue(char** stringarray,int M){_error2_("Vector of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot hold a string array");}
                 void  SetValue(IssmDouble* IssmDoublearray,int M){_error2_("Vector of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot hold a IssmDouble array");}
                 void  SetValue(IssmDouble* pIssmDoublearray,int M,int N){_error2_("Vector of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot hold a IssmDouble array");}
                 void  SetValue(int* intarray,int M){_error2_("Vector of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot hold a int array");}
                 void  SetValue(int* pintarray,int M,int N){_error2_("Vector of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot hold a int array");}
+                void  SetValue(bool boolean){_error_("Vector of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot hold a boolean");}
+                void  SetValue(int integer){_error_("Vector of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot hold an integer");}
+                void  SetValue(IssmDouble scalar){_error_("Vector of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot hold a scalar");}
+                void  SetValue(char* string){_error_("Vector of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot hold a string");}
+                void  SetValue(char** stringarray,int M){_error_("Vector of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot hold a string array");}
+                void  SetValue(IssmDouble* IssmDoublearray,int M){_error_("Vector of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot hold a IssmDouble array");}
+                void  SetValue(IssmDouble* pIssmDoublearray,int M,int N){_error_("Vector of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot hold a IssmDouble array");}
+                void  SetValue(int* intarray,int M){_error_("Vector of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot hold a int array");}
+                void  SetValue(int* pintarray,int M,int N){_error_("Vector of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot hold a int array");}
                 void  SetValue(Vector* vec);
                 void  SetValue(Matrix* mat){_error2_("Vector of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot hold a Mat");}
                 void  SetValue(FILE* fid){_error2_("Vector of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot hold a FILE");}
                 void  SetValue(IssmDouble** array, int M, int* mdim_array, int* ndim_array){_error2_("Param "<< EnumToStringx(enum_type) << " cannot hold an array of matrices");}
+                void  SetValue(Matrix* mat){_error_("Vector of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot hold a Mat");}
+                void  SetValue(FILE* fid){_error_("Vector of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot hold a FILE");}
+                void  SetValue(IssmDouble** array, int M, int* mdim_array, int* ndim_array){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold an array of matrices");}
                 void  UnitConversion(int direction_enum);

issm/branches/trunk-jpl-damage/src/c/include/macros.h

-              r12878
+              r13101
 #define _printf_(flag,...) do{if(flag) PrintfFunction(__VA_ARGS__);}while(0)
 /*}}}*/
-/* _error_ {{{*/
-/*Error exception macro*/
-#ifdef _INTEL_WIN_
-#define _error_(...)\
-  throw ErrorException(exprintf(__VA_ARGS__))
-#else
-#define _error_(...)\
-  throw ErrorException(__FILE__,__func__,__LINE__,exprintf(__VA_ARGS__))
-#endif
-/*}}}*/
 /* _error2_ {{{*/
 /*new Error exception macro*/
 #ifdef _INTEL_WIN_
 #define _error2_(StreamArgs)\
+#define _error_(StreamArgs)\
    do{std::ostringstream aLoNgAnDwEiRdLoCaLnAmeFoRtHiSmAcRoOnLy; \
    aLoNgAnDwEiRdLoCaLnAmeFoRtHiSmAcRoOnLy << StreamArgs << std::ends; \
    throw ErrorException(aLoNgAnDwEiRdLoCaLnAmeFoRtHiSmAcRoOnLy.str());}while(0)
 #else
 #define _error2_(StreamArgs)\
+#define _error_(StreamArgs)\
         do{std::ostringstream aLoNgAnDwEiRdLoCaLnAmeFoRtHiSmAcRoOnLy; \
    aLoNgAnDwEiRdLoCaLnAmeFoRtHiSmAcRoOnLy << StreamArgs << std::ends; \
 …
 #ifdef _ISSM_DEBUG_
 #define _assert_(statement)\
   if (!(statement)) _error_("Assertion \"%s\" failed, please report bug to %s",#statement,PACKAGE_BUGREPORT)
+  if (!(statement)) _error_("Assertion \""<<#statement<<"\" failed, please report bug to "<<PACKAGE_BUGREPORT)
 #else
 #define _assert_(ignore)\

issm/branches/trunk-jpl-damage/src/c/io/Disk/pfclose.cpp

r12878	r13101
18	18	extern int my_rank;
19	19	_assert_(fid);
20		if(fclose(fid)!=0)_error2_("could not close file " << filename);
	20	if(fclose(fid)!=0)_error_("could not close file " << filename);
21	21	}

issm/branches/trunk-jpl-damage/src/c/io/Disk/pfopen.cpp

r12878	r13101
20	20	/Open handle to data on disk: /
21	21	fid=fopen(filename,format);
22		if(fid==NULL) _error2_("could not open file " << filename << " for binary reading or writing");
	22	if(fid==NULL) _error_("could not open file " << filename << " for binary reading or writing");
23	23
24	24	return fid;

issm/branches/trunk-jpl-damage/src/c/matlab/io/CheckNumMatlabArguments.cpp

-              r12878
+              r13101
                 /* special case: */
                 function();
                 _error2_("usage: see above");
+                _error_("usage: see above");
+        }
         else if (nlhs!=NLHS || nrhs!=NRHS ) {
                 function();
                 _error2_("usage error.");
+                _error_("usage error.");
+        }
         return 1;

issm/branches/trunk-jpl-damage/src/c/matlab/io/FetchMatlabData.cpp

-              r12878
+              r13101
         else{
                 /*This is an error: we don't have the correct input!: */
                 _error2_("Input parameter of class " << mxGetClassName(dataref) << " not supported yet");
+                _error_("Input parameter of class " << mxGetClassName(dataref) << " not supported yet");
+        }
 …
         else{
                 /*This is an error: we don't have the correct input!: */
                 _error2_("Input parameter of class " << mxGetClassName(dataref) << " not supported yet");
+                _error_("Input parameter of class " << mxGetClassName(dataref) << " not supported yet");
+        }
 …
         else{
                 /*This is an error: we don't have the correct input!: */
                 _error2_("Input parameter of class " << mxGetClassName(dataref) << " not supported yet");
+                _error_("Input parameter of class " << mxGetClassName(dataref) << " not supported yet");
+        }
 …
         else{
                 /*This is an error: we don't have the correct input!: */
                 _error2_("Input parameter of class " << mxGetClassName(dataref) << " not supported yet");
+                _error_("Input parameter of class " << mxGetClassName(dataref) << " not supported yet");
+        }
 …
         else{
                 /*This is an error: we don't have the correct input!: */
                 _error2_("Input parameter of class " << mxGetClassName(dataref) << " not supported yet");
+                _error_("Input parameter of class " << mxGetClassName(dataref) << " not supported yet");
+        }
 …
         else{
                 /*This is an error: we don't have the correct input!: */
                 _error2_("Input parameter of class " << mxGetClassName(dataref) << " not supported yet");
+                _error_("Input parameter of class " << mxGetClassName(dataref) << " not supported yet");
+        }
 …
         else{
                 /*This is an error: we don't have the correct input!: */
                 _error2_("Input parameter of class " << mxGetClassName(dataref) << " not supported yet");
+                _error_("Input parameter of class " << mxGetClassName(dataref) << " not supported yet");
+        }
 …
         else{
                 /*This is an error: we don't have the correct input!: */
                 _error2_("Input parameter of class " << mxGetClassName(dataref) << " not supported yet");
+                _error_("Input parameter of class " << mxGetClassName(dataref) << " not supported yet");
+        }
 …
         else{
                 /*This is an error: we don't have the correct input!: */
                 _error2_("Input parameter of class " << mxGetClassName(dataref) << " not supported yet");
+                _error_("Input parameter of class " << mxGetClassName(dataref) << " not supported yet");
+        }
 …
         /*Ok, the string should be coming directly from the matlab workspace: */
         if (!mxIsClass(dataref,"char")){
                 _error2_("input data_type is not a string!");
+                _error_("input data_type is not a string!");
+        }
         else{
 …
         else{
                 /*This is an error: we don't have the correct input!: */
                 _error2_("Input parameter of class " << mxGetClassName(dataref) << " not supported yet");
+                _error_("Input parameter of class " << mxGetClassName(dataref) << " not supported yet");
+        }
 …
         if (!mxIsClass(dataref,"double")){
                 _error2_("input data_type is not a double!");
+                _error_("input data_type is not a double!");
+        }
         else{
 …
         if (!mxIsClass(dataref,"double")){
                 _error2_("input data_type is not a scalar!");
+                _error_("input data_type is not a scalar!");
+        }
         else{
 …
         if (mxIsClass(dataref,"logical")){
                 if(mxGetM(dataref)!=1) _error2_("input data is not of size 1x1");
                 if(mxGetN(dataref)!=1) _error2_("input data is not of size 1x1");
+                if(mxGetM(dataref)!=1) _error_("input data is not of size 1x1");
+                if(mxGetN(dataref)!=1) _error_("input data is not of size 1x1");
                 mxbool_ptr=mxGetLogicals(dataref);
+        }
         else{
                 _error2_("input data_type is not a bool!");
+                _error_("input data_type is not a bool!");
+        }
 …
         else{
                 /*This is an error: we don't have the correct input!: */
                 _error2_("Input parameter of class " << mxGetClassName(dataref) << " not supported yet");
+                _error_("Input parameter of class " << mxGetClassName(dataref) << " not supported yet");
+        }
 …
         else{
                 /*This is an error: we don't have the correct input!: */
                 _error2_("Input parameter of class " << mxGetClassName(dataref) << " not supported yet");
+                _error_("Input parameter of class " << mxGetClassName(dataref) << " not supported yet");
+        }
 …
         /*Fetch all options*/
         for (int i=istart; i<nrhs; i=i+2){
                 if (!mxIsClass(pdataref[i],"char")) _error2_("Argument " << i+1 << " must be name of option");
+                if (!mxIsClass(pdataref[i],"char")) _error_("Argument " << i+1 << " must be name of option");
                 FetchData(&name,pdataref[i]);
                 if(i+1 == nrhs) _error2_("Argument " << i+2 << " must exist and be value of option \"" << name << "\".");
+                if(i+1 == nrhs) _error_("Argument " << i+2 << " must exist and be value of option \"" << name << "\".");
                 option=(Option*)OptionParse(name,&pdataref[i+1]);

issm/branches/trunk-jpl-damage/src/c/matlab/io/MatlabMatrixToDoubleMatrix.cpp

r12878	r13101
119	119	}
120	120	else{
121		_error2_("Matlab matrix type Not implemented yet");
	121	_error_("Matlab matrix type Not implemented yet");
122	122	}
123	123

issm/branches/trunk-jpl-damage/src/c/matlab/io/MatlabVectorToDoubleVector.cpp

-              r12878
+              r13101
                 /*Check that input is actualy a vector*/
                 if (cols!=1) _error2_("input vector of size " << rows << "x" << cols << " should have only one column");
+                if (cols!=1) _error_("input vector of size " << rows << "x" << cols << " should have only one column");
                 nz=(int)((double)nnz/(double)rows);
 …
                 /*Check that input is actualy a vector*/
                 if (cols!=1) _error2_("input vector of size " << rows << "x" << cols << " should have only one column");
+                if (cols!=1) _error_("input vector of size " << rows << "x" << cols << " should have only one column");
                 /*allocate and memcpy*/

issm/branches/trunk-jpl-damage/src/c/matlab/io/OptionParse.cpp

-              r12878
+              r13101
         /*check and parse the value  */
         if (!mxIsClass(prhs[0],"double")){
                 _error2_("Value of option \"" << odouble->name  << "\" must be class \"double\", not class \"" << mxGetClassName(prhs[0]) <<"\".");
+                _error_("Value of option \"" << odouble->name  << "\" must be class \"double\", not class \"" << mxGetClassName(prhs[0]) <<"\".");
+        }
         FetchData(&odouble->values,&odouble->numel,&odouble->ndims,&odouble->size,prhs[0]);
 …
         /*check and parse the value  */
         if (!mxIsClass(prhs[0],"logical")){
                 _error2_("Value of option \"" << ological->name  << "\" must be class \"logical\", not class \"" << mxGetClassName(prhs[0]) <<"\".");
+                _error_("Value of option \"" << ological->name  << "\" must be class \"logical\", not class \"" << mxGetClassName(prhs[0]) <<"\".");
+        }
         FetchData(&ological->values,&ological->numel,&ological->ndims,&ological->size,prhs[0]);
 …
         /*check and parse the value  */
         if (!mxIsClass(prhs[0],"char")){
                 _error2_("Value of option \"" << ochar->name  << "\" must be class \"char\", not class \"" << mxGetClassName(prhs[0]) <<"\".");
+                _error_("Value of option \"" << ochar->name  << "\" must be class \"char\", not class \"" << mxGetClassName(prhs[0]) <<"\".");
+        }
         FetchData(&ochar->values,&ochar->numel,&ochar->ndims,&ochar->size,prhs[0]);
 …
         /*check and parse the value  */
         if (!mxIsClass(prhs[0],"struct")){
                 _error2_("Value of option \"" << ostruct->name  << "\" must be class \"struct\", not class \"" << mxGetClassName(prhs[0]) <<"\".");
+                _error_("Value of option \"" << ostruct->name  << "\" must be class \"struct\", not class \"" << mxGetClassName(prhs[0]) <<"\".");
+        }
         ostruct->numel=mxGetNumberOfElements(prhs[0]);
 …
         /*check and parse the value  */
         if (!mxIsClass(prhs[0],"cell")){
                 _error2_("Value of option \"" << ocell->name  << "\" must be class \"cell\", not class \"" << mxGetClassName(prhs[0]) <<"\".");
+                _error_("Value of option \"" << ocell->name  << "\" must be class \"cell\", not class \"" << mxGetClassName(prhs[0]) <<"\".");
+        }
 …
                         mxDestroyArray(lhs[0]);
+                }
                 else _error2_("Second argument value of option \""<< name <<"\" is of unrecognized class \""<< mxGetClassName(prhs[0]) <<"\".");
+                else _error_("Second argument value of option \""<< name <<"\" is of unrecognized class \""<< mxGetClassName(prhs[0]) <<"\".");
+        }

issm/branches/trunk-jpl-damage/src/c/modules/ControlInputScaleGradientx/ControlInputScaleGradientx.cpp

-              r12878
+              r13101
 #include "../../EnumDefinitions/EnumDefinitions.h"
 void ControlInputScaleGradientx(Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,double* norm_list,int step){
+void ControlInputScaleGradientx(Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,IssmDouble* norm_list,int step){
         /*Intermediaries*/
         int     i,j,num_controls;
         int    *control_type = NULL;
         double *scalar_list = NULL;
         double  scalar;
+        IssmDouble *scalar_list = NULL;
+        IssmDouble  scalar;
 …
         /*Clean up and return*/
         xDelete<int>(control_type);
         xDelete<double>(scalar_list);
+        xDelete<IssmDouble>(scalar_list);
+}

issm/branches/trunk-jpl-damage/src/c/modules/ControlInputScaleGradientx/ControlInputScaleGradientx.h

r12878	r13101
8	8	#include "../../Container/Container.h"
9	9
10		void ControlInputScaleGradientx(Elements* elements,Nodes* nodes, Vertices* vertices,Loads* loads, Materials* materials, Parameters* parameters,double* norm_list,int step);
	10	void ControlInputScaleGradientx(Elements* elements,Nodes* nodes, Vertices* vertices,Loads* loads, Materials* materials, Parameters* parameters,IssmDouble* norm_list,int step);
11	11
12	12	#endif

issm/branches/trunk-jpl-damage/src/c/modules/ControlInputSetGradientx/ControlInputSetGradientx.cpp

-              r12878
+              r13101
 #include "../../EnumDefinitions/EnumDefinitions.h"
 void ControlInputSetGradientx(Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,double* gradient){
+void ControlInputSetGradientx(Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,IssmDouble* gradient){
         /*Intermediaries*/
 …
         /*Serialize gradient*/
         double* serial_gradient=NULL;
+        IssmDouble* serial_gradient=NULL;
         serial_gradient=gradient->ToMPISerial();
 …
         /*Clean up and return*/
         xDelete<double>(serial_gradient);
+        xDelete<IssmDouble>(serial_gradient);
+}

issm/branches/trunk-jpl-damage/src/c/modules/CostFunctionx/CostFunctionx.cpp

-              r12878
+              r13101
 #include "../Responsex/Responsex.h"
 void CostFunctionx(double* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters){
+void CostFunctionx(IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters){
         /*Intermediary*/
         int      i;
         int      num_responses;
-        double   S;
         Element *element       = NULL;
         int     *responses     = NULL;
         /*output: */
         double J,Jplus;
+        IssmDouble J,Jplus;
         /*Recover parameters*/

issm/branches/trunk-jpl-damage/src/c/modules/CostFunctionx/CostFunctionx.h

r12878	r13101
10	10
11	11	/* local prototypes: */
12		void CostFunctionx( double* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters);
	12	void CostFunctionx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters);
13	13
14	14	#endif

issm/branches/trunk-jpl-damage/src/c/modules/DakotaResponsesx/DakotaResponsesx.cpp

r12878	r13101
86	86	}
87	87	else if (flag==NodalEnum){
88		_error2_("nodal response functions not supported yet!");
	88	_error_("nodal response functions not supported yet!");
89	89
90	90	/increment response_pointer :/
…	…
104	104	}
105	105	}
106		else _error2_("flag type " << flag << " not supported yet for response analysis");
	106	else _error_("flag type " << flag << " not supported yet for response analysis");
107	107	}
108	108

issm/branches/trunk-jpl-damage/src/c/modules/Dakotax/DescriptorIndex.cpp

-              r12878
+              r13101
         /*retrieve first token, separated by underscore: */
         pch = strtok (descriptor,"_");
         if(!pch)_error2_("descriptor " << descriptor << " is not correctly formatted!");
+        if(!pch)_error_("descriptor " << descriptor << " is not correctly formatted!");
         if (strncmp(pch,"scaled",6)==0){
                 /*we have a scaled variable. recover the root: */
                 pch = strtok (NULL, "_");
                 if(!pch)_error2_("scaled descriptor " << descriptor << " is not correctly formatted!");
+                if(!pch)_error_("scaled descriptor " << descriptor << " is not correctly formatted!");
                 memcpy(root,pch,(strlen(pch)+1)*sizeof(char));
 …
                 /*we have an indexed variable. recover the root: */
                 pch = strtok (NULL, "_");
                 if(!pch)_error2_("indexed descriptor " << descriptor << " is not correctly formatted!");
+                if(!pch)_error_("indexed descriptor " << descriptor << " is not correctly formatted!");
                 memcpy(root,pch,(strlen(pch)+1)*sizeof(char));
                 /*now recover  the index: */
                 pch = strtok (NULL, "_");
                 if(!pch)_error2_("indexed descriptor " << descriptor << " is not correctly formatted!");
+                if(!pch)_error_("indexed descriptor " << descriptor << " is not correctly formatted!");
                 sscanf(pch,"%i",pindex);
                 return IndexedEnum;
 …
                 /*we have an indexed variable. recover the root: */
                 pch = strtok (NULL, "_");
                 if(!pch)_error2_("nodal descriptor " << descriptor << " is not correctly formatted!");
+                if(!pch)_error_("nodal descriptor " << descriptor << " is not correctly formatted!");
                 memcpy(root,pch,(strlen(pch)+1)*sizeof(char));
                 /*now recover  the index: */
                 pch = strtok (NULL, "_");
                 if(!pch)_error2_("nodal descriptor " << descriptor << " is not correctly formatted!");
+                if(!pch)_error_("nodal descriptor " << descriptor << " is not correctly formatted!");
                 sscanf(pch,"%i",pindex);
                 return NodalEnum;

issm/branches/trunk-jpl-damage/src/c/modules/Dakotax/SpawnCoreParallel.cpp

r12878	r13101
72	72	if(control_analysis)solutioncore=&control_core;
73	73	#else
74		_error2_("ISSM was not compiled with control capabilities, exiting!");
	74	_error_("ISSM was not compiled with control capabilities, exiting!");
75	75	#endif
76	76

issm/branches/trunk-jpl-damage/src/c/modules/DragCoefficientAbsGradientx/DragCoefficientAbsGradientx.cpp

-              r12168
+              r13101
 #include "../../EnumDefinitions/EnumDefinitions.h"
 void DragCoefficientAbsGradientx( double* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units, int weight_index){
+void DragCoefficientAbsGradientx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units, int weight_index){
         /*Intermediary*/
 …
         /*output: */
         double J=0;
         double J_sum;
+        IssmDouble J=0;
+        IssmDouble J_sum;
         /*Compute Misfit: */

issm/branches/trunk-jpl-damage/src/c/modules/DragCoefficientAbsGradientx/DragCoefficientAbsGradientx.h

r12878	r13101
10	10
11	11	/* local prototypes: */
12		void DragCoefficientAbsGradientx( double* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units,int weight_index);
	12	void DragCoefficientAbsGradientx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units,int weight_index);
13	13
14	14	#endif

issm/branches/trunk-jpl-damage/src/c/modules/ElementResponsex/ElementResponsex.cpp

-              r12878
+              r13101
 #include "../../EnumDefinitions/EnumDefinitions.h"
 void ElementResponsex( double* presponse, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,int response_enum,bool process_units){
+void ElementResponsex( IssmDouble* presponse, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,int response_enum,bool process_units){
 …
         int cpu_found=-1;
         int index;
         double response;
+        IssmDouble response;
         Element* element=NULL;
 …
         #ifdef _HAVE_MPI_
         MPI_Allreduce ( &found,&sumfound,1,MPI_INT,MPI_SUM,MPI_COMM_WORLD);
         if(!sumfound)_error2_("could not find material with id" << index << " to compute ElementResponse");
+        if(!sumfound)_error_("could not find material with id" << index << " to compute ElementResponse");
         #endif

issm/branches/trunk-jpl-damage/src/c/modules/ElementResponsex/ElementResponsex.h

r12878	r13101
10	10
11	11	/* local prototypes: */
12		void ElementResponsex( double* presponse, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,int response_enum,bool process_units);
	12	void ElementResponsex( IssmDouble* presponse, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,int response_enum,bool process_units);
13	13
14	14	#endif /* _ELEMENTRESPONSEX_H */

issm/branches/trunk-jpl-damage/src/c/modules/EnumToStringx/EnumToStringx.cpp

-              r12946
+              r13101
         switch(en){
-                case AutodiffForwardEnum : return "AutodiffForward";
                 case AutodiffIsautodiffEnum : return "AutodiffIsautodiff";
-                case AutodiffReverseEnum : return "AutodiffReverse";
                 case BalancethicknessSpcthicknessEnum : return "BalancethicknessSpcthickness";
                 case BalancethicknessStabilizationEnum : return "BalancethicknessStabilization";
 …
                 case FlowequationElementEquationEnum : return "FlowequationElementEquation";
                 case FlowequationIshutterEnum : return "FlowequationIshutter";
+                case FlowequationIsl1l2Enum : return "FlowequationIsl1l2";
                 case FlowequationIsmacayealpattynEnum : return "FlowequationIsmacayealpattyn";
                 case FlowequationIsstokesEnum : return "FlowequationIsstokes";
 …
                 case TransientSolutionEnum : return "TransientSolution";
                 case ApproximationEnum : return "Approximation";
+                case NoneApproximationEnum : return "NoneApproximation";
                 case HutterApproximationEnum : return "HutterApproximation";
                 case MacAyealApproximationEnum : return "MacAyealApproximation";
                 case MacAyealPattynApproximationEnum : return "MacAyealPattynApproximation";
                 case MacAyealStokesApproximationEnum : return "MacAyealStokesApproximation";
                 case NoneApproximationEnum : return "NoneApproximation";
+                case L1L2ApproximationEnum : return "L1L2Approximation";
                 case PattynApproximationEnum : return "PattynApproximation";
                 case PattynStokesApproximationEnum : return "PattynStokesApproximation";
 …
                 case NumericalfluxEnum : return "Numericalflux";
                 case ParamEnum : return "Param";
+                case L1L2IceFrontEnum : return "L1L2IceFront";
                 case PattynIceFrontEnum : return "PattynIceFront";
                 case PengridEnum : return "Pengrid";
 …
                 case EnthalpyPicardEnum : return "EnthalpyPicard";
                 case ThicknessAbsGradientEnum : return "ThicknessAbsGradient";
+                case ThicknessAlongGradientEnum : return "ThicknessAlongGradient";
+                case ThicknessAcrossGradientEnum : return "ThicknessAcrossGradient";
                 case StepResponsesEnum : return "StepResponses";
                 case IntMatParamEnum : return "IntMatParam";
 …
                 case StressTensoryzEnum : return "StressTensoryz";
                 case StressTensorzzEnum : return "StressTensorzz";
-                case IceVolumeEnum : return "IceVolume";
-                case TotalSmbEnum : return "TotalSmb";
-                case ThicknessAlongGradientEnum : return "ThicknessAlongGradient";
-                case ThicknessAcrossGradientEnum : return "ThicknessAcrossGradient";
                 case P0Enum : return "P0";
                 case P1Enum : return "P1";
 …
                 case MaxVzEnum : return "MaxVz";
                 case MaxAbsVzEnum : return "MaxAbsVz";
+                case IceVolumeEnum : return "IceVolume";
+                case TotalSmbEnum : return "TotalSmb";
                 case RelativeEnum : return "Relative";
                 case AbsoluteEnum : return "Absolute";

issm/branches/trunk-jpl-damage/src/c/modules/Exp2Kmlx/Exp2Kmlx.cpp

r12878	r13101
55	55
56	56	if (!DomainOutlineRead(&nprof,&pnvert,&pprofx,&pprofy,&closed,filexp))
57		_error2_("Error reading exp file.");
	57	_error_("Error reading exp file.");
58	58	_pprintLine_("Exp2Kmlx -- Reading " << nprof << " exp profiles from file \"" << filexp << "\".");
59	59	// for (i=0; i<nprof; i++)

issm/branches/trunk-jpl-damage/src/c/modules/GetSolutionFromInputsx/GetSolutionFromInputsx.cpp

r12878	r13101
26	26	/Get size of vector: /
27	27	gsize=nodes->NumberOfDofs(configuration_type,GsetEnum);
28		if (gsize==0) _error2_("Allocating a Vec of size 0 as gsize=0 for configuration: " << EnumToStringx(configuration_type));
	28	if (gsize==0) _error_("Allocating a Vec of size 0 as gsize=0 for configuration: " << EnumToStringx(configuration_type));
29	29
30	30	/Initialize solution: /

issm/branches/trunk-jpl-damage/src/c/modules/GetVectorFromControlInputsx/GetVectorFromControlInputsx.cpp

-              r12878
+              r13101
+}
 void GetVectorFromControlInputsx( double** pvector, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters, const char* data){
+void GetVectorFromControlInputsx( IssmDouble** pvector, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters, const char* data){
         /*output: */
         double* vector=NULL;
+        IssmDouble* vector=NULL;
         /*intermediary: */

issm/branches/trunk-jpl-damage/src/c/modules/GetVectorFromControlInputsx/GetVectorFromControlInputsx.h

r12878	r13101
10	10	/* local prototypes: */
11	11	void GetVectorFromControlInputsx( Vector** pvector, Elements* elements,Nodes* nodes, Vertices* vertices,Loads* loads, Materials* materials, Parameters* parameters,const char* data="value");
12		void GetVectorFromControlInputsx( double** pvector, Elements* elements,Nodes* nodes, Vertices* vertices,Loads* loads, Materials* materials, Parameters* parameters,const char* data="value");
	12	void GetVectorFromControlInputsx( IssmDouble** pvector, Elements* elements,Nodes* nodes, Vertices* vertices,Loads* loads, Materials* materials, Parameters* parameters,const char* data="value");
13	13
14	14	#endif /* _GETVECTORFROMCONTROLINPUTSXX_H */

issm/branches/trunk-jpl-damage/src/c/modules/GetVectorFromInputsx/GetVectorFromInputsx.cpp

r12878	r13101
32	32	}
33	33	else{
34		_error2_("vector type: " << EnumToStringx(type) << " not supported yet!");
	34	_error_("vector type: " << EnumToStringx(type) << " not supported yet!");
35	35	}
36	36

issm/branches/trunk-jpl-damage/src/c/modules/Gradjx/Gradjx.cpp

-              r12878
+              r13101
 #include "../../EnumDefinitions/EnumDefinitions.h"
 void Gradjx(Vector** pgradient,double** pnorm_list, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters){
+void Gradjx(Vector** pgradient,IssmDouble** pnorm_list, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters){
         int     i,j,numberofvertices;
         int     num_controls;
         double   norm_inf;
         double  *norm_list     = NULL;
+        IssmDouble   norm_inf;
+        IssmDouble  *norm_list     = NULL;
         int     *control_type  = NULL;
         Vector  *gradient      = NULL;
 …
         /*Allocate gradient_list */
         gradient_list = xNew<Vector*>(num_controls);
         norm_list = xNew<double>(num_controls);
+        norm_list = xNew<IssmDouble>(num_controls);
         for(i=0;i<num_controls;i++){
                 gradient_list[i]=new Vector(num_controls*numberofvertices);
 …
         /*Check that gradient is clean*/
         norm_inf=gradient->Norm(NORM_INF);
         if(norm_inf<=0)    _error2_("||∂J/∂α||∞ = 0    gradient norm is zero");
         if(xIsNan<IssmDouble>(norm_inf))_error2_("||∂J/∂α||∞ = NaN  gradient norm is NaN");
+        if(norm_inf<=0)    _error_("||∂J/∂α||∞ = 0    gradient norm is zero");
+        if(xIsNan<IssmDouble>(norm_inf))_error_("||∂J/∂α||∞ = NaN  gradient norm is NaN");
         /*Clean-up and assign output pointer*/
 …
+        }
         else{
                 xDelete<double>(norm_list);
+                xDelete<IssmDouble>(norm_list);
+        }
         if(pgradient)  *pgradient=gradient;

issm/branches/trunk-jpl-damage/src/c/modules/Gradjx/Gradjx.h

r12878	r13101
10	10
11	11	/* local prototypes: */
12		void Gradjx(Vector pgrad_g,double pgrad_norm,Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters);
	12	void Gradjx(Vector pgrad_g,IssmDouble pgrad_norm,Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters);
13	13
14	14	#endif /* _GRADJX_H */

issm/branches/trunk-jpl-damage/src/c/modules/GroundinglineMigrationx/GroundinglineMigrationx.cpp

-              r12878
+              r13101
         int      i, migration_style,analysis_type;
         double*  vertices_potentially_ungrounding = NULL;
         double*  vertices_ungrounding             = NULL;
         double*  old_floatingice                  = NULL;
+        IssmDouble*  vertices_potentially_ungrounding = NULL;
+        IssmDouble*  vertices_ungrounding             = NULL;
+        IssmDouble*  old_floatingice                  = NULL;
         Vector*      vec_old_floatingice              = NULL;
         Element* element                          = NULL;
 …
         if(migration_style==NoneEnum) return;
         if(migration_style!=AgressiveMigrationEnum && migration_style!=SoftMigrationEnum) _error2_(EnumToStringx(migration_style) << " not supported yet!");
+        if(migration_style!=AgressiveMigrationEnum && migration_style!=SoftMigrationEnum) _error_(EnumToStringx(migration_style) << " not supported yet!");
         if(migration_style==SoftMigrationEnum){
 …
         /*free ressouces: */
         xdelete(&vec_old_floatingice);
         xDelete<double>(vertices_potentially_ungrounding);
         xDelete<double>(vertices_ungrounding);
         xDelete<double>(old_floatingice);
+        xDelete<IssmDouble>(vertices_potentially_ungrounding);
+        xDelete<IssmDouble>(vertices_ungrounding);
+        xDelete<IssmDouble>(old_floatingice);
+}
 …
 /*%}}}*/
 /*FUNCTION PotentialSheetUngrounding {{{*/
 double*    PotentialSheetUngrounding(Elements* elements,Vertices* vertices,Parameters* parameters){
+IssmDouble*    PotentialSheetUngrounding(Elements* elements,Vertices* vertices,Parameters* parameters){
         int      i,numberofvertices;
         double*  vertices_potentially_ungrounding      = NULL;
+        IssmDouble*  vertices_potentially_ungrounding      = NULL;
         Vector*      vec_vertices_potentially_ungrounding  = NULL;
         Element* element                               = NULL;
 …
 /*}}}*/
 /*FUNCTION PropagateFloatingiceToGroundedNeighbors {{{*/
 double*    PropagateFloatingiceToGroundedNeighbors(Elements* elements,Nodes* nodes,Vertices* vertices,Parameters* parameters,double* vertices_potentially_ungrounding){
+IssmDouble*    PropagateFloatingiceToGroundedNeighbors(Elements* elements,Nodes* nodes,Vertices* vertices,Parameters* parameters,IssmDouble* vertices_potentially_ungrounding){
         int      i,analysis_type;
         int      numberofvertices;
         int      nflipped,local_nflipped;
         double*  nodes_on_floatingice                  = NULL;
         double*  elements_neighboring_floatingce      = NULL;
+        IssmDouble*  nodes_on_floatingice                  = NULL;
+        IssmDouble*  elements_neighboring_floatingce      = NULL;
         Vector*      vec_elements_neighboring_floatingice = NULL;
         Vector*      vec_nodes_on_floatingice              = NULL;
 …
                 for(i=0;i<elements->Size();i++){
                         element=(Element*)elements->GetObjectByOffset(i);
                         if(elements_neighboring_floatingce[element->Sid()]){
+                        if(reCast<int,IssmDouble>(elements_neighboring_floatingce[element->Sid()])){
                                 local_nflipped+=element->UpdatePotentialSheetUngrounding(vertices_potentially_ungrounding,vec_nodes_on_floatingice,nodes_on_floatingice);
+                        }
 …
                 /*Avoid leaks: */
                 xDelete<double>(elements_neighboring_floatingce);
                 xDelete<double>(nodes_on_floatingice);
+                xDelete<IssmDouble>(elements_neighboring_floatingce);
+                xDelete<IssmDouble>(nodes_on_floatingice);
                 /*Assemble and serialize:*/
 …
         /*Free ressources:*/
         xdelete(&vec_nodes_on_floatingice);
         xDelete<double>(elements_neighboring_floatingce);
+        xDelete<IssmDouble>(elements_neighboring_floatingce);
         return nodes_on_floatingice;

issm/branches/trunk-jpl-damage/src/c/modules/GroundinglineMigrationx/GroundinglineMigrationx.h

-              r11708
+              r13101
 Vector*        CreateNodesOnFloatingIce(Nodes* nodes,int configuration_type);
 double*    PotentialSheetUngrounding(Elements* elements,Vertices* vertices,Parameters* parameters);
 double*    PropagateFloatingiceToGroundedNeighbors(Elements* elements,Nodes* nodes,Vertices* vertices,Parameters* parameters,double* vertices_potentially_ungrounding);
+IssmDouble*    PotentialSheetUngrounding(Elements* elements,Vertices* vertices,Parameters* parameters);
+IssmDouble*    PropagateFloatingiceToGroundedNeighbors(Elements* elements,Nodes* nodes,Vertices* vertices,Parameters* parameters,IssmDouble* vertices_potentially_ungrounding);
 #endif  /* _GROUNDINGLINEMIGRATIONX_H */

issm/branches/trunk-jpl-damage/src/c/modules/IceVolumex/IceVolumex.cpp

-              r12168
+              r13101
 #include "../../EnumDefinitions/EnumDefinitions.h"
 void IceVolumex(double* pV, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
+void IceVolumex(IssmDouble* pV, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
         double local_ice_volume = 0;
         double total_ice_volume;
+        IssmDouble local_ice_volume = 0;
+        IssmDouble total_ice_volume;
         for(int i=0;i<elements->Size();i++){

issm/branches/trunk-jpl-damage/src/c/modules/IceVolumex/IceVolumex.h

r12878	r13101
10	10
11	11	/* local prototypes: */
12		void IceVolumex(double* pV, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
	12	void IceVolumex(IssmDouble* pV, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
13	13
14	14	#endif

issm/branches/trunk-jpl-damage/src/c/modules/InputControlUpdatex/InputControlUpdatex.cpp

r4967	r13101
9	9	#include "../../EnumDefinitions/EnumDefinitions.h"
10	10
11		void InputControlUpdatex(Elements* elements,Nodes* nodes,Vertices* vertices,Loads* loads,Materials* materials,Parameters* parameters,double scalar,bool save_parameter){
	11	void InputControlUpdatex(Elements* elements,Nodes* nodes,Vertices* vertices,Loads* loads,Materials* materials,Parameters* parameters,IssmDouble scalar,bool save_parameter){
12	12
13	13	/Go through elemnets, and ask to carry out the operation on inputs: /

issm/branches/trunk-jpl-damage/src/c/modules/InputControlUpdatex/InputControlUpdatex.h

r4967	r13101
9	9
10	10	/* local prototypes: */
11		void InputControlUpdatex(Elements* elements,Nodes* nodes,Vertices* vertices,Loads* loads,Materials* materials,Parameters* parameters, double scalar,bool save_parameter);
	11	void InputControlUpdatex(Elements* elements,Nodes* nodes,Vertices* vertices,Loads* loads,Materials* materials,Parameters* parameters, IssmDouble scalar,bool save_parameter);
12	12
13	13	#endif

issm/branches/trunk-jpl-damage/src/c/modules/InputUpdateFromDakotax/InputUpdateFromDakotax.cpp

r12878	r13101
95	95	}
96	96	else if (strncmp(descriptor,"indexed_",8)==0){
97		_error2_("indexed variables not supported yet!");
	97	_error_("indexed variables not supported yet!");
98	98	}
99	99	else if (strncmp(descriptor,"nodal_",8)==0){
100		_error2_("nodal variables not supported yet!");
	100	_error_("nodal variables not supported yet!");
101	101	}
102	102	else{

issm/branches/trunk-jpl-damage/src/c/modules/InterpFromGridToMeshx/InterpFromGridToMeshx.cpp

r12878	r13101
37	37	/Some checks on arguments: /
38	38	if ((M<2) \|\| (N<2) \|\| (nods<=0)){
39		_error2_("nothing to be done according to the dimensions of input matrices and vectors.");
	39	_error_("nothing to be done according to the dimensions of input matrices and vectors.");
40	40	}
41	41	if (x_in[1]-x_in[0]<0){
42		_error2_("x coordinate vector should be increasing.\n use Matlab's command x=flipud(x), also flip the data matrix data=fliplr(data)");
	42	_error_("x coordinate vector should be increasing.\n use Matlab's command x=flipud(x), also flip the data matrix data=fliplr(data)");
43	43	}
44	44	if (y_in[1]-y_in[0]<0){
45		_error2_("y coordinate vector should be increasing.\n use Matlab's command y=flipud(y), also flip the data matrix data=flipud(data)");
	45	_error_("y coordinate vector should be increasing.\n use Matlab's command y=flipud(y), also flip the data matrix data=flipud(data)");
46	46	}
47	47
…	…
69	69	}
70	70	else{
71		_error2_("x and y vectors length should be 1 or 0 more than data number of rows.");
	71	_error_("x and y vectors length should be 1 or 0 more than data number of rows.");
72	72	}
73	73

issm/branches/trunk-jpl-damage/src/c/modules/InterpFromMesh2dx/InterpFromMesh2dx.cpp

r12878	r13101
40	40	/some checks/
41	41	if (nels_data<1 \|\| nods_data<3 \|\| nods_prime==0){
42		_error2_("nothing to be done according to the mesh given in input");
	42	_error_("nothing to be done according to the mesh given in input");
43	43	}
44	44
…	…
54	54	}
55	55	else{
56		_error2_("length of vector data not supported yet. It should be of length (number of nodes) or (number of elements)!");
	56	_error_("length of vector data not supported yet. It should be of length (number of nodes) or (number of elements)!");
57	57	}
58	58
59	59	if((numcontours) && (interpolation_type==2)){
60		_error2_("element interpolation_type with contours not supported yet!");
	60	_error_("element interpolation_type with contours not supported yet!");
61	61	}
62	62

issm/branches/trunk-jpl-damage/src/c/modules/InterpFromMeshToGridx/InterpFromMeshToGridx.cpp

r12878	r13101
30	30	/some checks/
31	31	if (nels<1 \|\| nods<3 \|\| nlines<1 \|\| ncols<1 \|\| xposting==0 \|\| yposting==0){
32		_error2_("nothing to be done according to the mesh given in input");
	32	_error_("nothing to be done according to the mesh given in input");
33	33	}
34	34
…	…
41	41	}
42	42	else{
43		_error2_("length of vector data not supported yet. It should be of length (number of nodes) or (number of elements)!");
	43	_error_("length of vector data not supported yet. It should be of length (number of nodes) or (number of elements)!");
44	44	}
45	45

issm/branches/trunk-jpl-damage/src/c/modules/InterpFromMeshToMesh2dx/InterpFromMeshToMesh2dx.cpp

-              r12878
+              r13101
         /*Checks*/
         if (M_data!=nods_data && M_data!=nels_data){
                 _error2_("data provided should have either " << nods_data << " or " << nels_data << " lines (not " << M_data << ")");
+                _error_("data provided should have either " << nods_data << " or " << nels_data << " lines (not " << M_data << ")");
+        }
 …
                         for (j=0;j<N_data;j++){
                                 if (it<0 || it>=nels_data){
                                         _error2_("Triangle number " << it << " not in [0 " << nels_data << "], report bug to developers");
+                                        _error_("Triangle number " << it << " not in [0 " << nels_data << "], report bug to developers");
+                                }
                                 data_interp[i*N_data+j]=data[N_data*it+j];

issm/branches/trunk-jpl-damage/src/c/modules/InterpFromMeshToMesh3dx/InterpFromMeshToMesh3dx.cpp

r12878	r13101
27	27	/some checks/
28	28	if (nels_data<1 \|\| nods_data<6 \|\| nods_prime==0){
29		_error2_("nothing to be done according to the mesh given in input");
	29	_error_("nothing to be done according to the mesh given in input");
30	30	}
31	31
…	…
41	41	}
42	42	else{
43		_error2_("length of vector data not supported yet. It should be of length (number of nodes) or (number of elements)!");
	43	_error_("length of vector data not supported yet. It should be of length (number of nodes) or (number of elements)!");
44	44	}
45	45

issm/branches/trunk-jpl-damage/src/c/modules/IoModelToConstraintsx/IoModelToConstraintsx.cpp

-              r12878
+              r13101
         fid=iomodel->SetFilePointerToData(&code, &vector_layout,vector_enum);
         if(code!=7)_error2_("expecting a IssmDouble vector for constraints with enum " << EnumToStringx(vector_enum));
         if(vector_layout!=1)_error2_("expecting a nodal vector for constraints with enum " << EnumToStringx(vector_enum));
+        if(code!=7)_error_("expecting a IssmDouble vector for constraints with enum " << EnumToStringx(vector_enum));
+        if(vector_layout!=1)_error_("expecting a nodal vector for constraints with enum " << EnumToStringx(vector_enum));
         /*Fetch vector:*/
 …
+        }
         else{
                 _error2_("Size of field " << EnumToStringx(vector_enum) << " not supported");
+                _error_("Size of field " << EnumToStringx(vector_enum) << " not supported");
+        }

issm/branches/trunk-jpl-damage/src/c/modules/KMLMeshWritex/KMLMeshWritex.cpp

r12878	r13101
133	133	}
134	134	else
135		_error2_("Nodal connectivity table needs more than specified " << mxepg << " columns.\n");
	135	_error_("Nodal connectivity table needs more than specified " << mxepg << " columns.\n");
136	136	}
137	137	jpt++;
…	…
173	173
174	174	else
175		_error2_("Data matrix has incorrect number of " << mdata << " rows.\n");
	175	_error_("Data matrix has incorrect number of " << mdata << " rows.\n");
176	176	}
177	177

issm/branches/trunk-jpl-damage/src/c/modules/Kml2Expx/Kml2Expx.cpp

r12878	r13101
44	44	fidi=fopen(filkml,"r");
45	45	if (!(kobj=KMLFileReadx(fidi)))
46		_error2_("Error reading kml file.");
	46	_error_("Error reading kml file.");
47	47	fclose(fidi);
48	48

issm/branches/trunk-jpl-damage/src/c/modules/Krigingx/Krigingx.cpp

r12878	r13101
138	138	}
139	139	else{
140		_error2_("output '" << output << "' not supported yet");
	140	_error_("output '" << output << "' not supported yet");
141	141	}
142	142
…	…
305	305	else if(strcmp(model,"spherical")==0) variogram = new SphericalVariogram(options);
306	306	else if(strcmp(model,"power")==0) variogram = new PowerVariogram(options);
307		else _error2_("variogram " << model << " not supported yet (list of supported variogram: gaussian, exponential, spherical and power)");
	307	else _error_("variogram " << model << " not supported yet (list of supported variogram: gaussian, exponential, spherical and power)");
308	308	}
309	309	else variogram = new GaussianVariogram(options);

issm/branches/trunk-jpl-damage/src/c/modules/Krigingx/pKrigingx.cpp

r12878	r13101
103	103	}
104	104	else{
105		_error2_("output '" << output << "' not supported yet");
	105	_error_("output '" << output << "' not supported yet");
106	106	}
107	107
…	…
126	126	else if(strcmp(model,"spherical")==0) variogram = new SphericalVariogram(options);
127	127	else if(strcmp(model,"power")==0) variogram = new PowerVariogram(options);
128		else _error2_("variogram " << model << " not supported yet (list of supported variogram: gaussian, exponential, spherical and power)");
	128	else _error_("variogram " << model << " not supported yet (list of supported variogram: gaussian, exponential, spherical and power)");
129	129	}
130	130	else variogram = new GaussianVariogram(options);

issm/branches/trunk-jpl-damage/src/c/modules/Ll2xyx/Ll2xyx.cpp

-              r12878
+              r13101
         double  T,rho,sl,tc,mc;
         if((sgn!=1) && (sgn!=-1)) _error2_("Sign should be either +1 or -1.\n");
+        if((sgn!=1) && (sgn!=-1)) _error_("Sign should be either +1 or -1.\n");
         delta = central_meridian;
 …
                 if(flag) _pprintLine_("Info: creating coordinates in polar stereographic (Std Latitude: 71S Meridian: 0).");
+        }
         else _error2_("Sign should be either +1 or -1.\n");
+        else _error_("Sign should be either +1 or -1.\n");
         return;

issm/branches/trunk-jpl-damage/src/c/modules/MassFluxx/MassFluxx.cpp

-              r12878
+              r13101
 #include "../../EnumDefinitions/EnumDefinitions.h"
 void MassFluxx(double* pmass_flux, Elements* elements,Nodes* nodes, Vertices* vertices,Loads* loads,Materials* materials, Parameters* parameters,bool process_units){
+void MassFluxx(IssmDouble* pmass_flux, Elements* elements,Nodes* nodes, Vertices* vertices,Loads* loads,Materials* materials, Parameters* parameters,bool process_units){
         int i,j;
 …
         /*output: */
         double mass_flux=0;
         double all_mass_flux=0;
+        IssmDouble mass_flux=0;
+        IssmDouble all_mass_flux=0;
         int  counter;
         /*all segments: */
         double** array=NULL;
+        IssmDouble** array=NULL;
         int      M;
         int*     mdims_array=NULL;
 …
         /*our segments of interest: */
         double*  segments=NULL;
+        IssmDouble*  segments=NULL;
         int      num_segments;
 …
          * When we find one, use the element to compute the mass flux on the segment: */
         for(i=0;i<num_segments;i++){
                 element_id=(int)*(segments+5*i+4);
+                element_id=reCast<int,IssmDouble>(*(segments+5*i+4));
                 for(j=0;j<elements->Size();j++){
                         element=(Element*)elements->GetObjectByOffset(j);
 …
         /*Free ressources:*/
         for(j=0;j<M;j++){
                 double* matrix=array[j];
                 xDelete<double>(matrix);
+                IssmDouble* matrix=array[j];
+                xDelete<IssmDouble>(matrix);
+        }
         xDelete<int>(mdims_array);
         xDelete<int>(ndims_array);
         xDelete<double*>(array);
+        xDelete<IssmDouble*>(array);
         /*Assign output pointers: */

issm/branches/trunk-jpl-damage/src/c/modules/MassFluxx/MassFluxx.h

r12878	r13101
10	10
11	11	/* local prototypes: */
12		void MassFluxx(double* pmass_flux, Elements* elements,Nodes* nodes, Vertices* vertices,Loads* loads,Materials* materials, Parameters* parameters,bool process_units);
	12	void MassFluxx(IssmDouble* pmass_flux, Elements* elements,Nodes* nodes, Vertices* vertices,Loads* loads,Materials* materials, Parameters* parameters,bool process_units);
13	13
14	14

issm/branches/trunk-jpl-damage/src/c/modules/MaxAbsVxx/MaxAbsVxx.cpp

-              r12168
+              r13101
 #include "../../EnumDefinitions/EnumDefinitions.h"
 void MaxAbsVxx( double* pmaxabsvx, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
+void MaxAbsVxx( IssmDouble* pmaxabsvx, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
         int i;
         double maxabsvx;
         double node_maxabsvx;
         double element_maxabsvx;
+        IssmDouble maxabsvx;
+        IssmDouble node_maxabsvx;
+        IssmDouble element_maxabsvx;
         /*Go through elements, and request velocity: */

issm/branches/trunk-jpl-damage/src/c/modules/MaxAbsVxx/MaxAbsVxx.h

r12878	r13101
10	10
11	11	/* local prototypes: */
12		void MaxAbsVxx( double* pmaxabsvx, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
	12	void MaxAbsVxx( IssmDouble* pmaxabsvx, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
13	13
14	14	#endif /* _MAXABSVXX_H */

issm/branches/trunk-jpl-damage/src/c/modules/MaxAbsVyx/MaxAbsVyx.cpp

-              r12168
+              r13101
 #include "../../EnumDefinitions/EnumDefinitions.h"
 void MaxAbsVyx( double* pmaxabsvy, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
+void MaxAbsVyx( IssmDouble* pmaxabsvy, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
         int i;
         double maxabsvy;
         double node_maxabsvy;
         double element_maxabsvy;
+        IssmDouble maxabsvy;
+        IssmDouble node_maxabsvy;
+        IssmDouble element_maxabsvy;

issm/branches/trunk-jpl-damage/src/c/modules/MaxAbsVyx/MaxAbsVyx.h

r12878	r13101
10	10
11	11	/* local prototypes: */
12		void MaxAbsVyx( double* pmaxabsvy, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
	12	void MaxAbsVyx( IssmDouble* pmaxabsvy, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
13	13
14	14	#endif /* _MAXABSVYX_H */

issm/branches/trunk-jpl-damage/src/c/modules/MaxAbsVzx/MaxAbsVzx.cpp

-              r12168
+              r13101
 #include "../../EnumDefinitions/EnumDefinitions.h"
 void MaxAbsVzx( double* pmaxabsvz, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
+void MaxAbsVzx( IssmDouble* pmaxabsvz, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
         int i;
         double maxabsvz;
         double node_maxabsvz;
         double element_maxabsvz;
+        IssmDouble maxabsvz;
+        IssmDouble node_maxabsvz;
+        IssmDouble element_maxabsvz;
         /*Go through elements, and request velocity: */

issm/branches/trunk-jpl-damage/src/c/modules/MaxAbsVzx/MaxAbsVzx.h

r12878	r13101
10	10
11	11	/* local prototypes: */
12		void MaxAbsVzx( double* pmaxabsvz, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
	12	void MaxAbsVzx( IssmDouble* pmaxabsvz, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
13	13
14	14	#endif /* _MAXABSVZX_H */

issm/branches/trunk-jpl-damage/src/c/modules/MaxVelx/MaxVelx.cpp

-              r12168
+              r13101
 #include "../../EnumDefinitions/EnumDefinitions.h"
 void MaxVelx( double* pmaxvel, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
+void MaxVelx( IssmDouble* pmaxvel, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
         int i;
         double maxvel;
         double node_maxvel;
         double element_maxvel;
+        IssmDouble maxvel;
+        IssmDouble node_maxvel;
+        IssmDouble element_maxvel;
         /*Go through elements, and request velocity: */

issm/branches/trunk-jpl-damage/src/c/modules/MaxVelx/MaxVelx.h

r12878	r13101
10	10
11	11	/* local prototypes: */
12		void MaxVelx( double* pmaxvel, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
	12	void MaxVelx( IssmDouble* pmaxvel, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
13	13
14	14	#endif /* _MAXVELX_H */

issm/branches/trunk-jpl-damage/src/c/modules/MaxVxx/MaxVxx.cpp

-              r12168
+              r13101
 #include "../../EnumDefinitions/EnumDefinitions.h"
 void MaxVxx( double* pmaxvx, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
+void MaxVxx( IssmDouble* pmaxvx, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
         int i;
         double maxvx;
         double node_maxvx;
         double element_maxvx;
+        IssmDouble maxvx;
+        IssmDouble node_maxvx;
+        IssmDouble element_maxvx;
         /*Go through elements, and request velocity: */

issm/branches/trunk-jpl-damage/src/c/modules/MaxVxx/MaxVxx.h

r12878	r13101
9	9
10	10	/* local prototypes: */
11		void MaxVxx( double* pmaxvx, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
	11	void MaxVxx( IssmDouble* pmaxvx, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
12	12
13	13	#endif /* _MAXVXX_H */

issm/branches/trunk-jpl-damage/src/c/modules/MaxVyx/MaxVyx.cpp

-              r12168
+              r13101
 #include "../../EnumDefinitions/EnumDefinitions.h"
 void MaxVyx( double* pmaxvy, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
+void MaxVyx( IssmDouble* pmaxvy, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
         int i;
         double maxvy;
         double node_maxvy;
         double element_maxvy;
+        IssmDouble maxvy;
+        IssmDouble node_maxvy;
+        IssmDouble element_maxvy;
         /*Go through elements, and request velocity: */

issm/branches/trunk-jpl-damage/src/c/modules/MaxVyx/MaxVyx.h

r12878	r13101
10	10
11	11	/* local prototypes: */
12		void MaxVyx( double* pmaxvy, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
	12	void MaxVyx( IssmDouble* pmaxvy, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
13	13
14	14	#endif /* _MAXVYX_H */

issm/branches/trunk-jpl-damage/src/c/modules/MaxVzx/MaxVzx.cpp

-              r12168
+              r13101
 #include "../../EnumDefinitions/EnumDefinitions.h"
 void MaxVzx( double* pmaxvz, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
+void MaxVzx( IssmDouble* pmaxvz, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
         int i;
         double maxvz;
         double node_maxvz;
         double element_maxvz;
+        IssmDouble maxvz;
+        IssmDouble node_maxvz;
+        IssmDouble element_maxvz;
         /*Go through elements, and request velocity: */

issm/branches/trunk-jpl-damage/src/c/modules/MaxVzx/MaxVzx.h

r12878	r13101
10	10
11	11	/* local prototypes: */
12		void MaxVzx( double* pmaxvz, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
	12	void MaxVzx( IssmDouble* pmaxvz, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
13	13
14	14	#endif /* _MAXVZX_H */

issm/branches/trunk-jpl-damage/src/c/modules/MeshPartitionx/MeshPartitionx.cpp

r12878	r13101
51	51	for (i=0;i<numberofnodes;i++) npart[i]=0;
52	52	}
53		else _error2_("At least one processor is required");
	53	else _error_("At least one processor is required");
54	54	}
55	55	else{
…	…
78	78	for (i=0;i<numberofnodes2d;i++) npart2d[i]=0;
79	79	}
80		else _error2_("At least one processor is required");
	80	else _error_("At least one processor is required");
81	81
82	82	/Extrude epart2d to epart, using numlayers: /

issm/branches/trunk-jpl-damage/src/c/modules/MeshProfileIntersectionx/ElementSegment.cpp

r12878	r13101
38	38	if( (edge1==IntersectEnum) && (edge2==IntersectEnum) && (edge3==IntersectEnum) ){
39	39	/This case is impossible: /
40		_error2_("error: a line cannot go through 3 different vertices!");
	40	_error_("error: a line cannot go through 3 different vertices!");
41	41	}
42	42	else if( ((edge1==IntersectEnum) && (edge2==IntersectEnum)) \|\| ((edge2==IntersectEnum) && (edge3==IntersectEnum)) \|\| ((edge3==IntersectEnum) && (edge1==IntersectEnum)) ){

issm/branches/trunk-jpl-damage/src/c/modules/MinVelx/MinVelx.cpp

-              r12168
+              r13101
 #include "../../EnumDefinitions/EnumDefinitions.h"
 void MinVelx( double* pminvel, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
+void MinVelx( IssmDouble* pminvel, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
         int i;
         double minvel;
         double node_minvel;
         double element_minvel;
+        IssmDouble minvel;
+        IssmDouble node_minvel;
+        IssmDouble element_minvel;
         /*Go through elements, and request velocity: */

issm/branches/trunk-jpl-damage/src/c/modules/MinVelx/MinVelx.h

r12878	r13101
10	10
11	11	/* local prototypes: */
12		void MinVelx( double* pminvel, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
	12	void MinVelx( IssmDouble* pminvel, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
13	13
14	14	#endif /* _MINVELX_H */

issm/branches/trunk-jpl-damage/src/c/modules/MinVxx/MinVxx.cpp

-              r12168
+              r13101
 #include "../../EnumDefinitions/EnumDefinitions.h"
 void MinVxx( double* pminvx, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
+void MinVxx( IssmDouble* pminvx, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
         int i;
         double minvx;
         double node_minvx;
         double element_minvx;
+        IssmDouble minvx;
+        IssmDouble node_minvx;
+        IssmDouble element_minvx;
         /*Go through elements, and request velocity: */

issm/branches/trunk-jpl-damage/src/c/modules/MinVxx/MinVxx.h

r12878	r13101
10	10
11	11	/* local prototypes: */
12		void MinVxx( double* pminvx, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
	12	void MinVxx( IssmDouble* pminvx, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
13	13
14	14	#endif /* _MINVX_H */

issm/branches/trunk-jpl-damage/src/c/modules/MinVyx/MinVyx.cpp

-              r12168
+              r13101
 #include "../../EnumDefinitions/EnumDefinitions.h"
 void MinVyx( double* pminvy, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
+void MinVyx( IssmDouble* pminvy, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
         int i;
         double minvy;
         double node_minvy;
         double element_minvy;
+        IssmDouble minvy;
+        IssmDouble node_minvy;
+        IssmDouble element_minvy;
         /*Go through elements, and request velocity: */

issm/branches/trunk-jpl-damage/src/c/modules/MinVyx/MinVyx.h

r12878	r13101
10	10
11	11	/* local prototypes: */
12		void MinVyx( double* pminvy, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
	12	void MinVyx( IssmDouble* pminvy, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
13	13
14	14	#endif /* _MINVYX_H */

issm/branches/trunk-jpl-damage/src/c/modules/MinVzx/MinVzx.cpp

-              r12168
+              r13101
 #include "../../EnumDefinitions/EnumDefinitions.h"
 void MinVzx( double* pminvz, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
+void MinVzx( IssmDouble* pminvz, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
         int i;
         double minvz;
         double node_minvz;
         double element_minvz;
+        IssmDouble minvz;
+        IssmDouble node_minvz;
+        IssmDouble element_minvz;
         /*Go through elements, and request velocity: */

issm/branches/trunk-jpl-damage/src/c/modules/MinVzx/MinVzx.h

r12878	r13101
10	10
11	11	/* local prototypes: */
12		void MinVzx( double* pminvz, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
	12	void MinVzx( IssmDouble* pminvz, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
13	13
14	14	#endif /* _MINVZX_H */

issm/branches/trunk-jpl-damage/src/c/modules/ModelProcessorx/Balancethickness/CreateLoadsBalancethickness.cpp

r12878	r13101
42	42
43	43	/Get left and right elements/
44		element=~~(int)iomodel->Data(MeshEdgesEnum)[4*i+2]~~-1; //edges are [node1 node2 elem1 elem2]
	44	element=reCast<int,IssmDouble>(iomodel->Data(MeshEdgesEnum)[4*i+2])-1; //edges are [node1 node2 elem1 elem2]
45	45
46	46	/Now, if this element is not in the partition, pass: /

issm/branches/trunk-jpl-damage/src/c/modules/ModelProcessorx/Balancethickness/CreateNodesBalancethickness.cpp

-              r12878
+              r13101
         /*Check in 3d*/
         if(stabilization==3 && dim==3) _error2_("DG 3d not implemented yet");
+        if(stabilization==3 && dim==3) _error_("DG 3d not implemented yet");
         /*First fetch data: */
 …
                                         //Get index of the vertex on which the current node is located
                                         vertex_id=(int)*(iomodel->Data(MeshElementsEnum)+3*i+j); //(Matlab indexing)
+                                        vertex_id=reCast<int,IssmDouble>(*(iomodel->Data(MeshElementsEnum)+3*i+j)); //(Matlab indexing)
                                         io_index=vertex_id-1;                      //(C indexing)
                                         _assert_(vertex_id>0 && vertex_id<=numberofvertices);

issm/branches/trunk-jpl-damage/src/c/modules/ModelProcessorx/Control/CreateParametersControl.cpp

-              r12878
+              r13101
         int         num_cm_responses;
         int        *control_type     = NULL;
         double     *cm_responses     = NULL;
         double     *cm_jump          = NULL;
         double     *optscal          = NULL;
         double     *maxiter          = NULL;
+        IssmDouble     *cm_responses     = NULL;
+        IssmDouble     *cm_jump          = NULL;
+        IssmDouble     *optscal          = NULL;
+        IssmDouble     *maxiter          = NULL;
         /*Get parameters: */
 …
                 xDelete<int>(control_type);
                 xDelete<double>(cm_responses);
                 xDelete<double>(cm_jump);
                 xDelete<double>(optscal);
                 xDelete<double>(maxiter);
+                xDelete<IssmDouble>(cm_responses);
+                xDelete<IssmDouble>(cm_jump);
+                xDelete<IssmDouble>(optscal);
+                xDelete<IssmDouble>(maxiter);
+        }

issm/branches/trunk-jpl-damage/src/c/modules/ModelProcessorx/Control/UpdateElementsAndMaterialsControl.cpp

-              r12878
+              r13101
         iomodel->FetchData(4,InversionControlParametersEnum,InversionCostFunctionsCoefficientsEnum,InversionMinParametersEnum,InversionMaxParametersEnum);
         for(i=0;i<num_control_type;i++){
                 switch((int)iomodel->Data(InversionControlParametersEnum)[i]){
+                switch(reCast<int,IssmDouble>(iomodel->Data(InversionControlParametersEnum)[i])){
                         case BalancethicknessThickeningRateEnum: iomodel->FetchData(1,BalancethicknessThickeningRateEnum); break;
                         case VxEnum:   iomodel->FetchData(1,VxEnum); break;
 …
                         case MaterialsRheologyBbarEnum:    iomodel->FetchData(1,MaterialsRheologyBEnum); break;
                         case MaterialsRheologyZbarEnum:    iomodel->FetchData(1,MaterialsRheologyZEnum); break;
                         default: _error_("Control %s not implemented yet",EnumToStringx((int)iomodel->Data(InversionControlParametersEnum)[i]));
+                        default: _error_("Control " << EnumToStringx(reCast<int,IssmDouble>(iomodel->Data(InversionControlParametersEnum)[i])) << " not implemented yet");
+                }
+        }

issm/branches/trunk-jpl-damage/src/c/modules/ModelProcessorx/CreateDataSets.cpp

r12878	r13101
124	124
125	125	default:
126		_error2_("analysis_type: " << EnumToStringx(analysis_type) << " not supported yet!");
	126	_error_("analysis_type: " << EnumToStringx(analysis_type) << " not supported yet!");
127	127	}
128	128

issm/branches/trunk-jpl-damage/src/c/modules/ModelProcessorx/CreateParameters.cpp

-              r12878
+              r13101
         parameters->AddObject(iomodel->CopyConstantObject(FlowequationIshutterEnum));
         parameters->AddObject(iomodel->CopyConstantObject(FlowequationIsmacayealpattynEnum));
+        parameters->AddObject(iomodel->CopyConstantObject(FlowequationIsl1l2Enum));
         parameters->AddObject(iomodel->CopyConstantObject(FlowequationIsstokesEnum));
         parameters->AddObject(iomodel->CopyConstantObject(SettingsOutputFrequencyEnum));
 …
         parameters->AddObject(iomodel->CopyConstantObject(MaterialsRheologyLawEnum));
         parameters->AddObject(iomodel->CopyConstantObject(AutodiffIsautodiffEnum));
-        parameters->AddObject(iomodel->CopyConstantObject(AutodiffForwardEnum));
-        parameters->AddObject(iomodel->CopyConstantObject(AutodiffReverseEnum));
         parameters->AddObject(iomodel->CopyConstantObject(QmuIsdakotaEnum));
         parameters->AddObject(iomodel->CopyConstantObject(InversionIscontrolEnum));

issm/branches/trunk-jpl-damage/src/c/modules/ModelProcessorx/Dakota/CreateParametersDakota.cpp

r12878	r13101
153	153	/Fetch the mass flux segments necessary to compute the mass fluxes. Build a DoubleMatArrayParam object out of them: /
154	154	iomodel->FetchData(&array,&mdims_array,&ndims_array,&qmu_mass_flux_num_profiles,QmuMassFluxSegmentsEnum);
155		if(qmu_mass_flux_num_profiles==0)_error2_("qmu_mass_flux_num_profiles is 0, when MassFlux computations were requested!");
	155	if(qmu_mass_flux_num_profiles==0)_error_("qmu_mass_flux_num_profiles is 0, when MassFlux computations were requested!");
156	156
157	157	/Go through segments, and extract those that belong to this cpu: /

issm/branches/trunk-jpl-damage/src/c/modules/ModelProcessorx/DiagnosticHoriz/CreateConstraintsDiagnosticHoriz.cpp

-              r12878
+              r13101
         int     i,j;
         int     count;
         double  yts;
         double  g;
         double  rho_ice;
         double  stokesreconditioning;
         bool    isstokes,ismacayealpattyn;
+        IssmDouble  yts;
+        IssmDouble  g;
+        IssmDouble  rho_ice;
+        IssmDouble  stokesreconditioning;
+        bool    isstokes,isl1l2,ismacayealpattyn;
    bool    spcpresent=false;
         int Mx,Nx;
         int My,Ny;
         int Mz,Nz;
         double *spcvx          = NULL;
         double *spcvy          = NULL;
         double *spcvz          = NULL;
         double *nodeonmacayeal = NULL;
         double *nodeonpattyn   = NULL;
         double *nodeonstokes   = NULL;
         double *nodeonbed      = NULL;
         double *nodeonicesheet = NULL;
         double *vertices_type  = NULL;
         double *surface        = NULL;
         double *z              = NULL;
         double *timesx=NULL;
         double *timesy=NULL;
         double *timesz=NULL;
    double* values=NULL;
+        IssmDouble *spcvx          = NULL;
+        IssmDouble *spcvy          = NULL;
+        IssmDouble *spcvz          = NULL;
+        IssmDouble *nodeonmacayeal = NULL;
+        IssmDouble *nodeonpattyn   = NULL;
+        IssmDouble *nodeonstokes   = NULL;
+        IssmDouble *nodeonbed      = NULL;
+        IssmDouble *nodeonicesheet = NULL;
+        IssmDouble *vertices_type  = NULL;
+        IssmDouble *surface        = NULL;
+        IssmDouble *z              = NULL;
+        IssmDouble *timesx=NULL;
+        IssmDouble *timesy=NULL;
+        IssmDouble *timesz=NULL;
+   IssmDouble* values=NULL;
         /*Output*/
 …
         iomodel->Constant(&stokesreconditioning,DiagnosticStokesreconditioningEnum);
         iomodel->Constant(&isstokes,FlowequationIsstokesEnum);
+        iomodel->Constant(&isl1l2,FlowequationIsl1l2Enum);
         iomodel->Constant(&ismacayealpattyn,FlowequationIsmacayealpattynEnum);
 …
         /*Now, is the flag macayaealpattyn on? otherwise, do nothing: */
         if (!ismacayealpattyn & !isstokes){
+        if(!ismacayealpattyn & !isstokes & !isl1l2){
                 *pconstraints=constraints;
                 return;
 …
         /*figure out times: */
         timesx=xNew<double>(Nx);
+        timesx=xNew<IssmDouble>(Nx);
         for(j=0;j<Nx;j++){
                 timesx[j]=spcvx[(Mx-1)*Nx+j];
 …
         UnitConversion(timesx,Nx,ExtToIuEnum,TimeEnum);
         /*figure out times: */
         timesy=xNew<double>(Ny);
+        timesy=xNew<IssmDouble>(Ny);
         for(j=0;j<Ny;j++){
                 timesy[j]=spcvy[(My-1)*Ny+j];
 …
         UnitConversion(timesy,Ny,ExtToIuEnum,TimeEnum);
         /*figure out times: */
         timesz=xNew<double>(Nz);
+        timesz=xNew<IssmDouble>(Nz);
         for(j=0;j<Nz;j++){
                 timesz[j]=spcvz[(Mz-1)*Nz+j];
 …
                         /*Start with adding spcs of coupling: zero at the border macayeal/pattyn for the appropriate dofs*/
                         if ((int)vertices_type[i]==MacAyealPattynApproximationEnum){
+                        if (reCast<int,IssmDouble>(vertices_type[i]==MacAyealPattynApproximationEnum)){
                                 /*If grionmacayeal, spc pattyn dofs: 3 & 4*/
                                         if ((int)nodeonpattyn[i]){
+                                        if (reCast<int,IssmDouble>(nodeonpattyn[i])){
                                                 constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,1,0,DiagnosticHorizAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
                                                 count++;
 …
+                                        }
                                         else if ((int)nodeonmacayeal[i]){
+                                        else if (reCast<int,IssmDouble>(nodeonmacayeal[i])){
                                                 constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,3,0,DiagnosticHorizAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
                                                 count++;
 …
+                                        }
                                         else _error2_("if vertices_type is MacAyealPattyn, you shoud have nodeonpattyn or nodeonmacayeal");
+                                        else _error_("if vertices_type is MacAyealPattyn, you shoud have nodeonpattyn or nodeonmacayeal");
+                        }
                         /*Also add spcs of coupling: zero at the border pattyn/stokes for the appropriate dofs*/
                         else if ((int)vertices_type[i]==PattynStokesApproximationEnum){
+                        else if (reCast<int,IssmDouble>(vertices_type[i])==PattynStokesApproximationEnum){
                                 /*If grion,pattyn spc stokes dofs: 3 4 & 5*/
                                         if ((int)nodeonpattyn[i]){
+                                        if (reCast<int,IssmDouble>(nodeonpattyn[i])){
                                                 constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,3,0,DiagnosticHorizAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
                                                 count++;
 …
+                                        }
                                         else if ((int)nodeonstokes[i]){ //spc pattyn nodes: 1 & 2
+                                        else if (reCast<int,IssmDouble>(nodeonstokes[i])){ //spc pattyn nodes: 1 & 2
                                                 constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,1,0,DiagnosticHorizAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
                                                 count++;
 …
+                                                }
+                                        }
                                         else _error2_("if vertices_type is PattynStokes, you shoud have nodeonpattyn or nodeonstokes");
+                                        else _error_("if vertices_type is PattynStokes, you shoud have nodeonpattyn or nodeonstokes");
+                        }
                         /*Also add spcs of coupling: zero at the border pattyn/stokes for the appropriate dofs*/
                         else if ((int)vertices_type[i]==MacAyealStokesApproximationEnum){
+                        else if (reCast<int,IssmDouble>(vertices_type[i])==MacAyealStokesApproximationEnum){
                                 /*If grion,pattyn spc stokes dofs: 3 4 & 5*/
                                         if ((int)nodeonmacayeal[i]){
+                                        if (reCast<int,IssmDouble>(nodeonmacayeal[i])){
                                                 constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,3,0,DiagnosticHorizAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
                                                 count++;
 …
+                                        }
                                         else if ((int)nodeonstokes[i]){ //spc macayeal nodes: 1 & 2
+                                        else if (reCast<int,IssmDouble>(nodeonstokes[i])){ //spc macayeal nodes: 1 & 2
                                                 constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,1,0,DiagnosticHorizAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
                                                 count++;
 …
+                                                }
+                                        }
                                         else _error2_("if vertices_type is MacAyealStokes, you shoud have nodeonmacayeal or nodeonstokes");
+                                        else _error_("if vertices_type is MacAyealStokes, you shoud have nodeonmacayeal or nodeonstokes");
+                        }
                         /*Now add the regular spcs*/
 …
                                 else if (Mx==numberofvertices+1) {
                                         /*figure out times and values: */
                                         values=xNew<double>(Nx);
+                                        values=xNew<IssmDouble>(Nx);
                                         spcpresent=false;
                                         for(j=0;j<Nx;j++){
 …
                                                 count++;
+                                        }
                                         xDelete<double>(values);
+                                        xDelete<IssmDouble>(values);
+                                }
                                 else if (vertices_type[i]==HutterApproximationEnum){
 …
                                 else if (My==numberofvertices+1){
                                         /*figure out times and values: */
                                         values=xNew<double>(Ny);
+                                        values=xNew<IssmDouble>(Ny);
                                         spcpresent=false;
                                         for(j=0;j<Ny;j++){
 …
                                                 count++;
+                                        }
                                         xDelete<double>(values);
+                                        xDelete<IssmDouble>(values);
+                                }
                                 else if (vertices_type[i]==HutterApproximationEnum){
 …
+                                }
                                 if ((int)vertices_type[i]==StokesApproximationEnum ||  ((int)vertices_type[i]==NoneApproximationEnum)){
+                                if (reCast<int,IssmDouble>(vertices_type[i])==StokesApproximationEnum ||  (reCast<int,IssmDouble>(vertices_type[i])==NoneApproximationEnum)){
                                         if (Mz==numberofvertices && !xIsNan<IssmDouble>(spcvz[i])){
                                                 constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,3,spcvz[i]/yts,DiagnosticHorizAnalysisEnum)); //add count'th spc, on node i+1, setting dof 2 to vy
 …
                                         else if (Mz==numberofvertices+1){
                                                 /*figure out times and values: */
                                                 values=xNew<double>(Nz);
+                                                values=xNew<IssmDouble>(Nz);
                                                 spcpresent=false;
                                                 for(j=0;j<Nz;j++){
 …
                                                         count++;
+                                                }
                                                 xDelete<double>(values);
+                                        }
+                                }
                                 if ((int)vertices_type[i]==NoneApproximationEnum){
+                                                xDelete<IssmDouble>(values);
+                                        }
+                                }
+                                if (reCast<int,IssmDouble>(vertices_type[i])==NoneApproximationEnum){
                                         constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,4,g*rho_ice*(surface[i]-z[i])/stokesreconditioning,DiagnosticHorizAnalysisEnum)); //add count'th spc, on node i+1, setting dof 2 to vy
                                         count++;
 …
                         /*Constraint at the bedrock interface (v.n = vz = 0) (Coordinates will be updated according to the bed slope)*/
                         if (dim==3) if(nodeonbed[i] && nodeonicesheet[i] && nodeonstokes[i]){
                                  switch((int)vertices_type[i]){
+                        if (dim==3) if(reCast<int,IssmDouble>(nodeonbed[i]) && reCast<int,IssmDouble>(nodeonicesheet[i]) && reCast<int,IssmDouble>(nodeonstokes[i])){
+                                 switch(reCast<int,IssmDouble>(vertices_type[i])){
                                         case MacAyealStokesApproximationEnum:
                                                 constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,5,0.,DiagnosticHorizAnalysisEnum));
 …
                                                 count++;
                                                 break;
                                         default: _error2_("Vertex approximation " << EnumToStringx((int)vertices_type[i]) << " not supported");
+                                        default: _error_("Vertex approximation " << EnumToStringx(reCast<int,IssmDouble>(vertices_type[i])) << " not supported");
+                                }
+                        }
 …
         /*Free data: */
         xDelete<double>(spcvx);
         xDelete<double>(spcvy);
         xDelete<double>(spcvz);
         xDelete<double>(nodeonmacayeal);
         xDelete<double>(nodeonpattyn);
         xDelete<double>(nodeonstokes);
         xDelete<double>(nodeonicesheet);
         xDelete<double>(nodeonbed);
         xDelete<double>(vertices_type);
         xDelete<double>(surface);
         xDelete<double>(z);
+        xDelete<IssmDouble>(spcvx);
+        xDelete<IssmDouble>(spcvy);
+        xDelete<IssmDouble>(spcvz);
+        xDelete<IssmDouble>(nodeonmacayeal);
+        xDelete<IssmDouble>(nodeonpattyn);
+        xDelete<IssmDouble>(nodeonstokes);
+        xDelete<IssmDouble>(nodeonicesheet);
+        xDelete<IssmDouble>(nodeonbed);
+        xDelete<IssmDouble>(vertices_type);
+        xDelete<IssmDouble>(surface);
+        xDelete<IssmDouble>(z);
         /*Free resources:*/
         xDelete<double>(timesx);
         xDelete<double>(timesy);
         xDelete<double>(timesz);
         xDelete<double>(values);
+        xDelete<IssmDouble>(timesx);
+        xDelete<IssmDouble>(timesy);
+        xDelete<IssmDouble>(timesz);
+        xDelete<IssmDouble>(values);
         /*Assign output pointer: */

issm/branches/trunk-jpl-damage/src/c/modules/ModelProcessorx/DiagnosticHoriz/CreateLoadsDiagnosticHoriz.cpp

-              r12878
+              r13101
         int dim;
         int numberofvertices;
         bool ismacayealpattyn,isstokes;
+        bool ismacayealpattyn,isstokes,isl1l2;
         int  numpenalties,numberofpressureloads,numrifts,numriftsegments;
         double *pressureload   = NULL;
         double *elements_type  = NULL;
         double *nodeoniceshelf = NULL;
         double *riftinfo       = NULL;
         double *nodeonbed      = NULL;
         double *nodeonstokes   = NULL;
         double *nodeonicesheet = NULL;
         double *vertices_type  = NULL;
         double *penalties      = NULL;
+        IssmDouble *pressureload   = NULL;
+        IssmDouble *elements_type  = NULL;
+        IssmDouble *nodeoniceshelf = NULL;
+        IssmDouble *riftinfo       = NULL;
+        IssmDouble *nodeonbed      = NULL;
+        IssmDouble *nodeonstokes   = NULL;
+        IssmDouble *nodeonicesheet = NULL;
+        IssmDouble *vertices_type  = NULL;
+        IssmDouble *penalties      = NULL;
         /*Fetch parameters: */
         iomodel->Constant(&dim,MeshDimensionEnum);
         iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
+        iomodel->Constant(&isl1l2,FlowequationIsl1l2Enum);
         iomodel->Constant(&isstokes,FlowequationIsstokesEnum);
         iomodel->Constant(&ismacayealpattyn,FlowequationIsmacayealpattynEnum);
 …
         /*Now, is the flag macayaealpattyn on? otherwise, do nothing: */
         if (!ismacayealpattyn & !isstokes){
+        if(!ismacayealpattyn & !isstokes & !isl1l2){
                 *ploads=loads;
                 return;
 …
                 if (dim==2) segment_width=4;
                 else segment_width=6;
                 element=(int)(*(pressureload+segment_width*i+segment_width-2)-1); //element is in the penultimate column (node1 node2 ... elem fill)
+                element=reCast<int,IssmDouble>(*(pressureload+segment_width*i+segment_width-2)-1); //element is in the penultimate column (node1 node2 ... elem fill)
                 /*Now, if this element is not in the partition, pass: */
 …
                 /*Do not create ice front if Hutter or Stokes elements*/
                 if ((int)*(elements_type+element)==HutterApproximationEnum) continue;
+                if (reCast<int,IssmDouble>(*(elements_type+element))==HutterApproximationEnum) continue;
                 /*Create and  add load: */
                 if ((int)*(elements_type+element)==(MacAyealApproximationEnum) && dim==2){
+                if (reCast<int,IssmDouble>(*(elements_type+element))==(MacAyealApproximationEnum) && dim==2){
                         loads->AddObject(new Icefront(iomodel->loadcounter+count+1,i,iomodel,MacAyeal2dIceFrontEnum,DiagnosticHorizAnalysisEnum));
                         count++;
+                }
                 else if ((int)*(elements_type+element)==(MacAyealApproximationEnum) && dim==3){
+                else if (reCast<int,IssmDouble>(*(elements_type+element))==(MacAyealApproximationEnum) && dim==3){
                         loads->AddObject(new Icefront(iomodel->loadcounter+count+1,i,iomodel,MacAyeal3dIceFrontEnum,DiagnosticHorizAnalysisEnum));
                         count++;
+                }
+                else if ((int)*(elements_type+element)==(PattynApproximationEnum)){
+                else if (reCast<int,IssmDouble>(*(elements_type+element))==(L1L2ApproximationEnum)){
+                        loads->AddObject(new Icefront(iomodel->loadcounter+count+1,i,iomodel,MacAyeal3dIceFrontEnum,DiagnosticHorizAnalysisEnum));
+                        count++;
+                }
+                else if (reCast<int,IssmDouble>(*(elements_type+element))==(PattynApproximationEnum)){
                         loads->AddObject(new Icefront(iomodel->loadcounter+count+1,i,iomodel,PattynIceFrontEnum,DiagnosticHorizAnalysisEnum));
                         count++;
+                }
+                else if ((int)*(elements_type+element)==(StokesApproximationEnum)){
+                else if (reCast<int,IssmDouble>(*(elements_type+element))==(L1L2ApproximationEnum)){
+                        loads->AddObject(new Icefront(iomodel->loadcounter+count+1,i,iomodel,L1L2IceFrontEnum,DiagnosticHorizAnalysisEnum));
+                        count++;
+                }
+                else if (reCast<int,IssmDouble>(*(elements_type+element))==(StokesApproximationEnum)){
                         loads->AddObject(new Icefront(iomodel->loadcounter+count+1,i,iomodel,StokesIceFrontEnum,DiagnosticHorizAnalysisEnum));
                         count++;
+                }
                 else if ((int)*(elements_type+element)==(MacAyealPattynApproximationEnum)){
+                else if (reCast<int,IssmDouble>(*(elements_type+element))==(MacAyealPattynApproximationEnum)){
                         loads->AddObject(new Icefront(iomodel->loadcounter+count+1,i,iomodel,MacAyeal3dIceFrontEnum,DiagnosticHorizAnalysisEnum));
                         count++;
 …
                         count++;
+                }
                 else if ((int)*(elements_type+element)==(PattynStokesApproximationEnum)){
+                else if (reCast<int,IssmDouble>(*(elements_type+element))==(PattynStokesApproximationEnum)){
                         loads->AddObject(new Icefront(iomodel->loadcounter+count+1,i,iomodel,PattynIceFrontEnum,DiagnosticHorizAnalysisEnum));
                         count++;
 …
                         count++;
+                }
                 else if ((int)*(elements_type+element)==(MacAyealStokesApproximationEnum)){
+                else if (reCast<int,IssmDouble>(*(elements_type+element))==(MacAyealStokesApproximationEnum)){
                         loads->AddObject(new Icefront(iomodel->loadcounter+count+1,i,iomodel,MacAyeal3dIceFrontEnum,DiagnosticHorizAnalysisEnum));
                         count++;
 …
         /*Free data: */
         iomodel->DeleteData(3,DiagnosticIcefrontEnum,ThicknessEnum,BedEnum);
         xDelete<double>(elements_type);
         xDelete<double>(pressureload);
+        xDelete<IssmDouble>(elements_type);
+        xDelete<IssmDouble>(pressureload);
         /*Create Penpair for penalties: */
 …
         for(i=0;i<numpenalties;i++){
                 if(iomodel->my_vertices[(int)penalties[2*i+0]-1]){
+                if(iomodel->my_vertices[reCast<int,IssmDouble>(penalties[2*i+0]-1)]){
                         /*In debugging mode, check that the second node is in the same cpu*/
 …
                         /*Get node ids*/
                         penpair_ids[0]=iomodel->nodecounter+(int)penalties[2*i+0];
                         penpair_ids[1]=iomodel->nodecounter+(int)penalties[2*i+1];
+                        penpair_ids[0]=iomodel->nodecounter+reCast<int,IssmDouble>(penalties[2*i+0]);
+                        penpair_ids[1]=iomodel->nodecounter+reCast<int,IssmDouble>(penalties[2*i+1]);
                         /*Create Load*/
 …
         /*free ressources: */
         xDelete<double>(penalties);
+        xDelete<IssmDouble>(penalties);
         /*Create Riffront loads for rifts: */
 …
                 iomodel->FetchData(5,RiftsRiftstructEnum,ThicknessEnum,BedEnum,SurfaceEnum,MaskVertexonfloatingiceEnum);
                 for(i=0;i<numriftsegments;i++){
                         if(iomodel->my_elements[(int)*(riftinfo+RIFTINFOSIZE*i+2)-1]){
+                        if(iomodel->my_elements[reCast<int,IssmDouble>(*(riftinfo+RIFTINFOSIZE*i+2))-1]){
                                 loads->AddObject(new Riftfront(iomodel->loadcounter+count+1,i,iomodel,DiagnosticHorizAnalysisEnum));
                                 count++;

issm/branches/trunk-jpl-damage/src/c/modules/ModelProcessorx/DiagnosticHoriz/CreateNodesDiagnosticHoriz.cpp

-              r12878
+              r13101
         bool   continuous_galerkin=true;
         int    numberofvertices;
         bool   isstokes,ismacayealpattyn;
+        bool   isstokes,isl1l2,ismacayealpattyn;
         /*DataSets: */
 …
         iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
         iomodel->Constant(&isstokes,FlowequationIsstokesEnum);
+        iomodel->Constant(&isl1l2,FlowequationIsl1l2Enum);
         iomodel->Constant(&ismacayealpattyn,FlowequationIsmacayealpattynEnum);
 …
         /*Now, is the flag macayaealpattyn on? otherwise, do nothing: */
         if(!ismacayealpattyn & !isstokes){
+        if(!ismacayealpattyn & !isstokes & !isl1l2){
                 *pnodes=nodes;
                 return;

issm/branches/trunk-jpl-damage/src/c/modules/ModelProcessorx/DiagnosticHoriz/UpdateElementsDiagnosticHoriz.cpp

-              r12878
+              r13101
         int    numberofelements;
         bool   ismacayealpattyn;
+        bool   isl1l2;
         bool   isstokes;
         bool   control_analysis;
 …
         /*Fetch constants needed: */
         iomodel->Constant(&isstokes,FlowequationIsstokesEnum);
+        iomodel->Constant(&isl1l2,FlowequationIsl1l2Enum);
         iomodel->Constant(&ismacayealpattyn,FlowequationIsmacayealpattynEnum);
         iomodel->Constant(&dim,MeshDimensionEnum);
 …
         /*Now, is the flag macayaealpattyn on? otherwise, do nothing: */
         if(!ismacayealpattyn & !isstokes) return;
+        if(!ismacayealpattyn & !isstokes &!isl1l2) return;
         /*Fetch data needed: */

issm/branches/trunk-jpl-damage/src/c/modules/ModelProcessorx/DiagnosticHutter/CreateConstraintsDiagnosticHutter.cpp

-              r12878
+              r13101
         int i;
         int count;
         double yts;
+        IssmDouble yts;
         int    numberofvertices;
         bool   ishutter;
 …
                 /*keep only this partition's nodes:*/
                 if((iomodel->my_vertices[i])){
                         if (!(int)iomodel->Data(FlowequationVertexEquationEnum)[i]==HutterApproximationEnum){
+                        if (!reCast<int,IssmDouble>(iomodel->Data(FlowequationVertexEquationEnum)[i])==HutterApproximationEnum){
                                 constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,1,0,DiagnosticHutterAnalysisEnum));

issm/branches/trunk-jpl-damage/src/c/modules/ModelProcessorx/DiagnosticVert/CreateConstraintsDiagnosticVert.cpp

-              r12878
+              r13101
         int dim;
         int count;
         double yts;
+        IssmDouble yts;
         int    numberofvertices;
 …
                 if(iomodel->my_vertices[i]){
                         if ((int)iomodel->Data(FlowequationBorderstokesEnum)[i]){
+                        if (reCast<int,IssmDouble>(iomodel->Data(FlowequationBorderstokesEnum)[i])){
                                 constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,1,0,DiagnosticVertAnalysisEnum)); //spc to zero as vertical velocity is done in Horiz for Stokes
                                 count++;

issm/branches/trunk-jpl-damage/src/c/modules/ModelProcessorx/DistributeNumDofs.cpp

-              r12878
+              r13101
         if (analysis_type==DiagnosticHorizAnalysisEnum){
                 if (vertices_type[0]==MacAyealApproximationEnum){
+                        numdofs=2;
+                }
+                else if (vertices_type[0]==L1L2ApproximationEnum){
                         numdofs=2;
+                }
 …
                         doftype[5]=StokesApproximationEnum;
+                }
                 else _error2_("Approximationtype " << reCast<int>(*vertices_type) << " (" << EnumToStringx(reCast<int>(*vertices_type)) << ") not implemented yet for DiagnosticHoriz");
+                else _error_("Approximationtype " << reCast<int>(*vertices_type) << " (" << EnumToStringx(reCast<int>(*vertices_type)) << ") not implemented yet for DiagnosticHoriz");
+        }
         else if (analysis_type==DiagnosticVertAnalysisEnum){
 …
                 numdofs=1;
+        }
         else _error2_("analysis type: " << analysis_type << " (" << EnumToStringx(analysis_type) << ") not implemented yet");
+        else _error_("analysis type: " << analysis_type << " (" << EnumToStringx(analysis_type) << ") not implemented yet");
         /*Now initialize the index*/

issm/branches/trunk-jpl-damage/src/c/modules/ModelProcessorx/Enthalpy/CreateConstraintsEnthalpy.cpp

-              r12878
+              r13101
         int    numberofvertices;
         bool   spcpresent=false;
         double heatcapacity;
         double referencetemperature;
+        IssmDouble heatcapacity;
+        IssmDouble referencetemperature;
         /*Output*/
 …
+        }
         else{
                 _error2_("Size of field " << EnumToStringx(ThermalSpctemperatureEnum) << " not supported");
+                _error_("Size of field " << EnumToStringx(ThermalSpctemperatureEnum) << " not supported");
+        }

issm/branches/trunk-jpl-damage/src/c/modules/ModelProcessorx/Melting/CreateLoadsMelting.cpp

-              r12878
+              r13101
         /*if 2d: Error*/
         if (dim==2) _error2_("2d meshes not supported yet");
+        if (dim==2) _error_("2d meshes not supported yet");
         /*Recover pointer: */
 …
         for (i=0;i<numberofvertices;i++){
                 if((iomodel->my_vertices[i]==1)){
                         if (iomodel->Data(MeshVertexonbedEnum)[i]){
+                        if (reCast<int>(iomodel->Data(MeshVertexonbedEnum)[i])){
                                 loads->AddObject(new Pengrid(iomodel->loadcounter+i+1,i,iomodel,MeltingAnalysisEnum));
+                        }

issm/branches/trunk-jpl-damage/src/c/modules/ModelProcessorx/NodesPartitioning.cpp

r12878	r13101
103	103	}
104	104	else{
105		_error2_("not implemented yet");
	105	_error_("not implemented yet");
106	106	}
107	107
…	…
111	111	iomodel->FetchData(&edges,&numberofedges,&cols,MeshEdgesEnum);
112	112	iomodel->FetchData(&elements,NULL,NULL,MeshElementsEnum);
113		if (cols!=4) _error2_("field edges should have 4 columns");
	113	if (cols!=4) _error_("field edges should have 4 columns");
114	114
115	115	/!All elements have been partitioned above, only create elements for this CPU: /
…	…
152	152	}
153	153	else{
154		_error2_("Problem in edges creation");
	154	_error_("Problem in edges creation");
155	155	}
156	156	}

issm/branches/trunk-jpl-damage/src/c/modules/ModelProcessorx/Prognostic/CreateNodesPrognostic.cpp

r12878	r13101
46	46
47	47	/Check in 3d/
48		if(stabilization==3 && dim==3) _error2_("DG 3d not implemented yet");
	48	if(stabilization==3 && dim==3) _error_("DG 3d not implemented yet");
49	49
50	50	/First fetch data: /

issm/branches/trunk-jpl-damage/src/c/modules/ModelProcessorx/Prognostic/UpdateElementsPrognostic.cpp

r12878	r13101
23	23	bool ispdd;
24	24	bool isdelta18o;
25		~~IssmDouble *size, Delta18oTimeSerie,Delta18oSurfaceTimeSerie ;~~
26	25
27	26	/Fetch data needed: /

issm/branches/trunk-jpl-damage/src/c/modules/ModelProcessorx/Thermal/CreateLoadsThermal.cpp

r12878	r13101
33	33
34	34	/return if 2d mesh/
35		if (dim==2) _error2_("2d meshes not supported yet");
	35	if (dim==2) _error_("2d meshes not supported yet");
36	36
37	37	//create penalties for nodes: no node can have a temperature over the melting point

issm/branches/trunk-jpl-damage/src/c/modules/NodalValuex/NodalValuex.cpp

r12878	r13101
38	38	#ifdef _HAVE_MPI_
39	39	MPI_Allreduce ( &found,&sumfound,1,MPI_INT,MPI_SUM,MPI_COMM_WORLD);
40		if(!sumfound)_error2_("could not find element with vertex with id" << index << " to compute nodal value " << EnumToStringx(natureofdataenum));
	40	if(!sumfound)_error_("could not find element with vertex with id" << index << " to compute nodal value " << EnumToStringx(natureofdataenum));
41	41	#endif
42	42

issm/branches/trunk-jpl-damage/src/c/modules/NodeConnectivityx/NodeConnectivityx.cpp

r12878	r13101
71	71	* warn the user to increase the connectivity width: */
72	72	for(i=0;i<nods;i++){
73		if ((connectivity+widthi+maxels)>maxels)_error2_("max connectivity width reached (" << (connectivity+widthi+maxels) << ")! increase width of connectivity table");
	73	if ((connectivity+widthi+maxels)>maxels)_error_("max connectivity width reached (" << (connectivity+widthi+maxels) << ")! increase width of connectivity table");
74	74	}
75	75

issm/branches/trunk-jpl-damage/src/c/modules/Orthx/Orthx.cpp

r11708	r13101
11	11
12	12	/intermediary:/
13		double norm_new,norm_old,dot_product;;
	13	IssmDouble norm_new,norm_old,dot_product;;
14	14
15	15	/Initialize output/

issm/branches/trunk-jpl-damage/src/c/modules/ParsePetscOptionsx/ParsePetscOptionsx.cpp

r12878	r13101
106	106	char* string=strings[i];
107	107	if(my_rank==0){
108		if(string==NULL) _error2_("PETSc options for analysis " << EnumToStringx(reCast<int>(analyses[i])) << " have been declared but were not found");
	108	if(string==NULL) _error_("PETSc options for analysis " << EnumToStringx(reCast<int>(analyses[i])) << " have been declared but were not found");
109	109	}
110	110	if(my_rank==0)stringlength=(strlen(string)+1)*sizeof(char);

issm/branches/trunk-jpl-damage/src/c/modules/ResetConstraintsx/ResetConstraintsx.cpp

r12878	r13101
30	30	* management routine, otherwise, skip : */
31	31	if (RiftIsPresent(loads,analysis_type)){
32		_error2_("rift constraints reset not supported yet!");
	32	_error_("rift constraints reset not supported yet!");
33	33	}
34	34	else if(ThermalIsPresent(loads,analysis_type)){

issm/branches/trunk-jpl-damage/src/c/modules/Responsex/Responsex.cpp

-              r12946
+              r13101
                 case VelEnum:ElementResponsex(responses, elements,nodes, vertices, loads, materials, parameters,VelEnum,process_units); break;
                 case FrictionCoefficientEnum:NodalValuex(responses, FrictionCoefficientEnum,elements,nodes, vertices, loads, materials, parameters,process_units); break;
                 default: _error2_("response descriptor \"" << response_descriptor << "\" not supported yet!"); break;
+                default: _error_("response descriptor \"" << response_descriptor << "\" not supported yet!"); break;
                 #else
                 default: _error2_("ISSM was not compiled with responses capabilities, exiting!");
+                default: _error_("ISSM was not compiled with responses capabilities, exiting!");
                 #endif
+        }

issm/branches/trunk-jpl-damage/src/c/modules/RheologyBbarAbsGradientx/RheologyBbarAbsGradientx.cpp

-              r12168
+              r13101
 #include "../../EnumDefinitions/EnumDefinitions.h"
 void RheologyBbarAbsGradientx( double* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units, int weight_index){
+void RheologyBbarAbsGradientx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units, int weight_index){
         /*Intermediary*/
 …
         /*output: */
         double J=0;
         double J_sum;
+        IssmDouble J=0;
+        IssmDouble J_sum;
         /*Compute Misfit: */

issm/branches/trunk-jpl-damage/src/c/modules/RheologyBbarAbsGradientx/RheologyBbarAbsGradientx.h

r12878	r13101
10	10
11	11	/* local prototypes: */
12		void RheologyBbarAbsGradientx( double* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units,int weight_index);
	12	void RheologyBbarAbsGradientx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units,int weight_index);
13	13
14	14	#endif

issm/branches/trunk-jpl-damage/src/c/modules/SetControlInputsFromVectorx/SetControlInputsFromVectorx.cpp

-              r12878
+              r13101
 #include "../../EnumDefinitions/EnumDefinitions.h"
 void SetControlInputsFromVectorx(Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,double* vector){
+void SetControlInputsFromVectorx(Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,IssmDouble* vector){
         int  num_controls;
 …
 void SetControlInputsFromVectorx(Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,Vector* vector){
         double* serial_vector=NULL;
+        IssmDouble* serial_vector=NULL;
         serial_vector=vector->ToMPISerial();
 …
         /*Free ressources:*/
         xDelete<double>(serial_vector);
+        xDelete<IssmDouble>(serial_vector);
+}

issm/branches/trunk-jpl-damage/src/c/modules/SetControlInputsFromVectorx/SetControlInputsFromVectorx.h

r12878	r13101
10	10	/* local prototypes: */
11	11	void SetControlInputsFromVectorx(Elements* elements,Nodes* nodes, Vertices* vertices,Loads* loads, Materials* materials, Parameters* parameters,Vector* vector);
12		void SetControlInputsFromVectorx(Elements* elements,Nodes* nodes, Vertices* vertices,Loads* loads, Materials* materials, Parameters* parameters,double* vector);
	12	void SetControlInputsFromVectorx(Elements* elements,Nodes* nodes, Vertices* vertices,Loads* loads, Materials* materials, Parameters* parameters,IssmDouble* vector);
13	13
14	14	#endif

issm/branches/trunk-jpl-damage/src/c/modules/Shp2Kmlx/Shp2Kmlx.cpp

r12878	r13101
75	75
76	76	hSHP = SHPOpen( filshp, "rb" );
77		if (!hSHP) _error2_("Error opening shp/shx files.");
	77	if (!hSHP) _error_("Error opening shp/shx files.");
78	78
79	79	/* read header and print out file bounds */

issm/branches/trunk-jpl-damage/src/c/modules/Solverx/Solverx.cpp

r12946	r13101
44	44	break;}
45	45	default:
46		_error2_("Matrix type: " << Kff->type << " not supported yet!");
	46	_error_("Matrix type: " << Kff->type << " not supported yet!");
47	47	}
48	48

issm/branches/trunk-jpl-damage/src/c/modules/Solverx/Solverx.h

r12878	r13101
25	25	void SolverxSeq(SeqVec** puf,SeqMat* Kff, SeqVec* pf);
26	26	void SolverxSeq(IssmDouble** pX,IssmDouble* A,IssmDouble* B,int n);
	27	void SolverxSeq(double** pX,double* A,double* B,int n);
27	28
28	29	#endif /* _SOLVERX_H */

issm/branches/trunk-jpl-damage/src/c/modules/Solverx/SolverxPetsc.cpp

-              r12878
+              r13101
                 #if _PETSC_MAJOR_ >=3
                         #ifndef _HAVE_MUMPS_
                         _error2_("requested MUMPS solver, which was not compiled into ISSM!\n");
+                        _error_("requested MUMPS solver, which was not compiled into ISSM!\n");
                         #endif
                 #endif
 …
         if (solver_type==StokesSolverEnum){
                 /*Make indices out of doftypes: */
                 if(!df)_error2_("need doftypes for Stokes solver!\n");
+                if(!df)_error_("need doftypes for Stokes solver!\n");
                 DofTypesToIndexSet(&isv,&isp,df,StokesSolverEnum);
 …
         /*Check convergence*/
         KSPGetIterationNumber(ksp,&iteration_number);
         if (iteration_number<0) _error2_("Solver diverged at iteration number: " << -iteration_number);
+        if (iteration_number<0) _error_("Solver diverged at iteration number: " << -iteration_number);
         /*Free resources:*/

issm/branches/trunk-jpl-damage/src/c/modules/Solverx/SolverxSeq.cpp

-              r12878
+              r13101
         pf->GetSize(&N2);
         if(N!=N2)_error2_("Right hand side vector of size " << N2 << ", when matrix is of size " << M << "-" << N << " !");
         if(M!=N)_error2_("Stiffness matrix should be square!");
+        if(N!=N2)_error_("Right hand side vector of size " << N2 << ", when matrix is of size " << M << "-" << N << " !");
+        if(M!=N)_error_("Stiffness matrix should be square!");
         SolverxSeq(&x,Kff->matrix,pf->vector,N);
 …
         #else
                 _error2_("GSL support not compiled in!");
+                _error_("GSL support not compiled in!");
         #endif
 }/*}}}*/
+void SolverxSeq(IssmDouble** pX,IssmDouble* A,IssmDouble* B,int n){/*{{{*/
+#ifdef _HAVE_ADOLC_
+void SolverxSeq(IssmDouble** pX,IssmDouble* A,IssmDouble* B,int n){//{{{
+        /* if we use Adol-C then the IssmDouble will be an adouble
+           and the calls to gsl_... will not work.
+           We therefore call a wrapped solver instead.
+        */
+        /*Output: */
+        IssmDouble* X=NULL;
+        /*Intermediary: */
+        int     i;
+        IssmPDouble* pdoubleA=NULL;
+        IssmPDouble* pdoubleB=NULL;
+        IssmPDouble* pdoubleX=NULL;
+        /*First, transfer from IssmDouble to double all our matrices and vectors: */
+        pdoubleA=xNew<double>(n*n);
+        pdoubleB=xNew<double>(n);
+        for(i=0;i<n*n;i++)pdoubleA[i]=reCast<IssmPDouble>(A[i]);
+        for(i=0;i<n;i++)pdoubleB[i]=reCast<IssmPDouble>(B[i]);
+        /*Call wrapped solver: */
+        SolverxSeq(&pdoubleX,pdoubleA, pdoubleB, n);
+        /*Transfer solution vector from double to IssmDouble: */
+        X = xNew<IssmDouble>(n);
+        for(i=0;i<n;i++)X[i]=reCast<IssmDouble>(pdoubleX[i]);
+        /*Free ressources:*/
+        xDelete<IssmPDouble>(pdoubleA);
+        xDelete<IssmPDouble>(pdoubleB);
+        /*Assign output pointers: */
+        *pX=X;
+}
+/*}}}*/
+#endif
+void SolverxSeq(IssmPDouble** pX,IssmPDouble* A,IssmPDouble* B,int n){ //{{{
         #ifdef _HAVE_GSL_
+                /*GSL Matrices and vectors: */
+                int              s;
+                gsl_matrix_view  a;
+                gsl_vector_view  b;
+                gsl_vector      *x = NULL;
+                gsl_permutation *p = NULL;
+                #ifdef _HAVE_ADOLC_
+                        // if we use Adol-C then the IssmDouble will be an adouble
+                        // and the calls to gsl_... will not work
+                        // and we should call  a suitable wrapped solve instead
+                        _error2_("SolverxSeq: should not be here with Adol-C");
+                #else
+                        /*A will be modified by LU decomposition. Use copy*/
+                        IssmDouble* Acopy = xNew<IssmDouble>(n*n);
+                        xMemCpy<IssmDouble>(Acopy,A,n*n);
+        /*GSL Matrices and vectors: */
+        int              s;
+        gsl_matrix_view  a;
+        gsl_vector_view  b;
+        gsl_vector      *x = NULL;
+        gsl_permutation *p = NULL;
+        /*A will be modified by LU decomposition. Use copy*/
+        double* Acopy = xNew<double>(n*n);
+        xMemCpy<double>(Acopy,A,n*n);
                         /*Initialize gsl matrices and vectors: */
                         a = gsl_matrix_view_array (Acopy,n,n);
                         b = gsl_vector_view_array (B,n);
                         x = gsl_vector_alloc (n);
+        /*Initialize gsl matrices and vectors: */
+        a = gsl_matrix_view_array (Acopy,n,n);
+        b = gsl_vector_view_array (B,n);
+        x = gsl_vector_alloc (n);
                         /*Run LU and solve: */
                         p = gsl_permutation_alloc (n);
                         gsl_linalg_LU_decomp (&a.matrix, p, &s);
                         gsl_linalg_LU_solve (&a.matrix, p, &b.vector, x);
+        /*Run LU and solve: */
+        p = gsl_permutation_alloc (n);
+        gsl_linalg_LU_decomp (&a.matrix, p, &s);
+        gsl_linalg_LU_solve (&a.matrix, p, &b.vector, x);
                         //printf ("x = \n");
                         //gsl_vector_fprintf (stdout, x, "%g");
+        //printf ("x = \n");
+        //gsl_vector_fprintf (stdout, x, "%g");
                         /*Copy result*/
                         IssmDouble* X = xNew<IssmDouble>(n);
                         memcpy(X,gsl_vector_ptr(x,0),n*sizeof(IssmDouble));
+        /*Copy result*/
+        double* X = xNew<double>(n);
+        memcpy(X,gsl_vector_ptr(x,0),n*sizeof(double));
+                        /*Clean up and assign output pointer*/
+                        xDelete<IssmDouble>(Acopy);
+                        gsl_permutation_free(p);
+                        gsl_vector_free(x);
+                        *pX=X;
+                #endif
+        /*Clean up and assign output pointer*/
+        xDelete<double>(Acopy);
+        gsl_permutation_free(p);
+        gsl_vector_free(x);
+        *pX=X;
         #endif
+}/*}}}*/
+}
+/*}}}*/

issm/branches/trunk-jpl-damage/src/c/modules/StringToEnumx/StringToEnumx.cpp

-              r12946
+              r13101
    if(stage==1){
+              if (strcmp(name,"AutodiffForward")==0) return AutodiffForwardEnum;
+              else if (strcmp(name,"AutodiffIsautodiff")==0) return AutodiffIsautodiffEnum;
+              else if (strcmp(name,"AutodiffReverse")==0) return AutodiffReverseEnum;
+              if (strcmp(name,"AutodiffIsautodiff")==0) return AutodiffIsautodiffEnum;
               else if (strcmp(name,"BalancethicknessSpcthickness")==0) return BalancethicknessSpcthicknessEnum;
               else if (strcmp(name,"BalancethicknessStabilization")==0) return BalancethicknessStabilizationEnum;
 …
               else if (strcmp(name,"FlowequationElementEquation")==0) return FlowequationElementEquationEnum;
               else if (strcmp(name,"FlowequationIshutter")==0) return FlowequationIshutterEnum;
+              else if (strcmp(name,"FlowequationIsl1l2")==0) return FlowequationIsl1l2Enum;
               else if (strcmp(name,"FlowequationIsmacayealpattyn")==0) return FlowequationIsmacayealpattynEnum;
               else if (strcmp(name,"FlowequationIsstokes")==0) return FlowequationIsstokesEnum;
 …
               else if (strcmp(name,"MiscellaneousName")==0) return MiscellaneousNameEnum;
               else if (strcmp(name,"PrognosticHydrostaticAdjustment")==0) return PrognosticHydrostaticAdjustmentEnum;
+              else if (strcmp(name,"PrognosticMinThickness")==0) return PrognosticMinThicknessEnum;
          else stage=2;
+   }
    if(stage==2){
+              if (strcmp(name,"PrognosticMinThickness")==0) return PrognosticMinThicknessEnum;
+              else if (strcmp(name,"PrognosticPenaltyFactor")==0) return PrognosticPenaltyFactorEnum;
+              if (strcmp(name,"PrognosticPenaltyFactor")==0) return PrognosticPenaltyFactorEnum;
               else if (strcmp(name,"PrognosticSpcthickness")==0) return PrognosticSpcthicknessEnum;
               else if (strcmp(name,"PrognosticStabilization")==0) return PrognosticStabilizationEnum;
 …
               else if (strcmp(name,"TransientSolution")==0) return TransientSolutionEnum;
               else if (strcmp(name,"Approximation")==0) return ApproximationEnum;
+              else if (strcmp(name,"NoneApproximation")==0) return NoneApproximationEnum;
               else if (strcmp(name,"HutterApproximation")==0) return HutterApproximationEnum;
               else if (strcmp(name,"MacAyealApproximation")==0) return MacAyealApproximationEnum;
               else if (strcmp(name,"MacAyealPattynApproximation")==0) return MacAyealPattynApproximationEnum;
               else if (strcmp(name,"MacAyealStokesApproximation")==0) return MacAyealStokesApproximationEnum;
               else if (strcmp(name,"NoneApproximation")==0) return NoneApproximationEnum;
+              else if (strcmp(name,"L1L2Approximation")==0) return L1L2ApproximationEnum;
               else if (strcmp(name,"PattynApproximation")==0) return PattynApproximationEnum;
               else if (strcmp(name,"PattynStokesApproximation")==0) return PattynStokesApproximationEnum;
 …
               else if (strcmp(name,"Numericalflux")==0) return NumericalfluxEnum;
               else if (strcmp(name,"Param")==0) return ParamEnum;
+              else if (strcmp(name,"L1L2IceFront")==0) return L1L2IceFrontEnum;
               else if (strcmp(name,"PattynIceFront")==0) return PattynIceFrontEnum;
               else if (strcmp(name,"Pengrid")==0) return PengridEnum;
 …
               else if (strcmp(name,"EnthalpyPicard")==0) return EnthalpyPicardEnum;
               else if (strcmp(name,"ThicknessAbsGradient")==0) return ThicknessAbsGradientEnum;
-              else if (strcmp(name,"StepResponses")==0) return StepResponsesEnum;
          else stage=4;
+   }
    if(stage==4){
+              if (strcmp(name,"IntMatParam")==0) return IntMatParamEnum;
+              if (strcmp(name,"ThicknessAlongGradient")==0) return ThicknessAlongGradientEnum;
+              else if (strcmp(name,"ThicknessAcrossGradient")==0) return ThicknessAcrossGradientEnum;
+              else if (strcmp(name,"StepResponses")==0) return StepResponsesEnum;
+              else if (strcmp(name,"IntMatParam")==0) return IntMatParamEnum;
               else if (strcmp(name,"RheologyBbarAbsGradient")==0) return RheologyBbarAbsGradientEnum;
               else if (strcmp(name,"DragCoefficientAbsGradient")==0) return DragCoefficientAbsGradientEnum;
 …
               else if (strcmp(name,"StressTensoryz")==0) return StressTensoryzEnum;
               else if (strcmp(name,"StressTensorzz")==0) return StressTensorzzEnum;
-              else if (strcmp(name,"IceVolume")==0) return IceVolumeEnum;
-              else if (strcmp(name,"TotalSmb")==0) return TotalSmbEnum;
-              else if (strcmp(name,"ThicknessAlongGradient")==0) return ThicknessAlongGradientEnum;
-              else if (strcmp(name,"ThicknessAcrossGradient")==0) return ThicknessAcrossGradientEnum;
               else if (strcmp(name,"P0")==0) return P0Enum;
               else if (strcmp(name,"P1")==0) return P1Enum;
 …
               else if (strcmp(name,"MaxVz")==0) return MaxVzEnum;
               else if (strcmp(name,"MaxAbsVz")==0) return MaxAbsVzEnum;
+              else if (strcmp(name,"IceVolume")==0) return IceVolumeEnum;
+              else if (strcmp(name,"TotalSmb")==0) return TotalSmbEnum;
               else if (strcmp(name,"Relative")==0) return RelativeEnum;
               else if (strcmp(name,"Absolute")==0) return AbsoluteEnum;
 …
+   }
         /*If we reach this point, the string provided has not been found*/
         _error2_("Enum " << name << " not found");
+        _error_("Enum " << name << " not found");
+}

issm/branches/trunk-jpl-damage/src/c/modules/SurfaceAbsVelMisfitx/SurfaceAbsVelMisfitx.cpp

-              r12168
+              r13101
 #include "../../EnumDefinitions/EnumDefinitions.h"
 void SurfaceAbsVelMisfitx( double* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units,int weight_index){
+void SurfaceAbsVelMisfitx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units,int weight_index){
         /*Intermediary*/
 …
         /*output: */
         double J=0;
         double J_sum;
+        IssmDouble J=0;
+        IssmDouble J_sum;
         /*Compute Misfit: */

issm/branches/trunk-jpl-damage/src/c/modules/SurfaceAbsVelMisfitx/SurfaceAbsVelMisfitx.h

r12878	r13101
10	10
11	11	/* local prototypes: */
12		void SurfaceAbsVelMisfitx( double* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units,int weight_index);
	12	void SurfaceAbsVelMisfitx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units,int weight_index);
13	13
14	14	#endif

issm/branches/trunk-jpl-damage/src/c/modules/SurfaceAverageVelMisfitx/SurfaceAverageVelMisfitx.cpp

-              r12168
+              r13101
 #include "../SurfaceAreax/SurfaceAreax.h"
 void SurfaceAverageVelMisfitx( double* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units,int weight_index){
+void SurfaceAverageVelMisfitx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units,int weight_index){
         /*Intermediary*/
 …
         /*output: */
         double J=0;
         double J_sum;
+        IssmDouble J=0;
+        IssmDouble J_sum;
         /*Compute surface area and add to elements inputs */

issm/branches/trunk-jpl-damage/src/c/modules/SurfaceAverageVelMisfitx/SurfaceAverageVelMisfitx.h

r12878	r13101
10	10
11	11	/* local prototypes: */
12		void SurfaceAverageVelMisfitx( double* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units,int weight_index);
	12	void SurfaceAverageVelMisfitx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units,int weight_index);
13	13
14	14	#endif

issm/branches/trunk-jpl-damage/src/c/modules/SurfaceLogVelMisfitx/SurfaceLogVelMisfitx.cpp

-              r12168
+              r13101
 #include "../../EnumDefinitions/EnumDefinitions.h"
 void SurfaceLogVelMisfitx( double* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units,int weight_index){
+void SurfaceLogVelMisfitx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units,int weight_index){
         /*Intermediary*/
 …
         /*output: */
         double J=0;
         double J_sum;
+        IssmDouble J=0;
+        IssmDouble J_sum;
         /*Compute Misfit: */

issm/branches/trunk-jpl-damage/src/c/modules/SurfaceLogVelMisfitx/SurfaceLogVelMisfitx.h

r12878	r13101
10	10
11	11	/* local prototypes: */
12		void SurfaceLogVelMisfitx( double* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units,int weight_index);
	12	void SurfaceLogVelMisfitx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units,int weight_index);
13	13
14	14	#endif

issm/branches/trunk-jpl-damage/src/c/modules/SurfaceLogVxVyMisfitx/SurfaceLogVxVyMisfitx.cpp

-              r12168
+              r13101
 #include "../../EnumDefinitions/EnumDefinitions.h"
 void SurfaceLogVxVyMisfitx( double* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units,int weight_index){
+void SurfaceLogVxVyMisfitx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units,int weight_index){
         /*Intermediary*/
 …
         /*output: */
         double J=0;
         double J_sum;
+        IssmDouble J=0;
+        IssmDouble J_sum;
         /*Compute Misfit: */

issm/branches/trunk-jpl-damage/src/c/modules/SurfaceLogVxVyMisfitx/SurfaceLogVxVyMisfitx.h

r12878	r13101
10	10
11	11	/* local prototypes: */
12		void SurfaceLogVxVyMisfitx( double* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units,int weight_index);
	12	void SurfaceLogVxVyMisfitx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units,int weight_index);
13	13
14	14	#endif

issm/branches/trunk-jpl-damage/src/c/modules/SurfaceRelVelMisfitx/SurfaceRelVelMisfitx.cpp

-              r12168
+              r13101
 #include "../../EnumDefinitions/EnumDefinitions.h"
 void SurfaceRelVelMisfitx( double* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units,int weight_index){
+void SurfaceRelVelMisfitx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units,int weight_index){
         /*Intermediary*/
 …
         /*output: */
         double J=0;
         double J_sum;
+        IssmDouble J=0;
+        IssmDouble J_sum;
         /*Compute Misfit: */

issm/branches/trunk-jpl-damage/src/c/modules/SurfaceRelVelMisfitx/SurfaceRelVelMisfitx.h

r12878	r13101
10	10
11	11	/* local prototypes: */
12		void SurfaceRelVelMisfitx( double* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units,int weight_index);
	12	void SurfaceRelVelMisfitx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units,int weight_index);
13	13
14	14	#endif

issm/branches/trunk-jpl-damage/src/c/modules/ThicknessAbsGradientx/ThicknessAbsGradientx.cpp

-              r12168
+              r13101
 #include "../../EnumDefinitions/EnumDefinitions.h"
 void ThicknessAbsGradientx( double* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units, int weight_index){
+void ThicknessAbsGradientx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units, int weight_index){
         /*Intermediary*/
 …
         /*output: */
         double J=0;
         double J_sum;
+        IssmDouble J=0;
+        IssmDouble J_sum;
         /*Compute Misfit: */

issm/branches/trunk-jpl-damage/src/c/modules/ThicknessAbsGradientx/ThicknessAbsGradientx.h

r12878	r13101
10	10
11	11	/* local prototypes: */
12		void ThicknessAbsGradientx( double* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units,int weight_index);
	12	void ThicknessAbsGradientx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units,int weight_index);
13	13
14	14	#endif

issm/branches/trunk-jpl-damage/src/c/modules/ThicknessAbsMisfitx/ThicknessAbsMisfitx.cpp

-              r12168
+              r13101
 #include "../../EnumDefinitions/EnumDefinitions.h"
 void ThicknessAbsMisfitx( double* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units, int weight_index){
+void ThicknessAbsMisfitx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units, int weight_index){
         /*Intermediary*/
 …
         /*output: */
         double J=0;
         double J_sum;
+        IssmDouble J=0;
+        IssmDouble J_sum;
         /*Compute Misfit: */

issm/branches/trunk-jpl-damage/src/c/modules/ThicknessAbsMisfitx/ThicknessAbsMisfitx.h

r12878	r13101
10	10
11	11	/* local prototypes: */
12		void ThicknessAbsMisfitx( double* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units,int weight_index);
	12	void ThicknessAbsMisfitx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units,int weight_index);
13	13
14	14	#endif

issm/branches/trunk-jpl-damage/src/c/modules/ThicknessAcrossGradientx/ThicknessAcrossGradientx.cpp

-              r12927
+              r13101
 #include "../../EnumDefinitions/EnumDefinitions.h"
 void ThicknessAcrossGradientx( double* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units, int weight_index){
+void ThicknessAcrossGradientx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units, int weight_index){
         /*Intermediary*/
 …
         /*output: */
         double J=0;
         double J_sum;
+        IssmDouble J=0;
+        IssmDouble J_sum;
         /*Compute Misfit: */

issm/branches/trunk-jpl-damage/src/c/modules/ThicknessAcrossGradientx/ThicknessAcrossGradientx.h

r12927	r13101
10	10
11	11	/* local prototypes: */
12		void ThicknessAcrossGradientx( double* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units,int weight_index);
	12	void ThicknessAcrossGradientx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units,int weight_index);
13	13
14	14	#endif

issm/branches/trunk-jpl-damage/src/c/modules/ThicknessAlongGradientx/ThicknessAlongGradientx.cpp

-              r12927
+              r13101
 #include "../../EnumDefinitions/EnumDefinitions.h"
 void ThicknessAlongGradientx( double* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units, int weight_index){
+void ThicknessAlongGradientx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units, int weight_index){
         /*Intermediary*/
 …
         /*output: */
         double J=0;
         double J_sum;
+        IssmDouble J=0;
+        IssmDouble J_sum;
         /*Compute Misfit: */

issm/branches/trunk-jpl-damage/src/c/modules/ThicknessAlongGradientx/ThicknessAlongGradientx.h

r12927	r13101
10	10
11	11	/* local prototypes: */
12		void ThicknessAlongGradientx( double* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units,int weight_index);
	12	void ThicknessAlongGradientx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units,int weight_index);
13	13
14	14	#endif

issm/branches/trunk-jpl-damage/src/c/modules/TotalSmbx/TotalSmbx.cpp

-              r12773
+              r13101
 #include "../../EnumDefinitions/EnumDefinitions.h"
 void TotalSmbx(double* pSmb, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
+void TotalSmbx(IssmDouble* pSmb, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
         double local_smb = 0;
         double total_smb;
+        IssmDouble local_smb = 0;
+        IssmDouble total_smb;
         for(int i=0;i<elements->Size();i++){

issm/branches/trunk-jpl-damage/src/c/modules/TotalSmbx/TotalSmbx.h

r12832	r13101
10	10
11	11	/* local prototypes: */
12		void TotalSmbx(double* pSmb, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
	12	void TotalSmbx(IssmDouble* pSmb, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
13	13
14	14	#endif

issm/branches/trunk-jpl-damage/src/c/modules/Xy2llx/Xy2llx.cpp

-              r12878
+              r13101
         double  sl,rho,cm,T,chi;
         if((sgn!=1) && (sgn!=-1)) _error2_("Sign should be either +1 or -1.\n");
+        if((sgn!=1) && (sgn!=-1)) _error_("Sign should be either +1 or -1.\n");
         delta = central_meridian;
 …
                 if(flag) _pprintLine_("Warning: expecting coordinates in polar stereographic (Std Latitude: 71S Meridian: 0).");
+        }
         else _error2_("Sign should be either +1 or -1.\n");
+        else _error_("Sign should be either +1 or -1.\n");
         return;

issm/branches/trunk-jpl-damage/src/c/python/io/CheckNumPythonArguments.cpp

-              r12878
+              r13101
         if (size==0){
                 function();
                 _error2_("usage: see above");
+                _error_("usage: see above");
+        }
         else if (size!=NRHS ) {
                 function();
                 _error2_("usage error.");
+                _error_("usage error.");
+        }
         return 1;

issm/branches/trunk-jpl-damage/src/c/python/io/FetchPythonData.cpp

-              r12878
+              r13101
         /*check this is indeed a subtype of long type: */
         if(!PyBool_Check(py_boolean))_error2_("expecting a boolean in input!");
+        if(!PyBool_Check(py_boolean))_error_("expecting a boolean in input!");
         /*extract boolean: */
 …
         /*retrive dimensions: */
         ndim=PyArray_NDIM((const PyArrayObject*)py_matrix);
         if(ndim!=2)_error2_("expecting an MxN matrix in input!");
+        if(ndim!=2)_error_("expecting an MxN matrix in input!");
         dims=PyArray_DIMS((PyArrayObject*)py_matrix);
         M=dims[0]; N=dims[1];
 …
         /*retrive dimensions: */
         ndim=PyArray_NDIM((const PyArrayObject*)py_matrix);
         if(ndim!=2)_error2_("expecting an MxN matrix in input!");
+        if(ndim!=2)_error_("expecting an MxN matrix in input!");
         dims=PyArray_DIMS((PyArrayObject*)py_matrix);
         M=dims[0]; N=dims[1];
 …
         /*retrive dimensions: */
         ndim=PyArray_NDIM((const PyArrayObject*)py_vector);
         if(ndim!=1)_error2_("expecting an Mx1 vector in input!");
+        if(ndim!=1)_error_("expecting an Mx1 vector in input!");
         dims=PyArray_DIMS((PyArrayObject*)py_vector);
         M=dims[0];

issm/branches/trunk-jpl-damage/src/c/python/io/WritePythonData.cpp

-              r12878
+              r13101
+/*FUNCTION WriteData(PyObject* py_tuple,int index,int integer){{{*/
+void WriteData(PyObject* py_tuple, int index, int integer){
+        PyTuple_SetItem(py_tuple, index, PyInt_FromSsize_t(integer));
+}/*}}}*/
 /*FUNCTION WriteData(PyObject* py_tuple,int index,char* string){{{*/
 void WriteData(PyObject* py_tuple, int index, char* string){

issm/branches/trunk-jpl-damage/src/c/python/io/pythonio.h

r12878	r13101
28	28	//void WriteData(DataHandle* py_tuple,Parameters* parameters);
29	29	void WriteData(PyObject* py_tuple, int index, double* matrix, int M,int N);
	30	void WriteData(PyObject* py_tuple, int index, int integer);
30	31	void WriteData(PyObject* py_tuple, int index, char* string);
31	32	void WriteData(PyObject* py_tuple, int index, Matrix* matrix);

issm/branches/trunk-jpl-damage/src/c/shared/Alloc/alloc.cpp

-              r12878
+              r13101
         void* memptr=NULL;
         if(!size)_error2_("attempting to 0 size allocation!");
+        if(!size)_error_("attempting to 0 size allocation!");
         /* Use the c library to do the allocation: */
         memptr=malloc(size);
         if(!memptr) _error2_("memory allocation failed!");
+        if(!memptr) _error_("memory allocation failed!");
         return memptr;
 …
         void* memptr=NULL;
         if(!size)_error2_("attempting to 0 size allocation!");
+        if(!size)_error_("attempting to 0 size allocation!");
         /* Use the c library to do the allocation: */
         memptr=calloc(n,size);
         if(!memptr) _error2_("memory allocation failed!");
+        if(!memptr) _error_("memory allocation failed!");
         return memptr;
 …
         register void* value=NULL;
         if(!size)_error2_("attempting to realloc to zero");
+        if(!size)_error_("attempting to realloc to zero");
         value = (void*)realloc(pv,size);
         if (value == NULL) {
                 _error2_("virtual memory exhausted");
+                _error_("virtual memory exhausted");
+        }
         return value;

issm/branches/trunk-jpl-damage/src/c/shared/Elements/CoordinateSystemTransform.cpp

r12878	r13101
22	22	case XYEnum: numdofs+=2; break;
23	23	case XYZPEnum: numdofs+=4; break;
24		default: _error2_("Coordinate system " << EnumToStringx(cs_array[i]) << " not supported yet");
	24	default: _error_("Coordinate system " << EnumToStringx(cs_array[i]) << " not supported yet");
25	25	}
26	26	}
…	…
67	67	break;
68	68	default:
69		_error2_("Coordinate system " << EnumToStringx(cs_array[i]) << " not supported yet");
	69	_error_("Coordinate system " << EnumToStringx(cs_array[i]) << " not supported yet");
70	70	}
71	71	}

issm/branches/trunk-jpl-damage/src/c/shared/Elements/PddSurfaceMassBalance.cpp

-              r12878
+              r13101
       if (tstar < PDup){
         pd = 1.;
         if (tstar >= -siglimc){ pd = pds[int(tstar/DT + siglim0c)];}}
+        if (tstar >= -siglimc){ pd = pds[reCast<int,IssmDouble>(tstar/DT + siglim0c)];}}
       else {
         pd = 0.;}
 …
       if (tstar >= siglim) {pdd = pdd + tstar*deltm;}
       else if (tstar> -siglim){
         pddsig=pdds[int(tstar/DT + siglim0)];
+        pddsig=pdds[reCast<int,IssmDouble>(tstar/DT + siglim0)];
         pdd = pdd + pddsig*deltm;
         frzndd = frzndd - (tstar-pddsig)*deltm;}

issm/branches/trunk-jpl-damage/src/c/shared/Elements/TransformInvStiffnessMatrixCoord.cpp

r12878	r13101
31	31	case XYEnum: numdofs+=2; break;
32	32	case XYZPEnum: numdofs+=4; break;
33		default: _error2_("Coordinate system " << EnumToStringx(cs_array[i]) << " not supported yet");
	33	default: _error_("Coordinate system " << EnumToStringx(cs_array[i]) << " not supported yet");
34	34	}
35	35	}

issm/branches/trunk-jpl-damage/src/c/shared/Elements/TransformLoadVectorCoord.cpp

r12878	r13101
30	30	case XYEnum: numdofs+=2; break;
31	31	case XYZPEnum: numdofs+=4; break;
32		default: _error2_("Coordinate system " << EnumToStringx(cs_array[i]) << " not supported yet");
	32	default: _error_("Coordinate system " << EnumToStringx(cs_array[i]) << " not supported yet");
33	33	}
34	34	}

issm/branches/trunk-jpl-damage/src/c/shared/Elements/TransformSolutionCoord.cpp

r12878	r13101
31	31	case XYEnum: numdofs+=2; break;
32	32	case XYZPEnum: numdofs+=4; break;
33		default: _error2_("Coordinate system " << EnumToStringx(cs_array[i]) << " not supported yet");
	33	default: _error_("Coordinate system " << EnumToStringx(cs_array[i]) << " not supported yet");
34	34	}
35	35	}

issm/branches/trunk-jpl-damage/src/c/shared/Elements/TransformStiffnessMatrixCoord.cpp

r12878	r13101
31	31	case XYEnum: numdofs+=2; break;
32	32	case XYZPEnum: numdofs+=4; break;
33		default: _error2_("Coordinate system " << EnumToStringx(cs_array[i]) << " not supported yet");
	33	default: _error_("Coordinate system " << EnumToStringx(cs_array[i]) << " not supported yet");
34	34	}
35	35	}

issm/branches/trunk-jpl-damage/src/c/shared/Exp/DomainOutlineRead.cpp

r12878	r13101
39	39	/open domain outline file for reading: /
40	40	if ((fid=fopen(domainname,"r"))==NULL){
41		_error2_("could not find domain file " << domainname);
	41	_error_("could not find domain file " << domainname);
42	42	}
43	43

issm/branches/trunk-jpl-damage/src/c/shared/Exp/DomainOutlineWrite.cpp

r12878	r13101
23	23	/open domain outline file for writing: /
24	24	if ((fid=fopen(domainname,"w"))==NULL){
25		_error2_("could not open domain file " << domainname);
	25	_error_("could not open domain file " << domainname);
26	26	noerr=0; goto cleanupandreturn;
27	27	}

issm/branches/trunk-jpl-damage/src/c/shared/Matrix/MatrixUtils.cpp

-              r12878
+              r13101
         if (!itrnb) {
                 if (nrowb != idimb) {
                         _error2_("Matrix A and B inner vectors not equal size.");
+                        _error_("Matrix A and B inner vectors not equal size.");
+                }
                 idimc=ncolb;
 …
         else {
                 if (ncolb != idimb) {
                         _error2_("Matrix A and B inner vectors not equal size.");
+                        _error_("Matrix A and B inner vectors not equal size.");
+                }
                 idimc=nrowb;
 …
         if (!itrnc) {
                 if (nrowc != idimc) {
                         _error2_("Matrix B and C inner vectors not equal size.");
+                        _error_("Matrix B and C inner vectors not equal size.");
+                }
                 idimd=ncolc;
 …
         else {
                 if (ncolc != idimc) {
                         _error2_("Matrix B and C inner vectors not equal size.");
+                        _error_("Matrix B and C inner vectors not equal size.");
+                }
                 idimd=nrowc;
 …
         if (ntrma != ntrmb) {
                 _error2_("Matrix A and B inner vectors not equal size");
+                _error_("Matrix A and B inner vectors not equal size");
             noerr=0;
                 return noerr;
 …
         if (!b && nvec) {
                 _error2_("No right-hand side for nvec=" << nvec << ".");
+                _error_("No right-hand side for nvec=" << nvec << ".");
                 noerr=0;
                 return noerr;
 …
                         xDelete<int>(pivrc2);
                         xDelete<int>(pindx);
                         _error2_("Pivot " << pivot << " less than machine epsilon");
+                        _error_("Pivot " << pivot << " less than machine epsilon");
                         noerr=0;
                         return noerr;
 …
         /*Compute determinant*/
         Matrix2x2Determinant(&det,A);
         if (fabs(det) < DBL_EPSILON) _error2_("Determinant smaller that machine epsilon");
+        if (fabs(det) < DBL_EPSILON) _error_("Determinant smaller that machine epsilon");
         /*Compute invert*/
 …
         /*Compute determinant*/
         Matrix3x3Determinant(&det,A);
         if (fabs(det) < DBL_EPSILON) _error2_("Determinant smaller that machine epsilon");
+        if (fabs(det) < DBL_EPSILON) _error_("Determinant smaller that machine epsilon");
         /*Compute invert*/

issm/branches/trunk-jpl-damage/src/c/shared/Numerics/BrentSearch.cpp

-              r12878
+              r13101
         iter=0;
         fxmin = (*f)(xmin,optargs);
         if (xIsNan<IssmDouble>(fxmin)) _error2_("Function evaluation returned NaN");
+        if (xIsNan<IssmDouble>(fxmin)) _error_("Function evaluation returned NaN");
         cout<<setprecision(5);
         if(VerboseControl()) _pprintLine_("");
 …
         if(VerboseControl()) _pprintLine_("           N/A    "<<setw(12)<<xmin<<"  "<<setw(12)<<fxmin<<"           N/A         boundary");
         fxmax = (*f)(xmax,optargs);
         if (xIsNan<IssmDouble>(fxmax)) _error2_("Function evaluation returned NaN");
+        if (xIsNan<IssmDouble>(fxmax)) _error_("Function evaluation returned NaN");
         if(VerboseControl()) _pprintLine_("           N/A    "<<setw(12)<<xmax<<"  "<<setw(12)<<fxmax<<"           N/A         boundary");
 …
         /*2: call the function to be evaluated*/
         fxbest = (*f)(x,optargs);
         if(xIsNan<IssmDouble>(fxbest)) _error2_("Function evaluation returned NaN");
+        if(xIsNan<IssmDouble>(fxbest)) _error_("Function evaluation returned NaN");
         iter=iter+1;
 …
                 //evaluate function on x
                 fx = (*f)(x,optargs);
                 if(xIsNan<IssmDouble>(fx)) _error2_("Function evaluation returned NaN");
+                if(xIsNan<IssmDouble>(fx)) _error_("Function evaluation returned NaN");
                 iter=iter+1;

issm/branches/trunk-jpl-damage/src/c/shared/Numerics/GaussPoints.cpp

r12878	r13101
1670	1670	if (iter >= MAX_GAUS_ITER) {
1671	1671	xDelete<IssmPDouble>(work);
1672		_error2_("Max iterations exceeded for l=" << MAX_GAUS_ITER);
	1672	_error_("Max iterations exceeded for l=" << MAX_GAUS_ITER);
1673	1673	}
1674	1674	}

issm/branches/trunk-jpl-damage/src/c/shared/Numerics/IsInputConverged.cpp

r12878	r13101
53	53	else eps=0;
54	54	}
55		else _error2_("convergence criterion " << EnumToStringx(criterion_enum) << " not supported yet!");
	55	else _error_("convergence criterion " << EnumToStringx(criterion_enum) << " not supported yet!");
56	56
57	57	/Assign output pointers:/

issm/branches/trunk-jpl-damage/src/c/shared/Numerics/OptimalSearch.cpp

-              r12878
+              r13101
         //get the value of the function at the first boundary
         fx1= (*f)(x1,optargs);
         if (xIsNan<IssmDouble>(fx1)) _error2_("Function evaluation returned NaN");
+        if (xIsNan<IssmDouble>(fx1)) _error_("Function evaluation returned NaN");
         cout<<setprecision(5);
         if(VerboseControl()) _pprintLine_("");
 …
                 iter++;
                 fx2 = (*f)(x2,optargs);
                 if (xIsNan<IssmDouble>(fx2)) _error2_("Function evaluation returned NaN");
+                if (xIsNan<IssmDouble>(fx2)) _error_("Function evaluation returned NaN");
                 if(VerboseControl())
                  _pprintLine_("         "<<setw(5)<<iter<<"    "<<setw(12)<<x2<<"  "<<setw(12)<<fx2<<"  "<<(fabs(x2-x1)>fabs(fx2-fx1)?fabs(fx2-fx1):fabs(x2-x1)));

issm/branches/trunk-jpl-damage/src/c/shared/Numerics/OptionsFromAnalysis.cpp

r12878	r13101
57	57	if (found==-1){
58	58	/ok, we did not find anything, this is not good! error out: /
59		_error2_("could find neither a default analysis nor analysis " << EnumToStringx(analysis_type));
	59	_error_("could find neither a default analysis nor analysis " << EnumToStringx(analysis_type));
60	60	}
61	61

issm/branches/trunk-jpl-damage/src/c/shared/Numerics/UnitConversion.cpp

r12946	r13101
29	29	if(direction_enum==IuToExtEnum) for(i=0;i<numvalues;i++)values[i]=values[i]*scale;
30	30	else if(direction_enum==ExtToIuEnum) for(i=0;i<numvalues;i++)values[i]=values[i]/scale;
31		else _error2_("wrong direction for unit conversion, either IuToExtEnum or ExtToIuEnum. ");
	31	else _error_("wrong direction for unit conversion, either IuToExtEnum or ExtToIuEnum. ");
32	32
33	33	}

issm/branches/trunk-jpl-damage/src/c/shared/Numerics/Verbosity.cpp

r12878	r13101
34	34	void SetVerbosityLevel(int level){
35	35
36		if(level<0) _error2_("vebosity level should be a positive integer (user provided " << level << ")");
	36	if(level<0) _error_("vebosity level should be a positive integer (user provided " << level << ")");
37	37
38	38	verbositylevel = level;

issm/branches/trunk-jpl-damage/src/c/shared/Numerics/numerics.h

-              r12878
+              r13101
 struct OptPars;
+IssmDouble min(IssmDouble a,IssmDouble b);
+IssmDouble max(IssmDouble a,IssmDouble b);
+int    min(int a,int b);
+int    max(int a,int b);
+IssmDouble OptFunc(IssmDouble scalar, OptArgs* optargs);
+void   BrentSearch(IssmDouble* psearch_scalar,IssmDouble* pJ,OptPars* optpars,IssmDouble (*f)(IssmDouble,OptArgs*), OptArgs* optargs);
+void   OptimalSearch(IssmDouble* psearch_scalar,IssmDouble* pJ,OptPars* optpars,IssmDouble (*f)(IssmDouble,OptArgs*), OptArgs* optargs);
+void   cross(IssmDouble* result,IssmDouble* vector1,IssmDouble* vector2);
+void   IsInputConverged(IssmDouble* peps, Input** new_inputs,Input** old_inputs,int num_inputs,int criterion_enum);
+void   UnitConversion(IssmDouble* values, int numvalues,int direction_enum, int type_enum);
+IssmDouble UnitConversion(IssmDouble value, int direction_enum, int type_enum);
+char*  OptionsFromAnalysis(Parameters* parameters,int analysis_type);
+void   XZvectorsToCoordinateSystem(IssmDouble* T,IssmDouble* xzvectors);
+IssmDouble  min(IssmDouble a,IssmDouble b);
+IssmDouble  max(IssmDouble a,IssmDouble b);
+int         min(int a,int b);
+int         max(int a,int b);
+IssmDouble  OptFunc(IssmDouble scalar, OptArgs *optargs);
+void        BrentSearch(IssmDouble *psearch_scalar,IssmDouble*pJ,OptPars*optpars,IssmDouble (*f)(IssmDouble,OptArgs*), OptArgs*optargs);
+void        OptimalSearch(IssmDouble *psearch_scalar,IssmDouble*pJ,OptPars*optpars,IssmDouble (*f)(IssmDouble,OptArgs*), OptArgs*optargs);
+void        cross(IssmDouble *result,IssmDouble*vector1,IssmDouble*vector2);
+void        IsInputConverged(IssmDouble *peps, Input**new_inputs,Input**old_inputs,int num_inputs,int criterion_enum);
+void        UnitConversion(IssmDouble *values, int numvalues,int direction_enum, int type_enum);
+IssmDouble  UnitConversion(IssmDouble value, int direction_enum, int type_enum);
+char       *OptionsFromAnalysis(Parameters *parameters,int analysis_type);
+void        XZvectorsToCoordinateSystem(IssmDouble *T,IssmDouble*xzvectors);
+int         cubic(IssmDouble a, IssmDouble b, IssmDouble c, IssmDouble d, double X[3], int *num);
 #ifdef _HAVE_PETSC_
 void   PetscOptionsFromAnalysis(Parameters* parameters,int analysis_type);

issm/branches/trunk-jpl-damage/src/c/shared/String/DescriptorIndex.cpp

-              r12878
+              r13101
         /*retrieve first token, separated by underscore: */
         pch = strtok (descriptor,"_");
         if(!pch)_error2_("descriptor " << descriptor << " is not correctly formatted!");
+        if(!pch)_error_("descriptor " << descriptor << " is not correctly formatted!");
         if (strncmp(pch,"scaled",6)==0){
                 /*we have a scaled variable. recover the root: */
                 pch = strtok (NULL, "_");
                 if(!pch)_error2_("scaled descriptor " << descriptor << " is not correctly formatted!");
+                if(!pch)_error_("scaled descriptor " << descriptor << " is not correctly formatted!");
                 memcpy(root,pch,(strlen(pch)+1)*sizeof(char));
 …
                 /*we have an indexed variable. recover the root: */
                 pch = strtok (NULL, "_");
                 if(!pch)_error2_("indexed descriptor " << descriptor << " is not correctly formatted!");
+                if(!pch)_error_("indexed descriptor " << descriptor << " is not correctly formatted!");
                 memcpy(root,pch,(strlen(pch)+1)*sizeof(char));
                 /*now recover  the index: */
                 pch = strtok (NULL, "_");
                 if(!pch)_error2_("indexed descriptor " << descriptor << " is not correctly formatted!");
+                if(!pch)_error_("indexed descriptor " << descriptor << " is not correctly formatted!");
                 sscanf(pch,"%i",pindex);
                 return IndexedEnum;
 …
                 /*we have an indexed variable. recover the root: */
                 pch = strtok (NULL, "_");
                 if(!pch)_error2_("nodal descriptor " << descriptor << " is not correctly formatted!");
+                if(!pch)_error_("nodal descriptor " << descriptor << " is not correctly formatted!");
                 memcpy(root,pch,(strlen(pch)+1)*sizeof(char));
                 /*now recover  the index: */
                 pch = strtok (NULL, "_");
                 if(!pch)_error2_("nodal descriptor " << descriptor << " is not correctly formatted!");
+                if(!pch)_error_("nodal descriptor " << descriptor << " is not correctly formatted!");
                 sscanf(pch,"%i",pindex);
                 return NodalEnum;

issm/branches/trunk-jpl-damage/src/c/shared/Threads/LaunchThread.cpp

r12878	r13101
44	44
45	45	if(pthread_create(threads+i,NULL,function,(void*)(handles+i))){
46		_error2_("pthread_create error");
	46	_error_("pthread_create error");
47	47	}
48	48	}
49	49	for(i=0;i<num_threads;i++){
50	50	if(pthread_join(threads[i],(void**)&status)){
51		_error2_("pthread_join error");
	51	_error_("pthread_join error");
52	52	}
53	53	}

issm/branches/trunk-jpl-damage/src/c/solutions/AdjointCorePointerFromSolutionEnum.cpp

r12878	r13101
35	35	break;
36	36	default:
37		_error2_("No adjoint has been implemented for solution " << EnumToStringx(solutiontype) << " yet");
	37	_error_("No adjoint has been implemented for solution " << EnumToStringx(solutiontype) << " yet");
38	38	break;
39	39	}

issm/branches/trunk-jpl-damage/src/c/solutions/AnalysisConfiguration.cpp

r12878	r13101
110	110
111	111	default:
112		_error2_("solution type: " << EnumToStringx(solutiontype) << " not supported yet!");
	112	_error_("solution type: " << EnumToStringx(solutiontype) << " not supported yet!");
113	113	break;
114	114	}

issm/branches/trunk-jpl-damage/src/c/solutions/CorePointerFromSolutionEnum.cpp

-              r12878
+              r13101
                         solutioncore=&diagnostic_core;
                         #else
                         _error2_("ISSM was not compiled with diagnostic capabilities. Exiting");
+                        _error_("ISSM was not compiled with diagnostic capabilities. Exiting");
                         #endif
                         break;
 …
                         solutioncore=&steadystate_core;
                         #else
                         _error2_("ISSM was not compiled with steady state capabilities. Exiting");
+                        _error_("ISSM was not compiled with steady state capabilities. Exiting");
                         #endif
                         break;
 …
                         solutioncore=&thermal_core;
                         #else
                         _error2_("ISSM was not compiled with thermal capabilities. Exiting");
+                        _error_("ISSM was not compiled with thermal capabilities. Exiting");
                         #endif
                         break;
 …
                         solutioncore=&enthalpy_core;
                         #else
                         _error2_("ISSM was not compiled with thermal capabilities. Exiting");
+                        _error_("ISSM was not compiled with thermal capabilities. Exiting");
                         #endif
                         break;
 …
                         solutioncore=&balancethickness_core;
                         #else
                         _error2_("ISSM was not compiled with balanced capabilities. Exiting");
+                        _error_("ISSM was not compiled with balanced capabilities. Exiting");
                         #endif
                         break;
 …
                         solutioncore=&hydrology_core;
                         #else
                         _error2_("ISSM was not compiled with hydrology capabilities. Exiting");
+                        _error_("ISSM was not compiled with hydrology capabilities. Exiting");
                         #endif
                         break;
 …
                         solutioncore=&surfaceslope_core;
                         #else
                         _error2_("ISSM was not compiled with slope capabilities. Exiting");
+                        _error_("ISSM was not compiled with slope capabilities. Exiting");
                         #endif
                         break;
 …
                         solutioncore=&bedslope_core;
                         #else
                         _error2_("ISSM was not compiled with slope capabilities. Exiting");
+                        _error_("ISSM was not compiled with slope capabilities. Exiting");
                         #endif
                         break;
 …
                         solutioncore=&transient_core;
                         #else
                         _error2_("ISSM was not compiled with transient capabilities. Exiting");
+                        _error_("ISSM was not compiled with transient capabilities. Exiting");
                         #endif
                         break;
 …
                         solutioncore=&prognostic_core;
                         #else
                         _error2_("ISSM was not compiled with prognostic capabilities. Exiting");
+                        _error_("ISSM was not compiled with prognostic capabilities. Exiting");
                         #endif
                         break;
                 default:
                         _error2_("solution type: " << EnumToStringx(solutiontype) << " not supported yet!");
+                        _error_("solution type: " << EnumToStringx(solutiontype) << " not supported yet!");
                         break;
+        }

issm/branches/trunk-jpl-damage/src/c/solutions/ProcessArguments.cpp

-              r12878
+              r13101
         char *lockfilename   = NULL;
         if(argc<2)_error2_("Usage error: no solution requested");
+        if(argc<2)_error_("Usage error: no solution requested");
         *solution_type=StringToEnumx(argv[1]);
         if(argc<3)_error2_("Usage error: missing model name");
+        if(argc<3)_error_("Usage error: missing model name");
         modelname=argv[3];
         binfilename    = xNew<char>(strlen(modelname)+strlen(".bin")   +1); sprintf(binfilename,   "%s%s",modelname,".bin");

issm/branches/trunk-jpl-damage/src/c/solutions/WriteLockFile.cpp

-              r12878
+              r13101
         if(my_rank==0){
                 fid=fopen(filename,"w");
                 if(fid==NULL) _error2_("error message: could not open lock file " << filename);
+                if(fid==NULL) _error_("error message: could not open lock file " << filename);
                 /*Close file: */
                 if(fclose(fid)!=0) _error2_("could not close lock file " << filename);
+                if(fclose(fid)!=0) _error_("could not close lock file " << filename);
+        }

issm/branches/trunk-jpl-damage/src/c/solutions/control_core.cpp

-              r12878
+              r13101
                 /*Display info*/
                 if(VerboseControl()) _pprintLine_("\n" << "   control method step " << n+1 << "/" << nsteps);
                 for(i=0;i<num_responses;i++) step_responses[i]=(int)responses[n*num_responses+i];
+                for(i=0;i<num_responses;i++) step_responses[i]=reCast<int,IssmDouble>(responses[n*num_responses+i]);
                 femmodel->parameters->SetParam(step_responses,1,num_responses,StepResponsesEnum);
 …
                 if(VerboseControl()) _pprintLine_("   optimizing along gradient direction");
                 optpars.maxiter=(int)maxiter[n]; optpars.cm_jump=cm_jump[n];
+                optpars.maxiter=reCast<int,IssmDouble>(maxiter[n]); optpars.cm_jump=cm_jump[n];
                 BrentSearch(&search_scalar,J+n,&optpars,&objectivefunction,&optargs);

issm/branches/trunk-jpl-damage/src/c/solutions/controltao_core.cpp

-              r12946
+              r13101
 #include "../solvers/solvers.h"
 #if defined (_HAVE_TAO_) && defined (_HAVE_PETSC_) && (_PETSC_MAJOR_ == 3 && _PETSC_MINOR_ == 2)
+#if defined (_HAVE_TAO_) && defined (_HAVE_PETSC_) && (_PETSC_MAJOR_ == 3 && _PETSC_MINOR_ > 1)
 #include <tao.h>
 …
         PetscGetArgs(&argc,&args);
         ierr = TaoInitialize(&argc,&args,(char*)0,"");
         if(ierr) _error2_("Could not initialize Tao");
+        if(ierr) _error_("Could not initialize Tao");
         /*Recover some parameters*/
 …
         xdelete(&XU);
         user.J=(double*)xcalloc((maxiter+5),sizeof(double));
+        user.J=xNewZeroInit<double>(maxiter+5);
         user.femmodel=femmodel;
         TaoSetObjectiveAndGradientRoutine(tao,FormFunctionGradient,(void*)&user);
 …
 #else
 void controltao_core(FemModel* femmodel){
         _error2_("TAO not installed or PETSc version not supported");
+        _error_("TAO not installed or PETSc version not supported");
+}
 #endif //_HAVE_TAO_

issm/branches/trunk-jpl-damage/src/c/solutions/convergence.cpp

-              r12878
+              r13101
         if (xIsNan<IssmDouble>(res)){
                 _pprintLine_("norm nf = " << nF << "f and norm kuold = " << nKUoldF << "f");
                 _error2_("mechanical equilibrium convergence criterion is NaN!");
+                _error_("mechanical equilibrium convergence criterion is NaN!");
+        }
 …
         //print
         if(res<eps_res){
                 if(VerboseConvergence()) _pprintLine_(setw(50) << left << "   mechanical equilibrium convergence criterion" << res*100 << " < " << eps_res*100 << " %");
+                if(VerboseConvergence()) _pprintLine_(setw(50)<<left<<"   mechanical equilibrium convergence criterion"<<res*100<< " < "<<eps_res*100<<" %");
                 converged=true;
+        }
         else{
                 if(VerboseConvergence()) _pprintLine_(setw(50) << left << "   mechanical equilibrium convergence criterion" << res*100 << " > " << eps_res*100 << " %");
+                if(VerboseConvergence()) _pprintLine_(setw(50)<<left<<"   mechanical equilibrium convergence criterion"<<res*100<<" > "<<eps_res*100<<" %");
                 converged=false;
+        }
 …
                 ndu=duf->Norm(NORM_TWO); nu=old_uf->Norm(NORM_TWO);
                 if (xIsNan<IssmDouble>(ndu) || xIsNan<IssmDouble>(nu)) _error2_("convergence criterion is NaN!");
+                if (xIsNan<IssmDouble>(ndu) || xIsNan<IssmDouble>(nu)) _error_("convergence criterion is NaN!");
                 //clean up
 …
                 duf=old_uf->Duplicate(); old_uf->Copy(duf); duf->AYPX(uf,-1.0);
                 ndu=duf->Norm(NORM_TWO); nduinf=duf->Norm(NORM_INF);
                 if (xIsNan<IssmDouble>(ndu) || xIsNan<IssmDouble>(nu)) _error2_("convergence criterion is NaN!");
+                if (xIsNan<IssmDouble>(ndu) || xIsNan<IssmDouble>(nu)) _error_("convergence criterion is NaN!");
                 //clean up

issm/branches/trunk-jpl-damage/src/c/solutions/diagnostic_core.cpp

-              r12878
+              r13101
         bool  ishutter          = false;
         bool  ismacayealpattyn  = false;
+        bool  isl1l2            = false;
         bool  isstokes          = false;
         bool  isnewton          = false;
 …
         femmodel->parameters->FindParam(&ishutter,FlowequationIshutterEnum);
         femmodel->parameters->FindParam(&ismacayealpattyn,FlowequationIsmacayealpattynEnum);
+        femmodel->parameters->FindParam(&isl1l2,FlowequationIsl1l2Enum);
         femmodel->parameters->FindParam(&isstokes,FlowequationIsstokesEnum);
         femmodel->parameters->FindParam(&isnewton,DiagnosticIsnewtonEnum);
 …
+        }
         if (ismacayealpattyn ^ isstokes){ // ^ = xor
+        if ((ismacayealpattyn || isl1l2) ^ isstokes){ // ^ = xor
                 if(VerboseSolution()) _pprintLine_("   computing velocities");

issm/branches/trunk-jpl-damage/src/c/solutions/gradient_core.cpp

-              r12878
+              r13101
         /*Check that gradient is clean*/
         norm_inf=new_gradient->Norm(NORM_INF);
         if(norm_inf<=0)    _error2_("||∂J/∂α||∞ = 0    gradient norm is zero");
         if(xIsNan<IssmDouble>(norm_inf))_error2_("||∂J/∂α||∞ = NaN  gradient norm is NaN");
+        if(norm_inf<=0)    _error_("||∂J/∂α||∞ = 0    gradient norm is zero");
+        if(xIsNan<IssmDouble>(norm_inf))_error_("||∂J/∂α||∞ = NaN  gradient norm is NaN");
         /*plug back into inputs: */

issm/branches/trunk-jpl-damage/src/c/solutions/hydrology_core.cpp

r12878	r13101
39	39	nsteps=1;
40	40	}
41		else nsteps=~~(int)~~((final_time-starttime)/dt);
	41	else nsteps=reCast<int,IssmDouble>((final_time-starttime)/dt);
42	42	time=starttime;
43	43

issm/branches/trunk-jpl-damage/src/c/solutions/issm.cpp

-              r12878
+              r13101
         bool  dakota_analysis,control_analysis,tao_analysis;
+        /*AD: */
+        bool autodiff=false;
+        #if _ADOLC_VERSION_ == 2
+        int      tape_stats[11];
+        #else
+        size_t   tape_stats[11];
+        #endif
         /*FemModel: */
         FemModel *femmodel = NULL;
 …
         ISSMBOOT();
         /*Initialize environments: Petsc, MPI, etc...: */
         #ifdef _HAVE_PETSC_
         ierr=PetscInitialize(&argc,&argv,(char*)0,"");
         if(ierr) _error2_("Could not initialize Petsc");
+        if(ierr) _error_("Could not initialize Petsc");
         #else
         #ifdef _HAVE_MPI_
 …
         femmodel->parameters->FindParam(&tao_analysis,InversionTaoEnum);
         femmodel->parameters->FindParam(&profiling,DebugProfilingEnum);
+        femmodel->parameters->FindParam(&autodiff,AutodiffIsautodiffEnum);
         #ifdef _HAVE_MPI_
 …
         #else
         finish_init=(IssmPDouble)clock();
+        #endif
+        /*If running AD, then initialize the tape: */
+        #ifdef _HAVE_ADOLC_
+        if(autodiff) trace_on(1);
         #endif
 …
                 Dakotax(femmodel);
                 #else
                 _error2_("ISSM was not compiled with dakota support, cannot carry out dakota analysis!");
+                _error_("ISSM was not compiled with dakota support, cannot carry out dakota analysis!");
                 #endif
+        }
 …
                  control_core(femmodel);
                 #else
                 _error2_("ISSM was not compiled with control support, cannot carry out dakota analysis!");
+                _error_("ISSM was not compiled with control support, cannot carry out dakota analysis!");
                 #endif
+        }
 …
         _pprintLine_("write results to disk:");
         OutputResultsx(femmodel->elements, femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,femmodel->results);
+        /*If running AD, close our tape, print statistics: {{{*/
+        #ifdef _HAVE_ADOLC_
+        if(autodiff){
+                trace_off();
+                tapestats(1,tape_stats); //reading of tape statistics
+                _pprintLine_("   ADOLC statistics: ");
+                _pprintLine_("   "<<setw(45)<<left<<"Number of independents: " <<tape_stats[0]);
+                _pprintLine_("   "<<setw(45)<<left<<"Number of dependents: " <<tape_stats[1]);
+                _pprintLine_("   "<<setw(45)<<left<<"Maximal number of live active variables: " <<tape_stats[2]);
+                _pprintLine_("   "<<setw(45)<<left<<"Size of value stack (number of overwrites): " <<tape_stats[3]);
+                _pprintLine_("   "<<setw(45)<<left<<"Buffer size (a multiple of eight): " <<tape_stats[4]);
+                _pprintLine_("   "<<setw(45)<<left<<"Total number of operations recorded: " <<tape_stats[5]);
+        }
+        #endif  /*}}}*/
         /*Close output and petsc options file and write lock file if requested*/
 …
         #endif
         #endif
         /*end module: */

issm/branches/trunk-jpl-damage/src/c/solutions/kriging.cpp

-              r12878
+              r13101
 #ifdef _HAVE_PETSC_
         int ierr=PetscInitialize(&argc,&argv,(char*)0,"");
         if(ierr) _error2_("Could not initialize Petsc");
+        if(ierr) _error_("Could not initialize Petsc");
 #else
 #ifdef _HAVE_MPI_
 …
         char *lockfilename   = NULL;
         if(argc<2)_error2_("Usage error: missing model name");
+        if(argc<2)_error_("Usage error: missing model name");
         modelname=argv[2];
         binfilename    = xNew<char>((strlen(modelname)+strlen(".bin")   +1)); sprintf(binfilename,   "%s%s",modelname,".bin");

issm/branches/trunk-jpl-damage/src/c/solutions/objectivefunction.cpp

r12878	r13101
49	49	}
50	50	else{
51		_error2_("Solution " << EnumToStringx(solution_type) << " not implemented yet");
	51	_error_("Solution " << EnumToStringx(solution_type) << " not implemented yet");
52	52	}
53	53
…	…
66	66	}
67	67	else{
68		_error2_("Solution " << EnumToStringx(solution_type) << " not implemented yet");
	68	_error_("Solution " << EnumToStringx(solution_type) << " not implemented yet");
69	69	}
70	70

issm/branches/trunk-jpl-damage/src/c/solutions/steadystate_core.cpp

r12878	r13101
52	52	}
53	53	#else
54		_error2_("ISSM was not compiled with thermal capabilities. Exiting");
	54	_error_("ISSM was not compiled with thermal capabilities. Exiting");
55	55	#endif
56	56

issm/branches/trunk-jpl-damage/src/c/solutions/transient_core.cpp

-              r12946
+              r13101
+                        }
                         #else
                         _error2_("ISSM was not compiled with thermal capabilities. Exiting");
+                        _error_("ISSM was not compiled with thermal capabilities. Exiting");
                         #endif
+                }
 …
                         diagnostic_core(femmodel);
                         #else
                         _error2_("ISSM was not compiled with diagnostic capabilities. Exiting");
+                        _error_("ISSM was not compiled with diagnostic capabilities. Exiting");
                         #endif
+                }
 …
                         GroundinglineMigrationx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters);
                         #else
                         _error2_("ISSM was not compiled with grounding line migration capabilities. Exiting");
+                        _error_("ISSM was not compiled with grounding line migration capabilities. Exiting");
                         #endif
+                }

issm/branches/trunk-jpl-damage/src/c/toolkits/issm/SeqMat.cpp

-              r12878
+              r13101
                         break;
                 default:
                         _error2_("unknown norm !");
+                        _error_("unknown norm !");
                         break;
+        }
 …
         AX->GetSize(&AXM);
         if(M!=AXM)_error2_("A and AX should have the same number of rows!");
         if(N!=XM)_error2_("A and X should have the same number of columns!");
+        if(M!=AXM)_error_("A and AX should have the same number of rows!");
+        if(N!=XM)_error_("A and X should have the same number of columns!");
         for(i=0;i<M;i++){
 …
                         break;
                 default:
                         _error2_("unknown insert mode!");
+                        _error_("unknown insert mode!");
                         break;
+        }

issm/branches/trunk-jpl-damage/src/c/toolkits/issm/SeqVec.cpp

-              r12878
+              r13101
                         break;
                 default:
                         _error2_("unknown insert mode!");
+                        _error_("unknown insert mode!");
                         break;
+        }
 …
                         break;
                 default:
                         _error2_("unknown insert mode!");
+                        _error_("unknown insert mode!");
                         break;
+        }
 …
                         break;
                 default:
                         _error2_("unknown norm !");
+                        _error_("unknown norm !");
                         break;
+        }

issm/branches/trunk-jpl-damage/src/c/toolkits/metis/patches/METIS_PartMeshNodalPatch.cpp

r12878	r13101
60	60
61	61	#else
62		_error2_("METIS version not supported yet");
	62	_error_("METIS version not supported yet");
63	63	#endif
64	64	}

issm/branches/trunk-jpl-damage/src/c/toolkits/petsc/patches/ISSMToPetscInsertMode.cpp

r12878	r13101
30	30	break;
31	31	default:
32		_error2_("unknown insert mode!");
	32	_error_("unknown insert mode!");
33	33	break;
34	34	}

issm/branches/trunk-jpl-damage/src/c/toolkits/petsc/patches/ISSMToPetscMatrixType.cpp

r12878	r13101
30	30	break;
31	31	default:
32		_error2_("unknown matrix type !");
	32	_error_("unknown matrix type !");
33	33	break;
34	34	}

issm/branches/trunk-jpl-damage/src/c/toolkits/petsc/patches/ISSMToPetscNormMode.cpp

r12878	r13101
30	30	break;
31	31	default:
32		_error2_("unknown norm !");
	32	_error_("unknown norm !");
33	33	break;
34	34	}

issm/branches/trunk-jpl-damage/src/c/toolkits/petsc/patches/MatInvert.cpp

r12878	r13101
29	29	/Some checks: /
30	30	MatGetSize(matrix,&M,&N);
31		if(M!=N) _error2_("trying to invert a non square matrix!");
	31	if(M!=N) _error_("trying to invert a non square matrix!");
32	32
33	33	/Create identitiy matrix: /

issm/branches/trunk-jpl-damage/src/c/toolkits/petsc/patches/MatPartition.cpp

r12878	r13101
62	62	}
63	63	else{
64		_error2_("MatType " << type << " not supported yet");
	64	_error_("MatType " << type << " not supported yet");
65	65	}
66	66	/Assemble/

issm/branches/trunk-jpl-damage/src/c/toolkits/petsc/patches/PetscOptionsInsertMultipleString.cpp

r12878	r13101
55	55	if(first[0]!='-'){
56	56	/This is not good, the option does not have '-'! Get out/
57		_error2_("Option " << first << " should be preceded by '-'!");
	57	_error_("Option " << first << " should be preceded by '-'!");
58	58	}
59	59	/Reduce first to bare option value/

issm/branches/trunk-jpl-damage/src/c/toolkits/petsc/patches/VecMerge.cpp

r12878	r13101
35	35	/If the dimension of the partitioning vector is not the same as that of vector B, we have a problem: /
36	36	if ( (row_partition_size !=MB) ){
37		_error2_("Dimensions of partitioning vector incompatible with dimensions of input vector\n");
	37	_error_("Dimensions of partitioning vector incompatible with dimensions of input vector\n");
38	38	}
39	39

issm/branches/trunk-jpl-damage/src/c/toolkits/plapack/patches/PlapackInvertMatrix.cpp

r12878	r13101
51	51
52	52	/Some dimensions checks: /
53		if (mA!=nA) _error2_("trying to take the invert of a non-square matrix!");
	53	if (mA!=nA) _error_("trying to take the invert of a non-square matrix!");
54	54
55	55	/* Set default Plapack parameters */

issm/branches/trunk-jpl-damage/src/m/Makefile.am

-              r12946
+              r13101
+bin_SCRIPTS=./classes/*.m \
+                                ./classes/model/*.m \
+                                ./classes/clusters/*.m \
+                                ./enum/*.m \
+                                ./kml/*.m \
+                                ./model/*.m \
+                                ./model/plot/*.m \
+                                ./model/mesh/*.m \
+                                ./model/display/*.m \
+                                ./model/parameterization/*.m \
+                                ./model/partition/*.m \
+                                ./model/solvers/*.m \
+                                ./qmu/*.m \
+                                ./utils/*.m \
+                                ./utils/Array/*.m \
+                                ./utils/BC/*.m \
+                                ./utils/Basins/*.m \
+                                ./utils/Cluster/*.m \
+                                ./utils/DataProcessing/*.m \
+                                ./utils/Ecco3/*.m \
+                                ./utils/Exp/*.m \
+                                ./utils/Exp/manipulation/*.m \
+                                ./utils/Exp/readwrite/*.m \
+                                ./utils/Geometry/*.m \
+                                ./utils/ImageProcessing/*.m \
+                                ./utils/Interp/*.m \
+                                ./utils/Kml/*.m \
+                                ./utils/LatLong/*.m \
+                                ./utils/Math/*.m \
+                                ./utils/Meca/*.m \
+                                ./utils/Mesh/*.m \
+                                ./utils/Miscellaneous/*.m \
+                                ./utils/Model/*.m \
+                                ./utils/Numerics/*.m \
+                                ./utils/OS/*.m \
+                                ./utils/Plot/*.m \
+                                ./utils/Shell/*.m \
+                                ./utils/String/*.m \
+                                ./utils/consistency/*.m \
+                                ./utils/qmu/*.m
+#To generate list of directories
+#
+#find . -type d -exec ls -d {} \;
+bin_SCRIPTS= ./qmu/*.m \
+                                 ./qmu/setupdesign/*.m \
+                                 ./qmu/plot/*.m \
+                                 ./qmu/examples/*.m \
+                                 ./kml/*.m \
+                                 ./enum/*.m \
+                                 ./classes/*.m \
+                                 ./classes/qmu/*.m \
+                                 ./classes/qmu/@dakota_method/*.m \
+                                 ./classes/clusters/*.m \
+                                 ./classes/model/*.m \
+                                 ./consistency/*.m \
+                                 ./array/*.m \
+                                 ./boundaryconditions/*.m \
+                                 ./exp/*.m \
+                                 ./exp/manipulation/*.m \
+                                 ./geometry/*.m \
+                                 ./interp/*.m \
+                                 ./latlong/*.m \
+                                 ./meca/*.m \
+                                 ./mesh/*.m \
+                                 ./mesh/planet/*.m \
+                                 ./mesh/rifts/*.m \
+                                 ./miscellaneous/*.m \
+                                 ./os/*.m \
+                                 ./plot/*.m \
+                                 ./plot/colormaps/*.m \
+                                 ./string/*.m \
+                                 ./contrib/massbalance/*.m \
+                                 ./contrib/ecco/*.m \
+                                 ./contrib/hydrology/*.m \
+                                 ./contrib/hack/*.m \
+                                 ./contrib/gslib/*.m \
+                                 ./contrib/uci/*.m \
+                                 ./contrib/oasis/*.m \
+                                 ./contrib/bamg/*.m \
+                                 ./extrusion/*.m \
+                                 ./inversions/*.m \
+                                 ./io/*.m \
+                                 ./parameterization/*.m \
+                                 ./partition/*.m \
+                                 ./print/*.m \
+                                 ./regional/*.m \
+                                 ./solve/*.m \
+                                 ./solvers/*.m \
+                                 ./materials/*.m

issm/branches/trunk-jpl-damage/src/m/classes/autodiff.m

-              r12878
+              r13101
         properties (SetAccess=public)
                 isautodiff = false;
-                forward    = true;
-                reverse    = false;
         end
         methods
 …
                         fielddisplay(obj,'isautodiff','indicates if the automatic differentiation is activated');
-                        fielddisplay(obj,'forward','forward differentiation');
-                        fielddisplay(obj,'reverse','backward differentiation');
                 end % }}}
                 function marshall(obj,fid) % {{{
                         WriteData(fid,'object',obj,'fieldname','isautodiff','format','Boolean');
-                        WriteData(fid,'object',obj,'fieldname','forward','format','Boolean');
-                        WriteData(fid,'object',obj,'fieldname','reverse','format','Boolean');
                 end % }}}
         end

issm/branches/trunk-jpl-damage/src/m/classes/autodiff.py

-              r12168
+              r13101
 #module imports
 from fielddisplay import fielddisplay
+from EnumDefinitions import *
+from checkfield import *
+from WriteData import *
+class autodiff:
+class autodiff(object):
+        """
+        AUTODIFF class definition
+           Usage:
+              autodiff=autodiff();
+        """
         #properties
         def __init__(self):
                 # {{{ Properties
                 self.isautodiff = False
-                self.forward    = True
-                self.reverse    = False
                 #set defaults
 …
                 #}}}
         def __repr__(obj):
+        def __repr__(self):
                 # {{{ Display
                 string='   automatic differentiation parameters:'
+                string="%s\n%s"%(string,fielddisplay(obj,'isautodiff','indicates if the automatic differentiation is activated'))
+                string="%s\n%s"%(string,fielddisplay(obj,'forward','forward differentiation'))
+                string="%s\n%s"%(string,fielddisplay(obj,'reverse','backward differentiation'))
+                string="%s\n%s"%(string,fielddisplay(self,'isautodiff','indicates if the automatic differentiation is activated'))
                 return string
                 #}}}
         def setdefaultparameters(obj):
+        def setdefaultparameters(self):
                 # {{{setdefaultparameters
                 return obj
+                return self
         #}}}
+        def checkconsistency(self,md,solution,analyses):    # {{{
+                return md
+        # }}}
+        def marshall(self,fid):    # {{{
+                WriteData(fid,'object',self,'fieldname','isautodiff','format','Boolean')
+        # }}}

issm/branches/trunk-jpl-damage/src/m/classes/balancethickness.m

r12878	r13101
27	27	function md = checkconsistency(obj,md,solution,analyses) % {{{
28	28	%Early return
29		if solution~=BalancethicknessSolutionEnum, return; end
	29	if solution~=BalancethicknessSolutionEnum(), return; end
30	30
31	31	md = checkfield(md,'balancethickness.spcthickness','forcing',1);

issm/branches/trunk-jpl-damage/src/m/classes/balancethickness.py

-              r12168
+              r13101
 #module imports
 from fielddisplay import fielddisplay
+class balancethickness:
+from EnumDefinitions import *
+from checkfield import *
+from WriteData import *
+class balancethickness(object):
+        """
+        BALANCETHICKNESS class definition
+           Usage:
+              balancethickness=balancethickness();
+        """
         #properties
         def __init__(self):
                 # {{{ Properties
                 self.spcthickness = float('NaN')
                 self.thickening_rate           = float('NaN')
                 self.stabilization           = 0
+                self.spcthickness      = float('NaN')
+                self.thickening_rate   = float('NaN')
+                self.stabilization     = 0
                 #set defaults
 …
                 #}}}
         def __repr__(obj):
+        def __repr__(self):
                 # {{{ Display
                 string='   balance thickness solution parameters:'
                 string="%s\n\n%s"%(string,fielddisplay(obj,'spcthickness','thickness constraints (NaN means no constraint)'))
                 string="%s\n%s"%(string,fielddisplay(obj,'thickening_rate','ice thickening rate used in the mass conservation (dh/dt)'))
                 string="%s\n%s"%(string,fielddisplay(obj,'stabilization','0: None, 1: SU, 2: MacAyeal''s artificial diffusivity, 3:DG'))
+                string="%s\n\n%s"%(string,fielddisplay(self,'spcthickness','thickness constraints (NaN means no constraint)'))
+                string="%s\n%s"%(string,fielddisplay(self,'thickening_rate','ice thickening rate used in the mass conservation (dh/dt)'))
+                string="%s\n%s"%(string,fielddisplay(self,'stabilization',"0: None, 1: SU, 2: MacAyeal's artificial diffusivity, 3:DG"))
                 return string
                 #}}}
         def setdefaultparameters(obj):
+        def setdefaultparameters(self):
                 # {{{setdefaultparameters
                 #Type of stabilization used
                 obj.stabilization=1
+                self.stabilization=1
                 return obj
+                return self
         #}}}
+        def checkconsistency(self,md,solution,analyses):    # {{{
+                #Early return
+                if not solution==BalancethicknessSolutionEnum():
+                        return md
+                md = checkfield(md,'balancethickness.spcthickness','forcing',1)
+                md = checkfield(md,'balancethickness.thickening_rate','size',[md.mesh.numberofvertices],'NaN',1)
+                md = checkfield(md,'balancethickness.stabilization','size',[1],'values',[0,1,2,3])
+                return md
+        # }}}
+        def marshall(self,fid):    # {{{
+                WriteData(fid,'object',self,'fieldname','spcthickness','format','DoubleMat','mattype',1)
+                WriteData(fid,'object',self,'fieldname','thickening_rate','format','DoubleMat','mattype',1)
+                WriteData(fid,'object',self,'fieldname','stabilization','format','Integer')
+        # }}}

issm/branches/trunk-jpl-damage/src/m/classes/basalforcings.m

-              r12878
+              r13101
                 function md = checkconsistency(obj,md,solution,analyses) % {{{
                         if ismember(PrognosticAnalysisEnum,analyses) & ~(solution==TransientSolutionEnum & md.transient.isprognostic==0),
+                        if ismember(PrognosticAnalysisEnum(),analyses) & ~(solution==TransientSolutionEnum() & md.transient.isprognostic==0),
                                 md = checkfield(md,'basalforcings.melting_rate','NaN',1,'forcing',1);
                         end
                         if ismember(BalancethicknessAnalysisEnum,analyses),
+                        if ismember(BalancethicknessAnalysisEnum(),analyses),
                                 md = checkfield(md,'basalforcings.melting_rate','NaN',1,'size',[md.mesh.numberofvertices 1]);
                         end
                         if ismember(ThermalAnalysisEnum,analyses) & ~(solution==TransientSolutionEnum & md.transient.isthermal==0),
+                        if ismember(ThermalAnalysisEnum(),analyses) & ~(solution==TransientSolutionEnum() & md.transient.isthermal==0),
                                 md = checkfield(md,'basalforcings.melting_rate','NaN',1,'forcing',1);
                                 md = checkfield(md,'basalforcings.geothermalflux','NaN',1,'forcing',1,'>=',0);

issm/branches/trunk-jpl-damage/src/m/classes/basalforcings.py

-              r12168
+              r13101
 #module imports
 from fielddisplay import fielddisplay
+from EnumDefinitions import *
+from checkfield import *
+from WriteData import *
+class basalforcings:
+class basalforcings(object):
+        """
+        BASAL FORCINGS class definition
+           Usage:
+              basalforcings=basalforcings();
+        """
         #properties
         def __init__(self):
 …
                 #}}}
         def __repr__(obj):
+        def __repr__(self):
                 # {{{ Display
                 string="   basal forcings parameters:"
                 string="%s\n\n%s"%(string,fielddisplay(obj,"melting_rate","basal melting rate (positive if melting)"))
                 string="%s\n%s"%(string,fielddisplay(obj,"melting_rate_correction","additional melting applied when the grounding line retreats"))
                 string="%s\n%s"%(string,fielddisplay(obj,"geothermalflux","geothermal heat flux [W/m^2]"))
+                string="%s\n\n%s"%(string,fielddisplay(self,"melting_rate","basal melting rate (positive if melting)"))
+                string="%s\n%s"%(string,fielddisplay(self,"melting_rate_correction","additional melting applied when the grounding line retreats"))
+                string="%s\n%s"%(string,fielddisplay(self,"geothermalflux","geothermal heat flux [W/m^2]"))
                 return string
                 #}}}
         def setdefaultparameters(obj):
+        def setdefaultparameters(self):
                 # {{{setdefaultparameters
                 return obj
+                return self
         #}}}
+        def checkconsistency(self,md,solution,analyses):    # {{{
+                if PrognosticAnalysisEnum() in analyses and not (solution==TransientSolutionEnum() and not md.transient.isprognostic):
+                        md = checkfield(md,'basalforcings.melting_rate','NaN',1,'forcing',1)
+                if BalancethicknessAnalysisEnum() in analyses:
+                        md = checkfield(md,'basalforcings.melting_rate','NaN',1,'size',[md.mesh.numberofvertices])
+                if ThermalAnalysisEnum() in analyses and not (solution==TransientSolutionEnum() and not md.transient.isthermal):
+                        md = checkfield(md,'basalforcings.melting_rate','NaN',1,'forcing',1)
+                        md = checkfield(md,'basalforcings.geothermalflux','NaN',1,'forcing',1,'>=',0)
+                return md
+        # }}}
+        def marshall(self,fid):    # {{{
+                WriteData(fid,'object',self,'fieldname','melting_rate','format','DoubleMat','mattype',1)
+                WriteData(fid,'object',self,'fieldname','melting_rate_correction','format','DoubleMat','mattype',1)
+                WriteData(fid,'object',self,'fieldname','geothermalflux','format','DoubleMat','mattype',1)
+        # }}}

issm/branches/trunk-jpl-damage/src/m/classes/clusters/generic.m

-              r12878
+              r13101
                                         %Add --gen-suppressions=all to get suppression lines
                                         fprintf(fid,'LD_PRELOAD=%s \\\n',cluster.valgrindlib);
+                                        fprintf(fid,'mpiexec -np %i %s --leak-check=full --suppressions=%s %s/issm.exe %s %s %s 2> %s.errlog >%s.outlog ',...
+                                        if ismac,
+                                                fprintf(fid,'mpiexec -np %i %s --leak-check=full --dsymutil=yes --suppressions=%s %s/issm.exe %s %s %s 2> %s.errlog >%s.outlog ',...
                                                 cluster.np,cluster.valgrind,cluster.valgrindsup,cluster.codepath,EnumToString(solution),cluster.executionpath,modelname,modelname,modelname);
+                                        else
+                                                fprintf(fid,'mpiexec -np %i %s --leak-check=full --suppressions=%s %s/issm.exe %s %s %s 2> %s.errlog >%s.outlog ',...
+                                                cluster.np,cluster.valgrind,cluster.valgrindsup,cluster.codepath,EnumToString(solution),cluster.executionpath,modelname,modelname,modelname);
+                                        end
                                 end
                                 if ~io_gather, %concatenate the output files:

issm/branches/trunk-jpl-damage/src/m/classes/clusters/generic.py

-              r12946
+              r13101
 import platform
 import subprocess
+from EnumToString import EnumToString
 from issmdir import *
 from pairoptions import *
 …
                 #write queuing script
                 if not 'Windows' in platform.system():
+                if 'Windows' not in platform.system():
                         fid=open(modelname+'.queue','w')
 …
                         if not isvalgrind:
                                 if self.interactive:
                                         fid.write('mpiexec -np %i %s/issm.exe %s %s %s ' % (self.np,self.codepath,EnumToString(solution),self.executionpath,modelname))
+                                        fid.write('mpiexec -np %i %s/issm.exe %s %s %s ' % (self.np,self.codepath,EnumToString(solution)[0],self.executionpath,modelname))
                                 else:
                                         fid.write('mpiexec -np %i %s/issm.exe %s %s %s 2> %s.errlog >%s.outlog ' % (self.np,self.codepath,EnumToString(solution),self.executionpath,modelname,modelname,modelname))
+                                        fid.write('mpiexec -np %i %s/issm.exe %s %s %s 2> %s.errlog >%s.outlog ' % (self.np,self.codepath,EnumToString(solution)[0],self.executionpath,modelname,modelname,modelname))
                         elif isgprof:
                                 fid.write('\n gprof %s/issm.exe gmon.out > %s.performance' % (self.codepath,modelname))
 …
                                 fid.write('LD_PRELOAD=%s \\\n' % self.valgrindlib)
                                 fid.write('mpiexec -np %i %s --leak-check=full --suppressions=%s %s/issm.exe %s %s %s 2> %s.errlog >%s.outlog ' % \
                                         (self.np,self.valgrind,self.valgrindsup,self.codepath,EnumToString(solution),self.executionpath,modelname,modelname,modelname))
+                                        (self.np,self.valgrind,self.valgrindsup,self.codepath,EnumToString(solution)[0],self.executionpath,modelname,modelname,modelname))
                         if not io_gather:    #concatenate the output files:
                                 fid.write('\ncat %s.outbin.* > %s.outbin' % (modelname,modelname))
 …
                         fid.write('@echo off\n')
                         if self.interactive:
                                 fid.write('"%s/issm.exe" %s "%s" %s ' % (self.codepath,EnumToString(solution),self.executionpath,modelname))
+                                fid.write('"%s/issm.exe" %s "%s" %s ' % (self.codepath,EnumToString(solution)[0],self.executionpath,modelname))
                         else:
                                 fid.write('"%s/issm.exe" %s "%s" %s 2> %s.errlog >%s.outlog' % \
                                         (self.codepath,EnumToString(solution),self.executionpath,modelname,modelname,modelname))
+                                        (self.codepath,EnumToString(solution)[0],self.executionpath,modelname,modelname,modelname))
                         fid.close()
 …
                 #write queuing script
                 if not 'Windows' in platform.system():
+                if 'Windows' not in platform.system():
                         fid=open(modelname+'.queue','w')
 …
                         fid.write('@echo off\n')
                         if self.interactive:
                                 fid.write('"%s/issm.exe" %s "%s" %s ' % (self.codepath,EnumToString(solution),self.executionpath,modelname))
+                                fid.write('"%s/issm.exe" %s "%s" %s ' % (self.codepath,EnumToString(solution)[0],self.executionpath,modelname))
                         else:
                                 fid.write('"%s/issm.exe" %s "%s" %s 2> %s.errlog >%s.outlog' % \
                                         (self.codepath,EnumToString(solution),self.executionpath,modelname,modelname,modelname))
+                                        (self.codepath,EnumToString(solution)[0],self.executionpath,modelname,modelname,modelname))
                         fid.close()

issm/branches/trunk-jpl-damage/src/m/classes/constants.py

-              r12168
+              r13101
 #module imports
 from fielddisplay import fielddisplay
+from EnumDefinitions import *
+from checkfield import *
+from WriteData import *
+class constants:
+class constants(object):
+        """
+        CONSTANTS class definition
+           Usage:
+              constants=constants();
+        """
         #properties
         def __init__(self):
 …
                 #}}}
         def __repr__(obj):
+        def __repr__(self):
                 # {{{ Display
                 string="   constants parameters:"
                 string="%s\n\n%s"%(string,fielddisplay(obj,"g","gravitational acceleration"))
                 string="%s\n%s"%(string,fielddisplay(obj,"yts","number of seconds in a year"))
                 string="%s\n%s"%(string,fielddisplay(obj,"referencetemperature","reference temperature used in the enthalpy model"))
+                string="%s\n\n%s"%(string,fielddisplay(self,"g","gravitational acceleration"))
+                string="%s\n%s"%(string,fielddisplay(self,"yts","number of seconds in a year"))
+                string="%s\n%s"%(string,fielddisplay(self,"referencetemperature","reference temperature used in the enthalpy model"))
 …
                 #}}}
         def setdefaultparameters(obj):
+        def setdefaultparameters(self):
                 # {{{setdefaultparameters
                 #acceleration due to gravity (m/s^2)
                 obj.g=9.81
+                self.g=9.81
                 #converstion from year to seconds
                 obj.yts=365*24*3600
+                self.yts=365*24*3600
                 #the reference temperature for enthalpy model (cf Aschwanden)
                 obj.referencetemperature=223.15
+                self.referencetemperature=223.15
                 return obj
+                return self
         #}}}
+        def checkconsistency(self,md,solution,analyses):    # {{{
+                md = checkfield(md,'constants.g','>',0,'size',[1])
+                md = checkfield(md,'constants.yts','>',0,'size',[1])
+                md = checkfield(md,'constants.referencetemperature','size',[1])
+                return md
+        # }}}
+        def marshall(self,fid):    # {{{
+                WriteData(fid,'object',self,'fieldname','g','format','Double')
+                WriteData(fid,'object',self,'fieldname','yts','format','Double')
+                WriteData(fid,'object',self,'fieldname','referencetemperature','format','Double')
+        # }}}

issm/branches/trunk-jpl-damage/src/m/classes/debug.py

-              r12168
+              r13101
 #module imports
 from fielddisplay import fielddisplay
+from WriteData import *
+class debug:
+class debug(object):
+        """
+        DEBUG class definition
+           Usage:
+              debug=debug();
+        """
         #properties
         def __init__(self):
                 # {{{ Properties
+                self.valgrind=False
+                self.gprof   = False
+                self.valgrind  = False
+                self.gprof     = False
+                self.profiling = False
                 #set defaults
 …
                 #}}}
         def __repr__(obj):
+        def __repr__(self):
                 # {{{ Display
                 string="   debug parameters:"
+                string="%s\n\n%s"%(string,fielddisplay(obj,"valgrind","use Valgrind to debug (0 or 1)"))
+                string="%s\n%s"%(string,fielddisplay(obj,"gprof","use gnu-profiler to find out where the time is spent"))
+                string="%s\n\n%s"%(string,fielddisplay(self,"valgrind","use Valgrind to debug (0 or 1)"))
+                string="%s\n%s"%(string,fielddisplay(self,"gprof","use gnu-profiler to find out where the time is spent"))
+                string="%s\n%s"%(string,fielddisplay(self,'profiling','enables profiling (memory, flops, time)'))
                 return string
                 #}}}
         def setdefaultparameters(obj):
+        def setdefaultparameters(self):
                 # {{{setdefaultparameters
                 return obj
+                return self
         #}}}
+        def marshall(self,fid):    # {{{
+                WriteData(fid,'object',self,'fieldname','profiling','format','Boolean')
+        # }}}

issm/branches/trunk-jpl-damage/src/m/classes/diagnostic.m

-              r12946
+              r13101
                         %Early return
                         if ~ismember(DiagnosticHorizAnalysisEnum,analyses), return; end
                         %if ~ismember(DiagnosticHorizAnalysisEnum,analyses) |  (solution==TransientSolutionEnum & md.transient.isdiagnostic==0), return; end
+                        if ~ismember(DiagnosticHorizAnalysisEnum(),analyses), return; end
+                        %if ~ismember(DiagnosticHorizAnalysisEnum(),analyses) |  (solution==TransientSolutionEnum() & md.transient.isdiagnostic==0), return; end
                         md = checkfield(md,'diagnostic.spcvx','forcing',1);
 …
                         md = checkfield(md,'diagnostic.reltol','size',[1 1]);
                         md = checkfield(md,'diagnostic.abstol','size',[1 1]);
                         md = checkfield(md,'diagnostic.isnewton','numel',1,'values',[0 1]);
+                        md = checkfield(md,'diagnostic.isnewton','numel',[1],'values',[0 1]);
                         md = checkfield(md,'diagnostic.stokesreconditioning','size',[1 1],'NaN',1);
                         md = checkfield(md,'diagnostic.viscosity_overshoot','size',[1 1],'NaN',1);
 …
                         if any(sum(isnan(md.diagnostic.referential),2)==0),
                                 pos=find(sum(isnan(md.diagnostic.referential),2)==0);
                                 if any(abs(dot(md.diagnostic.referential(pos,1:3)',md.diagnostic.referential(pos,4:6)'))>eps),
                                         md = checkmessage(md,['Vectors in diagnostic.referential (colums 1 to 3 and 4 to 6) must be orthogonal']);
+                                if any(abs(dot(md.diagnostic.referential(pos,1:3),md.diagnostic.referential(pos,4:6),2))>eps),
+                                        md = checkmessage(md,['Vectors in diagnostic.referential (columns 1 to 3 and 4 to 6) must be orthogonal']);
                                 end
                         end
 …
                         %marshall ice front
                         data=obj.icefront;
                         pos=find(data(:,end)==0); data(pos,end)=AirEnum;
                         pos=find(data(:,end)==1); data(pos,end)=WaterEnum;
                         pos=find(data(:,end)==2); data(pos,end)=IceEnum;
                         WriteData(fid,'data',data,'enum',DiagnosticIcefrontEnum,'format','DoubleMat','mattype',3);
+                        pos=find(data(:,end)==0); data(pos,end)=AirEnum();
+                        pos=find(data(:,end)==1); data(pos,end)=WaterEnum();
+                        pos=find(data(:,end)==2); data(pos,end)=IceEnum();
+                        WriteData(fid,'data',data,'enum',DiagnosticIcefrontEnum(),'format','DoubleMat','mattype',3);
                 end % }}}
         end

issm/branches/trunk-jpl-damage/src/m/classes/diagnostic.py

-              r12168
+              r13101
 #module imports
+import numpy
+import sys
 from fielddisplay import fielddisplay
+from EnumDefinitions import *
+from checkfield import *
+from WriteData import *
+class diagnostic:
+class diagnostic(object):
+        """
+        DIAGNOSTIC class definition
+           Usage:
+              diagnostic=diagnostic();
+        """
         #properties
         def __init__(self):
 …
                 #}}}
         def __repr__(obj):
+        def __repr__(self):
                 # {{{ Display
                 string='\n   Diagnostic solution parameters:'
                 string="%s\n\n%s"%(string,'      Convergence criteria:')
                 string="%s\n%s"%(string,fielddisplay(obj,'restol','mechanical equilibrium residual convergence criterion'))
                 string="%s\n%s"%(string,fielddisplay(obj,'reltol','velocity relative convergence criterion, NaN -> not applied'))
                 string="%s\n%s"%(string,fielddisplay(obj,'abstol','velocity absolute convergence criterion, NaN -> not applied'))
                 string="%s\n%s"%(string,fielddisplay(obj,'isnewton','Apply Newton''s method instead of a Picard fixed point method'))
                 string="%s\n%s"%(string,fielddisplay(obj,'maxiter','maximum number of nonlinear iterations'))
                 string="%s\n%s"%(string,fielddisplay(obj,'viscosity_overshoot','over-shooting constant new=new+C*(new-old)'))
+                string="%s\n%s"%(string,fielddisplay(self,'restol','mechanical equilibrium residual convergence criterion'))
+                string="%s\n%s"%(string,fielddisplay(self,'reltol','velocity relative convergence criterion, NaN -> not applied'))
+                string="%s\n%s"%(string,fielddisplay(self,'abstol','velocity absolute convergence criterion, NaN -> not applied'))
+                string="%s\n%s"%(string,fielddisplay(self,'isnewton',"Apply Newton's method instead of a Picard fixed point method"))
+                string="%s\n%s"%(string,fielddisplay(self,'maxiter','maximum number of nonlinear iterations'))
+                string="%s\n%s"%(string,fielddisplay(self,'viscosity_overshoot','over-shooting constant new=new+C*(new-old)'))
                 string="%s\n%s"%(string,'      boundary conditions:')
                 string="%s\n%s"%(string,fielddisplay(obj,'spcvx','x-axis velocity constraint (NaN means no constraint)'))
                 string="%s\n%s"%(string,fielddisplay(obj,'spcvy','y-axis velocity constraint (NaN means no constraint)'))
                 string="%s\n%s"%(string,fielddisplay(obj,'spcvz','z-axis velocity constraint (NaN means no constraint)'))
                 string="%s\n%s"%(string,fielddisplay(obj,'icefront','segments on ice front list (last column 0-> Air, 1-> Water, 2->Ice'))
+                string="%s\n%s"%(string,fielddisplay(self,'spcvx','x-axis velocity constraint (NaN means no constraint)'))
+                string="%s\n%s"%(string,fielddisplay(self,'spcvy','y-axis velocity constraint (NaN means no constraint)'))
+                string="%s\n%s"%(string,fielddisplay(self,'spcvz','z-axis velocity constraint (NaN means no constraint)'))
+                string="%s\n%s"%(string,fielddisplay(self,'icefront','segments on ice front list (last column 0-> Air, 1-> Water, 2->Ice'))
                 string="%s\n%s"%(string,'      Rift options:')
                 string="%s\n%s"%(string,fielddisplay(obj,'rift_penalty_threshold','threshold for instability of mechanical constraints'))
                 string="%s\n%s"%(string,fielddisplay(obj,'rift_penalty_lock','number of iterations before rift penalties are locked'))
+                string="%s\n%s"%(string,fielddisplay(self,'rift_penalty_threshold','threshold for instability of mechanical constraints'))
+                string="%s\n%s"%(string,fielddisplay(self,'rift_penalty_lock','number of iterations before rift penalties are locked'))
                 string="%s\n%s"%(string,'      Penalty options:')
                 string="%s\n%s"%(string,fielddisplay(obj,'penalty_factor','offset used by penalties: penalty = Kmax*10^offset'))
                 string="%s\n%s"%(string,fielddisplay(obj,'vertex_pairing','pairs of vertices that are penalized'))
+                string="%s\n%s"%(string,fielddisplay(self,'penalty_factor','offset used by penalties: penalty = Kmax*10^offset'))
+                string="%s\n%s"%(string,fielddisplay(self,'vertex_pairing','pairs of vertices that are penalized'))
                 string="%s\n%s"%(string,'      Other:')
                 string="%s\n%s"%(string,fielddisplay(obj,'shelf_dampening','use dampening for floating ice ? Only for Stokes model'))
                 string="%s\n%s"%(string,fielddisplay(obj,'stokesreconditioning','multiplier for incompressibility equation. Only for Stokes model'))
                 string="%s\n%s"%(string,fielddisplay(obj,'referential','local referential'))
                 string="%s\n%s"%(string,fielddisplay(obj,'requested_outputs','additional outputs requested'))
+                string="%s\n%s"%(string,fielddisplay(self,'shelf_dampening','use dampening for floating ice ? Only for Stokes model'))
+                string="%s\n%s"%(string,fielddisplay(self,'stokesreconditioning','multiplier for incompressibility equation. Only for Stokes model'))
+                string="%s\n%s"%(string,fielddisplay(self,'referential','local referential'))
+                string="%s\n%s"%(string,fielddisplay(self,'requested_outputs','additional outputs requested'))
                 return string
                 #}}}
         def setdefaultparameters(obj):
+        def setdefaultparameters(self):
                 # {{{setdefaultparameters
                 #maximum of non-linear iterations.
                 obj.maxiter=100
+                self.maxiter=100
                 #Convergence criterion: absolute, relative and residual
                 obj.restol=10**-4;
                 obj.reltol=0.01
                 obj.abstol=10
+                self.restol=10**-4
+                self.reltol=0.01
+                self.abstol=10
                 obj.stokesreconditioning=10**13
                 obj.shelf_dampening=0
+                self.stokesreconditioning=10**13
+                self.shelf_dampening=0
                 #Penalty factor applied kappa=max(stiffness matrix)*10^penalty_factor
                 obj.penalty_factor=3
+                self.penalty_factor=3
                 #coefficient to update the viscosity between each iteration of
                 #a diagnostic according to the following formula
                 #viscosity(n)=viscosity(n)+viscosity_overshoot(viscosity(n)-viscosity(n-1))
                 obj.viscosity_overshoot=0
+                self.viscosity_overshoot=0
                 #Stop the iterations of rift if below a threshold
                 obj.rift_penalty_threshold=0
+                self.rift_penalty_threshold=0
                 #in some solutions, it might be needed to stop a run when only
                 #a few constraints remain unstable. For thermal computation, this
                 #parameter is often used.
                 obj.rift_penalty_lock=10
+                self.rift_penalty_lock=10
                 return obj
+                return self
         #}}}
+        def checkconsistency(self,md,solution,analyses):    # {{{
+                #Early return
+                if DiagnosticHorizAnalysisEnum() not in analyses:
+                        return md
+                #if (DiagnosticHorizAnalysisEnum() not in analyses) | (solution==TransientSolutionEnum() and not md.transient.isdiagnostic):
+                #       return md
+                md = checkfield(md,'diagnostic.spcvx','forcing',1)
+                md = checkfield(md,'diagnostic.spcvy','forcing',1)
+                if md.mesh.dimension==3:
+                        md = checkfield(md,'diagnostic.spcvz','forcing',1)
+                md = checkfield(md,'diagnostic.restol','size',[1],'>',0)
+                md = checkfield(md,'diagnostic.reltol','size',[1])
+                md = checkfield(md,'diagnostic.abstol','size',[1])
+                md = checkfield(md,'diagnostic.isnewton','numel',[1],'values',[0,1])
+                md = checkfield(md,'diagnostic.stokesreconditioning','size',[1],'NaN',1)
+                md = checkfield(md,'diagnostic.viscosity_overshoot','size',[1],'NaN',1)
+                if md.mesh.dimension==2:
+                        md = checkfield(md,'diagnostic.icefront','size',[float('NaN'),4],'NaN',1)
+                else:
+                        md = checkfield(md,'diagnostic.icefront','size',[float('NaN'),6],'NaN',1)
+                md = checkfield(md,'diagnostic.icefront[:,-1]','values',[0,1,2])
+                md = checkfield(md,'diagnostic.maxiter','size',[1],'>=',1)
+                md = checkfield(md,'diagnostic.referential','size',[md.mesh.numberofvertices,6])
+                if not md.diagnostic.requested_outputs:
+                        md = checkfield(md,'diagnostic.requested_outputs','size',[float('NaN'),1])
+                #singular solution
+#               if ~any((~isnan(md.diagnostic.spcvx)+~isnan(md.diagnostic.spcvy))==2),
+                if not numpy.any(numpy.logical_and(numpy.logical_not(numpy.isnan(md.diagnostic.spcvx)),numpy.logical_not(numpy.isnan(md.diagnostic.spcvy)))):
+                        md.checkmessage("model is not well posed (singular). You need at least one node with fixed velocity!")
+                #CHECK THAT EACH LINES CONTAINS ONLY NAN VALUES OR NO NAN VALUES
+#               if any(sum(isnan(md.diagnostic.referential),2)~=0 & sum(isnan(md.diagnostic.referential),2)~=6),
+                if numpy.any(numpy.logical_and(numpy.sum(numpy.isnan(md.diagnostic.referential),axis=1)!=0,numpy.sum(numpy.isnan(md.diagnostic.referential),axis=1)!=6)):
+                        md.checkmessage("Each line of diagnostic.referential should contain either only NaN values or no NaN values")
+                #CHECK THAT THE TWO VECTORS PROVIDED ARE ORTHOGONAL
+#               if any(sum(isnan(md.diagnostic.referential),2)==0),
+                if numpy.any(numpy.sum(numpy.isnan(md.diagnostic.referential),axis=1)==0):
+                        pos=[i for i,item in enumerate(numpy.sum(numpy.isnan(md.diagnostic.referential),axis=1)) if item==0]
+#                       numpy.inner (and numpy.dot) calculate all the dot product permutations, resulting in a full matrix multiply
+#                       if numpy.any(numpy.abs(numpy.inner(md.diagnostic.referential[pos,0:2],md.diagnostic.referential[pos,3:5]).diagonal())>sys.float_info.epsilon):
+#                               md.checkmessage("Vectors in diagnostic.referential (columns 1 to 3 and 4 to 6) must be orthogonal")
+                        for item in md.diagnostic.referential[pos,:]:
+                                if numpy.abs(numpy.inner(item[0:2],item[3:5]))>sys.float_info.epsilon:
+                                        md.checkmessage("Vectors in diagnostic.referential (columns 1 to 3 and 4 to 6) must be orthogonal")
+                #CHECK THAT NO rotation specified for FS Grounded ice at base
+#               if md.mesh.dimension==3 & md.flowequation.isstokes,
+                if md.mesh.dimension==3 and md.flowequation.isstokes:
+                        pos=numpy.nonzero(numpy.logical_and(md.mask.vertexongroundedice,md.mesh.vertexonbed))
+                        if numpy.any(numpy.logical_not(numpy.isnan(md.diagnostic.referential[pos,:]))):
+                                md.checkmessage("no referential should be specified for basal vertices of grounded ice")
+                return md
+        # }}}
+        def marshall(self,fid):    # {{{
+                WriteData(fid,'object',self,'fieldname','spcvx','format','DoubleMat','mattype',1)
+                WriteData(fid,'object',self,'fieldname','spcvy','format','DoubleMat','mattype',1)
+                WriteData(fid,'object',self,'fieldname','spcvz','format','DoubleMat','mattype',1)
+                WriteData(fid,'object',self,'fieldname','restol','format','Double')
+                WriteData(fid,'object',self,'fieldname','reltol','format','Double')
+                WriteData(fid,'object',self,'fieldname','abstol','format','Double')
+                WriteData(fid,'object',self,'fieldname','isnewton','format','Boolean')
+                WriteData(fid,'object',self,'fieldname','stokesreconditioning','format','Double')
+                WriteData(fid,'object',self,'fieldname','viscosity_overshoot','format','Double')
+                WriteData(fid,'object',self,'fieldname','maxiter','format','Integer')
+                WriteData(fid,'object',self,'fieldname','shelf_dampening','format','Integer')
+                WriteData(fid,'object',self,'fieldname','vertex_pairing','format','DoubleMat','mattype',3)
+                WriteData(fid,'object',self,'fieldname','penalty_factor','format','Double')
+                WriteData(fid,'object',self,'fieldname','rift_penalty_lock','format','Integer')
+                WriteData(fid,'object',self,'fieldname','rift_penalty_threshold','format','Integer')
+                WriteData(fid,'object',self,'fieldname','referential','format','DoubleMat','mattype',1)
+                WriteData(fid,'object',self,'fieldname','requested_outputs','format','DoubleMat','mattype',3)
+                #marshall ice front
+                data=self.icefront
+                data[[i for i,item in enumerate(data[:,-1]) if item==0],-1]=AirEnum()
+                data[[i for i,item in enumerate(data[:,-1]) if item==1],-1]=WaterEnum()
+                data[[i for i,item in enumerate(data[:,-1]) if item==2],-1]=IceEnum()
+                WriteData(fid,'data',data,'enum',DiagnosticIcefrontEnum(),'format','DoubleMat','mattype',3)
+        # }}}

issm/branches/trunk-jpl-damage/src/m/classes/flaim.m

r12878	r13101
35	35
36	36	%Early return
37		if solution~=FlaimSolutionEnum, return; end
	37	if solution~=FlaimSolutionEnum(), return; end
38	38
39	39	md = checkfield(md,'flaim.tracks','file',1);

issm/branches/trunk-jpl-damage/src/m/classes/flaim.py

-              r12168
+              r13101
 #module imports
+import numpy
 from fielddisplay import fielddisplay
+from EnumDefinitions import *
+from checkfield import *
+from WriteData import *
+class flaim:
+class flaim(object):
+        """
+        FLAIM class definition
+           Usage:
+              flaim=flaim();
+        """
         #properties
         def __init__(self):
 …
                 self.opt_niter          = 30000
                 #}}}
         def __repr__(obj):
+        def __repr__(self):
                 # {{{ Displa
                 string='   FLAIM - Flight Line Adaptation using Ice sheet Modeling:'
                 string="%s\n\n%s"%(string,'      Input:')
                 string="%s\n%s"%(string,fielddisplay(obj,'targets'            ,'name of kml output targets file '))
                 string="%s\n%s"%(string,fielddisplay(obj,'tracks'             ,'name of kml input tracks file '))
                 string="%s\n%s"%(string,fielddisplay(obj,'flightreqs'         ,'structure of kml flight requirements (not used yet)'))
                 string="%s\n%s"%(string,fielddisplay(obj,'criterion'          ,'element or nodal criterion for flight path evaluation (metric)'))
+                string="%s\n%s"%(string,fielddisplay(self,'targets'            ,'name of kml output targets file '))
+                string="%s\n%s"%(string,fielddisplay(self,'tracks'             ,'name of kml input tracks file '))
+                string="%s\n%s"%(string,fielddisplay(self,'flightreqs'         ,'structure of kml flight requirements (not used yet)'))
+                string="%s\n%s"%(string,fielddisplay(self,'criterion'          ,'element or nodal criterion for flight path evaluation (metric)'))
                 string="%s\n\n%s"%(string,'      Arguments:')
                 string="%s\n%s"%(string,fielddisplay(obj,'gridsatequator'     ,'number of grids at equator (determines resolution)'))
                 string="%s\n%s"%(string,fielddisplay(obj,'usevalueordering'   ,'flag to consider target values for flight path evaluation'))
                 string="%s\n%s"%(string,fielddisplay(obj,'split_antimeridian' ,'flag to split polygons on the antimeridian'))
+                string="%s\n%s"%(string,fielddisplay(self,'gridsatequator'     ,'number of grids at equator (determines resolution)'))
+                string="%s\n%s"%(string,fielddisplay(self,'usevalueordering'   ,'flag to consider target values for flight path evaluation'))
+                string="%s\n%s"%(string,fielddisplay(self,'split_antimeridian' ,'flag to split polygons on the antimeridian'))
                 string="%s\n\n%s"%(string,'      Optimization:')
                 string="%s\n%s"%(string,fielddisplay(obj,'path_optimize'     ,'optimize? (default false)'))
                 string="%s\n%s"%(string,fielddisplay(obj,'opt_ndir'     ,['number of directions to test when moving a point.  If this value = 1, a random direction is tested.',\
+                string="%s\n%s"%(string,fielddisplay(self,'path_optimize'     ,'optimize? (default false)'))
+                string="%s\n%s"%(string,fielddisplay(self,'opt_ndir'     ,['number of directions to test when moving a point.  If this value = 1, a random direction is tested.',\
                                                                                   'A value > 1 results in directions equally spaced from [0, 2*PI] being tested.',\
                                                                                   'For example, 4 would result in directions [0, PI/2, PI, 3PI/2].']))
                 string="%s\n%s"%(string,fielddisplay(obj,'opt_dist'     ,'specifies the distance in km (default 25) to move a randomly selected path point on each iteration'))
                 string="%s\n%s"%(string,fielddisplay(obj,'opt_niter'     ,['number of iterations (default 30,000) to run for flightplan optimization',\
+                string="%s\n%s"%(string,fielddisplay(self,'opt_dist'     ,'specifies the distance in km (default 25) to move a randomly selected path point on each iteration'))
+                string="%s\n%s"%(string,fielddisplay(self,'opt_niter'     ,['number of iterations (default 30,000) to run for flightplan optimization',\
                                                                                    'i.e. the number of times to randomly select a point and move it.']))
                 string="%s\n\n%s"%(string,'      Output:')
                 string="%s\n%s"%(string,fielddisplay(obj,'solution'           ,'name of kml solution file'))
                 string="%s\n%s"%(string,fielddisplay(obj,'quality'            ,'quality of kml solution'))
+                string="%s\n%s"%(string,fielddisplay(self,'solution'           ,'name of kml solution file'))
+                string="%s\n%s"%(string,fielddisplay(self,'quality'            ,'quality of kml solution'))
                 return string
                 #}}}
+        def checkconsistency(self,md,solution,analyses):    # {{{
+                #Early return
+                if not solution==FlaimSolutionEnum():
+                        return md
+                md = checkfield(md,'flaim.tracks','file',1)
+                if numpy.any(numpy.isnan(md.flaim.criterion)) or not md.flaim.criterion:
+                        md = checkfield(md,'flaim.targets','file',1)
+                else:
+                        md = checkfield(md,'flaim.criterion','numel',[md.mesh.numberofvertices,md.mesh.numberofelements])
+                return md
+        # }}}

issm/branches/trunk-jpl-damage/src/m/classes/flowequation.m

-              r12878
+              r13101
                 ismacayealpattyn     = 0;
                 ishutter             = 0;
+                isl1l2               = 0;
                 isstokes             = 0;
                 vertex_equation      = NaN;
 …
                 function md = checkconsistency(obj,md,solution,analyses) % {{{
                         if ismember(DiagnosticHorizAnalysisEnum,analyses),
+                        if ismember(DiagnosticHorizAnalysisEnum(),analyses),
+                                md = checkfield(md,'flowequation.ismacayealpattyn','numel',1,'values',[0 1]);
+                                md = checkfield(md,'flowequation.ishutter','numel',1,'values',[0 1]);
+                                md = checkfield(md,'flowequation.isstokes','numel',1,'values',[0 1]);
+                                md = checkfield(md,'flowequation.ismacayealpattyn','numel',[1],'values',[0 1]);
+                                md = checkfield(md,'flowequation.ishutter','numel',[1],'values',[0 1]);
+                                md = checkfield(md,'flowequation.isl1l2','numel',[1],'values',[0 1]);
+                                md = checkfield(md,'flowequation.isstokes','numel',[1],'values',[0 1]);
                                 md = checkfield(md,'flowequation.bordermacayeal','size',[md.mesh.numberofvertices 1],'values',[0 1]);
                                 md = checkfield(md,'flowequation.borderpattyn','size',[md.mesh.numberofvertices 1],'values',[0 1]);
 …
                                         md = checkfield(md,'flowequation.element_equation','size',[md.mesh.numberofelements 1],'values',[1:2]);
                                 else
                                         md = checkfield(md,'flowequation.vertex_equation','size',[md.mesh.numberofvertices 1],'values',[0:7]);
                                         md = checkfield(md,'flowequation.element_equation','size',[md.mesh.numberofelements 1],'values',[0:7]);
+                                        md = checkfield(md,'flowequation.vertex_equation','size',[md.mesh.numberofvertices 1],'values',[0:8]);
+                                        md = checkfield(md,'flowequation.element_equation','size',[md.mesh.numberofelements 1],'values',[0:8]);
                                 end
                                 if (md.flowequation.ismacayealpattyn==0 && md.flowequation.ishutter==0 && md.flowequation.isstokes==0),
+                                if ~(obj.ismacayealpattyn || obj.ishutter || obj.isstokes || obj.isl1l2),
                                         md = checkmessage(md,['no element types set for this model. At least one of ismacayealpattyn, ishutter or isstokes need to be =1']);
                                 end
                         end
                         if ismember(DiagnosticHutterAnalysisEnum,analyses),
                                 if any(md.flowequation.element_equation==1),
                                         if(md.flowequation.element_equation & md.mask.elementonfloatingice),
+                        if ismember(DiagnosticHutterAnalysisEnum(),analyses),
+                                if any(obj.element_equation==1),
+                                        if(obj.element_equation & md.mask.elementonfloatingice),
                                                 disp(sprintf('\n !!! Warning: Hutter''s model is not consistent on ice shelves !!!\n'));
                                         end
 …
                         fielddisplay(obj,'ismacayealpattyn','is the macayeal or pattyn approximation used ?');
                         fielddisplay(obj,'ishutter','is the shallow ice approximation used ?');
+                        fielddisplay(obj,'isl1l2','is the l1l2 approximation used ?');
                         fielddisplay(obj,'isstokes','are the Full-Stokes equations used ?');
                         fielddisplay(obj,'vertex_equation','flow equation for each vertex');
 …
                         WriteData(fid,'object',obj,'fieldname','ismacayealpattyn','format','Boolean');
                         WriteData(fid,'object',obj,'fieldname','ishutter','format','Boolean');
+                        WriteData(fid,'object',obj,'fieldname','isl1l2','format','Boolean');
                         WriteData(fid,'object',obj,'fieldname','isstokes','format','Boolean');
                         WriteData(fid,'object',obj,'fieldname','bordermacayeal','format','DoubleMat','mattype',1);
 …
                         %convert approximations to enums
                         data=obj.vertex_equation;
+                        pos=find(data==0); data(pos,end)=NoneApproximationEnum;
+                        pos=find(data==1); data(pos,end)=HutterApproximationEnum;
+                        pos=find(data==2); data(pos,end)=MacAyealApproximationEnum;
+                        pos=find(data==3); data(pos,end)=PattynApproximationEnum;
+                        pos=find(data==4); data(pos,end)=StokesApproximationEnum;
+                        pos=find(data==5); data(pos,end)=MacAyealPattynApproximationEnum;
+                        pos=find(data==6); data(pos,end)=MacAyealStokesApproximationEnum;
+                        pos=find(data==7); data(pos,end)=PattynStokesApproximationEnum;
+                        WriteData(fid,'data',data,'enum',FlowequationVertexEquationEnum,'format','DoubleMat','mattype',1);
+                        pos=find(data==0); data(pos,end)=NoneApproximationEnum();
+                        pos=find(data==1); data(pos,end)=HutterApproximationEnum();
+                        pos=find(data==2); data(pos,end)=MacAyealApproximationEnum();
+                        pos=find(data==3); data(pos,end)=PattynApproximationEnum();
+                        pos=find(data==4); data(pos,end)=StokesApproximationEnum();
+                        pos=find(data==5); data(pos,end)=MacAyealPattynApproximationEnum();
+                        pos=find(data==6); data(pos,end)=MacAyealStokesApproximationEnum();
+                        pos=find(data==7); data(pos,end)=PattynStokesApproximationEnum();
+                        pos=find(data==8); data(pos,end)=L1L2ApproximationEnum();
+                        WriteData(fid,'data',data,'enum',FlowequationVertexEquationEnum(),'format','DoubleMat','mattype',1);
                         data=obj.element_equation;
+                        pos=find(data==0); data(pos,end)=NoneApproximationEnum;
+                        pos=find(data==1); data(pos,end)=HutterApproximationEnum;
+                        pos=find(data==2); data(pos,end)=MacAyealApproximationEnum;
+                        pos=find(data==3); data(pos,end)=PattynApproximationEnum;
+                        pos=find(data==4); data(pos,end)=StokesApproximationEnum;
+                        pos=find(data==5); data(pos,end)=MacAyealPattynApproximationEnum;
+                        pos=find(data==6); data(pos,end)=MacAyealStokesApproximationEnum;
+                        pos=find(data==7); data(pos,end)=PattynStokesApproximationEnum;
+                        WriteData(fid,'data',data,'enum',FlowequationElementEquationEnum,'format','DoubleMat','mattype',2);
+                        pos=find(data==0); data(pos,end)=NoneApproximationEnum();
+                        pos=find(data==1); data(pos,end)=HutterApproximationEnum();
+                        pos=find(data==2); data(pos,end)=MacAyealApproximationEnum();
+                        pos=find(data==3); data(pos,end)=PattynApproximationEnum();
+                        pos=find(data==4); data(pos,end)=StokesApproximationEnum();
+                        pos=find(data==5); data(pos,end)=MacAyealPattynApproximationEnum();
+                        pos=find(data==6); data(pos,end)=MacAyealStokesApproximationEnum();
+                        pos=find(data==7); data(pos,end)=PattynStokesApproximationEnum();
+                        pos=find(data==8); data(pos,end)=L1L2ApproximationEnum();
+                        WriteData(fid,'data',data,'enum',FlowequationElementEquationEnum(),'format','DoubleMat','mattype',2);
                 end % }}}
         end

issm/branches/trunk-jpl-damage/src/m/classes/flowequation.py

-              r12168
+              r13101
 #module imports
+import numpy
 from fielddisplay import fielddisplay
+from EnumDefinitions import *
+from checkfield import *
+from WriteData import *
+class flowequation:
+class flowequation(object):
+        """
+        FLOWEQUATION class definition
+           Usage:
+              flowequation=flowequation();
+        """
         #properties
         def __init__(self):
 …
                 self.ismacayealpattyn     = 0;
                 self.ishutter             = 0;
+                self.isl1l2             = 0;
                 self.isstokes             = 0;
                 self.vertex_equation      = float('NaN')
 …
                 #}}}
         def __repr__(obj):
+        def __repr__(self):
                 # {{{ Display
                 string='   flow equation parameters:'
+                string="%s\n\n%s"%(string,fielddisplay(obj,'ismacayealpattyn','is the macayeal or pattyn approximation used ?'))
+                string="%s\n%s"%(string,fielddisplay(obj,'ishutter','is the shallow ice approximation used ?'))
+                string="%s\n%s"%(string,fielddisplay(obj,'isstokes','are the Full-Stokes equations used ?'))
+                string="%s\n%s"%(string,fielddisplay(obj,'vertex_equation','flow equation for each vertex'))
+                string="%s\n%s"%(string,fielddisplay(obj,'element_equation','flow equation for each element'))
+                string="%s\n%s"%(string,fielddisplay(obj,'bordermacayeal','vertices on MacAyeal''s border (for tiling)'))
+                string="%s\n%s"%(string,fielddisplay(obj,'borderpattyn','vertices on Pattyn''s border (for tiling)'))
+                string="%s\n%s"%(string,fielddisplay(obj,'borderstokes','vertices on Stokes'' border (for tiling)'))
+                string="%s\n\n%s"%(string,fielddisplay(self,'ismacayealpattyn','is the macayeal or pattyn approximation used ?'))
+                string="%s\n%s"%(string,fielddisplay(self,'ishutter','is the shallow ice approximation used ?'))
+                string="%s\n%s"%(string,fielddisplay(self,'isl1l2','are l1l2 equations used ?'))
+                string="%s\n%s"%(string,fielddisplay(self,'isstokes','are the Full-Stokes equations used ?'))
+                string="%s\n%s"%(string,fielddisplay(self,'vertex_equation','flow equation for each vertex'))
+                string="%s\n%s"%(string,fielddisplay(self,'element_equation','flow equation for each element'))
+                string="%s\n%s"%(string,fielddisplay(self,'bordermacayeal','vertices on MacAyeal''s border (for tiling)'))
+                string="%s\n%s"%(string,fielddisplay(self,'borderpattyn','vertices on Pattyn''s border (for tiling)'))
+                string="%s\n%s"%(string,fielddisplay(self,'borderstokes','vertices on Stokes'' border (for tiling)'))
                 return string
                 #}}}
         def setdefaultparameters(obj):
+        def setdefaultparameters(self):
                 # {{{setdefaultparameters
                 return obj
+                return self
         #}}}
+        def checkconsistency(self,md,solution,analyses):    # {{{
+                if DiagnosticHorizAnalysisEnum() in analyses:
+                        md = checkfield(md,'flowequation.ismacayealpattyn','numel',[1],'values',[0,1])
+                        md = checkfield(md,'flowequation.ishutter','numel',[1],'values',[0,1])
+                        md = checkfield(md,'flowequation.isl1l2','numel',[1],'values',[0,1])
+                        md = checkfield(md,'flowequation.isstokes','numel',[1],'values',[0,1])
+                        md = checkfield(md,'flowequation.bordermacayeal','size',[md.mesh.numberofvertices],'values',[0,1])
+                        md = checkfield(md,'flowequation.borderpattyn','size',[md.mesh.numberofvertices],'values',[0,1])
+                        md = checkfield(md,'flowequation.borderstokes','size',[md.mesh.numberofvertices],'values',[0,1])
+                        if md.mesh.dimension==2:
+                                md = checkfield(md,'flowequation.vertex_equation','size',[md.mesh.numberofvertices],'values',[1,2])
+                                md = checkfield(md,'flowequation.element_equation','size',[md.mesh.numberofelements],'values',[1,2])
+                        else:
+                                md = checkfield(md,'flowequation.vertex_equation','size',[md.mesh.numberofvertices],'values',range(0,7+1))
+                                md = checkfield(md,'flowequation.element_equation','size',[md.mesh.numberofelements],'values',range(0,7+1))
+                        if not (self.ismacayealpattyn or self.ishutter or self.isstokes or self.isl1l2):
+                                md.checkmessage("no element types set for this model. At least one of ismacayealpattyn, ishutter or isstokes need to be =1")
+                if DiagnosticHutterAnalysisEnum() in analyses:
+                        if any(self.element_equation==1):
+                                if numpy.any(numpy.logical_and(self.element_equation,md.mask.elementonfloatingice)):
+                                        print "\n !!! Warning: Hutter's model is not consistent on ice shelves !!!\n"
+                return md
+        # }}}
+        def marshall(self,fid):    # {{{
+                WriteData(fid,'object',self,'fieldname','ismacayealpattyn','format','Boolean')
+                WriteData(fid,'object',self,'fieldname','ishutter','format','Boolean')
+                WriteData(fid,'object',self,'fieldname','isl1l2','format','Boolean')
+                WriteData(fid,'object',self,'fieldname','isstokes','format','Boolean')
+                WriteData(fid,'object',self,'fieldname','bordermacayeal','format','DoubleMat','mattype',1)
+                WriteData(fid,'object',self,'fieldname','borderpattyn','format','DoubleMat','mattype',1)
+                WriteData(fid,'object',self,'fieldname','borderstokes','format','DoubleMat','mattype',1)
+                #convert approximations to enums
+                data=self.vertex_equation
+                data[[i for i,item in enumerate(data) if item==0]]=NoneApproximationEnum()
+                data[[i for i,item in enumerate(data) if item==1]]=HutterApproximationEnum()
+                data[[i for i,item in enumerate(data) if item==2]]=MacAyealApproximationEnum()
+                data[[i for i,item in enumerate(data) if item==3]]=PattynApproximationEnum()
+                data[[i for i,item in enumerate(data) if item==4]]=StokesApproximationEnum()
+                data[[i for i,item in enumerate(data) if item==5]]=MacAyealPattynApproximationEnum()
+                data[[i for i,item in enumerate(data) if item==6]]=MacAyealStokesApproximationEnum()
+                data[[i for i,item in enumerate(data) if item==7]]=PattynStokesApproximationEnum()
+                data[[i for i,item in enumerate(data) if item==8]]=L1L2ApproximationEnum()
+                WriteData(fid,'data',data,'enum',FlowequationVertexEquationEnum(),'format','DoubleMat','mattype',1)
+                data=self.element_equation
+                data[[i for i,item in enumerate(data) if item==0]]=NoneApproximationEnum()
+                data[[i for i,item in enumerate(data) if item==1]]=HutterApproximationEnum()
+                data[[i for i,item in enumerate(data) if item==2]]=MacAyealApproximationEnum()
+                data[[i for i,item in enumerate(data) if item==3]]=PattynApproximationEnum()
+                data[[i for i,item in enumerate(data) if item==4]]=StokesApproximationEnum()
+                data[[i for i,item in enumerate(data) if item==5]]=MacAyealPattynApproximationEnum()
+                data[[i for i,item in enumerate(data) if item==6]]=MacAyealStokesApproximationEnum()
+                data[[i for i,item in enumerate(data) if item==7]]=PattynStokesApproximationEnum()
+                data[[i for i,item in enumerate(data) if item==8]]=L1L2ApproximationEnum()
+                WriteData(fid,'data',data,'enum',FlowequationElementEquationEnum(),'format','DoubleMat','mattype',2)
+        # }}}

issm/branches/trunk-jpl-damage/src/m/classes/friction.m

r12878	r13101
25	25
26	26	%Early return
27		if ~ismember(DiagnosticHorizAnalysisEnum~~,analyses) & ~ismember(ThermalAnalysisEnum~~,analyses), return; end
	27	if ~ismember(DiagnosticHorizAnalysisEnum(),analyses) & ~ismember(ThermalAnalysisEnum(),analyses), return; end
28	28
29	29	md = checkfield(md,'friction.coefficient','NaN',1,'size',[md.mesh.numberofvertices 1]);

issm/branches/trunk-jpl-damage/src/m/classes/friction.py

-              r12168
+              r13101
 #module imports
 from fielddisplay import fielddisplay
+from EnumDefinitions import *
+from checkfield import *
+from WriteData import *
+class friction:
+class friction(object):
+        """
+        FRICTION class definition
+           Usage:
+              friction=friction();
+        """
         #properties
         def __init__(self):
 …
                 #}}}
         def __repr__(obj):
+        def __repr__(self):
                 # {{{ Display
                 string="Sigma= drag^2 * Neff ^r * u ^s, with Neff=rho_ice*g*thickness+rho_water*g*bed, r=q/p and s=1/p"
                 string="%s\n\n%s"%(string,fielddisplay(obj,"coefficient","friction coefficient [SI]"))
                 string="%s\n%s"%(string,fielddisplay(obj,"p","p exponent"))
                 string="%s\n%s"%(string,fielddisplay(obj,"q","q exponent"))
+                string="%s\n\n%s"%(string,fielddisplay(self,"coefficient","friction coefficient [SI]"))
+                string="%s\n%s"%(string,fielddisplay(self,"p","p exponent"))
+                string="%s\n%s"%(string,fielddisplay(self,"q","q exponent"))
                 return string
                 #}}}
         def setdefaultparameters(obj):
+        def setdefaultparameters(self):
                 # {{{setdefaultparameters
                 return obj
+                return self
         #}}}
+        def checkconsistency(self,md,solution,analyses):    # {{{
+                #Early return
+                if DiagnosticHorizAnalysisEnum() not in analyses and ThermalAnalysisEnum() not in analyses:
+                        return md
+                md = checkfield(md,'friction.coefficient','NaN',1,'size',[md.mesh.numberofvertices])
+                md = checkfield(md,'friction.q','NaN',1,'size',[md.mesh.numberofelements])
+                md = checkfield(md,'friction.p','NaN',1,'size',[md.mesh.numberofelements])
+                return md
+        # }}}
+        def marshall(self,fid):    # {{{
+                WriteData(fid,'object',self,'fieldname','coefficient','format','DoubleMat','mattype',1)
+                WriteData(fid,'object',self,'fieldname','p','format','DoubleMat','mattype',2)
+                WriteData(fid,'object',self,'fieldname','q','format','DoubleMat','mattype',2)
+        # }}}

issm/branches/trunk-jpl-damage/src/m/classes/geometry.m

-              r12878
+              r13101
                                 md = checkmessage(md,['equality thickness=surface-bed violated']);
                         end
                         if solution==TransientSolutionEnum & md.transient.isgroundingline,
+                        if solution==TransientSolutionEnum() & md.transient.isgroundingline,
                                 md = checkfield(md,'geometry.bathymetry','NaN',1,'size',[md.mesh.numberofvertices 1]);
                         end
 …
                 end % }}}
                 function marshall(obj,fid) % {{{
                         WriteData(fid,'data',obj.surface,'format','DoubleMat','mattype',1,'enum',SurfaceEnum);
                         WriteData(fid,'data',obj.thickness,'format','DoubleMat','mattype',1,'enum',ThicknessEnum);
                         WriteData(fid,'data',obj.bed,'format','DoubleMat','mattype',1,'enum',BedEnum);
                         WriteData(fid,'data',obj.bathymetry,'format','DoubleMat','mattype',1,'enum',BathymetryEnum);
+                        WriteData(fid,'data',obj.surface,'format','DoubleMat','mattype',1,'enum',SurfaceEnum());
+                        WriteData(fid,'data',obj.thickness,'format','DoubleMat','mattype',1,'enum',ThicknessEnum());
+                        WriteData(fid,'data',obj.bed,'format','DoubleMat','mattype',1,'enum',BedEnum());
+                        WriteData(fid,'data',obj.bathymetry,'format','DoubleMat','mattype',1,'enum',BathymetryEnum());
                         WriteData(fid,'object',obj,'fieldname','hydrostatic_ratio','format','DoubleMat','mattype',1);
                 end % }}}

issm/branches/trunk-jpl-damage/src/m/classes/geometry.py

-              r12168
+              r13101
 #module imports
 from fielddisplay import fielddisplay
+from EnumDefinitions import *
+from checkfield import *
+from WriteData import *
+class geometry:
+class geometry(object):
+        """
+        GEOMETRY class definition
+           Usage:
+              geometry=geometry();
+        """
         #properties
         def __init__(self):
 …
                 #}}}
         def __repr__(obj):
+        def __repr__(self):
                 # {{{ Display
                 string="   geometry parameters:"
                 string="%s\n\n%s"%(string,fielddisplay(obj,'surface','surface elevation'))
                 string="%s\n%s"%(string,fielddisplay(obj,'thickness','ice thickness'))
                 string="%s\n%s"%(string,fielddisplay(obj,'bed','bed elevation'))
                 string="%s\n%s"%(string,fielddisplay(obj,'bathymetry','bathymetry elevation'))
                 string="%s\n%s"%(string,fielddisplay(obj,'hydrostatic_ratio','coefficient for ice shelves'' thickness correction: hydrostatic_ratio H_obs+ (1-hydrostatic_ratio) H_hydro'))
+                string="%s\n\n%s"%(string,fielddisplay(self,'surface','surface elevation'))
+                string="%s\n%s"%(string,fielddisplay(self,'thickness','ice thickness'))
+                string="%s\n%s"%(string,fielddisplay(self,'bed','bed elevation'))
+                string="%s\n%s"%(string,fielddisplay(self,'bathymetry','bathymetry elevation'))
+                string="%s\n%s"%(string,fielddisplay(self,'hydrostatic_ratio','coefficient for ice shelves'' thickness correction: hydrostatic_ratio H_obs+ (1-hydrostatic_ratio) H_hydro'))
                 return string
                 #}}}
         def setdefaultparameters(obj):
+        def setdefaultparameters(self):
                 # {{{setdefaultparameters
                 return obj
+                return self
         #}}}
+        def checkconsistency(self,md,solution,analyses):    # {{{
+                md = checkfield(md,'geometry.surface'  ,'NaN',1,'size',[md.mesh.numberofvertices])
+                md = checkfield(md,'geometry.bed'      ,'NaN',1,'size',[md.mesh.numberofvertices])
+                md = checkfield(md,'geometry.thickness','NaN',1,'size',[md.mesh.numberofvertices],'>',0)
+                if any((self.thickness-self.surface+self.bed)>10**-9):
+                        md.checkmessage("equality thickness=surface-bed violated")
+                if solution==TransientSolutionEnum() and md.transient.isgroundingline:
+                        md = checkfield(md,'geometry.bathymetry','NaN',1,'size',[md.mesh.numberofvertices])
+                return md
+        # }}}
+        def marshall(self,fid):    # {{{
+                WriteData(fid,'data',self.surface,'format','DoubleMat','mattype',1,'enum',SurfaceEnum())
+                WriteData(fid,'data',self.thickness,'format','DoubleMat','mattype',1,'enum',ThicknessEnum())
+                WriteData(fid,'data',self.bed,'format','DoubleMat','mattype',1,'enum',BedEnum())
+                WriteData(fid,'data',self.bathymetry,'format','DoubleMat','mattype',1,'enum',BathymetryEnum())
+                WriteData(fid,'object',self,'fieldname','hydrostatic_ratio','format','DoubleMat','mattype',1)
+        # }}}

issm/branches/trunk-jpl-damage/src/m/classes/groundingline.m

-              r12878
+              r13101
                                         md = checkmessage(md,['requesting grounding line migration, but bathymetry is absent!']);
                                 end
                                 pos=find(md.mask.vertexongroundedice);
+                                pos=find(md.mask.vertexongroundedice);
                                 if any(abs(md.geometry.bed(pos)-md.geometry.bathymetry(pos))>10^-10),
                                         md = checkmessage(md,['bathymetry not equal to bed on grounded ice !']);
+                                        md = checkmessage(md,['bathymetry not equal to bed on grounded ice!']);
                                 end
                                 pos=find(md.mask.vertexonfloatingice);
+                                pos=find(md.mask.vertexonfloatingice);
                                 if any(md.geometry.bathymetry(pos)-md.geometry.bed(pos)>10^-9),
                                         md = checkmessage(md,['bathymetry superior to bed on floating ice !']);
+                                        md = checkmessage(md,['bathymetry superior to bed on floating ice!']);
                                 end
                         end
 …
                 end % }}}
                 function marshall(obj,fid) % {{{
                         WriteData(fid,'data',StringToEnum(obj.migration),'enum',GroundinglineMigrationEnum,'format','Integer');
+                        WriteData(fid,'data',StringToEnum(obj.migration),'enum',GroundinglineMigrationEnum(),'format','Integer');
                         WriteData(fid,'object',obj,'fieldname','melting_rate','format','Double');
                 end % }}}

issm/branches/trunk-jpl-damage/src/m/classes/groundingline.py

-              r12168
+              r13101
 #module imports
+import numpy
 from fielddisplay import fielddisplay
+from EnumDefinitions import *
+from StringToEnum import StringToEnum
+from checkfield import *
+from WriteData import *
+from MatlabFuncs import *
+class groundingline:
+class groundingline(object):
+        """
+        CONSTANTS class definition
+           Usage:
+              groundingline=groundingline();
+        """
         #properties
         def __init__(self):
 …
                 #}}}
         def __repr__(obj):
+        def __repr__(self):
                 # {{{ Display
                 string='   grounding line solution parameters:'
                 string="%s\n\n%s"%(string,fielddisplay(obj,'migration','type of grounding line migration: ''SoftMigration'',''AgressiveMigration'' or ''None'''))
                 string="%s\n%s"%(string,fielddisplay(obj,'melting_rate','melting rate applied when previously grounded parts start floating'))
+                string="%s\n\n%s"%(string,fielddisplay(self,'migration','type of grounding line migration: ''SoftMigration'',''AgressiveMigration'' or ''None'''))
+                string="%s\n%s"%(string,fielddisplay(self,'melting_rate','melting rate applied when previously grounded parts start floating'))
                 return string
                 #}}}
         def setdefaultparameters(obj):
+        def setdefaultparameters(self):
                 # {{{setdefaultparameters
                 #Type of migration
                 obj.migration='None'
+                self.migration='None'
                 #basal melting rate correction:
                 obj.melting_rate=0;
+                self.melting_rate=0;
                 return obj
+                return self
         #}}}
+        def checkconsistency(self,md,solution,analyses):    # {{{
+                md = checkfield(md,'groundingline.migration','values',['None','AgressiveMigration','SoftMigration'])
+                if not strcmp(self.migration,'None'):
+                        if numpy.any(numpy.isnan(md.geometry.bathymetry)):
+                                md.checkmessage("requesting grounding line migration, but bathymetry is absent!")
+                        pos=numpy.nonzero(md.mask.vertexongroundedice)
+                        if any(numpy.abs(md.geometry.bed[pos]-md.geometry.bathymetry[pos])>10**-10):
+                                md.checkmessage("bathymetry not equal to bed on grounded ice!")
+                        pos=numpy.nonzero(md.mask.vertexonfloatingice)
+                        if any(md.geometry.bathymetry[pos]-md.geometry.bed[pos]>10**-9):
+                                md.checkmessage("bathymetry superior to bed on floating ice!")
+                return md
+        # }}}
+        def marshall(self,fid):    # {{{
+                WriteData(fid,'data',StringToEnum(self.migration)[0],'enum',GroundinglineMigrationEnum(),'format','Integer')
+                WriteData(fid,'object',self,'fieldname','melting_rate','format','Double')
+        # }}}

issm/branches/trunk-jpl-damage/src/m/classes/hydrology.m

-              r12878
+              r13101
                         %Early return
                         if ~ismember(HydrologyAnalysisEnum,analyses), return; end
+                        if ~ismember(HydrologyAnalysisEnum(),analyses), return; end
                         md = checkfield(md,'hydrology.spcwatercolumn','forcing',1);
 …
                 function marshall(obj,fid) % {{{
                         WriteData(fid,'object',obj,'fieldname','spcwatercolumn','format','DoubleMat','mattype',1);
                         WriteData(fid,'object',obj,'fieldname','n','format','Double');
+                        WriteData(fid,'object',obj,'fieldname','n','format','Double');
                         WriteData(fid,'object',obj,'fieldname','CR','format','Double');
                         WriteData(fid,'object',obj,'fieldname','p','format','Double');

issm/branches/trunk-jpl-damage/src/m/classes/hydrology.py

-              r12168
+              r13101
 #module imports
 from fielddisplay import fielddisplay
+from EnumDefinitions import *
+from checkfield import *
+from WriteData import *
+class hydrology:
+class hydrology(object):
+        """
+        HYDROLOGY class definition
+           Usage:
+              hydrology=hydrology();
+        """
         #properties
         def __init__(self):
 …
                 self.setdefaultparameters()
                 #}}}
         def __repr__(obj):
+        def __repr__(self):
                 # {{{ Display
                 string='   hydrology solution parameters:'
                 string="%s\n\n%s"%(string,fielddisplay(obj,'spcwatercolumn','water thickness constraints (NaN means no constraint)'))
                 string="%s\n%s"%(string,fielddisplay(obj,'n','Manning roughness coefficient'))
                 string="%s\n%s"%(string,fielddisplay(obj,'CR','tortuosity parameter'))
                 string="%s\n%s"%(string,fielddisplay(obj,'p','dimensionless exponent in Manning velocity formula'))
                 string="%s\n%s"%(string,fielddisplay(obj,'q','dimensionless exponent in Manning velocity formula'))
                 string="%s\n%s"%(string,fielddisplay(obj,'kn','parameter in effective pressure formula'))
                 string="%s\n%s"%(string,fielddisplay(obj,'stabilization','artificial diffusivity (default is 1). can be more than 1 to increase diffusivity.'))
+                string="%s\n\n%s"%(string,fielddisplay(self,'spcwatercolumn','water thickness constraints (NaN means no constraint)'))
+                string="%s\n%s"%(string,fielddisplay(self,'n','Manning roughness coefficient'))
+                string="%s\n%s"%(string,fielddisplay(self,'CR','tortuosity parameter'))
+                string="%s\n%s"%(string,fielddisplay(self,'p','dimensionless exponent in Manning velocity formula'))
+                string="%s\n%s"%(string,fielddisplay(self,'q','dimensionless exponent in Manning velocity formula'))
+                string="%s\n%s"%(string,fielddisplay(self,'kn','parameter in effective pressure formula'))
+                string="%s\n%s"%(string,fielddisplay(self,'stabilization','artificial diffusivity (default is 1). can be more than 1 to increase diffusivity.'))
                 return string
                 #}}}
         def setdefaultparameters(obj):
+        def setdefaultparameters(self):
                 # {{{setdefaultparameters
                 #Parameters from Johnson's 2002 thesis, section 3.5.4
                 obj.n=.02
                 obj.CR=.01
                 obj.p=2
                 obj.q=1
                 obj.kn=0
+                self.n=.02
+                self.CR=.01
+                self.p=2
+                self.q=1
+                self.kn=0
                 #Type of stabilization to use 0:nothing 1:artificial_diffusivity
                 obj.stabilization=1
+                self.stabilization=1
                 return obj
+                return self
         #}}}
+        def checkconsistency(self,md,solution,analyses):    # {{{
+                #Early return
+                if HydrologyAnalysisEnum() not in analyses:
+                        return md
+                md = checkfield(md,'hydrology.spcwatercolumn','forcing',1)
+                md = checkfield(md,'hydrology.stabilization','>=',0)
+                return md
+        # }}}
+        def marshall(self,fid):    # {{{
+                WriteData(fid,'object',self,'fieldname','spcwatercolumn','format','DoubleMat','mattype',1)
+                WriteData(fid,'object',self,'fieldname','n','format','Double')
+                WriteData(fid,'object',self,'fieldname','CR','format','Double')
+                WriteData(fid,'object',self,'fieldname','p','format','Double')
+                WriteData(fid,'object',self,'fieldname','q','format','Double')
+                WriteData(fid,'object',self,'fieldname','kn','format','Double')
+                WriteData(fid,'object',self,'fieldname','stabilization','format','Double')
+        # }}}

issm/branches/trunk-jpl-damage/src/m/classes/initialization.m

-              r12917
+              r13101
                 end % }}}
                 function md = checkconsistency(obj,md,solution,analyses) % {{{
                         if ismember(DiagnosticHorizAnalysisEnum,analyses)
                                 if ~isnan(md.initialization.vx) & ~isnan(md.initialization.vy),
+                        if ismember(DiagnosticHorizAnalysisEnum(),analyses)
+                                if ~(isnan(md.initialization.vx) | isnan(md.initialization.vy)),
                                         md = checkfield(md,'initialization.vx','NaN',1,'size',[md.mesh.numberofvertices 1]);
                                         md = checkfield(md,'initialization.vy','NaN',1,'size',[md.mesh.numberofvertices 1]);
                                 end
                         end
                         if ismember(PrognosticAnalysisEnum,analyses),
+                        if ismember(PrognosticAnalysisEnum(),analyses),
                                 md = checkfield(md,'initialization.vx','NaN',1,'size',[md.mesh.numberofvertices 1]);
                                 md = checkfield(md,'initialization.vy','NaN',1,'size',[md.mesh.numberofvertices 1]);
                         end
                         if ismember(HydrologyAnalysisEnum,analyses),
+                        if ismember(HydrologyAnalysisEnum(),analyses),
                                 md = checkfield(md,'initialization.watercolumn','NaN',1,'size',[md.mesh.numberofvertices 1]);
                         end
                         if ismember(BalancethicknessAnalysisEnum,analyses),
+                        if ismember(BalancethicknessAnalysisEnum(),analyses),
                                 md = checkfield(md,'initialization.vx','NaN',1,'size',[md.mesh.numberofvertices 1]);
                                 md = checkfield(md,'initialization.vy','NaN',1,'size',[md.mesh.numberofvertices 1]);
 …
                                 end
                         end
                         if ismember(ThermalAnalysisEnum,analyses),
+                        if ismember(ThermalAnalysisEnum(),analyses),
                                 md = checkfield(md,'initialization.vx','NaN',1,'size',[md.mesh.numberofvertices 1]);
                                 md = checkfield(md,'initialization.vy','NaN',1,'size',[md.mesh.numberofvertices 1]);
 …
                                 md = checkfield(md,'initialization.pressure','NaN',1,'size',[md.mesh.numberofvertices 1]);
                         end
                         if (ismember(EnthalpyAnalysisEnum,analyses) & md.thermal.isenthalpy) | solution==EnthalpySolutionEnum,
+                        if (ismember(EnthalpyAnalysisEnum(),analyses) & md.thermal.isenthalpy) | solution==EnthalpySolutionEnum(),
                                 md = checkfield(md,'initialization.waterfraction','>=',0,'size',[md.mesh.numberofvertices 1]);
                         end

issm/branches/trunk-jpl-damage/src/m/classes/initialization.py

-              r12168
+              r13101
 #module imports
+import numpy
 from fielddisplay import fielddisplay
+from EnumDefinitions import *
+from checkfield import *
+from WriteData import *
+class initialization:
+class initialization(object):
+        """
+        INITIALIZATION class definition
+           Usage:
+              initialization=initialization();
+        """
         #properties
         def __init__(self):
 …
                 #}}}
         def __repr__(obj):
+        def __repr__(self):
                 # {{{ Display
                 string='   initial field values:'
                 string="%s\n%s"%(string,fielddisplay(obj,'vx','x component of velocity'))
                 string="%s\n%s"%(string,fielddisplay(obj,'vy','y component of velocity'))
                 string="%s\n%s"%(string,fielddisplay(obj,'vz','z component of velocity'))
                 string="%s\n%s"%(string,fielddisplay(obj,'vel','velocity norm'))
                 string="%s\n%s"%(string,fielddisplay(obj,'pressure','pressure field'))
                 string="%s\n%s"%(string,fielddisplay(obj,'temperature','temperature in Kelvins'))
                 string="%s\n%s"%(string,fielddisplay(obj,'watercolumn','thickness of subglacial water'))
                 string="%s\n%s"%(string,fielddisplay(obj,'waterfraction','fraction of water in the ice'))
+                string="%s\n%s"%(string,fielddisplay(self,'vx','x component of velocity'))
+                string="%s\n%s"%(string,fielddisplay(self,'vy','y component of velocity'))
+                string="%s\n%s"%(string,fielddisplay(self,'vz','z component of velocity'))
+                string="%s\n%s"%(string,fielddisplay(self,'vel','velocity norm'))
+                string="%s\n%s"%(string,fielddisplay(self,'pressure','pressure field'))
+                string="%s\n%s"%(string,fielddisplay(self,'temperature','temperature in Kelvins'))
+                string="%s\n%s"%(string,fielddisplay(self,'watercolumn','thickness of subglacial water'))
+                string="%s\n%s"%(string,fielddisplay(self,'waterfraction','fraction of water in the ice'))
                 return string
                 #}}}
         def setdefaultparameters(obj):
+        def setdefaultparameters(self):
                 # {{{setdefaultparameters
                 return obj
+                return self
         #}}}
+        def checkconsistency(self,md,solution,analyses):    # {{{
+                if DiagnosticHorizAnalysisEnum() in analyses:
+                        if not numpy.any(numpy.logical_or(numpy.isnan(md.initialization.vx),numpy.isnan(md.initialization.vy))):
+                                md = checkfield(md,'initialization.vx','NaN',1,'size',[md.mesh.numberofvertices])
+                                md = checkfield(md,'initialization.vy','NaN',1,'size',[md.mesh.numberofvertices])
+                if PrognosticAnalysisEnum() in analyses:
+                        md = checkfield(md,'initialization.vx','NaN',1,'size',[md.mesh.numberofvertices])
+                        md = checkfield(md,'initialization.vy','NaN',1,'size',[md.mesh.numberofvertices])
+                if HydrologyAnalysisEnum() in analyses:
+                        md = checkfield(md,'initialization.watercolumn','NaN',1,'size',[md.mesh.numberofvertices])
+                if BalancethicknessAnalysisEnum() in analyses:
+                        md = checkfield(md,'initialization.vx','NaN',1,'size',[md.mesh.numberofvertices])
+                        md = checkfield(md,'initialization.vy','NaN',1,'size',[md.mesh.numberofvertices])
+                        #Triangle with zero velocity
+                        if numpy.any(numpy.logical_and(numpy.sum(numpy.abs(md.initialization.vx[md.mesh.elements.astype(int)-1]),axis=1)==0,\
+                                                       numpy.sum(numpy.abs(md.initialization.vy[md.mesh.elements.astype(int)-1]),axis=1)==0)):
+                                md.checkmessage("at least one triangle has all its vertices with a zero velocity")
+                if ThermalAnalysisEnum() in analyses:
+                        md = checkfield(md,'initialization.vx','NaN',1,'size',[md.mesh.numberofvertices])
+                        md = checkfield(md,'initialization.vy','NaN',1,'size',[md.mesh.numberofvertices])
+                        md = checkfield(md,'initialization.vz','NaN',1,'size',[md.mesh.numberofvertices])
+                        md = checkfield(md,'initialization.pressure','NaN',1,'size',[md.mesh.numberofvertices])
+                if (EnthalpyAnalysisEnum() in analyses and md.thermal.isenthalpy) or solution==EnthalpySolutionEnum():
+                        md = checkfield(md,'initialization.waterfraction','>=',0,'size',[md.mesh.numberofvertices])
+                return md
+        # }}}
+        def marshall(self,fid):    # {{{
+                WriteData(fid,'data',self.vx,'format','DoubleMat','mattype',1,'enum',VxEnum())
+                WriteData(fid,'data',self.vy,'format','DoubleMat','mattype',1,'enum',VyEnum())
+                WriteData(fid,'data',self.vz,'format','DoubleMat','mattype',1,'enum',VzEnum())
+                WriteData(fid,'data',self.pressure,'format','DoubleMat','mattype',1,'enum',PressureEnum())
+                WriteData(fid,'data',self.temperature,'format','DoubleMat','mattype',1,'enum',TemperatureEnum())
+                WriteData(fid,'data',self.watercolumn,'format','DoubleMat','mattype',1,'enum',WatercolumnEnum())
+                WriteData(fid,'data',self.waterfraction,'format','DoubleMat','mattype',1,'enum',WaterfractionEnum())
+        # }}}

issm/branches/trunk-jpl-damage/src/m/classes/inversion.m

-              r12878
+              r13101
 %CONSTANTS class definition
+%INVERSION class definition
+%
 %   Usage:
 …
                         checkfield(md,'inversion.max_parameters','size',[md.mesh.numberofvertices num_controls]);
                         if solution==BalancethicknessSolutionEnum
+                        if solution==BalancethicknessSolutionEnum()
                                 md = checkfield(md,'inversion.thickness_obs','size',[md.mesh.numberofvertices 1],'NaN',1);
                         else
 …
                                 data(i)=StringToEnum(obj.control_parameters{i});
                         end
                         WriteData(fid,'data',data,'enum',InversionControlParametersEnum,'format','DoubleMat','mattype',3);
                         WriteData(fid,'data',num_control_parameters,'enum',InversionNumControlParametersEnum,'format','Integer');
+                        WriteData(fid,'data',data,'enum',InversionControlParametersEnum(),'format','DoubleMat','mattype',3);
+                        WriteData(fid,'data',num_control_parameters,'enum',InversionNumControlParametersEnum(),'format','Integer');
                         %process cost functions
                         num_cost_functions=size(obj.cost_functions,2);
                         data=obj.cost_functions;
+                        pos=find(data==101); data(pos)=SurfaceAbsVelMisfitEnum;
+                        pos=find(data==102); data(pos)=SurfaceRelVelMisfitEnum;
+                        pos=find(data==103); data(pos)=SurfaceLogVelMisfitEnum;
+                        pos=find(data==104); data(pos)=SurfaceLogVxVyMisfitEnum;
+                        pos=find(data==105); data(pos)=SurfaceAverageVelMisfitEnum;
+                        pos=find(data==201); data(pos)=ThicknessAbsMisfitEnum;
+                        pos=find(data==501); data(pos)=DragCoefficientAbsGradientEnum;
+                        pos=find(data==502); data(pos)=RheologyBbarAbsGradientEnum;
+                        pos=find(data==503); data(pos)=ThicknessAbsGradientEnum;
+                        WriteData(fid,'data',data,'enum',InversionCostFunctionsEnum,'format','DoubleMat','mattype',3);
+                        WriteData(fid,'data',num_cost_functions,'enum',InversionNumCostFunctionsEnum,'format','Integer');
+                        pos=find(data==101); data(pos)=SurfaceAbsVelMisfitEnum();
+                        pos=find(data==102); data(pos)=SurfaceRelVelMisfitEnum();
+                        pos=find(data==103); data(pos)=SurfaceLogVelMisfitEnum();
+                        pos=find(data==104); data(pos)=SurfaceLogVxVyMisfitEnum();
+                        pos=find(data==105); data(pos)=SurfaceAverageVelMisfitEnum();
+                        pos=find(data==201); data(pos)=ThicknessAbsMisfitEnum();
+                        pos=find(data==501); data(pos)=DragCoefficientAbsGradientEnum();
+                        pos=find(data==502); data(pos)=RheologyBbarAbsGradientEnum();
+                        pos=find(data==503); data(pos)=ThicknessAbsGradientEnum();
+                        pos=find(data==504); data(pos)=ThicknessAlongGradientEnum();
+                        pos=find(data==505); data(pos)=ThicknessAcrossGradientEnum();
+                        WriteData(fid,'data',data,'enum',InversionCostFunctionsEnum(),'format','DoubleMat','mattype',3);
+                        WriteData(fid,'data',num_cost_functions,'enum',InversionNumCostFunctionsEnum(),'format','Integer');
                 end % }}}
         end

issm/branches/trunk-jpl-damage/src/m/classes/inversion.py

-              r12168
+              r13101
 #module imports
+import numpy
 from fielddisplay import fielddisplay
+from EnumDefinitions import *
+from StringToEnum import StringToEnum
+from checkfield import *
+from WriteData import *
+class inversion:
+class inversion(object):
+        """
+        INVERSION class definition
+           Usage:
+              inversion=inversion();
+        """
         #properties
         def __init__(self):
 …
                 self.vel_obs                     = float('NaN')
                 self.thickness_obs               = float('NaN')
+                #set defaults
+                self.setdefaultparameters()
                 #}}}
         def __repr__(obj):
+        def __repr__(self):
                 # {{{ Display
                 string='\n   Inversion parameters:'
                 string="%s\n%s"%(string,fielddisplay(obj,'iscontrol','is inversion activated?'))
                 string="%s\n%s"%(string,fielddisplay(obj,'incomplete_adjoint','do we assume linear viscosity?'))
                 string="%s\n%s"%(string,fielddisplay(obj,'control_parameters','parameter where inverse control is carried out; ex: {''FrictionCoefficient''}, or {''MaterialsRheologyBbar''}'))
                 string="%s\n%s"%(string,fielddisplay(obj,'nsteps','number of optimization searches'))
                 string="%s\n%s"%(string,fielddisplay(obj,'cost_functions','indicate the type of response for each optimization step'))
                 string="%s\n%s"%(string,fielddisplay(obj,'cost_functions_coefficients','cost_functions_coefficients applied to the misfit of each vertex and for each control_parameter'))
                 string="%s\n%s"%(string,fielddisplay(obj,'cost_function_threshold','misfit convergence criterion. Default is 1%, NaN if not applied'))
                 string="%s\n%s"%(string,fielddisplay(obj,'maxiter_per_step','maximum iterations during each optimization step'))
                 string="%s\n%s"%(string,fielddisplay(obj,'gradient_scaling','scaling factor on gradient direction during optimization, for each optimization step'))
                 string="%s\n%s"%(string,fielddisplay(obj,'step_threshold','decrease threshold for misfit, default is 30%'))
                 string="%s\n%s"%(string,fielddisplay(obj,'min_parameters','absolute minimum acceptable value of the inversed parameter on each vertex'))
                 string="%s\n%s"%(string,fielddisplay(obj,'max_parameters','absolute maximum acceptable value of the inversed parameter on each vertex'))
                 string="%s\n%s"%(string,fielddisplay(obj,'gradient_only','stop control method solution at gradient'))
                 string="%s\n%s"%(string,fielddisplay(obj,'vx_obs','observed velocity x component [m/a]'))
                 string="%s\n%s"%(string,fielddisplay(obj,'vy_obs','observed velocity y component [m/a]'))
                 string="%s\n%s"%(string,fielddisplay(obj,'vel_obs','observed velocity magnitude [m/a]'))
                 string="%s\n%s"%(string,fielddisplay(obj,'thickness_obs','observed thickness [m]'))
+                string="%s\n%s"%(string,fielddisplay(self,'iscontrol','is inversion activated?'))
+                string="%s\n%s"%(string,fielddisplay(self,'incomplete_adjoint','do we assume linear viscosity?'))
+                string="%s\n%s"%(string,fielddisplay(self,'control_parameters','parameter where inverse control is carried out; ex: {''FrictionCoefficient''}, or {''MaterialsRheologyBbar''}'))
+                string="%s\n%s"%(string,fielddisplay(self,'nsteps','number of optimization searches'))
+                string="%s\n%s"%(string,fielddisplay(self,'cost_functions','indicate the type of response for each optimization step'))
+                string="%s\n%s"%(string,fielddisplay(self,'cost_functions_coefficients','cost_functions_coefficients applied to the misfit of each vertex and for each control_parameter'))
+                string="%s\n%s"%(string,fielddisplay(self,'cost_function_threshold','misfit convergence criterion. Default is 1%, NaN if not applied'))
+                string="%s\n%s"%(string,fielddisplay(self,'maxiter_per_step','maximum iterations during each optimization step'))
+                string="%s\n%s"%(string,fielddisplay(self,'gradient_scaling','scaling factor on gradient direction during optimization, for each optimization step'))
+                string="%s\n%s"%(string,fielddisplay(self,'step_threshold','decrease threshold for misfit, default is 30%'))
+                string="%s\n%s"%(string,fielddisplay(self,'min_parameters','absolute minimum acceptable value of the inversed parameter on each vertex'))
+                string="%s\n%s"%(string,fielddisplay(self,'max_parameters','absolute maximum acceptable value of the inversed parameter on each vertex'))
+                string="%s\n%s"%(string,fielddisplay(self,'gradient_only','stop control method solution at gradient'))
+                string="%s\n%s"%(string,fielddisplay(self,'vx_obs','observed velocity x component [m/a]'))
+                string="%s\n%s"%(string,fielddisplay(self,'vy_obs','observed velocity y component [m/a]'))
+                string="%s\n%s"%(string,fielddisplay(self,'vel_obs','observed velocity magnitude [m/a]'))
+                string="%s\n%s"%(string,fielddisplay(self,'thickness_obs','observed thickness [m]'))
                 string="%s\n%s"%(string,'Available cost functions:')
                 string="%s\n%s"%(string,'   101: SurfaceAbsVelMisfit')
 …
                 #}}}
+        def setdefaultparameters(obj):
+                # {{{setdefaultparameters
+        def setdefaultparameters(self): # {{{
                 #default is incomplete adjoint for now
                 obj.incomplete_adjoint=1
+                self.incomplete_adjoint=1
                 #parameter to be inferred by control methods (only
                 #drag and B are supported yet)
                 obj.control_parameters=['FrictionCoefficient']
+                self.control_parameters='FrictionCoefficient'
                 #number of steps in the control methods
                 obj.nsteps=20
+                self.nsteps=20
                 #maximum number of iteration in the optimization algorithm for
                 #each step
                 obj.maxiter_per_step=20*ones(obj.nsteps)
+                self.maxiter_per_step=20*numpy.ones(self.nsteps)
                 #the inversed parameter is updated as follows:
 …
                 #inversed parameter (10^8 for B, 50 for drag) and can be decreased
                 #after the first iterations
                 obj.gradient_scaling=50*ones(obj.nsteps)
+                self.gradient_scaling=50*numpy.ones(self.nsteps)
                 #several responses can be used:
                 obj.cost_functions=101*ones(obj.nsteps)
+                self.cost_functions=101*numpy.ones(self.nsteps)
                 #step_threshold is used to speed up control method. When
                 #misfit(1)/misfit(0) < obj.step_threshold, we go directly to
+                #misfit(1)/misfit(0) < self.step_threshold, we go directly to
                 #the next step
                 obj.step_threshold=.7*ones(obj.nsteps) #30 per cent decrement
+                self.step_threshold=.7*numpy.ones(self.nsteps) #30 per cent decrement
                 #stop control solution at the gradient computation and return it?
                 obj.gradient_only=0
+                self.gradient_only=0
                 #cost_function_threshold is a criteria to stop the control methods.
                 #if J[n]-J[n-1]/J[n] < criteria, the control run stops
                 #NaN if not applied
                 obj.cost_function_threshold=NaN #not activated
+                self.cost_function_threshold=float('NaN')    #not activated
                 return obj
                 #}}}
+                return self
+        #}}}
+        def checkconsistency(self,md,solution,analyses):    # {{{
+                #Early return
+                if not self.iscontrol:
+                        return md
+                num_controls=numpy.size(md.inversion.control_parameters)
+                num_costfunc=numpy.size(md.inversion.cost_functions,1)
+                md = checkfield(md,'inversion.iscontrol','values',[0,1])
+                md = checkfield(md,'inversion.tao','values',[0,1])
+                md = checkfield(md,'inversion.incomplete_adjoint','values',[0,1])
+                md = checkfield(md,'inversion.control_parameters','cell',1,'values',['BalancethicknessThickeningRate','FrictionCoefficient','MaterialsRheologyBbar','Vx','Vy'])
+                md = checkfield(md,'inversion.nsteps','numel',[1],'>=',1)
+                md = checkfield(md,'inversion.maxiter_per_step','size',[md.inversion.nsteps],'>=',0)
+                md = checkfield(md,'inversion.step_threshold','size',[md.inversion.nsteps])
+                md = checkfield(md,'inversion.cost_functions','size',[md.inversion.nsteps,num_costfunc],'values',[101,102,103,104,105,201,501,502,503,504,505])
+                md = checkfield(md,'inversion.cost_functions_coefficients','size',[md.mesh.numberofvertices,num_costfunc],'>=',0)
+                md = checkfield(md,'inversion.gradient_only','values',[0,1])
+                md = checkfield(md,'inversion.gradient_scaling','size',[md.inversion.nsteps,num_controls])
+                md = checkfield(md,'inversion.min_parameters','size',[md.mesh.numberofvertices,num_controls])
+                md = checkfield(md,'inversion.max_parameters','size',[md.mesh.numberofvertices,num_controls])
+                if solution==BalancethicknessSolutionEnum():
+                        md = checkfield(md,'inversion.thickness_obs','size',[md.mesh.numberofvertices],'NaN',1)
+                else:
+                        md = checkfield(md,'inversion.vx_obs','size',[md.mesh.numberofvertices],'NaN',1)
+                        md = checkfield(md,'inversion.vy_obs','size',[md.mesh.numberofvertices],'NaN',1)
+                return md
+        # }}}
+        def marshall(self,fid):    # {{{
+                WriteData(fid,'object',self,'fieldname','iscontrol','format','Boolean')
+                WriteData(fid,'object',self,'fieldname','tao','format','Boolean')
+                WriteData(fid,'object',self,'fieldname','incomplete_adjoint','format','Boolean')
+                if not self.iscontrol:
+                        return
+                WriteData(fid,'object',self,'fieldname','nsteps','format','Integer')
+                WriteData(fid,'object',self,'fieldname','maxiter_per_step','format','DoubleMat','mattype',3)
+                WriteData(fid,'object',self,'fieldname','cost_functions_coefficients','format','DoubleMat','mattype',1)
+                WriteData(fid,'object',self,'fieldname','gradient_scaling','format','DoubleMat','mattype',3)
+                WriteData(fid,'object',self,'fieldname','cost_function_threshold','format','Double')
+                WriteData(fid,'object',self,'fieldname','min_parameters','format','DoubleMat','mattype',3)
+                WriteData(fid,'object',self,'fieldname','max_parameters','format','DoubleMat','mattype',3)
+                WriteData(fid,'object',self,'fieldname','step_threshold','format','DoubleMat','mattype',3)
+                WriteData(fid,'object',self,'fieldname','gradient_only','format','Boolean')
+                WriteData(fid,'object',self,'fieldname','vx_obs','format','DoubleMat','mattype',1)
+                WriteData(fid,'object',self,'fieldname','vy_obs','format','DoubleMat','mattype',1)
+                WriteData(fid,'object',self,'fieldname','vz_obs','format','DoubleMat','mattype',1)
+                WriteData(fid,'object',self,'fieldname','thickness_obs','format','DoubleMat','mattype',1)
+                #process control parameters
+                num_control_parameters=numpy.size(self.control_parameters)
+                data=[StringToEnum(self.control_parameters[i])[0] for i in xrange(0,num_control_parameters)]
+                WriteData(fid,'data',data,'enum',InversionControlParametersEnum(),'format','DoubleMat','mattype',3)
+                WriteData(fid,'data',num_control_parameters,'enum',InversionNumControlParametersEnum(),'format','Integer')
+                #process cost functions
+                num_cost_functions=size(self.cost_functions,1)
+                data=self.cost_functions
+                data[[i for i,item in enumerate(data) if item==101]]=SurfaceAbsVelMisfitEnum()
+                data[[i for i,item in enumerate(data) if item==102]]=SurfaceRelVelMisfitEnum()
+                data[[i for i,item in enumerate(data) if item==103]]=SurfaceLogVelMisfitEnum()
+                data[[i for i,item in enumerate(data) if item==104]]=SurfaceLogVxVyMisfitEnum()
+                data[[i for i,item in enumerate(data) if item==105]]=SurfaceAverageVelMisfitEnum()
+                data[[i for i,item in enumerate(data) if item==201]]=ThicknessAbsMisfitEnum()
+                data[[i for i,item in enumerate(data) if item==501]]=DragCoefficientAbsGradientEnum()
+                data[[i for i,item in enumerate(data) if item==502]]=RheologyBbarAbsGradientEnum()
+                data[[i for i,item in enumerate(data) if item==503]]=ThicknessAbsGradientEnum()
+                data[[i for i,item in enumerate(data) if item==504]]=ThicknessAlongGradientEnum()
+                data[[i for i,item in enumerate(data) if item==505]]=ThicknessAcrossGradientEnum()
+                WriteData(fid,'data',data,'enum',InversionCostFunctionsEnum(),'format','DoubleMat','mattype',3)
+                WriteData(fid,'data',num_cost_functions,'enum',InversionNumCostFunctionsEnum(),'format','Integer')
+        # }}}

issm/branches/trunk-jpl-damage/src/m/classes/mask.py

-              r12168
+              r13101
 #module imports
 from fielddisplay import fielddisplay
+from EnumDefinitions import *
+from checkfield import *
+from WriteData import *
+class mask:
+class mask(object):
+        """
+        MASK class definition
+           Usage:
+              mask=mask();
+        """
         #properties
         def __init__(self):
 …
                 #}}}
         def __repr__(obj):
+        def __repr__(self):
                 # {{{ Display
                 string="";
                 string="%s\n%s"%(string,fielddisplay(obj,"elementonfloatingice","element on floating ice flags list"))
                 string="%s\n%s"%(string,fielddisplay(obj,"vertexonfloatingice","vertex on floating ice flags list"))
                 string="%s\n%s"%(string,fielddisplay(obj,"elementongroundedice","element on grounded ice  list"))
                 string="%s\n%s"%(string,fielddisplay(obj,"vertexongroundedice","vertex on grounded ice flags list"))
                 string="%s\n%s"%(string,fielddisplay(obj,"elementonwater","element on water flags list"))
                 string="%s\n%s"%(string,fielddisplay(obj,"vertexonwater","vertex on water flags list"))
+                string="%s\n%s"%(string,fielddisplay(self,"elementonfloatingice","element on floating ice flags list"))
+                string="%s\n%s"%(string,fielddisplay(self,"vertexonfloatingice","vertex on floating ice flags list"))
+                string="%s\n%s"%(string,fielddisplay(self,"elementongroundedice","element on grounded ice  list"))
+                string="%s\n%s"%(string,fielddisplay(self,"vertexongroundedice","vertex on grounded ice flags list"))
+                string="%s\n%s"%(string,fielddisplay(self,"elementonwater","element on water flags list"))
+                string="%s\n%s"%(string,fielddisplay(self,"vertexonwater","vertex on water flags list"))
                 return string
                 #}}}
         def setdefaultparameters(obj):
+        def setdefaultparameters(self):
                 # {{{setdefaultparameters
                 return obj
+                return self
         #}}}
+        def checkconsistency(self,md,solution,analyses):    # {{{
+                md = checkfield(md,'mask.elementonfloatingice','size',[md.mesh.numberofelements],'values',[0,1])
+                md = checkfield(md,'mask.elementongroundedice','size',[md.mesh.numberofelements],'values',[0,1])
+                md = checkfield(md,'mask.elementonwater'      ,'size',[md.mesh.numberofelements],'values',[0,1])
+                md = checkfield(md,'mask.vertexonfloatingice' ,'size',[md.mesh.numberofvertices],'values',[0,1])
+                md = checkfield(md,'mask.vertexongroundedice' ,'size',[md.mesh.numberofvertices],'values',[0,1])
+                md = checkfield(md,'mask.vertexonwater'       ,'size',[md.mesh.numberofvertices],'values',[0,1])
+                return md
+        # }}}
+        def marshall(self,fid):    # {{{
+                WriteData(fid,'object',self,'fieldname','elementonfloatingice','format','BooleanMat','mattype',2)
+                WriteData(fid,'object',self,'fieldname','elementongroundedice','format','BooleanMat','mattype',2)
+                WriteData(fid,'object',self,'fieldname','elementonwater','format','BooleanMat','mattype',2)
+                WriteData(fid,'object',self,'fieldname','vertexonfloatingice','format','DoubleMat','mattype',1)
+                WriteData(fid,'object',self,'fieldname','vertexongroundedice','format','DoubleMat','mattype',1)
+                WriteData(fid,'object',self,'fieldname','vertexonwater','format','DoubleMat','mattype',1)
+        # }}}

issm/branches/trunk-jpl-damage/src/m/classes/materials.m

-              r12897
+              r13101
 classdef materials
         properties (SetAccess=public)
                 rho_ice                    = 0;
                 rho_water                  = 0;
                 rho_freshwater             = 0;
                 mu_water                   = 0;
                 heatcapacity               = 0;
                 latentheat                 = 0;
                 thermalconductivity        = 0;
                 meltingpoint               = 0;
                 beta                       = 0;
                 mixed_layer_capacity       = 0;
                 thermal_exchange_velocity  = 0;
+                rho_ice                    = 0.;
+                rho_water                  = 0.;
+                rho_freshwater             = 0.;
+                mu_water                   = 0.;
+                heatcapacity               = 0.;
+                latentheat                 = 0.;
+                thermalconductivity        = 0.;
+                meltingpoint               = 0.;
+                beta                       = 0.;
+                mixed_layer_capacity       = 0.;
+                thermal_exchange_velocity  = 0.;
                 rheology_B   = NaN;
                 rheology_n   = NaN;
 …
                         %ice density (kg/m^3)
                         obj.rho_ice=917;
+                        obj.rho_ice=917.;
                         %ocean water density (kg/m^3)
                         obj.rho_water=1023;
+                        obj.rho_water=1023.;
                         %fresh water density (kg/m^3)
                         obj.rho_freshwater=1000;
+                        obj.rho_freshwater=1000.;
                         %water viscosity (N.s/m^2)
 …
                         %ice heat capacity cp (J/kg/K)
                         obj.heatcapacity=2093;
+                        obj.heatcapacity=2093.;
                         %ice latent heat of fusion L (J/kg)
 …
                         %mixed layer (ice-water interface) heat capacity (J/kg/K)
                         obj.mixed_layer_capacity=3974;
+                        obj.mixed_layer_capacity=3974.;
                         %thermal exchange velocity (ice-water interface) (m/s)
 …
                         WriteData(fid,'object',obj,'fieldname','rheology_n','format','DoubleMat','mattype',2);
                         WriteData(fid,'object',obj,'fieldname','rheology_Z','format','DoubleMat','mattype',1);
                         WriteData(fid,'data',StringToEnum(obj.rheology_law),'enum',MaterialsRheologyLawEnum,'format','Integer');
+                        WriteData(fid,'data',StringToEnum(obj.rheology_law),'enum',MaterialsRheologyLawEnum(),'format','Integer');
                 end % }}}
         end

issm/branches/trunk-jpl-damage/src/m/classes/materials.py

-              r12168
+              r13101
 #module imports
 from fielddisplay import fielddisplay
+from EnumDefinitions import *
+from StringToEnum import StringToEnum
+from checkfield import *
+from WriteData import *
+class materials:
+class materials(object):
+        """
+        MATERIALS class definition
+           Usage:
+              materials=materials();
+        """
         #properties
         def __init__(self):
                 # {{{ Properties
+                self.rho_ice                    = 0;
+                self.rho_water                  = 0;
+                self.mu_water                   = 0;
+                self.heatcapacity               = 0;
+                self.latentheat                 = 0;
+                self.thermalconductivity        = 0;
+                self.meltingpoint               = 0;
+                self.beta                       = 0;
+                self.mixed_layer_capacity       = 0;
+                self.thermal_exchange_velocity  = 0;
+                self.rho_ice                    = 0.
+                self.rho_water                  = 0.
+                self.rho_freshwater             = 0.
+                self.mu_water                   = 0.
+                self.heatcapacity               = 0.
+                self.latentheat                 = 0.
+                self.thermalconductivity        = 0.
+                self.meltingpoint               = 0.
+                self.beta                       = 0.
+                self.mixed_layer_capacity       = 0.
+                self.thermal_exchange_velocity  = 0.
                 self.rheology_B   = float('NaN')
                 self.rheology_n   = float('NaN')
                 self.rheology_law = "";
+                self.rheology_law = ''
                 self.setdefaultparameters()
                 #}}}
         def __repr__(obj):
+        def __repr__(self):
                 # {{{ Display
                 string="   Materials:"
+                string="%s\n\n%s"%(string,fielddisplay(obj,"rho_ice","ice density [kg/m^3]"))
+                string="%s\n%s"%(string,fielddisplay(obj,"rho_water","water density [kg/m^3]"))
+                string="%s\n%s"%(string,fielddisplay(obj,"mu_water","water viscosity [N s/m^2]"))
+                string="%s\n%s"%(string,fielddisplay(obj,"heatcapacity","heat capacity [J/kg/K]"))
+                string="%s\n%s"%(string,fielddisplay(obj,"thermalconductivity","ice thermal conductivity [W/m/K]"))
+                string="%s\n%s"%(string,fielddisplay(obj,"meltingpoint","melting point of ice at 1atm in K"))
+                string="%s\n%s"%(string,fielddisplay(obj,"latentheat","latent heat of fusion [J/m^3]"))
+                string="%s\n%s"%(string,fielddisplay(obj,"beta","rate of change of melting point with pressure [K/Pa]"))
+                string="%s\n%s"%(string,fielddisplay(obj,"mixed_layer_capacity","mixed layer capacity [W/kg/K]"))
+                string="%s\n%s"%(string,fielddisplay(obj,"thermal_exchange_velocity","thermal exchange velocity [m/s]"))
+                string="%s\n%s"%(string,fielddisplay(obj,"rheology_B","flow law parameter [Pa/s^(1/n)]"))
+                string="%s\n%s"%(string,fielddisplay(obj,"rheology_n","Glen""s flow law exponent"))
+                string="%s\n%s"%(string,fielddisplay(obj,"rheology_law","law for the temperature dependance of the rheology: ""None"", ""Paterson"" or ""Arrhenius"""))
+                string="%s\n\n%s"%(string,fielddisplay(self,"rho_ice","ice density [kg/m^3]"))
+                string="%s\n%s"%(string,fielddisplay(self,"rho_water","water density [kg/m^3]"))
+                string="%s\n%s"%(string,fielddisplay(self,"rho_freshwater","fresh water density [kg/m^3]"))
+                string="%s\n%s"%(string,fielddisplay(self,"mu_water","water viscosity [N s/m^2]"))
+                string="%s\n%s"%(string,fielddisplay(self,"heatcapacity","heat capacity [J/kg/K]"))
+                string="%s\n%s"%(string,fielddisplay(self,"thermalconductivity","ice thermal conductivity [W/m/K]"))
+                string="%s\n%s"%(string,fielddisplay(self,"meltingpoint","melting point of ice at 1atm in K"))
+                string="%s\n%s"%(string,fielddisplay(self,"latentheat","latent heat of fusion [J/m^3]"))
+                string="%s\n%s"%(string,fielddisplay(self,"beta","rate of change of melting point with pressure [K/Pa]"))
+                string="%s\n%s"%(string,fielddisplay(self,"mixed_layer_capacity","mixed layer capacity [W/kg/K]"))
+                string="%s\n%s"%(string,fielddisplay(self,"thermal_exchange_velocity","thermal exchange velocity [m/s]"))
+                string="%s\n%s"%(string,fielddisplay(self,"rheology_B","flow law parameter [Pa/s^(1/n)]"))
+                string="%s\n%s"%(string,fielddisplay(self,"rheology_n","Glen's flow law exponent"))
+                string="%s\n%s"%(string,fielddisplay(self,"rheology_law","law for the temperature dependance of the rheology: 'None', 'Paterson' or 'Arrhenius'"))
                 return string
                 #}}}
         def setdefaultparameters(obj):
+        def setdefaultparameters(self):
                 # {{{setdefaultparameters
                 #ice density (kg/m^3)
                 obj.rho_ice=917
+                self.rho_ice=917.
+                #water density (kg/m^3)
+                obj.rho_water=1023
+                #ocean water density (kg/m^3)
+                self.rho_water=1023.
+                #fresh water density (kg/m^3)
+                self.rho_freshwater=1000.
                 #water viscosity (N.s/m^2)
                 obj.mu_water=0.001787
+                self.mu_water=0.001787
                 #ice heat capacity cp (J/kg/K)
                 obj.heatcapacity=2093
+                self.heatcapacity=2093.
                 #ice latent heat of fusion L (J/kg)
                 obj.latentheat=3.34*10**5
+                self.latentheat=3.34*10**5
                 #ice thermal conductivity (W/m/K)
                 obj.thermalconductivity=2.4
+                self.thermalconductivity=2.4
                 #the melting point of ice at 1 atmosphere of pressure in K
                 obj.meltingpoint=273.15
+                self.meltingpoint=273.15
                 #rate of change of melting point with pressure (K/Pa)
                 obj.beta=9.8*10**-8
+                self.beta=9.8*10**-8
                 #mixed layer (ice-water interface) heat capacity (J/kg/K)
                 obj.mixed_layer_capacity=3974
+                self.mixed_layer_capacity=3974.
                 #thermal exchange velocity (ice-water interface) (m/s)
                 obj.thermal_exchange_velocity=1.00*10**-4
+                self.thermal_exchange_velocity=1.00*10**-4
                 #Rheology law: what is the temperature dependence of B with T
                 #available: none, paterson and arrhenius
                 obj.rheology_law='Paterson'
                 return obj
+                self.rheology_law='Paterson'
+                return self
                 #}}}
+        def checkconsistency(self,md,solution,analyses):    # {{{
+                md = checkfield(md,'materials.rho_ice','>',0)
+                md = checkfield(md,'materials.rho_water','>',0)
+                md = checkfield(md,'materials.rho_freshwater','>',0)
+                md = checkfield(md,'materials.mu_water','>',0)
+                md = checkfield(md,'materials.rheology_B','>',0,'size',[md.mesh.numberofvertices])
+                md = checkfield(md,'materials.rheology_n','>',0,'size',[md.mesh.numberofelements])
+                md = checkfield(md,'materials.rheology_law','values',['None','Paterson','Arrhenius'])
+                return md
+        # }}}
+        def marshall(self,fid):    # {{{
+                WriteData(fid,'object',self,'fieldname','rho_ice','format','Double')
+                WriteData(fid,'object',self,'fieldname','rho_water','format','Double')
+                WriteData(fid,'object',self,'fieldname','rho_freshwater','format','Double')
+                WriteData(fid,'object',self,'fieldname','mu_water','format','Double')
+                WriteData(fid,'object',self,'fieldname','heatcapacity','format','Double')
+                WriteData(fid,'object',self,'fieldname','latentheat','format','Double')
+                WriteData(fid,'object',self,'fieldname','thermalconductivity','format','Double')
+                WriteData(fid,'object',self,'fieldname','meltingpoint','format','Double')
+                WriteData(fid,'object',self,'fieldname','beta','format','Double')
+                WriteData(fid,'object',self,'fieldname','mixed_layer_capacity','format','Double')
+                WriteData(fid,'object',self,'fieldname','thermal_exchange_velocity','format','Double')
+                WriteData(fid,'object',self,'fieldname','rheology_B','format','DoubleMat','mattype',1)
+                WriteData(fid,'object',self,'fieldname','rheology_n','format','DoubleMat','mattype',2)
+                WriteData(fid,'data',StringToEnum(self.rheology_law)[0],'enum',MaterialsRheologyLawEnum(),'format','Integer')
+        # }}}

issm/branches/trunk-jpl-damage/src/m/classes/mesh.m

-              r12946
+              r13101
                         md = checkfield(md,'mesh.vertexonbed','size',[md.mesh.numberofvertices 1],'values',[0 1]);
                         md = checkfield(md,'mesh.vertexonsurface','size',[md.mesh.numberofvertices 1],'values',[0 1]);
+                        if (md.mesh.dimension==3),
+                                md = checkfield(md,'mesh.z','>=',md.geometry.bed-10^-10,'message','''mesh.z'' lower than bedrock');
+                                md = checkfield(md,'mesh.z','<=',md.geometry.surface+10^-10,'message','''mesh.z'' higher than surface elevation');
+                        end
                         if (md.mesh.dimension==2),
                                 md = checkfield(md,'mesh.average_vertex_connectivity','>=',9,'message','''mesh.average_vertex_connectivity'' should be at least 9 in 2d');
 …
                         %Solution specific checks
                         switch(solution),
                                 case PrognosticSolutionEnum,
+                                case PrognosticSolutionEnum(),
                                         if md.prognostic.stabilization==3,
                                                 md = checkfield(md,'mesh.dimension','values',2,'message','Discontinuous Galerkin only supported for 2d meshes');
 …
                                                 md = checkfield(md,'mesh.edges(:,1:3)','>',0);
                                         end
                                 case BalancethicknessSolutionEnum,
+                                case BalancethicknessSolutionEnum(),
                                         if md.balancethickness.stabilization==3,
                                                 md = checkfield(md,'mesh.dimension','values',2,'message','Discontinuous Galerkin only supported for 2d meshes');
 …
                                                 md = checkfield(md,'mesh.edges(:,1:3)','>',0);
                                         end
                                 case TransientSolutionEnum,
+                                case TransientSolutionEnum(),
                                         if md.transient.isprognostic & md.prognostic.stabilization==3,
                                                 md = checkfield(md,'mesh.dimension','values',2,'message','Discontinuous Galerkin only supported for 2d meshes');
 …
                                                 md = checkfield(md,'mesh.edges(:,1:3)','>',0);
                                         end
                                 case ThermalSolutionEnum,
+                                case ThermalSolutionEnum(),
                                         md = checkfield(md,'mesh.dimension','values',3,'message','thermal solution only supported on 3d meshes');
                         end

issm/branches/trunk-jpl-damage/src/m/classes/mesh.py

-              r12946
+              r13101
 import numpy
 from fielddisplay import fielddisplay
+from EnumDefinitions import *
 from checkfield import *
-from EnumDefinitions import *
 from MatlabFuncs import *
+class mesh:
+class mesh(object):
+        """
+        MESH class definition
+           Usage:
+              mesh=mesh();
+        """
         #properties
         def __init__(self):
 …
                 #}}}
         def __repr__(obj):
+        def __repr__(self):
                 # {{{ Display
                 if obj.dimension==3:
+                if self.dimension==3:
                         string="\n%s"%("      Elements and vertices of the original 2d mesh:")
                         string="%s\n%s"%(string,fielddisplay(obj,"numberofelements2d","number of elements"))
                         string="%s\n%s"%(string,fielddisplay(obj,"numberofvertices2d","number of vertices"))
                         string="%s\n%s"%(string,fielddisplay(obj,"elements2d","index into (x,y,z), coordinates of the vertices"))
                         string="%s\n%s"%(string,fielddisplay(obj,"x2d","vertices x coordinate"))
                         string="%s\n%s"%(string,fielddisplay(obj,"y2d","vertices y coordinate"))
+                        string="%s\n%s"%(string,fielddisplay(self,"numberofelements2d","number of elements"))
+                        string="%s\n%s"%(string,fielddisplay(self,"numberofvertices2d","number of vertices"))
+                        string="%s\n%s"%(string,fielddisplay(self,"elements2d","index into (x,y,z), coordinates of the vertices"))
+                        string="%s\n%s"%(string,fielddisplay(self,"x2d","vertices x coordinate"))
+                        string="%s\n%s"%(string,fielddisplay(self,"y2d","vertices y coordinate"))
                         string="%s\n%s" %(string,"Elements and vertices of the extruded 3d mesh:")
                 else:
                         string="\n%s"%("      Elements and vertices:")
                 string="%s\n%s"%(string,fielddisplay(obj,"numberofelements","number of elements"))
                 string="%s\n%s"%(string,fielddisplay(obj,"numberofvertices","number of vertices"))
                 string="%s\n%s"%(string,fielddisplay(obj,"elements","index into (x,y,z), coordinates of the vertices"))
                 string="%s\n%s"%(string,fielddisplay(obj,"x","vertices x coordinate"))
                 string="%s\n%s"%(string,fielddisplay(obj,"y","vertices y coordinate"))
                 string="%s\n%s"%(string,fielddisplay(obj,"z","vertices z coordinate"))
                 string="%s\n%s"%(string,fielddisplay(obj,"edges","edges of the 2d mesh (vertex1 vertex2 element1 element2)"))
                 string="%s\n%s"%(string,fielddisplay(obj,"numberofedges","number of edges of the 2d mesh"))
+                string="%s\n%s"%(string,fielddisplay(self,"numberofelements","number of elements"))
+                string="%s\n%s"%(string,fielddisplay(self,"numberofvertices","number of vertices"))
+                string="%s\n%s"%(string,fielddisplay(self,"elements","index into (x,y,z), coordinates of the vertices"))
+                string="%s\n%s"%(string,fielddisplay(self,"x","vertices x coordinate"))
+                string="%s\n%s"%(string,fielddisplay(self,"y","vertices y coordinate"))
+                string="%s\n%s"%(string,fielddisplay(self,"z","vertices z coordinate"))
+                string="%s\n%s"%(string,fielddisplay(self,"edges","edges of the 2d mesh (vertex1 vertex2 element1 element2)"))
+                string="%s\n%s"%(string,fielddisplay(self,"numberofedges","number of edges of the 2d mesh"))
                 string="%s%s"%(string,"\n      Properties:")
                 string="%s\n%s"%(string,fielddisplay(obj,"dimension","mesh dimension (2d or 3d)"))
                 string="%s\n%s"%(string,fielddisplay(obj,"numberoflayers","number of extrusion layers"))
                 string="%s\n%s"%(string,fielddisplay(obj,"vertexonbed","lower vertices flags list"))
                 string="%s\n%s"%(string,fielddisplay(obj,"elementonbed","lower elements flags list"))
                 string="%s\n%s"%(string,fielddisplay(obj,"vertexonsurface","upper vertices flags list"))
                 string="%s\n%s"%(string,fielddisplay(obj,"elementonsurface","upper elements flags list"))
                 string="%s\n%s"%(string,fielddisplay(obj,"uppervertex","upper vertex list (NaN for vertex on the upper surface)"))
                 string="%s\n%s"%(string,fielddisplay(obj,"upperelements","upper element list (NaN for element on the upper layer)"))
                 string="%s\n%s"%(string,fielddisplay(obj,"lowervertex","lower vertex list (NaN for vertex on the lower surface)"))
                 string="%s\n%s"%(string,fielddisplay(obj,"lowerelements","lower element list (NaN for element on the lower layer"))
                 string="%s\n%s"%(string,fielddisplay(obj,"vertexonboundary","vertices on the boundary of the domain flag list"))
                 string="%s\n%s"%(string,fielddisplay(obj,"segments","edges on domain boundary (vertex1 vertex2 element)"))
                 string="%s\n%s"%(string,fielddisplay(obj,"segmentmarkers","number associated to each segment"))
                 string="%s\n%s"%(string,fielddisplay(obj,"vertexconnectivity","list of vertices connected to vertex_i"))
                 string="%s\n%s"%(string,fielddisplay(obj,"elementconnectivity","list of vertices connected to element_i"))
                 string="%s\n%s"%(string,fielddisplay(obj,"average_vertex_connectivity","average number of vertices connected to one vertex"))
+                string="%s\n%s"%(string,fielddisplay(self,"dimension","mesh dimension (2d or 3d)"))
+                string="%s\n%s"%(string,fielddisplay(self,"numberoflayers","number of extrusion layers"))
+                string="%s\n%s"%(string,fielddisplay(self,"vertexonbed","lower vertices flags list"))
+                string="%s\n%s"%(string,fielddisplay(self,"elementonbed","lower elements flags list"))
+                string="%s\n%s"%(string,fielddisplay(self,"vertexonsurface","upper vertices flags list"))
+                string="%s\n%s"%(string,fielddisplay(self,"elementonsurface","upper elements flags list"))
+                string="%s\n%s"%(string,fielddisplay(self,"uppervertex","upper vertex list (NaN for vertex on the upper surface)"))
+                string="%s\n%s"%(string,fielddisplay(self,"upperelements","upper element list (NaN for element on the upper layer)"))
+                string="%s\n%s"%(string,fielddisplay(self,"lowervertex","lower vertex list (NaN for vertex on the lower surface)"))
+                string="%s\n%s"%(string,fielddisplay(self,"lowerelements","lower element list (NaN for element on the lower layer"))
+                string="%s\n%s"%(string,fielddisplay(self,"vertexonboundary","vertices on the boundary of the domain flag list"))
+                string="%s\n%s"%(string,fielddisplay(self,"segments","edges on domain boundary (vertex1 vertex2 element)"))
+                string="%s\n%s"%(string,fielddisplay(self,"segmentmarkers","number associated to each segment"))
+                string="%s\n%s"%(string,fielddisplay(self,"vertexconnectivity","list of vertices connected to vertex_i"))
+                string="%s\n%s"%(string,fielddisplay(self,"elementconnectivity","list of vertices connected to element_i"))
+                string="%s\n%s"%(string,fielddisplay(self,"average_vertex_connectivity","average number of vertices connected to one vertex"))
                 string="%s%s"%(string,"\n      Extracted model:")
                 string="%s\n%s"%(string,fielddisplay(obj,"extractedvertices","vertices extracted from the model"))
                 string="%s\n%s"%(string,fielddisplay(obj,"extractedelements","elements extracted from the model"))
+                string="%s\n%s"%(string,fielddisplay(self,"extractedvertices","vertices extracted from the model"))
+                string="%s\n%s"%(string,fielddisplay(self,"extractedelements","elements extracted from the model"))
                 string="%s%s"%(string,"\n      Projection:")
                 string="%s\n%s"%(string,fielddisplay(obj,"lat","vertices latitude"))
                 string="%s\n%s"%(string,fielddisplay(obj,"long","vertices longitude"))
                 string="%s\n%s"%(string,fielddisplay(obj,"hemisphere","Indicate hemisphere ""n"" or ""s"" "))
+                string="%s\n%s"%(string,fielddisplay(self,"lat","vertices latitude"))
+                string="%s\n%s"%(string,fielddisplay(self,"long","vertices longitude"))
+                string="%s\n%s"%(string,fielddisplay(self,"hemisphere","Indicate hemisphere 'n' or 's'"))
                 return string
                 #}}}
         def setdefaultparameters(obj):
+        def setdefaultparameters(self):
                 # {{{setdefaultparameters
 …
                 #give a good memory/time ration. This value can be checked in
                 #trunk/test/Miscellaneous/runme.m
                 obj.average_vertex_connectivity=25
                 return obj
+                self.average_vertex_connectivity=25
+                return self
         #}}}
 …
                 else:
                         md = checkfield(md,'mesh.elements','size',[md.mesh.numberofelements,6])
                 if any(numpy.logical_not(ismember(range(1,md.mesh.numberofvertices+1),md.mesh.elements))):
                         md = checkmessage(md,"orphan nodes have been found. Check the mesh outline")
+                if numpy.any(numpy.logical_not(ismember(range(1,md.mesh.numberofvertices+1),md.mesh.elements))):
+                        md.checkmessage("orphan nodes have been found. Check the mesh outline")
                 md = checkfield(md,'mesh.dimension','values',[2,3])
                 md = checkfield(md,'mesh.numberoflayers','>=',0)
 …
                 #Solution specific checks
                 if   solution==PrognosticSolutionEnum:
+                if   solution==PrognosticSolutionEnum():
                         if md.prognostic.stabilization==3:
                                 md = checkfield(md,'mesh.dimension','values',2,'message',"Discontinuous Galerkin only supported for 2d meshes")
                                 md = checkfield(md,'mesh.edges','size',[float('NaN'),4])
                                 md = checkfield(md,'mesh.edges[:,1:3]','>',0)
                 elif solution==BalancethicknessSolutionEnum:
+                elif solution==BalancethicknessSolutionEnum():
                         if md.balancethickness.stabilization==3:
                                 md = checkfield(md,'mesh.dimension','values',2,'message',"Discontinuous Galerkin only supported for 2d meshes")
                                 md = checkfield(md,'mesh.edges','size',[float('NaN'),4])
                                 md = checkfield(md,'mesh.edges[:,1:3]','>',0)
                 elif solution==TransientSolutionEnum:
+                elif solution==TransientSolutionEnum():
                         if md.transient.isprognostic and md.prognostic.stabilization==3:
                                 md = checkfield(md,'mesh.dimension','values',2,'message',"Discontinuous Galerkin only supported for 2d meshes")
                                 md = checkfield(md,'mesh.edges','size',[float('NaN'),4])
                                 md = checkfield(md,'mesh.edges[:,1:3]','>',0)
                 elif solution==ThermalSolutionEnum:
+                elif solution==ThermalSolutionEnum():
                         md = checkfield(md,'mesh.dimension','values',3,'message','thermal solution only supported on 3d meshes')

issm/branches/trunk-jpl-damage/src/m/classes/miscellaneous.m

r12878	r13101
1		%MISCELANEOUS class definition
	1	%MISCELLANEOUS class definition
2	2	%
3	3	% Usage:

issm/branches/trunk-jpl-damage/src/m/classes/miscellaneous.py

-              r12168
+              r13101
 #module imports
 from fielddisplay import fielddisplay
+from EnumDefinitions import *
+from checkfield import *
+from WriteData import *
+class miscellaneous:
+class miscellaneous(object):
+        """
+        MISCELLANEOUS class definition
+           Usage:
+              miscellaneous=miscellaneous();
+        """
         #properties
         def __init__(self):
 …
                 #}}}
         def __repr__(obj):
+        def __repr__(self):
                 # {{{ Display
                 string='   miscellaneous parameters:'
                 string="%s\n\n%s"%(string,fielddisplay(obj,'notes','notes in a cell of strings'))
                 string="%s\n%s"%(string,fielddisplay(obj,'name','model name'))
                 string="%s\n%s"%(string,fielddisplay(obj,'dummy','empty field to store some data'))
+                string="%s\n\n%s"%(string,fielddisplay(self,'notes','notes in a cell of strings'))
+                string="%s\n%s"%(string,fielddisplay(self,'name','model name'))
+                string="%s\n%s"%(string,fielddisplay(self,'dummy','empty field to store some data'))
                 return string
                 #}}}
         def setdefaultparameters(obj):
+        def setdefaultparameters(self):
                 # {{{setdefaultparameters
                 return obj
+                return self
         #}}}
+        def checkconsistency(self,md,solution,analyses):    # {{{
+                md = checkfield(md,'miscellaneous.name','empty',1)
+                return md
+        # }}}
+        def marshall(self,fid):    #  {{{
+                WriteData(fid,'object',self,'fieldname','name','format','String')
+        # }}}

issm/branches/trunk-jpl-damage/src/m/classes/model/model.m

-              r12878
+              r13101
                  end
                  %}}}
+                 function md = collapse(md)% {{{
+                         %COLLAPSE - collapses a 3d mesh into a 2d mesh
+                         %
+                         %   This routine collapses a 3d model into a 2d model
+                         %   and collapses all the fileds of the 3d model by
+                         %   taking their depth-averaged values
+                         %
+                         %   Usage:
+                         %      md=collapse(md)
+                         %
+                         %   See also: EXTRUDE, MODELEXTRACT
+                         %Check that the model is really a 3d model
+                         if ~md.mesh.dimension==3,
+                                 error('collapse error message: only 3d mesh can be collapsed')
+                         end
+                         %Start with changing alle the fields from the 3d mesh
+                         %drag is limited to nodes that are on the bedrock.
+                         md.friction.coefficient=project2d(md,md.friction.coefficient,1);
+                         %p and q (same deal, except for element that are on the bedrock: )
+                         md.friction.p=project2d(md,md.friction.p,1);
+                         md.friction.q=project2d(md,md.friction.q,1);
+                         %observations
+                         if ~isnan(md.inversion.vx_obs), md.inversion.vx_obs=project2d(md,md.inversion.vx_obs,md.mesh.numberoflayers); end;
+                         if ~isnan(md.inversion.vy_obs), md.inversion.vy_obs=project2d(md,md.inversion.vy_obs,md.mesh.numberoflayers); end;
+                         if ~isnan(md.inversion.vel_obs), md.inversion.vel_obs=project2d(md,md.inversion.vel_obs,md.mesh.numberoflayers); end;
+                         if ~isnan(md.inversion.cost_functions_coefficients), md.inversion.cost_functions_coefficients=project2d(md,md.inversion.cost_functions_coefficients,md.mesh.numberoflayers); end;
+                         if numel(md.inversion.min_parameters)>1, md.inversion.min_parameters=project2d(md,md.inversion.min_parameters,md.mesh.numberoflayers); end;
+                         if numel(md.inversion.max_parameters)>1, md.inversion.max_parameters=project2d(md,md.inversion.max_parameters,md.mesh.numberoflayers); end;
+                         if ~isnan(md.surfaceforcings.mass_balance),
+                                 md.surfaceforcings.mass_balance=project2d(md,md.surfaceforcings.mass_balance,md.mesh.numberoflayers);
+                         end;
+                         if ~isnan(md.balancethickness.thickening_rate), md.balancethickness.thickening_rate=project2d(md,md.balancethickness.thickening_rate,md.mesh.numberoflayers); end;
+                         %results
+                         if ~isnan(md.initialization.vx),md.initialization.vx=DepthAverage(md,md.initialization.vx);end;
+                         if ~isnan(md.initialization.vy),md.initialization.vy=DepthAverage(md,md.initialization.vy);end;
+                         if ~isnan(md.initialization.vz),md.initialization.vz=DepthAverage(md,md.initialization.vz);end;
+                         if ~isnan(md.initialization.vel),md.initialization.vel=DepthAverage(md,md.initialization.vel);end;
+                         if ~isnan(md.initialization.temperature),md.initialization.temperature=DepthAverage(md,md.initialization.temperature);end;
+                         %bedinfo and surface info
+                         md.mesh.elementonbed=ones(md.mesh.numberofelements2d,1);
+                         md.mesh.elementonsurface=ones(md.mesh.numberofelements2d,1);
+                         md.mesh.vertexonbed=ones(md.mesh.numberofvertices2d,1);
+                         md.mesh.vertexonsurface=ones(md.mesh.numberofvertices2d,1);
+                         %elementstype
+                         if ~isnan(md.flowequation.element_equation)
+                                 md.flowequation.element_equation=project2d(md,md.flowequation.element_equation,1);
+                                 md.flowequation.vertex_equation=project2d(md,md.flowequation.vertex_equation,1);
+                                 md.flowequation.bordermacayeal=project2d(md,md.flowequation.bordermacayeal,1);
+                                 md.flowequation.borderpattyn=project2d(md,md.flowequation.borderpattyn,1);
+                                 md.flowequation.borderstokes=project2d(md,md.flowequation.borderstokes,1);
+                         end
+                         %boundary conditions
+                         md.diagnostic.spcvx=project2d(md,md.diagnostic.spcvx,md.mesh.numberoflayers);
+                         md.diagnostic.spcvy=project2d(md,md.diagnostic.spcvy,md.mesh.numberoflayers);
+                         md.diagnostic.spcvz=project2d(md,md.diagnostic.spcvz,md.mesh.numberoflayers);
+                         md.diagnostic.referential=project2d(md,md.diagnostic.referential,md.mesh.numberoflayers);
+                         md.prognostic.spcthickness=project2d(md,md.prognostic.spcthickness,md.mesh.numberoflayers);
+                         md.thermal.spctemperature=project2d(md,md.thermal.spctemperature,md.mesh.numberoflayers);
+                         %Extrusion of Neumann BC
+                         if ~isnan(md.diagnostic.icefront),
+                                 numberofneumann2d=size(md.diagnostic.icefront,1)/(md.mesh.numberoflayers-1);
+                                 md.diagnostic.icefront=[md.diagnostic.icefront(1:numberofneumann2d,1:2) md.diagnostic.icefront(1:numberofneumann2d,5:6)]; %Add two columns on the first layer
+                         end
+                         %materials
+                         md.materials.rheology_B=DepthAverage(md,md.materials.rheology_B);
+                         md.materials.rheology_n=project2d(md,md.materials.rheology_n,1);
+                         %special for thermal modeling:
+                         md.basalforcings.melting_rate=project2d(md,md.basalforcings.melting_rate,1);
+                         md.basalforcings.geothermalflux=project2d(md,md.basalforcings.geothermalflux,1); %bedrock only gets geothermal flux
+                         %update of connectivity matrix
+                         md.mesh.average_vertex_connectivity=25;
+                         %Collapse the mesh
+                         nodes2d=md.mesh.numberofvertices2d;
+                         elements2d=md.mesh.numberofelements2d;
+                         %parameters
+                         md.geometry.surface=project2d(md,md.geometry.surface,1);
+                         md.geometry.thickness=project2d(md,md.geometry.thickness,1);
+                         md.geometry.bed=project2d(md,md.geometry.bed,1);
+                         md.geometry.bathymetry=project2d(md,md.geometry.bathymetry,1);
+                         md.mesh.vertexonboundary=project2d(md,md.mesh.vertexonboundary,1);
+                         md.mesh.elementconnectivity=project2d(md,md.mesh.elementconnectivity,1);
+                         md.mask.elementonfloatingice=project2d(md,md.mask.elementonfloatingice,1);
+                         md.mask.vertexonfloatingice=project2d(md,md.mask.vertexonfloatingice,1);
+                         md.mask.elementongroundedice=project2d(md,md.mask.elementongroundedice,1);
+                         md.mask.vertexongroundedice=project2d(md,md.mask.vertexongroundedice,1);
+                         md.mask.elementonwater=project2d(md,md.mask.elementonwater,1);
+                         md.mask.vertexonwater=project2d(md,md.mask.vertexonwater,1);
+                         %lat long
+                         if numel(md.mesh.lat) ==md.mesh.numberofvertices,  md.mesh.lat=project2d(md,md.mesh.lat,1); end
+                         if numel(md.mesh.long)==md.mesh.numberofvertices, md.mesh.long=project2d(md,md.mesh.long,1); end
+                         %Initialize with the 2d mesh
+                         md.mesh.x=md.mesh.x2d;
+                         md.mesh.y=md.mesh.y2d;
+                         md.mesh.z=zeros(size(md.mesh.x2d));
+                         md.mesh.numberofvertices=md.mesh.numberofvertices2d;
+                         md.mesh.numberofelements=md.mesh.numberofelements2d;
+                         md.mesh.elements=md.mesh.elements2d;
+                         %Keep a trace of lower and upper nodes
+                         md.mesh.lowervertex=NaN;
+                         md.mesh.uppervertex=NaN;
+                         md.mesh.lowerelements=NaN;
+                         md.mesh.upperelements=NaN;
+                         %Remove old mesh
+                         md.mesh.x2d=NaN;
+                         md.mesh.y2d=NaN;
+                         md.mesh.elements2d=NaN;
+                         md.mesh.numberofelements2d=md.mesh.numberofelements;
+                         md.mesh.numberofvertices2d=md.mesh.numberofvertices;
+                         md.mesh.numberoflayers=0;
+                         %Update mesh type
+                         md.mesh.dimension=2;
+                 end % }}}
+                 function md2 = extract(md,area) % {{{
+                         %extract - extract a model according to an Argus contour or flag list
+                         %
+                         %   This routine extracts a submodel from a bigger model with respect to a given contour
+                         %   md must be followed by the corresponding exp file or flags list
+                         %   It can either be a domain file (argus type, .exp extension), or an array of element flags.
+                         %   If user wants every element outside the domain to be
+                         %   extract2d, add '~' to the name of the domain file (ex: '~Pattyn.exp');
+                         %   an empty string '' will be considered as an empty domain
+                         %   a string 'all' will be considered as the entire domain
+                         %   add an argument 0 if you do not want the elements to be checked (faster)
+                         %
+                         %   Usage:
+                         %      md2=extract(md,area);
+                         %
+                         %   Examples:
+                         %      md2=extract(md,'Domain.exp');
+                         %      md2=extract(md,md.mask.elementonfloatingice);
+                         %
+                         %   See also: EXTRUDE, COLLAPSE
+                         %copy model
+                         md1=md;
+                         %some checks
+                         if ((nargin~=2) | (nargout~=1)),
+                                 help extract
+                                 error('extract error message: bad usage');
+                         end
+                         %get check option
+                         if (nargin==3 & varargin{1}==0),
+                                 checkoutline=0;
+                         else
+                                 checkoutline=1;
+                         end
+                         %get elements that are inside area
+                         flag_elem=FlagElements(md1,area);
+                         if ~any(flag_elem),
+                                 error('extracted model is empty');
+                         end
+                         %kick out all elements with 3 dirichlets
+                         spc_elem=find(~flag_elem);
+                         spc_node=sort(unique(md1.mesh.elements(spc_elem,:)));
+                         flag=ones(md1.mesh.numberofvertices,1);
+                         flag(spc_node)=0;
+                         pos=find(sum(flag(md1.mesh.elements),2)==0);
+                         flag_elem(pos)=0;
+                         %extracted elements and nodes lists
+                         pos_elem=find(flag_elem);
+                         pos_node=sort(unique(md1.mesh.elements(pos_elem,:)));
+                         %keep track of some fields
+                         numberofvertices1=md1.mesh.numberofvertices;
+                         numberofelements1=md1.mesh.numberofelements;
+                         numberofvertices2=length(pos_node);
+                         numberofelements2=length(pos_elem);
+                         flag_node=zeros(numberofvertices1,1);
+                         flag_node(pos_node)=1;
+                         %Create Pelem and Pnode (transform old nodes in new nodes and same thing for the elements)
+                         Pelem=zeros(numberofelements1,1);
+                         Pelem(pos_elem)=[1:numberofelements2]';
+                         Pnode=zeros(numberofvertices1,1);
+                         Pnode(pos_node)=[1:numberofvertices2]';
+                         %renumber the elements (some node won't exist anymore)
+                         elements_1=md1.mesh.elements;
+                         elements_2=elements_1(pos_elem,:);
+                         elements_2(:,1)=Pnode(elements_2(:,1));
+                         elements_2(:,2)=Pnode(elements_2(:,2));
+                         elements_2(:,3)=Pnode(elements_2(:,3));
+                         if md1.mesh.dimension==3,
+                                 elements_2(:,4)=Pnode(elements_2(:,4));
+                                 elements_2(:,5)=Pnode(elements_2(:,5));
+                                 elements_2(:,6)=Pnode(elements_2(:,6));
+                         end
+                         %OK, now create the new model !
+                         %take every fields from model
+                         md2=md1;
+                         %automatically modify fields
+                         %loop over model fields
+                         model_fields=fields(md1);
+                         for i=1:length(model_fields),
+                                 %get field
+                                 field=md1.(model_fields{i});
+                                 fieldsize=size(field);
+                                 if isobject(field), %recursive call
+                                         object_fields=fields(md1.(model_fields{i}));
+                                         for j=1:length(object_fields),
+                                                 %get field
+                                                 field=md1.(model_fields{i}).(object_fields{j});
+                                                 fieldsize=size(field);
+                                                 %size = number of nodes * n
+                                                 if fieldsize(1)==numberofvertices1
+                                                         md2.(model_fields{i}).(object_fields{j})=field(pos_node,:);
+                                                 elseif (fieldsize(1)==numberofvertices1+1)
+                                                         md2.(model_fields{i}).(object_fields{j})=[field(pos_node,:); field(end,:)];
+                                                         %size = number of elements * n
+                                                 elseif fieldsize(1)==numberofelements1
+                                                         md2.(model_fields{i}).(object_fields{j})=field(pos_elem,:);
+                                                 end
+                                         end
+                                 else
+                                         %size = number of nodes * n
+                                         if fieldsize(1)==numberofvertices1
+                                                 md2.(model_fields{i})=field(pos_node,:);
+                                         elseif (fieldsize(1)==numberofvertices1+1)
+                                                 md2.(model_fields{i})=[field(pos_node,:); field(end,:)];
+                                                 %size = number of elements * n
+                                         elseif fieldsize(1)==numberofelements1
+                                                 md2.(model_fields{i})=field(pos_elem,:);
+                                         end
+                                 end
+                         end
+                         %modify some specific fields
+                         %Mesh
+                         md2.mesh.numberofelements=numberofelements2;
+                         md2.mesh.numberofvertices=numberofvertices2;
+                         md2.mesh.elements=elements_2;
+                         %mesh.uppervertex mesh.lowervertex
+                         if md1.mesh.dimension==3
+                                 md2.mesh.uppervertex=md1.mesh.uppervertex(pos_node);
+                                 pos=find(~isnan(md2.mesh.uppervertex));
+                                 md2.mesh.uppervertex(pos)=Pnode(md2.mesh.uppervertex(pos));
+                                 md2.mesh.lowervertex=md1.mesh.lowervertex(pos_node);
+                                 pos=find(~isnan(md2.mesh.lowervertex));
+                                 md2.mesh.lowervertex(pos)=Pnode(md2.mesh.lowervertex(pos));
+                                 md2.mesh.upperelements=md1.mesh.upperelements(pos_elem);
+                                 pos=find(~isnan(md2.mesh.upperelements));
+                                 md2.mesh.upperelements(pos)=Pelem(md2.mesh.upperelements(pos));
+                                 md2.mesh.lowerelements=md1.mesh.lowerelements(pos_elem);
+                                 pos=find(~isnan(md2.mesh.lowerelements));
+                                 md2.mesh.lowerelements(pos)=Pelem(md2.mesh.lowerelements(pos));
+                         end
+                         %Initial 2d mesh
+                         if md1.mesh.dimension==3
+                                 flag_elem_2d=flag_elem(1:md1.mesh.numberofelements2d);
+                                 pos_elem_2d=find(flag_elem_2d);
+                                 flag_node_2d=flag_node(1:md1.mesh.numberofvertices2d);
+                                 pos_node_2d=find(flag_node_2d);
+                                 md2.mesh.numberofelements2d=length(pos_elem_2d);
+                                 md2.mesh.numberofvertices2d=length(pos_node_2d);
+                                 md2.mesh.elements2d=md1.mesh.elements2d(pos_elem_2d,:);
+                                 md2.mesh.elements2d(:,1)=Pnode(md2.mesh.elements2d(:,1));
+                                 md2.mesh.elements2d(:,2)=Pnode(md2.mesh.elements2d(:,2));
+                                 md2.mesh.elements2d(:,3)=Pnode(md2.mesh.elements2d(:,3));
+                                 md2.mesh.x2d=md1.mesh.x(pos_node_2d);
+                                 md2.mesh.y2d=md1.mesh.y(pos_node_2d);
+                         end
+                         %Edges
+                         if size(md2.mesh.edges,2)>1, %do not use ~isnan because there are some NaNs...
+                                 %renumber first two columns
+                                 pos=find(md2.mesh.edges(:,4)~=-1);
+                                 md2.mesh.edges(:  ,1)=Pnode(md2.mesh.edges(:,1));
+                                 md2.mesh.edges(:  ,2)=Pnode(md2.mesh.edges(:,2));
+                                 md2.mesh.edges(:  ,3)=Pelem(md2.mesh.edges(:,3));
+                                 md2.mesh.edges(pos,4)=Pelem(md2.mesh.edges(pos,4));
+                                 %remove edges when the 2 vertices are not in the domain.
+                                 md2.mesh.edges=md2.mesh.edges(find(md2.mesh.edges(:,1) & md2.mesh.edges(:,2)),:);
+                                 %Replace all zeros by -1 in the last two columns;
+                                 pos=find(md2.mesh.edges(:,3)==0);
+                                 md2.mesh.edges(pos,3)=-1;
+                                 pos=find(md2.mesh.edges(:,4)==0);
+                                 md2.mesh.edges(pos,4)=-1;
+                                 %Invert -1 on the third column with last column (Also invert first two columns!!)
+                                 pos=find(md2.mesh.edges(:,3)==-1);
+                                 md2.mesh.edges(pos,3)=md2.mesh.edges(pos,4);
+                                 md2.mesh.edges(pos,4)=-1;
+                                 values=md2.mesh.edges(pos,2);
+                                 md2.mesh.edges(pos,2)=md2.mesh.edges(pos,1);
+                                 md2.mesh.edges(pos,1)=values;
+                                 %Finally remove edges that do not belong to any element
+                                 pos=find(md2.mesh.edges(:,3)==-1 & md2.mesh.edges(:,4)==-1);
+                                 md2.mesh.edges(pos,:)=[];
+                         end
+                         %Penalties
+                         if ~isnan(md2.diagnostic.vertex_pairing),
+                                 for i=1:size(md1.diagnostic.vertex_pairing,1);
+                                         md2.diagnostic.vertex_pairing(i,:)=Pnode(md1.diagnostic.vertex_pairing(i,:));
+                                 end
+                                 md2.diagnostic.vertex_pairing=md2.diagnostic.vertex_pairing(find(md2.diagnostic.vertex_pairing(:,1)),:);
+                         end
+                         if ~isnan(md2.prognostic.vertex_pairing),
+                                 for i=1:size(md1.prognostic.vertex_pairing,1);
+                                         md2.prognostic.vertex_pairing(i,:)=Pnode(md1.prognostic.vertex_pairing(i,:));
+                                 end
+                                 md2.prognostic.vertex_pairing=md2.prognostic.vertex_pairing(find(md2.prognostic.vertex_pairing(:,1)),:);
+                         end
+                         %recreate segments
+                         if md1.mesh.dimension==2
+                                 md2.mesh.vertexconnectivity=NodeConnectivity(md2.mesh.elements,md2.mesh.numberofvertices);
+                                 md2.mesh.elementconnectivity=ElementConnectivity(md2.mesh.elements,md2.mesh.vertexconnectivity);
+                                 md2.mesh.segments=contourenvelope(md2);
+                                 md2.mesh.vertexonboundary=zeros(numberofvertices2,1); md2.mesh.vertexonboundary(md2.mesh.segments(:,1:2))=1;
+                         else
+                                 %First do the connectivity for the contourenvelope in 2d
+                                 md2.mesh.vertexconnectivity=NodeConnectivity(md2.mesh.elements2d,md2.mesh.numberofvertices2d);
+                                 md2.mesh.elementconnectivity=ElementConnectivity(md2.mesh.elements2d,md2.mesh.vertexconnectivity);
+                                 md2.mesh.segments=contourenvelope(md2);
+                                 md2.mesh.vertexonboundary=zeros(numberofvertices2/md2.mesh.numberoflayers,1); md2.mesh.vertexonboundary(md2.mesh.segments(:,1:2))=1;
+                                 md2.mesh.vertexonboundary=repmat(md2.mesh.vertexonboundary,md2.mesh.numberoflayers,1);
+                                 %Then do it for 3d as usual
+                                 md2.mesh.vertexconnectivity=NodeConnectivity(md2.mesh.elements,md2.mesh.numberofvertices);
+                                 md2.mesh.elementconnectivity=ElementConnectivity(md2.mesh.elements,md2.mesh.vertexconnectivity);
+                         end
+                         %Boundary conditions: Dirichlets on new boundary
+                         %Catch the elements that have not been extracted
+                         orphans_elem=find(~flag_elem);
+                         orphans_node=unique(md1.mesh.elements(orphans_elem,:))';
+                         %Figure out which node are on the boundary between md2 and md1
+                         nodestoflag1=intersect(orphans_node,pos_node);
+                         nodestoflag2=Pnode(nodestoflag1);
+                         if numel(md1.diagnostic.spcvx)>1 & numel(md1.diagnostic.spcvy)>2 & numel(md1.diagnostic.spcvz)>2,
+                                 if numel(md1.inversion.vx_obs)>1 & numel(md1.inversion.vy_obs)>1
+                                         md2.diagnostic.spcvx(nodestoflag2)=md2.inversion.vx_obs(nodestoflag2);
+                                         md2.diagnostic.spcvy(nodestoflag2)=md2.inversion.vy_obs(nodestoflag2);
+                                 else
+                                         md2.diagnostic.spcvx(nodestoflag2)=NaN;
+                                         md2.diagnostic.spcvy(nodestoflag2)=NaN;
+                                         disp(' ')
+                                         disp('!! extract warning: spc values should be checked !!')
+                                         disp(' ')
+                                 end
+                                 %put 0 for vz
+                                 md2.diagnostic.spcvz(nodestoflag2)=0;
+                         end
+                         if ~isnan(md1.thermal.spctemperature),
+                                 md2.thermal.spctemperature(nodestoflag2,1)=1;
+                         end
+                         %Diagnostic
+                         if ~isnan(md2.diagnostic.icefront)
+                                 md2.diagnostic.icefront(:,1)=Pnode(md1.diagnostic.icefront(:,1));
+                                 md2.diagnostic.icefront(:,2)=Pnode(md1.diagnostic.icefront(:,2));
+                                 md2.diagnostic.icefront(:,end-1)=Pelem(md1.diagnostic.icefront(:,end-1));
+                                 if md1.mesh.dimension==3
+                                         md2.diagnostic.icefront(:,3)=Pnode(md1.diagnostic.icefront(:,3));
+                                         md2.diagnostic.icefront(:,4)=Pnode(md1.diagnostic.icefront(:,4));
+                                 end
+                                 md2.diagnostic.icefront=md2.diagnostic.icefront(find(md2.diagnostic.icefront(:,1) & md2.diagnostic.icefront(:,2) & md2.diagnostic.icefront(:,end)),:);
+                         end
+                         %Results fields
+                         if isstruct(md1.results),
+                                 md2.results=struct();
+                                 solutionfields=fields(md1.results);
+                                 for i=1:length(solutionfields),
+                                         %get subfields
+                                         solutionsubfields=fields(md1.results.(solutionfields{i}));
+                                         for j=1:length(solutionsubfields),
+                                                 field=md1.results.(solutionfields{i}).(solutionsubfields{j});
+                                                 if length(field)==numberofvertices1,
+                                                         md2.results.(solutionfields{i}).(solutionsubfields{j})=field(pos_node);
+                                                 elseif length(field)==numberofelements1,
+                                                         md2.results.(solutionfields{i}).(solutionsubfields{j})=field(pos_elem);
+                                                 else
+                                                         md2.results.(solutionfields{i}).(solutionsubfields{j})=field;
+                                                 end
+                                         end
+                                 end
+                         end
+                         %Keep track of pos_node and pos_elem
+                         md2.mesh.extractedvertices=pos_node;
+                         md2.mesh.extractedelements=pos_elem;
+                 end % }}}
+                 function md = extrude(md,varargin) % {{{
+                         %EXTRUDE - vertically extrude a 2d mesh
+                         %
+                         %   vertically extrude a 2d mesh and create corresponding 3d mesh.
+                         %   The vertical distribution can:
+                         %    - follow a polynomial law
+                         %    - follow two polynomial laws, one for the lower part and one for the upper part of the mesh
+                         %    - be discribed by a list of coefficients (between 0 and 1)
+                         %
+                         %
+                         %   Usage:
+                         %      md=extrude(md,numlayers,extrusionexponent);
+                         %      md=extrude(md,numlayers,lowerexponent,upperexponent);
+                         %      md=extrude(md,listofcoefficients);
+                         %
+                         %   Example:
+                         %      md=extrude(md,8,3);
+                         %      md=extrude(md,8,3,2);
+                         %      md=extrude(md,[0 0.2 0.5 0.7 0.9 0.95 1]);
+                         %
+                         %   See also: MODELEXTRACT, COLLAPSE
+                         %some checks on list of arguments
+                         if ((nargin>4) | (nargin<2) | (nargout~=1)),
+                                 help extrude;
+                                 error('extrude error message');
+                         end
+                         %Extrude the mesh
+                         if nargin==2, %list of coefficients
+                                 list=varargin{1};
+                                 if any(list<0) | any(list>1),
+                                         error('extrusioncoefficients must be between 0 and 1');
+                                 end
+                                 extrusionlist=sort(unique([list(:);0;1]));
+                                 numlayers=length(extrusionlist);
+                         elseif nargin==3, %one polynomial law
+                                 if varargin{2}<=0,
+                                         help extrude;
+                                         error('extrusionexponent must be >=0');
+                                 end
+                                 numlayers=varargin{1};
+                                 extrusionlist=((0:1:numlayers-1)/(numlayers-1)).^varargin{2};
+                         elseif nargin==4, %two polynomial laws
+                                 numlayers=varargin{1};
+                                 lowerexp=varargin{2};
+                                 upperexp=varargin{3};
+                                 if varargin{2}<=0 | varargin{3}<=0,
+                                         help extrude;
+                                         error('lower and upper extrusionexponents must be >=0');
+                                 end
+                                 lowerextrusionlist=[(0:2/(numlayers-1):1).^lowerexp]/2;
+                                 upperextrusionlist=[(0:2/(numlayers-1):1).^upperexp]/2;
+                                 extrusionlist=sort(unique([lowerextrusionlist 1-upperextrusionlist]));
+                         end
+                         if numlayers<2,
+                                 error('number of layers should be at least 2');
+                         end
+                         if md.mesh.dimension==3,
+                                 error('Cannot extrude a 3d mesh (extrude cannot be called more than once)');
+                         end
+                         %Initialize with the 2d mesh
+                         x3d=[];
+                         y3d=[];
+                         z3d=[];  %the lower node is on the bed
+                         thickness3d=md.geometry.thickness; %thickness and bed for these nodes
+                         bed3d=md.geometry.bed;
+                         %Create the new layers
+                         for i=1:numlayers,
+                                 x3d=[x3d; md.mesh.x];
+                                 y3d=[y3d; md.mesh.y];
+                                 %nodes are distributed between bed and surface accordingly to the given exponent
+                                 z3d=[z3d; bed3d+thickness3d*extrusionlist(i)];
+                         end
+                         number_nodes3d=size(x3d,1); %number of 3d nodes for the non extruded part of the mesh
+                         %Extrude elements
+                         elements3d=[];
+                         for i=1:numlayers-1,
+                                 elements3d=[elements3d;[md.mesh.elements+(i-1)*md.mesh.numberofvertices md.mesh.elements+i*md.mesh.numberofvertices]]; %Create the elements of the 3d mesh for the non extruded part
+                         end
+                         number_el3d=size(elements3d,1); %number of 3d nodes for the non extruded part of the mesh
+                         %Keep a trace of lower and upper nodes
+                         mesh.lowervertex=NaN*ones(number_nodes3d,1);
+                         mesh.uppervertex=NaN*ones(number_nodes3d,1);
+                         mesh.lowervertex(md.mesh.numberofvertices+1:end)=1:(numlayers-1)*md.mesh.numberofvertices;
+                         mesh.uppervertex(1:(numlayers-1)*md.mesh.numberofvertices)=md.mesh.numberofvertices+1:number_nodes3d;
+                         md.mesh.lowervertex=mesh.lowervertex;
+                         md.mesh.uppervertex=mesh.uppervertex;
+                         %same for lower and upper elements
+                         mesh.lowerelements=NaN*ones(number_el3d,1);
+                         mesh.upperelements=NaN*ones(number_el3d,1);
+                         mesh.lowerelements(md.mesh.numberofelements+1:end)=1:(numlayers-2)*md.mesh.numberofelements;
+                         mesh.upperelements(1:(numlayers-2)*md.mesh.numberofelements)=md.mesh.numberofelements+1:(numlayers-1)*md.mesh.numberofelements;
+                         md.mesh.lowerelements=mesh.lowerelements;
+                         md.mesh.upperelements=mesh.upperelements;
+                         %Save old mesh
+                         md.mesh.x2d=md.mesh.x;
+                         md.mesh.y2d=md.mesh.y;
+                         md.mesh.elements2d=md.mesh.elements;
+                         md.mesh.numberofelements2d=md.mesh.numberofelements;
+                         md.mesh.numberofvertices2d=md.mesh.numberofvertices;
+                         %Update mesh type
+                         md.mesh.dimension=3;
+                         %Build global 3d mesh
+                         md.mesh.elements=elements3d;
+                         md.mesh.x=x3d;
+                         md.mesh.y=y3d;
+                         md.mesh.z=z3d;
+                         md.mesh.numberofelements=number_el3d;
+                         md.mesh.numberofvertices=number_nodes3d;
+                         md.mesh.numberoflayers=numlayers;
+                         %Ok, now deal with the other fields from the 2d mesh:
+                         %lat long
+                         md.mesh.lat=project3d(md,'vector',md.mesh.lat,'type','node');
+                         md.mesh.long=project3d(md,'vector',md.mesh.long,'type','node');
+                         %drag coefficient is limited to nodes that are on the bedrock.
+                         md.friction.coefficient=project3d(md,'vector',md.friction.coefficient,'type','node','layer',1);
+                         %p and q (same deal, except for element that are on the bedrock: )
+                         md.friction.p=project3d(md,'vector',md.friction.p,'type','element');
+                         md.friction.q=project3d(md,'vector',md.friction.q,'type','element');
+                         %observations
+                         md.inversion.vx_obs=project3d(md,'vector',md.inversion.vx_obs,'type','node');
+                         md.inversion.vy_obs=project3d(md,'vector',md.inversion.vy_obs,'type','node');
+                         md.inversion.vel_obs=project3d(md,'vector',md.inversion.vel_obs,'type','node');
+                         md.surfaceforcings.mass_balance=project3d(md,'vector',md.surfaceforcings.mass_balance,'type','node');
+                         md.surfaceforcings.precipitation=project3d(md,'vector',md.surfaceforcings.precipitation,'type','node');
+                         md.balancethickness.thickening_rate=project3d(md,'vector',md.balancethickness.thickening_rate,'type','node');
+                         md.surfaceforcings.monthlytemperatures=project3d(md,'vector',md.surfaceforcings.monthlytemperatures,'type','node');
+                         %results
+                         if ~isnan(md.initialization.vx),md.initialization.vx=project3d(md,'vector',md.initialization.vx,'type','node');end;
+                         if ~isnan(md.initialization.vy),md.initialization.vy=project3d(md,'vector',md.initialization.vy,'type','node');end;
+                         if ~isnan(md.initialization.vz),md.initialization.vz=project3d(md,'vector',md.initialization.vz,'type','node');end;
+                         if ~isnan(md.initialization.vel),md.initialization.vel=project3d(md,'vector',md.initialization.vel,'type','node');end;
+                         if ~isnan(md.initialization.temperature),md.initialization.temperature=project3d(md,'vector',md.initialization.temperature,'type','node');end;
+                         if ~isnan(md.initialization.waterfraction),md.initialization.waterfraction=project3d(md,'vector',md.initialization.waterfraction,'type','node');end;
+                         %bedinfo and surface info
+                         md.mesh.elementonbed=project3d(md,'vector',ones(md.mesh.numberofelements2d,1),'type','element','layer',1);
+                         md.mesh.elementonsurface=project3d(md,'vector',ones(md.mesh.numberofelements2d,1),'type','element','layer',md.mesh.numberoflayers-1);
+                         md.mesh.vertexonbed=project3d(md,'vector',ones(md.mesh.numberofvertices2d,1),'type','node','layer',1);
+                         md.mesh.vertexonsurface=project3d(md,'vector',ones(md.mesh.numberofvertices2d,1),'type','node','layer',md.mesh.numberoflayers);
+                         %elementstype
+                         if ~isnan(md.flowequation.element_equation)
+                                 oldelements_type=md.flowequation.element_equation;
+                                 md.flowequation.element_equation=zeros(number_el3d,1);
+                                 md.flowequation.element_equation=project3d(md,'vector',oldelements_type,'type','element');
+                         end
+                         %verticestype
+                         if ~isnan(md.flowequation.vertex_equation)
+                                 oldvertices_type=md.flowequation.vertex_equation;
+                                 md.flowequation.vertex_equation=zeros(number_nodes3d,1);
+                                 md.flowequation.vertex_equation=project3d(md,'vector',oldvertices_type,'type','node');
+                         end
+                         md.flowequation.bordermacayeal=project3d(md,'vector',md.flowequation.bordermacayeal,'type','node');
+                         md.flowequation.borderpattyn=project3d(md,'vector',md.flowequation.borderpattyn,'type','node');
+                         md.flowequation.borderstokes=project3d(md,'vector',md.flowequation.borderstokes,'type','node');
+                         %boundary conditions
+                         md.diagnostic.spcvx=project3d(md,'vector',md.diagnostic.spcvx,'type','node');
+                         md.diagnostic.spcvy=project3d(md,'vector',md.diagnostic.spcvy,'type','node');
+                         md.diagnostic.spcvz=project3d(md,'vector',md.diagnostic.spcvz,'type','node');
+                         md.thermal.spctemperature=project3d(md,'vector',md.thermal.spctemperature,'type','node','layer',md.mesh.numberoflayers,'padding',NaN);
+                         md.prognostic.spcthickness=project3d(md,'vector',md.prognostic.spcthickness,'type','node');
+                         md.balancethickness.spcthickness=project3d(md,'vector',md.balancethickness.spcthickness,'type','node');
+                         md.diagnostic.referential=project3d(md,'vector',md.diagnostic.referential,'type','node');
+                         %in 3d, pressureload: [node1 node2 node3 node4 element]
+                         pressureload_layer1=[md.diagnostic.icefront(:,1:2)  md.diagnostic.icefront(:,2)+md.mesh.numberofvertices2d  md.diagnostic.icefront(:,1)+md.mesh.numberofvertices2d  md.diagnostic.icefront(:,3:4)]; %Add two columns on the first layer
+                         pressureload=[];
+                         for i=1:numlayers-1,
+                                 pressureload=[pressureload ;pressureload_layer1(:,1:4)+(i-1)*md.mesh.numberofvertices2d pressureload_layer1(:,5)+(i-1)*md.mesh.numberofelements2d pressureload_layer1(:,6)];
+                         end
+                         md.diagnostic.icefront=pressureload;
+                         %connectivity
+                         md.mesh.elementconnectivity=repmat(md.mesh.elementconnectivity,numlayers-1,1);
+                         md.mesh.elementconnectivity(find(md.mesh.elementconnectivity==0))=NaN;
+                         for i=2:numlayers-1,
+                                 md.mesh.elementconnectivity((i-1)*md.mesh.numberofelements2d+1:(i)*md.mesh.numberofelements2d,:)...
+                                         =md.mesh.elementconnectivity((i-1)*md.mesh.numberofelements2d+1:(i)*md.mesh.numberofelements2d,:)+md.mesh.numberofelements2d;
+                         end
+                         md.mesh.elementconnectivity(find(isnan(md.mesh.elementconnectivity)))=0;
+                         %materials
+                         md.materials.rheology_B=project3d(md,'vector',md.materials.rheology_B,'type','node');
+                         md.materials.rheology_n=project3d(md,'vector',md.materials.rheology_n,'type','element');
+                         %parameters
+                         md.geometry.surface=project3d(md,'vector',md.geometry.surface,'type','node');
+                         md.geometry.thickness=project3d(md,'vector',md.geometry.thickness,'type','node');
+                         md.geometry.hydrostatic_ratio=project3d(md,'vector',md.geometry.hydrostatic_ratio,'type','node');
+                         md.geometry.bed=project3d(md,'vector',md.geometry.bed,'type','node');
+                         md.geometry.bathymetry=project3d(md,'vector',md.geometry.bathymetry,'type','node');
+                         md.mesh.vertexonboundary=project3d(md,'vector',md.mesh.vertexonboundary,'type','node');
+                         md.mask.elementonfloatingice=project3d(md,'vector',md.mask.elementonfloatingice,'type','element');
+                         md.mask.vertexonfloatingice=project3d(md,'vector',md.mask.vertexonfloatingice,'type','node');
+                         md.mask.elementongroundedice=project3d(md,'vector',md.mask.elementongroundedice,'type','element');
+                         md.mask.vertexongroundedice=project3d(md,'vector',md.mask.vertexongroundedice,'type','node');
+                         md.mask.elementonwater=project3d(md,'vector',md.mask.elementonwater,'type','element');
+                         md.mask.vertexonwater=project3d(md,'vector',md.mask.vertexonwater,'type','node');
+                         if ~isnan(md.inversion.cost_functions_coefficients),md.inversion.cost_functions_coefficients=project3d(md,'vector',md.inversion.cost_functions_coefficients,'type','node');end;
+                         if ~isnan(md.inversion.min_parameters),md.inversion.min_parameters=project3d(md,'vector',md.inversion.min_parameters,'type','node');end;
+                         if ~isnan(md.inversion.max_parameters),md.inversion.max_parameters=project3d(md,'vector',md.inversion.max_parameters,'type','node');end;
+                         if ~isnan(md.qmu.partition),md.qmu.partition=project3d(md,'vector',md.qmu.partition','type','node');end
+                         if(md.surfaceforcings.isdelta18o),md.surfaceforcings.temperatures_lgm=project3d(md,'vector',md.surfaceforcings.temperatures_lgm,'type','node');end
+                         if(md.surfaceforcings.isdelta18o),md.surfaceforcings.temperatures_presentday=project3d(md,'vector',md.surfaceforcings.temperatures_presentday,'type','node');end
+                         if(md.surfaceforcings.isdelta18o),md.surfaceforcings.precipitations_presentday=project3d(md,'vector',md.surfaceforcings.precipitations_presentday,'type','node');end
+                         %Put lithostatic pressure if there is an existing pressure
+                         if ~isnan(md.initialization.pressure),
+                                 md.initialization.pressure=md.constants.g*md.materials.rho_ice*(md.geometry.surface-md.mesh.z);
+                         end
+                         %special for thermal modeling:
+                         md.basalforcings.melting_rate=project3d(md,'vector',md.basalforcings.melting_rate,'type','node','layer',1);
+                         if ~isnan(md.basalforcings.geothermalflux)
+                                 md.basalforcings.geothermalflux=project3d(md,'vector',md.basalforcings.geothermalflux,'type','node','layer',1); %bedrock only gets geothermal flux
+                         end
+                         %increase connectivity if less than 25:
+                         if md.mesh.average_vertex_connectivity<=25,
+                                 md.mesh.average_vertex_connectivity=100;
+                         end
+                        end % }}}
                  function md = structtomodel(md,structmd) % {{{
 …
                          md.settings         = settings();
                          md.solver           = solver();
                          if ismumps,
                                  md.solver           = addoptions(md.solver,DiagnosticVertAnalysisEnum,mumpsoptions);
+                         if ismumps(),
+                                 md.solver           = addoptions(md.solver,DiagnosticVertAnalysisEnum(),mumpsoptions());
                          else
                                  md.solver           = addoptions(md.solver,DiagnosticVertAnalysisEnum,iluasmoptions);
+                                 md.solver           = addoptions(md.solver,DiagnosticVertAnalysisEnum(),iluasmoptions());
                          end
                          md.cluster          = generic();

issm/branches/trunk-jpl-damage/src/m/classes/model/model.py

-              r12946
+              r13101
 from private import private
 from EnumDefinitions import *
+from ismumps import *
+from mumpsoptions import *
+from iluasmoptions import *
 #}}}
 …
                 self.settings         = settings()
                 self.solver           = solver()
+#               need EnumToString for these to work
+#               if ismumps:
+#                       md.solver.addoptions(DiagnosticVertAnalysisEnum(),mumpsoptions)
+#               else:
+#                       md.solver.addoptions(DiagnosticVertAnalysisEnum(),iluasmoptions)
+                if ismumps():
+                        self.solver.addoptions(DiagnosticVertAnalysisEnum(),mumpsoptions())
+                else:
+                        self.solver.addoptions(DiagnosticVertAnalysisEnum(),iluasmoptions())
                 self.cluster          = generic()
 …
                 string="%s\n%s" % (string,"%19s: %-22s -- %s" % ("inversion","[%s,%s]" % ("1x1",obj.inversion.__class__.__name__),"parameters for inverse methods"))
                 string="%s\n%s" % (string,"%19s: %-22s -- %s" % ("qmu","[%s,%s]" % ("1x1",obj.qmu.__class__.__name__),"dakota properties"))
                 string="%s\n%s" % (string,"%19s: %-22s -- %s" % ("results","[%s,%s]" % ("1x1",obj.results.__class__.__name__),"model results'"))
+                string="%s\n%s" % (string,"%19s: %-22s -- %s" % ("results","[%s,%s]" % ("1x1",obj.results.__class__.__name__),"model results"))
                 string="%s\n%s" % (string,"%19s: %-22s -- %s" % ("radaroverlay","[%s,%s]" % ("1x1",obj.radaroverlay.__class__.__name__),"radar image for plot overlay"))
                 string="%s\n%s" % (string,"%19s: %-22s -- %s" % ("miscellaneous","[%s,%s]" % ("1x1",obj.miscellaneous.__class__.__name__),"miscellaneous fields"))

issm/branches/trunk-jpl-damage/src/m/classes/model/planet.m

-              r12878
+              r13101
 classdef planet < model
     properties (SetAccess=public) %Planet fields
+                 % {{{
+                 %Planet specific fields
+                 r=NaN;
+                 theta=NaN;
+                 phi=NaN;
+         end
+         methods
+                 function md = planet(varargin) % {{{
+                         switch nargin
+                                 case 0
+                                         md=setdefaultparameters(md);
+                                 otherwise
+                                         error('planet constructor error message: 0 of 1 argument only in input.');
+                                 end
+                 end
+                 %}}}
+                 function md = setdefaultparameters(md) % {{{
+                         %initialize subclasses
+                         md.mesh             = planetmesh();
+                         md.mask             = mask();
+                         md.constants        = constants();
+                         md.geometry         = geometry();
+                         md.initialization   = initialization();
+                         md.surfaceforcings  = surfaceforcings();
+                         md.basalforcings    = basalforcings();
+                         md.friction         = friction();
+                         md.rifts            = rifts();
+                         md.timestepping     = timestepping();
+                         md.groundingline    = groundingline();
+                         md.materials        = materials();
+                         md.flowequation     = flowequation();
+                         md.debug            = debug();
+                         md.verbose          = verbose('solution',true,'qmu',true,'control',true);
+                         md.settings         = settings();
+                         md.solver           = solver();
+                         if ismumps(),
+                                 md.solver           = addoptions(md.solver,DiagnosticVertAnalysisEnum(),mumpsoptions());
+                         else
+                                 md.solver           = addoptions(md.solver,DiagnosticVertAnalysisEnum(),iluasmoptions());
+                         end
+                         md.cluster          = generic();
+                         md.balancethickness = balancethickness();
+                         md.diagnostic       = diagnostic();
+                         md.hydrology        = hydrology();
+                         md.prognostic       = prognostic();
+                         md.thermal          = thermal();
+                         md.steadystate      = steadystate();
+                         md.transient        = transient();
+                         md.autodiff         = autodiff();
+                         md.flaim            = flaim();
+                         md.inversion        = inversion();
+                         md.qmu              = qmu();
+                         md.radaroverlay     = radaroverlay();
+                         md.results          = struct();
+                         md.miscellaneous    = miscellaneous();
+                         md.private          = private();
+                 end
                  %}}}
          end
-         methods
-                function md=planetmesh(md,varargin) % {{{
-                %PLANETMESH: build 2d shell mesh
+                %
-                % Usage: md=planetmesh(md,'method','mixed','radius',6378000,'angleresol',1);
-                %        md=planetmesh(md,'method','tria','shape','iso','radius',6378000,'refinement',5);
+                %
-                %recover options
-                options=pairoptions(varargin{:});
-                method=getfieldvalue(options,'method','mixed');
-                if strcmpi(method,'mixed'),
-                        %recover radius and angleresol:
-                        radius=getfieldvalue(options,'radius',6378000); %earth radius as default
-                        angleresol=getfieldvalue(options,'angleresol',10); %10 degree resolution
-                        %call mixed mesh
-                        md=planetmixedmesh(md,radius,angleresol);
-                else
-                        %recover radius, shape and level of refinmenet
-                        radius=getfieldvalue(options,'radius',6378000); %earth radius as default
-                        refinement=getfieldvalue(options,'refinement',5); %refine 5 times
-                        shape=getfieldvalue(options,'shape','ico');
-                        %call triangular mesh
-                        md=planettrimesh(md,shape,radius,refinement);
-                end
-                end
-                % }}}
-         end
  end

issm/branches/trunk-jpl-damage/src/m/classes/modellist.m

-              r12168
+              r13101
         end
         methods
+                function md_list=modelsextract(md,flags,minel,varargin) % {{{
+                        %modelsextract - extract several self contained models according to a list of element flags.
+                        %
+                        %   The difference between this routine and the modelextract.m routine (without an 's') is that
+                        %   as many models are extracted as there are closed contours defined in area.
+                        %   This routine is needed for example when doing data assimilation of ice shelves in Antarctica.
+                        %   Many independent ice shelves are present, and we don't want data assimilation on one ice shelf
+                        %   to be hindered by another totally independent ice shelf.
+                        %
+                        %   Usage:
+                        %      md_list=modelsextract(md,elementfalgs,minel);
+                        %
+                        %   Examples:
+                        %      md_list=modelsextract(md,md.mask.elementonfloatingice,1000);
+                        %
+                        %   See also: EXTRUDE, COLLAPSE, MODELEXTRACT
+                        disp('selecting pools of elements');
+                        %go through flags and build as many independent element flags as there are groups of connected 1s
+                        %in flags.
+                        %2D or 3D?
+                        if md.mesh.dimension==3,
+                                numberofelements=md.mesh.numberofelements2d; %this will be forgotten when we get out.
+                                flags=project2d(md,flags,1);
+                        else
+                                numberofelements=md.mesh.numberofelements;
+                        end
+                        %recover extra arguments:
+                        distance=0;
+                        if nargin==4,
+                                distance=varargin{1};
+                        end
+                        flag_list=cell(0,1);
+                        for i=1:size(flags,1),
+                                if (flags(i)),
+                                        %ok, we are sure element i is part of a new pool.
+                                        pool=zeros(numberofelements,1);
+                                        pool=PropagateFlagsFromConnectivity(md.mesh.elementconnectivity,pool,i,flags);
+                                        flag_list{end+1,1}=pool;
+                                        %speed up rest of computation by taking pool out of flags:
+                                        pos=find(pool);flags(pos)=0;
+                                end
+                        end
+                        %go through flag_list and discard any pool of less than minel elements:
+                        ex_pos=[];
+                        for i=1:length(flag_list),
+                                if length(find(flag_list{i}))<minel,
+                                        ex_pos=[ex_pos; i];
+                                end
+                        end
+                        flag_list(ex_pos)=[];
+                        %now, if distance was specified, expand the flag_list by distance km:
+                        if distance,
+                                for i=1:length(flag_list),
+                                        flag_list{i}=PropagateFlagsUntilDistance(md,flag_list{i},distance);
+                                end
+                        end
+                        %now, go use the pools of flags to extract models:
+                        disp(['extracting ' num2str(size(flag_list,1)) ' models']);
+                        models=cell(0,1);
+                        for i=1:size(flag_list,1),
+                                disp(['   ' num2str(i) '/' num2str(size(flag_list,1))]);
+                                if md.mesh.dimension==3,
+                                        flags2d=flag_list{i};
+                                        realflags=project3d(md,flags2d,'element');
+                                else
+                                        realflags=flag_list{i};
+                                end
+                                models{end+1,1}=modelextract(md,realflags);
+                        end
+                        %return model list
+                        md_list=modellist(models);
+                end %end of this function }}}
+                function md_list=modelsextractfromdomains(md,directory) % {{{
+                        %modelsextractfromdomains- extract several self contained models according to a list of domains
+                        %
+                        %   Usage:
+                        %      md_list=modelsextractfromdomains(md,'Basins/');
+                        %
+                        %   Examples:
+                        %      md_list=modelsextract(md,'Basins/');
+                        %
+                        %   See also: MODELSEXTRACTS, MODELEXTRACT
+                        %go into directory and get list of files.
+                        cd(directory);
+                        basins=listfiles;
+                        cd ..
+                        models=cell(0,1);
+                        for i=1:length(basins),
+                                models{end+1,1}=modelextract(md,[directory '/' basins{i}]);
+                        end
+                        %return model list:
+                        md_list=modellist(models);
+                end % }}}
                 function obj = modellist(varargin) % {{{
 …
         end
 end
+function BuildMultipleQueueingScript(cluster,name,executionpath,codepath)% {{{
+%BUILDMULTIPLEQUEUEINGSCRIPT -
+%
+%   Usage:
+%      BuildMultipleQueueingScript(executionpath,codepath)
+disp('building queueing script');
+%First try and figure out if there is a special script for this particular cluster
+function_name=['BuildMultipleQueueingScript' cluster];
+%some specific treatment of identical cluster, gemini, castor and pollux
+if strcmpi(cluster,'castor') || strcmpi(cluster,'pollux'),
+        function_name='BuildMultipleQueueingScriptgemini';
+end
+if exist(function_name,'file'),
+        %Call this function:
+        eval([function_name '(name,executionpath,codepath);']);
+else
+        %Call the generic BuildQueueingScript:
+        BuildMultipleQueueingScriptGeneric(name,executionpath,codepath);
+end
+end % }}}
+function BuildQueueingScriptgemini(name,executionpath,codepath)% {{{
+%BUILDQUEUEINGSCRIPTGEMINI - ...
+%
+%   Usage:
+%      BuildQueueingScriptgemini(md,executionpath,codepath)
+scriptname=[name '.queue'];
+fid=fopen(scriptname,'w');
+if fid==-1,
+        error(['BuildQueueingScriptgeminierror message: could not open ' scriptname ' file for ascii writing']);
+end
+fprintf(fid,'#!/bin/sh\n');
+fprintf(fid,'cd %s\n',executionpath);
+fprintf(fid,'mkdir %s\n',name);
+fprintf(fid,'cd %s\n',name);
+fprintf(fid,'mv ../ModelList.tar.gz ./\n');
+fprintf(fid,'tar -zxvf ModelList.tar.gz\n');
+fprintf(fid,'foreach i (%s-*vs*.queue)\n',name);
+fprintf(fid,'qsub $i\n');
+fprintf(fid,'end\n');
+fclose(fid);
+end% }}}
+function LaunchMultipleQueueJob(cluster,name,executionpath)% {{{
+%LAUNCHMULTIPLEQUEUEJOB - ...
+%
+%   Usage:
+%      LaunchMultipleQueueJob(executionpath)
+%First try and figure out if there is a special script for thie particular cluster
+function_name=['LaunchMultipleQueueJob' cluster];
+%some specific treatment of identical cluster, gemini, castor and pollux
+if strcmpi(cluster,'castor') || strcmpi(cluster,'pollux'),
+        function_name='LaunchMultipleQueueJobgemini';
+end
+if exist(function_name,'file'),
+        %Call this function:
+        eval([function_name '(cluster,name,executionpath);']);
+else
+        %Call the generic LaunchMultipleQueueJob:
+        LaunchMultipleQueueJobGeneric(cluster,name,executionpath);
+end
+end% }}}
+function md=LaunchMultipleQueueJobgemini(cluster,name,executionpath)% {{{
+%LAUNCHMULTIPLEQUEUEJOBGEMINI - Launch multiple queueing script on Gemini cluster
+%
+%   Usage:
+%      LaunchMultipleQueueJobgemini(cluster,name,executionpath)
+%first, check we have the binary file and the queueing script
+if ~exist([ name '.queue'],'file'),
+        error('LaunchMultipleQueueJobgemini error message: queueing script issing, cannot go forward');
+end
+if ~exist('ModelList.tar.gz','file'),
+        error('LaunchMultipleQueueJobgemini error message: inputs models file missing, cannot go forward');
+end
+%upload both files to cluster
+disp('uploading input file,  queueing script and variables script');
+eval(['!scp ModelList.tar.gz ' name '.queue '  cluster ':' executionpath]);
+disp('launching solution sequence on remote cluster');
+issmssh(cluster,login,['"cd ' executionpath ' && source ' name '.queue "']);
+end% }}}

issm/branches/trunk-jpl-damage/src/m/classes/pairoptions.py

-              r12946
+              r13101
                 #go through arg and build list of objects
                 for i in xrange(numoptions):
                         if isinstance(arg[2*i],str):
+                        if isinstance(arg[2*i],(str,unicode)):
                                 self.list[arg[2*i]] = arg[2*i+1];
                         else:
 …
         def addfield(self,field,value):    # {{{
                 """ADDFIELD - add a field to an options list"""
                 if isinstance(field,str):
+                if isinstance(field,(str,unicode)):
                         if field in self.list:
                                 print "WARNING: field '%s' with value=%s exists and will be overwritten with value=%s." % (field,str(self.list[field]),str(value))
 …
         def addfielddefault(self,field,value):    # {{{
                 """ADDFIELDDEFAULT - add a field to an options list if it does not exist"""
                 if isinstance(field,str):
                         if not field in self.list:
+                if isinstance(field,(str,unicode)):
+                        if field not in self.list:
                                 self.list[field] = value
         # }}}
 …
                         s+="   list: (%ix%i)\n\n" % (len(self.list),2)
                         for item in self.list.iteritems():
                                 if   isinstance(item[1],str):
+                                if   isinstance(item[1],(str,unicode)):
                                         s+="     field: %-10s value: '%s'\n" % (item[0],item[1])
                                 elif isinstance(item[1],(bool,int,long,float)):
 …
                 if field == None or field == '':
                         raise ValueError('exist error message: bad usage');
                 if not isinstance(field,str):
+                if not isinstance(field,(str,unicode)):
                         raise TypeError("exist error message: field '%s' should be a string." % str(field));
 …
                 if field == None or field == '':
                         raise ValueError('getfieldvalue error message: bad usage');
                 if not isinstance(field,str):
+                if not isinstance(field,(str,unicode)):
                         raise TypeError("getfieldvalue error message: field '%s' should be a string." % str(field));
 …
                         #Write option value
                         if   isinstance(value,str):
+                        if   isinstance(value,(str,unicode)):
                                 WriteData(fid,'enum',(firstindex-1)+2*i+2,'data',value,'format','String')
                         elif isinstance(value,(bool,int,long,float)):

issm/branches/trunk-jpl-damage/src/m/classes/planetmesh.m

-              r12946
+              r13101
 classdef planetmesh
         properties (SetAccess=public)
+                x                           = NaN;
+                y                           = NaN;
+                z                           = NaN;
                 r                           = NaN;
                 theta                       = NaN;
 …
                 function md = checkconsistency(obj,md,solution,analyses) % {{{
+                        md = checkfield(md,'planetmesh.x','NaN',1,'size',[md.planetmesh.numberofvertices 1]);
+                        md = checkfield(md,'planetmesh.y','NaN',1,'size',[md.planetmesh.numberofvertices 1]);
+                        md = checkfield(md,'planetmesh.z','NaN',1,'size',[md.planetmesh.numberofvertices 1]);
                         md = checkfield(md,'planetmesh.r','NaN',1,'size',[md.planetmesh.numberofvertices 1]);
                         md = checkfield(md,'planetmesh.theta','NaN',1,'size',[md.planetmesh.numberofvertices 1]);
 …
                         %Solution specific checks
                         switch(solution),
                                 case PrognosticSolutionEnum,
+                                case PrognosticSolutionEnum(),
                                         if md.prognostic.stabilization==3,
                                                 md = checkfield(md,'planetmesh.dimension','values',2,'message','Discontinuous Galerkin only supported for 2d planetmeshes');
                                         end
                                 case TransientSolutionEnum,
+                                case TransientSolutionEnum(),
                                         if md.transient.isprognostic & md.prognostic.stabilization==3,
                                                 md = checkfield(md,'planetmesh.dimension','values',2,'message','Discontinuous Galerkin only supported for 2d planetmeshes');
                                         end
                                 case ThermalSolutionEnum,
+                                case ThermalSolutionEnum(),
                                         md = checkfield(md,'planetmesh.dimension','values',3,'message','thermal solution only supported on 3d planetmeshes');
                         end
 …
                         fielddisplay(obj,'numberofvertices','number of vertices');
                         fielddisplay(obj,'elements','index into (x,y,z), coordinates of the vertices');
+                        fielddisplay(obj,'x','vertices x coordinate');
+                        fielddisplay(obj,'y','vertices y coordinate');
+                        fielddisplay(obj,'z','vertices z coordinate');
                         fielddisplay(obj,'r','vertices r coordinate');
                         fielddisplay(obj,'theta','vertices theta coordinate');
 …
                 end % }}}
                 function marshall(obj,fid) % {{{
+                        WriteData(fid,'object',obj,'fieldname','x','format','DoubleMat','mattype',1);
+                        WriteData(fid,'object',obj,'fieldname','y','format','DoubleMat','mattype',1);
+                        WriteData(fid,'object',obj,'fieldname','z','format','DoubleMat','mattype',1);
                         WriteData(fid,'object',obj,'fieldname','r','format','DoubleMat','mattype',1);
                         WriteData(fid,'object',obj,'fieldname','theta','format','DoubleMat','mattype',1);

issm/branches/trunk-jpl-damage/src/m/classes/private.py

-              r12946
+              r13101
 #module imports
 from fielddisplay import fielddisplay
+from EnumDefinitions import *
+from checkfield import *
+class private:
+class private(object):
+        """
+        PRIVATE class definition
+           Usage:
+              private=private();
+        """
         #properties
         def __init__(self):
                 # {{{ Properties
                 self.isconsistent = True;
+                self.isconsistent = True
                 self.runtimename  = ''
                 self.bamg         = {}
                 self.solution     = '';
+                self.solution     = ''
                 #set defaults
 …
                 #}}}
         def __repr__(obj):
+        def __repr__(self):
                 # {{{ Display
                 string='   private parameters: do not change'
                 string="%s\n%s"%(string,fielddisplay(obj,'isconsistent','is model self consistent'))
                 string="%s\n%s"%(string,fielddisplay(obj,'runtimename','name of the run launched'))
                 string="%s\n%s"%(string,fielddisplay(obj,'bamg','structure with mesh properties constructed if bamg is used to mesh the domain'))
                 string="%s\n%s"%(string,fielddisplay(obj,'solution','type of solution launched'))
+                string="%s\n%s"%(string,fielddisplay(self,'isconsistent','is model self consistent'))
+                string="%s\n%s"%(string,fielddisplay(self,'runtimename','name of the run launched'))
+                string="%s\n%s"%(string,fielddisplay(self,'bamg','structure with mesh properties constructed if bamg is used to mesh the domain'))
+                string="%s\n%s"%(string,fielddisplay(self,'solution','type of solution launched'))
                 return string
                 #}}}
         def setdefaultparameters(obj):
+        def setdefaultparameters(self):
                 # {{{setdefaultparameters
                 return obj
+                return self
         #}}}
+        def checkconsistency(self,md,solution,analyses):    # {{{
+                return md
+        # }}}

issm/branches/trunk-jpl-damage/src/m/classes/prognostic.m

-              r12878
+              r13101
                 function md = checkconsistency(obj,md,solution,analyses) % {{{
                         %Early return,
                         if ~ismember(PrognosticAnalysisEnum,analyses) |  (solution==TransientSolutionEnum & md.transient.isprognostic==0), return; end
+                        %Early return
+                        if ~ismember(PrognosticAnalysisEnum(),analyses) |  (solution==TransientSolutionEnum() & md.transient.isprognostic==0), return; end
                         md = checkfield(md,'prognostic.spcthickness','forcing',1);
 …
                         WriteData(fid,'object',obj,'fieldname','spcthickness','format','DoubleMat','mattype',1);
                         WriteData(fid,'object',obj,'fieldname','min_thickness','format','Double');
                         WriteData(fid,'data',StringToEnum(obj.hydrostatic_adjustment),'format','Integer','enum',PrognosticHydrostaticAdjustmentEnum);
+                        WriteData(fid,'data',StringToEnum(obj.hydrostatic_adjustment),'format','Integer','enum',PrognosticHydrostaticAdjustmentEnum());
                         WriteData(fid,'object',obj,'fieldname','stabilization','format','Integer');
                         WriteData(fid,'object',obj,'fieldname','vertex_pairing','format','DoubleMat','mattype',3);

issm/branches/trunk-jpl-damage/src/m/classes/prognostic.py

-              r12168
+              r13101
 #module imports
 from fielddisplay import fielddisplay
+from EnumDefinitions import *
+from StringToEnum import StringToEnum
+from checkfield import *
+from WriteData import *
+class prognostic:
+class prognostic(object):
+        """
+        PROGNOSTIC class definition
+           Usage:
+              prognostic=prognostic();
+        """
         #properties
         def __init__(self):
 …
                 #}}}
         def __repr__(obj):
+        def __repr__(self):
                 # {{{ Display
                 string='   Prognostic solution parameters:'
                 string="%s\n\n%s"%(string,fielddisplay(obj,'spcthickness','thickness constraints (NaN means no constraint)'))
                 string="%s\n%s"%(string,fielddisplay(obj,'min_thickness','minimum ice thickness allowed'))
                 string="%s\n%s"%(string,fielddisplay(obj,'hydrostatic_adjustment','adjustment of ice shelves surface and bed elevations: ''Incremental'' or ''Absolute'' '))
                 string="%s\n%s"%(string,fielddisplay(obj,'stabilization','0->no, 1->artificial_diffusivity, 2->streamline upwinding, 3->discontinuous Galerkin'))
+                string="%s\n\n%s"%(string,fielddisplay(self,'spcthickness','thickness constraints (NaN means no constraint)'))
+                string="%s\n%s"%(string,fielddisplay(self,'min_thickness','minimum ice thickness allowed'))
+                string="%s\n%s"%(string,fielddisplay(self,'hydrostatic_adjustment','adjustment of ice shelves surface and bed elevations: ''Incremental'' or ''Absolute'' '))
+                string="%s\n%s"%(string,fielddisplay(self,'stabilization','0->no, 1->artificial_diffusivity, 2->streamline upwinding, 3->discontinuous Galerkin'))
                 return string
                 #}}}
         def setdefaultparameters(obj):
+        def setdefaultparameters(self):
                 # {{{setdefaultparameters
                 #Type of stabilization to use 0:nothing 1:artificial_diffusivity 3:Discontinuous Galerkin
                 obj.stabilization=1
+                self.stabilization=1
                 #Factor applied to compute the penalties kappa=max(stiffness matrix)*10^penalty_factor
                 obj.penalty_factor=3
+                self.penalty_factor=3
                 #Minimum ice thickness that can be used
                 obj.min_thickness=1
+                self.min_thickness=1
                 #Hydrostatic adjustment
                 obj.hydrostatic_adjustment='Absolute'
+                self.hydrostatic_adjustment='Absolute'
                 return obj
+                return self
         #}}}
+        def checkconsistency(self,md,solution,analyses):    # {{{
+                #Early return
+                if (PrognosticAnalysisEnum() not in analyses) or (solution==TransientSolutionEnum() and not md.transient.isprognostic):
+                        return md
+                md = checkfield(md,'prognostic.spcthickness','forcing',1)
+                md = checkfield(md,'prognostic.hydrostatic_adjustment','values',['Absolute','Incremental'])
+                md = checkfield(md,'prognostic.stabilization','values',[0,1,2,3])
+                md = checkfield(md,'prognostic.min_thickness','>',0)
+                return md
+        # }}}
+        def marshall(self,fid):    # {{{
+                WriteData(fid,'object',self,'fieldname','spcthickness','format','DoubleMat','mattype',1)
+                WriteData(fid,'object',self,'fieldname','min_thickness','format','Double')
+                WriteData(fid,'data',StringToEnum(self.hydrostatic_adjustment)[0],'format','Integer','enum',PrognosticHydrostaticAdjustmentEnum())
+                WriteData(fid,'object',self,'fieldname','stabilization','format','Integer')
+                WriteData(fid,'object',self,'fieldname','vertex_pairing','format','DoubleMat','mattype',3)
+                WriteData(fid,'object',self,'fieldname','penalty_factor','format','Double')
+        # }}}

issm/branches/trunk-jpl-damage/src/m/classes/qmu.m

-              r12878
+              r13101
                                         md = checkmessage(md,['user supplied partition for qmu analysis should have size md.mesh.numberofvertices x 1 ']);
                                 end
-                                if find(md.qmu.partition)>=md.mesh.numberofvertices,
-                                        md = checkmessage(md,['user supplied partition should be indexed from 0 (c-convention)']);
-                                end
                                 if min(md.qmu.partition)~=0,
                                         md = checkmessage(md,['partition vector not indexed from 0 on']);
-                                end
-                                if max(md.qmu.partition)>=md.mesh.numberofvertices,
-                                        md = checkmessage(md,['partition vector cannot have maximum index larger than number of nodes']);
-                                end
-                                if ~isempty(find(md.qmu.partition<0)),
-                                        md = checkmessage(md,['partition vector cannot have values less than 0']);
-                                end
-                                if ~isempty(find(md.qmu.partition>=md.qmu.numberofpartitions)),
-                                        md = checkmessage(md,['partition vector cannot have values more than md.qmu.numberofpartitions-1']);
                                 end
                                 if max(md.qmu.partition)>=md.qmu.numberofpartitions,
 …
                                 end
                         end
                         fielddisplay(obj,'partition','user provided mesh partitionition, defaults to metis if not specified')
                         fielddisplay(obj,'numberofpartitions','number of partitions for semi-descrete qmu')
+                        fielddisplay(obj,'partition','user provided mesh partitioning, defaults to metis if not specified')
+                        fielddisplay(obj,'numberofpartitions','number of partitions for semi-discrete qmu')
                         fielddisplay(obj,'variabledescriptors','');
                         fielddisplay(obj,'responsedescriptors','');

issm/branches/trunk-jpl-damage/src/m/classes/qmu.py

-              r12168
+              r13101
 #module imports
+import numpy
 from fielddisplay import fielddisplay
+from EnumDefinitions import *
+from checkfield import *
+from WriteData import *
+from MatlabFuncs import *
+class qmu:
+class qmu(object):
+        """
+        QMU class definition
+           Usage:
+              qmu=qmu();
+        """
         #properties
         def __init__(self):
 …
                 #}}}
+        def __repr__(obj):
+                # {{{ Display
+                string="   qmu parameters: not implemented yet!"
+                return string
+                #}}}
+        def setdefaultparameters(obj):
+        def setdefaultparameters(self):
                 # {{{setdefaultparameters
                 return obj
+                return self
         #}}}
+        def checkconsistency(self,md,solution,analyses):    # {{{
+                #Early return
+                if not md.qmu.isdakota:
+                        return
+                if not md.qmu.params.evaluation_concurrency==1:
+                        md.checkmessage("concurrency should be set to 1 when running dakota in library mode")
+                if md.qmu.partition:
+                        if not numpy.size(md.qmu.partition)==md.mesh.numberofvertices:
+                                md.checkmessage("user supplied partition for qmu analysis should have size md.mesh.numberofvertices x 1")
+                        if not min(md.qmu.partition)==0:
+                                md.checkmessage("partition vector not indexed from 0 on")
+                        if max(md.qmu.partition)>=md.qmu.numberofpartitions:
+                                md.checkmessage("for qmu analysis, partitioning vector cannot go over npart, number of partition areas")
+                if not strcmpi(md.cluster.name,'none'):
+                        if not md.settings.waitonlock:
+                                md.checkmessage("waitonlock should be activated when running qmu in parallel mode!")
+                return md
+        # }}}
+        def __repr__(self):    # {{{
+                s ='   qmu parameters:\n'
+                s+="%s\n" % fielddisplay(self,'isdakota','is qmu analysis activated?')
+                for i,variable in enumerate(self.variables):
+                        s+="         variables%s:  (arrays of each variable class)\n" % \
+                                string_dim(self.variables,i)
+                        fnames=vars(variable)
+                        maxlen=0
+                        for fname in fnames:
+                                maxlen=max(maxlen,len(fname))
+                        for fname in fnames:
+                                s+="'            %-*s:    [%ix%i]    '%s'\n" % \
+                                        (maxlen+1,fname,size(getattr(variable,fname)),type(getattr(variable,fname)))
+                for i,response in enumerate(self.responses):
+                        s+="         responses%s:  (arrays of each response class)\n" % \
+                                string_dim(self.responses,i)
+                        fnames=vars(response)
+                        maxlen=0
+                        for fname in fnames:
+                                maxlen=max(maxlen,len(fname))
+                        for fname in fnames:
+                                s+="            %-*s:    [%ix%i]    '%s'\n" % \
+                                        (maxlen+1,fname,size(getattr(response,fname)),type(getattr(response,fname)))
+                s+="%s\n" % fielddisplay(self,'numberofresponses','number of responses')
+                for i,method in enumerate(self.method):
+                        if isinstance(method,'dakota_method'):
+                                s+="            method%s :    '%s'\n" % \
+                                        (string_dim(method,i),method.method)
+                for i,param in enumerate(self.params):
+                        s+="         params%s:  (array of method-independent parameters)\n" % \
+                                string_dim(self.params,i)
+                        fnames=vars(param)
+                        maxlen=0
+                        for fname in fnames:
+                                maxlen=max(maxlen,len(fname))
+                        for fname in fnames:
+                                s+="            %-*s: %s\n" % \
+                                        (maxlen+1,fname,any2str(getattr(param,fname)))
+                for i,result in enumerate(self.results):
+                        s+="         results%s:  (information from dakota files)\n" % \
+                                string_dim(self.results,i)
+                        fnames=vars(result)
+                        maxlen=0
+                        for fname in fnames:
+                                maxlen=max(maxlen,len(fname))
+                        for fname in fnames:
+                                s+="            %-*s:    [%ix%i]    '%s'\n" % \
+                                        (maxlen+1,fname,size(getattr(result,fname)),type(getattr(result,fname)))
+                s+="%s\n" % fielddisplay(self,'partition','user provided mesh partitioning, defaults to metis if not specified')
+                s+="%s\n" % fielddisplay(self,'numberofpartitions','number of partitions for semi-discrete qmu')
+                s+="%s\n" % fielddisplay(self,'variabledescriptors','')
+                s+="%s\n" % fielddisplay(self,'responsedescriptors','')
+                s+="%s\n" % fielddisplay(self,'method','array of dakota_method class')
+                s+="%s\n" % fielddisplay(self,'mass_flux_profile_directory','directory for mass flux profiles')
+                s+="%s\n" % fielddisplay(self,'mass_flux_profiles','list of mass_flux profiles')
+                s+="%s\n" % fielddisplay(self,'mass_flux_segments','')
+                s+="%s\n" % fielddisplay(self,'adjacency','')
+                s+="%s\n" % fielddisplay(self,'vertex_weight','weight applied to each mesh vertex')
+                return s
+        # }}}
+        def marshall(self,fid):    # {{{
+                WriteData(fid,'object',self,'fieldname','isdakota','format','Boolean')
+                if not self.isdakota:
+                        return
+                WriteData(fid,'object',self,'fieldname','partition','format','DoubleMat','mattype',2)
+                WriteData(fid,'object',self,'fieldname','numberofpartitions','format','Integer')
+                WriteData(fid,'object',self,'fieldname','numberofresponses','format','Integer')
+                WriteData(fid,'object',self,'fieldname','variabledescriptors','format','StringArray')
+                WriteData(fid,'object',self,'fieldname','responsedescriptors','format','StringArray')
+                WriteData(fid,'object',self,'fieldname','mass_flux_segments','format','MatArray')
+        # }}}

issm/branches/trunk-jpl-damage/src/m/classes/radaroverlay.py

-              r12168
+              r13101
 from fielddisplay import fielddisplay
+class radaroverlay:
+class radaroverlay(object):
+        """
+        RADAROVERLAY class definition
+           Usage:
+              radaroverlay=radaroverlay();
+        """
         #properties
         def __init__(self):
 …
                 #}}}
         def __repr__(obj):
+        def __repr__(self):
                 # {{{ Display
                 string='   radaroverlay parameters:'
                 string="%s\n\n%s"%(string,fielddisplay(obj,'pwr','radar power image (matrix)'))
                 string="%s\n%s"%(string,fielddisplay(obj,'x','corresponding x coordinates'))
                 string="%s\n%s"%(string,fielddisplay(obj,'y','corresponding y coordinates'))
+                string="%s\n\n%s"%(string,fielddisplay(self,'pwr','radar power image (matrix)'))
+                string="%s\n%s"%(string,fielddisplay(self,'x','corresponding x coordinates'))
+                string="%s\n%s"%(string,fielddisplay(self,'y','corresponding y coordinates'))
                 return string
                 #}}}
         def setdefaultparameters(obj):
+        def setdefaultparameters(self):
                 # {{{setdefaultparameters
                 return obj
+                return self
         #}}}

issm/branches/trunk-jpl-damage/src/m/classes/rifts.m

-              r12878
+              r13101
                         end
                         WriteData(fid,'data',numrifts,'enum',RiftsNumriftsEnum,'format','Integer');
                         WriteData(fid,'data',data,'enum',RiftsRiftstructEnum,'format','DoubleMat','mattype',3);
+                        WriteData(fid,'data',numrifts,'enum',RiftsNumriftsEnum(),'format','Integer');
+                        WriteData(fid,'data',data,'enum',RiftsRiftstructEnum(),'format','DoubleMat','mattype',3);
                 end % }}}
         end

issm/branches/trunk-jpl-damage/src/m/classes/rifts.py

-              r12168
+              r13101
 #module imports
+import numpy
 from fielddisplay import fielddisplay
+from EnumDefinitions import *
+from checkfield import *
+from WriteData import *
+from isnans import *
+class rifts:
+class rifts(object):
+        """
+        RIFTS class definition
+           Usage:
+              rifts=rifts();
+        """
         #properties
         def __init__(self):
 …
                 #}}}
         def __repr__(obj):
+        def __repr__(self):
                 # {{{ Display
                 string='   rifts parameters:'
                 string="%s\n\n%s"%(string,fielddisplay(obj,'riftstruct','structure containing all rift information (vertices coordinates, segments, type of melange, ...)'))
                 string="%s\n%s"%(string,fielddisplay(obj,'riftproperties',''))
+                string="%s\n\n%s"%(string,fielddisplay(self,'riftstruct','structure containing all rift information (vertices coordinates, segments, type of melange, ...)'))
+                string="%s\n%s"%(string,fielddisplay(self,'riftproperties',''))
                 return string
                 #}}}
         def setdefaultparameters(obj):
+        def setdefaultparameters(self):
                 # {{{setdefaultparameters
                 return obj
+                return self
         #}}}
+        def checkconsistency(self,md,solution,analyses):    # {{{
+                if (not self.riftstruct) or numpy.any(isnans(self.riftstruct)):
+                        numrifts=0
+                else:
+                        numrifts=len(self.riftstruct)
+                if numrifts:
+                        if not md.mesh.dimension==2:
+                                md.checkmessage("models with rifts are only supported in 2d for now!")
+                        if not isinstance(self.riftstruct,list):
+                                md.checkmessage("rifts.riftstruct should be a structure!")
+                        if numpy.any(md.mesh.segmentmarkers>=2):
+                                #We have segments with rift markers, but no rift structure!
+                                md.checkmessage("model should be processed for rifts (run meshprocessrifts)!")
+                        md = checkfield(md,'rifts.riftstruct.fill','values',[WaterEnum(),AirEnum(),IceEnum(),MelangeEnum()])
+                else:
+                        if numpy.any(numpy.logical_not(isnans(self.riftstruct))):
+                                md.checkmessage("riftstruct shoud be NaN since numrifts is 0!")
+                return md
+        # }}}
+        def marshall(self,fid):    # {{{
+                #Process rift info
+                if (not self.riftstruct) or numpy.any(isnans(self.riftstruct)):
+                        numrifts=0
+                else:
+                        numrifts=len(self.riftstruct)
+                numpairs=0
+                for i in xrange(0,numrifts):
+                        numpairs+=numpy.size(self.riftstruct[i].penaltypairs,0)
+                # 2 for nodes + 2 for elements+ 2 for  normals + 1 for length + 1 for fill + 1 for friction + 1 for fraction + 1 for fractionincrement + 1 for state.
+                data=numpy.zeros((numpairs,12))
+                count=0
+                for i in xrange(0,numrifts):
+                        numpairsforthisrift=numpy.size(self.riftstruct[i]['penaltypairs'],0)
+                        data[count:count+numpairsforthisrift-1,0:6]=self.riftstruct[i]['penaltypairs']
+                        data[count:count+numpairsforthisrift-1,7]=self.riftstruct[i]['fill']
+                        data[count:count+numpairsforthisrift-1,8]=self.riftstruct[i]['friction']
+                        data[count:count+numpairsforthisrift-1,9]=self.riftstruct[i]['fraction']
+                        data[count:count+numpairsforthisrift-1,10]=self.riftstruct[i]['fractionincrement']
+                        data[count:count+numpairsforthisrift-1,11]=self.riftstruct[i]['state']
+                        count+=numpairsforthisrift
+                WriteData(fid,'data',numrifts,'enum',RiftsNumriftsEnum(),'format','Integer')
+                WriteData(fid,'data',data,'enum',RiftsRiftstructEnum(),'format','DoubleMat','mattype',3)
+        # }}}

issm/branches/trunk-jpl-damage/src/m/classes/settings.m

-              r12878
+              r13101
                 function md = checkconsistency(obj,md,solution,analyses) % {{{
                         md = checkfield(md,'settings.io_gather','numel',1,'values',[0 1]);
                         md = checkfield(md,'settings.lowmem','numel',1,'values',[0 1]);
                         md = checkfield(md,'settings.results_as_patches','numel',1,'values',[0 1]);
                         md = checkfield(md,'settings.output_frequency','numel',1,'>=',1);
                         md = checkfield(md,'settings.waitonlock','numel',1);
+                        md = checkfield(md,'settings.io_gather','numel',[1],'values',[0 1]);
+                        md = checkfield(md,'settings.lowmem','numel',[1],'values',[0 1]);
+                        md = checkfield(md,'settings.results_as_patches','numel',[1],'values',[0 1]);
+                        md = checkfield(md,'settings.output_frequency','numel',[1],'>=',1);
+                        md = checkfield(md,'settings.waitonlock','numel',[1]);
                 end % }}}

issm/branches/trunk-jpl-damage/src/m/classes/settings.py

-              r12168
+              r13101
 #module imports
 from fielddisplay import fielddisplay
+from EnumDefinitions import *
+from checkfield import *
+from WriteData import *
+class settings:
+class settings(object):
+        """
+        SETTINGS class definition
+           Usage:
+              settings=settings();
+        """
         #properties
         def __init__(self):
 …
                 #}}}
         def __repr__(obj):
+        def __repr__(self):
                 # {{{ Display
                 string="   general settings parameters:"
                 string="%s\n%s"%(string,fielddisplay(obj,"io_gather","I/O gathering strategy for result outputs (default 1)"))
                 string="%s\n%s"%(string,fielddisplay(obj,"lowmem","is the memory limited ? (0 or 1)"))
                 string="%s\n%s"%(string,fielddisplay(obj,"results_as_patches","provide results as patches for each element (0 or 1)"))
                 string="%s\n%s"%(string,fielddisplay(obj,"output_frequency","frequency at which results are saved in all solutions with multiple time_steps"))
                 string="%s\n%s"%(string,fielddisplay(obj,"waitonlock","maximum number of minutes to wait for batch results, or return 0"))
+                string="%s\n%s"%(string,fielddisplay(self,"io_gather","I/O gathering strategy for result outputs (default 1)"))
+                string="%s\n%s"%(string,fielddisplay(self,"lowmem","is the memory limited ? (0 or 1)"))
+                string="%s\n%s"%(string,fielddisplay(self,"results_as_patches","provide results as patches for each element (0 or 1)"))
+                string="%s\n%s"%(string,fielddisplay(self,"output_frequency","frequency at which results are saved in all solutions with multiple time_steps"))
+                string="%s\n%s"%(string,fielddisplay(self,"waitonlock","maximum number of minutes to wait for batch results, or return 0"))
                 return string
                 #}}}
         def setdefaultparameters(obj):
+        def setdefaultparameters(self):
                 # {{{setdefaultparameters
                 #are we short in memory ? (0 faster but requires more memory)
                 obj.lowmem=0
+                self.lowmem=0
                 #i/o:
                 obj.io_gather=1
+                self.io_gather=1
                 #results frequency by default every step
                 obj.output_frequency=1
+                self.output_frequency=1
                 #do not use patches by default (difficult to plot)
                 obj.results_as_patches=0
+                self.results_as_patches=0
                 #this option can be activated to load automatically the results
 …
                 #N minutes that is generated once the solution has converged
                 #0 to desactivate
                 obj.waitonlock=float('Inf')
+                self.waitonlock=float('Inf')
                 return obj
+                return self
         #}}}
+        def checkconsistency(self,md,solution,analyses):    # {{{
+                md = checkfield(md,'settings.io_gather','numel',[1],'values',[0,1])
+                md = checkfield(md,'settings.lowmem','numel',[1],'values',[0,1])
+                md = checkfield(md,'settings.results_as_patches','numel',[1],'values',[0,1])
+                md = checkfield(md,'settings.output_frequency','numel',[1],'>=',1)
+                md = checkfield(md,'settings.waitonlock','numel',[1])
+                return md
+        # }}}
+        def marshall(self,fid):    # {{{
+                WriteData(fid,'object',self,'fieldname','io_gather','format','Boolean')
+                WriteData(fid,'object',self,'fieldname','lowmem','format','Boolean')
+                WriteData(fid,'object',self,'fieldname','results_as_patches','format','Boolean')
+                WriteData(fid,'object',self,'fieldname','output_frequency','format','Integer')
+                WriteData(fid,'object',self,'fieldname','waitonlock','format','Boolean')
+        # }}}

issm/branches/trunk-jpl-damage/src/m/classes/solver.m

-              r12878
+              r13101
                  function obj = addoptions(obj,analysis,varargin) % {{{
                  % Usage example:
                  %    md.solver=addoptions(md.solver,DiagnosticHorizAnalysisEnum,stokesoptions());
                  %    md.solver=addoptions(md.solver,DiagnosticHorizAnalysisEnum);
+                 %    md.solver=addoptions(md.solver,DiagnosticHorizAnalysisEnum(),stokesoptions());
+                 %    md.solver=addoptions(md.solver,DiagnosticHorizAnalysisEnum());
                          %Convert analysis from enum to string
 …
                          %MUMPS is the default solver
                          if ismumps,
                                  obj.NoneAnalysis=mumpsoptions;
+                         if ismumps(),
+                                 obj.NoneAnalysis=mumpsoptions();
                          else
                                  obj.NoneAnalysis=iluasmoptions;
+                                 obj.NoneAnalysis=iluasmoptions();
                          end

issm/branches/trunk-jpl-damage/src/m/classes/solver.py

-              r12168
+              r13101
+#module imports {{{
+import fielddisplay
+import ismumps
+from  mumpsoptions import *
+from  iluasmoptions import *
+#}}}
+class solver:
+        #properties
+        def __init__(self):
+                # {{{ Properties
+                if ismumps:
+                        self.options=[["NoneAnalysis",mumpsoptions()]]
+from ismumps import *
+from mumpsoptions import *
+from iluasmoptions import *
+from EnumToString import EnumToString
+from MatlabFuncs import *
+from EnumDefinitions import *
+from checkfield import *
+class solver(object):
+        """
+        SOLVER class definition
+           Usage:
+              obj=solver();
+        """
+        def __init__(self):    # {{{
+                #MUMPS is the default solver
+                if ismumps():
+                        self.NoneAnalysis=mumpsoptions()
                 else:
+                        self.options=[["NoneAnalysis",iluasmoptions()]]
+                #}}}
+        def __repr__(obj):
+                # {{{ Display
+                string2="   solver parameters:"
+                for i in range(len(obj.options)):
+                        option=obj.options[i]
+                        analysis=option[0]
+                        ioptions=option[1]
+                        self.NoneAnalysis=iluasmoptions()
+                        string=""
+                        for i in range(len(ioptions)):
+                                option=ioptions[i]
+                                if not option:
+                                        #do nothing
+                                        pass
+                                elif len(option)==1:
+                #The other properties are dynamic
+        # }}}
+        def addoptions(self,analysis,*args):    # {{{
+                # Usage example:
+                #    md.solver=addoptions(md.solver,DiagnosticHorizAnalysisEnum(),stokesoptions());
+                #    md.solver=addoptions(md.solver,DiagnosticHorizAnalysisEnum());
+                #Convert analysis from enum to string
+                [analysis]=EnumToString(analysis)
+                #Create dynamic property if property does not exist yet
+                if not hasattr(self,analysis):
+#                       exec("self.%s = None" % analysis)
+                        setattr(self,analysis,None)
+                #Add solver options to analysis
+                if len(args)==1:
+                        setattr(self,analysis,args[0])
+                return self
+        # }}}
+        def __repr__(self):    # {{{
+                s ="List of solver options per analysis:\n\n"
+                for analysis in vars(self).iterkeys():
+                        s+="%s :\n" % analysis
+                        s+="%s\n" % getattr(self,analysis)
+                return s
+        # }}}
+        def checkconsistency(self,md,solution,analyses):    # {{{
+                for analysis in vars(self).iterkeys():
+                        if not getattr(self,analysis):
+                                md.checkmessage("md.solver.%s is empty" % analysis)
+                return md
+        # }}}
+        def PetscFile(self,filename):    # {{{
+                """
+                PETSCFILE - build petsc file
+                   Build a Petsc compatible options file, from the solver model field  + return options string
+                   Usage:     PetscFile(solver,filename);
+                """
+                #open file for writing
+                try:
+                        fid=open(filename,'w')
+                except IOError as e:
+                        raise IOError("PetscFile error: could not open '%s' for writing." % filename)
+                #write header
+                fid.write("%s%s%s\n" % ('%Petsc options file: ',filename,' written from Matlab solver array'))
+                #start writing options
+                for analysis in vars(self).iterkeys():
+                        options=getattr(self,analysis)
+                        #first write analysis:
+                        fid.write("\n+%s\n" % analysis)    #append a + to recognize it's an analysis enum
+                        #now, write options
+                        for optionname,optionvalue in options.iteritems():
+                                if not optionvalue:
                                         #this option has only one argument
                                         string="%s%s%s"%(string," -",option[0])
                                 elif len(option)==2:
+                                        fid.write("-%s\n" % optionname)
+                                else:
                                         #option with value. value can be string or scalar
+                                        if isinstance(option[1],float):
+                                                string="%s%s%s%s%s"%(string," -",option[0]," ","%g"%(option[1]))
+                                        elif isinstance(option[1],str):
+                                                string="%s%s%s%s%s"%(string," -",option[0]," ",option[1])
+                                        elif isinstance(option[1],int):
+                                                string="%s%s%s%s%s"%(string," -",option[0]," ","%i"%(option[1]))
+                                        if   isinstance(optionvalue,(bool,int,long,float)):
+                                                fid.write("-%s %g\n" % (optionname,optionvalue))
+                                        elif isinstance(optionvalue,(str,unicode)):
+                                                fid.write("-%s %s\n" % (optionname,optionvalue))
                                         else:
+                                                raise RuntimeError("%s%s%s"%("PetscString error: option #","%i"%(i)," is not well formatted"))
+                                else:
+                                        raise RuntimeError("%s%s%s"%("PetscString error: option #","%i"%(i)," is not well formatted"))
+                                                raise TypeError("PetscFile error: option '%s' is not well formatted." % optionname)
                         string2="%s\n%s"%(string2,"   %s -> '%s'"%(analysis,string))
                 return string2
+        #}}}
+                fid.close()
+        # }}}

issm/branches/trunk-jpl-damage/src/m/classes/steadystate.m

r12878	r13101
29	29
30	30	%Early return
31		if solution~=SteadystateSolutionEnum, return; end;
	31	if solution~=SteadystateSolutionEnum(), return; end;
32	32
33	33	if md.timestepping.time_step~=0,

issm/branches/trunk-jpl-damage/src/m/classes/steadystate.py

-              r12168
+              r13101
 #module imports
+import numpy
 from fielddisplay import fielddisplay
+from EnumDefinitions import *
+from checkfield import *
+from WriteData import *
+class steadystate:
+class steadystate(object):
+        """
+        STEADYSTATE class definition
+           Usage:
+              steadystate=steadystate();
+        """
         #properties
         def __init__(self):
 …
                 #}}}
         def __repr__(obj):
+        def __repr__(self):
                 # {{{ Display
                 string='   steadystate solution parameters:'
                 string="%s\n%s"%(string,fielddisplay(obj,'reltol','relative tolerance criterion'))
                 string="%s\n%s"%(string,fielddisplay(obj,'maxiter','maximum number of iterations'))
                 string="%s\n%s"%(string,fielddisplay(obj,'requested_outputs','additional requested outputs'))
+                string="%s\n%s"%(string,fielddisplay(self,'reltol','relative tolerance criterion'))
+                string="%s\n%s"%(string,fielddisplay(self,'maxiter','maximum number of iterations'))
+                string="%s\n%s"%(string,fielddisplay(self,'requested_outputs','additional requested outputs'))
                 return string
                 #}}}
         def setdefaultparameters(obj):
+        def setdefaultparameters(self):
                 # {{{setdefaultparameters
                 #maximum of steady state iterations
                 obj.maxiter=100
+                self.maxiter=100
                 #Relative tolerance for the steadystate convertgence
                 obj.reltol=0.01
+                self.reltol=0.01
                 return obj
+                return self
         #}}}
+        def checkconsistency(self,md,solution,analyses):    # {{{
+                #Early return
+                if not solution==SteadystateSolutionEnum():
+                        return md
+                if not md.timestepping.time_step==0:
+                        md.checkmessage("for a steadystate computation, timestepping.time_step must be zero.")
+                if numpy.isnan(md.diagnostic.reltol):
+                        md.checkmessage("for a steadystate computation, diagnostic.reltol (relative convergence criterion) must be defined!")
+                return md
+        # }}}
+        def marshall(self,fid):    # {{{
+                WriteData(fid,'object',self,'fieldname','reltol','format','Double')
+                WriteData(fid,'object',self,'fieldname','maxiter','format','Integer')
+                WriteData(fid,'object',self,'fieldname','requested_outputs','format','DoubleMat','mattype',3)
+        # }}}

issm/branches/trunk-jpl-damage/src/m/classes/surfaceforcings.m

-              r12878
+              r13101
                 issmbgradients = 0;
                 isdelta18o = 0;
            hc = NaN;
+                hc = NaN;
                 smb_pos_max = NaN;
                 smb_pos_min = NaN;
 …
                 function md = checkconsistency(obj,md,solution,analyses) % {{{
                         if ismember(PrognosticAnalysisEnum,analyses),
                                 md = checkfield(md,'surfaceforcings.ispdd','numel',1,'values',[0 1]);
                                 checkfield(md,'surfaceforcings.issmbgradients','numel',1,'values',[0 1]);
+                        if ismember(PrognosticAnalysisEnum(),analyses),
+                                md = checkfield(md,'surfaceforcings.ispdd','numel',[1],'values',[0 1]);
+                                md = checkfield(md,'surfaceforcings.issmbgradients','numel',[1],'values',[0 1]);
                                 if(obj.ispdd)
                                         if(obj.isdelta18o==0)
                                                 md = checkfield(md,'surfaceforcings.monthlytemperatures','forcing',1,'NaN',1);
                                                 md = checkfield(md,'surfaceforcings.precipitation','forcing',1,'NaN',1);
                                         else
                                                 md = checkfield(md,'surfaceforcings.delta18o','NaN',1);
                                                 md = checkfield(md,'surfaceforcings.delta18o_surface','NaN',1);
                                                 md = checkfield(md,'surfaceforcings.temperatures_presentday','size',[md.mesh.numberofvertices+1 12],'NaN',1);
                                                 md = checkfield(md,'surfaceforcings.temperatures_lgm','size',[md.mesh.numberofvertices+1 12],'NaN',1);
                                                 md = checkfield(md,'surfaceforcings.precipitations_presentday','size',[md.mesh.numberofvertices+1 12],'NaN',1);
                                         end
+                                        if(obj.isdelta18o==0)
+                                                md = checkfield(md,'surfaceforcings.monthlytemperatures','forcing',1,'NaN',1);
+                                                md = checkfield(md,'surfaceforcings.precipitation','forcing',1,'NaN',1);
+                                        else
+                                                md = checkfield(md,'surfaceforcings.delta18o','NaN',1);
+                                                md = checkfield(md,'surfaceforcings.delta18o_surface','NaN',1);
+                                                md = checkfield(md,'surfaceforcings.temperatures_presentday','size',[md.mesh.numberofvertices+1 12],'NaN',1);
+                                                md = checkfield(md,'surfaceforcings.temperatures_lgm','size',[md.mesh.numberofvertices+1 12],'NaN',1);
+                                                md = checkfield(md,'surfaceforcings.precipitations_presentday','size',[md.mesh.numberofvertices+1 12],'NaN',1);
+                                        end
                                 elseif(obj.issmbgradients)
                                         checkfield(md,'surfaceforcings.hc','forcing',1,'NaN',1);
                                         checkfield(md,'surfaceforcings.smb_pos_max','forcing',1,'NaN',1);
                                         checkfield(md,'surfaceforcings.smb_pos_min','forcing',1,'NaN',1);
                                         checkfield(md,'surfaceforcings.a_pos','forcing',1,'NaN',1);
                                         checkfield(md,'surfaceforcings.b_pos','forcing',1,'NaN',1);
                                         checkfield(md,'surfaceforcings.a_neg','forcing',1,'NaN',1);
                                         checkfield(md,'surfaceforcings.b_neg','forcing',1,'NaN',1);
+                                        md = checkfield(md,'surfaceforcings.hc','forcing',1,'NaN',1);
+                                        md = checkfield(md,'surfaceforcings.smb_pos_max','forcing',1,'NaN',1);
+                                        md = checkfield(md,'surfaceforcings.smb_pos_min','forcing',1,'NaN',1);
+                                        md = checkfield(md,'surfaceforcings.a_pos','forcing',1,'NaN',1);
+                                        md = checkfield(md,'surfaceforcings.b_pos','forcing',1,'NaN',1);
+                                        md = checkfield(md,'surfaceforcings.a_neg','forcing',1,'NaN',1);
+                                        md = checkfield(md,'surfaceforcings.b_neg','forcing',1,'NaN',1);
                                 else
                                         md = checkfield(md,'surfaceforcings.mass_balance','forcing',1,'NaN',1);
                                 end
                         end
                         if ismember(BalancethicknessAnalysisEnum,analyses),
+                        if ismember(BalancethicknessAnalysisEnum(),analyses),
                                 md = checkfield(md,'surfaceforcings.mass_balance','size',[md.mesh.numberofvertices 1],'NaN',1);
                         end
 …
                         WriteData(fid,'object',obj,'fieldname','isdelta18o','format','Boolean');
                         if obj.ispdd,
                           if obj.isdelta18o
                                 WriteData(fid,'object',obj,'fieldname','temperatures_presentday','format','DoubleMat','mattype',1);
                                 WriteData(fid,'object',obj,'fieldname','temperatures_lgm','format','DoubleMat','mattype',1);
                                 WriteData(fid,'object',obj,'fieldname','precipitations_presentday','format','DoubleMat','mattype',1);
                                 WriteData(fid,'object',obj,'fieldname','delta18o_surface','format','DoubleMat','mattype',1);
                                 WriteData(fid,'object',obj,'fieldname','delta18o','format','DoubleMat','mattype',1);
                           else
                                 WriteData(fid,'object',obj,'fieldname','monthlytemperatures','format','DoubleMat','mattype',1);
                                 WriteData(fid,'object',obj,'fieldname','precipitation','format','DoubleMat','mattype',1);
                           end
+                                if obj.isdelta18o
+                                        WriteData(fid,'object',obj,'fieldname','temperatures_presentday','format','DoubleMat','mattype',1);
+                                        WriteData(fid,'object',obj,'fieldname','temperatures_lgm','format','DoubleMat','mattype',1);
+                                        WriteData(fid,'object',obj,'fieldname','precipitations_presentday','format','DoubleMat','mattype',1);
+                                        WriteData(fid,'object',obj,'fieldname','delta18o_surface','format','DoubleMat','mattype',1);
+                                        WriteData(fid,'object',obj,'fieldname','delta18o','format','DoubleMat','mattype',1);
+                                else
+                                        WriteData(fid,'object',obj,'fieldname','monthlytemperatures','format','DoubleMat','mattype',1);
+                                        WriteData(fid,'object',obj,'fieldname','precipitation','format','DoubleMat','mattype',1);
+                                end
                         end
                         WriteData(fid,'object',obj,'fieldname','issmbgradients','format','Boolean');

issm/branches/trunk-jpl-damage/src/m/classes/surfaceforcings.py

-              r12168
+              r13101
 #module imports
 from fielddisplay import fielddisplay
+from EnumDefinitions import *
+from checkfield import *
+from WriteData import *
+class surfaceforcings:
+class surfaceforcings(object):
+        """
+        SURFACEFORCING Class definition
+           Usage:
+              surfaceforcings=surfaceforcings();
+        """
         #properties
         def __init__(self):
 …
                 self.precipitation = float('NaN')
                 self.mass_balance  = float('NaN')
+                self.ispdd = 0
+                self.issmbgradients = 0
+                self.isdelta18o = 0
+                self.hc = float('NaN')
+                self.smb_pos_max = float('NaN')
+                self.smb_pos_min = float('NaN')
+                self.a_pos = float('NaN')
+                self.b_pos = float('NaN')
+                self.a_neg = float('NaN')
+                self.b_neg = float('NaN')
+                self.monthlytemperatures = float('NaN')
+                self.delta18o = float('NaN')
+                self.delta18o_surface = float('NaN')
+                self.temperatures_presentday = float('NaN')
+                self.temperatures_lgm = float('NaN')
+                self.precipitations_presentday = float('NaN')
                 #set defaults
 …
                 #}}}
         def __repr__(obj):
+        def __repr__(self):
                 # {{{ Display
                 string="   surface forcings parameters:"
+                string="%s\n\n%s"%(string,fielddisplay(obj,'precipitation','surface precipitation [m/yr water eq]'))
+                string="%s\n%s"%(string,fielddisplay(obj,'mass_balance','surface mass balance [m/yr ice eq]'))
+                string="%s\n\n%s"%(string,fielddisplay(self,'precipitation','surface precipitation [m/yr water eq]'))
+                string="%s\n%s"%(string,fielddisplay(self,'mass_balance','surface mass balance [m/yr ice eq]'))
+                string="%s\n%s"%(string,fielddisplay(self,'ispdd','is pdd activated (0 or 1, default is 0)'))
+                string="%s\n%s"%(string,fielddisplay(self,'isdelta18o','is temperature and precipitation delta18o parametrisation activated (0 or 1, default is 0)'))
+                string="%s\n%s"%(string,fielddisplay(self,'monthlytemperatures','monthly surface temperatures [Kelvin], required if pdd is activated and delta18o not activated'))
+                string="%s\n%s"%(string,fielddisplay(self,'precipitation','surface precipitation [m/yr water eq]'))
+                string="%s\n%s"%(string,fielddisplay(self,'temperatures_presentday','monthly present day surface temperatures [Kelvin], required if pdd is activated and delta18o activated'))
+                string="%s\n%s"%(string,fielddisplay(self,'temperatures_lgm','monthly LGM surface temperatures [Kelvin], required if pdd is activated and delta18o activated'))
+                string="%s\n%s"%(string,fielddisplay(self,'precipitations_presentday','monthly surface precipitation [m/yr water eq], required if pdd is activated and delta18o activated'))
+                string="%s\n%s"%(string,fielddisplay(self,'delta18o','delta18o, required if pdd is activated and delta18o activated'))
+                string="%s\n%s"%(string,fielddisplay(self,'delta18o_surface','surface elevation of the delta18o site, required if pdd is activated and delta18o activated'))
+                string="%s\n%s"%(string,fielddisplay(self,'issmbgradients','is smb gradients method activated (0 or 1, default is 0)'))
+                string="%s\n%s"%(string,fielddisplay(self,'hc',' elevation of intersection between accumulation and ablation regime required if smb gradients is activated'))
+                string="%s\n%s"%(string,fielddisplay(self,'smb_pos_max',' maximum value of positive smb required if smb gradients is activated'))
+                string="%s\n%s"%(string,fielddisplay(self,'smb_pos_min',' minimum value of positive smb required if smb gradients is activated'))
+                string="%s\n%s"%(string,fielddisplay(self,'a_pos',' intercept of hs - smb regression line for accumulation regime required if smb gradients is activated'))
+                string="%s\n%s"%(string,fielddisplay(self,'b_pos',' slope of hs - smb regression line for accumulation regime required if smb gradients is activated'))
+                string="%s\n%s"%(string,fielddisplay(self,'a_neg',' intercept of hs - smb regression line for ablation regime required if smb gradients is activated'))
+                string="%s\n%s"%(string,fielddisplay(self,'b_neg',' slope of hs - smb regression line for ablation regime required if smb gradients is activated'))
                 return string
                 #}}}
         def setdefaultparameters(obj):
+        def setdefaultparameters(self):
                 # {{{setdefaultparameters
+                return obj
+                #pdd method not used in default mode
+                self.ispdd=0
+                self.issmbgradients=0
+                self.isdelta18o=0
+                return self
         #}}}
+        def checkconsistency(self,md,solution,analyses):    # {{{
+                if PrognosticAnalysisEnum() in analyses:
+                        md = checkfield(md,'surfaceforcings.ispdd','numel',[1],'values',[0,1])
+                        md = checkfield(md,'surfaceforcings.issmbgradients','numel',[1],'values',[0,1])
+                        if   self.ispdd:
+                                if not self.isdelta18o:
+                                        md = checkfield(md,'surfaceforcings.monthlytemperatures','forcing',1,'NaN',1)
+                                        md = checkfield(md,'surfaceforcings.precipitation','forcing',1,'NaN',1)
+                                else:
+                                        md = checkfield(md,'surfaceforcings.delta18o','NaN',1)
+                                        md = checkfield(md,'surfaceforcings.delta18o_surface','NaN',1)
+                                        md = checkfield(md,'surfaceforcings.temperatures_presentday','size',[md.mesh.numberofvertices+1,12],'NaN',1)
+                                        md = checkfield(md,'surfaceforcings.temperatures_lgm','size',[md.mesh.numberofvertices+1,12],'NaN',1)
+                                        md = checkfield(md,'surfaceforcings.precipitations_presentday','size',[md.mesh.numberofvertices+1,12],'NaN',1)
+                        elif self.issmbgradients:
+                                md = checkfield(md,'surfaceforcings.hc','forcing',1,'NaN',1)
+                                md = checkfield(md,'surfaceforcings.smb_pos_max','forcing',1,'NaN',1)
+                                md = checkfield(md,'surfaceforcings.smb_pos_min','forcing',1,'NaN',1)
+                                md = checkfield(md,'surfaceforcings.a_pos','forcing',1,'NaN',1)
+                                md = checkfield(md,'surfaceforcings.b_pos','forcing',1,'NaN',1)
+                                md = checkfield(md,'surfaceforcings.a_neg','forcing',1,'NaN',1)
+                                md = checkfield(md,'surfaceforcings.b_neg','forcing',1,'NaN',1)
+                        else:
+                                md = checkfield(md,'surfaceforcings.mass_balance','forcing',1,'NaN',1)
+                if BalancethicknessAnalysisEnum() in analyses:
+                        md = checkfield(md,'surfaceforcings.mass_balance','size',[md.mesh.numberofvertices],'NaN',1)
+                return md
+        # }}}
+        def marshall(self,fid):    # {{{
+                WriteData(fid,'object',self,'fieldname','precipitation','format','DoubleMat','mattype',1)
+                WriteData(fid,'object',self,'fieldname','mass_balance','format','DoubleMat','mattype',1)
+                WriteData(fid,'object',self,'fieldname','ispdd','format','Boolean')
+                WriteData(fid,'object',self,'fieldname','isdelta18o','format','Boolean')
+                if self.ispdd:
+                        if self.isdelta18o:
+                                WriteData(fid,'object',self,'fieldname','temperatures_presentday','format','DoubleMat','mattype',1)
+                                WriteData(fid,'object',self,'fieldname','temperatures_lgm','format','DoubleMat','mattype',1)
+                                WriteData(fid,'object',self,'fieldname','precipitations_presentday','format','DoubleMat','mattype',1)
+                                WriteData(fid,'object',self,'fieldname','delta18o_surface','format','DoubleMat','mattype',1)
+                                WriteData(fid,'object',self,'fieldname','delta18o','format','DoubleMat','mattype',1)
+                        else:
+                                WriteData(fid,'object',self,'fieldname','monthlytemperatures','format','DoubleMat','mattype',1)
+                                WriteData(fid,'object',self,'fieldname','precipitation','format','DoubleMat','mattype',1)
+                WriteData(fid,'object',self,'fieldname','issmbgradients','format','Boolean')
+                if self.issmbgradients:
+                        WriteData(fid,'object',self,'fieldname','hc','format','DoubleMat','mattype',1)
+                        WriteData(fid,'object',self,'fieldname','smb_pos_max','format','DoubleMat','mattype',1)
+                        WriteData(fid,'object',self,'fieldname','smb_pos_min','format','DoubleMat','mattype',1)
+                        WriteData(fid,'object',self,'fieldname','a_pos','format','DoubleMat','mattype',1)
+                        WriteData(fid,'object',self,'fieldname','b_pos','format','DoubleMat','mattype',1)
+                        WriteData(fid,'object',self,'fieldname','a_neg','format','DoubleMat','mattype',1)
+                        WriteData(fid,'object',self,'fieldname','b_neg','format','DoubleMat','mattype',1)
+        # }}}

issm/branches/trunk-jpl-damage/src/m/classes/thermal.m

-              r12878
+              r13101
                         %Early return
                         if (~ismember(ThermalAnalysisEnum,analyses) & ~ismember(EnthalpyAnalysisEnum,analyses)) | (solution==TransientSolutionEnum & md.transient.isthermal==0), return; end
+                        if (~ismember(ThermalAnalysisEnum(),analyses) & ~ismember(EnthalpyAnalysisEnum(),analyses)) | (solution==TransientSolutionEnum() & md.transient.isthermal==0), return; end
                         md = checkfield(md,'thermal.stabilization','numel',1,'values',[0 1 2]);
+                        md = checkfield(md,'thermal.stabilization','numel',[1],'values',[0 1 2]);
                         md = checkfield(md,'thermal.spctemperature','forcing',1);
                         if (ismember(EnthalpyAnalysisEnum,analyses) & md.thermal.isenthalpy & md.mesh.dimension==3),
                         md = checkfield(md,'thermal.spctemperature','<',md.materials.meltingpoint-md.materials.beta*md.materials.rho_ice*md.constants.g*(md.geometry.surface-md.mesh.z),'message','spctemperature should be below the adjusted melting point');
                         md = checkfield(md,'thermal.isenthalpy','numel',1,'values',[0 1]);
+                        if (ismember(EnthalpyAnalysisEnum(),analyses) & md.thermal.isenthalpy & md.mesh.dimension==3),
+                                md = checkfield(md,'thermal.spctemperature','<',md.materials.meltingpoint-md.materials.beta*md.materials.rho_ice*md.constants.g*(md.geometry.surface-md.mesh.z),'message','spctemperature should be below the adjusted melting point');
+                                md = checkfield(md,'thermal.isenthalpy','numel',[1],'values',[0 1]);
                         end
                 end % }}}

issm/branches/trunk-jpl-damage/src/m/classes/thermal.py

-              r12168
+              r13101
 #module imports
 from fielddisplay import fielddisplay
+from EnumDefinitions import *
+from checkfield import *
+from WriteData import *
+class thermal:
+class thermal(object):
+        """
+        THERMAL class definition
+           Usage:
+              thermal=thermal();
+        """
         #properties
         def __init__(self):
 …
                 #}}}
         def __repr__(obj):
+        def __repr__(self):
                 # {{{ Display
                 string='   Thermal solution parameters:'
                 string="%s\n\n%s"%(string,fielddisplay(obj,'spctemperature','temperature constraints (NaN means no constraint)'))
                 string="%s\n%s"%(string,fielddisplay(obj,'stabilization','0->no, 1->artificial_diffusivity, 2->SUPG'))
                 string="%s\n%s"%(string,fielddisplay(obj,'maxiter','maximum number of non linear iterations'))
                 string="%s\n%s"%(string,fielddisplay(obj,'penalty_lock','stabilize unstable thermal constraints that keep zigzagging after n iteration (default is 0, no stabilization)'))
                 string="%s\n%s"%(string,fielddisplay(obj,'penalty_threshold','threshold to declare convergence of thermal solution (default is 0)'))
                 string="%s\n%s"%(string,fielddisplay(obj,'isenthalpy','use an enthalpy formulation to include temperate ice (default is 0)'))
+                string="%s\n\n%s"%(string,fielddisplay(self,'spctemperature','temperature constraints (NaN means no constraint)'))
+                string="%s\n%s"%(string,fielddisplay(self,'stabilization','0->no, 1->artificial_diffusivity, 2->SUPG'))
+                string="%s\n%s"%(string,fielddisplay(self,'maxiter','maximum number of non linear iterations'))
+                string="%s\n%s"%(string,fielddisplay(self,'penalty_lock','stabilize unstable thermal constraints that keep zigzagging after n iteration (default is 0, no stabilization)'))
+                string="%s\n%s"%(string,fielddisplay(self,'penalty_threshold','threshold to declare convergence of thermal solution (default is 0)'))
+                string="%s\n%s"%(string,fielddisplay(self,'isenthalpy','use an enthalpy formulation to include temperate ice (default is 0)'))
                 return string
                 #}}}
         def setdefaultparameters(obj):
+        def setdefaultparameters(self):
                 # {{{setdefaultparameters
                 #Number of unstable constraints acceptable
                 obj.penalty_threshold=0
+                self.penalty_threshold=0
                 #Type of stabilization used
                 obj.stabilization=1
+                self.stabilization=1
                 #Maximum number of iterations
                 obj.maxiter=100
+                self.maxiter=100
                 #factor used to compute the values of the penalties: kappa=max(stiffness matrix)*10^penalty_factor
                 obj.penalty_factor=3
+                self.penalty_factor=3
                 #Should we use cold ice (default) or enthalpy formulation
                 obj.isenthalpy=0
+                self.isenthalpy=0
                 return obj
+                return self
         #}}}
+        def checkconsistency(self,md,solution,analyses):    # {{{
+                #Early return
+                if (ThermalAnalysisEnum() not in analyses and EnthalpyAnalysisEnum() not in analyses) or (solution==TransientSolutionEnum() and not md.transient.isthermal):
+                        return md
+                md = checkfield(md,'thermal.stabilization','numel',[1],'values',[0,1,2])
+                md = checkfield(md,'thermal.spctemperature','forcing',1)
+                if EnthalpyAnalysisEnum() in analyses and md.thermal.isenthalpy and md.mesh.dimension==3:
+                        md = checkfield(md,'thermal.spctemperature','<',md.materials.meltingpoint-md.materials.beta*md.materials.rho_ice*md.constants.g*(md.geometry.surface-md.mesh.z),'message',"spctemperature should be below the adjusted melting point")
+                        md = checkfield(md,'thermal.isenthalpy','numel',[1],'values',[0,1])
+                return md
+        # }}}
+        def marshall(self,fid):    # {{{
+                WriteData(fid,'object',self,'fieldname','spctemperature','format','DoubleMat','mattype',1)
+                WriteData(fid,'object',self,'fieldname','penalty_threshold','format','Integer')
+                WriteData(fid,'object',self,'fieldname','stabilization','format','Integer')
+                WriteData(fid,'object',self,'fieldname','maxiter','format','Integer')
+                WriteData(fid,'object',self,'fieldname','penalty_lock','format','Integer')
+                WriteData(fid,'object',self,'fieldname','penalty_factor','format','Double')
+                WriteData(fid,'object',self,'fieldname','isenthalpy','format','Boolean')
+        # }}}

issm/branches/trunk-jpl-damage/src/m/classes/timestepping.m

-              r12878
+              r13101
                 function md = checkconsistency(obj,md,solution,analyses) % {{{
                         md = checkfield(md,'timestepping.start_time','numel',1,'NaN',1);
                         md = checkfield(md,'timestepping.final_time','numel',1,'NaN',1);
                         md = checkfield(md,'timestepping.time_step','numel',1,'>=',0,'NaN',1);
                         md = checkfield(md,'timestepping.time_adapt','numel',1,'values',[0 1]);
                         md = checkfield(md,'timestepping.cfl_coefficient','numel',1,'>',0,'<=',1);
+                        md = checkfield(md,'timestepping.start_time','numel',[1],'NaN',1);
+                        md = checkfield(md,'timestepping.final_time','numel',[1],'NaN',1);
+                        md = checkfield(md,'timestepping.time_step','numel',[1],'>=',0,'NaN',1);
+                        md = checkfield(md,'timestepping.time_adapt','numel',[1],'values',[0 1]);
+                        md = checkfield(md,'timestepping.cfl_coefficient','numel',[1],'>',0,'<=',1);
                         if obj.final_time-obj.start_time<0,
                                 md = checkmessage(md,'timestepping.final_time should be larger than timestepping.start_time');

issm/branches/trunk-jpl-damage/src/m/classes/timestepping.py

-              r12168
+              r13101
 #module imports
 from fielddisplay import fielddisplay
+from EnumDefinitions import *
+from checkfield import *
+from WriteData import *
+class timestepping:
+class timestepping(object):
+        """
+        TIMESTEPPING Class definition
+           Usage:
+              timestepping=timestepping();
+        """
         #properties
         def __init__(self):
                 # {{{ Properties
+                self.start_time      = 0
+                self.final_time      = 0
                 self.time_step       = 0
-                self.final_time      = 0
                 self.time_adapt      = 0
                 self.cfl_coefficient = 0
 …
                 #}}}
         def __repr__(obj):
+        def __repr__(self):
                 # {{{ Display
                 string="   timestepping parameters:"
+                string="%s\n\n%s"%(string,fielddisplay(obj,"time_step","length of time steps [yrs]"))
+                string="%s\n%s"%(string,fielddisplay(obj,"final_time","final time to stop the simulation [yrs]"))
+                string="%s\n%s"%(string,fielddisplay(obj,"time_adapt","use cfl condition to define time step ? (0 or 1) "))
+                string="%s\n%s"%(string,fielddisplay(obj,"cfl_coefficient","coefficient applied to cfl condition"))
+                string="%s\n\n%s"%(string,fielddisplay(self,"start_time","simulation starting time [yrs]"))
+                string="%s\n%s"%(string,fielddisplay(self,"final_time","final time to stop the simulation [yrs]"))
+                string="%s\n%s"%(string,fielddisplay(self,"time_step","length of time steps [yrs]"))
+                string="%s\n%s"%(string,fielddisplay(self,"time_adapt","use cfl condition to define time step ? (0 or 1) "))
+                string="%s\n%s"%(string,fielddisplay(self,"cfl_coefficient","coefficient applied to cfl condition"))
                 return string
                 #}}}
         def setdefaultparameters(obj):
+        def setdefaultparameters(self):
                 # {{{setdefaultparameters
                 #time between 2 time steps
                 obj.time_step=1/2
+                self.time_step=1/2
                 #final time
                 obj.final_time=10*obj.time_step
+                self.final_time=10*self.time_step
                 #time adaptation?
                 obj.time_adapt=0
                 obj.cfl_coefficient=.5
+                self.time_adapt=0
+                self.cfl_coefficient=.5
                 return obj
+                return self
         #}}}
+        def checkconsistency(self,md,solution,analyses):    # {{{
+                md = checkfield(md,'timestepping.start_time','numel',[1],'NaN',1)
+                md = checkfield(md,'timestepping.final_time','numel',[1],'NaN',1)
+                md = checkfield(md,'timestepping.time_step','numel',[1],'>=',0,'NaN',1)
+                md = checkfield(md,'timestepping.time_adapt','numel',[1],'values',[0,1])
+                md = checkfield(md,'timestepping.cfl_coefficient','numel',[1],'>',0,'<=',1)
+                if self.final_time-self.start_time<0:
+                        md.checkmessage("timestepping.final_time should be larger than timestepping.start_time")
+                return md
+        # }}}
+        def marshall(self,fid):    # {{{
+                WriteData(fid,'object',self,'fieldname','start_time','format','Double')
+                WriteData(fid,'object',self,'fieldname','final_time','format','Double')
+                WriteData(fid,'object',self,'fieldname','time_step','format','Double')
+                WriteData(fid,'object',self,'fieldname','time_adapt','format','Boolean')
+                WriteData(fid,'object',self,'fieldname','cfl_coefficient','format','Double')
+        # }}}

issm/branches/trunk-jpl-damage/src/m/classes/transient.m

-              r12878
+              r13101
                         %Early return
                         if solution~=TransientSolutionEnum, return; end
+                        if solution~=TransientSolutionEnum(), return; end
                         md = checkfield(md,'transient.isprognostic','numel',1,'values',[0 1]);
                         md = checkfield(md,'transient.isdiagnostic','numel',1,'values',[0 1]);
                         md = checkfield(md,'transient.isthermal','numel',1,'values',[0 1]);
                         md = checkfield(md,'transient.isgroundingline','numel',1,'values',[0 1]);
+                        md = checkfield(md,'transient.isprognostic','numel',[1],'values',[0 1]);
+                        md = checkfield(md,'transient.isdiagnostic','numel',[1],'values',[0 1]);
+                        md = checkfield(md,'transient.isthermal','numel',[1],'values',[0 1]);
+                        md = checkfield(md,'transient.isgroundingline','numel',[1],'values',[0 1]);
                         md = checkfield(md,'transient.requested_outputs','size',[NaN 1]);

issm/branches/trunk-jpl-damage/src/m/classes/transient.py

-              r12168
+              r13101
 #module imports
 from fielddisplay import fielddisplay
+from EnumDefinitions import *
+from checkfield import *
+from WriteData import *
+class transient:
+class transient(object):
+        """
+        TRANSIENT class definition
+           Usage:
+              transient=transient();
+        """
         #properties
         def __init__(self):
 …
                 #}}}
         def __repr__(obj):
+        def __repr__(self):
                 # {{{ Display
                 string='   transient solution parameters:'
                 string="%s\n%s"%(string,fielddisplay(obj,'isprognostic','indicates if a prognostic solution is used in the transient'))
                 string="%s\n%s"%(string,fielddisplay(obj,'isthermal','indicates if a thermal solution is used in the transient'))
                 string="%s\n%s"%(string,fielddisplay(obj,'isdiagnostic','indicates if a diagnostic solution is used in the transient'))
                 string="%s\n%s"%(string,fielddisplay(obj,'isgroundingline','indicates if a groundingline migration is used in the transient'))
                 string="%s\n%s"%(string,fielddisplay(obj,'requested_outputs','list of additional outputs requested'))
+                string="%s\n%s"%(string,fielddisplay(self,'isprognostic','indicates if a prognostic solution is used in the transient'))
+                string="%s\n%s"%(string,fielddisplay(self,'isthermal','indicates if a thermal solution is used in the transient'))
+                string="%s\n%s"%(string,fielddisplay(self,'isdiagnostic','indicates if a diagnostic solution is used in the transient'))
+                string="%s\n%s"%(string,fielddisplay(self,'isgroundingline','indicates if a groundingline migration is used in the transient'))
+                string="%s\n%s"%(string,fielddisplay(self,'requested_outputs','list of additional outputs requested'))
                 return string
                 #}}}
         def setdefaultparameters(obj):
+        def setdefaultparameters(self):
                 # {{{setdefaultparameters
                 #full analysis: Diagnostic, Prognostic and Thermal but no groundingline migration for now
                 obj.isprognostic=1
                 obj.isdiagnostic=1
                 obj.isthermal=1
                 obj.isgroundingline=0
+                self.isprognostic=1
+                self.isdiagnostic=1
+                self.isthermal=1
+                self.isgroundingline=0
                 return obj
+                return self
         #}}}
+        def checkconsistency(self,md,solution,analyses):    # {{{
+                #Early return
+                if not solution==TransientSolutionEnum():
+                        return md
+                md = checkfield(md,'transient.isprognostic','numel',[1],'values',[0,1])
+                md = checkfield(md,'transient.isdiagnostic','numel',[1],'values',[0,1])
+                md = checkfield(md,'transient.isthermal','numel',[1],'values',[0,1])
+                md = checkfield(md,'transient.isgroundingline','numel',[1],'values',[0,1])
+                md = checkfield(md,'transient.requested_outputs','size',[float('NaN')])
+                return md
+        # }}}
+        def marshall(self,fid):    # {{{
+                WriteData(fid,'object',self,'fieldname','isprognostic','format','Boolean')
+                WriteData(fid,'object',self,'fieldname','isdiagnostic','format','Boolean')
+                WriteData(fid,'object',self,'fieldname','isthermal','format','Boolean')
+                WriteData(fid,'object',self,'fieldname','isgroundingline','format','Boolean')
+                WriteData(fid,'object',self,'fieldname','requested_outputs','format','DoubleMat','mattype',3)
+        # }}}

issm/branches/trunk-jpl-damage/src/m/classes/verbose.m

r12946	r13101
120	120	%}}}
121	121	function marshall(obj,fid) % {{{
122		WriteData(fid,'data',VerboseToBinary(obj),'enum',VerboseEnum,'format','Integer');
	122	WriteData(fid,'data',VerboseToBinary(obj),'enum',VerboseEnum(),'format','Integer');
123	123	end % }}}
124	124	end

issm/branches/trunk-jpl-damage/src/m/classes/verbose.py

-              r12946
+              r13101
 from pairoptions import *
 from MatlabFuncs import *
+from EnumDefinitions import *
 from WriteData import *
-from EnumDefinitions import *
 class verbose(object):
 …
                 elif len(args) == 1:
                         binary=args[0]
                         if   isinstance(binary,str):
+                        if   isinstance(binary,(str,unicode)):
                                 if strcmpi(binary,'all'):
                                         binary=2**11-1    #all ones
 …
                                         binary=int(binary,2)
                                         self.BinaryToVerbose(binary)
                         elif isinstance(binary,(int,float)):
+                        elif isinstance(binary,(int,long,float)):
                                 self.BinaryToVerbose(int(binary))
 …
                         listproperties=vars(self)
                         for [fieldname,fieldvalue] in listproperties.iteritems():
                                 if isinstance(fieldvalue,bool) or isinstance(fieldvalue,(int,float)):
+                                if isinstance(fieldvalue,bool) or isinstance(fieldvalue,(int,long,float)):
                                         setattr(self,fieldname,bool(fieldvalue))
                                 else:
 …
         def marshall(self,fid):    # {{{
                         WriteData(fid,'data',VerboseToBinary(self),'enum',VerboseEnum,'format','Integer')
+                        WriteData(fid,'data',self.VerboseToBinary(),'enum',VerboseEnum(),'format','Integer')
         # }}}

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

-              r12947
+              r13101
+from StringToEnum import StringToEnum
 """
 …
 """
-def AutodiffForwardEnum():
-        """
-        AUTODIFFFORWARDENUM - Enum of AutodiffForward
-           Usage:
-              macro=AutodiffForwardEnum()
-        """
-        return StringToEnum('AutodiffForward')
 def AutodiffIsautodiffEnum():
         """
 …
         """
+        return StringToEnum('AutodiffIsautodiff')
+def AutodiffReverseEnum():
+        """
+        AUTODIFFREVERSEENUM - Enum of AutodiffReverse
+           Usage:
+              macro=AutodiffReverseEnum()
+        """
+        return StringToEnum('AutodiffReverse')
+        return StringToEnum('AutodiffIsautodiff')[0]
 def BalancethicknessSpcthicknessEnum():
 …
         """
         return StringToEnum('BalancethicknessSpcthickness')
+        return StringToEnum('BalancethicknessSpcthickness')[0]
 def BalancethicknessStabilizationEnum():
 …
         """
         return StringToEnum('BalancethicknessStabilization')
+        return StringToEnum('BalancethicknessStabilization')[0]
 def BalancethicknessThickeningRateEnum():
 …
         """
         return StringToEnum('BalancethicknessThickeningRate')
+        return StringToEnum('BalancethicknessThickeningRate')[0]
 def BasalforcingsGeothermalfluxEnum():
 …
         """
         return StringToEnum('BasalforcingsGeothermalflux')
+        return StringToEnum('BasalforcingsGeothermalflux')[0]
 def BasalforcingsMeltingRateCorrectionEnum():
 …
         """
         return StringToEnum('BasalforcingsMeltingRateCorrection')
+        return StringToEnum('BasalforcingsMeltingRateCorrection')[0]
 def BasalforcingsMeltingRateEnum():
 …
         """
         return StringToEnum('BasalforcingsMeltingRate')
+        return StringToEnum('BasalforcingsMeltingRate')[0]
 def BathymetryEnum():
 …
         """
         return StringToEnum('Bathymetry')
+        return StringToEnum('Bathymetry')[0]
 def BedEnum():
 …
         """
         return StringToEnum('Bed')
+        return StringToEnum('Bed')[0]
 def ConstantsGEnum():
 …
         """
         return StringToEnum('ConstantsG')
+        return StringToEnum('ConstantsG')[0]
 def ConstantsReferencetemperatureEnum():
 …
         """
         return StringToEnum('ConstantsReferencetemperature')
+        return StringToEnum('ConstantsReferencetemperature')[0]
 def ConstantsYtsEnum():
 …
         """
         return StringToEnum('ConstantsYts')
+        return StringToEnum('ConstantsYts')[0]
 def DiagnosticAbstolEnum():
 …
         """
         return StringToEnum('DiagnosticAbstol')
+        return StringToEnum('DiagnosticAbstol')[0]
 def DiagnosticIcefrontEnum():
 …
         """
         return StringToEnum('DiagnosticIcefront')
+        return StringToEnum('DiagnosticIcefront')[0]
 def DiagnosticIsnewtonEnum():
 …
         """
         return StringToEnum('DiagnosticIsnewton')
+        return StringToEnum('DiagnosticIsnewton')[0]
 def DiagnosticMaxiterEnum():
 …
         """
         return StringToEnum('DiagnosticMaxiter')
+        return StringToEnum('DiagnosticMaxiter')[0]
 def DiagnosticNumRequestedOutputsEnum():
 …
         """
         return StringToEnum('DiagnosticNumRequestedOutputs')
+        return StringToEnum('DiagnosticNumRequestedOutputs')[0]
 def DiagnosticPenaltyFactorEnum():
 …
         """
         return StringToEnum('DiagnosticPenaltyFactor')
+        return StringToEnum('DiagnosticPenaltyFactor')[0]
 def DiagnosticReferentialEnum():
 …
         """
         return StringToEnum('DiagnosticReferential')
+        return StringToEnum('DiagnosticReferential')[0]
 def DiagnosticReltolEnum():
 …
         """
         return StringToEnum('DiagnosticReltol')
+        return StringToEnum('DiagnosticReltol')[0]
 def DiagnosticRequestedOutputsEnum():
 …
         """
         return StringToEnum('DiagnosticRequestedOutputs')
+        return StringToEnum('DiagnosticRequestedOutputs')[0]
 def DiagnosticRestolEnum():
 …
         """
         return StringToEnum('DiagnosticRestol')
+        return StringToEnum('DiagnosticRestol')[0]
 def DiagnosticRiftPenaltyLockEnum():
 …
         """
         return StringToEnum('DiagnosticRiftPenaltyLock')
+        return StringToEnum('DiagnosticRiftPenaltyLock')[0]
 def DiagnosticRiftPenaltyThresholdEnum():
 …
         """
         return StringToEnum('DiagnosticRiftPenaltyThreshold')
+        return StringToEnum('DiagnosticRiftPenaltyThreshold')[0]
 def DiagnosticShelfDampeningEnum():
 …
         """
         return StringToEnum('DiagnosticShelfDampening')
+        return StringToEnum('DiagnosticShelfDampening')[0]
 def DiagnosticSpcvxEnum():
 …
         """
         return StringToEnum('DiagnosticSpcvx')
+        return StringToEnum('DiagnosticSpcvx')[0]
 def DiagnosticSpcvyEnum():
 …
         """
         return StringToEnum('DiagnosticSpcvy')
+        return StringToEnum('DiagnosticSpcvy')[0]
 def DiagnosticSpcvzEnum():
 …
         """
         return StringToEnum('DiagnosticSpcvz')
+        return StringToEnum('DiagnosticSpcvz')[0]
 def DiagnosticStokesreconditioningEnum():
 …
         """
         return StringToEnum('DiagnosticStokesreconditioning')
+        return StringToEnum('DiagnosticStokesreconditioning')[0]
 def DiagnosticVertexPairingEnum():
 …
         """
         return StringToEnum('DiagnosticVertexPairing')
+        return StringToEnum('DiagnosticVertexPairing')[0]
 def DiagnosticViscosityOvershootEnum():
 …
         """
         return StringToEnum('DiagnosticViscosityOvershoot')
+        return StringToEnum('DiagnosticViscosityOvershoot')[0]
 def FlowequationBordermacayealEnum():
 …
         """
         return StringToEnum('FlowequationBordermacayeal')
+        return StringToEnum('FlowequationBordermacayeal')[0]
 def FlowequationBorderpattynEnum():
 …
         """
         return StringToEnum('FlowequationBorderpattyn')
+        return StringToEnum('FlowequationBorderpattyn')[0]
 def FlowequationBorderstokesEnum():
 …
         """
         return StringToEnum('FlowequationBorderstokes')
+        return StringToEnum('FlowequationBorderstokes')[0]
 def FlowequationElementEquationEnum():
 …
         """
         return StringToEnum('FlowequationElementEquation')
+        return StringToEnum('FlowequationElementEquation')[0]
 def FlowequationIshutterEnum():
 …
         """
+        return StringToEnum('FlowequationIshutter')
+        return StringToEnum('FlowequationIshutter')[0]
+def FlowequationIsl1l2Enum():
+        """
+        FLOWEQUATIONISL1L2ENUM - Enum of FlowequationIsl1l2
+           Usage:
+              macro=FlowequationIsl1l2Enum()
+        """
+        return StringToEnum('FlowequationIsl1l2')[0]
 def FlowequationIsmacayealpattynEnum():
 …
         """
         return StringToEnum('FlowequationIsmacayealpattyn')
+        return StringToEnum('FlowequationIsmacayealpattyn')[0]
 def FlowequationIsstokesEnum():
 …
         """
         return StringToEnum('FlowequationIsstokes')
+        return StringToEnum('FlowequationIsstokes')[0]
 def FlowequationVertexEquationEnum():
 …
         """
         return StringToEnum('FlowequationVertexEquation')
+        return StringToEnum('FlowequationVertexEquation')[0]
 def FrictionCoefficientEnum():
 …
         """
         return StringToEnum('FrictionCoefficient')
+        return StringToEnum('FrictionCoefficient')[0]
 def FrictionPEnum():
 …
         """
         return StringToEnum('FrictionP')
+        return StringToEnum('FrictionP')[0]
 def FrictionQEnum():
 …
         """
         return StringToEnum('FrictionQ')
+        return StringToEnum('FrictionQ')[0]
 def GeometryHydrostaticRatioEnum():
 …
         """
         return StringToEnum('GeometryHydrostaticRatio')
+        return StringToEnum('GeometryHydrostaticRatio')[0]
 def HydrologyCREnum():
 …
         """
         return StringToEnum('HydrologyCR')
+        return StringToEnum('HydrologyCR')[0]
 def HydrologyKnEnum():
 …
         """
         return StringToEnum('HydrologyKn')
+        return StringToEnum('HydrologyKn')[0]
 def HydrologyNEnum():
 …
         """
         return StringToEnum('HydrologyN')
+        return StringToEnum('HydrologyN')[0]
 def HydrologyPEnum():
 …
         """
         return StringToEnum('HydrologyP')
+        return StringToEnum('HydrologyP')[0]
 def HydrologyQEnum():
 …
         """
         return StringToEnum('HydrologyQ')
+        return StringToEnum('HydrologyQ')[0]
 def HydrologySpcwatercolumnEnum():
 …
         """
         return StringToEnum('HydrologySpcwatercolumn')
+        return StringToEnum('HydrologySpcwatercolumn')[0]
 def HydrologyStabilizationEnum():
 …
         """
         return StringToEnum('HydrologyStabilization')
+        return StringToEnum('HydrologyStabilization')[0]
 def InversionControlParametersEnum():
 …
         """
         return StringToEnum('InversionControlParameters')
+        return StringToEnum('InversionControlParameters')[0]
 def InversionCostFunctionEnum():
 …
         """
         return StringToEnum('InversionCostFunction')
+        return StringToEnum('InversionCostFunction')[0]
 def InversionCostFunctionThresholdEnum():
 …
         """
         return StringToEnum('InversionCostFunctionThreshold')
+        return StringToEnum('InversionCostFunctionThreshold')[0]
 def InversionCostFunctionsCoefficientsEnum():
 …
         """
         return StringToEnum('InversionCostFunctionsCoefficients')
+        return StringToEnum('InversionCostFunctionsCoefficients')[0]
 def InversionCostFunctionsEnum():
 …
         """
         return StringToEnum('InversionCostFunctions')
+        return StringToEnum('InversionCostFunctions')[0]
 def InversionGradientOnlyEnum():
 …
         """
         return StringToEnum('InversionGradientOnly')
+        return StringToEnum('InversionGradientOnly')[0]
 def InversionGradientScalingEnum():
 …
         """
         return StringToEnum('InversionGradientScaling')
+        return StringToEnum('InversionGradientScaling')[0]
 def InversionIscontrolEnum():
 …
         """
         return StringToEnum('InversionIscontrol')
+        return StringToEnum('InversionIscontrol')[0]
 def InversionTaoEnum():
 …
         """
         return StringToEnum('InversionTao')
+        return StringToEnum('InversionTao')[0]
 def InversionIncompleteAdjointEnum():
 …
         """
         return StringToEnum('InversionIncompleteAdjoint')
+        return StringToEnum('InversionIncompleteAdjoint')[0]
 def InversionMaxParametersEnum():
 …
         """
         return StringToEnum('InversionMaxParameters')
+        return StringToEnum('InversionMaxParameters')[0]
 def InversionMaxiterPerStepEnum():
 …
         """
         return StringToEnum('InversionMaxiterPerStep')
+        return StringToEnum('InversionMaxiterPerStep')[0]
 def InversionMinParametersEnum():
 …
         """
         return StringToEnum('InversionMinParameters')
+        return StringToEnum('InversionMinParameters')[0]
 def InversionNstepsEnum():
 …
         """
         return StringToEnum('InversionNsteps')
+        return StringToEnum('InversionNsteps')[0]
 def InversionNumControlParametersEnum():
 …
         """
         return StringToEnum('InversionNumControlParameters')
+        return StringToEnum('InversionNumControlParameters')[0]
 def InversionNumCostFunctionsEnum():
 …
         """
         return StringToEnum('InversionNumCostFunctions')
+        return StringToEnum('InversionNumCostFunctions')[0]
 def InversionStepThresholdEnum():
 …
         """
         return StringToEnum('InversionStepThreshold')
+        return StringToEnum('InversionStepThreshold')[0]
 def InversionThicknessObsEnum():
 …
         """
         return StringToEnum('InversionThicknessObs')
+        return StringToEnum('InversionThicknessObs')[0]
 def InversionVelObsEnum():
 …
         """
         return StringToEnum('InversionVelObs')
+        return StringToEnum('InversionVelObs')[0]
 def InversionVxObsEnum():
 …
         """
         return StringToEnum('InversionVxObs')
+        return StringToEnum('InversionVxObs')[0]
 def InversionVyObsEnum():
 …
         """
         return StringToEnum('InversionVyObs')
+        return StringToEnum('InversionVyObs')[0]
 def InversionVzObsEnum():
 …
         """
         return StringToEnum('InversionVzObs')
+        return StringToEnum('InversionVzObs')[0]
 def MaskElementonfloatingiceEnum():
 …
         """
         return StringToEnum('MaskElementonfloatingice')
+        return StringToEnum('MaskElementonfloatingice')[0]
 def MaskElementongroundediceEnum():
 …
         """
         return StringToEnum('MaskElementongroundedice')
+        return StringToEnum('MaskElementongroundedice')[0]
 def MaskElementonwaterEnum():
 …
         """
         return StringToEnum('MaskElementonwater')
+        return StringToEnum('MaskElementonwater')[0]
 def MaskVertexonfloatingiceEnum():
 …
         """
         return StringToEnum('MaskVertexonfloatingice')
+        return StringToEnum('MaskVertexonfloatingice')[0]
 def MaskVertexongroundediceEnum():
 …
         """
         return StringToEnum('MaskVertexongroundedice')
+        return StringToEnum('MaskVertexongroundedice')[0]
 def MaskVertexonwaterEnum():
 …
         """
         return StringToEnum('MaskVertexonwater')
+        return StringToEnum('MaskVertexonwater')[0]
 def MaterialsBetaEnum():
 …
         """
         return StringToEnum('MaterialsBeta')
+        return StringToEnum('MaterialsBeta')[0]
 def MaterialsHeatcapacityEnum():
 …
         """
         return StringToEnum('MaterialsHeatcapacity')
+        return StringToEnum('MaterialsHeatcapacity')[0]
 def MaterialsLatentheatEnum():
 …
         """
         return StringToEnum('MaterialsLatentheat')
+        return StringToEnum('MaterialsLatentheat')[0]
 def MaterialsMeltingpointEnum():
 …
         """
         return StringToEnum('MaterialsMeltingpoint')
+        return StringToEnum('MaterialsMeltingpoint')[0]
 def MaterialsMixedLayerCapacityEnum():
 …
         """
         return StringToEnum('MaterialsMixedLayerCapacity')
+        return StringToEnum('MaterialsMixedLayerCapacity')[0]
 def MaterialsRheologyBEnum():
 …
         """
         return StringToEnum('MaterialsRheologyB')
+        return StringToEnum('MaterialsRheologyB')[0]
 def MaterialsRheologyBbarEnum():
 …
         """
         return StringToEnum('MaterialsRheologyBbar')
+        return StringToEnum('MaterialsRheologyBbar')[0]
 def MaterialsRheologyLawEnum():
 …
         """
         return StringToEnum('MaterialsRheologyLaw')
+        return StringToEnum('MaterialsRheologyLaw')[0]
 def MaterialsRheologyNEnum():
 …
         """
         return StringToEnum('MaterialsRheologyN')
+        return StringToEnum('MaterialsRheologyN')[0]
 def MaterialsRheologyZEnum():
 …
         """
         return StringToEnum('MaterialsRheologyZ')
+        return StringToEnum('MaterialsRheologyZ')[0]
 def MaterialsRheologyZbarEnum():
 …
         """
         return StringToEnum('MaterialsRheologyZbar')
+        return StringToEnum('MaterialsRheologyZbar')[0]
 def MaterialsRhoIceEnum():
 …
         """
         return StringToEnum('MaterialsRhoIce')
+        return StringToEnum('MaterialsRhoIce')[0]
 def MaterialsRhoWaterEnum():
 …
         """
         return StringToEnum('MaterialsRhoWater')
+        return StringToEnum('MaterialsRhoWater')[0]
 def MaterialsRhoFreshwaterEnum():
 …
         """
         return StringToEnum('MaterialsRhoFreshwater')
+        return StringToEnum('MaterialsRhoFreshwater')[0]
 def MaterialsMuWaterEnum():
 …
         """
         return StringToEnum('MaterialsMuWater')
+        return StringToEnum('MaterialsMuWater')[0]
 def MaterialsThermalExchangeVelocityEnum():
 …
         """
         return StringToEnum('MaterialsThermalExchangeVelocity')
+        return StringToEnum('MaterialsThermalExchangeVelocity')[0]
 def MaterialsThermalconductivityEnum():
 …
         """
         return StringToEnum('MaterialsThermalconductivity')
+        return StringToEnum('MaterialsThermalconductivity')[0]
 def MeshAverageVertexConnectivityEnum():
 …
         """
         return StringToEnum('MeshAverageVertexConnectivity')
+        return StringToEnum('MeshAverageVertexConnectivity')[0]
 def MeshDimensionEnum():
 …
         """
         return StringToEnum('MeshDimension')
+        return StringToEnum('MeshDimension')[0]
 def MeshEdgesEnum():
 …
         """
         return StringToEnum('MeshEdges')
+        return StringToEnum('MeshEdges')[0]
 def MeshElementconnectivityEnum():
 …
         """
         return StringToEnum('MeshElementconnectivity')
+        return StringToEnum('MeshElementconnectivity')[0]
 def MeshElementonbedEnum():
 …
         """
         return StringToEnum('MeshElementonbed')
+        return StringToEnum('MeshElementonbed')[0]
 def MeshElementonsurfaceEnum():
 …
         """
         return StringToEnum('MeshElementonsurface')
+        return StringToEnum('MeshElementonsurface')[0]
 def MeshElements2dEnum():
 …
         """
         return StringToEnum('MeshElements2d')
+        return StringToEnum('MeshElements2d')[0]
 def MeshElementsEnum():
 …
         """
         return StringToEnum('MeshElements')
+        return StringToEnum('MeshElements')[0]
 def MeshLowerelementsEnum():
 …
         """
         return StringToEnum('MeshLowerelements')
+        return StringToEnum('MeshLowerelements')[0]
 def MeshNumberofedgesEnum():
 …
         """
         return StringToEnum('MeshNumberofedges')
+        return StringToEnum('MeshNumberofedges')[0]
 def MeshNumberofelements2dEnum():
 …
         """
         return StringToEnum('MeshNumberofelements2d')
+        return StringToEnum('MeshNumberofelements2d')[0]
 def MeshNumberofelementsEnum():
 …
         """
         return StringToEnum('MeshNumberofelements')
+        return StringToEnum('MeshNumberofelements')[0]
 def MeshNumberoflayersEnum():
 …
         """
         return StringToEnum('MeshNumberoflayers')
+        return StringToEnum('MeshNumberoflayers')[0]
 def MeshNumberofvertices2dEnum():
 …
         """
         return StringToEnum('MeshNumberofvertices2d')
+        return StringToEnum('MeshNumberofvertices2d')[0]
 def MeshNumberofverticesEnum():
 …
         """
         return StringToEnum('MeshNumberofvertices')
+        return StringToEnum('MeshNumberofvertices')[0]
 def MeshUpperelementsEnum():
 …
         """
         return StringToEnum('MeshUpperelements')
+        return StringToEnum('MeshUpperelements')[0]
 def MeshVertexonbedEnum():
 …
         """
         return StringToEnum('MeshVertexonbed')
+        return StringToEnum('MeshVertexonbed')[0]
 def MeshVertexonsurfaceEnum():
 …
         """
         return StringToEnum('MeshVertexonsurface')
+        return StringToEnum('MeshVertexonsurface')[0]
 def MeshXEnum():
 …
         """
         return StringToEnum('MeshX')
+        return StringToEnum('MeshX')[0]
 def MeshYEnum():
 …
         """
         return StringToEnum('MeshY')
+        return StringToEnum('MeshY')[0]
 def MeshZEnum():
 …
         """
         return StringToEnum('MeshZ')
+        return StringToEnum('MeshZ')[0]
 def MiscellaneousNameEnum():
 …
         """
         return StringToEnum('MiscellaneousName')
+        return StringToEnum('MiscellaneousName')[0]
 def PrognosticHydrostaticAdjustmentEnum():
 …
         """
         return StringToEnum('PrognosticHydrostaticAdjustment')
+        return StringToEnum('PrognosticHydrostaticAdjustment')[0]
 def PrognosticMinThicknessEnum():
 …
         """
         return StringToEnum('PrognosticMinThickness')
+        return StringToEnum('PrognosticMinThickness')[0]
 def PrognosticPenaltyFactorEnum():
 …
         """
         return StringToEnum('PrognosticPenaltyFactor')
+        return StringToEnum('PrognosticPenaltyFactor')[0]
 def PrognosticSpcthicknessEnum():
 …
         """
         return StringToEnum('PrognosticSpcthickness')
+        return StringToEnum('PrognosticSpcthickness')[0]
 def PrognosticStabilizationEnum():
 …
         """
         return StringToEnum('PrognosticStabilization')
+        return StringToEnum('PrognosticStabilization')[0]
 def PrognosticVertexPairingEnum():
 …
         """
         return StringToEnum('PrognosticVertexPairing')
+        return StringToEnum('PrognosticVertexPairing')[0]
 def QmuIsdakotaEnum():
 …
         """
         return StringToEnum('QmuIsdakota')
+        return StringToEnum('QmuIsdakota')[0]
 def QmuMassFluxSegmentsEnum():
 …
         """
         return StringToEnum('QmuMassFluxSegments')
+        return StringToEnum('QmuMassFluxSegments')[0]
 def QmuNumberofpartitionsEnum():
 …
         """
         return StringToEnum('QmuNumberofpartitions')
+        return StringToEnum('QmuNumberofpartitions')[0]
 def QmuNumberofresponsesEnum():
 …
         """
         return StringToEnum('QmuNumberofresponses')
+        return StringToEnum('QmuNumberofresponses')[0]
 def QmuPartitionEnum():
 …
         """
         return StringToEnum('QmuPartition')
+        return StringToEnum('QmuPartition')[0]
 def QmuResponsedescriptorsEnum():
 …
         """
         return StringToEnum('QmuResponsedescriptors')
+        return StringToEnum('QmuResponsedescriptors')[0]
 def QmuVariabledescriptorsEnum():
 …
         """
         return StringToEnum('QmuVariabledescriptors')
+        return StringToEnum('QmuVariabledescriptors')[0]
 def RiftsNumriftsEnum():
 …
         """
         return StringToEnum('RiftsNumrifts')
+        return StringToEnum('RiftsNumrifts')[0]
 def RiftsRiftstructEnum():
 …
         """
         return StringToEnum('RiftsRiftstruct')
+        return StringToEnum('RiftsRiftstruct')[0]
 def SettingsIoGatherEnum():
 …
         """
         return StringToEnum('SettingsIoGather')
+        return StringToEnum('SettingsIoGather')[0]
 def SettingsLowmemEnum():
 …
         """
         return StringToEnum('SettingsLowmem')
+        return StringToEnum('SettingsLowmem')[0]
 def SettingsOutputFrequencyEnum():
 …
         """
         return StringToEnum('SettingsOutputFrequency')
+        return StringToEnum('SettingsOutputFrequency')[0]
 def SettingsResultsAsPatchesEnum():
 …
         """
         return StringToEnum('SettingsResultsAsPatches')
+        return StringToEnum('SettingsResultsAsPatches')[0]
 def SettingsWaitonlockEnum():
 …
         """
         return StringToEnum('SettingsWaitonlock')
+        return StringToEnum('SettingsWaitonlock')[0]
 def SurfaceforcingsDelta18oEnum():
 …
         """
         return StringToEnum('SurfaceforcingsDelta18o')
+        return StringToEnum('SurfaceforcingsDelta18o')[0]
 def SurfaceforcingsDelta18oSurfaceEnum():
 …
         """
         return StringToEnum('SurfaceforcingsDelta18oSurface')
+        return StringToEnum('SurfaceforcingsDelta18oSurface')[0]
 def SurfaceforcingsIsdelta18oEnum():
 …
         """
         return StringToEnum('SurfaceforcingsIsdelta18o')
+        return StringToEnum('SurfaceforcingsIsdelta18o')[0]
 def SurfaceforcingsPrecipitationsPresentdayEnum():
 …
         """
         return StringToEnum('SurfaceforcingsPrecipitationsPresentday')
+        return StringToEnum('SurfaceforcingsPrecipitationsPresentday')[0]
 def SurfaceforcingsTemperaturesPresentdayEnum():
 …
         """
         return StringToEnum('SurfaceforcingsTemperaturesPresentday')
+        return StringToEnum('SurfaceforcingsTemperaturesPresentday')[0]
 def SurfaceforcingsTemperaturesLgmEnum():
 …
         """
         return StringToEnum('SurfaceforcingsTemperaturesLgm')
+        return StringToEnum('SurfaceforcingsTemperaturesLgm')[0]
 def DebugProfilingEnum():
 …
         """
         return StringToEnum('DebugProfiling')
+        return StringToEnum('DebugProfiling')[0]
 def ProfilingCurrentMemEnum():
 …
         """
         return StringToEnum('ProfilingCurrentMem')
+        return StringToEnum('ProfilingCurrentMem')[0]
 def ProfilingCurrentFlopsEnum():
 …
         """
         return StringToEnum('ProfilingCurrentFlops')
+        return StringToEnum('ProfilingCurrentFlops')[0]
 def ProfilingSolutionTimeEnum():
 …
         """
         return StringToEnum('ProfilingSolutionTime')
+        return StringToEnum('ProfilingSolutionTime')[0]
 def MaxIterationConvergenceFlagEnum():
 …
         """
         return StringToEnum('MaxIterationConvergenceFlag')
+        return StringToEnum('MaxIterationConvergenceFlag')[0]
 def SteadystateMaxiterEnum():
 …
         """
         return StringToEnum('SteadystateMaxiter')
+        return StringToEnum('SteadystateMaxiter')[0]
 def SteadystateNumRequestedOutputsEnum():
 …
         """
         return StringToEnum('SteadystateNumRequestedOutputs')
+        return StringToEnum('SteadystateNumRequestedOutputs')[0]
 def SteadystateReltolEnum():
 …
         """
         return StringToEnum('SteadystateReltol')
+        return StringToEnum('SteadystateReltol')[0]
 def SteadystateRequestedOutputsEnum():
 …
         """
         return StringToEnum('SteadystateRequestedOutputs')
+        return StringToEnum('SteadystateRequestedOutputs')[0]
 def SurfaceEnum():
 …
         """
         return StringToEnum('Surface')
+        return StringToEnum('Surface')[0]
 def SurfaceforcingsPrecipitationEnum():
 …
         """
         return StringToEnum('SurfaceforcingsPrecipitation')
+        return StringToEnum('SurfaceforcingsPrecipitation')[0]
 def SurfaceforcingsMassBalanceEnum():
 …
         """
         return StringToEnum('SurfaceforcingsMassBalance')
+        return StringToEnum('SurfaceforcingsMassBalance')[0]
 def SurfaceforcingsIspddEnum():
 …
         """
         return StringToEnum('SurfaceforcingsIspdd')
+        return StringToEnum('SurfaceforcingsIspdd')[0]
 def SurfaceforcingsIssmbgradientsEnum():
 …
         """
         return StringToEnum('SurfaceforcingsIssmbgradients')
+        return StringToEnum('SurfaceforcingsIssmbgradients')[0]
 def SurfaceforcingsMonthlytemperaturesEnum():
 …
         """
         return StringToEnum('SurfaceforcingsMonthlytemperatures')
+        return StringToEnum('SurfaceforcingsMonthlytemperatures')[0]
 def SurfaceforcingsHcEnum():
 …
         """
         return StringToEnum('SurfaceforcingsHc')
+        return StringToEnum('SurfaceforcingsHc')[0]
 def SurfaceforcingsSmbPosMaxEnum():
 …
         """
         return StringToEnum('SurfaceforcingsSmbPosMax')
+        return StringToEnum('SurfaceforcingsSmbPosMax')[0]
 def SurfaceforcingsSmbPosMinEnum():
 …
         """
         return StringToEnum('SurfaceforcingsSmbPosMin')
+        return StringToEnum('SurfaceforcingsSmbPosMin')[0]
 def SurfaceforcingsAPosEnum():
 …
         """
         return StringToEnum('SurfaceforcingsAPos')
+        return StringToEnum('SurfaceforcingsAPos')[0]
 def SurfaceforcingsBPosEnum():
 …
         """
         return StringToEnum('SurfaceforcingsBPos')
+        return StringToEnum('SurfaceforcingsBPos')[0]
 def SurfaceforcingsANegEnum():
 …
         """
         return StringToEnum('SurfaceforcingsANeg')
+        return StringToEnum('SurfaceforcingsANeg')[0]
 def SurfaceforcingsBNegEnum():
 …
         """
         return StringToEnum('SurfaceforcingsBNeg')
+        return StringToEnum('SurfaceforcingsBNeg')[0]
 def ThermalMaxiterEnum():
 …
         """
         return StringToEnum('ThermalMaxiter')
+        return StringToEnum('ThermalMaxiter')[0]
 def ThermalPenaltyFactorEnum():
 …
         """
         return StringToEnum('ThermalPenaltyFactor')
+        return StringToEnum('ThermalPenaltyFactor')[0]
 def ThermalPenaltyLockEnum():
 …
         """
         return StringToEnum('ThermalPenaltyLock')
+        return StringToEnum('ThermalPenaltyLock')[0]
 def ThermalPenaltyThresholdEnum():
 …
         """
         return StringToEnum('ThermalPenaltyThreshold')
+        return StringToEnum('ThermalPenaltyThreshold')[0]
 def ThermalSpctemperatureEnum():
 …
         """
         return StringToEnum('ThermalSpctemperature')
+        return StringToEnum('ThermalSpctemperature')[0]
 def ThermalStabilizationEnum():
 …
         """
         return StringToEnum('ThermalStabilization')
+        return StringToEnum('ThermalStabilization')[0]
 def ThermalIsenthalpyEnum():
 …
         """
         return StringToEnum('ThermalIsenthalpy')
+        return StringToEnum('ThermalIsenthalpy')[0]
 def ThicknessEnum():
 …
         """
         return StringToEnum('Thickness')
+        return StringToEnum('Thickness')[0]
 def TimesteppingStartTimeEnum():
 …
         """
         return StringToEnum('TimesteppingStartTime')
+        return StringToEnum('TimesteppingStartTime')[0]
 def TimesteppingFinalTimeEnum():
 …
         """
         return StringToEnum('TimesteppingFinalTime')
+        return StringToEnum('TimesteppingFinalTime')[0]
 def TimesteppingCflCoefficientEnum():
 …
         """
         return StringToEnum('TimesteppingCflCoefficient')
+        return StringToEnum('TimesteppingCflCoefficient')[0]
 def TimesteppingTimeAdaptEnum():
 …
         """
         return StringToEnum('TimesteppingTimeAdapt')
+        return StringToEnum('TimesteppingTimeAdapt')[0]
 def TimesteppingTimeStepEnum():
 …
         """
         return StringToEnum('TimesteppingTimeStep')
+        return StringToEnum('TimesteppingTimeStep')[0]
 def TransientIsdiagnosticEnum():
 …
         """
         return StringToEnum('TransientIsdiagnostic')
+        return StringToEnum('TransientIsdiagnostic')[0]
 def TransientIsgroundinglineEnum():
 …
         """
         return StringToEnum('TransientIsgroundingline')
+        return StringToEnum('TransientIsgroundingline')[0]
 def TransientIsprognosticEnum():
 …
         """
         return StringToEnum('TransientIsprognostic')
+        return StringToEnum('TransientIsprognostic')[0]
 def TransientIsthermalEnum():
 …
         """
         return StringToEnum('TransientIsthermal')
+        return StringToEnum('TransientIsthermal')[0]
 def TransientNumRequestedOutputsEnum():
 …
         """
         return StringToEnum('TransientNumRequestedOutputs')
+        return StringToEnum('TransientNumRequestedOutputs')[0]
 def TransientRequestedOutputsEnum():
 …
         """
         return StringToEnum('TransientRequestedOutputs')
+        return StringToEnum('TransientRequestedOutputs')[0]
 def SolutionTypeEnum():
 …
         """
         return StringToEnum('SolutionType')
+        return StringToEnum('SolutionType')[0]
 def AnalysisTypeEnum():
 …
         """
         return StringToEnum('AnalysisType')
+        return StringToEnum('AnalysisType')[0]
 def ConfigurationTypeEnum():
 …
         """
         return StringToEnum('ConfigurationType')
+        return StringToEnum('ConfigurationType')[0]
 def AdjointBalancethicknessAnalysisEnum():
 …
         """
         return StringToEnum('AdjointBalancethicknessAnalysis')
+        return StringToEnum('AdjointBalancethicknessAnalysis')[0]
 def AdjointHorizAnalysisEnum():
 …
         """
         return StringToEnum('AdjointHorizAnalysis')
+        return StringToEnum('AdjointHorizAnalysis')[0]
 def AdjointSolutionEnum():
 …
         """
         return StringToEnum('AdjointSolution')
+        return StringToEnum('AdjointSolution')[0]
 def AnalysisCounterEnum():
 …
         """
         return StringToEnum('AnalysisCounter')
+        return StringToEnum('AnalysisCounter')[0]
 def BalancethicknessAnalysisEnum():
 …
         """
         return StringToEnum('BalancethicknessAnalysis')
+        return StringToEnum('BalancethicknessAnalysis')[0]
 def BalancethicknessSolutionEnum():
 …
         """
         return StringToEnum('BalancethicknessSolution')
+        return StringToEnum('BalancethicknessSolution')[0]
 def BedSlopeAnalysisEnum():
 …
         """
         return StringToEnum('BedSlopeAnalysis')
+        return StringToEnum('BedSlopeAnalysis')[0]
 def BedSlopeSolutionEnum():
 …
         """
         return StringToEnum('BedSlopeSolution')
+        return StringToEnum('BedSlopeSolution')[0]
 def BedSlopeXAnalysisEnum():
 …
         """
         return StringToEnum('BedSlopeXAnalysis')
+        return StringToEnum('BedSlopeXAnalysis')[0]
 def BedSlopeYAnalysisEnum():
 …
         """
         return StringToEnum('BedSlopeYAnalysis')
+        return StringToEnum('BedSlopeYAnalysis')[0]
 def DiagnosticHorizAnalysisEnum():
 …
         """
         return StringToEnum('DiagnosticHorizAnalysis')
+        return StringToEnum('DiagnosticHorizAnalysis')[0]
 def DiagnosticHutterAnalysisEnum():
 …
         """
         return StringToEnum('DiagnosticHutterAnalysis')
+        return StringToEnum('DiagnosticHutterAnalysis')[0]
 def DiagnosticSolutionEnum():
 …
         """
         return StringToEnum('DiagnosticSolution')
+        return StringToEnum('DiagnosticSolution')[0]
 def DiagnosticVertAnalysisEnum():
 …
         """
         return StringToEnum('DiagnosticVertAnalysis')
+        return StringToEnum('DiagnosticVertAnalysis')[0]
 def EnthalpyAnalysisEnum():
 …
         """
         return StringToEnum('EnthalpyAnalysis')
+        return StringToEnum('EnthalpyAnalysis')[0]
 def EnthalpySolutionEnum():
 …
         """
         return StringToEnum('EnthalpySolution')
+        return StringToEnum('EnthalpySolution')[0]
 def FlaimAnalysisEnum():
 …
         """
         return StringToEnum('FlaimAnalysis')
+        return StringToEnum('FlaimAnalysis')[0]
 def FlaimSolutionEnum():
 …
         """
         return StringToEnum('FlaimSolution')
+        return StringToEnum('FlaimSolution')[0]
 def HydrologyAnalysisEnum():
 …
         """
         return StringToEnum('HydrologyAnalysis')
+        return StringToEnum('HydrologyAnalysis')[0]
 def HydrologySolutionEnum():
 …
         """
         return StringToEnum('HydrologySolution')
+        return StringToEnum('HydrologySolution')[0]
 def MeltingAnalysisEnum():
 …
         """
         return StringToEnum('MeltingAnalysis')
+        return StringToEnum('MeltingAnalysis')[0]
 def NoneAnalysisEnum():
 …
         """
         return StringToEnum('NoneAnalysis')
+        return StringToEnum('NoneAnalysis')[0]
 def PrognosticAnalysisEnum():
 …
         """
         return StringToEnum('PrognosticAnalysis')
+        return StringToEnum('PrognosticAnalysis')[0]
 def PrognosticSolutionEnum():
 …
         """
         return StringToEnum('PrognosticSolution')
+        return StringToEnum('PrognosticSolution')[0]
 def SteadystateSolutionEnum():
 …
         """
         return StringToEnum('SteadystateSolution')
+        return StringToEnum('SteadystateSolution')[0]
 def SurfaceSlopeAnalysisEnum():
 …
         """
         return StringToEnum('SurfaceSlopeAnalysis')
+        return StringToEnum('SurfaceSlopeAnalysis')[0]
 def SurfaceSlopeSolutionEnum():
 …
         """
         return StringToEnum('SurfaceSlopeSolution')
+        return StringToEnum('SurfaceSlopeSolution')[0]
 def SurfaceSlopeXAnalysisEnum():
 …
         """
         return StringToEnum('SurfaceSlopeXAnalysis')
+        return StringToEnum('SurfaceSlopeXAnalysis')[0]
 def SurfaceSlopeYAnalysisEnum():
 …
         """
         return StringToEnum('SurfaceSlopeYAnalysis')
+        return StringToEnum('SurfaceSlopeYAnalysis')[0]
 def ThermalAnalysisEnum():
 …
         """
         return StringToEnum('ThermalAnalysis')
+        return StringToEnum('ThermalAnalysis')[0]
 def ThermalSolutionEnum():
 …
         """
         return StringToEnum('ThermalSolution')
+        return StringToEnum('ThermalSolution')[0]
 def TransientSolutionEnum():
 …
         """
         return StringToEnum('TransientSolution')
+        return StringToEnum('TransientSolution')[0]
 def ApproximationEnum():
 …
         """
+        return StringToEnum('Approximation')
+        return StringToEnum('Approximation')[0]
+def NoneApproximationEnum():
+        """
+        NONEAPPROXIMATIONENUM - Enum of NoneApproximation
+           Usage:
+              macro=NoneApproximationEnum()
+        """
+        return StringToEnum('NoneApproximation')[0]
 def HutterApproximationEnum():
 …
         """
         return StringToEnum('HutterApproximation')
+        return StringToEnum('HutterApproximation')[0]
 def MacAyealApproximationEnum():
 …
         """
         return StringToEnum('MacAyealApproximation')
+        return StringToEnum('MacAyealApproximation')[0]
 def MacAyealPattynApproximationEnum():
 …
         """
         return StringToEnum('MacAyealPattynApproximation')
+        return StringToEnum('MacAyealPattynApproximation')[0]
 def MacAyealStokesApproximationEnum():
 …
         """
         return StringToEnum('MacAyealStokesApproximation')
 def NoneApproximationEnum():
         """
         NONEAPPROXIMATIONENUM - Enum of NoneApproximation
            Usage:
               macro=NoneApproximationEnum()
         """
         return StringToEnum('NoneApproximation')
+        return StringToEnum('MacAyealStokesApproximation')[0]
+def L1L2ApproximationEnum():
+        """
+        L1L2APPROXIMATIONENUM - Enum of L1L2Approximation
+           Usage:
+              macro=L1L2ApproximationEnum()
+        """
+        return StringToEnum('L1L2Approximation')[0]
 def PattynApproximationEnum():
 …
         """
         return StringToEnum('PattynApproximation')
+        return StringToEnum('PattynApproximation')[0]
 def PattynStokesApproximationEnum():
 …
         """
         return StringToEnum('PattynStokesApproximation')
+        return StringToEnum('PattynStokesApproximation')[0]
 def StokesApproximationEnum():
 …
         """
         return StringToEnum('StokesApproximation')
+        return StringToEnum('StokesApproximation')[0]
 def ConstraintsEnum():
 …
         """
         return StringToEnum('Constraints')
+        return StringToEnum('Constraints')[0]
 def LoadsEnum():
 …
         """
         return StringToEnum('Loads')
+        return StringToEnum('Loads')[0]
 def MaterialsEnum():
 …
         """
         return StringToEnum('Materials')
+        return StringToEnum('Materials')[0]
 def NodesEnum():
 …
         """
         return StringToEnum('Nodes')
+        return StringToEnum('Nodes')[0]
 def ParametersEnum():
 …
         """
         return StringToEnum('Parameters')
+        return StringToEnum('Parameters')[0]
 def VerticesEnum():
 …
         """
         return StringToEnum('Vertices')
+        return StringToEnum('Vertices')[0]
 def ResultsEnum():
 …
         """
         return StringToEnum('Results')
+        return StringToEnum('Results')[0]
 def BoolInputEnum():
 …
         """
         return StringToEnum('BoolInput')
+        return StringToEnum('BoolInput')[0]
 def BoolParamEnum():
 …
         """
         return StringToEnum('BoolParam')
+        return StringToEnum('BoolParam')[0]
 def ContourEnum():
 …
         """
         return StringToEnum('Contour')
+        return StringToEnum('Contour')[0]
 def ControlInputEnum():
 …
         """
         return StringToEnum('ControlInput')
+        return StringToEnum('ControlInput')[0]
 def DatasetInputEnum():
 …
         """
         return StringToEnum('DatasetInput')
+        return StringToEnum('DatasetInput')[0]
 def DofIndexingEnum():
 …
         """
         return StringToEnum('DofIndexing')
+        return StringToEnum('DofIndexing')[0]
 def DoubleInputEnum():
 …
         """
         return StringToEnum('DoubleInput')
+        return StringToEnum('DoubleInput')[0]
 def DoubleMatArrayParamEnum():
 …
         """
         return StringToEnum('DoubleMatArrayParam')
+        return StringToEnum('DoubleMatArrayParam')[0]
 def DoubleMatParamEnum():
 …
         """
         return StringToEnum('DoubleMatParam')
+        return StringToEnum('DoubleMatParam')[0]
 def DoubleParamEnum():
 …
         """
         return StringToEnum('DoubleParam')
+        return StringToEnum('DoubleParam')[0]
 def DoubleVecParamEnum():
 …
         """
         return StringToEnum('DoubleVecParam')
+        return StringToEnum('DoubleVecParam')[0]
 def ElementEnum():
 …
         """
         return StringToEnum('Element')
+        return StringToEnum('Element')[0]
 def ElementResultEnum():
 …
         """
         return StringToEnum('ElementResult')
+        return StringToEnum('ElementResult')[0]
 def ExternalResultEnum():
 …
         """
         return StringToEnum('ExternalResult')
+        return StringToEnum('ExternalResult')[0]
 def FileParamEnum():
 …
         """
         return StringToEnum('FileParam')
+        return StringToEnum('FileParam')[0]
 def HookEnum():
 …
         """
         return StringToEnum('Hook')
+        return StringToEnum('Hook')[0]
 def IcefrontEnum():
 …
         """
         return StringToEnum('Icefront')
+        return StringToEnum('Icefront')[0]
 def InputEnum():
 …
         """
         return StringToEnum('Input')
+        return StringToEnum('Input')[0]
 def IntInputEnum():
 …
         """
         return StringToEnum('IntInput')
+        return StringToEnum('IntInput')[0]
 def IntParamEnum():
 …
         """
         return StringToEnum('IntParam')
+        return StringToEnum('IntParam')[0]
 def IntVecParamEnum():
 …
         """
         return StringToEnum('IntVecParam')
+        return StringToEnum('IntVecParam')[0]
 def TransientParamEnum():
 …
         """
         return StringToEnum('TransientParam')
+        return StringToEnum('TransientParam')[0]
 def MacAyeal2dIceFrontEnum():
 …
         """
         return StringToEnum('MacAyeal2dIceFront')
+        return StringToEnum('MacAyeal2dIceFront')[0]
 def MacAyeal3dIceFrontEnum():
 …
         """
         return StringToEnum('MacAyeal3dIceFront')
+        return StringToEnum('MacAyeal3dIceFront')[0]
 def MaticeEnum():
 …
         """
         return StringToEnum('Matice')
+        return StringToEnum('Matice')[0]
 def MatparEnum():
 …
         """
         return StringToEnum('Matpar')
+        return StringToEnum('Matpar')[0]
 def NodeEnum():
 …
         """
         return StringToEnum('Node')
+        return StringToEnum('Node')[0]
 def NumericalfluxEnum():
 …
         """
         return StringToEnum('Numericalflux')
+        return StringToEnum('Numericalflux')[0]
 def ParamEnum():
 …
         """
+        return StringToEnum('Param')
+        return StringToEnum('Param')[0]
+def L1L2IceFrontEnum():
+        """
+        L1L2ICEFRONTENUM - Enum of L1L2IceFront
+           Usage:
+              macro=L1L2IceFrontEnum()
+        """
+        return StringToEnum('L1L2IceFront')[0]
 def PattynIceFrontEnum():
 …
         """
         return StringToEnum('PattynIceFront')
+        return StringToEnum('PattynIceFront')[0]
 def PengridEnum():
 …
         """
         return StringToEnum('Pengrid')
+        return StringToEnum('Pengrid')[0]
 def PenpairEnum():
 …
         """
         return StringToEnum('Penpair')
+        return StringToEnum('Penpair')[0]
 def PentaEnum():
 …
         """
         return StringToEnum('Penta')
+        return StringToEnum('Penta')[0]
 def PentaP1InputEnum():
 …
         """
         return StringToEnum('PentaP1Input')
+        return StringToEnum('PentaP1Input')[0]
 def MatrixParamEnum():
 …
         """
         return StringToEnum('MatrixParam')
+        return StringToEnum('MatrixParam')[0]
 def VectorParamEnum():
 …
         """
         return StringToEnum('VectorParam')
+        return StringToEnum('VectorParam')[0]
 def RiftfrontEnum():
 …
         """
         return StringToEnum('Riftfront')
+        return StringToEnum('Riftfront')[0]
 def SegmentEnum():
 …
         """
         return StringToEnum('Segment')
+        return StringToEnum('Segment')[0]
 def SegmentRiftfrontEnum():
 …
         """
         return StringToEnum('SegmentRiftfront')
+        return StringToEnum('SegmentRiftfront')[0]
 def SpcDynamicEnum():
 …
         """
         return StringToEnum('SpcDynamic')
+        return StringToEnum('SpcDynamic')[0]
 def SpcStaticEnum():
 …
         """
         return StringToEnum('SpcStatic')
+        return StringToEnum('SpcStatic')[0]
 def SpcTransientEnum():
 …
         """
         return StringToEnum('SpcTransient')
+        return StringToEnum('SpcTransient')[0]
 def StokesIceFrontEnum():
 …
         """
         return StringToEnum('StokesIceFront')
+        return StringToEnum('StokesIceFront')[0]
 def StringArrayParamEnum():
 …
         """
         return StringToEnum('StringArrayParam')
+        return StringToEnum('StringArrayParam')[0]
 def StringParamEnum():
 …
         """
         return StringToEnum('StringParam')
+        return StringToEnum('StringParam')[0]
 def TriaEnum():
 …
         """
         return StringToEnum('Tria')
+        return StringToEnum('Tria')[0]
 def TriaP1InputEnum():
 …
         """
         return StringToEnum('TriaP1Input')
+        return StringToEnum('TriaP1Input')[0]
 def VertexEnum():
 …
         """
         return StringToEnum('Vertex')
+        return StringToEnum('Vertex')[0]
 def AirEnum():
 …
         """
         return StringToEnum('Air')
+        return StringToEnum('Air')[0]
 def IceEnum():
 …
         """
         return StringToEnum('Ice')
+        return StringToEnum('Ice')[0]
 def MelangeEnum():
 …
         """
         return StringToEnum('Melange')
+        return StringToEnum('Melange')[0]
 def WaterEnum():
 …
         """
         return StringToEnum('Water')
+        return StringToEnum('Water')[0]
 def ClosedEnum():
 …
         """
         return StringToEnum('Closed')
+        return StringToEnum('Closed')[0]
 def FreeEnum():
 …
         """
         return StringToEnum('Free')
+        return StringToEnum('Free')[0]
 def OpenEnum():
 …
         """
         return StringToEnum('Open')
+        return StringToEnum('Open')[0]
 def AdjointpEnum():
 …
         """
         return StringToEnum('Adjointp')
+        return StringToEnum('Adjointp')[0]
 def AdjointxEnum():
 …
         """
         return StringToEnum('Adjointx')
+        return StringToEnum('Adjointx')[0]
 def AdjointyEnum():
 …
         """
         return StringToEnum('Adjointy')
+        return StringToEnum('Adjointy')[0]
 def AdjointzEnum():
 …
         """
         return StringToEnum('Adjointz')
+        return StringToEnum('Adjointz')[0]
 def BedSlopeXEnum():
 …
         """
         return StringToEnum('BedSlopeX')
+        return StringToEnum('BedSlopeX')[0]
 def BedSlopeYEnum():
 …
         """
         return StringToEnum('BedSlopeY')
+        return StringToEnum('BedSlopeY')[0]
 def BoundaryEnum():
 …
         """
         return StringToEnum('Boundary')
+        return StringToEnum('Boundary')[0]
 def ConstantEnum():
 …
         """
         return StringToEnum('Constant')
+        return StringToEnum('Constant')[0]
 def ConvergedEnum():
 …
         """
         return StringToEnum('Converged')
+        return StringToEnum('Converged')[0]
 def ExtToIuEnum():
 …
         """
         return StringToEnum('ExtToIu')
+        return StringToEnum('ExtToIu')[0]
 def FillEnum():
 …
         """
         return StringToEnum('Fill')
+        return StringToEnum('Fill')[0]
 def FractionIncrementEnum():
 …
         """
         return StringToEnum('FractionIncrement')
+        return StringToEnum('FractionIncrement')[0]
 def FrictionEnum():
 …
         """
         return StringToEnum('Friction')
+        return StringToEnum('Friction')[0]
 def GroundinglineMeltingRateEnum():
 …
         """
         return StringToEnum('GroundinglineMeltingRate')
+        return StringToEnum('GroundinglineMeltingRate')[0]
 def InternalEnum():
 …
         """
         return StringToEnum('Internal')
+        return StringToEnum('Internal')[0]
 def IuToExtEnum():
 …
         """
         return StringToEnum('IuToExt')
+        return StringToEnum('IuToExt')[0]
 def MassFluxEnum():
 …
         """
         return StringToEnum('MassFlux')
+        return StringToEnum('MassFlux')[0]
 def MaxPenetrationEnum():
 …
         """
         return StringToEnum('MaxPenetration')
+        return StringToEnum('MaxPenetration')[0]
 def MeltingOffsetEnum():
 …
         """
         return StringToEnum('MeltingOffset')
+        return StringToEnum('MeltingOffset')[0]
 def MisfitEnum():
 …
         """
         return StringToEnum('Misfit')
+        return StringToEnum('Misfit')[0]
 def NumberNodeToElementConnectivityEnum():
 …
         """
         return StringToEnum('NumberNodeToElementConnectivity')
+        return StringToEnum('NumberNodeToElementConnectivity')[0]
 def PressureEnum():
 …
         """
         return StringToEnum('Pressure')
+        return StringToEnum('Pressure')[0]
 def PressurePicardEnum():
 …
         """
         return StringToEnum('PressurePicard')
+        return StringToEnum('PressurePicard')[0]
 def QmuPressureEnum():
 …
         """
         return StringToEnum('QmuPressure')
+        return StringToEnum('QmuPressure')[0]
 def QmuVxEnum():
 …
         """
         return StringToEnum('QmuVx')
+        return StringToEnum('QmuVx')[0]
 def QmuVyEnum():
 …
         """
         return StringToEnum('QmuVy')
+        return StringToEnum('QmuVy')[0]
 def QmuVzEnum():
 …
         """
         return StringToEnum('QmuVz')
+        return StringToEnum('QmuVz')[0]
 def QmuThicknessEnum():
 …
         """
         return StringToEnum('QmuThickness')
+        return StringToEnum('QmuThickness')[0]
 def QmuBedEnum():
 …
         """
         return StringToEnum('QmuBed')
+        return StringToEnum('QmuBed')[0]
 def QmuSurfaceEnum():
 …
         """
         return StringToEnum('QmuSurface')
+        return StringToEnum('QmuSurface')[0]
 def QmuMeltingEnum():
 …
         """
         return StringToEnum('QmuMelting')
+        return StringToEnum('QmuMelting')[0]
 def ResetPenaltiesEnum():
 …
         """
         return StringToEnum('ResetPenalties')
+        return StringToEnum('ResetPenalties')[0]
 def SegmentOnIceShelfEnum():
 …
         """
         return StringToEnum('SegmentOnIceShelf')
+        return StringToEnum('SegmentOnIceShelf')[0]
 def SurfaceAbsVelMisfitEnum():
 …
         """
         return StringToEnum('SurfaceAbsVelMisfit')
+        return StringToEnum('SurfaceAbsVelMisfit')[0]
 def SurfaceAreaEnum():
 …
         """
         return StringToEnum('SurfaceArea')
+        return StringToEnum('SurfaceArea')[0]
 def SurfaceAverageVelMisfitEnum():
 …
         """
         return StringToEnum('SurfaceAverageVelMisfit')
+        return StringToEnum('SurfaceAverageVelMisfit')[0]
 def SurfaceLogVelMisfitEnum():
 …
         """
         return StringToEnum('SurfaceLogVelMisfit')
+        return StringToEnum('SurfaceLogVelMisfit')[0]
 def SurfaceLogVxVyMisfitEnum():
 …
         """
         return StringToEnum('SurfaceLogVxVyMisfit')
+        return StringToEnum('SurfaceLogVxVyMisfit')[0]
 def SurfaceRelVelMisfitEnum():
 …
         """
         return StringToEnum('SurfaceRelVelMisfit')
+        return StringToEnum('SurfaceRelVelMisfit')[0]
 def SurfaceSlopeXEnum():
 …
         """
         return StringToEnum('SurfaceSlopeX')
+        return StringToEnum('SurfaceSlopeX')[0]
 def SurfaceSlopeYEnum():
 …
         """
         return StringToEnum('SurfaceSlopeY')
+        return StringToEnum('SurfaceSlopeY')[0]
 def TemperatureEnum():
 …
         """
         return StringToEnum('Temperature')
+        return StringToEnum('Temperature')[0]
 def TemperatureOldEnum():
 …
         """
         return StringToEnum('TemperatureOld')
+        return StringToEnum('TemperatureOld')[0]
 def TemperaturePicardEnum():
 …
         """
         return StringToEnum('TemperaturePicard')
+        return StringToEnum('TemperaturePicard')[0]
 def TemperatureSurfaceEnum():
 …
         """
         return StringToEnum('TemperatureSurface')
+        return StringToEnum('TemperatureSurface')[0]
 def TemperatureBasalEnum():
 …
         """
         return StringToEnum('TemperatureBasal')
+        return StringToEnum('TemperatureBasal')[0]
 def ThicknessAbsMisfitEnum():
 …
         """
         return StringToEnum('ThicknessAbsMisfit')
+        return StringToEnum('ThicknessAbsMisfit')[0]
 def TypeEnum():
 …
         """
         return StringToEnum('Type')
+        return StringToEnum('Type')[0]
 def VelEnum():
 …
         """
         return StringToEnum('Vel')
+        return StringToEnum('Vel')[0]
 def VelocityEnum():
 …
         """
         return StringToEnum('Velocity')
+        return StringToEnum('Velocity')[0]
 def VxAverageEnum():
 …
         """
         return StringToEnum('VxAverage')
+        return StringToEnum('VxAverage')[0]
 def VxEnum():
 …
         """
         return StringToEnum('Vx')
+        return StringToEnum('Vx')[0]
 def VxPicardEnum():
 …
         """
         return StringToEnum('VxPicard')
+        return StringToEnum('VxPicard')[0]
 def VyAverageEnum():
 …
         """
         return StringToEnum('VyAverage')
+        return StringToEnum('VyAverage')[0]
 def VyEnum():
 …
         """
         return StringToEnum('Vy')
+        return StringToEnum('Vy')[0]
 def VyPicardEnum():
 …
         """
         return StringToEnum('VyPicard')
+        return StringToEnum('VyPicard')[0]
 def VzEnum():
 …
         """
         return StringToEnum('Vz')
+        return StringToEnum('Vz')[0]
 def VzMacAyealEnum():
 …
         """
         return StringToEnum('VzMacAyeal')
+        return StringToEnum('VzMacAyeal')[0]
 def VzPattynEnum():
 …
         """
         return StringToEnum('VzPattyn')
+        return StringToEnum('VzPattyn')[0]
 def VzPicardEnum():
 …
         """
         return StringToEnum('VzPicard')
+        return StringToEnum('VzPicard')[0]
 def VzStokesEnum():
 …
         """
         return StringToEnum('VzStokes')
+        return StringToEnum('VzStokes')[0]
 def VxMeshEnum():
 …
         """
         return StringToEnum('VxMesh')
+        return StringToEnum('VxMesh')[0]
 def VyMeshEnum():
 …
         """
         return StringToEnum('VyMesh')
+        return StringToEnum('VyMesh')[0]
 def VzMeshEnum():
 …
         """
         return StringToEnum('VzMesh')
+        return StringToEnum('VzMesh')[0]
 def EnthalpyEnum():
 …
         """
         return StringToEnum('Enthalpy')
+        return StringToEnum('Enthalpy')[0]
 def EnthalpyPicardEnum():
 …
         """
         return StringToEnum('EnthalpyPicard')
+        return StringToEnum('EnthalpyPicard')[0]
 def ThicknessAbsGradientEnum():
 …
         """
+        return StringToEnum('ThicknessAbsGradient')
+        return StringToEnum('ThicknessAbsGradient')[0]
+def ThicknessAlongGradientEnum():
+        """
+        THICKNESSALONGGRADIENTENUM - Enum of ThicknessAlongGradient
+           Usage:
+              macro=ThicknessAlongGradientEnum()
+        """
+        return StringToEnum('ThicknessAlongGradient')[0]
+def ThicknessAcrossGradientEnum():
+        """
+        THICKNESSACROSSGRADIENTENUM - Enum of ThicknessAcrossGradient
+           Usage:
+              macro=ThicknessAcrossGradientEnum()
+        """
+        return StringToEnum('ThicknessAcrossGradient')[0]
 def StepResponsesEnum():
 …
         """
         return StringToEnum('StepResponses')
+        return StringToEnum('StepResponses')[0]
 def IntMatParamEnum():
 …
         """
         return StringToEnum('IntMatParam')
+        return StringToEnum('IntMatParam')[0]
 def RheologyBbarAbsGradientEnum():
 …
         """
         return StringToEnum('RheologyBbarAbsGradient')
+        return StringToEnum('RheologyBbarAbsGradient')[0]
 def DragCoefficientAbsGradientEnum():
 …
         """
         return StringToEnum('DragCoefficientAbsGradient')
+        return StringToEnum('DragCoefficientAbsGradient')[0]
 def TransientInputEnum():
 …
         """
         return StringToEnum('TransientInput')
+        return StringToEnum('TransientInput')[0]
 def OutputfilenameEnum():
 …
         """
         return StringToEnum('Outputfilename')
+        return StringToEnum('Outputfilename')[0]
 def WaterfractionEnum():
 …
         """
         return StringToEnum('Waterfraction')
+        return StringToEnum('Waterfraction')[0]
 def WatercolumnEnum():
 …
         """
         return StringToEnum('Watercolumn')
+        return StringToEnum('Watercolumn')[0]
 def BasalFrictionEnum():
 …
         """
         return StringToEnum('BasalFriction')
+        return StringToEnum('BasalFriction')[0]
 def ViscousHeatingEnum():
 …
         """
         return StringToEnum('ViscousHeating')
+        return StringToEnum('ViscousHeating')[0]
 def QmuTemperatureEnum():
 …
         """
         return StringToEnum('QmuTemperature')
+        return StringToEnum('QmuTemperature')[0]
 def HydrologyWaterVxEnum():
 …
         """
         return StringToEnum('HydrologyWaterVx')
+        return StringToEnum('HydrologyWaterVx')[0]
 def HydrologyWaterVyEnum():
 …
         """
         return StringToEnum('HydrologyWaterVy')
+        return StringToEnum('HydrologyWaterVy')[0]
 def StressTensorEnum():
 …
         """
         return StringToEnum('StressTensor')
+        return StringToEnum('StressTensor')[0]
 def StressTensorxxEnum():
 …
         """
         return StringToEnum('StressTensorxx')
+        return StringToEnum('StressTensorxx')[0]
 def StressTensorxyEnum():
 …
         """
         return StringToEnum('StressTensorxy')
+        return StringToEnum('StressTensorxy')[0]
 def StressTensorxzEnum():
 …
         """
         return StringToEnum('StressTensorxz')
+        return StringToEnum('StressTensorxz')[0]
 def StressTensoryyEnum():
 …
         """
         return StringToEnum('StressTensoryy')
+        return StringToEnum('StressTensoryy')[0]
 def StressTensoryzEnum():
 …
         """
         return StringToEnum('StressTensoryz')
+        return StringToEnum('StressTensoryz')[0]
 def StressTensorzzEnum():
 …
         """
+        return StringToEnum('StressTensorzz')
+        return StringToEnum('StressTensorzz')[0]
+def P0Enum():
+        """
+        P0ENUM - Enum of P0
+           Usage:
+              macro=P0Enum()
+        """
+        return StringToEnum('P0')[0]
+def P1Enum():
+        """
+        P1ENUM - Enum of P1
+           Usage:
+              macro=P1Enum()
+        """
+        return StringToEnum('P1')[0]
+def P1DGEnum():
+        """
+        P1DGENUM - Enum of P1DG
+           Usage:
+              macro=P1DGEnum()
+        """
+        return StringToEnum('P1DG')[0]
+def SaveResultsEnum():
+        """
+        SAVERESULTSENUM - Enum of SaveResults
+           Usage:
+              macro=SaveResultsEnum()
+        """
+        return StringToEnum('SaveResults')[0]
+def BoolElementResultEnum():
+        """
+        BOOLELEMENTRESULTENUM - Enum of BoolElementResult
+           Usage:
+              macro=BoolElementResultEnum()
+        """
+        return StringToEnum('BoolElementResult')[0]
+def BoolExternalResultEnum():
+        """
+        BOOLEXTERNALRESULTENUM - Enum of BoolExternalResult
+           Usage:
+              macro=BoolExternalResultEnum()
+        """
+        return StringToEnum('BoolExternalResult')[0]
+def DoubleElementResultEnum():
+        """
+        DOUBLEELEMENTRESULTENUM - Enum of DoubleElementResult
+           Usage:
+              macro=DoubleElementResultEnum()
+        """
+        return StringToEnum('DoubleElementResult')[0]
+def DoubleExternalResultEnum():
+        """
+        DOUBLEEXTERNALRESULTENUM - Enum of DoubleExternalResult
+           Usage:
+              macro=DoubleExternalResultEnum()
+        """
+        return StringToEnum('DoubleExternalResult')[0]
+def DoubleMatExternalResultEnum():
+        """
+        DOUBLEMATEXTERNALRESULTENUM - Enum of DoubleMatExternalResult
+           Usage:
+              macro=DoubleMatExternalResultEnum()
+        """
+        return StringToEnum('DoubleMatExternalResult')[0]
+def DoubleVecExternalResultEnum():
+        """
+        DOUBLEVECEXTERNALRESULTENUM - Enum of DoubleVecExternalResult
+           Usage:
+              macro=DoubleVecExternalResultEnum()
+        """
+        return StringToEnum('DoubleVecExternalResult')[0]
+def IntExternalResultEnum():
+        """
+        INTEXTERNALRESULTENUM - Enum of IntExternalResult
+           Usage:
+              macro=IntExternalResultEnum()
+        """
+        return StringToEnum('IntExternalResult')[0]
+def JEnum():
+        """
+        JENUM - Enum of J
+           Usage:
+              macro=JEnum()
+        """
+        return StringToEnum('J')[0]
+def PatchEnum():
+        """
+        PATCHENUM - Enum of Patch
+           Usage:
+              macro=PatchEnum()
+        """
+        return StringToEnum('Patch')[0]
+def PatchNodesEnum():
+        """
+        PATCHNODESENUM - Enum of PatchNodes
+           Usage:
+              macro=PatchNodesEnum()
+        """
+        return StringToEnum('PatchNodes')[0]
+def PatchVerticesEnum():
+        """
+        PATCHVERTICESENUM - Enum of PatchVertices
+           Usage:
+              macro=PatchVerticesEnum()
+        """
+        return StringToEnum('PatchVertices')[0]
+def PentaP1ElementResultEnum():
+        """
+        PENTAP1ELEMENTRESULTENUM - Enum of PentaP1ElementResult
+           Usage:
+              macro=PentaP1ElementResultEnum()
+        """
+        return StringToEnum('PentaP1ElementResult')[0]
+def PetscVecExternalResultEnum():
+        """
+        PETSCVECEXTERNALRESULTENUM - Enum of PetscVecExternalResult
+           Usage:
+              macro=PetscVecExternalResultEnum()
+        """
+        return StringToEnum('PetscVecExternalResult')[0]
+def StringExternalResultEnum():
+        """
+        STRINGEXTERNALRESULTENUM - Enum of StringExternalResult
+           Usage:
+              macro=StringExternalResultEnum()
+        """
+        return StringToEnum('StringExternalResult')[0]
+def StepEnum():
+        """
+        STEPENUM - Enum of Step
+           Usage:
+              macro=StepEnum()
+        """
+        return StringToEnum('Step')[0]
+def TimeEnum():
+        """
+        TIMEENUM - Enum of Time
+           Usage:
+              macro=TimeEnum()
+        """
+        return StringToEnum('Time')[0]
+def TriaP1ElementResultEnum():
+        """
+        TRIAP1ELEMENTRESULTENUM - Enum of TriaP1ElementResult
+           Usage:
+              macro=TriaP1ElementResultEnum()
+        """
+        return StringToEnum('TriaP1ElementResult')[0]
+def WaterColumnOldEnum():
+        """
+        WATERCOLUMNOLDENUM - Enum of WaterColumnOld
+           Usage:
+              macro=WaterColumnOldEnum()
+        """
+        return StringToEnum('WaterColumnOld')[0]
+def MinVelEnum():
+        """
+        MINVELENUM - Enum of MinVel
+           Usage:
+              macro=MinVelEnum()
+        """
+        return StringToEnum('MinVel')[0]
+def MaxVelEnum():
+        """
+        MAXVELENUM - Enum of MaxVel
+           Usage:
+              macro=MaxVelEnum()
+        """
+        return StringToEnum('MaxVel')[0]
+def MinVxEnum():
+        """
+        MINVXENUM - Enum of MinVx
+           Usage:
+              macro=MinVxEnum()
+        """
+        return StringToEnum('MinVx')[0]
+def MaxVxEnum():
+        """
+        MAXVXENUM - Enum of MaxVx
+           Usage:
+              macro=MaxVxEnum()
+        """
+        return StringToEnum('MaxVx')[0]
+def MaxAbsVxEnum():
+        """
+        MAXABSVXENUM - Enum of MaxAbsVx
+           Usage:
+              macro=MaxAbsVxEnum()
+        """
+        return StringToEnum('MaxAbsVx')[0]
+def MinVyEnum():
+        """
+        MINVYENUM - Enum of MinVy
+           Usage:
+              macro=MinVyEnum()
+        """
+        return StringToEnum('MinVy')[0]
+def MaxVyEnum():
+        """
+        MAXVYENUM - Enum of MaxVy
+           Usage:
+              macro=MaxVyEnum()
+        """
+        return StringToEnum('MaxVy')[0]
+def MaxAbsVyEnum():
+        """
+        MAXABSVYENUM - Enum of MaxAbsVy
+           Usage:
+              macro=MaxAbsVyEnum()
+        """
+        return StringToEnum('MaxAbsVy')[0]
+def MinVzEnum():
+        """
+        MINVZENUM - Enum of MinVz
+           Usage:
+              macro=MinVzEnum()
+        """
+        return StringToEnum('MinVz')[0]
+def MaxVzEnum():
+        """
+        MAXVZENUM - Enum of MaxVz
+           Usage:
+              macro=MaxVzEnum()
+        """
+        return StringToEnum('MaxVz')[0]
+def MaxAbsVzEnum():
+        """
+        MAXABSVZENUM - Enum of MaxAbsVz
+           Usage:
+              macro=MaxAbsVzEnum()
+        """
+        return StringToEnum('MaxAbsVz')[0]
 def IceVolumeEnum():
 …
         """
         return StringToEnum('IceVolume')
+        return StringToEnum('IceVolume')[0]
 def TotalSmbEnum():
 …
         """
+        return StringToEnum('TotalSmb')
+def ThicknessAlongGradientEnum():
+        """
+        THICKNESSALONGGRADIENTENUM - Enum of ThicknessAlongGradient
+           Usage:
+              macro=ThicknessAlongGradientEnum()
+        """
+        return StringToEnum('ThicknessAlongGradient')
+def ThicknessAcrossGradientEnum():
+        """
+        THICKNESSACROSSGRADIENTENUM - Enum of ThicknessAcrossGradient
+           Usage:
+              macro=ThicknessAcrossGradientEnum()
+        """
+        return StringToEnum('ThicknessAcrossGradient')
+def P0Enum():
+        """
+        P0ENUM - Enum of P0
+           Usage:
+              macro=P0Enum()
+        """
+        return StringToEnum('P0')
+def P1Enum():
+        """
+        P1ENUM - Enum of P1
+           Usage:
+              macro=P1Enum()
+        """
+        return StringToEnum('P1')
+def P1DGEnum():
+        """
+        P1DGENUM - Enum of P1DG
+           Usage:
+              macro=P1DGEnum()
+        """
+        return StringToEnum('P1DG')
+def SaveResultsEnum():
+        """
+        SAVERESULTSENUM - Enum of SaveResults
+           Usage:
+              macro=SaveResultsEnum()
+        """
+        return StringToEnum('SaveResults')
+def BoolElementResultEnum():
+        """
+        BOOLELEMENTRESULTENUM - Enum of BoolElementResult
+           Usage:
+              macro=BoolElementResultEnum()
+        """
+        return StringToEnum('BoolElementResult')
+def BoolExternalResultEnum():
+        """
+        BOOLEXTERNALRESULTENUM - Enum of BoolExternalResult
+           Usage:
+              macro=BoolExternalResultEnum()
+        """
+        return StringToEnum('BoolExternalResult')
+def DoubleElementResultEnum():
+        """
+        DOUBLEELEMENTRESULTENUM - Enum of DoubleElementResult
+           Usage:
+              macro=DoubleElementResultEnum()
+        """
+        return StringToEnum('DoubleElementResult')
+def DoubleExternalResultEnum():
+        """
+        DOUBLEEXTERNALRESULTENUM - Enum of DoubleExternalResult
+           Usage:
+              macro=DoubleExternalResultEnum()
+        """
+        return StringToEnum('DoubleExternalResult')
+def DoubleMatExternalResultEnum():
+        """
+        DOUBLEMATEXTERNALRESULTENUM - Enum of DoubleMatExternalResult
+           Usage:
+              macro=DoubleMatExternalResultEnum()
+        """
+        return StringToEnum('DoubleMatExternalResult')
+def DoubleVecExternalResultEnum():
+        """
+        DOUBLEVECEXTERNALRESULTENUM - Enum of DoubleVecExternalResult
+           Usage:
+              macro=DoubleVecExternalResultEnum()
+        """
+        return StringToEnum('DoubleVecExternalResult')
+def IntExternalResultEnum():
+        """
+        INTEXTERNALRESULTENUM - Enum of IntExternalResult
+           Usage:
+              macro=IntExternalResultEnum()
+        """
+        return StringToEnum('IntExternalResult')
+def JEnum():
+        """
+        JENUM - Enum of J
+           Usage:
+              macro=JEnum()
+        """
+        return StringToEnum('J')
+def PatchEnum():
+        """
+        PATCHENUM - Enum of Patch
+           Usage:
+              macro=PatchEnum()
+        """
+        return StringToEnum('Patch')
+def PatchNodesEnum():
+        """
+        PATCHNODESENUM - Enum of PatchNodes
+           Usage:
+              macro=PatchNodesEnum()
+        """
+        return StringToEnum('PatchNodes')
+def PatchVerticesEnum():
+        """
+        PATCHVERTICESENUM - Enum of PatchVertices
+           Usage:
+              macro=PatchVerticesEnum()
+        """
+        return StringToEnum('PatchVertices')
+def PentaP1ElementResultEnum():
+        """
+        PENTAP1ELEMENTRESULTENUM - Enum of PentaP1ElementResult
+           Usage:
+              macro=PentaP1ElementResultEnum()
+        """
+        return StringToEnum('PentaP1ElementResult')
+def PetscVecExternalResultEnum():
+        """
+        PETSCVECEXTERNALRESULTENUM - Enum of PetscVecExternalResult
+           Usage:
+              macro=PetscVecExternalResultEnum()
+        """
+        return StringToEnum('PetscVecExternalResult')
+def StringExternalResultEnum():
+        """
+        STRINGEXTERNALRESULTENUM - Enum of StringExternalResult
+           Usage:
+              macro=StringExternalResultEnum()
+        """
+        return StringToEnum('StringExternalResult')
+def StepEnum():
+        """
+        STEPENUM - Enum of Step
+           Usage:
+              macro=StepEnum()
+        """
+        return StringToEnum('Step')
+def TimeEnum():
+        """
+        TIMEENUM - Enum of Time
+           Usage:
+              macro=TimeEnum()
+        """
+        return StringToEnum('Time')
+def TriaP1ElementResultEnum():
+        """
+        TRIAP1ELEMENTRESULTENUM - Enum of TriaP1ElementResult
+           Usage:
+              macro=TriaP1ElementResultEnum()
+        """
+        return StringToEnum('TriaP1ElementResult')
+def WaterColumnOldEnum():
+        """
+        WATERCOLUMNOLDENUM - Enum of WaterColumnOld
+           Usage:
+              macro=WaterColumnOldEnum()
+        """
+        return StringToEnum('WaterColumnOld')
+def MinVelEnum():
+        """
+        MINVELENUM - Enum of MinVel
+           Usage:
+              macro=MinVelEnum()
+        """
+        return StringToEnum('MinVel')
+def MaxVelEnum():
+        """
+        MAXVELENUM - Enum of MaxVel
+           Usage:
+              macro=MaxVelEnum()
+        """
+        return StringToEnum('MaxVel')
+def MinVxEnum():
+        """
+        MINVXENUM - Enum of MinVx
+           Usage:
+              macro=MinVxEnum()
+        """
+        return StringToEnum('MinVx')
+def MaxVxEnum():
+        """
+        MAXVXENUM - Enum of MaxVx
+           Usage:
+              macro=MaxVxEnum()
+        """
+        return StringToEnum('MaxVx')
+def MaxAbsVxEnum():
+        """
+        MAXABSVXENUM - Enum of MaxAbsVx
+           Usage:
+              macro=MaxAbsVxEnum()
+        """
+        return StringToEnum('MaxAbsVx')
+def MinVyEnum():
+        """
+        MINVYENUM - Enum of MinVy
+           Usage:
+              macro=MinVyEnum()
+        """
+        return StringToEnum('MinVy')
+def MaxVyEnum():
+        """
+        MAXVYENUM - Enum of MaxVy
+           Usage:
+              macro=MaxVyEnum()
+        """
+        return StringToEnum('MaxVy')
+def MaxAbsVyEnum():
+        """
+        MAXABSVYENUM - Enum of MaxAbsVy
+           Usage:
+              macro=MaxAbsVyEnum()
+        """
+        return StringToEnum('MaxAbsVy')
+def MinVzEnum():
+        """
+        MINVZENUM - Enum of MinVz
+           Usage:
+              macro=MinVzEnum()
+        """
+        return StringToEnum('MinVz')
+def MaxVzEnum():
+        """
+        MAXVZENUM - Enum of MaxVz
+           Usage:
+              macro=MaxVzEnum()
+        """
+        return StringToEnum('MaxVz')
+def MaxAbsVzEnum():
+        """
+        MAXABSVZENUM - Enum of MaxAbsVz
+           Usage:
+              macro=MaxAbsVzEnum()
+        """
+        return StringToEnum('MaxAbsVz')
+        return StringToEnum('TotalSmb')[0]
 def RelativeEnum():
 …
         """
         return StringToEnum('Relative')
+        return StringToEnum('Relative')[0]
 def AbsoluteEnum():
 …
         """
         return StringToEnum('Absolute')
+        return StringToEnum('Absolute')[0]
 def IncrementalEnum():
 …
         """
         return StringToEnum('Incremental')
+        return StringToEnum('Incremental')[0]
 def AgressiveMigrationEnum():
 …
         """
         return StringToEnum('AgressiveMigration')
+        return StringToEnum('AgressiveMigration')[0]
 def NoneEnum():
 …
         """
         return StringToEnum('None')
+        return StringToEnum('None')[0]
 def SoftMigrationEnum():
 …
         """
         return StringToEnum('SoftMigration')
+        return StringToEnum('SoftMigration')[0]
 def StokesSolverEnum():
 …
         """
         return StringToEnum('StokesSolver')
+        return StringToEnum('StokesSolver')[0]
 def AdjointEnum():
 …
         """
         return StringToEnum('Adjoint')
+        return StringToEnum('Adjoint')[0]
 def ColinearEnum():
 …
         """
         return StringToEnum('Colinear')
+        return StringToEnum('Colinear')[0]
 def ControlSteadyEnum():
 …
         """
         return StringToEnum('ControlSteady')
+        return StringToEnum('ControlSteady')[0]
 def FsetEnum():
 …
         """
         return StringToEnum('Fset')
+        return StringToEnum('Fset')[0]
 def Gradient1Enum():
 …
         """
         return StringToEnum('Gradient1')
+        return StringToEnum('Gradient1')[0]
 def Gradient2Enum():
 …
         """
         return StringToEnum('Gradient2')
+        return StringToEnum('Gradient2')[0]
 def Gradient3Enum():
 …
         """
         return StringToEnum('Gradient3')
+        return StringToEnum('Gradient3')[0]
 def GradientEnum():
 …
         """
         return StringToEnum('Gradient')
+        return StringToEnum('Gradient')[0]
 def GroundinglineMigrationEnum():
 …
         """
         return StringToEnum('GroundinglineMigration')
+        return StringToEnum('GroundinglineMigration')[0]
 def GsetEnum():
 …
         """
         return StringToEnum('Gset')
+        return StringToEnum('Gset')[0]
 def IndexEnum():
 …
         """
         return StringToEnum('Index')
+        return StringToEnum('Index')[0]
 def IndexedEnum():
 …
         """
         return StringToEnum('Indexed')
+        return StringToEnum('Indexed')[0]
 def IntersectEnum():
 …
         """
         return StringToEnum('Intersect')
+        return StringToEnum('Intersect')[0]
 def NodalEnum():
 …
         """
         return StringToEnum('Nodal')
+        return StringToEnum('Nodal')[0]
 def OldGradientEnum():
 …
         """
         return StringToEnum('OldGradient')
+        return StringToEnum('OldGradient')[0]
 def OutputFilePointerEnum():
 …
         """
         return StringToEnum('OutputFilePointer')
+        return StringToEnum('OutputFilePointer')[0]
 def PetscOptionsAnalysesEnum():
 …
         """
         return StringToEnum('PetscOptionsAnalyses')
+        return StringToEnum('PetscOptionsAnalyses')[0]
 def PetscOptionsStringsEnum():
 …
         """
         return StringToEnum('PetscOptionsStrings')
+        return StringToEnum('PetscOptionsStrings')[0]
 def QmuErrNameEnum():
 …
         """
         return StringToEnum('QmuErrName')
+        return StringToEnum('QmuErrName')[0]
 def QmuInNameEnum():
 …
         """
         return StringToEnum('QmuInName')
+        return StringToEnum('QmuInName')[0]
 def QmuOutNameEnum():
 …
         """
         return StringToEnum('QmuOutName')
+        return StringToEnum('QmuOutName')[0]
 def RegularEnum():
 …
         """
         return StringToEnum('Regular')
+        return StringToEnum('Regular')[0]
 def ScaledEnum():
 …
         """
         return StringToEnum('Scaled')
+        return StringToEnum('Scaled')[0]
 def SeparateEnum():
 …
         """
         return StringToEnum('Separate')
+        return StringToEnum('Separate')[0]
 def SsetEnum():
 …
         """
         return StringToEnum('Sset')
+        return StringToEnum('Sset')[0]
 def VerboseEnum():
 …
         """
         return StringToEnum('Verbose')
+        return StringToEnum('Verbose')[0]
 def TriangleInterpEnum():
 …
         """
         return StringToEnum('TriangleInterp')
+        return StringToEnum('TriangleInterp')[0]
 def BilinearInterpEnum():
 …
         """
         return StringToEnum('BilinearInterp')
+        return StringToEnum('BilinearInterp')[0]
 def NearestInterpEnum():
 …
         """
         return StringToEnum('NearestInterp')
+        return StringToEnum('NearestInterp')[0]
 def XYEnum():
 …
         """
         return StringToEnum('XY')
+        return StringToEnum('XY')[0]
 def XYZPEnum():
 …
         """
         return StringToEnum('XYZP')
+        return StringToEnum('XYZP')[0]
 def OptionEnum():
 …
         """
         return StringToEnum('Option')
+        return StringToEnum('Option')[0]
 def OptionCellEnum():
 …
         """
         return StringToEnum('OptionCell')
+        return StringToEnum('OptionCell')[0]
 def OptionCharEnum():
 …
         """
         return StringToEnum('OptionChar')
+        return StringToEnum('OptionChar')[0]
 def OptionStructEnum():
 …
         """
         return StringToEnum('OptionStruct')
+        return StringToEnum('OptionStruct')[0]
 def OptionDoubleEnum():
 …
         """
         return StringToEnum('OptionDouble')
+        return StringToEnum('OptionDouble')[0]
 def OptionLogicalEnum():
 …
         """
         return StringToEnum('OptionLogical')
+        return StringToEnum('OptionLogical')[0]
 def PatersonEnum():
 …
         """
         return StringToEnum('Paterson')
+        return StringToEnum('Paterson')[0]
 def ArrheniusEnum():
 …
         """
         return StringToEnum('Arrhenius')
+        return StringToEnum('Arrhenius')[0]
 def MaximumNumberOfEnums():
 …
         """
         return 462
+        return 463

issm/branches/trunk-jpl-damage/src/m/enum/MaximumNumberOfEnums.m

r12947	r13101
9	9	% macro=MaximumNumberOfEnums()
10	10
11		macro=462;
	11	macro=463;

issm/branches/trunk-jpl-damage/src/modules/BamgConvertMesh/BamgConvertMesh.cpp

-              r12878
+              r13101
         /*Check inputs*/
         if(nels<0) _error2_("Number of elements must be positive, check index number of lines");
         if(nods<0) _error2_("Number of nods must be positive, check x and y sizes");
         if(test1!=3) _error2_("index should have 3 columns");
         if(test2!=nods) _error2_("x and y do not have the same length");
+        if(nels<0) _error_("Number of elements must be positive, check index number of lines");
+        if(nods<0) _error_("Number of nods must be positive, check x and y sizes");
+        if(test1!=3) _error_("index should have 3 columns");
+        if(test2!=nods) _error_("x and y do not have the same length");
         /* Run core computations: */

issm/branches/trunk-jpl-damage/src/modules/BamgTriangulate/BamgTriangulate.cpp

-              r12878
+              r13101
         /*Check inputs*/
         if(y_rows!=nods)         _error2_("x and y do not have the same length");
         if(x_cols>1 || y_cols>1) _error2_("x and y should have only one column");
         if(nods<3)               _error2_("At least 3 points are required");
+        if(y_rows!=nods)         _error_("x and y do not have the same length");
+        if(x_cols>1 || y_cols>1) _error_("x and y should have only one column");
+        if(nods<3)               _error_("At least 3 points are required");
         /* Run core computations: */

issm/branches/trunk-jpl-damage/src/modules/Chaco/Chaco.cpp

-              r12878
+              r13101
         #ifndef _HAVE_CHACO_ //only works if dakota library has been compiled in.
         _error2_("Chaco not available! Cannot carry out Chaco partitioning!");
+        _error_("Chaco not available! Cannot carry out Chaco partitioning!");
         #endif
 …
         nvtxs = mxGetN(A_IN);
         mwstart = mxGetJc(A_IN);
         start=(int*)xmalloc((nvtxs+1)*sizeof(int));
+        start=xNew<int>((nvtxs+1));
         for (i=0; i<nvtxs+1;i++)start[i]=(int)mwstart[i];
         mwadjacency = mxGetIr(A_IN);
         adjacency = (int*)xmalloc(mxGetNzmax(A_IN)*sizeof(int));
+        adjacency = xNew<int>(mxGetNzmax(A_IN));
         for (i=0; i<mxGetNzmax(A_IN); i++) adjacency[i]= (int)mwadjacency[i];
         nedges = start[nvtxs];
         if(!mxIsEmpty(EWGTS_IN)){
                 ewgts = (float*)xcalloc(nedges, sizeof(float));
+                ewgts = xNewZeroInit<float>(nedges);
                 doublepointer=mxGetPr(A_IN);
                 for (i = 0; i < nedges; i++)ewgts[i] = (float)doublepointer[i];
 …
         for (i=0;i<(nterms<10?nterms:10);i++) options[i]=in_options[i]; //copy in_options into default options
         FetchData(&npart,NPARTS_IN);
         nparts=(int*)xmalloc(sizeof(int)); nparts[0]=npart; //weird Chacox interface ain't it?
+        nparts=xNew<int>(1); nparts[0]=npart; //weird Chacox interface ain't it?
         FetchData(&goal,&nterms,GOAL_IN);
 …
         /*Allocate output: */
         assignment = (short*)xcalloc(nvtxs, sizeof(short));
+        assignment = xNewZeroInit<short>(nvtxs);
     /*Call core: */
 …
     /*Output data: */
         doubleassignment=(double*)xmalloc(nvtxs*sizeof(double));
+        doubleassignment=xNew<double>(nvtxs);
         for(i=0;i<nvtxs;i++) doubleassignment[i]=(double)assignment[i];
         WriteData(ASSGN_OUT,doubleassignment,nvtxs);

issm/branches/trunk-jpl-damage/src/modules/ContourToMesh/ContourToMesh.cpp

-              r12878
+              r13101
         if(nlhs!=1 && nlhs!=2){
                 ContourToMeshUsage();
                 _error2_("usage. See above");
+                _error_("usage. See above");
+        }
         #endif
 …
         if(nrhs!=NRHS){
                 ContourToMeshUsage();
                 _error2_("usage. See above");
+                _error_("usage. See above");
+        }
 …
                 WriteData(PLHS1,in_elem);
+        }
         else _error2_("wrong interpolation type");
+        else _error_("wrong interpolation type");
         /*end module: */

issm/branches/trunk-jpl-damage/src/modules/ContourToNodes/ContourToNodes.cpp

-              r12878
+              r13101
         numcontours=mxGetNumberOfElements(matlabstructure);
         contours=(Contour**)xmalloc(numcontours*sizeof(Contour*));
+        contours=xNew<Contour*>(numcontours);
         for(i=0;i<numcontours;i++){
                 //allocate
                 contouri=(Contour*)xmalloc(sizeof(Contour));
+                contouri=xNew<Contour>(1);
                 //retrieve dimension of this contour.
                 contouri->nods=(int)mxGetScalar(mxGetField(matlabstructure,i,"nods"));

issm/branches/trunk-jpl-damage/src/modules/EnumToString/EnumToString.cpp

-              r12878
+              r13101
 #include "./EnumToString.h"
 void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
+WRAPPER(EnumToString){
         char    *name    = NULL;
         int      enum_in;
+        /*checks on arguments on the matlab side: */
+        if(nrhs!=NRHS){
+                EnumToStringUsage(); _error2_("usage. See above");
+        }
+        /*Boot module: */
+        MODULEBOOT();
+        /*checks on arguments: */
+        CHECKARGUMENTS(NLHS,NRHS,&EnumToStringUsage);
         /*Fetch inputs: */
 …
         /* output: */
         WriteData(NAME,name);
+        /*end module: */
+        MODULEEND();
+}

issm/branches/trunk-jpl-damage/src/modules/EnumToString/EnumToString.h

-              r12013
+              r13101
 #define _ENUMTOSTRING_H
+/* local prototypes: */
+void EnumToStringUsage(void);
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#else
+#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!"
+#endif
+/*Very important definition in case we are compiling a python module!: needs to come before header files inclusion*/
+#ifdef _HAVE_PYTHON_
+#define PY_ARRAY_UNIQUE_SYMBOL PythonIOSymbol
+#endif
+/*Header files: */
 #include "../../c/include/globals.h"
 #include "../../c/modules/modules.h"
 …
 #include "../../c/issm-binding.h"
+#ifdef _HAVE_MATLAB_MODULES_
 /* serial input macros: */
 #define ENUMIN (mxArray*)prhs[0]
 /* serial output macros: */
 #define NAME (mxArray**)&plhs[0]
+#endif
+#ifdef _HAVE_PYTHON_MODULES_
+/* serial input macros: */
+#define ENUMIN PyTuple_GetItem(args,0)
+/* serial output macros: */
+#define NAME output,0
+#endif
 /* serial arg counts: */
 …
 #define __FUNCT__  "EnumToString"
+/* local prototypes: */
+void EnumToStringUsage(void);
 #endif  /* _TEST_H */

issm/branches/trunk-jpl-damage/src/modules/Exp2Kml/Exp2Kml.cpp

-              r12878
+              r13101
         /*checks on arguments on the matlab side: */
         if (nlhs > NLHS) {
                 Exp2KmlUsage(); _error2_("Exp2Kml usage error");
+                Exp2KmlUsage(); _error_("Exp2Kml usage error");
+        }
         if (nrhs < NRHS) {
                 Exp2KmlUsage(); _error2_("Exp2Kml usage error");
+                Exp2KmlUsage(); _error_("Exp2Kml usage error");
+        }
 …
         /*some checks*/
         if (sgn !=+1 && sgn !=-1) _error2_("Hemisphere sgn=" << sgn << " must be +1 (north) or -1 (south).");
         if (fabs(cm)      > 180.) _error2_("Central meridian cm=" << cm << " must be between -180 (west) and +180 (east) degrees.");
         if (sp < 0. || sp >  90.) _error2_("Standard parallel sp=" << sp << " must be between 0 and 90 degrees (in specified hemisphere).");
+        if (sgn !=+1 && sgn !=-1) _error_("Hemisphere sgn=" << sgn << " must be +1 (north) or -1 (south).");
+        if (fabs(cm)      > 180.) _error_("Central meridian cm=" << cm << " must be between -180 (west) and +180 (east) degrees.");
+        if (sp < 0. || sp >  90.) _error_("Standard parallel sp=" << sp << " must be between 0 and 90 degrees (in specified hemisphere).");
         /* Run core computations: */

issm/branches/trunk-jpl-damage/src/modules/InternalFront/InternalFront.cpp

-              r12878
+              r13101
         /*Fetch required fields*/
         FetchData(&numberofelements,mxGetAssignedField(MODEL,0,"numberofelements"));
         if(numberofelements<=0) _error2_("No elements found in the model");
+        if(numberofelements<=0) _error_("No elements found in the model");
         FetchData(&elements,&M,&N,mxGetAssignedField(MODEL,0,"elements"));
         if(M!=numberofelements || N!=3) _error2_("Field 'elements' should be of size [md.numberofelements 3]");
+        if(M!=numberofelements || N!=3) _error_("Field 'elements' should be of size [md.numberofelements 3]");
         FetchData(&elementonwater,&M,&N,mxGetAssignedField(MODEL,0,"elementonwater"));
         if(M!=numberofelements || N!=1) _error2_("Field 'elementonwater' should be of size [md.numberofelements 1]");
+        if(M!=numberofelements || N!=1) _error_("Field 'elementonwater' should be of size [md.numberofelements 1]");
         FetchData(&elementconnectivity,&M,&N,mxGetAssignedField(MODEL,0,"elementconnectivity"));
         if(M!=numberofelements || N!=3) _error2_("Field 'elementconnectivity' should be of size [md.numberofelements 3]");
+        if(M!=numberofelements || N!=3) _error_("Field 'elementconnectivity' should be of size [md.numberofelements 3]");
         /*Allocate and initialize all variables*/
         numberofsegments=0;
         front=(int*)xmalloc(3*numberofelements*4*sizeof(int));
+        front=xNew<int>(3*numberofelements*4);
         /*Loop over all elements on water*/
 …
         /*Now that we know how many segments there is we can allocate the final matrix*/
         if(numberofsegments){
                 front2=(double*)xmalloc(4*numberofsegments*sizeof(double));
+                front2=xNew<double>(4*numberofsegments);
                 for(i=0;i<4*numberofsegments;i++) front2[i]=(double)front[i];
+        }

issm/branches/trunk-jpl-damage/src/modules/InterpFromGridToMesh/InterpFromGridToMesh.cpp

r12878	r13101
46	46	if((nlhs!=NLHS) \|\| (nrhs!=6 && nrhs!=7)){
47	47	InterpFromGridToMeshUsage();
48		_error2_("usage. See above");
	48	_error_("usage. See above");
49	49	}
50	50

issm/branches/trunk-jpl-damage/src/modules/InterpFromMesh2d/InterpFromMesh2d.cpp

-              r12878
+              r13101
         if(nlhs!=NLHS){
                 InterpFromMesh2dUsage();
                 _error2_("InterpFromMeshToMesh2dUsage usage error");
+                _error_("InterpFromMeshToMesh2dUsage usage error");
+        }
         if((nrhs!=6) && (nrhs!=7) && (nrhs!=8)){
                 InterpFromMesh2dUsage();
                 _error2_("InterpFromMeshToMesh2dUsage usage error");
+                _error_("InterpFromMeshToMesh2dUsage usage error");
+        }
 …
                 /*contours: */
                 numcontours=mxGetNumberOfElements(matlabstructure);
                 contours=(Contour**)xmalloc(numcontours*sizeof(Contour*));
+                contours=xNew<Contour*>(numcontours);
                 for(i=0;i<numcontours;i++){
                         //allocate
                         contouri=(Contour*)xmalloc(sizeof(Contour));
+                        contouri=xNew<Contour>(1);
                         //retrieve dimension of this contour.
                         contouri->nods=(int)mxGetScalar(mxGetField(matlabstructure,i,"nods"));
 …
         /*some checks*/
         if (x_data_rows!=y_data_rows){
                 _error2_("vectors x and y should have the same length!");
+                _error_("vectors x and y should have the same length!");
+        }
         if (x_prime_rows!=y_prime_rows){
                 _error2_("vectors x_prime and y_prime should have the same length!");
+                _error_("vectors x_prime and y_prime should have the same length!");
+        }

issm/branches/trunk-jpl-damage/src/modules/InterpFromMeshToMesh2d/InterpFromMeshToMesh2d.cpp

-              r12878
+              r13101
         if(nlhs!=NLHS){
                 InterpFromMeshToMesh2dUsage();
                 _error2_("InterpFromMeshToMesh2dUsage usage error");
+                _error_("InterpFromMeshToMesh2dUsage usage error");
+        }
         #endif
 …
         if(nrhs<NRHS){
                 InterpFromMeshToMesh2dUsage();
                 _error2_("InterpFromMeshToMesh2dUsage usage error");
+                _error_("InterpFromMeshToMesh2dUsage usage error");
+        }
         /*Fetch inputs: */
         FetchData(&index,&nels_data,&test,INDEX); if(test!=3) _error2_("index should have 3 columns");
         FetchData(&x_data,&nods_data,X);          if(nods_data<3) _error2_("there should be at least three points");
         FetchData(&y_data,&test,Y);               if(test!=nods_data) _error2_("vectors x and y should have the same length");
         FetchData(&data,&M_data,&N_data,DATA);    if(M_data*N_data<1) _error2_("data is empty");
         FetchData(&x_interp,&N_interp,XINTERP);   if(N_interp<1) _error2_("no interpolation requested");
         FetchData(&y_interp,&test,YINTERP);       if(test!=N_interp) _error2_("vectors x_interp and y_interp should have the same length");
+        FetchData(&index,&nels_data,&test,INDEX); if(test!=3) _error_("index should have 3 columns");
+        FetchData(&x_data,&nods_data,X);          if(nods_data<3) _error_("there should be at least three points");
+        FetchData(&y_data,&test,Y);               if(test!=nods_data) _error_("vectors x and y should have the same length");
+        FetchData(&data,&M_data,&N_data,DATA);    if(M_data*N_data<1) _error_("data is empty");
+        FetchData(&x_interp,&N_interp,XINTERP);   if(N_interp<1) _error_("no interpolation requested");
+        FetchData(&y_interp,&test,YINTERP);       if(test!=N_interp) _error_("vectors x_interp and y_interp should have the same length");
         FetchData(&options,NRHS,nrhs,ARGUMENTS);

issm/branches/trunk-jpl-damage/src/modules/InterpFromMeshToMesh3d/InterpFromMeshToMesh3d.cpp

-              r12878
+              r13101
         /*some checks*/
         if (x_data_rows!=y_data_rows || x_data_rows!=z_data_rows){
                 _error2_("vectors x, y and z should have the same length!");
+                _error_("vectors x, y and z should have the same length!");
+        }
         if (x_prime_rows!=y_prime_rows || x_prime_rows!=z_prime_rows){
                 _error2_("vectors x_prime, y_prime and z_prime should have the same length!");
+                _error_("vectors x_prime, y_prime and z_prime should have the same length!");
+        }
         /*get number of elements and number of nodes in the data*/

issm/branches/trunk-jpl-damage/src/modules/KMLFileRead/KMLFileRead.cpp

-              r12878
+              r13101
         /*checks on arguments on the matlab side: */
         if (nlhs > NLHS) {
                 KMLFileReadUsage(); _error2_("KMLFileRead usage error");
+                KMLFileReadUsage(); _error_("KMLFileRead usage error");
+        }
         if (nrhs < NRHS) {
                 KMLFileReadUsage(); _error2_("KMLFileRead usage error");
+                KMLFileReadUsage(); _error_("KMLFileRead usage error");
+        }

issm/branches/trunk-jpl-damage/src/modules/KMLMeshWrite/KMLMeshWrite.cpp

-              r12878
+              r13101
         /*checks on arguments on the matlab side: */
         if (nlhs > NLHS) {
                 KMLMeshWriteUsage(); _error2_("KMLMeshWrite usage error");
+                KMLMeshWriteUsage(); _error_("KMLMeshWrite usage error");
+        }
         if (nrhs < NRHS) {
                 KMLMeshWriteUsage(); _error2_("KMLMeshWrite usage error");
+                KMLMeshWriteUsage(); _error_("KMLMeshWrite usage error");
+        }
 …
                         if (notesi && mxIsChar(notesi) && mxGetNumberOfElements(notesi)) {
                                 if (!notes) {
                                         notes=(char *) xmalloc((mxGetNumberOfElements(notesi)+1)*sizeof(char));
+                                        notes=xNew<char>(mxGetNumberOfElements(notesi)+1);
                                         mxGetString(notesi,notes,mxGetNumberOfElements(notesi)+1);
+                                }
 …
         if (nodecon && (mncon != nnodes))
           {_error2_("Nodal connectivity table, if supplied, must be supplied for all nodes.");}
+          {_error_("Nodal connectivity table, if supplied, must be supplied for all nodes.");}
         else if (!nodecon)
                 mncon=nnodes;
         if ((llat != nnodes) || (llng != nnodes) || (llat != llng))
                 _error2_("Latitude and longitude vectors must be supplied for all nodes.");
+                _error_("Latitude and longitude vectors must be supplied for all nodes.");
         if (part && (lprt != nnodes))
                 _error2_("Partitioning vector, if supplied, must be supplied for all nodes.");
+                _error_("Partitioning vector, if supplied, must be supplied for all nodes.");
         if (data && !((mdata == nnodes) || (mdata == melem)))
                 _error2_("Data matrix, if supplied, must be supplied for all nodes or all elements.");
+                _error_("Data matrix, if supplied, must be supplied for all nodes or all elements.");
         if (cmap && (ncmap != 3))
                 _error2_("Colormap matrix, if supplied, must have three columns for rgb.");
+                _error_("Colormap matrix, if supplied, must have three columns for rgb.");
         if (!strlen(filnam))
                 strcpy(filnam,"stdout");

issm/branches/trunk-jpl-damage/src/modules/KMLOverlay/KMLOverlay.cpp

-              r12878
+              r13101
         /*checks on arguments on the matlab side: */
         if(nlhs>NLHS){
                 KMLOverlayUsage(); _error2_("KMLOverlay usage error");
+                KMLOverlayUsage(); _error_("KMLOverlay usage error");
+        }
         if(nrhs<NRHS){
                 KMLOverlayUsage(); _error2_("KMLOverlay usage error");
+                KMLOverlayUsage(); _error_("KMLOverlay usage error");
+        }
 …
         /*some checks*/
         if (nlat !=2) _error2_("Latitudinal axes \"lataxis\" require two double values, not " << nlat << ".");
         if (nlong!=2) _error2_("Longitudinal axes \"longaxis\" require two double values, not " << nlong << ".");
         if (!nimages) _error2_("No image files provided.");
+        if (nlat !=2) _error_("Latitudinal axes \"lataxis\" require two double values, not " << nlat << ".");
+        if (nlong!=2) _error_("Longitudinal axes \"longaxis\" require two double values, not " << nlong << ".");
+        if (!nimages) _error_("No image files provided.");
         if ((int)dzip){
 …
                 if (verbose) _printLine_(czip);
                 if (mexEvalString(czip)) _error2_("Error zipping file \"" << filkmz << "\".");
+                if (mexEvalString(czip)) _error_("Error zipping file \"" << filkmz << "\".");
                 xfree((void**)&czip);
                 xfree((void**)&filkmz);

issm/branches/trunk-jpl-damage/src/modules/Kml2Exp/Kml2Exp.cpp

-              r12878
+              r13101
         /*checks on arguments on the matlab side: */
         if (nlhs > NLHS) {
                 Kml2ExpUsage(); _error2_("Kml2Exp usage error");
+                Kml2ExpUsage(); _error_("Kml2Exp usage error");
+        }
         if (nrhs < NRHS) {
                 Kml2ExpUsage(); _error2_("Kml2Exp usage error");
+                Kml2ExpUsage(); _error_("Kml2Exp usage error");
+        }
 …
         /*some checks*/
         if (sgn !=+1 && sgn!= -1) _error2_("Hemisphere sgn=" << sgn << " must be +1 (north) or -1 (south).");
         if (fabs(cm)      > 180.) _error2_("Central meridian cm=" << cm << " must be between -180 (west) and +180 (east) degrees.");
         if (sp < 0. || sp >  90.) _error2_("Standard parallel sp=" << sp << " must be between 0 and 90 degrees (in specified hemisphere).");
+        if (sgn !=+1 && sgn!= -1) _error_("Hemisphere sgn=" << sgn << " must be +1 (north) or -1 (south).");
+        if (fabs(cm)      > 180.) _error_("Central meridian cm=" << cm << " must be between -180 (west) and +180 (east) degrees.");
+        if (sp < 0. || sp >  90.) _error_("Standard parallel sp=" << sp << " must be between 0 and 90 degrees (in specified hemisphere).");
         /* Run core computations: */

issm/branches/trunk-jpl-damage/src/modules/Kriging/Kriging.cpp

-              r12878
+              r13101
         /*checks on arguments on the matlab side: */
         if (nrhs<NRHS || nlhs>NLHS){
                 KrigingUsage(); _error2_("Kriging usage error");
+                KrigingUsage(); _error_("Kriging usage error");
+        }
         /*Fetch inputs: */
         FetchData(&x,&n_obs,X);
         FetchData(&y,&N,Y);                       if(n_obs!=N) _error2_("x and y should have the same size");
         FetchData(&observations,&N,OBSERVATIONS); if(n_obs!=N) _error2_("x and observations should have the same size");
+        FetchData(&y,&N,Y);                       if(n_obs!=N) _error_("x and y should have the same size");
+        FetchData(&observations,&N,OBSERVATIONS); if(n_obs!=N) _error_("x and observations should have the same size");
         FetchData(&x_interp,&M_interp,&N_interp,XINTERP);
         FetchData(&y_interp,&M,&N,YINTERP);       if(N!=N_interp || M!=M_interp) _error2_("x_interp and y_interp should have the same size");
+        FetchData(&y_interp,&M,&N,YINTERP);       if(N!=N_interp || M!=M_interp) _error_("x_interp and y_interp should have the same size");
         FetchData(&options,NRHS,nrhs,prhs);

issm/branches/trunk-jpl-damage/src/modules/Ll2xy/Ll2xy.cpp

-              r12878
+              r13101
         /*checks on arguments on the matlab side: */
         if (nlhs > NLHS) {
                 Ll2xyUsage(); _error2_("Ll2xy usage error");
+                Ll2xyUsage(); _error_("Ll2xy usage error");
+        }
         if (nrhs < NRHS) {
                 Ll2xyUsage(); _error2_("Ll2xy usage error");
+                Ll2xyUsage(); _error_("Ll2xy usage error");
+        }
 …
         /*some checks*/
         if (verbose) _printLine_("Checking inputs:");
         if (nlat != nlon){_error2_("Must have same number of lat[" << nlat << "] and lon[" << nlon << "] coordinates.");}
+        if (nlat != nlon){_error_("Must have same number of lat[" << nlat << "] and lon[" << nlon << "] coordinates.");}
         else                ncoord=nlat;
         if (sgn != +1 && sgn != -1) _error2_("Hemisphere sgn=" << sgn << " must be +1 (north) or -1 (south).");
         if (fabs(cm)      > 180.) _error2_("Central meridian cm=" << cm << " must be between -180 (west) and +180 (east) degrees.");
         if (sp < 0. || sp >  90.) _error2_("Standard parallel sp=" << sp << " must be between 0 and 90 degrees (in specified hemisphere).");
+        if (sgn != +1 && sgn != -1) _error_("Hemisphere sgn=" << sgn << " must be +1 (north) or -1 (south).");
+        if (fabs(cm)      > 180.) _error_("Central meridian cm=" << cm << " must be between -180 (west) and +180 (east) degrees.");
+        if (sp < 0. || sp >  90.) _error_("Standard parallel sp=" << sp << " must be between 0 and 90 degrees (in specified hemisphere).");
         x=(double*)mxMalloc(ncoord*sizeof(double));

issm/branches/trunk-jpl-damage/src/modules/MeshPartition/MeshPartition.cpp

-              r12878
+              r13101
         /*Post process node_partitioning and element_partitioning to be in double format. Metis needed them in int* format: */
         element_partitioning=(double*)xmalloc(numberofelements*sizeof(double));
+        element_partitioning=xNew<double>(numberofelements);
         for (i=0;i<numberofelements;i++){
                 element_partitioning[i]=(double)int_element_partitioning[i]+1; //Metis indexing from 0, matlab from 1.
+        }
         node_partitioning=(double*)xmalloc(numberofvertices*sizeof(double));
+        node_partitioning=xNew<double>(numberofvertices);
         for (i=0;i<numberofvertices;i++){
                 node_partitioning[i]=(double)int_node_partitioning[i]+1; //Metis indexing from 0, matlab from 1.

issm/branches/trunk-jpl-damage/src/modules/MeshProfileIntersection/MeshProfileIntersection.cpp

-              r12878
+              r13101
         //index
         FetchData(&double_index,&nel,&dummy,INDEX);
         if(dummy!=3 && dummy!=6)_error2_("element triangulation should be of 3 or 6 column width!");
         index=(int*)xmalloc(nel*3*sizeof(int));
+        if(dummy!=3 && dummy!=6)_error_("element triangulation should be of 3 or 6 column width!");
+        index=xNew<int>(nel*3);
         for(i=0;i<nel;i++){
                 for(j=0;j<3;j++){
 …
         //contours
         numcontours=mxGetNumberOfElements(matlabstructure);
         contours=(Contour**)xmalloc(numcontours*sizeof(Contour*));
+        contours=xNew<Contour*>(numcontours);
         for(i=0;i<numcontours;i++){
                 //allocate
                 contouri=(Contour*)xmalloc(sizeof(Contour));
+                contouri=xNew<Contour>(1);
                 //retrieve dimension of this contour.
                 contouri->nods=(int)mxGetScalar(mxGetField(matlabstructure,i,"nods"));

issm/branches/trunk-jpl-damage/src/modules/Scotch/Scotch.cpp

r12878	r13101
25	25
26	26	#ifndef _HAVE_SCOTCH_ //only works if scotch library has been compiled in.
27		_error2_("Scotch not available! Cannot carry out Scotch partitioning!");
	27	_error_("Scotch not available! Cannot carry out Scotch partitioning!");
28	28	#else
29	29

issm/branches/trunk-jpl-damage/src/modules/Shp2Kml/Shp2Kml.cpp

-              r12878
+              r13101
         #ifndef _HAVE_SHAPELIB_ //only works if shapelib library has been compiled in.
         _error2_("Shapelib not available! Cannot carry out shp file translation!");
+        _error_("Shapelib not available! Cannot carry out shp file translation!");
         #endif
 …
         /*checks on arguments on the matlab side: */
         if (nlhs > NLHS) {
                 Shp2KmlUsage(); _error2_("Shp2Kml usage error");
+                Shp2KmlUsage(); _error_("Shp2Kml usage error");
+        }
         if (nrhs < NRHS) {
                 Shp2KmlUsage(); _error2_("Shp2Kml usage error");
+                Shp2KmlUsage(); _error_("Shp2Kml usage error");
+        }
 …
         /*some checks*/
         if (sgn < -1 || sgn > +1) _error2_("Hemisphere sgn=" << sgn << " must be +1 (north), -1 (south), or 0 (no translation).");
         if (fabs(cm)      > 180.) _error2_("Central meridian cm=" << cm << " must be between -180 (west) and +180 (east) degrees.");
         if (sp < 0. || sp >  90.) _error2_("Standard parallel sp=" << sp << " must be between 0 and 90 degrees (in specified hemisphere).");
+        if (sgn < -1 || sgn > +1) _error_("Hemisphere sgn=" << sgn << " must be +1 (north), -1 (south), or 0 (no translation).");
+        if (fabs(cm)      > 180.) _error_("Central meridian cm=" << cm << " must be between -180 (west) and +180 (east) degrees.");
+        if (sp < 0. || sp >  90.) _error_("Standard parallel sp=" << sp << " must be between 0 and 90 degrees (in specified hemisphere).");
         /* Run core computations: */

issm/branches/trunk-jpl-damage/src/modules/StringToEnum/StringToEnum.cpp

-              r12878
+              r13101
 #include "./StringToEnum.h"
 void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
+WRAPPER(StringToEnum){
         char    *name    = NULL;
         int      enum_out;
+        /*checks on arguments on the matlab side: */
+        if(nrhs!=NRHS){
+                StringToEnumUsage(); _error2_("usage. See above");
+        }
+        /*Boot module: */
+        MODULEBOOT();
+        /*checks on arguments: */
+        CHECKARGUMENTS(NLHS,NRHS,&StringToEnumUsage);
         /*Fetch inputs: */
 …
         /* output: */
         WriteData(ENUMOUT,enum_out);
+        /*end module: */
+        MODULEEND();
+}

issm/branches/trunk-jpl-damage/src/modules/StringToEnum/StringToEnum.h

-              r12013
+              r13101
 #define _STRINGTOENUM_H
+/* local prototypes: */
+void StringToEnumUsage(void);
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#else
+#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!"
+#endif
+/*Very important definition in case we are compiling a python module!: needs to come before header files inclusion*/
+#ifdef _HAVE_PYTHON_
+#define PY_ARRAY_UNIQUE_SYMBOL PythonIOSymbol
+#endif
+/*Header files: */
 #include "../../c/include/globals.h"
 #include "../../c/modules/modules.h"
 …
 #include "../../c/issm-binding.h"
+#ifdef _HAVE_MATLAB_MODULES_
 /* serial input macros: */
 #define NAME (mxArray*)prhs[0]
 /* serial output macros: */
 #define ENUMOUT (mxArray**)&plhs[0]
+#endif
+#ifdef _HAVE_PYTHON_MODULES_
+/* serial input macros: */
+#define NAME PyTuple_GetItem(args,0)
+/* serial output macros: */
+#define ENUMOUT output,0
+#endif
 /* serial arg counts: */
 …
 #define __FUNCT__  "StringToEnum"
+/* local prototypes: */
+void StringToEnumUsage(void);
 #endif  /* _TEST_H */

issm/branches/trunk-jpl-damage/src/modules/TriMeshProcessRifts/TriMeshProcessRifts.cpp

-              r12878
+              r13101
                 nel=mxGetM(prhs[0]);
                 tindex_in=mxGetPr(prhs[0]);
                 index_in=(double*)xmalloc(nel*3*sizeof(double));
+                index_in=xNew<double>(nel*3);
                 for (i=0;i<nel;i++){
                         for (j=0;j<3;j++){
 …
                 nods=mxGetM(prhs[1]);
                 x_inm=mxGetPr(prhs[1]);
                 x_in=(double*)xmalloc(nods*sizeof(double));
+                x_in=xNew<double>(nods);
                 for (i=0;i<nods;i++){
                         x_in[i]=x_inm[i];
 …
         if(mxIsDouble(prhs[2])){
                 y_inm=mxGetPr(prhs[2]);
                 y_in=(double*)xmalloc(nods*sizeof(double));
+                y_in=xNew<double>(nods);
                 for (i=0;i<nods;i++){
                         y_in[i]=y_inm[i];
 …
                 num_seg=mxGetM(prhs[3]);
                 tsegments_in=mxGetPr(prhs[3]);
                 segments_in=(double*)xmalloc(num_seg*3*sizeof(double));
+                segments_in=xNew<double>(num_seg*3);
                 for (i=0;i<num_seg;i++){
                         for (j=0;j<3;j++){
 …
         if(mxIsDouble(prhs[4])){
                 tsegmentmarkers_in=mxGetPr(prhs[4]);
                 segmentmarkers_in=(double*)xmalloc(num_seg*sizeof(double));
+                segmentmarkers_in=xNew<double>(num_seg);
                 for (i=0;i<num_seg;i++){
                         segmentmarkers_in[i]=tsegmentmarkers_in[i];

issm/branches/trunk-jpl-damage/src/modules/Xy2ll/Xy2ll.cpp

-              r12878
+              r13101
         /*checks on arguments on the matlab side: */
         if (nlhs > NLHS) {
                 Xy2llUsage(); _error2_("Xy2ll usage error");
+                Xy2llUsage(); _error_("Xy2ll usage error");
+        }
         if (nrhs < NRHS) {
                 Xy2llUsage(); _error2_("Xy2ll usage error");
+                Xy2llUsage(); _error_("Xy2ll usage error");
+        }
 …
         /*some checks*/
         if   (nx != ny){_error2_("Must have same number of x[" << nx << "] and y[" << ny << "] coordinates.");}
+        if   (nx != ny){_error_("Must have same number of x[" << nx << "] and y[" << ny << "] coordinates.");}
         else            ncoord=nx;
         if (sgn != +1 && sgn != -1) _error2_("Hemisphere sgn=" << sgn << " must be +1 (north) or -1 (south).");
         if (fabs(cm)      > 180.) _error2_("Central meridian cm=" << cm << " must be between -180 (west) and +180 (east) degrees.");
         if (sp < 0. || sp >  90.) _error2_("Standard parallel sp=" << sp << " must be between 0 and 90 degrees (in specified hemisphere).");
+        if (sgn != +1 && sgn != -1) _error_("Hemisphere sgn=" << sgn << " must be +1 (north) or -1 (south).");
+        if (fabs(cm)      > 180.) _error_("Central meridian cm=" << cm << " must be between -180 (west) and +180 (east) degrees.");
+        if (sp < 0. || sp >  90.) _error_("Standard parallel sp=" << sp << " must be between 0 and 90 degrees (in specified hemisphere).");
         lat=(double*)mxMalloc(ncoord*sizeof(double));

issm/branches/trunk-jpl-damage/src/modules/matlab/Makefile.am

-              r12878
+              r13101
+INCLUDES = @DAKOTAINCL@ @MATLABINCL@ @PETSCINCL@ @MPIINCL@ @SPOOLESINCL@ @METISINCL@ @TRIANGLEINCL@ @CHACOINCL@ @SCOTCHINCL@ @SHAPELIBINCL@ @BOOSTINCL@ @PYTHONINCL@ @PYTHON_NUMPYINCL@
+AM_CPPFLAGS = @DAKOTAINCL@ @MATLABINCL@ @PETSCINCL@ @MPIINCL@ @SPOOLESINCL@ @METISINCL@ @TRIANGLEINCL@ @CHACOINCL@ @SCOTCHINCL@ @SHAPELIBINCL@ @BOOSTINCL@ @PYTHONINCL@ @PYTHON_NUMPYINCL@
 EXEEXT=$(MATLABWRAPPEREXT)
+#Bin programs {{{1
+#Modules {{{1
 if MODULES
 bin_PROGRAMS =  AverageFilter\
                                 BamgMesher\
                                 BamgConvertMesh\
                                 BamgTriangulate\
                                 Chaco\
                                 ContourToMesh \
                                 ContourToNodes \
                                 ElementConnectivity\
                                 EnumToString\
                                 Exp2Kml \
                                 HoleFiller \
                                 InternalFront\
                                 InterpFromGridToMesh \
                                 InterpFromMeshToMesh2d \
                                 InterpFromMeshToMesh3d \
                                 InterpFromMeshToGrid \
                                 InterpFromMesh2d \
                                 KMLFileRead \
                                 KMLMeshWrite \
                                 KMLOverlay \
                                 Kml2Exp \
                                 Kriging \
                                 Ll2xy \
                                 NodeConnectivity \
                                 MeshPartition\
                                 MeshProfileIntersection\
                                 PointCloudFindNeighbors\
                                 PropagateFlagsFromConnectivity\
                                 Scotch\
                                 Shp2Kml\
                                 StringToEnum\
                                 TriaSearch\
                                 TriMesh\
                                 TriMeshProcessRifts\
+                                Xy2ll
+lib_LTLIBRARIES =  AverageFilter.la\
+                               BamgMesher.la\
+                                   BamgConvertMesh.la\
+                                   BamgTriangulate.la\
+                                   ContourToMesh.la\
+                                   ContourToNodes.la\
+                                   ElementConnectivity.la\
+                                   EnumToString.la\
+                                   Exp2Kml.la\
+                                   HoleFiller.la\
+                                   InternalFront.la\
+                                   InterpFromGridToMesh.la\
+                                   InterpFromMeshToMesh2d.la\
+                                   InterpFromMeshToMesh3d.la\
+                                   InterpFromMeshToGrid.la\
+                                   InterpFromMesh2d.la\
+                                   KMLFileRead.la\
+                                   KMLMeshWrite.la\
+                                   KMLOverlay.la\
+                                   Kml2Exp.la\
+                                   Kriging.la\
+                                   Ll2xy.la\
+                                   NodeConnectivity.la\
+                                   MeshPartition.la\
+                                   MeshProfileIntersection.la\
+                                   PointCloudFindNeighbors.la\
+                                   PropagateFlagsFromConnectivity.la\
+                                   Shp2Kml.la\
+                                   StringToEnum.la\
+                                   TriaSearch.la\
+                                   TriMesh.la\
+                                   TriMeshProcessRifts.la\
+                                   Scotch.la\
+                                   Xy2ll.la\
+                   Chaco.la
 endif
 #}}}
 #Flags and libraries {{{1
+LDADD = ../../c/libISSMCore.a ../../c/libISSMModules.a $(TRIANGLELIB) $(PETSCLIB) $(FLIBS) $(PLAPACKLIB) $(SPOOLESLIB) $(MUMPSLIB) $(SUPERLULIB) $(SPAILIB) $(PROMETHEUSLIB) $(PASTIXLIB) $(SCALAPACKLIB) $(BLACSLIB) $(HYPRELIB) $(MLLIB) $(DAKOTALIB) $(METISLIB) $(CHACOLIB) $(SCOTCHLIB) $(BLASLAPACKLIB) $(MPILIB) $(MATHLIB) $(FORTRANLIB) $(GRAPHICSLIB) $(MULTITHREADINGLIB) $(SHAPELIBLIB) $(GSLLIB)
+if SHAREDLIBS
+deps = ../../c/libISSMCore.la ../../c/libISSMModules.la
+else
+deps = ../../c/libISSMCore.a ../../c/libISSMModules.a
+endif
+deps +=  $(MATHLIB) ${MEXLIB}
+#$(TRIANGLELIB) $(PETSCLIB) $(FLIBS) $(PLAPACKLIB) $(SPOOLESLIB) $(MUMPSLIB) $(SUPERLULIB) $(SPAILIB) $(PROMETHEUSLIB) $(PASTIXLIB) $(SCALAPACKLIB) $(BLACSLIB) $(HYPRELIB) $(MLLIB) $(DAKOTALIB) $(METISLIB) $(CHACOLIB) $(SCOTCHLIB) $(BLASLAPACKLIB) $(MPILIB) $(FORTRANLIB) $(GRAPHICSLIB) $(MULTITHREADINGLIB) $(SHAPELIBLIB) $(GSLLIB)
 #Triangle library
 …
 #Matlab part
+AM_LDFLAGS   = $(MEXLINK)
+AM_LDFLAGS = $(MEXLINK) -shrext ${EXEEXT} -module
+if VERSION
+AM_LDFLAGS +=
+else
+AM_LDFLAGS += -avoid-version
+endif
+if SHAREDLIBS
+deps += ../../c/libISSMMatlab.la
+else
+deps += ../../c/libISSMMatlab.a
+AM_LDFLAGS += --no-warnings
+endif
 AM_CXXFLAGS +=  -D_HAVE_MATLAB_MODULES_ -D_GNU_SOURCE -fPIC -fno-omit-frame-pointer -pthread
+LDADD       += $(MEXLIB) ../../c/libISSMMatlab.a
+LDADD       += ../../c/libISSMCore.a
+if CIRCULAR_DEPENDENCIES
+LDADD       += $(TRIANGLELIB) $(PETSCLIB) $(FLIBS) $(PLAPACKLIB) $(SPOOLESLIB) $(MUMPSLIB) $(SUPERLULIB) $(SPAILIB) $(PROMETHEUSLIB) $(PASTIXLIB) $(SCALAPACKLIB) $(BLACSLIB) $(HYPRELIB) $(MLLIB) $(DAKOTALIB) $(METISLIB) $(CHACOLIB) $(SCOTCHLIB) $(BLASLAPACKLIB) $(MPILIB) $(MATHLIB) $(FORTRANLIB) $(GRAPHICSLIB) $(MULTITHREADINGLIB) $(SHAPELIBLIB) $(GSLLIB)
+endif
+LDADD       += ../../c/libISSMModules.a
+######################################################################################
+# Circular dependencies may not be necessary here.
+#deps += ../../c/libISSMCore.a
+#if CIRCULAR_DEPENDENCIES
+#deps += $(TRIANGLELIB) $(PETSCLIB) $(FLIBS) $(PLAPACKLIB) $(SPOOLESLIB) $(MUMPSLIB) $(SUPERLULIB) $(SPAILIB) $(PROMETHEUSLIB) $(PASTIXLIB) $(SCALAPACKLIB) $(BLACSLIB) $(HYPRELIB) $(MLLIB) $(DAKOTALIB) $(METISLIB) $(CHACOLIB) $(SCOTCHLIB) $(BLASLAPACKLIB) $(MPILIB) $(MATHLIB) $(FORTRANLIB) $(GRAPHICSLIB) $(MULTITHREADINGLIB) $(SHAPELIBLIB) $(GSLLIB)
+#endif
+######################################################################################
+if SHAREDLIBS
+deps +=
+else
+deps += ../../c/libISSMModules.a ../../c/libISSMCore.a
+endif
 #Optimization flags:
 AM_CXXFLAGS += $(CXXOPTFLAGS)
 #}}}
 #Bin sources {{{1
 AverageFilter_SOURCES = ../AverageFilter/AverageFilter.cpp\
+AverageFilter_la_SOURCES = ../AverageFilter/AverageFilter.cpp\
                           ../AverageFilter/AverageFilter.h
+BamgMesher_SOURCES = ../BamgMesher/BamgMesher.cpp\
+AverageFilter_la_LIBADD = ${deps} $(MPILIB) $(PETSCLIB)
+BamgMesher_la_SOURCES = ../BamgMesher/BamgMesher.cpp\
                                         ../BamgMesher/BamgMesher.h
+BamgConvertMesh_SOURCES = ../BamgConvertMesh/BamgConvertMesh.cpp\
+BamgMesher_la_LIBADD = ${deps} $(MPILIB) $(PETSCLIB)
+BamgConvertMesh_la_SOURCES = ../BamgConvertMesh/BamgConvertMesh.cpp\
                                         ../BamgConvertMesh/BamgConvertMesh.h
+BamgTriangulate_SOURCES = ../BamgTriangulate/BamgTriangulate.cpp\
+BamgConvertMesh_la_LIBADD = ${deps} $(MPILIB) $(PETSCLIB)
+BamgTriangulate_la_SOURCES = ../BamgTriangulate/BamgTriangulate.cpp\
                                                                   ../BamgTriangulate/BamgTriangulate.h
+Chaco_SOURCES = ../Chaco/Chaco.cpp\
+BamgTriangulate_la_LIBADD = ${deps} $(MPILIB) $(PETSCLIB)
+Chaco_la_SOURCES = ../Chaco/Chaco.cpp\
                                         ../Chaco/Chaco.h
+ContourToMesh_SOURCES = ../ContourToMesh/ContourToMesh.cpp\
+                          ../ContourToMesh/ContourToMesh.h
+ContourToNodes_SOURCES = ../ContourToNodes/ContourToNodes.cpp\
+Chaco_la_LIBADD = ${deps} $(MPILIB) $(PETSCLIB) $(CHACOLIB)
+ContourToMesh_la_SOURCES = ../ContourToMesh/ContourToMesh.cpp\
+                                       ../ContourToMesh/ContourToMesh.h
+ContourToMesh_la_LIBADD = ${deps} $(MPILIB) $(PETSCLIB) $(MULTITHREADINGLIB)
+ContourToNodes_la_SOURCES = ../ContourToNodes/ContourToNodes.cpp\
                           ../ContourToNodes/ContourToNodes.h
+ElementConnectivity_SOURCES = ../ElementConnectivity/ElementConnectivity.cpp\
+ContourToNodes_la_LIBADD = ${deps} $(MPILIB) $(PETSCLIB)
+ElementConnectivity_la_SOURCES = ../ElementConnectivity/ElementConnectivity.cpp\
                           ../ElementConnectivity/ElementConnectivity.h
+EnumToString_SOURCES = ../EnumToString/EnumToString.cpp\
+ElementConnectivity_la_LIBADD = ${deps} $(MPILIB) $(PETSCLIB)
+EnumToString_la_SOURCES = ../EnumToString/EnumToString.cpp\
                           ../EnumToString/EnumToString.h
+StringToEnum_SOURCES = ../StringToEnum/StringToEnum.cpp\
+EnumToString_la_LIBADD = ${deps} $(MPILIB) $(PETSCLIB)
+StringToEnum_la_SOURCES = ../StringToEnum/StringToEnum.cpp\
                           ../StringToEnum/StringToEnum.h
+HoleFiller_SOURCES = ../HoleFiller/HoleFiller.cpp\
+StringToEnum_la_LIBADD = ${deps} $(MPILIB) $(PETSCLIB)
+HoleFiller_la_SOURCES = ../HoleFiller/HoleFiller.cpp\
                           ../HoleFiller/HoleFiller.h
+InternalFront_SOURCES = ../InternalFront/InternalFront.cpp\
+HoleFiller_la_LIBADD = ${deps} $(MPILIB) $(PETSCLIB)
+InternalFront_la_SOURCES = ../InternalFront/InternalFront.cpp\
                                                                                  ../InternalFront/InternalFront.h
+InterpFromGridToMesh_SOURCES = ../InterpFromGridToMesh/InterpFromGridToMesh.cpp\
+InternalFront_la_LIBADD = ${deps} $(MPILIB) $(PETSCLIB)
+InterpFromGridToMesh_la_SOURCES = ../InterpFromGridToMesh/InterpFromGridToMesh.cpp\
                           ../InterpFromGridToMesh/InterpFromGridToMesh.h
+InterpFromMeshToMesh2d_SOURCES = ../InterpFromMeshToMesh2d/InterpFromMeshToMesh2d.cpp\
+InterpFromGridToMesh_la_LIBADD = ${deps} $(MPILIB) $(PETSCLIB) $(MULTITHREADINGLIB)
+InterpFromMeshToMesh2d_la_SOURCES = ../InterpFromMeshToMesh2d/InterpFromMeshToMesh2d.cpp\
                                                         ../InterpFromMeshToMesh2d/InterpFromMeshToMesh2d.h
+InterpFromMeshToMesh3d_SOURCES = ../InterpFromMeshToMesh3d/InterpFromMeshToMesh3d.cpp\
+InterpFromMeshToMesh2d_la_LIBADD = ${deps} $(MPILIB) $(PETSCLIB) $(MULTITHREADINGLIB)
+InterpFromMeshToMesh3d_la_SOURCES = ../InterpFromMeshToMesh3d/InterpFromMeshToMesh3d.cpp\
                                                                         ../InterpFromMeshToMesh3d/InterpFromMeshToMesh3d.h
+InterpFromMeshToGrid_SOURCES = ../InterpFromMeshToGrid/InterpFromMeshToGrid.cpp\
+InterpFromMeshToMesh3d_la_LIBADD = ${deps} $(MPILIB) $(PETSCLIB)
+InterpFromMeshToGrid_la_SOURCES = ../InterpFromMeshToGrid/InterpFromMeshToGrid.cpp\
                                                                         ../InterpFromMeshToGrid/InterpFromMeshToGrid.h
+InterpFromMesh2d_SOURCES = ../InterpFromMesh2d/InterpFromMesh2d.cpp\
+InterpFromMeshToGrid_la_LIBADD = ${deps} $(MPILIB) $(PETSCLIB)
+InterpFromMesh2d_la_SOURCES = ../InterpFromMesh2d/InterpFromMesh2d.cpp\
                                                                         ../InterpFromMesh2d/InterpFromMesh2d.h
+KMLFileRead_SOURCES = ../KMLFileRead/KMLFileRead.cpp\
+InterpFromMesh2d_la_LIBADD = ${deps} $(MPILIB) $(PETSCLIB) $(MULTITHREADINGLIB)
+KMLFileRead_la_SOURCES = ../KMLFileRead/KMLFileRead.cpp\
                           ../KMLFileRead/KMLFileRead.h
+KMLMeshWrite_SOURCES = ../KMLMeshWrite/KMLMeshWrite.cpp\
+KMLFileRead_la_LIBADD = ${deps} $(MPILIB) $(PETSCLIB)
+KMLMeshWrite_la_SOURCES = ../KMLMeshWrite/KMLMeshWrite.cpp\
                           ../KMLMeshWrite/KMLMeshWrite.h
+KMLOverlay_SOURCES = ../KMLOverlay/KMLOverlay.cpp\
+KMLMeshWrite_la_LIBADD = ${deps} $(MPILIB) $(PETSCLIB)
+KMLOverlay_la_SOURCES = ../KMLOverlay/KMLOverlay.cpp\
                           ../KMLOverlay/KMLOverlay.h
+Xy2ll_SOURCES = ../Xy2ll/Xy2ll.cpp\
+KMLOverlay_la_LIBADD = ${deps} $(MPILIB) $(PETSCLIB)
+Xy2ll_la_SOURCES = ../Xy2ll/Xy2ll.cpp\
                           ../Xy2ll/Xy2ll.h
+Ll2xy_SOURCES = ../Ll2xy/Ll2xy.cpp\
+Xy2ll_la_LIBADD = ${deps} $(MPILIB) $(PETSCLIB)
+Ll2xy_la_SOURCES = ../Ll2xy/Ll2xy.cpp\
                           ../Ll2xy/Ll2xy.h
+Exp2Kml_SOURCES = ../Exp2Kml/Exp2Kml.cpp\
+Ll2xy_la_LIBADD = ${deps} $(MPILIB) $(PETSCLIB)
+Exp2Kml_la_SOURCES = ../Exp2Kml/Exp2Kml.cpp\
                           ../Exp2Kml/Exp2Kml.h
+Kml2Exp_SOURCES = ../Kml2Exp/Kml2Exp.cpp\
+Exp2Kml_la_LIBADD = ${deps} $(MPILIB) $(PETSCLIB)
+Kml2Exp_la_SOURCES = ../Kml2Exp/Kml2Exp.cpp\
                           ../Kml2Exp/Kml2Exp.h
+Kriging_SOURCES = ../Kriging/Kriging.cpp\
+Kml2Exp_la_LIBADD = ${deps} $(MPILIB) $(PETSCLIB)
+Kriging_la_SOURCES = ../Kriging/Kriging.cpp\
                                                 ../Kriging/Kriging.h
+MeshPartition_SOURCES = ../MeshPartition/MeshPartition.cpp\
+Kriging_la_LIBADD = ${deps} $(MPILIB) $(PETSCLIB) $(MULTITHREADINGLIB)
+MeshPartition_la_SOURCES = ../MeshPartition/MeshPartition.cpp\
                           ../MeshPartition/MeshPartition.h
+MeshProfileIntersection_SOURCES = ../MeshProfileIntersection/MeshProfileIntersection.cpp\
+MeshPartition_la_LIBADD = ${deps} $(MPILIB) $(PETSCLIB)
+MeshProfileIntersection_la_SOURCES = ../MeshProfileIntersection/MeshProfileIntersection.cpp\
                           ../MeshProfileIntersection/MeshProfileIntersection.h
+NodeConnectivity_SOURCES = ../NodeConnectivity/NodeConnectivity.cpp\
+MeshProfileIntersection_la_LIBADD = ${deps} $(MPILIB) $(PETSCLIB)
+NodeConnectivity_la_SOURCES = ../NodeConnectivity/NodeConnectivity.cpp\
                                                                                 ../NodeConnectivity/NodeConnectivity.h
+PointCloudFindNeighbors_SOURCES = ../PointCloudFindNeighbors/PointCloudFindNeighbors.cpp\
+NodeConnectivity_la_LIBADD = ${deps} $(MPILIB) $(PETSCLIB)
+PointCloudFindNeighbors_la_SOURCES = ../PointCloudFindNeighbors/PointCloudFindNeighbors.cpp\
                           ../PointCloudFindNeighbors/PointCloudFindNeighbors.h
+PropagateFlagsFromConnectivity_SOURCES = ../PropagateFlagsFromConnectivity/PropagateFlagsFromConnectivity.cpp\
+PointCloudFindNeighbors_la_LIBADD = ${deps} $(MPILIB) $(PETSCLIB) $(MULTITHREADINGLIB)
+PropagateFlagsFromConnectivity_la_SOURCES = ../PropagateFlagsFromConnectivity/PropagateFlagsFromConnectivity.cpp\
                           ../PropagateFlagsFromConnectivity/PropagateFlagsFromConnectivity.h
+Scotch_SOURCES = ../Scotch/Scotch.cpp\
+                          ../Scotch/Scotch.h
+Shp2Kml_SOURCES = ../Shp2Kml/Shp2Kml.cpp\
+                          ../Shp2Kml/Shp2Kml.h
+TriaSearch_SOURCES = ../TriaSearch/TriaSearch.cpp\
+PropagateFlagsFromConnectivity_la_LIBADD = ${deps} $(MPILIB) $(PETSCLIB)
+Scotch_la_SOURCES = ../Scotch/Scotch.cpp\
+                    ../Scotch/Scotch.h
+Scotch_la_LIBADD = ${deps} $(SCOTCHLIB)
+Shp2Kml_la_SOURCES = ../Shp2Kml/Shp2Kml.cpp\
+                     ../Shp2Kml/Shp2Kml.h
+Shp2Kml_la_LIBADD = ${deps}
+TriaSearch_la_SOURCES = ../TriaSearch/TriaSearch.cpp\
                           ../TriaSearch/TriaSearch.h
+TriMesh_SOURCES = ../TriMesh/TriMesh.cpp\
+                          ../TriMesh/TriMesh.h
+TriMeshProcessRifts_SOURCES = ../TriMeshProcessRifts/TriMeshProcessRifts.cpp\
+TriaSearch_la_LIBADD = ${deps} $(MPILIB) $(PETSCLIB)
+TriMesh_la_SOURCES = ../TriMesh/TriMesh.cpp\
+                     ../TriMesh/TriMesh.h
+TriMesh_la_LIBADD = ${deps} $(MPILIB) $(PETSCLIB) $(TRIANGLELIB)
+TriMeshProcessRifts_la_SOURCES = ../TriMeshProcessRifts/TriMeshProcessRifts.cpp\
                           ../TriMeshProcessRifts/TriMeshProcessRifts.h
+TriMeshProcessRifts_la_LIBADD = ${deps} $(MPILIB) $(PETSCLIB)
 #}}}

issm/branches/trunk-jpl-damage/src/modules/python/Makefile.am

-              r12878
+              r13101
 INCLUDES = @DAKOTAINCL@ @MATLABINCL@ @PETSCINCL@ @MPIINCL@ @METISINCL@ @TRIANGLEINCL@ @CHACOINCL@ @SCOTCHINCL@ @SHAPELIBINCL@ @BOOSTINCL@ @PYTHONINCL@ @PYTHON_NUMPYINCL@
+AM_CPPFLAGS = @DAKOTAINCL@ @MATLABINCL@ @PETSCINCL@ @MPIINCL@ @METISINCL@ @TRIANGLEINCL@ @CHACOINCL@ @SCOTCHINCL@ @SHAPELIBINCL@ @BOOSTINCL@ @PYTHONINCL@ @PYTHON_NUMPYINCL@
 EXEEXT=$(PYTHONWRAPPEREXT)
 #Bin programs {{{1
 if MODULES
 bin_PROGRAMS = ElementConnectivity\
+                           EnumToString\
                            InterpFromMeshToMesh2d \
                            NodeConnectivity\
+                           TriMesh
+                           StringToEnum\
+                           TriMesh
 endif
 #}}}
 …
                           ../ElementConnectivity/ElementConnectivity.h
+EnumToString_SOURCES = ../EnumToString/EnumToString.cpp\
+                          ../EnumToString/EnumToString.h
 InterpFromMeshToMesh2d_SOURCES = ../InterpFromMeshToMesh2d/InterpFromMeshToMesh2d.cpp\
                                                         ../InterpFromMeshToMesh2d/InterpFromMeshToMesh2d.h
 …
                                                                                 ../NodeConnectivity/NodeConnectivity.h
+StringToEnum_SOURCES = ../StringToEnum/StringToEnum.cpp\
+                          ../StringToEnum/StringToEnum.h
 TriMesh_SOURCES = ../TriMesh/TriMesh.cpp\
                           ../TriMesh/TriMesh.h

issm/branches/trunk-jpl-damage/startup.m

-              r12168
+              r13101
 %ISSM path
 addpath([ISSM_DIR '/src/m/utils/']); %loads recursivepath
+addpath([ISSM_DIR '/src/m/os/']); %loads recursivepath
 addpath([ISSM_DIR '/bin']);
+addpath([ISSM_DIR '/lib']);
 addpath(recursivepath([ISSM_DIR '/src/m']));
 addpath(recursivepath([ISSM_DIR '/externalpackages/scotch']));

issm/branches/trunk-jpl-damage/test/NightlyRun/IdToName.py

-              r12946
+              r13101
 : 'SquareShelfTranForceNeg2dDakotaSamp',
 : 'SquareShelfTranForceNeg2dDakotaLocal',
 : 'SquareShelfTranIspddIsdeltaM2d';
 : 'SquareShelfTranIspddIsdeltaM3d';
+: 'SquareShelfTranIspddIsdeltaM2d',
+: 'SquareShelfTranIspddIsdeltaM3d',
 : 'SquareSheetConstrainedDiagM2d',
 : 'SquareSheetConstrainedDiagH2d',

issm/branches/trunk-jpl-damage/test/NightlyRun/runme.m

-              r12878
+              r13101
 % }}}
 %GET ids  {{{1
 list=dir;%use dir, as it seems to act OS independent
+flist=dir;%use dir, as it seems to act OS independent
 list_ids=[];
 for i=1:numel(list),
         if ( strncmp(list(i).name,'test',4) &...                         %File name must start with 'test'
                         strncmp(fliplr(list(i).name),fliplr('.m'),2)&...           %File name must end by '.m'
                         ~strcmp(list(i).name,'test.m'))                            %File name must be different than 'test.m'
                 list_ids(end+1)=eval(list(i).name(5:end-2));                  %Keep test id only (skip 'test' and '.m')
+for i=1:numel(flist),
+        if ( strncmp(flist(i).name,'test',4) &...                         %File name must start with 'test'
+                        strncmp(fliplr(flist(i).name),fliplr('.m'),2)&...           %File name must end by '.m'
+                        ~strcmp(flist(i).name,'test.m'))                            %File name must be different than 'test.m'
+                list_ids(end+1)=eval(flist(i).name(5:end-2));                  %Keep test id only (skip 'test' and '.m')
         end
 end

issm/branches/trunk-jpl-damage/test/NightlyRun/runme.py

-              r12878
+              r13101
         from parallelrange import parallelrange
         from IdToName import IdToName
+        from MatlabFuncs import *
         #Get ISSM_DIR variable
 …
         #Process options
         #GET benchmark {{{1
         if not benchmark.lower() in ['all','nightly','ismip','eismint','thermal','mesh','validation','tranforcing']:
+        if not ismember(benchmark,['all','nightly','ismip','eismint','thermal','mesh','validation','tranforcing']):
                 print "runme warning: benchmark '%s' not supported, defaulting to test 'nightly'." % benchmark
                 benchmark='nightly'
         # }}}
         #GET procedure {{{1
         if not procedure.lower() in ['check','update']:
+        if not ismember(procedure,['check','update']):
                 print "runme warning: procedure '%s' not supported, defaulting to test 'check'." % procedure
                 procedure='check'
         # }}}
         #GET output {{{1
         if not output.lower() in ['nightly','daily','none']:
+        if not ismember(output,['nightly','daily','none']):
                 print "runme warning: output '%s' not supported, defaulting to test 'none'." % output
                 output='none'
 …
         #Process Ids according to benchmarks {{{1
         if   benchmark.lower() == 'nightly':
+        if   strcmpi(benchmark,'nightly'):
                 test_ids=test_ids.intersection(set(range(1,1000)))
         elif benchmark.lower() == 'ismip':
+        elif strcmpi(benchmark,'ismip'):
                 test_ids=test_ids.intersection(set(range(1101,1200)))
         elif benchmark.lower() == 'eismint':
+        elif strcmpi(benchmark,'eismint'):
                 test_ids=test_ids.intersection(set(range(1201,1300)))
         elif benchmark.lower() == 'thermal':
+        elif strcmpi(benchmark,'thermal'):
                 test_ids=test_ids.intersection(set(range(1301,1400)))
         elif benchmark.lower() == 'mesh':
+        elif strcmpi(benchmark,'mesh'):
                 test_ids=test_ids.intersection(set(range(1401,1500)))
         elif benchmark.lower() == 'validation':
+        elif strcmpi(benchmark,'validation'):
                 test_ids=test_ids.intersection(set(range(1001,2000)))
         elif benchmark.lower() == 'tranforcing':
+        elif strcmpi(benchmark,'tranforcing'):
                 test_ids=test_ids.intersection(set(range(1501,1503)))
 #       print 'test_ids after benchmark =',test_ids
 …
                         #UPDATE ARCHIVE?
                         archive_name='Archive'+str(id)
                         if procedure.lower() == 'update':
                                 if not socket.gethostname().lower().split('.')[0] == 'larsen':
+                        if strcmpi(procedure,'update'):
+                                if not strcmp(socket.gethostname().lower().split('.')[0],'larsen'):
 #                                       raise RuntimeError("Nightly run archives must be saved on 'larsen' (hostname is '"+socket.gethostname()+"').")
                                         print "Nightly run archives must be saved on 'larsen' (hostname is '"+socket.gethostname()+"')."
 …
                                                 directory=os.getcwd().split('/')    #  not used?
                                                 message=me2
                                                 if   output.lower() == 'nightly':
+                                                if   strcmpi(output,'nightly'):
                                                         fid=open(os.path.join(ISSM_DIR,'nightlylog','matlaberror.log'), 'a')
                                                         fid.write('%s' % message)
 …
                                                         fid.close()
                                                         print 'FAILURE difference: N/A test id: %i test name: %s field: %s' % (id,id_string,fieldname)
                                                 elif output.lower() == 'daily':
+                                                elif strcmpi(output,'daily'):
                                                         fid=open(os.path.join(ISSM_DIR,'dailylog','matlaberror.log'), 'a')
                                                         fid.write('%s' % message)
 …
                         directory=os.getcwd().split('/')    #  not used?
                         message=me
                         if   output.lower() == 'nightly':
+                        if   strcmpi(output,'nightly'):
                                 fid=open(os.path.join(ISSM_DIR+'nightlylog','matlaberror.log'), 'a')
                                 fid.write('%s' % message)
 …
                                 fid.close()
                                 print 'FAILURE difference: N/A test id: %i test name: %s field: %s' % (id,id_string,'N/A')
                         elif output.lower() == 'daily':
+                        elif strcmpi(output,'daily'):
                                 fid=open(os.path.join(ISSM_DIR+'dailylog','matlaberror.log'), 'a')
                                 fid.write('%s' % message)

issm/branches/trunk-jpl-damage/test/NightlyRun/test101.py

-              r12946
+              r13101
 md=setflowequation(md,'macayeal','all')
 md.cluster=generic('name',oshostname(),'np',3)
 md.diagnostic.requested_outputs=StressTensorEnum
 md=solve(md,DiagnosticSolutionEnum)
+md.diagnostic.requested_outputs=StressTensorEnum()
+md=solve(md,DiagnosticSolutionEnum())
 #Fields and tolerances to track changes

issm/branches/trunk-jpl-damage/test/NightlyRun/test218.m

r12878	r13101
84	84
85	85	%Fields and tolerances to track changes
86		md~~=tres(md,'dakota')~~;
	86	md.qmu.results=md.results.dakota;
87	87	md.results.dakota.importancefactors=importancefactors(md,'scaled_MaterialsRheologyB','MaxVel')';
88	88	field_names ={'importancefactors'};

issm/branches/trunk-jpl-damage/test/NightlyRun/test225.m

-              r12878
+              r13101
 md=setmask(md,'all','');
 md=parameterize(md,'../Par/SquareShelf.par');
+md.geometry.bed=md.geometry.bed+50; md.geometry.surface=md.geometry.surface+50;
 md=extrude(md,3,1);
 md=setflowequation(md,'pattyn','all');
-md.geometry.bed=md.geometry.bed+50; md.geometry.surface=md.geometry.surface+50;
 md.cluster=generic('name',oshostname(),'np',3);
 md.prognostic.hydrostatic_adjustment='Incremental';

issm/branches/trunk-jpl-damage/test/NightlyRun/test234.m

r12878	r13101
56	56	%solve
57	57	md=solve(md,TransientSolutionEnum,'overwrite','y');
58		md~~=tres(md,'dakota')~~;
	58	md.qmu.results=md.results.dakota;
59	59
60	60	%Fields and tolerances to track changes

issm/branches/trunk-jpl-damage/test/NightlyRun/test235.m

r12878	r13101
56	56	%solve
57	57	md=solve(md,TransientSolutionEnum,'overwrite','y');
58		md~~=tres(md,'dakota')~~;
	58	md.qmu.results=md.results.dakota;
59	59
60	60	%Fields and tolerances to track changes

issm/branches/trunk-jpl-damage/test/NightlyRun/test412.m

r12878	r13101
36	36
37	37	%Fields and tolerances to track changes
38		md~~=tres(md,'dakota')~~;
	38	md.qmu.results=md.results.dakota;
39	39	md.results.dakota.importancefactors=importancefactors(md,'scaled_FrictionCoefficient','MaxVel')';
40	40	field_names ={'importancefactors'};

issm/branches/trunk-jpl-damage/test/NightlyRun/test413.m

r12878	r13101
37	37
38	38	%Fields and tolerances to track changes
39		md~~=tres(md,'dakota')~~;
	39	md.qmu.results=md.results.dakota;
40	40	md.results.dakota.importancefactors=importancefactors(md,'scaled_FrictionCoefficient','MaxVel')';
41	41	field_names ={'importancefactors'};

issm/branches/trunk-jpl-damage/test/NightlyRun/test414.m

r12878	r13101
49	49	%solve
50	50	md=solve(md,DiagnosticSolutionEnum,'overwrite','y');
51		md~~=tres(md,'dakota')~~;
	51	md.qmu.results=md.results.dakota;
52	52
53	53	%Fields and tolerances to track changes

issm/branches/trunk-jpl-damage/test/NightlyRun/test417.m

r12878	r13101
53	53
54	54	%Fields and tolerances to track changes
55		md~~=tres(md,'dakota')~~;
	55	md.qmu.results=md.results.dakota;
56	56
57	57	%ok, mass flux of 3 profiles should be -3 Gt/yr -3 Gt/yr and the sum, which is -6 Gt/yr

issm/branches/trunk-jpl-damage/test/NightlyRun/test420.m

r12878	r13101
33	33	%solve
34	34	md=solve(md,DiagnosticSolutionEnum,'overwrite','y');
35		md~~=tres(md,'dakota')~~;
	35	md.qmu.results=md.results.dakota;
36	36
37	37	%test on thickness

issm/branches/trunk-jpl-damage/test/NightlyRun/test511.m

r12878	r13101
8	8	md=extrude(md,3,1);
9	9	md=setflowequation(md,'stokes','all');
10		md=~~model~~extract(md,md.mask.elementonfloatingice);
	10	md=extract(md,md.mask.elementonfloatingice);
11	11
12	12	%control parameters

issm/branches/trunk-jpl-damage/test/NightlyRun/test613.m

r12878	r13101
6	6
7	7	%Ice sheet only
8		md=~~model~~extract(md,md.mask.elementongroundedice);
	8	md=extract(md,md.mask.elementongroundedice);
9	9	pos=find(md.mesh.vertexonboundary);
10	10	md.balancethickness.spcthickness(pos)=md.geometry.thickness(pos);

issm/branches/trunk-jpl-damage/test/Par/SquareShelfConstrained.py

-              r12878
+              r13101
 from verbose import *
 import scipy.io as matio
+import InterpFromMeshToMesh2d as im
 from   paterson import  *
+from InterpFromMeshToMesh2d import InterpFromMeshToMesh2d
+from paterson import  *
 from SetIceShelfBC import *
 import inspect
+import os.path
 #Start defining model parameters here
 …
 index=reshape(index.T,(len(index),3),order='F')
 md.initialization.vx = im.InterpFromMeshToMesh2d(index, x, y, vx, md.mesh.x, md.mesh.y)
 md.initialization.vy = im.InterpFromMeshToMesh2d(index, x, y, vy, md.mesh.x, md.mesh.y)
+[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 = zeros(md.mesh.numberofvertices)
 md.initialization.pressure = zeros(md.mesh.numberofvertices)
 …
 #Change name so that no tests have the same name
 if len(inspect.stack()) > 2:
     md.miscellaneous.name = inspect.stack()[2][1].split('.')[0]
+        md.miscellaneous.name = os.path.basename(inspect.stack()[2][1]).split('.')[0]

Context Navigation

Legend: