Index: /issm/trunk-jpl/m4/issm_options.m4 =================================================================== --- /issm/trunk-jpl/m4/issm_options.m4 (revision 15770) +++ /issm/trunk-jpl/m4/issm_options.m4 (revision 15771) @@ -1577,21 +1577,21 @@ AC_MSG_RESULT($HAVE_HYDROLOGY) dnl }}} - dnl with-diagnostic{{{ - AC_ARG_WITH([diagnostic], - AS_HELP_STRING([--with-diagnostic = YES], [compile with diagnostic capabilities (default is yes)]), - [DIAGNOSTIC=$withval],[DIAGNOSTIC=yes]) - AC_MSG_CHECKING(for diagnostic capability compilation) - - if test "x$DIAGNOSTIC" = "xyes"; then + dnl with-stressbalance{{{ + AC_ARG_WITH([stressbalance], + AS_HELP_STRING([--with-stressbalance = YES], [compile with stressbalance capabilities (default is yes)]), + [STRESSBALANCE=$withval],[STRESSBALANCE=yes]) + AC_MSG_CHECKING(for stressbalance capability compilation) + + if test "x$STRESSBALANCE" = "xyes"; then dnl defaults - HAVE_DIAGNOSTIC=yes - - AC_DEFINE([_HAVE_DIAGNOSTIC_],[1],[with diagnostic capability]) - else - HAVE_DIAGNOSTIC=no - fi - AM_CONDITIONAL([DIAGNOSTIC], [test x$HAVE_DIAGNOSTIC = xyes]) - AC_MSG_RESULT($HAVE_DIAGNOSTIC) + HAVE_STRESSBALANCE=yes + + AC_DEFINE([_HAVE_STRESSBALANCE_],[1],[with stressbalance capability]) + else + HAVE_STRESSBALANCE=no + fi + AM_CONDITIONAL([STRESSBALANCE], [test x$HAVE_STRESSBALANCE = xyes]) + AC_MSG_RESULT($HAVE_STRESSBALANCE) dnl }}} dnl with-balanced{{{ Index: /issm/trunk-jpl/src/ad/validation/Update/SquareShelfConstrained.par =================================================================== --- /issm/trunk-jpl/src/ad/validation/Update/SquareShelfConstrained.par (revision 15770) +++ /issm/trunk-jpl/src/ad/validation/Update/SquareShelfConstrained.par (revision 15771) @@ -35,13 +35,13 @@ %Numerical parameters -md.diagnostic.viscosity_overshoot=0.0; +md.stressbalance.viscosity_overshoot=0.0; md.prognostic.stabilization=1; md.thermal.stabilization=1; md.verbose=verbose(0); md.settings.waitonlock=30; -md.diagnostic.restol=0.05; -md.diagnostic.reltol=0.05; +md.stressbalance.restol=0.05; +md.stressbalance.reltol=0.05; md.steadystate.reltol=0.05; -md.diagnostic.abstol=NaN; +md.stressbalance.abstol=NaN; md.timestepping.time_step=1; md.timestepping.final_time=3; Index: /issm/trunk-jpl/src/c/Makefile.am =================================================================== --- /issm/trunk-jpl/src/c/Makefile.am (revision 15770) +++ /issm/trunk-jpl/src/c/Makefile.am (revision 15771) @@ -440,5 +440,5 @@ ./analyses/objectivefunction.cpp\ ./analyses/gradient_core.cpp\ - ./analyses/adjointdiagnostic_core.cpp\ + ./analyses/adjointstressbalance_core.cpp\ ./analyses/adjointbalancethickness_core.cpp\ ./analyses/AdjointCorePointerFromSolutionEnum.cpp\ @@ -465,18 +465,18 @@ ./solutionsequences/solutionsequence_hydro_nonlinear.cpp #}}} -#Diagnostic sources {{{ -diagnostic_sources = ./modules/ModelProcessorx/DiagnosticHoriz/UpdateElementsDiagnosticHoriz.cpp\ - ./modules/ModelProcessorx/DiagnosticHoriz/CreateNodesDiagnosticHoriz.cpp \ - ./modules/ModelProcessorx/DiagnosticHoriz/CreateConstraintsDiagnosticHoriz.cpp \ - ./modules/ModelProcessorx/DiagnosticHoriz/CreateLoadsDiagnosticHoriz.cpp\ - ./modules/ModelProcessorx/DiagnosticVert/UpdateElementsDiagnosticVert.cpp\ - ./modules/ModelProcessorx/DiagnosticVert/CreateNodesDiagnosticVert.cpp \ - ./modules/ModelProcessorx/DiagnosticVert/CreateConstraintsDiagnosticVert.cpp \ - ./modules/ModelProcessorx/DiagnosticVert/CreateLoadsDiagnosticVert.cpp\ - ./modules/ModelProcessorx/DiagnosticHutter/UpdateElementsDiagnosticHutter.cpp\ - ./modules/ModelProcessorx/DiagnosticHutter/CreateNodesDiagnosticHutter.cpp \ - ./modules/ModelProcessorx/DiagnosticHutter/CreateConstraintsDiagnosticHutter.cpp \ - ./modules/ModelProcessorx/DiagnosticHutter/CreateLoadsDiagnosticHutter.cpp \ - ./analyses/diagnostic_core.cpp\ +#Stressbalance sources {{{ +stressbalance_sources = ./modules/ModelProcessorx/Stressbalance/UpdateElementsStressbalance.cpp\ + ./modules/ModelProcessorx/Stressbalance/CreateNodesStressbalance.cpp \ + ./modules/ModelProcessorx/Stressbalance/CreateConstraintsStressbalance.cpp \ + ./modules/ModelProcessorx/Stressbalance/CreateLoadsStressbalance.cpp\ + ./modules/ModelProcessorx/StressbalanceVertical/UpdateElementsStressbalanceVertical.cpp\ + ./modules/ModelProcessorx/StressbalanceVertical/CreateNodesStressbalanceVertical.cpp \ + ./modules/ModelProcessorx/StressbalanceVertical/CreateConstraintsStressbalanceVertical.cpp \ + ./modules/ModelProcessorx/StressbalanceVertical/CreateLoadsStressbalanceVertical.cpp\ + ./modules/ModelProcessorx/StressbalanceSIA/UpdateElementsStressbalanceSIA.cpp\ + ./modules/ModelProcessorx/StressbalanceSIA/CreateNodesStressbalanceSIA.cpp \ + ./modules/ModelProcessorx/StressbalanceSIA/CreateConstraintsStressbalanceSIA.cpp \ + ./modules/ModelProcessorx/StressbalanceSIA/CreateLoadsStressbalanceSIA.cpp \ + ./analyses/stressbalance_core.cpp\ ./solutionsequences/solutionsequence_stokescoupling_nonlinear.cpp #}}} @@ -890,6 +890,6 @@ endif -if DIAGNOSTIC -issm_sources += $(diagnostic_sources) +if STRESSBALANCE +issm_sources += $(stressbalance_sources) endif Index: /issm/trunk-jpl/src/c/analyses/AdjointCorePointerFromSolutionEnum.cpp =================================================================== --- /issm/trunk-jpl/src/c/analyses/AdjointCorePointerFromSolutionEnum.cpp (revision 15770) +++ /issm/trunk-jpl/src/c/analyses/AdjointCorePointerFromSolutionEnum.cpp (revision 15771) @@ -23,9 +23,9 @@ switch(solutiontype){ - case DiagnosticSolutionEnum: - adjointcore=&adjointdiagnostic_core; + case StressbalanceSolutionEnum: + adjointcore=&adjointstressbalance_core; break; case SteadystateSolutionEnum: - adjointcore=&adjointdiagnostic_core; + adjointcore=&adjointstressbalance_core; break; case BalancethicknessSolutionEnum: Index: /issm/trunk-jpl/src/c/analyses/AnalysisConfiguration.cpp =================================================================== --- /issm/trunk-jpl/src/c/analyses/AnalysisConfiguration.cpp (revision 15770) +++ /issm/trunk-jpl/src/c/analyses/AnalysisConfiguration.cpp (revision 15771) @@ -25,10 +25,10 @@ switch(solutiontype){ - case DiagnosticSolutionEnum: + case StressbalanceSolutionEnum: numanalyses=5; analyses=xNew(numanalyses); - analyses[0]=DiagnosticHorizAnalysisEnum; - analyses[1]=DiagnosticVertAnalysisEnum; - analyses[2]=DiagnosticSIAAnalysisEnum; + analyses[0]=StressbalanceAnalysisEnum; + analyses[1]=StressbalanceVerticalAnalysisEnum; + analyses[2]=StressbalanceSIAAnalysisEnum; analyses[3]=SurfaceSlopeAnalysisEnum; analyses[4]=BedSlopeAnalysisEnum; @@ -38,7 +38,7 @@ numanalyses=8; analyses=xNew(numanalyses); - analyses[0]=DiagnosticHorizAnalysisEnum; - analyses[1]=DiagnosticVertAnalysisEnum; - analyses[2]=DiagnosticSIAAnalysisEnum; + analyses[0]=StressbalanceAnalysisEnum; + analyses[1]=StressbalanceVerticalAnalysisEnum; + analyses[2]=StressbalanceSIAAnalysisEnum; analyses[3]=SurfaceSlopeAnalysisEnum; analyses[4]=BedSlopeAnalysisEnum; @@ -110,7 +110,7 @@ numanalyses=10-1; analyses=xNew(numanalyses); - analyses[0]=DiagnosticHorizAnalysisEnum; - analyses[1]=DiagnosticVertAnalysisEnum; - analyses[2]=DiagnosticSIAAnalysisEnum; + analyses[0]=StressbalanceAnalysisEnum; + analyses[1]=StressbalanceVerticalAnalysisEnum; + analyses[2]=StressbalanceSIAAnalysisEnum; analyses[3]=SurfaceSlopeAnalysisEnum; analyses[4]=BedSlopeAnalysisEnum; Index: /issm/trunk-jpl/src/c/analyses/CorePointerFromSolutionEnum.cpp =================================================================== --- /issm/trunk-jpl/src/c/analyses/CorePointerFromSolutionEnum.cpp (revision 15770) +++ /issm/trunk-jpl/src/c/analyses/CorePointerFromSolutionEnum.cpp (revision 15771) @@ -23,9 +23,9 @@ switch(solutiontype){ - case DiagnosticSolutionEnum: - #ifdef _HAVE_DIAGNOSTIC_ - solutioncore=&diagnostic_core; + case StressbalanceSolutionEnum: + #ifdef _HAVE_STRESSBALANCE_ + solutioncore=&stressbalance_core; #else - _error_("ISSM was not compiled with diagnostic capabilities. Exiting"); + _error_("ISSM was not compiled with stressbalance capabilities. Exiting"); #endif break; Index: sm/trunk-jpl/src/c/analyses/adjointdiagnostic_core.cpp =================================================================== --- /issm/trunk-jpl/src/c/analyses/adjointdiagnostic_core.cpp (revision 15770) +++ (revision ) @@ -1,46 +1,0 @@ -/*!\file: adjointdiagnostic_core.cpp - * \brief compute inverse method adjoint state - */ - -#include "./analyses.h" -#include "../toolkits/toolkits.h" -#include "../classes/classes.h" -#include "../shared/shared.h" -#include "../modules/modules.h" -#include "../solutionsequences/solutionsequences.h" - -void adjointdiagnostic_core(FemModel* femmodel){ - - /*parameters: */ - bool isFS; - bool save_results; - bool conserve_loads = true; - - /*retrieve parameters:*/ - femmodel->parameters->FindParam(&isFS,FlowequationIsFSEnum); - femmodel->parameters->FindParam(&save_results,SaveResultsEnum); - - /*Compute velocities*/ - if(VerboseSolution()) _printf0_(" computing velocities\n"); - femmodel->SetCurrentConfiguration(DiagnosticHorizAnalysisEnum); - solutionsequence_nonlinear(femmodel,conserve_loads); - - /*Call SurfaceAreax, because some it might be needed by PVector*/ - SurfaceAreax(NULL,femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters); - - /*Compute adjoint*/ - if(VerboseSolution()) _printf0_(" computing adjoint\n"); - femmodel->SetCurrentConfiguration(DiagnosticHorizAnalysisEnum,AdjointHorizAnalysisEnum); - solutionsequence_adjoint_linear(femmodel); - - /*Save results*/ - if(save_results){ - if(VerboseSolution()) _printf0_(" saving results\n"); - InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,AdjointxEnum); - InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,AdjointyEnum); - if (isFS){ - InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,AdjointzEnum); - InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,AdjointpEnum); - } - } -} Index: /issm/trunk-jpl/src/c/analyses/adjointstressbalance_core.cpp =================================================================== --- /issm/trunk-jpl/src/c/analyses/adjointstressbalance_core.cpp (revision 15771) +++ /issm/trunk-jpl/src/c/analyses/adjointstressbalance_core.cpp (revision 15771) @@ -0,0 +1,46 @@ +/*!\file: adjointstressbalance_core.cpp + * \brief compute inverse method adjoint state + */ + +#include "./analyses.h" +#include "../toolkits/toolkits.h" +#include "../classes/classes.h" +#include "../shared/shared.h" +#include "../modules/modules.h" +#include "../solutionsequences/solutionsequences.h" + +void adjointstressbalance_core(FemModel* femmodel){ + + /*parameters: */ + bool isFS; + bool save_results; + bool conserve_loads = true; + + /*retrieve parameters:*/ + femmodel->parameters->FindParam(&isFS,FlowequationIsFSEnum); + femmodel->parameters->FindParam(&save_results,SaveResultsEnum); + + /*Compute velocities*/ + if(VerboseSolution()) _printf0_(" computing velocities\n"); + femmodel->SetCurrentConfiguration(StressbalanceAnalysisEnum); + solutionsequence_nonlinear(femmodel,conserve_loads); + + /*Call SurfaceAreax, because some it might be needed by PVector*/ + SurfaceAreax(NULL,femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters); + + /*Compute adjoint*/ + if(VerboseSolution()) _printf0_(" computing adjoint\n"); + femmodel->SetCurrentConfiguration(StressbalanceAnalysisEnum,AdjointHorizAnalysisEnum); + solutionsequence_adjoint_linear(femmodel); + + /*Save results*/ + if(save_results){ + if(VerboseSolution()) _printf0_(" saving results\n"); + InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,AdjointxEnum); + InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,AdjointyEnum); + if (isFS){ + InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,AdjointzEnum); + InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,AdjointpEnum); + } + } +} Index: /issm/trunk-jpl/src/c/analyses/analyses.h =================================================================== --- /issm/trunk-jpl/src/c/analyses/analyses.h (revision 15770) +++ /issm/trunk-jpl/src/c/analyses/analyses.h (revision 15771) @@ -17,8 +17,8 @@ /*cores: */ -void adjointdiagnostic_core(FemModel* femmodel); +void adjointstressbalance_core(FemModel* femmodel); void adjointbalancethickness_core(FemModel* femmodel); void gradient_core(FemModel* femmodel,int n=0,bool orthogonalize=false); -void diagnostic_core(FemModel* femmodel); +void stressbalance_core(FemModel* femmodel); void hydrology_core(FemModel* femmodel); void thermal_core(FemModel* femmodel); Index: /issm/trunk-jpl/src/c/analyses/control_core.cpp =================================================================== --- /issm/trunk-jpl/src/c/analyses/control_core.cpp (revision 15770) +++ /issm/trunk-jpl/src/c/analyses/control_core.cpp (revision 15771) @@ -112,5 +112,5 @@ solutioncore(femmodel); - /*some results not computed by steadystate_core or diagnostic_core: */ + /*some results not computed by steadystate_core or stressbalance_core: */ if(!dakota_analysis){ //do not save this if we are running the control core from a qmu run! for(i=0;ielements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,control_type[i]); Index: /issm/trunk-jpl/src/c/analyses/dakota_core.cpp =================================================================== --- /issm/trunk-jpl/src/c/analyses/dakota_core.cpp (revision 15770) +++ /issm/trunk-jpl/src/c/analyses/dakota_core.cpp (revision 15771) @@ -14,5 +14,5 @@ * * Now, how does CPU 0 drive all other CPUS to carry out sensitivity analysese? By synchronizing its call to - * our ISSM cores (diagnostic_core, thermal_core, transient_core, etc ...) on CPU 0 with all other CPUS. + * our ISSM cores (stressbalance_core, thermal_core, transient_core, etc ...) on CPU 0 with all other CPUS. * This explains the structure of qmu.cpp, where cpu 0 runs Dakota, the Dakota pluggin fires up DakotaSpawnCore.cpp, * while the other CPUS are waiting for a broadcast from CPU0, once they get it, they also fire up Index: sm/trunk-jpl/src/c/analyses/diagnostic_core.cpp =================================================================== --- /issm/trunk-jpl/src/c/analyses/diagnostic_core.cpp (revision 15770) +++ (revision ) @@ -1,100 +1,0 @@ -/*!\file: diagnostic_core.cpp - * \brief: core of the diagnostic solution - */ - -#include "./analyses.h" -#include "../toolkits/toolkits.h" -#include "../classes/classes.h" -#include "../shared/shared.h" -#include "../modules/modules.h" -#include "../solutionsequences/solutionsequences.h" - -void diagnostic_core(FemModel* femmodel){ - - /*parameters: */ - bool dakota_analysis; - int dim; - bool isSIA,isSSA,isL1L2,isHO,isFS; - bool conserve_loads = true; - bool save_results; - int newton; - int solution_type; - int numoutputs = 0; - int *requested_outputs = NULL; - - /* recover parameters:*/ - femmodel->parameters->FindParam(&dim,MeshDimensionEnum); - femmodel->parameters->FindParam(&isSIA,FlowequationIsSIAEnum); - femmodel->parameters->FindParam(&isSSA,FlowequationIsSSAEnum); - femmodel->parameters->FindParam(&isL1L2,FlowequationIsL1L2Enum); - femmodel->parameters->FindParam(&isHO,FlowequationIsHOEnum); - femmodel->parameters->FindParam(&isFS,FlowequationIsFSEnum); - femmodel->parameters->FindParam(&newton,DiagnosticIsnewtonEnum); - femmodel->parameters->FindParam(&dakota_analysis,QmuIsdakotaEnum); - femmodel->parameters->FindParam(&save_results,SaveResultsEnum); - femmodel->parameters->FindParam(&solution_type,SolutionTypeEnum); - femmodel->parameters->FindParam(&numoutputs,DiagnosticNumRequestedOutputsEnum); - if(numoutputs) femmodel->parameters->FindParam(&requested_outputs,&numoutputs,DiagnosticRequestedOutputsEnum); - - /*for qmu analysis, reinitialize velocity so that fake sensitivities do not show up as a result of a different restart of the convergence at each trial.*/ - if(dakota_analysis && solution_type==DiagnosticSolutionEnum){ - InputDuplicatex(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,QmuVxEnum,VxEnum); - InputDuplicatex(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,QmuVyEnum,VyEnum); - InputDuplicatex(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,QmuVzEnum,VzEnum); - InputDuplicatex(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,QmuPressureEnum,PressureEnum); - } - - /*Compute slopes: */ - if(isSIA) surfaceslope_core(femmodel); - if(isFS){ - bedslope_core(femmodel); - femmodel->SetCurrentConfiguration(DiagnosticHorizAnalysisEnum); - ResetCoordinateSystemx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters); - } - - if(isSIA){ - if(VerboseSolution()) _printf0_(" computing SIA velocities\n"); - - /*Take the last velocity into account so that the velocity on the SSA domain is not zero*/ - if(isSSA || isL1L2 || isHO ) ResetBoundaryConditions(femmodel,DiagnosticSIAAnalysisEnum); - femmodel->SetCurrentConfiguration(DiagnosticSIAAnalysisEnum); - solutionsequence_linear(femmodel); - if(isSSA || isL1L2 || isHO) ResetBoundaryConditions(femmodel,DiagnosticHorizAnalysisEnum); - } - - if ((isSSA || isHO || isL1L2) ^ isFS){ // ^ = xor - if(VerboseSolution()) _printf0_(" computing velocities\n"); - - femmodel->SetCurrentConfiguration(DiagnosticHorizAnalysisEnum); - if(newton>0) - solutionsequence_newton(femmodel); - else - solutionsequence_nonlinear(femmodel,conserve_loads); - } - - if ((isSSA || isL1L2 || isHO) && isFS){ - if(VerboseSolution()) _printf0_(" computing coupling betweem lower order models and full-FS\n"); - solutionsequence_FScoupling_nonlinear(femmodel,conserve_loads); - } - - if (dim==3 & (isSIA || isSSA || isL1L2 || isHO)){ - if(VerboseSolution()) _printf0_(" computing vertical velocities\n"); - femmodel->SetCurrentConfiguration(DiagnosticVertAnalysisEnum); - solutionsequence_linear(femmodel); - } - - if(save_results){ - if(VerboseSolution()) _printf0_(" saving results\n"); - InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,VxEnum); - InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,VyEnum); - InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,VelEnum); - InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,PressureEnum); - if(dim==3) InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,VzEnum); - femmodel->RequestedOutputsx(requested_outputs,numoutputs); - } - - if(solution_type==DiagnosticSolutionEnum)femmodel->RequestedDependentsx(); - - /*Free ressources:*/ - xDelete(requested_outputs); -} Index: /issm/trunk-jpl/src/c/analyses/objectivefunction.cpp =================================================================== --- /issm/trunk-jpl/src/c/analyses/objectivefunction.cpp (revision 15770) +++ /issm/trunk-jpl/src/c/analyses/objectivefunction.cpp (revision 15771) @@ -37,6 +37,6 @@ /*set analysis type to compute velocity: */ - if (solution_type==SteadystateSolutionEnum || solution_type==DiagnosticSolutionEnum){ - femmodel->SetCurrentConfiguration(DiagnosticHorizAnalysisEnum); + if (solution_type==SteadystateSolutionEnum || solution_type==StressbalanceSolutionEnum){ + femmodel->SetCurrentConfiguration(StressbalanceAnalysisEnum); } else if (solution_type==BalancethicknessSolutionEnum){ @@ -53,9 +53,9 @@ InputControlUpdatex(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,search_scalar,false); - /*Run diagnostic with updated inputs: */ + /*Run stressbalance with updated inputs: */ if (solution_type==SteadystateSolutionEnum){ - diagnostic_core(femmodel); //We need a 3D velocity!! (vz is required for the next thermal run) + stressbalance_core(femmodel); //We need a 3D velocity!! (vz is required for the next thermal run) } - else if (solution_type==DiagnosticSolutionEnum){ + else if (solution_type==StressbalanceSolutionEnum){ solutionsequence_nonlinear(femmodel,conserve_loads); } Index: /issm/trunk-jpl/src/c/analyses/steadystate_core.cpp =================================================================== --- /issm/trunk-jpl/src/c/analyses/steadystate_core.cpp (revision 15770) +++ /issm/trunk-jpl/src/c/analyses/steadystate_core.cpp (revision 15771) @@ -64,5 +64,5 @@ if(VerboseSolution()) _printf0_(" computing new velocity\n"); - diagnostic_core(femmodel); + stressbalance_core(femmodel); GetSolutionFromInputsx(&ug,femmodel->elements, femmodel->nodes, femmodel->vertices,femmodel->loads, femmodel->materials, femmodel->parameters); Index: /issm/trunk-jpl/src/c/analyses/stressbalance_core.cpp =================================================================== --- /issm/trunk-jpl/src/c/analyses/stressbalance_core.cpp (revision 15771) +++ /issm/trunk-jpl/src/c/analyses/stressbalance_core.cpp (revision 15771) @@ -0,0 +1,100 @@ +/*!\file: stressbalance_core.cpp + * \brief: core of the stressbalance solution + */ + +#include "./analyses.h" +#include "../toolkits/toolkits.h" +#include "../classes/classes.h" +#include "../shared/shared.h" +#include "../modules/modules.h" +#include "../solutionsequences/solutionsequences.h" + +void stressbalance_core(FemModel* femmodel){ + + /*parameters: */ + bool dakota_analysis; + int dim; + bool isSIA,isSSA,isL1L2,isHO,isFS; + bool conserve_loads = true; + bool save_results; + int newton; + int solution_type; + int numoutputs = 0; + int *requested_outputs = NULL; + + /* recover parameters:*/ + femmodel->parameters->FindParam(&dim,MeshDimensionEnum); + femmodel->parameters->FindParam(&isSIA,FlowequationIsSIAEnum); + femmodel->parameters->FindParam(&isSSA,FlowequationIsSSAEnum); + femmodel->parameters->FindParam(&isL1L2,FlowequationIsL1L2Enum); + femmodel->parameters->FindParam(&isHO,FlowequationIsHOEnum); + femmodel->parameters->FindParam(&isFS,FlowequationIsFSEnum); + femmodel->parameters->FindParam(&newton,StressbalanceIsnewtonEnum); + femmodel->parameters->FindParam(&dakota_analysis,QmuIsdakotaEnum); + femmodel->parameters->FindParam(&save_results,SaveResultsEnum); + femmodel->parameters->FindParam(&solution_type,SolutionTypeEnum); + femmodel->parameters->FindParam(&numoutputs,StressbalanceNumRequestedOutputsEnum); + if(numoutputs) femmodel->parameters->FindParam(&requested_outputs,&numoutputs,StressbalanceRequestedOutputsEnum); + + /*for qmu analysis, reinitialize velocity so that fake sensitivities do not show up as a result of a different restart of the convergence at each trial.*/ + if(dakota_analysis && solution_type==StressbalanceSolutionEnum){ + InputDuplicatex(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,QmuVxEnum,VxEnum); + InputDuplicatex(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,QmuVyEnum,VyEnum); + InputDuplicatex(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,QmuVzEnum,VzEnum); + InputDuplicatex(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,QmuPressureEnum,PressureEnum); + } + + /*Compute slopes: */ + if(isSIA) surfaceslope_core(femmodel); + if(isFS){ + bedslope_core(femmodel); + femmodel->SetCurrentConfiguration(StressbalanceAnalysisEnum); + ResetCoordinateSystemx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters); + } + + if(isSIA){ + if(VerboseSolution()) _printf0_(" computing SIA velocities\n"); + + /*Take the last velocity into account so that the velocity on the SSA domain is not zero*/ + if(isSSA || isL1L2 || isHO ) ResetBoundaryConditions(femmodel,StressbalanceSIAAnalysisEnum); + femmodel->SetCurrentConfiguration(StressbalanceSIAAnalysisEnum); + solutionsequence_linear(femmodel); + if(isSSA || isL1L2 || isHO) ResetBoundaryConditions(femmodel,StressbalanceAnalysisEnum); + } + + if ((isSSA || isHO || isL1L2) ^ isFS){ // ^ = xor + if(VerboseSolution()) _printf0_(" computing velocities\n"); + + femmodel->SetCurrentConfiguration(StressbalanceAnalysisEnum); + if(newton>0) + solutionsequence_newton(femmodel); + else + solutionsequence_nonlinear(femmodel,conserve_loads); + } + + if ((isSSA || isL1L2 || isHO) && isFS){ + if(VerboseSolution()) _printf0_(" computing coupling betweem lower order models and full-FS\n"); + solutionsequence_FScoupling_nonlinear(femmodel,conserve_loads); + } + + if (dim==3 & (isSIA || isSSA || isL1L2 || isHO)){ + if(VerboseSolution()) _printf0_(" computing vertical velocities\n"); + femmodel->SetCurrentConfiguration(StressbalanceVerticalAnalysisEnum); + solutionsequence_linear(femmodel); + } + + if(save_results){ + if(VerboseSolution()) _printf0_(" saving results\n"); + InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,VxEnum); + InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,VyEnum); + InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,VelEnum); + InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,PressureEnum); + if(dim==3) InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,VzEnum); + femmodel->RequestedOutputsx(requested_outputs,numoutputs); + } + + if(solution_type==StressbalanceSolutionEnum)femmodel->RequestedDependentsx(); + + /*Free ressources:*/ + xDelete(requested_outputs); +} Index: /issm/trunk-jpl/src/c/analyses/transient_core.cpp =================================================================== --- /issm/trunk-jpl/src/c/analyses/transient_core.cpp (revision 15770) +++ /issm/trunk-jpl/src/c/analyses/transient_core.cpp (revision 15771) @@ -21,5 +21,5 @@ /*parameters: */ IssmDouble starttime,finaltime,dt,yts; - bool isdiagnostic,ismasstransport,isthermal,isgroundingline,isenthalpy,isdelta18o,isgia; + bool isstressbalance,ismasstransport,isthermal,isgroundingline,isenthalpy,isdelta18o,isgia; bool save_results,dakota_analysis; bool time_adapt=false; @@ -42,5 +42,5 @@ femmodel->parameters->FindParam(&output_frequency,SettingsOutputFrequencyEnum); femmodel->parameters->FindParam(&time_adapt,TimesteppingTimeAdaptEnum); - femmodel->parameters->FindParam(&isdiagnostic,TransientIsdiagnosticEnum); + femmodel->parameters->FindParam(&isstressbalance,TransientIsstressbalanceEnum); femmodel->parameters->FindParam(&ismasstransport,TransientIsmasstransportEnum); femmodel->parameters->FindParam(&isthermal,TransientIsthermalEnum); @@ -117,10 +117,10 @@ } - if(isdiagnostic){ + if(isstressbalance){ if(VerboseSolution()) _printf0_(" computing new velocity\n"); - #ifdef _HAVE_DIAGNOSTIC_ - diagnostic_core(femmodel); + #ifdef _HAVE_STRESSBALANCE_ + stressbalance_core(femmodel); #else - _error_("ISSM was not compiled with diagnostic capabilities. Exiting"); + _error_("ISSM was not compiled with stressbalance capabilities. Exiting"); #endif } Index: /issm/trunk-jpl/src/c/classes/Elements/Penta.cpp =================================================================== --- /issm/trunk-jpl/src/c/classes/Elements/Penta.cpp (revision 15770) +++ /issm/trunk-jpl/src/c/classes/Elements/Penta.cpp (revision 15771) @@ -184,5 +184,5 @@ /*Build friction element, needed later: */ - friction=new Friction("3d",inputs,matpar,DiagnosticHorizAnalysisEnum); + friction=new Friction("3d",inputs,matpar,StressbalanceAnalysisEnum); /* Start looping on the number of gauss 2d (nodes on the bedrock) */ @@ -233,9 +233,9 @@ /*Check analysis_types*/ - if (analysis_type!=DiagnosticHorizAnalysisEnum) _error_("Not supported yet!"); + if (analysis_type!=StressbalanceAnalysisEnum) _error_("Not supported yet!"); if (approximation!=FSApproximationEnum) _error_("Not supported yet!"); /*retrieve some parameters: */ - this->parameters->FindParam(&FSreconditioning,DiagnosticFSreconditioningEnum); + this->parameters->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum); if(!IsOnBed()){ @@ -403,5 +403,5 @@ int analysis_type; parameters->FindParam(&analysis_type,AnalysisTypeEnum); - if(analysis_type==DiagnosticHorizAnalysisEnum){ + if(analysis_type==StressbalanceAnalysisEnum){ int approximation; inputs->GetInputValue(&approximation,ApproximationEnum); @@ -450,16 +450,16 @@ /*Just branch to the correct element stiffness matrix generator, according to the type of analysis we are carrying out: */ switch(analysis_type){ - #ifdef _HAVE_DIAGNOSTIC_ - case DiagnosticHorizAnalysisEnum: - return CreateKMatrixDiagnosticHoriz(); + #ifdef _HAVE_STRESSBALANCE_ + case StressbalanceAnalysisEnum: + return CreateKMatrixStressbalanceHoriz(); break; case AdjointHorizAnalysisEnum: return CreateKMatrixAdjointHoriz(); break; - case DiagnosticSIAAnalysisEnum: - return CreateKMatrixDiagnosticSIA(); + case StressbalanceSIAAnalysisEnum: + return CreateKMatrixStressbalanceSIA(); break; - case DiagnosticVertAnalysisEnum: - return CreateKMatrixDiagnosticVert(); + case StressbalanceVerticalAnalysisEnum: + return CreateKMatrixStressbalanceVert(); break; #endif @@ -550,7 +550,7 @@ switch(analysis_type){ - #ifdef _HAVE_DIAGNOSTIC_ - case DiagnosticHorizAnalysisEnum: - De=CreateDVectorDiagnosticHoriz(); + #ifdef _HAVE_STRESSBALANCE_ + case StressbalanceAnalysisEnum: + De=CreateDVectorStressbalanceHoriz(); break; #endif @@ -576,5 +576,5 @@ int analysis_type; parameters->FindParam(&analysis_type,AnalysisTypeEnum); - if(analysis_type==DiagnosticHorizAnalysisEnum){ + if(analysis_type==StressbalanceAnalysisEnum){ /*StaticCondensation if requested*/ if(this->element_type==MINIcondensedEnum){ @@ -588,5 +588,5 @@ this->element_type=MINIEnum; - ElementMatrix* Ke = CreateKMatrixDiagnosticFS(); + ElementMatrix* Ke = CreateKMatrixStressbalanceFS(); this->element_type=MINIcondensedEnum; @@ -633,13 +633,13 @@ /*Just branch to the correct element stiffness matrix generator, according to the type of analysis we are carrying out: */ switch(analysis_type){ - #ifdef _HAVE_DIAGNOSTIC_ - case DiagnosticHorizAnalysisEnum: - return CreatePVectorDiagnosticHoriz(); + #ifdef _HAVE_STRESSBALANCE_ + case StressbalanceAnalysisEnum: + return CreatePVectorStressbalanceHoriz(); break; - case DiagnosticSIAAnalysisEnum: - return CreatePVectorDiagnosticSIA(); + case StressbalanceSIAAnalysisEnum: + return CreatePVectorStressbalanceSIA(); break; - case DiagnosticVertAnalysisEnum: - return CreatePVectorDiagnosticVert(); + case StressbalanceVerticalAnalysisEnum: + return CreatePVectorStressbalanceVert(); break; #endif @@ -740,7 +740,7 @@ /*Just branch to the correct element stiffness matrix generator, according to the type of analysis we are carrying out: */ switch(analysis_type){ -#ifdef _HAVE_DIAGNOSTIC_ - case DiagnosticHorizAnalysisEnum: - Ke=CreateJacobianDiagnosticHoriz(); +#ifdef _HAVE_STRESSBALANCE_ + case StressbalanceAnalysisEnum: + Ke=CreateJacobianStressbalanceHoriz(); break; #endif @@ -1379,13 +1379,13 @@ /*Just branch to the correct InputUpdateFromSolution generator, according to the type of analysis we are carrying out: */ switch(analysis_type){ - #ifdef _HAVE_DIAGNOSTIC_ - case DiagnosticHorizAnalysisEnum: + #ifdef _HAVE_STRESSBALANCE_ + case StressbalanceAnalysisEnum: int approximation; inputs->GetInputValue(&approximation,ApproximationEnum); if(approximation==FSApproximationEnum || approximation==NoneApproximationEnum){ - GetSolutionFromInputsDiagnosticFS(solution); + GetSolutionFromInputsStressbalanceFS(solution); } else if (approximation==SSAApproximationEnum || approximation==HOApproximationEnum || approximation==SIAApproximationEnum){ - GetSolutionFromInputsDiagnosticHoriz(solution); + GetSolutionFromInputsStressbalanceHoriz(solution); } else if (approximation==SSAHOApproximationEnum || approximation==HOFSApproximationEnum || approximation==SSAFSApproximationEnum){ @@ -1393,9 +1393,9 @@ } break; - case DiagnosticSIAAnalysisEnum: - GetSolutionFromInputsDiagnosticSIA(solution); + case StressbalanceSIAAnalysisEnum: + GetSolutionFromInputsStressbalanceSIA(solution); break; - case DiagnosticVertAnalysisEnum: - //GetSolutionFromInputsDiagnosticVert(solution); + case StressbalanceVerticalAnalysisEnum: + //GetSolutionFromInputsStressbalanceVert(solution); GetSolutionFromInputsOneDof(solution, VzEnum); break; @@ -2214,13 +2214,13 @@ /*Just branch to the correct InputUpdateFromSolution generator, according to the type of analysis we are carrying out: */ switch(analysis_type){ - #ifdef _HAVE_DIAGNOSTIC_ - case DiagnosticHorizAnalysisEnum: - InputUpdateFromSolutionDiagnosticHoriz( solution); + #ifdef _HAVE_STRESSBALANCE_ + case StressbalanceAnalysisEnum: + InputUpdateFromSolutionStressbalanceHoriz( solution); break; - case DiagnosticSIAAnalysisEnum: - InputUpdateFromSolutionDiagnosticSIA( solution); + case StressbalanceSIAAnalysisEnum: + InputUpdateFromSolutionStressbalanceSIA( solution); break; - case DiagnosticVertAnalysisEnum: - InputUpdateFromSolutionDiagnosticVert( solution); + case StressbalanceVerticalAnalysisEnum: + InputUpdateFromSolutionStressbalanceVert( solution); break; #endif @@ -3073,5 +3073,5 @@ int analysis_type,approximation,numlayers; parameters->FindParam(&analysis_type,AnalysisTypeEnum); - if(analysis_type==DiagnosticHorizAnalysisEnum){ + if(analysis_type==StressbalanceAnalysisEnum){ inputs->GetInputValue(&approximation,ApproximationEnum); if(approximation==SSAHOApproximationEnum || approximation==SSAFSApproximationEnum){ @@ -3450,5 +3450,5 @@ switch(analysis_type){ - case DiagnosticHorizAnalysisEnum: + case StressbalanceAnalysisEnum: /*default vx,vy and vz: either observation or 0 */ @@ -5138,5 +5138,5 @@ /*Initialize Jacobian with regular HO (first part of the Gateau derivative)*/ parameters->FindParam(&incomplete_adjoint,InversionIncompleteAdjointEnum); - ElementMatrix* Ke=CreateKMatrixDiagnosticHO(); + ElementMatrix* Ke=CreateKMatrixStressbalanceHO(); if(incomplete_adjoint) return Ke; @@ -5203,5 +5203,5 @@ /*Initialize Jacobian with regular FS (first part of the Gateau derivative)*/ parameters->FindParam(&incomplete_adjoint,InversionIncompleteAdjointEnum); - ElementMatrix* Ke=CreateKMatrixDiagnosticFS(); + ElementMatrix* Ke=CreateKMatrixStressbalanceFS(); if(incomplete_adjoint) return Ke; @@ -6112,5 +6112,5 @@ /*Recondition pressure and compute vel: */ - this->parameters->FindParam(&FSreconditioning,DiagnosticFSreconditioningEnum); + this->parameters->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum); for(i=0;iparameters->FindParam(&viscosity_overshoot,DiagnosticViscosityOvershootEnum); + this->parameters->FindParam(&viscosity_overshoot,StressbalanceViscosityOvershootEnum); Input* vx_input=inputs->GetInput(VxEnum); _assert_(vx_input); Input* vy_input=inputs->GetInput(VyEnum); _assert_(vy_input); @@ -6933,5 +6933,5 @@ /* Get node coordinates and dof list: */ GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES); - parameters->FindParam(&FSreconditioning,DiagnosticFSreconditioningEnum); + parameters->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum); Input* vx_input=inputs->GetInput(VxEnum); _assert_(vx_input); Input* vy_input=inputs->GetInput(VyEnum); _assert_(vy_input); @@ -7043,5 +7043,5 @@ GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES); parameters->FindParam(&analysis_type,AnalysisTypeEnum); - parameters->FindParam(&FSreconditioning,DiagnosticFSreconditioningEnum); + parameters->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum); Input* vx_input=inputs->GetInput(VxEnum); _assert_(vx_input); Input* vy_input=inputs->GetInput(VyEnum); _assert_(vy_input); @@ -7131,8 +7131,8 @@ /*Compute HO Matrix with P1 element type\n");*/ this->element_type=P1Enum; - Ke1=CreateKMatrixDiagnosticHO(); + Ke1=CreateKMatrixStressbalanceHO(); this->element_type=init; /*Compute FS Matrix and condense it \n");*/ - Ke2=CreateKMatrixDiagnosticFS(); + Ke2=CreateKMatrixStressbalanceFS(); int indices[3]={18,19,20}; Ke2->StaticCondensation(3,&indices[0]); @@ -7156,6 +7156,6 @@ } //*}}}*/ -/*FUNCTION Penta::CreateKMatrixDiagnosticHoriz {{{*/ -ElementMatrix* Penta::CreateKMatrixDiagnosticHoriz(void){ +/*FUNCTION Penta::CreateKMatrixStressbalanceHoriz {{{*/ +ElementMatrix* Penta::CreateKMatrixStressbalanceHoriz(void){ int approximation; @@ -7163,11 +7163,11 @@ switch(approximation){ case SSAApproximationEnum: - return CreateKMatrixDiagnosticSSA2d(); + return CreateKMatrixStressbalanceSSA2d(); case L1L2ApproximationEnum: - return CreateKMatrixDiagnosticL1L2(); + return CreateKMatrixStressbalanceL1L2(); case HOApproximationEnum: - return CreateKMatrixDiagnosticHO(); + return CreateKMatrixStressbalanceHO(); case FSApproximationEnum: - return CreateKMatrixDiagnosticFS(); + return CreateKMatrixStressbalanceFS(); case SIAApproximationEnum: return NULL; @@ -7175,9 +7175,9 @@ return NULL; case SSAHOApproximationEnum: - return CreateKMatrixDiagnosticSSAHO(); + return CreateKMatrixStressbalanceSSAHO(); case SSAFSApproximationEnum: - return CreateKMatrixDiagnosticSSAFS(); + return CreateKMatrixStressbalanceSSAFS(); case HOFSApproximationEnum: - return CreateKMatrixDiagnosticHOFS(); + return CreateKMatrixStressbalanceHOFS(); default: _error_("Approximation " << EnumToStringx(approximation) << " not supported yet"); @@ -7185,6 +7185,6 @@ } /*}}}*/ -/*FUNCTION Penta::CreateKMatrixDiagnosticSIA{{{*/ -ElementMatrix* Penta::CreateKMatrixDiagnosticSIA(void){ +/*FUNCTION Penta::CreateKMatrixStressbalanceSIA{{{*/ +ElementMatrix* Penta::CreateKMatrixStressbalanceSIA(void){ /*Intermediaries*/ @@ -7248,6 +7248,6 @@ return Ke; }/*}}}*/ -/*FUNCTION Penta::CreateKMatrixDiagnosticSSA2d{{{*/ -ElementMatrix* Penta::CreateKMatrixDiagnosticSSA2d(void){ +/*FUNCTION Penta::CreateKMatrixStressbalanceSSA2d{{{*/ +ElementMatrix* Penta::CreateKMatrixStressbalanceSSA2d(void){ /*Figure out if this penta is collapsed. If so, then bailout, except if it is at the @@ -7271,5 +7271,5 @@ /*Call Tria function*/ Tria* tria=(Tria*)SpawnTria(0); //lower face is 0, upper face is 1. - ElementMatrix* Ke=tria->CreateKMatrixDiagnosticSSA(); + ElementMatrix* Ke=tria->CreateKMatrixStressbalanceSSA(); delete tria->material; delete tria; @@ -7282,10 +7282,10 @@ } /*}}}*/ -/*FUNCTION Penta::CreateKMatrixDiagnosticSSA3d{{{*/ -ElementMatrix* Penta::CreateKMatrixDiagnosticSSA3d(void){ +/*FUNCTION Penta::CreateKMatrixStressbalanceSSA3d{{{*/ +ElementMatrix* Penta::CreateKMatrixStressbalanceSSA3d(void){ /*compute all stiffness matrices for this element*/ - ElementMatrix* Ke1=CreateKMatrixDiagnosticSSA3dViscous(); - ElementMatrix* Ke2=CreateKMatrixDiagnosticSSA3dFriction(); + ElementMatrix* Ke1=CreateKMatrixStressbalanceSSA3dViscous(); + ElementMatrix* Ke2=CreateKMatrixStressbalanceSSA3dFriction(); ElementMatrix* Ke =new ElementMatrix(Ke1,Ke2); @@ -7296,6 +7296,6 @@ } /*}}}*/ -/*FUNCTION Penta::CreateKMatrixDiagnosticSSA3dViscous{{{*/ -ElementMatrix* Penta::CreateKMatrixDiagnosticSSA3dViscous(void){ +/*FUNCTION Penta::CreateKMatrixStressbalanceSSA3dViscous{{{*/ +ElementMatrix* Penta::CreateKMatrixStressbalanceSSA3dViscous(void){ /*Constants*/ @@ -7329,5 +7329,5 @@ /*Retrieve all inputs and parameters*/ GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES); - this->parameters->FindParam(&viscosity_overshoot,DiagnosticViscosityOvershootEnum); + this->parameters->FindParam(&viscosity_overshoot,StressbalanceViscosityOvershootEnum); Input* vx_input=inputs->GetInput(VxEnum); _assert_(vx_input); Input* vy_input=inputs->GetInput(VyEnum); _assert_(vy_input); @@ -7384,6 +7384,6 @@ } /*}}}*/ -/*FUNCTION Penta::CreateKMatrixDiagnosticSSA3dFriction{{{*/ -ElementMatrix* Penta::CreateKMatrixDiagnosticSSA3dFriction(void){ +/*FUNCTION Penta::CreateKMatrixStressbalanceSSA3dFriction{{{*/ +ElementMatrix* Penta::CreateKMatrixStressbalanceSSA3dFriction(void){ /*Initialize Element matrix and return if necessary*/ @@ -7394,5 +7394,5 @@ * nodes: */ Tria* tria=(Tria*)SpawnTria(0); //lower face is 0, upper face is 1. - ElementMatrix* Ke=tria->CreateKMatrixDiagnosticSSAFriction(); + ElementMatrix* Ke=tria->CreateKMatrixStressbalanceSSAFriction(); delete tria->material; delete tria; @@ -7401,10 +7401,10 @@ } /*}}}*/ -/*FUNCTION Penta::CreateKMatrixDiagnosticSSAHO{{{*/ -ElementMatrix* Penta::CreateKMatrixDiagnosticSSAHO(void){ +/*FUNCTION Penta::CreateKMatrixStressbalanceSSAHO{{{*/ +ElementMatrix* Penta::CreateKMatrixStressbalanceSSAHO(void){ /*compute all stiffness matrices for this element*/ - ElementMatrix* Ke1=CreateKMatrixDiagnosticSSA3d(); - ElementMatrix* Ke2=CreateKMatrixDiagnosticHO(); + ElementMatrix* Ke1=CreateKMatrixStressbalanceSSA3d(); + ElementMatrix* Ke2=CreateKMatrixStressbalanceHO(); ElementMatrix* Ke3=CreateKMatrixCouplingSSAHO(); ElementMatrix* Ke =new ElementMatrix(Ke1,Ke2,Ke3); @@ -7417,14 +7417,14 @@ } /*}}}*/ -/*FUNCTION Penta::CreateKMatrixDiagnosticSSAFS{{{*/ -ElementMatrix* Penta::CreateKMatrixDiagnosticSSAFS(void){ +/*FUNCTION Penta::CreateKMatrixStressbalanceSSAFS{{{*/ +ElementMatrix* Penta::CreateKMatrixStressbalanceSSAFS(void){ /*compute all stiffness matrices for this element*/ - ElementMatrix* Ke1=CreateKMatrixDiagnosticFS(); + ElementMatrix* Ke1=CreateKMatrixStressbalanceFS(); int indices[3]={18,19,20}; Ke1->StaticCondensation(3,&indices[0]); int init = this->element_type; this->element_type=P1Enum; //P1 needed for HO - ElementMatrix* Ke2=CreateKMatrixDiagnosticSSA3d(); + ElementMatrix* Ke2=CreateKMatrixStressbalanceSSA3d(); this->element_type=init; ElementMatrix* Ke3=CreateKMatrixCouplingSSAFS(); @@ -7438,10 +7438,10 @@ } /*}}}*/ -/*FUNCTION Penta::CreateKMatrixDiagnosticL1L2{{{*/ -ElementMatrix* Penta::CreateKMatrixDiagnosticL1L2(void){ +/*FUNCTION Penta::CreateKMatrixStressbalanceL1L2{{{*/ +ElementMatrix* Penta::CreateKMatrixStressbalanceL1L2(void){ /*compute all stiffness matrices for this element*/ - ElementMatrix* Ke1=CreateKMatrixDiagnosticL1L2Viscous(); - ElementMatrix* Ke2=CreateKMatrixDiagnosticL1L2Friction(); + ElementMatrix* Ke1=CreateKMatrixStressbalanceL1L2Viscous(); + ElementMatrix* Ke2=CreateKMatrixStressbalanceL1L2Friction(); ElementMatrix* Ke =new ElementMatrix(Ke1,Ke2); @@ -7452,6 +7452,6 @@ } /*}}}*/ -/*FUNCTION Penta::CreateKMatrixDiagnosticL1L2Viscous{{{*/ -ElementMatrix* Penta::CreateKMatrixDiagnosticL1L2Viscous(void){ +/*FUNCTION Penta::CreateKMatrixStressbalanceL1L2Viscous{{{*/ +ElementMatrix* Penta::CreateKMatrixStressbalanceL1L2Viscous(void){ /*Constants*/ @@ -7520,6 +7520,6 @@ } /*}}}*/ -/*FUNCTION Penta::CreateKMatrixDiagnosticL1L2Friction{{{*/ -ElementMatrix* Penta::CreateKMatrixDiagnosticL1L2Friction(void){ +/*FUNCTION Penta::CreateKMatrixStressbalanceL1L2Friction{{{*/ +ElementMatrix* Penta::CreateKMatrixStressbalanceL1L2Friction(void){ /*Initialize Element matrix and return if necessary*/ @@ -7530,5 +7530,5 @@ * nodes: */ Tria* tria=(Tria*)SpawnTria(0); //lower face is 0, upper face is 1. - ElementMatrix* Ke=tria->CreateKMatrixDiagnosticSSAFriction(); + ElementMatrix* Ke=tria->CreateKMatrixStressbalanceSSAFriction(); delete tria->material; delete tria; @@ -7537,10 +7537,10 @@ } /*}}}*/ -/*FUNCTION Penta::CreateKMatrixDiagnosticHO{{{*/ -ElementMatrix* Penta::CreateKMatrixDiagnosticHO(void){ +/*FUNCTION Penta::CreateKMatrixStressbalanceHO{{{*/ +ElementMatrix* Penta::CreateKMatrixStressbalanceHO(void){ /*compute all stiffness matrices for this element*/ - ElementMatrix* Ke1=CreateKMatrixDiagnosticHOViscous(); - ElementMatrix* Ke2=CreateKMatrixDiagnosticHOFriction(); + ElementMatrix* Ke1=CreateKMatrixStressbalanceHOViscous(); + ElementMatrix* Ke2=CreateKMatrixStressbalanceHOFriction(); ElementMatrix* Ke =new ElementMatrix(Ke1,Ke2); @@ -7552,6 +7552,6 @@ } /*}}}*/ -/*FUNCTION Penta::CreateKMatrixDiagnosticHOViscous{{{*/ -ElementMatrix* Penta::CreateKMatrixDiagnosticHOViscous(void){ +/*FUNCTION Penta::CreateKMatrixStressbalanceHOViscous{{{*/ +ElementMatrix* Penta::CreateKMatrixStressbalanceHOViscous(void){ /*Intermediaries */ @@ -7578,5 +7578,5 @@ inputs->GetInputValue(&approximation,ApproximationEnum); GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES); - this->parameters->FindParam(&viscosity_overshoot,DiagnosticViscosityOvershootEnum); + this->parameters->FindParam(&viscosity_overshoot,StressbalanceViscosityOvershootEnum); Input* vx_input=inputs->GetInput(VxEnum); _assert_(vx_input); Input* vy_input=inputs->GetInput(VyEnum); _assert_(vy_input); @@ -7620,6 +7620,6 @@ } /*}}}*/ -/*FUNCTION Penta::CreateKMatrixDiagnosticHOFriction{{{*/ -ElementMatrix* Penta::CreateKMatrixDiagnosticHOFriction(void){ +/*FUNCTION Penta::CreateKMatrixStressbalanceHOFriction{{{*/ +ElementMatrix* Penta::CreateKMatrixStressbalanceHOFriction(void){ /*Intermediaries */ @@ -7694,14 +7694,14 @@ } /*}}}*/ -/*FUNCTION Penta::CreateKMatrixDiagnosticHOFS{{{*/ -ElementMatrix* Penta::CreateKMatrixDiagnosticHOFS(void){ +/*FUNCTION Penta::CreateKMatrixStressbalanceHOFS{{{*/ +ElementMatrix* Penta::CreateKMatrixStressbalanceHOFS(void){ /*compute all stiffness matrices for this element*/ - ElementMatrix* Ke1=CreateKMatrixDiagnosticFS(); + ElementMatrix* Ke1=CreateKMatrixStressbalanceFS(); int indices[3]={18,19,20}; Ke1->StaticCondensation(3,&indices[0]); int init = this->element_type; this->element_type=P1Enum; //P1 needed for HO - ElementMatrix* Ke2=CreateKMatrixDiagnosticHO(); + ElementMatrix* Ke2=CreateKMatrixStressbalanceHO(); this->element_type=init; ElementMatrix* Ke3=CreateKMatrixCouplingHOFS(); @@ -7715,6 +7715,6 @@ } /*}}}*/ -/*FUNCTION Penta::CreateKMatrixDiagnosticFS{{{*/ -ElementMatrix* Penta::CreateKMatrixDiagnosticFS(void){ +/*FUNCTION Penta::CreateKMatrixStressbalanceFS{{{*/ +ElementMatrix* Penta::CreateKMatrixStressbalanceFS(void){ ElementMatrix* Ke1 = NULL; @@ -7723,6 +7723,6 @@ /*compute all stiffness matrices for this element*/ - Ke1=CreateKMatrixDiagnosticFSViscous(); - Ke2=CreateKMatrixDiagnosticFSFriction(); + Ke1=CreateKMatrixStressbalanceFSViscous(); + Ke2=CreateKMatrixStressbalanceFSFriction(); Ke =new ElementMatrix(Ke1,Ke2); @@ -7767,5 +7767,5 @@ /*Retrieve all inputs and parameters*/ GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES); - parameters->FindParam(&FSreconditioning,DiagnosticFSreconditioningEnum); + parameters->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum); Input* vx_input=inputs->GetInput(VxEnum); _assert_(vx_input); Input* vy_input=inputs->GetInput(VyEnum); _assert_(vy_input); @@ -7848,6 +7848,6 @@ } /*}}}*/ -/*FUNCTION Penta::CreateKMatrixDiagnosticFSViscous {{{*/ -ElementMatrix* Penta::CreateKMatrixDiagnosticFSViscous(void){ +/*FUNCTION Penta::CreateKMatrixStressbalanceFSViscous {{{*/ +ElementMatrix* Penta::CreateKMatrixStressbalanceFSViscous(void){ /*Intermediaries */ @@ -7880,5 +7880,5 @@ /*Retrieve all inputs and parameters*/ GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES); - parameters->FindParam(&FSreconditioning,DiagnosticFSreconditioningEnum); + parameters->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum); Input* vx_input=inputs->GetInput(VxEnum); _assert_(vx_input); Input* vy_input=inputs->GetInput(VyEnum); _assert_(vy_input); @@ -7920,6 +7920,6 @@ } /*}}}*/ -/*FUNCTION Penta::CreateKMatrixDiagnosticFSFriction{{{*/ -ElementMatrix* Penta::CreateKMatrixDiagnosticFSFriction(void){ +/*FUNCTION Penta::CreateKMatrixStressbalanceFSFriction{{{*/ +ElementMatrix* Penta::CreateKMatrixStressbalanceFSFriction(void){ /*Intermediaries */ @@ -7954,5 +7954,5 @@ GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES); parameters->FindParam(&analysis_type,AnalysisTypeEnum); - parameters->FindParam(&FSreconditioning,DiagnosticFSreconditioningEnum); + parameters->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum); Input* vx_input=inputs->GetInput(VxEnum); _assert_(vx_input); Input* vy_input=inputs->GetInput(VyEnum); _assert_(vy_input); @@ -7997,10 +7997,10 @@ } /*}}}*/ -/*FUNCTION Penta::CreateKMatrixDiagnosticVert {{{*/ -ElementMatrix* Penta::CreateKMatrixDiagnosticVert(void){ +/*FUNCTION Penta::CreateKMatrixStressbalanceVert {{{*/ +ElementMatrix* Penta::CreateKMatrixStressbalanceVert(void){ /*compute all stiffness matrices for this element*/ - ElementMatrix* Ke1=CreateKMatrixDiagnosticVertVolume(); - ElementMatrix* Ke2=CreateKMatrixDiagnosticVertSurface(); + ElementMatrix* Ke1=CreateKMatrixStressbalanceVertVolume(); + ElementMatrix* Ke2=CreateKMatrixStressbalanceVertSurface(); ElementMatrix* Ke =new ElementMatrix(Ke1,Ke2); @@ -8012,6 +8012,6 @@ } /*}}}*/ -/*FUNCTION Penta::CreateKMatrixDiagnosticVertVolume {{{*/ -ElementMatrix* Penta::CreateKMatrixDiagnosticVertVolume(void){ +/*FUNCTION Penta::CreateKMatrixStressbalanceVertVolume {{{*/ +ElementMatrix* Penta::CreateKMatrixStressbalanceVertVolume(void){ /*Intermediaries */ @@ -8052,6 +8052,6 @@ } /*}}}*/ -/*FUNCTION Penta::CreateKMatrixDiagnosticVertSurface {{{*/ -ElementMatrix* Penta::CreateKMatrixDiagnosticVertSurface(void){ +/*FUNCTION Penta::CreateKMatrixStressbalanceVertSurface {{{*/ +ElementMatrix* Penta::CreateKMatrixStressbalanceVertSurface(void){ if (!IsOnSurface()) return NULL; @@ -8142,5 +8142,5 @@ /*Retrieve all inputs and parameters*/ GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES); - this->parameters->FindParam(&FSreconditioning,DiagnosticFSreconditioningEnum); + this->parameters->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum); Input* vx_input=inputs->GetInput(VxEnum); _assert_(vx_input); Input* vy_input=inputs->GetInput(VyEnum); _assert_(vy_input); @@ -8208,5 +8208,5 @@ GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES); parameters->FindParam(&analysis_type,AnalysisTypeEnum); - this->parameters->FindParam(&FSreconditioning,DiagnosticFSreconditioningEnum); + this->parameters->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum); Input* vx_input=inputs->GetInput(VxEnum); _assert_(vx_input); Input* vy_input=inputs->GetInput(VyEnum); _assert_(vy_input); @@ -8297,5 +8297,5 @@ /*Retrieve all inputs and parameters*/ GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES); - this->parameters->FindParam(&FSreconditioning,DiagnosticFSreconditioningEnum); + this->parameters->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum); Input* vx_input=inputs->GetInput(VxEnum); _assert_(vx_input); Input* vy_input=inputs->GetInput(VyEnum); _assert_(vy_input); @@ -8373,5 +8373,5 @@ GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES); parameters->FindParam(&analysis_type,AnalysisTypeEnum); - this->parameters->FindParam(&FSreconditioning,DiagnosticFSreconditioningEnum); + this->parameters->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum); Input* vx_input=inputs->GetInput(VxEnum); _assert_(vx_input); Input* vy_input=inputs->GetInput(VyEnum); _assert_(vy_input); @@ -8418,6 +8418,6 @@ } /*}}}*/ -/*FUNCTION Penta::CreatePVectorDiagnosticHoriz{{{*/ -ElementVector* Penta::CreatePVectorDiagnosticHoriz(void){ +/*FUNCTION Penta::CreatePVectorStressbalanceHoriz{{{*/ +ElementVector* Penta::CreatePVectorStressbalanceHoriz(void){ int approximation; @@ -8426,9 +8426,9 @@ switch(approximation){ case SSAApproximationEnum: - return CreatePVectorDiagnosticSSA(); + return CreatePVectorStressbalanceSSA(); case HOApproximationEnum: - return CreatePVectorDiagnosticHO(); + return CreatePVectorStressbalanceHO(); case L1L2ApproximationEnum: - return CreatePVectorDiagnosticL1L2(); + return CreatePVectorStressbalanceL1L2(); case SIAApproximationEnum: return NULL; @@ -8436,11 +8436,11 @@ return NULL; case FSApproximationEnum: - return CreatePVectorDiagnosticFS(); + return CreatePVectorStressbalanceFS(); case SSAHOApproximationEnum: - return CreatePVectorDiagnosticSSAHO(); + return CreatePVectorStressbalanceSSAHO(); case SSAFSApproximationEnum: - return CreatePVectorDiagnosticSSAFS(); + return CreatePVectorStressbalanceSSAFS(); case HOFSApproximationEnum: - return CreatePVectorDiagnosticHOFS(); + return CreatePVectorStressbalanceHOFS(); default: _error_("Approximation " << EnumToStringx(approximation) << " not supported yet"); @@ -8448,10 +8448,10 @@ } /*}}}*/ -/*FUNCTION Penta::CreatePVectorDiagnosticSSAHO{{{*/ -ElementVector* Penta::CreatePVectorDiagnosticSSAHO(void){ +/*FUNCTION Penta::CreatePVectorStressbalanceSSAHO{{{*/ +ElementVector* Penta::CreatePVectorStressbalanceSSAHO(void){ /*compute all load vectors for this element*/ - ElementVector* pe1=CreatePVectorDiagnosticSSA(); - ElementVector* pe2=CreatePVectorDiagnosticHO(); + ElementVector* pe1=CreatePVectorStressbalanceSSA(); + ElementVector* pe2=CreatePVectorStressbalanceHO(); ElementVector* pe =new ElementVector(pe1,pe2); @@ -8462,16 +8462,16 @@ } /*}}}*/ -/*FUNCTION Penta::CreatePVectorDiagnosticSSAFS{{{*/ -ElementVector* Penta::CreatePVectorDiagnosticSSAFS(void){ +/*FUNCTION Penta::CreatePVectorStressbalanceSSAFS{{{*/ +ElementVector* Penta::CreatePVectorStressbalanceSSAFS(void){ /*compute all load vectors for this element*/ int init = this->element_type; this->element_type=P1Enum; - ElementVector* pe1=CreatePVectorDiagnosticSSA(); + ElementVector* pe1=CreatePVectorStressbalanceSSA(); this->element_type=init; - ElementVector* pe2=CreatePVectorDiagnosticFS(); + ElementVector* pe2=CreatePVectorStressbalanceFS(); int indices[3]={18,19,20}; this->element_type=MINIcondensedEnum; - ElementMatrix* Ke = CreateKMatrixDiagnosticFS(); + ElementMatrix* Ke = CreateKMatrixStressbalanceFS(); this->element_type=init; pe2->StaticCondensation(Ke,3,&indices[0]); @@ -8487,16 +8487,16 @@ } /*}}}*/ -/*FUNCTION Penta::CreatePVectorDiagnosticHOFS{{{*/ -ElementVector* Penta::CreatePVectorDiagnosticHOFS(void){ +/*FUNCTION Penta::CreatePVectorStressbalanceHOFS{{{*/ +ElementVector* Penta::CreatePVectorStressbalanceHOFS(void){ /*compute all load vectors for this element*/ int init = this->element_type; this->element_type=P1Enum; - ElementVector* pe1=CreatePVectorDiagnosticHO(); + ElementVector* pe1=CreatePVectorStressbalanceHO(); this->element_type=init; - ElementVector* pe2=CreatePVectorDiagnosticFS(); + ElementVector* pe2=CreatePVectorStressbalanceFS(); int indices[3]={18,19,20}; this->element_type=MINIcondensedEnum; - ElementMatrix* Ke = CreateKMatrixDiagnosticFS(); + ElementMatrix* Ke = CreateKMatrixStressbalanceFS(); this->element_type=init; pe2->StaticCondensation(Ke,3,&indices[0]); @@ -8512,6 +8512,6 @@ } /*}}}*/ -/*FUNCTION Penta::CreatePVectorDiagnosticSIA{{{*/ -ElementVector* Penta::CreatePVectorDiagnosticSIA(void){ +/*FUNCTION Penta::CreatePVectorStressbalanceSIA{{{*/ +ElementVector* Penta::CreatePVectorStressbalanceSIA(void){ /*Intermediaries*/ @@ -8602,6 +8602,6 @@ } /*}}}*/ -/*FUNCTION Penta::CreatePVectorDiagnosticSSA{{{*/ -ElementVector* Penta::CreatePVectorDiagnosticSSA(void){ +/*FUNCTION Penta::CreatePVectorStressbalanceSSA{{{*/ +ElementVector* Penta::CreatePVectorStressbalanceSSA(void){ if (!IsOnBed()) return NULL; @@ -8609,5 +8609,5 @@ /*Call Tria function*/ Tria* tria=(Tria*)SpawnTria(0); //lower face is 0, upper face is 1. - ElementVector* pe=tria->CreatePVectorDiagnosticSSA(); + ElementVector* pe=tria->CreatePVectorStressbalanceSSA(); delete tria->material; delete tria; @@ -8616,6 +8616,6 @@ } /*}}}*/ -/*FUNCTION Penta::CreatePVectorDiagnosticL1L2{{{*/ -ElementVector* Penta::CreatePVectorDiagnosticL1L2(void){ +/*FUNCTION Penta::CreatePVectorStressbalanceL1L2{{{*/ +ElementVector* Penta::CreatePVectorStressbalanceL1L2(void){ if (!IsOnBed()) return NULL; @@ -8623,5 +8623,5 @@ /*Call Tria function*/ Tria* tria=(Tria*)SpawnTria(0); //lower face is 0, upper face is 1. - ElementVector* pe=tria->CreatePVectorDiagnosticSSA(); + ElementVector* pe=tria->CreatePVectorStressbalanceSSA(); delete tria->material; delete tria; @@ -8630,10 +8630,10 @@ } /*}}}*/ -/*FUNCTION Penta::CreatePVectorDiagnosticHO{{{*/ -ElementVector* Penta::CreatePVectorDiagnosticHO(void){ +/*FUNCTION Penta::CreatePVectorStressbalanceHO{{{*/ +ElementVector* Penta::CreatePVectorStressbalanceHO(void){ /*compute all load vectors for this element*/ - ElementVector* pe1=CreatePVectorDiagnosticHODrivingStress(); - ElementVector* pe2=CreatePVectorDiagnosticHOFront(); + ElementVector* pe1=CreatePVectorStressbalanceHODrivingStress(); + ElementVector* pe2=CreatePVectorStressbalanceHOFront(); ElementVector* pe =new ElementVector(pe1,pe2); @@ -8644,6 +8644,6 @@ } /*}}}*/ -/*FUNCTION Penta::CreatePVectorDiagnosticHODrivingStress{{{*/ -ElementVector* Penta::CreatePVectorDiagnosticHODrivingStress(void){ +/*FUNCTION Penta::CreatePVectorStressbalanceHODrivingStress{{{*/ +ElementVector* Penta::CreatePVectorStressbalanceHODrivingStress(void){ /*Intermediaries*/ @@ -8696,6 +8696,6 @@ } /*}}}*/ -/*FUNCTION Penta::CreatePVectorDiagnosticHOFront{{{*/ -ElementVector* Penta::CreatePVectorDiagnosticHOFront(void){ +/*FUNCTION Penta::CreatePVectorStressbalanceHOFront{{{*/ +ElementVector* Penta::CreatePVectorStressbalanceHOFront(void){ /*Intermediaries */ @@ -8779,6 +8779,6 @@ } /*}}}*/ -/*FUNCTION Penta::CreatePVectorDiagnosticFS {{{*/ -ElementVector* Penta::CreatePVectorDiagnosticFS(void){ +/*FUNCTION Penta::CreatePVectorStressbalanceFS {{{*/ +ElementVector* Penta::CreatePVectorStressbalanceFS(void){ ElementVector* pe1; @@ -8788,7 +8788,7 @@ /*compute all stiffness matrices for this element*/ - pe1=CreatePVectorDiagnosticFSViscous(); - pe2=CreatePVectorDiagnosticFSShelf(); - pe3=CreatePVectorDiagnosticFSFront(); + pe1=CreatePVectorStressbalanceFSViscous(); + pe2=CreatePVectorStressbalanceFSShelf(); + pe3=CreatePVectorStressbalanceFSFront(); pe =new ElementVector(pe1,pe2,pe3); @@ -8800,6 +8800,6 @@ } /*}}}*/ -/*FUNCTION Penta::CreatePVectorDiagnosticFSFront{{{*/ -ElementVector* Penta::CreatePVectorDiagnosticFSFront(void){ +/*FUNCTION Penta::CreatePVectorStressbalanceFSFront{{{*/ +ElementVector* Penta::CreatePVectorStressbalanceFSFront(void){ /*Intermediaries */ @@ -8980,6 +8980,6 @@ } /*}}}*/ -/*FUNCTION Penta::CreatePVectorDiagnosticFSViscous {{{*/ -ElementVector* Penta::CreatePVectorDiagnosticFSViscous(void){ +/*FUNCTION Penta::CreatePVectorStressbalanceFSViscous {{{*/ +ElementVector* Penta::CreatePVectorStressbalanceFSViscous(void){ /*Intermediaries*/ @@ -9047,6 +9047,6 @@ } /*}}}*/ -/*FUNCTION Penta::CreatePVectorDiagnosticFSShelf{{{*/ -ElementVector* Penta::CreatePVectorDiagnosticFSShelf(void){ +/*FUNCTION Penta::CreatePVectorStressbalanceFSShelf{{{*/ +ElementVector* Penta::CreatePVectorStressbalanceFSShelf(void){ /*Intermediaries*/ @@ -9081,5 +9081,5 @@ /*Retrieve all inputs and parameters*/ - this->parameters->FindParam(&shelf_dampening,DiagnosticShelfDampeningEnum); + this->parameters->FindParam(&shelf_dampening,StressbalanceShelfDampeningEnum); rho_water=matpar->GetRhoWater(); gravity=matpar->GetG(); @@ -9132,10 +9132,10 @@ } /*}}}*/ -/*FUNCTION Penta::CreatePVectorDiagnosticVert {{{*/ -ElementVector* Penta::CreatePVectorDiagnosticVert(void){ +/*FUNCTION Penta::CreatePVectorStressbalanceVert {{{*/ +ElementVector* Penta::CreatePVectorStressbalanceVert(void){ /*compute all load vectors for this element*/ - ElementVector* pe1=CreatePVectorDiagnosticVertVolume(); - ElementVector* pe2=CreatePVectorDiagnosticVertBase(); + ElementVector* pe1=CreatePVectorStressbalanceVertVolume(); + ElementVector* pe2=CreatePVectorStressbalanceVertBase(); ElementVector* pe =new ElementVector(pe1,pe2); @@ -9146,6 +9146,6 @@ } /*}}}*/ -/*FUNCTION Penta::CreatePVectorDiagnosticVertVolume {{{*/ -ElementVector* Penta::CreatePVectorDiagnosticVertVolume(void){ +/*FUNCTION Penta::CreatePVectorStressbalanceVertVolume {{{*/ +ElementVector* Penta::CreatePVectorStressbalanceVertVolume(void){ /*Constants*/ @@ -9201,6 +9201,6 @@ } /*}}}*/ -/*FUNCTION Penta::CreatePVectorDiagnosticVertBase {{{*/ -ElementVector* Penta::CreatePVectorDiagnosticVertBase(void){ +/*FUNCTION Penta::CreatePVectorStressbalanceVertBase {{{*/ +ElementVector* Penta::CreatePVectorStressbalanceVertBase(void){ /*Constants*/ @@ -9265,6 +9265,6 @@ } /*}}}*/ -/*FUNCTION Penta::CreateJacobianDiagnosticHoriz{{{*/ -ElementMatrix* Penta::CreateJacobianDiagnosticHoriz(void){ +/*FUNCTION Penta::CreateJacobianStressbalanceHoriz{{{*/ +ElementMatrix* Penta::CreateJacobianStressbalanceHoriz(void){ int approximation; @@ -9273,9 +9273,9 @@ switch(approximation){ case SSAApproximationEnum: - return CreateJacobianDiagnosticSSA2d(); + return CreateJacobianStressbalanceSSA2d(); case HOApproximationEnum: - return CreateJacobianDiagnosticHO(); + return CreateJacobianStressbalanceHO(); case FSApproximationEnum: - return CreateJacobianDiagnosticFS(); + return CreateJacobianStressbalanceFS(); case NoneApproximationEnum: return NULL; @@ -9285,6 +9285,6 @@ } /*}}}*/ -/*FUNCTION Penta::CreateJacobianDiagnosticSSA2d{{{*/ -ElementMatrix* Penta::CreateJacobianDiagnosticSSA2d(void){ +/*FUNCTION Penta::CreateJacobianStressbalanceSSA2d{{{*/ +ElementMatrix* Penta::CreateJacobianStressbalanceSSA2d(void){ /*Figure out if this penta is collapsed. If so, then bailout, except if it is at the @@ -9308,5 +9308,5 @@ /*Call Tria function*/ Tria* tria=(Tria*)SpawnTria(0); //lower face is 0, upper face is 1. - ElementMatrix* Ke=tria->CreateJacobianDiagnosticSSA(); + ElementMatrix* Ke=tria->CreateJacobianStressbalanceSSA(); delete tria->material; delete tria; @@ -9319,6 +9319,6 @@ } /*}}}*/ -/*FUNCTION Penta::CreateJacobianDiagnosticHO{{{*/ -ElementMatrix* Penta::CreateJacobianDiagnosticHO(void){ +/*FUNCTION Penta::CreateJacobianStressbalanceHO{{{*/ +ElementMatrix* Penta::CreateJacobianStressbalanceHO(void){ /*Constants*/ @@ -9338,5 +9338,5 @@ /*Initialize Jacobian with regular HO (first part of the Gateau derivative)*/ - ElementMatrix* Ke=CreateKMatrixDiagnosticHO(); + ElementMatrix* Ke=CreateKMatrixStressbalanceHO(); /*Retrieve all inputs and parameters*/ @@ -9383,6 +9383,6 @@ } /*}}}*/ -/*FUNCTION Penta::CreateJacobianDiagnosticFS{{{*/ -ElementMatrix* Penta::CreateJacobianDiagnosticFS(void){ +/*FUNCTION Penta::CreateJacobianStressbalanceFS{{{*/ +ElementMatrix* Penta::CreateJacobianStressbalanceFS(void){ /*Intermediaries */ @@ -9413,5 +9413,5 @@ /*Initialize Jacobian with regular FS (first part of the Gateau derivative)*/ - ElementMatrix* Ke=CreateKMatrixDiagnosticFS(); + ElementMatrix* Ke=CreateKMatrixStressbalanceFS(); IssmDouble* dbasis = xNew(3*vnumnodes); @@ -9476,6 +9476,6 @@ } /*}}}*/ -/*FUNCTION Penta::GetSolutionFromInputsDiagnosticHoriz{{{*/ -void Penta::GetSolutionFromInputsDiagnosticHoriz(Vector* solution){ +/*FUNCTION Penta::GetSolutionFromInputsStressbalanceHoriz{{{*/ +void Penta::GetSolutionFromInputsStressbalanceHoriz(Vector* solution){ int approximation; @@ -9517,6 +9517,6 @@ } /*}}}*/ -/*FUNCTION Penta::GetSolutionFromInputsDiagnosticSIA{{{*/ -void Penta::GetSolutionFromInputsDiagnosticSIA(Vector* solution){ +/*FUNCTION Penta::GetSolutionFromInputsStressbalanceSIA{{{*/ +void Penta::GetSolutionFromInputsStressbalanceSIA(Vector* solution){ const int numdof=NDOF2*NUMVERTICES; @@ -9553,6 +9553,6 @@ } /*}}}*/ -/*FUNCTION Penta::GetSolutionFromInputsDiagnosticVert{{{*/ -void Penta::GetSolutionFromInputsDiagnosticVert(Vector* solution){ +/*FUNCTION Penta::GetSolutionFromInputsStressbalanceVert{{{*/ +void Penta::GetSolutionFromInputsStressbalanceVert(Vector* solution){ const int numdof=NDOF1*NUMVERTICES; @@ -9586,6 +9586,6 @@ } /*}}}*/ -/*FUNCTION Penta::GetSolutionFromInputsDiagnosticFS{{{*/ -void Penta::GetSolutionFromInputsDiagnosticFS(Vector* solution){ +/*FUNCTION Penta::GetSolutionFromInputsStressbalanceFS{{{*/ +void Penta::GetSolutionFromInputsStressbalanceFS(Vector* solution){ int* vdoflist=NULL; @@ -9613,5 +9613,5 @@ Input* p_input =inputs->GetInput(PressureEnum); _assert_(p_input); - this->parameters->FindParam(&FSreconditioning,DiagnosticFSreconditioningEnum); + this->parameters->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum); /*Ok, we have vx vy vz in values, fill in vx vy vz arrays: */ @@ -9714,6 +9714,6 @@ } /*}}}*/ -/*FUNCTION Penta::InputUpdateFromSolutionDiagnosticHoriz {{{*/ -void Penta::InputUpdateFromSolutionDiagnosticHoriz(IssmDouble* solution){ +/*FUNCTION Penta::InputUpdateFromSolutionStressbalanceHoriz {{{*/ +void Penta::InputUpdateFromSolutionStressbalanceHoriz(IssmDouble* solution){ int approximation; @@ -9729,5 +9729,5 @@ } else{ - InputUpdateFromSolutionDiagnosticSSA(solution); + InputUpdateFromSolutionStressbalanceSSA(solution); return; } @@ -9735,26 +9735,26 @@ if (approximation==L1L2ApproximationEnum){ if (!IsOnBed()) return; - InputUpdateFromSolutionDiagnosticL1L2(solution); + InputUpdateFromSolutionStressbalanceL1L2(solution); return; } else if (approximation==HOApproximationEnum){ - InputUpdateFromSolutionDiagnosticHO(solution); + InputUpdateFromSolutionStressbalanceHO(solution); } else if (approximation==HOFSApproximationEnum){ - InputUpdateFromSolutionDiagnosticHOFS(solution); + InputUpdateFromSolutionStressbalanceHOFS(solution); } else if (approximation==SSAFSApproximationEnum){ - InputUpdateFromSolutionDiagnosticSSAFS(solution); + InputUpdateFromSolutionStressbalanceSSAFS(solution); } else if (approximation==FSApproximationEnum || approximation==NoneApproximationEnum){ - InputUpdateFromSolutionDiagnosticFS(solution); + InputUpdateFromSolutionStressbalanceFS(solution); } else if (approximation==SSAHOApproximationEnum){ - InputUpdateFromSolutionDiagnosticSSAHO(solution); - } -} -/*}}}*/ -/*FUNCTION Penta::InputUpdateFromSolutionDiagnosticSSA {{{*/ -void Penta::InputUpdateFromSolutionDiagnosticSSA(IssmDouble* solution){ + InputUpdateFromSolutionStressbalanceSSAHO(solution); + } +} +/*}}}*/ +/*FUNCTION Penta::InputUpdateFromSolutionStressbalanceSSA {{{*/ +void Penta::InputUpdateFromSolutionStressbalanceSSA(IssmDouble* solution){ int numnodes = this->NumberofNodes(); @@ -9837,6 +9837,6 @@ } /*}}}*/ -/*FUNCTION Penta::InputUpdateFromSolutionDiagnosticSSAHO {{{*/ -void Penta::InputUpdateFromSolutionDiagnosticSSAHO(IssmDouble* solution){ +/*FUNCTION Penta::InputUpdateFromSolutionStressbalanceSSAHO {{{*/ +void Penta::InputUpdateFromSolutionStressbalanceSSAHO(IssmDouble* solution){ const int numdof=NDOF2*NUMVERTICES; @@ -9921,6 +9921,6 @@ } /*}}}*/ -/*FUNCTION Penta::InputUpdateFromSolutionDiagnosticSSAFS {{{*/ -void Penta::InputUpdateFromSolutionDiagnosticSSAFS(IssmDouble* solution){ +/*FUNCTION Penta::InputUpdateFromSolutionStressbalanceSSAFS {{{*/ +void Penta::InputUpdateFromSolutionStressbalanceSSAFS(IssmDouble* solution){ const int numdofm=NDOF2*NUMVERTICES; @@ -9955,5 +9955,5 @@ GetDofList(&doflists,FSvelocityEnum,GsetEnum); GetDofListPressure(&doflistpressure,GsetEnum); - this->parameters->FindParam(&FSreconditioning,DiagnosticFSreconditioningEnum); + this->parameters->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum); /*Get node data: */ @@ -10024,6 +10024,6 @@ } /*}}}*/ -/*FUNCTION Penta::InputUpdateFromSolutionDiagnosticL1L2 {{{*/ -void Penta::InputUpdateFromSolutionDiagnosticL1L2(IssmDouble* solution){ +/*FUNCTION Penta::InputUpdateFromSolutionStressbalanceL1L2 {{{*/ +void Penta::InputUpdateFromSolutionStressbalanceL1L2(IssmDouble* solution){ const int numdof=NDOF2*NUMVERTICES; @@ -10105,6 +10105,6 @@ } /*}}}*/ -/*FUNCTION Penta::InputUpdateFromSolutionDiagnosticHO {{{*/ -void Penta::InputUpdateFromSolutionDiagnosticHO(IssmDouble* solution){ +/*FUNCTION Penta::InputUpdateFromSolutionStressbalanceHO {{{*/ +void Penta::InputUpdateFromSolutionStressbalanceHO(IssmDouble* solution){ int i; @@ -10178,6 +10178,6 @@ } /*}}}*/ -/*FUNCTION Penta::InputUpdateFromSolutionDiagnosticHOFS {{{*/ -void Penta::InputUpdateFromSolutionDiagnosticHOFS(IssmDouble* solution){ +/*FUNCTION Penta::InputUpdateFromSolutionStressbalanceHOFS {{{*/ +void Penta::InputUpdateFromSolutionStressbalanceHOFS(IssmDouble* solution){ const int numdofp=NDOF2*NUMVERTICES; @@ -10211,5 +10211,5 @@ GetDofList(&doflists,FSvelocityEnum,GsetEnum); GetDofListPressure(&doflistpressure,GsetEnum); - this->parameters->FindParam(&FSreconditioning,DiagnosticFSreconditioningEnum); + this->parameters->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum); /*Get node data: */ @@ -10278,6 +10278,6 @@ } /*}}}*/ -/*FUNCTION Penta::InputUpdateFromSolutionDiagnosticSIA {{{*/ -void Penta::InputUpdateFromSolutionDiagnosticSIA(IssmDouble* solution){ +/*FUNCTION Penta::InputUpdateFromSolutionStressbalanceSIA {{{*/ +void Penta::InputUpdateFromSolutionStressbalanceSIA(IssmDouble* solution){ int numnodes = this->NumberofNodes(); @@ -10342,6 +10342,6 @@ } /*}}}*/ -/*FUNCTION Penta::InputUpdateFromSolutionDiagnosticVert {{{*/ -void Penta::InputUpdateFromSolutionDiagnosticVert(IssmDouble* solution){ +/*FUNCTION Penta::InputUpdateFromSolutionStressbalanceVert {{{*/ +void Penta::InputUpdateFromSolutionStressbalanceVert(IssmDouble* solution){ int numnodes = this->NumberofNodes(); @@ -10446,6 +10446,6 @@ } /*}}}*/ -/*FUNCTION Penta::InputUpdateFromSolutionDiagnosticFS {{{*/ -void Penta::InputUpdateFromSolutionDiagnosticFS(IssmDouble* solution){ +/*FUNCTION Penta::InputUpdateFromSolutionStressbalanceFS {{{*/ +void Penta::InputUpdateFromSolutionStressbalanceFS(IssmDouble* solution){ int i; @@ -10496,5 +10496,5 @@ /*Recondition pressure and compute vel: */ - this->parameters->FindParam(&FSreconditioning,DiagnosticFSreconditioningEnum); + this->parameters->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum); for(i=0;i* solutiong); - void GetSolutionFromInputsDiagnosticSIA(Vector* solutiong); - void GetSolutionFromInputsDiagnosticFS(Vector* solutiong); - void GetSolutionFromInputsDiagnosticVert(Vector* solutiong); + ElementMatrix* CreateKMatrixStressbalanceFSFriction(void); + ElementMatrix* CreateKMatrixStressbalanceVert(void); + ElementMatrix* CreateKMatrixStressbalanceVertVolume(void); + ElementMatrix* CreateKMatrixStressbalanceVertSurface(void); + ElementMatrix* CreateJacobianStressbalanceHoriz(void); + ElementMatrix* CreateJacobianStressbalanceSSA2d(void); + ElementMatrix* CreateJacobianStressbalanceHO(void); + ElementMatrix* CreateJacobianStressbalanceFS(void); + void InputUpdateFromSolutionStressbalanceHoriz( IssmDouble* solutiong); + void InputUpdateFromSolutionStressbalanceSSA( IssmDouble* solutiong); + void InputUpdateFromSolutionStressbalanceSSAHO( IssmDouble* solutiong); + void InputUpdateFromSolutionStressbalanceSSAFS( IssmDouble* solutiong); + void InputUpdateFromSolutionStressbalanceL1L2( IssmDouble* solutiong); + void InputUpdateFromSolutionStressbalanceHO( IssmDouble* solutiong); + void InputUpdateFromSolutionStressbalanceHOFS( IssmDouble* solutiong); + void InputUpdateFromSolutionStressbalanceSIA( IssmDouble* solutiong); + void InputUpdateFromSolutionStressbalanceVert( IssmDouble* solutiong); + void InputUpdateFromSolutionStressbalanceFS( IssmDouble* solutiong); + void GetSolutionFromInputsStressbalanceHoriz(Vector* solutiong); + void GetSolutionFromInputsStressbalanceSIA(Vector* solutiong); + void GetSolutionFromInputsStressbalanceFS(Vector* solutiong); + void GetSolutionFromInputsStressbalanceVert(Vector* solutiong); ElementVector* CreatePVectorCouplingSSAFS(void); ElementVector* CreatePVectorCouplingSSAFSViscous(void); @@ -285,22 +285,22 @@ ElementVector* CreatePVectorCouplingHOFSViscous(void); ElementVector* CreatePVectorCouplingHOFSFriction(void); - ElementVector* CreatePVectorDiagnosticHoriz(void); - ElementVector* CreatePVectorDiagnosticSIA(void); - ElementVector* CreatePVectorDiagnosticSSA(void); - ElementVector* CreatePVectorDiagnosticSSAHO(void); - ElementVector* CreatePVectorDiagnosticSSAFS(void); - ElementVector* CreatePVectorDiagnosticL1L2(void); - ElementVector* CreatePVectorDiagnosticHO(void); - ElementVector* CreatePVectorDiagnosticHODrivingStress(void); - ElementVector* CreatePVectorDiagnosticHOFront(void); - ElementVector* CreatePVectorDiagnosticHOFS(void); - ElementVector* CreatePVectorDiagnosticFS(void); - ElementVector* CreatePVectorDiagnosticFSFront(void); - ElementVector* CreatePVectorDiagnosticFSViscous(void); + ElementVector* CreatePVectorStressbalanceHoriz(void); + ElementVector* CreatePVectorStressbalanceSIA(void); + ElementVector* CreatePVectorStressbalanceSSA(void); + ElementVector* CreatePVectorStressbalanceSSAHO(void); + ElementVector* CreatePVectorStressbalanceSSAFS(void); + ElementVector* CreatePVectorStressbalanceL1L2(void); + ElementVector* CreatePVectorStressbalanceHO(void); + ElementVector* CreatePVectorStressbalanceHODrivingStress(void); + ElementVector* CreatePVectorStressbalanceHOFront(void); + ElementVector* CreatePVectorStressbalanceHOFS(void); + ElementVector* CreatePVectorStressbalanceFS(void); + ElementVector* CreatePVectorStressbalanceFSFront(void); + ElementVector* CreatePVectorStressbalanceFSViscous(void); void PVectorGLSstabilization(ElementVector* pe); - ElementVector* CreatePVectorDiagnosticFSShelf(void); - ElementVector* CreatePVectorDiagnosticVert(void); - ElementVector* CreatePVectorDiagnosticVertVolume(void); - ElementVector* CreatePVectorDiagnosticVertBase(void); + ElementVector* CreatePVectorStressbalanceFSShelf(void); + ElementVector* CreatePVectorStressbalanceVert(void); + ElementVector* CreatePVectorStressbalanceVertVolume(void); + ElementVector* CreatePVectorStressbalanceVertBase(void); void GetL1L2Viscosity(IssmDouble*, IssmDouble*, GaussPenta*, Input*, Input*, Input*); #endif Index: /issm/trunk-jpl/src/c/classes/Elements/Tria.cpp =================================================================== --- /issm/trunk-jpl/src/c/classes/Elements/Tria.cpp (revision 15770) +++ /issm/trunk-jpl/src/c/classes/Elements/Tria.cpp (revision 15771) @@ -215,10 +215,10 @@ /*Just branch to the correct element stiffness matrix generator, according to the type of analysis we are carrying out: */ switch(analysis_type){ - #ifdef _HAVE_DIAGNOSTIC_ - case DiagnosticHorizAnalysisEnum: - return CreateKMatrixDiagnosticSSA(); + #ifdef _HAVE_STRESSBALANCE_ + case StressbalanceAnalysisEnum: + return CreateKMatrixStressbalanceSSA(); break; - case DiagnosticSIAAnalysisEnum: - return CreateKMatrixDiagnosticSIA(); + case StressbalanceSIAAnalysisEnum: + return CreateKMatrixStressbalanceSIA(); break; #endif @@ -357,10 +357,10 @@ /*Just branch to the correct load generator, according to the type of analysis we are carrying out: */ switch(analysis_type){ -#ifdef _HAVE_DIAGNOSTIC_ - case DiagnosticHorizAnalysisEnum: - return CreatePVectorDiagnosticSSA(); +#ifdef _HAVE_STRESSBALANCE_ + case StressbalanceAnalysisEnum: + return CreatePVectorStressbalanceSSA(); break; - case DiagnosticSIAAnalysisEnum: - return CreatePVectorDiagnosticSIA(); + case StressbalanceSIAAnalysisEnum: + return CreatePVectorStressbalanceSIA(); break; #endif @@ -472,7 +472,7 @@ /*Just branch to the correct element stiffness matrix generator, according to the type of analysis we are carrying out: */ switch(analysis_type){ -#ifdef _HAVE_DIAGNOSTIC_ - case DiagnosticHorizAnalysisEnum: - Ke=CreateJacobianDiagnosticSSA(); +#ifdef _HAVE_STRESSBALANCE_ + case StressbalanceAnalysisEnum: + Ke=CreateJacobianStressbalanceSSA(); break; #endif @@ -1248,10 +1248,10 @@ /*Just branch to the correct InputUpdateFromSolution generator, according to the type of analysis we are carrying out: */ switch(analysis_type){ - #ifdef _HAVE_DIAGNOSTIC_ - case DiagnosticHorizAnalysisEnum: - GetSolutionFromInputsDiagnosticHoriz(solution); + #ifdef _HAVE_STRESSBALANCE_ + case StressbalanceAnalysisEnum: + GetSolutionFromInputsStressbalanceHoriz(solution); break; - case DiagnosticSIAAnalysisEnum: - GetSolutionFromInputsDiagnosticSIA(solution); + case StressbalanceSIAAnalysisEnum: + GetSolutionFromInputsStressbalanceSIA(solution); break; #endif @@ -1569,10 +1569,10 @@ /*Just branch to the correct InputUpdateFromSolution generator, according to the type of analysis we are carrying out: */ switch(analysis_type){ - #ifdef _HAVE_DIAGNOSTIC_ - case DiagnosticHorizAnalysisEnum: - InputUpdateFromSolutionDiagnosticHoriz(solution); + #ifdef _HAVE_STRESSBALANCE_ + case StressbalanceAnalysisEnum: + InputUpdateFromSolutionStressbalanceHoriz(solution); break; - case DiagnosticSIAAnalysisEnum: - InputUpdateFromSolutionDiagnosticHoriz(solution); + case StressbalanceSIAAnalysisEnum: + InputUpdateFromSolutionStressbalanceHoriz(solution); break; #endif @@ -2463,5 +2463,5 @@ switch(analysis_type){ - case DiagnosticHorizAnalysisEnum: + case StressbalanceAnalysisEnum: /*default vx,vy and vz: either observation or 0 */ @@ -2944,11 +2944,11 @@ #endif -#ifdef _HAVE_DIAGNOSTIC_ -/*FUNCTION Tria::CreateKMatrixDiagnosticSSA {{{*/ -ElementMatrix* Tria::CreateKMatrixDiagnosticSSA(void){ +#ifdef _HAVE_STRESSBALANCE_ +/*FUNCTION Tria::CreateKMatrixStressbalanceSSA {{{*/ +ElementMatrix* Tria::CreateKMatrixStressbalanceSSA(void){ /*compute all stiffness matrices for this element*/ - ElementMatrix* Ke1=CreateKMatrixDiagnosticSSAViscous(); - ElementMatrix* Ke2=CreateKMatrixDiagnosticSSAFriction(); + ElementMatrix* Ke1=CreateKMatrixStressbalanceSSAViscous(); + ElementMatrix* Ke2=CreateKMatrixStressbalanceSSAFriction(); ElementMatrix* Ke =new ElementMatrix(Ke1,Ke2); @@ -2959,6 +2959,6 @@ } /*}}}*/ -/*FUNCTION Tria::CreateKMatrixDiagnosticSSAViscous{{{*/ -ElementMatrix* Tria::CreateKMatrixDiagnosticSSAViscous(void){ +/*FUNCTION Tria::CreateKMatrixStressbalanceSSAViscous{{{*/ +ElementMatrix* Tria::CreateKMatrixStressbalanceSSAViscous(void){ /*Intermediaries*/ @@ -2987,5 +2987,5 @@ Input* vxold_input=inputs->GetInput(VxPicardEnum); _assert_(vxold_input); Input* vyold_input=inputs->GetInput(VyPicardEnum); _assert_(vyold_input); - this->parameters->FindParam(&viscosity_overshoot,DiagnosticViscosityOvershootEnum); + this->parameters->FindParam(&viscosity_overshoot,StressbalanceViscosityOvershootEnum); /* Start looping on the number of gaussian points: */ @@ -3026,6 +3026,6 @@ } /*}}}*/ -/*FUNCTION Tria::CreateKMatrixDiagnosticSSAFriction {{{*/ -ElementMatrix* Tria::CreateKMatrixDiagnosticSSAFriction(void){ +/*FUNCTION Tria::CreateKMatrixStressbalanceSSAFriction {{{*/ +ElementMatrix* Tria::CreateKMatrixStressbalanceSSAFriction(void){ /*Intermediaries*/ @@ -3114,6 +3114,6 @@ } /*}}}*/ -/*FUNCTION Tria::CreateKMatrixDiagnosticSIA{{{*/ -ElementMatrix* Tria::CreateKMatrixDiagnosticSIA(void){ +/*FUNCTION Tria::CreateKMatrixStressbalanceSIA{{{*/ +ElementMatrix* Tria::CreateKMatrixStressbalanceSIA(void){ /*Intermediaries*/ @@ -3138,10 +3138,10 @@ } /*}}}*/ -/*FUNCTION Tria::CreatePVectorDiagnosticSSA {{{*/ -ElementVector* Tria::CreatePVectorDiagnosticSSA(){ +/*FUNCTION Tria::CreatePVectorStressbalanceSSA {{{*/ +ElementVector* Tria::CreatePVectorStressbalanceSSA(){ /*compute all load vectors for this element*/ - ElementVector* pe1=CreatePVectorDiagnosticSSADrivingStress(); - ElementVector* pe2=CreatePVectorDiagnosticSSAFront(); + ElementVector* pe1=CreatePVectorStressbalanceSSADrivingStress(); + ElementVector* pe2=CreatePVectorStressbalanceSSAFront(); ElementVector* pe =new ElementVector(pe1,pe2); @@ -3152,6 +3152,6 @@ } /*}}}*/ -/*FUNCTION Tria::CreatePVectorDiagnosticSSADrivingStress {{{*/ -ElementVector* Tria::CreatePVectorDiagnosticSSADrivingStress(){ +/*FUNCTION Tria::CreatePVectorStressbalanceSSADrivingStress {{{*/ +ElementVector* Tria::CreatePVectorStressbalanceSSADrivingStress(){ /*Intermediaries */ @@ -3207,6 +3207,6 @@ } /*}}}*/ -/*FUNCTION Tria::CreatePVectorDiagnosticSSAFront {{{*/ -ElementVector* Tria::CreatePVectorDiagnosticSSAFront(){ +/*FUNCTION Tria::CreatePVectorStressbalanceSSAFront {{{*/ +ElementVector* Tria::CreatePVectorStressbalanceSSAFront(){ /*Intermediaries */ @@ -3287,6 +3287,6 @@ } /*}}}*/ -/*FUNCTION Tria::CreatePVectorDiagnosticSIA{{{*/ -ElementVector* Tria::CreatePVectorDiagnosticSIA(void){ +/*FUNCTION Tria::CreatePVectorStressbalanceSIA{{{*/ +ElementVector* Tria::CreatePVectorStressbalanceSIA(void){ /*Intermediaries */ @@ -3339,6 +3339,6 @@ } /*}}}*/ -/*FUNCTION Tria::CreateJacobianDiagnosticSSA{{{*/ -ElementMatrix* Tria::CreateJacobianDiagnosticSSA(void){ +/*FUNCTION Tria::CreateJacobianStressbalanceSSA{{{*/ +ElementMatrix* Tria::CreateJacobianStressbalanceSSA(void){ /*Intermediaries */ @@ -3358,5 +3358,5 @@ /*Initialize Element matrix, vectors and Gaussian points*/ - ElementMatrix* Ke=CreateKMatrixDiagnosticSSA(); //Initialize Jacobian with regular SSA (first part of the Gateau derivative) + ElementMatrix* Ke=CreateKMatrixStressbalanceSSA(); //Initialize Jacobian with regular SSA (first part of the Gateau derivative) IssmDouble* dbasis = xNew(2*numnodes); @@ -3406,6 +3406,6 @@ } /*}}}*/ -/*FUNCTION Tria::GetSolutionFromInputsDiagnosticHoriz{{{*/ -void Tria::GetSolutionFromInputsDiagnosticHoriz(Vector* solution){ +/*FUNCTION Tria::GetSolutionFromInputsStressbalanceHoriz{{{*/ +void Tria::GetSolutionFromInputsStressbalanceHoriz(Vector* solution){ IssmDouble vx,vy; @@ -3445,6 +3445,6 @@ } /*}}}*/ -/*FUNCTION Tria::GetSolutionFromInputsDiagnosticSIA{{{*/ -void Tria::GetSolutionFromInputsDiagnosticSIA(Vector* solution){ +/*FUNCTION Tria::GetSolutionFromInputsStressbalanceSIA{{{*/ +void Tria::GetSolutionFromInputsStressbalanceSIA(Vector* solution){ const int numdof=NDOF2*NUMVERTICES; @@ -3484,6 +3484,6 @@ } /*}}}*/ -/*FUNCTION Tria::InputUpdateFromSolutionDiagnosticHoriz {{{*/ -void Tria::InputUpdateFromSolutionDiagnosticHoriz(IssmDouble* solution){ +/*FUNCTION Tria::InputUpdateFromSolutionStressbalanceHoriz {{{*/ +void Tria::InputUpdateFromSolutionStressbalanceHoriz(IssmDouble* solution){ int i; @@ -3556,6 +3556,6 @@ } /*}}}*/ -/*FUNCTION Tria::InputUpdateFromSolutionDiagnosticSIA {{{*/ -void Tria::InputUpdateFromSolutionDiagnosticSIA(IssmDouble* solution){ +/*FUNCTION Tria::InputUpdateFromSolutionStressbalanceSIA {{{*/ +void Tria::InputUpdateFromSolutionStressbalanceSIA(IssmDouble* solution){ int i; @@ -5284,5 +5284,5 @@ /*Initialize Jacobian with regular SSA (first part of the Gateau derivative)*/ parameters->FindParam(&incomplete_adjoint,InversionIncompleteAdjointEnum); - ElementMatrix* Ke=CreateKMatrixDiagnosticSSA(); + ElementMatrix* Ke=CreateKMatrixStressbalanceSSA(); if(incomplete_adjoint) return Ke; Index: /issm/trunk-jpl/src/c/classes/Elements/Tria.h =================================================================== --- /issm/trunk-jpl/src/c/classes/Elements/Tria.h (revision 15770) +++ /issm/trunk-jpl/src/c/classes/Elements/Tria.h (revision 15771) @@ -222,18 +222,18 @@ void UpdateConstraints(void); - #ifdef _HAVE_DIAGNOSTIC_ - ElementMatrix* CreateKMatrixDiagnosticSSA(void); - ElementMatrix* CreateKMatrixDiagnosticSSAViscous(void); - ElementMatrix* CreateKMatrixDiagnosticSSAFriction(void); - ElementMatrix* CreateKMatrixDiagnosticSIA(void); - ElementVector* CreatePVectorDiagnosticSSA(void); - ElementVector* CreatePVectorDiagnosticSSADrivingStress(void); - ElementVector* CreatePVectorDiagnosticSSAFront(void); - ElementVector* CreatePVectorDiagnosticSIA(void); - ElementMatrix* CreateJacobianDiagnosticSSA(void); - void GetSolutionFromInputsDiagnosticHoriz(Vector* solution); - void GetSolutionFromInputsDiagnosticSIA(Vector* solution); - void InputUpdateFromSolutionDiagnosticHoriz( IssmDouble* solution); - void InputUpdateFromSolutionDiagnosticSIA( IssmDouble* solution); + #ifdef _HAVE_STRESSBALANCE_ + ElementMatrix* CreateKMatrixStressbalanceSSA(void); + ElementMatrix* CreateKMatrixStressbalanceSSAViscous(void); + ElementMatrix* CreateKMatrixStressbalanceSSAFriction(void); + ElementMatrix* CreateKMatrixStressbalanceSIA(void); + ElementVector* CreatePVectorStressbalanceSSA(void); + ElementVector* CreatePVectorStressbalanceSSADrivingStress(void); + ElementVector* CreatePVectorStressbalanceSSAFront(void); + ElementVector* CreatePVectorStressbalanceSIA(void); + ElementMatrix* CreateJacobianStressbalanceSSA(void); + void GetSolutionFromInputsStressbalanceHoriz(Vector* solution); + void GetSolutionFromInputsStressbalanceSIA(Vector* solution); + void InputUpdateFromSolutionStressbalanceHoriz( IssmDouble* solution); + void InputUpdateFromSolutionStressbalanceSIA( IssmDouble* solution); #endif Index: /issm/trunk-jpl/src/c/classes/Loads/Pengrid.cpp =================================================================== --- /issm/trunk-jpl/src/c/classes/Loads/Pengrid.cpp (revision 15770) +++ /issm/trunk-jpl/src/c/classes/Loads/Pengrid.cpp (revision 15771) @@ -261,5 +261,5 @@ pe=PenaltyCreatePVectorMelting(kmax); break; - case DiagnosticHorizAnalysisEnum: case AdjointHorizAnalysisEnum: + case StressbalanceAnalysisEnum: case AdjointHorizAnalysisEnum: break; #endif @@ -418,5 +418,5 @@ this->parameters->FindParam(&analysis_type,AnalysisTypeEnum); - if (analysis_type==DiagnosticHorizAnalysisEnum){ + if (analysis_type==StressbalanceAnalysisEnum){ /*No penalty to check*/ return; Index: /issm/trunk-jpl/src/c/classes/Loads/Penpair.cpp =================================================================== --- /issm/trunk-jpl/src/c/classes/Loads/Penpair.cpp (revision 15770) +++ /issm/trunk-jpl/src/c/classes/Loads/Penpair.cpp (revision 15771) @@ -173,6 +173,6 @@ switch(analysis_type){ - case DiagnosticHorizAnalysisEnum: - Ke=PenaltyCreateKMatrixDiagnosticHoriz(kmax); + case StressbalanceAnalysisEnum: + Ke=PenaltyCreateKMatrixStressbalanceHoriz(kmax); break; case MasstransportAnalysisEnum: @@ -292,6 +292,6 @@ /*Penpair management:*/ -/*FUNCTION Penpair::PenaltyCreateKMatrixDiagnosticHoriz{{{*/ -ElementMatrix* Penpair::PenaltyCreateKMatrixDiagnosticHoriz(IssmDouble kmax){ +/*FUNCTION Penpair::PenaltyCreateKMatrixStressbalanceHoriz{{{*/ +ElementMatrix* Penpair::PenaltyCreateKMatrixStressbalanceHoriz(IssmDouble kmax){ int approximation0=nodes[0]->GetApproximation(); @@ -301,24 +301,24 @@ case SSAApproximationEnum: switch(approximation1){ - case SSAApproximationEnum: return PenaltyCreateKMatrixDiagnosticSSAHO(kmax); - case HOApproximationEnum: return PenaltyCreateKMatrixDiagnosticSSAHO(kmax); + case SSAApproximationEnum: return PenaltyCreateKMatrixStressbalanceSSAHO(kmax); + case HOApproximationEnum: return PenaltyCreateKMatrixStressbalanceSSAHO(kmax); default: _error_("not supported yet"); } case HOApproximationEnum: switch(approximation1){ - case SSAApproximationEnum: return PenaltyCreateKMatrixDiagnosticSSAHO(kmax); - case HOApproximationEnum: return PenaltyCreateKMatrixDiagnosticSSAHO(kmax); + case SSAApproximationEnum: return PenaltyCreateKMatrixStressbalanceSSAHO(kmax); + case HOApproximationEnum: return PenaltyCreateKMatrixStressbalanceSSAHO(kmax); default: _error_("not supported yet"); } case FSApproximationEnum: switch(approximation1){ - case FSApproximationEnum: return PenaltyCreateKMatrixDiagnosticFS(kmax); - case NoneApproximationEnum: return PenaltyCreateKMatrixDiagnosticFS(kmax); + case FSApproximationEnum: return PenaltyCreateKMatrixStressbalanceFS(kmax); + case NoneApproximationEnum: return PenaltyCreateKMatrixStressbalanceFS(kmax); default: _error_("not supported yet"); } case NoneApproximationEnum: switch(approximation1){ - case FSApproximationEnum: return PenaltyCreateKMatrixDiagnosticFS(kmax); - case NoneApproximationEnum: return PenaltyCreateKMatrixDiagnosticFS(kmax); + case FSApproximationEnum: return PenaltyCreateKMatrixStressbalanceFS(kmax); + case NoneApproximationEnum: return PenaltyCreateKMatrixStressbalanceFS(kmax); default: _error_("not supported yet"); } @@ -327,6 +327,6 @@ } /*}}}*/ -/*FUNCTION Penpair::PenaltyCreateKMatrixDiagnosticSSAHO {{{*/ -ElementMatrix* Penpair::PenaltyCreateKMatrixDiagnosticSSAHO(IssmDouble kmax){ +/*FUNCTION Penpair::PenaltyCreateKMatrixStressbalanceSSAHO {{{*/ +ElementMatrix* Penpair::PenaltyCreateKMatrixStressbalanceSSAHO(IssmDouble kmax){ const int numdof=NUMVERTICES*NDOF2; @@ -337,5 +337,5 @@ /*recover parameters: */ - parameters->FindParam(&penalty_offset,DiagnosticPenaltyFactorEnum); + parameters->FindParam(&penalty_offset,StressbalancePenaltyFactorEnum); //Create elementary matrix: add penalty to @@ -354,6 +354,6 @@ } /*}}}*/ -/*FUNCTION Penpair::PenaltyCreateKMatrixDiagnosticFS {{{*/ -ElementMatrix* Penpair::PenaltyCreateKMatrixDiagnosticFS(IssmDouble kmax){ +/*FUNCTION Penpair::PenaltyCreateKMatrixStressbalanceFS {{{*/ +ElementMatrix* Penpair::PenaltyCreateKMatrixStressbalanceFS(IssmDouble kmax){ const int numdof=NUMVERTICES*NDOF4; @@ -364,5 +364,5 @@ /*recover parameters: */ - parameters->FindParam(&penalty_offset,DiagnosticPenaltyFactorEnum); + parameters->FindParam(&penalty_offset,StressbalancePenaltyFactorEnum); //Create elementary matrix: add penalty to Index: /issm/trunk-jpl/src/c/classes/Loads/Penpair.h =================================================================== --- /issm/trunk-jpl/src/c/classes/Loads/Penpair.h (revision 15770) +++ /issm/trunk-jpl/src/c/classes/Loads/Penpair.h (revision 15771) @@ -67,7 +67,7 @@ /*}}}*/ /*Penpair management: {{{*/ - ElementMatrix* PenaltyCreateKMatrixDiagnosticHoriz(IssmDouble kmax); - ElementMatrix* PenaltyCreateKMatrixDiagnosticSSAHO(IssmDouble kmax); - ElementMatrix* PenaltyCreateKMatrixDiagnosticFS(IssmDouble kmax); + ElementMatrix* PenaltyCreateKMatrixStressbalanceHoriz(IssmDouble kmax); + ElementMatrix* PenaltyCreateKMatrixStressbalanceSSAHO(IssmDouble kmax); + ElementMatrix* PenaltyCreateKMatrixStressbalanceFS(IssmDouble kmax); ElementMatrix* PenaltyCreateKMatrixMasstransport(IssmDouble kmax); /*}}}*/ Index: /issm/trunk-jpl/src/c/classes/Loads/Riftfront.cpp =================================================================== --- /issm/trunk-jpl/src/c/classes/Loads/Riftfront.cpp (revision 15770) +++ /issm/trunk-jpl/src/c/classes/Loads/Riftfront.cpp (revision 15771) @@ -51,5 +51,5 @@ /*Fetch parameters: */ - iomodel->Constant(&penalty_lock,DiagnosticRiftPenaltyLockEnum); + iomodel->Constant(&penalty_lock,StressbalanceRiftPenaltyLockEnum); /*Ok, retrieve all the data needed to add a penalty between the two nodes: */ @@ -308,9 +308,9 @@ switch(analysis_type){ - case DiagnosticHorizAnalysisEnum: - Ke=PenaltyCreateKMatrixDiagnosticHoriz(kmax); + case StressbalanceAnalysisEnum: + Ke=PenaltyCreateKMatrixStressbalanceHoriz(kmax); break; case AdjointHorizAnalysisEnum: - Ke=PenaltyCreateKMatrixDiagnosticHoriz(kmax); + Ke=PenaltyCreateKMatrixStressbalanceHoriz(kmax); break; default: @@ -334,6 +334,6 @@ switch(analysis_type){ - case DiagnosticHorizAnalysisEnum: - pe=PenaltyCreatePVectorDiagnosticHoriz(kmax); + case StressbalanceAnalysisEnum: + pe=PenaltyCreatePVectorStressbalanceHoriz(kmax); break; case AdjointHorizAnalysisEnum: @@ -437,6 +437,6 @@ /*Riftfront numerics*/ -/*FUNCTION Riftfront::PenaltyCreateKMatrixDiagnosticHoriz {{{*/ -ElementMatrix* Riftfront::PenaltyCreateKMatrixDiagnosticHoriz(IssmDouble kmax){ +/*FUNCTION Riftfront::PenaltyCreateKMatrixStressbalanceHoriz {{{*/ +ElementMatrix* Riftfront::PenaltyCreateKMatrixStressbalanceHoriz(IssmDouble kmax){ const int numdof = NDOF2*NUMVERTICES; @@ -461,5 +461,5 @@ /*Get some parameters: */ - this->parameters->FindParam(&penalty_offset,DiagnosticPenaltyFactorEnum); + this->parameters->FindParam(&penalty_offset,StressbalancePenaltyFactorEnum); this->inputs->GetInputValue(&friction,FrictionEnum); tria1->GetInputValue(&h[0],nodes[0],ThicknessEnum); @@ -518,6 +518,6 @@ } /*}}}*/ -/*FUNCTION Riftfront::PenaltyCreatePVectorDiagnosticHoriz {{{*/ -ElementVector* Riftfront::PenaltyCreatePVectorDiagnosticHoriz(IssmDouble kmax){ +/*FUNCTION Riftfront::PenaltyCreatePVectorStressbalanceHoriz {{{*/ +ElementVector* Riftfront::PenaltyCreatePVectorStressbalanceHoriz(IssmDouble kmax){ const int numdof = NDOF2*NUMVERTICES; Index: /issm/trunk-jpl/src/c/classes/Loads/Riftfront.h =================================================================== --- /issm/trunk-jpl/src/c/classes/Loads/Riftfront.h (revision 15770) +++ /issm/trunk-jpl/src/c/classes/Loads/Riftfront.h (revision 15771) @@ -89,6 +89,6 @@ /*Riftfront specific routines: {{{*/ bool PreStable(); - ElementMatrix* PenaltyCreateKMatrixDiagnosticHoriz(IssmDouble kmax); - ElementVector* PenaltyCreatePVectorDiagnosticHoriz(IssmDouble kmax); + ElementMatrix* PenaltyCreateKMatrixStressbalanceHoriz(IssmDouble kmax); + ElementVector* PenaltyCreatePVectorStressbalanceHoriz(IssmDouble kmax); void SetPreStable(); int PreConstrain(int* punstable); Index: /issm/trunk-jpl/src/c/classes/Node.cpp =================================================================== --- /issm/trunk-jpl/src/c/classes/Node.cpp (revision 15770) +++ /issm/trunk-jpl/src/c/classes/Node.cpp (revision 15771) @@ -42,5 +42,5 @@ gsize=this->indexing.gsize; - if(analysis_type==DiagnosticHorizAnalysisEnum) + if(analysis_type==StressbalanceAnalysisEnum) this->approximation=in_approximation; else @@ -54,11 +54,11 @@ this->inputs->AddInput(new BoolInput(MaskVertexongroundediceEnum,reCast(iomodel->Data(MaskVertexongroundediceEnum)[io_index]))); - /*Diagnostic Horiz*/ - #ifdef _HAVE_DIAGNOSTIC_ - if(analysis_type==DiagnosticHorizAnalysisEnum){ + /*Stressbalance Horiz*/ + #ifdef _HAVE_STRESSBALANCE_ + if(analysis_type==StressbalanceAnalysisEnum){ /*Coordinate system provided, convert to coord_system matrix*/ - _assert_(iomodel->Data(DiagnosticReferentialEnum)); - XZvectorsToCoordinateSystem(&this->coord_system[0][0],&iomodel->Data(DiagnosticReferentialEnum)[io_index*6]); + _assert_(iomodel->Data(StressbalanceReferentialEnum)); + XZvectorsToCoordinateSystem(&this->coord_system[0][0],&iomodel->Data(StressbalanceReferentialEnum)[io_index*6]); if(iomodel->dim==3){ @@ -338,5 +338,5 @@ int Node::Sid(void){ return sid; } /*}}}*/ -#ifdef _HAVE_DIAGNOSTIC_ +#ifdef _HAVE_STRESSBALANCE_ /*FUNCTION Node::GetCoordinateSystem{{{*/ void Node::GetCoordinateSystem(IssmDouble* coord_system_out){ @@ -972,5 +972,5 @@ } /*}}}*/ -#ifdef _HAVE_DIAGNOSTIC_ +#ifdef _HAVE_STRESSBALANCE_ void TransformInvStiffnessMatrixCoord(ElementMatrix* Ke,Node** nodes,int numnodes,int cs_enum){/*{{{*/ Index: /issm/trunk-jpl/src/c/classes/Node.h =================================================================== --- /issm/trunk-jpl/src/c/classes/Node.h (revision 15770) +++ /issm/trunk-jpl/src/c/classes/Node.h (revision 15771) @@ -68,5 +68,5 @@ void SetCurrentConfiguration(DataSet* nodes,Vertices* vertices); int Sid(void); -#ifdef _HAVE_DIAGNOSTIC_ +#ifdef _HAVE_STRESSBALANCE_ void GetCoordinateSystem(IssmDouble* coord_system_out); #endif @@ -103,5 +103,5 @@ int* GetGlobalDofList(Node** nodes,int numnodes,int setenum,int approximation); int GetNumberOfDofs(Node** nodes,int numnodes,int setenum,int approximation); -#ifdef _HAVE_DIAGNOSTIC_ +#ifdef _HAVE_STRESSBALANCE_ void TransformInvStiffnessMatrixCoord(ElementMatrix* Ke,Node** nodes,int numnodes,int cs_enum); void TransformInvStiffnessMatrixCoord(ElementMatrix* Ke,Node** nodes,int numnodes,int* cs_array); Index: /issm/trunk-jpl/src/c/modules/ConstraintsStatex/ConstraintsStatex.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/ConstraintsStatex/ConstraintsStatex.cpp (revision 15770) +++ /issm/trunk-jpl/src/c/modules/ConstraintsStatex/ConstraintsStatex.cpp (revision 15771) @@ -20,5 +20,5 @@ /*recover parameters: */ - parameters->FindParam(&min_mechanical_constraints,DiagnosticRiftPenaltyThresholdEnum); + parameters->FindParam(&min_mechanical_constraints,StressbalanceRiftPenaltyThresholdEnum); parameters->FindParam(&analysis_type,AnalysisTypeEnum); Index: /issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateDataSets.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateDataSets.cpp (revision 15770) +++ /issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateDataSets.cpp (revision 15771) @@ -40,24 +40,24 @@ switch(analysis_type){ - #ifdef _HAVE_DIAGNOSTIC_ - case DiagnosticHorizAnalysisEnum: - CreateNodesDiagnosticHoriz(pnodes, iomodel); - CreateConstraintsDiagnosticHoriz(pconstraints,iomodel); - CreateLoadsDiagnosticHoriz(ploads,iomodel); - UpdateElementsDiagnosticHoriz(elements,iomodel,analysis_counter,analysis_type); + #ifdef _HAVE_STRESSBALANCE_ + case StressbalanceAnalysisEnum: + CreateNodesStressbalance(pnodes,iomodel); + CreateConstraintsStressbalance(pconstraints,iomodel); + CreateLoadsStressbalance(ploads,iomodel); + UpdateElementsStressbalance(elements,iomodel,analysis_counter,analysis_type); break; - case DiagnosticVertAnalysisEnum: - CreateNodesDiagnosticVert(pnodes, iomodel); - CreateConstraintsDiagnosticVert(pconstraints,iomodel); - CreateLoadsDiagnosticVert(ploads,iomodel); - UpdateElementsDiagnosticVert(elements,iomodel,analysis_counter,analysis_type); + case StressbalanceVerticalAnalysisEnum: + CreateNodesStressbalanceVertical(pnodes, iomodel); + CreateConstraintsStressbalanceVertical(pconstraints,iomodel); + CreateLoadsStressbalanceVertical(ploads,iomodel); + UpdateElementsStressbalanceVertical(elements,iomodel,analysis_counter,analysis_type); break; - case DiagnosticSIAAnalysisEnum: - CreateNodesDiagnosticSIA(pnodes, iomodel); - CreateConstraintsDiagnosticSIA(pconstraints,iomodel); - CreateLoadsDiagnosticSIA(ploads,iomodel); - UpdateElementsDiagnosticSIA(elements,iomodel,analysis_counter,analysis_type); + case StressbalanceSIAAnalysisEnum: + CreateNodesStressbalanceSIA(pnodes, iomodel); + CreateConstraintsStressbalanceSIA(pconstraints,iomodel); + CreateLoadsStressbalanceSIA(ploads,iomodel); + UpdateElementsStressbalanceSIA(elements,iomodel,analysis_counter,analysis_type); break; #endif Index: /issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateElementsVerticesAndMaterials.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateElementsVerticesAndMaterials.cpp (revision 15770) +++ /issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateElementsVerticesAndMaterials.cpp (revision 15771) @@ -1,4 +1,4 @@ /* - * CreateElementsNodesAndMaterialsDiagnosticHoriz.c: + * CreateElementsNodesAndMaterialsStressbalanceHoriz.c: */ Index: /issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateParameters.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateParameters.cpp (revision 15770) +++ /issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateParameters.cpp (revision 15771) @@ -52,9 +52,9 @@ parameters->AddObject(iomodel->CopyConstantObject(FlowequationFeFSEnum)); parameters->AddObject(iomodel->CopyConstantObject(SettingsOutputFrequencyEnum)); - parameters->AddObject(iomodel->CopyConstantObject(DiagnosticRestolEnum)); - parameters->AddObject(iomodel->CopyConstantObject(DiagnosticReltolEnum)); - parameters->AddObject(iomodel->CopyConstantObject(DiagnosticAbstolEnum)); - parameters->AddObject(iomodel->CopyConstantObject(DiagnosticIsnewtonEnum)); - parameters->AddObject(iomodel->CopyConstantObject(DiagnosticMaxiterEnum)); + parameters->AddObject(iomodel->CopyConstantObject(StressbalanceRestolEnum)); + parameters->AddObject(iomodel->CopyConstantObject(StressbalanceReltolEnum)); + parameters->AddObject(iomodel->CopyConstantObject(StressbalanceAbstolEnum)); + parameters->AddObject(iomodel->CopyConstantObject(StressbalanceIsnewtonEnum)); + parameters->AddObject(iomodel->CopyConstantObject(StressbalanceMaxiterEnum)); parameters->AddObject(iomodel->CopyConstantObject(SteadystateReltolEnum)); parameters->AddObject(iomodel->CopyConstantObject(SteadystateMaxiterEnum)); @@ -67,5 +67,5 @@ parameters->AddObject(iomodel->CopyConstantObject(MasstransportHydrostaticAdjustmentEnum)); parameters->AddObject(iomodel->CopyConstantObject(MasstransportStabilizationEnum)); - parameters->AddObject(iomodel->CopyConstantObject(DiagnosticPenaltyFactorEnum)); + parameters->AddObject(iomodel->CopyConstantObject(StressbalancePenaltyFactorEnum)); parameters->AddObject(iomodel->CopyConstantObject(MasstransportMinThicknessEnum)); parameters->AddObject(iomodel->CopyConstantObject(MasstransportPenaltyFactorEnum)); @@ -81,8 +81,8 @@ parameters->AddObject(iomodel->CopyConstantObject(ThermalPenaltyThresholdEnum)); parameters->AddObject(iomodel->CopyConstantObject(ThermalPenaltyLockEnum)); - parameters->AddObject(iomodel->CopyConstantObject(DiagnosticRiftPenaltyThresholdEnum)); - parameters->AddObject(iomodel->CopyConstantObject(DiagnosticFSreconditioningEnum)); - parameters->AddObject(iomodel->CopyConstantObject(DiagnosticShelfDampeningEnum)); - parameters->AddObject(iomodel->CopyConstantObject(DiagnosticViscosityOvershootEnum)); + parameters->AddObject(iomodel->CopyConstantObject(StressbalanceRiftPenaltyThresholdEnum)); + parameters->AddObject(iomodel->CopyConstantObject(StressbalanceFSreconditioningEnum)); + parameters->AddObject(iomodel->CopyConstantObject(StressbalanceShelfDampeningEnum)); + parameters->AddObject(iomodel->CopyConstantObject(StressbalanceViscosityOvershootEnum)); parameters->AddObject(iomodel->CopyConstantObject(SettingsWaitonlockEnum)); parameters->AddObject(iomodel->CopyConstantObject(MeshNumberofelementsEnum)); @@ -92,5 +92,5 @@ parameters->AddObject(iomodel->CopyConstantObject(SettingsResultsAsPatchesEnum)); parameters->AddObject(iomodel->CopyConstantObject(GroundinglineMigrationEnum)); - parameters->AddObject(iomodel->CopyConstantObject(TransientIsdiagnosticEnum)); + parameters->AddObject(iomodel->CopyConstantObject(TransientIsstressbalanceEnum)); parameters->AddObject(iomodel->CopyConstantObject(TransientIsmasstransportEnum)); parameters->AddObject(iomodel->CopyConstantObject(TransientIsthermalEnum)); @@ -147,8 +147,8 @@ /*Requested outputs*/ - iomodel->FetchData(&requestedoutputs,&numoutputs,NULL,DiagnosticRequestedOutputsEnum); - parameters->AddObject(new IntParam(DiagnosticNumRequestedOutputsEnum,numoutputs)); - if(numoutputs)parameters->AddObject(new IntVecParam(DiagnosticRequestedOutputsEnum,requestedoutputs,numoutputs)); - iomodel->DeleteData(requestedoutputs,DiagnosticRequestedOutputsEnum); + iomodel->FetchData(&requestedoutputs,&numoutputs,NULL,StressbalanceRequestedOutputsEnum); + parameters->AddObject(new IntParam(StressbalanceNumRequestedOutputsEnum,numoutputs)); + if(numoutputs)parameters->AddObject(new IntVecParam(StressbalanceRequestedOutputsEnum,requestedoutputs,numoutputs)); + iomodel->DeleteData(requestedoutputs,StressbalanceRequestedOutputsEnum); iomodel->FetchData(&requestedoutputs,&numoutputs,NULL,TransientRequestedOutputsEnum); Index: /issm/trunk-jpl/src/c/modules/ModelProcessorx/DistributeNumDofs.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/ModelProcessorx/DistributeNumDofs.cpp (revision 15770) +++ /issm/trunk-jpl/src/c/modules/ModelProcessorx/DistributeNumDofs.cpp (revision 15771) @@ -16,5 +16,5 @@ /*ok, according to analysis type: */ switch(analysis_type){ - case DiagnosticHorizAnalysisEnum: + case StressbalanceAnalysisEnum: switch(node_type){ case SSAApproximationEnum: @@ -66,12 +66,12 @@ break; default: - _error_("Approximationtype " << node_type << " (" << EnumToStringx(node_type) << ") not implemented yet for DiagnosticHoriz"); + _error_("Approximationtype " << node_type << " (" << EnumToStringx(node_type) << ") not implemented yet for StressbalanceHoriz"); } break; - case DiagnosticVertAnalysisEnum: + case StressbalanceVerticalAnalysisEnum: numdofs=1; break; - case DiagnosticSIAAnalysisEnum: + case StressbalanceSIAAnalysisEnum: numdofs=2; break; Index: /issm/trunk-jpl/src/c/modules/ModelProcessorx/ElementsAndVerticesPartitioning.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/ModelProcessorx/ElementsAndVerticesPartitioning.cpp (revision 15770) +++ /issm/trunk-jpl/src/c/modules/ModelProcessorx/ElementsAndVerticesPartitioning.cpp (revision 15771) @@ -110,5 +110,5 @@ * penpair has 2 nodes that are poointing toward 2 vertices. * The 2 vertices must be in the same cpu as the penpair*/ - iomodel->FetchData(&vertex_pairing,&numvertex_pairing,NULL,DiagnosticVertexPairingEnum); + iomodel->FetchData(&vertex_pairing,&numvertex_pairing,NULL,StressbalanceVertexPairingEnum); for(i=0;iConstant(&isenthalpy,ThermalIsenthalpyEnum); iomodel->Constant(&ismasstransport,TransientIsmasstransportEnum); - iomodel->Constant(&isdiagnostic,TransientIsdiagnosticEnum); + iomodel->Constant(&isstressbalance,TransientIsstressbalanceEnum); iomodel->Constant(&isgroundingline,TransientIsgroundinglineEnum); @@ -57,7 +57,7 @@ if(solution_type==TransientSolutionEnum && analysis_type==EnthalpyAnalysisEnum && isenthalpy==false) continue; if(solution_type==TransientSolutionEnum && analysis_type==MasstransportAnalysisEnum && ismasstransport==false && isgroundingline==false) continue; - if(solution_type==TransientSolutionEnum && analysis_type==DiagnosticHorizAnalysisEnum && isdiagnostic==false) continue; - if(solution_type==TransientSolutionEnum && analysis_type==DiagnosticVertAnalysisEnum && isdiagnostic==false) continue; - if(solution_type==TransientSolutionEnum && analysis_type==DiagnosticSIAAnalysisEnum && isdiagnostic==false) continue; + if(solution_type==TransientSolutionEnum && analysis_type==StressbalanceAnalysisEnum && isstressbalance==false) continue; + if(solution_type==TransientSolutionEnum && analysis_type==StressbalanceVerticalAnalysisEnum && isstressbalance==false) continue; + if(solution_type==TransientSolutionEnum && analysis_type==StressbalanceSIAAnalysisEnum && isstressbalance==false) continue; if(solution_type==SteadystateSolutionEnum && analysis_type==ThermalAnalysisEnum && isenthalpy==true) continue; if(solution_type==SteadystateSolutionEnum && analysis_type==MeltingAnalysisEnum && isenthalpy==true) continue; Index: /issm/trunk-jpl/src/c/modules/ModelProcessorx/ModelProcessorx.h =================================================================== --- /issm/trunk-jpl/src/c/modules/ModelProcessorx/ModelProcessorx.h (revision 15770) +++ /issm/trunk-jpl/src/c/modules/ModelProcessorx/ModelProcessorx.h (revision 15771) @@ -27,21 +27,21 @@ /*Creation of fem datasets: specialised drivers: */ -/*diagnostic horizontal*/ -void CreateNodesDiagnosticHoriz(Nodes** pnodes,IoModel* iomodel); -void CreateConstraintsDiagnosticHoriz(Constraints** pconstraints,IoModel* iomodel); -void CreateLoadsDiagnosticHoriz(Loads** ploads, IoModel* iomodel); -void UpdateElementsDiagnosticHoriz(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type); +/*stressbalance horizontal*/ +void CreateNodesStressbalance(Nodes** pnodes,IoModel* iomodel); +void CreateConstraintsStressbalance(Constraints** pconstraints,IoModel* iomodel); +void CreateLoadsStressbalance(Loads** ploads, IoModel* iomodel); +void UpdateElementsStressbalance(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type); -/*diagnostic vertical*/ -void CreateNodesDiagnosticVert(Nodes** pnodes,IoModel* iomodel); -void CreateConstraintsDiagnosticVert(Constraints** pconstraints,IoModel* iomodel); -void CreateLoadsDiagnosticVert(Loads** ploads, IoModel* iomodel); -void UpdateElementsDiagnosticVert(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type); +/*stressbalance vertical*/ +void CreateNodesStressbalanceVertical(Nodes** pnodes,IoModel* iomodel); +void CreateConstraintsStressbalanceVertical(Constraints** pconstraints,IoModel* iomodel); +void CreateLoadsStressbalanceVertical(Loads** ploads, IoModel* iomodel); +void UpdateElementsStressbalanceVertical(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type); -/*diagnostic SIA*/ -void CreateNodesDiagnosticSIA(Nodes** pnodes,IoModel* iomodel); -void CreateConstraintsDiagnosticSIA(Constraints** pconstraints,IoModel* iomodel); -void CreateLoadsDiagnosticSIA(Loads** ploads, IoModel* iomodel); -void UpdateElementsDiagnosticSIA(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type); +/*stressbalance SIA*/ +void CreateNodesStressbalanceSIA(Nodes** pnodes,IoModel* iomodel); +void CreateConstraintsStressbalanceSIA(Constraints** pconstraints,IoModel* iomodel); +void CreateLoadsStressbalanceSIA(Loads** ploads, IoModel* iomodel); +void UpdateElementsStressbalanceSIA(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type); #ifdef _HAVE_GIA_ Index: /issm/trunk-jpl/src/c/modules/ModelProcessorx/Stressbalance/CreateConstraintsStressbalance.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/ModelProcessorx/Stressbalance/CreateConstraintsStressbalance.cpp (revision 15771) +++ /issm/trunk-jpl/src/c/modules/ModelProcessorx/Stressbalance/CreateConstraintsStressbalance.cpp (revision 15771) @@ -0,0 +1,448 @@ +/* + * CreateConstraintsStressbalance.c: + */ + +#include "../../../toolkits/toolkits.h" +#include "../../../classes/classes.h" +#include "../../../shared/shared.h" +#include "../../IoModelToConstraintsx/IoModelToConstraintsx.h" +#include "../ModelProcessorx.h" + +void CreateConstraintsStressbalance(Constraints** pconstraints, IoModel* iomodel){ + + /*Intermediary*/ + int i,j; + int count,temp,finiteelement; + IssmDouble g; + IssmDouble rho_ice; + IssmDouble FSreconditioning; + bool isSIA,isSSA,isL1L2,isHO,isFS,iscoupling; + bool spcpresent = false; + int Mx,Nx; + int My,Ny; + int Mz,Nz; + IssmDouble *spcvx = NULL; + IssmDouble *spcvy = NULL; + IssmDouble *spcvz = NULL; + IssmDouble *nodeonSSA = NULL; + IssmDouble *nodeonHO = NULL; + IssmDouble *nodeonFS = 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*/ + Constraints *constraints = NULL; + SpcStatic *spcstatic = NULL; + + /*Fetch parameters: */ + iomodel->Constant(&g,ConstantsGEnum); + iomodel->Constant(&rho_ice,MaterialsRhoIceEnum); + iomodel->Constant(&FSreconditioning,StressbalanceFSreconditioningEnum); + iomodel->Constant(&isSIA,FlowequationIsSIAEnum); + iomodel->Constant(&isSSA,FlowequationIsSSAEnum); + iomodel->Constant(&isL1L2,FlowequationIsL1L2Enum); + iomodel->Constant(&isHO,FlowequationIsHOEnum); + iomodel->Constant(&isFS,FlowequationIsFSEnum); + + /*Recover pointer: */ + constraints=*pconstraints; + + /*Now, is the flag macayaealHO on? otherwise, do nothing: */ + if(!isSSA & !isHO & !isFS & !isL1L2){ + *pconstraints=constraints; + return; + } + + /*Do we have coupling*/ + if((isSIA?1.:0.) + (isSSA?1.:0.) + (isL1L2?1.:0.) + (isHO?1.:0.) + (isFS?1.:0.) >1.) + iscoupling = true; + else + iscoupling = false; + + /*If no coupling, call Regular IoModelToConstraintsx, else, use P1 elements only*/ + if(!iscoupling){ + + /*Get finite element type*/ + if(isSSA){ + iomodel->Constant(&temp,FlowequationFeSSAEnum); + switch(temp){ + case 0 : finiteelement = P1Enum; break; + case 1 : finiteelement = P2Enum; break; + case 2 : finiteelement = P1bubblecondensedEnum; break; + case 3 : finiteelement = P1bubbleEnum; break; + default: _error_("finite element "<Constant(&temp,FlowequationFeHOEnum); + switch(temp){ + case 0 : finiteelement = P1Enum; break; + case 1 : finiteelement = P1xP2Enum; break; + case 2 : finiteelement = P2xP1Enum; break; + case 3 : finiteelement = P2Enum; break; + case 4 : finiteelement = P1bubblecondensedEnum; break; + case 5 : finiteelement = P1bubbleEnum; break; + default: _error_("finite element "<Constant(&temp,FlowequationFeFSEnum); + switch(temp){ + case 0 : finiteelement = P1Enum; break;//P1P1 + case 1 : finiteelement = P1Enum; break;//P1P1GSL + case 2 : finiteelement = P1bubbleEnum; break;//MINIcondensed + case 3 : finiteelement = P1bubbleEnum; break;//MINI + case 4 : finiteelement = P2Enum; break;//TaylorHood (P2P1) + default: _error_("finite element "<FetchData(&spcvz,&Mz,&Nz,StressbalanceSpcvzEnum); + iomodel->FetchData(&vertices_type,NULL,NULL,FlowequationVertexEquationEnum); + iomodel->FetchData(&nodeonFS,NULL,NULL,FlowequationBorderFSEnum); + iomodel->FetchData(&nodeonbed,NULL,NULL,MeshVertexonbedEnum); + iomodel->FetchData(&nodeonicesheet,NULL,NULL,MaskVertexongroundediceEnum); + for(i=0;inumberofvertices;i++){ + if(iomodel->my_vertices[i]){ + if(reCast(nodeonbed[i]) && reCast(nodeonicesheet[i]) && reCast(nodeonFS[i])){ + if(vertices_type[i] == FSApproximationEnum){ + for(j=0;jDeleteData(spcvz,StressbalanceSpcvzEnum); + iomodel->DeleteData(vertices_type,FlowequationVertexEquationEnum); + iomodel->DeleteData(nodeonFS,FlowequationBorderFSEnum); + iomodel->DeleteData(nodeonbed,MeshVertexonbedEnum); + iomodel->DeleteData(nodeonicesheet,MaskVertexongroundediceEnum); + + /*Pressure spc*/ + count = constraints->Size(); + iomodel->FetchData(&vertices_type,NULL,NULL,FlowequationVertexEquationEnum); + iomodel->FetchData(&surface,NULL,NULL,SurfaceEnum); + iomodel->FetchData(&z,NULL,NULL,MeshZEnum); + switch(finiteelement){ + case P1bubbleEnum: + for(i=0;inumberofvertices;i++){ + if(iomodel->my_vertices[i]){ + if (reCast(vertices_type[i])==NoneApproximationEnum){ + constraints->AddObject(new SpcStatic(count+1,iomodel->nodecounter+iomodel->numberofvertices+iomodel->numberofelements+i+1,1,g*rho_ice*(surface[i]-z[i])/FSreconditioning,StressbalanceAnalysisEnum)); + count++; + } + } + } + break; + case P2Enum: + for(i=0;inumberofvertices;i++){ + if(iomodel->my_vertices[i]){ + if (reCast(vertices_type[i])==NoneApproximationEnum){ + constraints->AddObject(new SpcStatic(count+1,iomodel->nodecounter+iomodel->numberofvertices+iomodel->numberofedges+i+1,1,g*rho_ice*(surface[i]-z[i])/FSreconditioning,StressbalanceAnalysisEnum)); + count++; + } + } + } + break; + default: + _error_("not implemented yet"); + } + iomodel->DeleteData(vertices_type,FlowequationVertexEquationEnum); + iomodel->DeleteData(surface,SurfaceEnum); + iomodel->DeleteData(z,MeshZEnum); + } + + *pconstraints=constraints; + return; + } + + /*Constraints: fetch data: */ + iomodel->FetchData(&spcvx,&Mx,&Nx,StressbalanceSpcvxEnum); + iomodel->FetchData(&spcvy,&My,&Ny,StressbalanceSpcvyEnum); + iomodel->FetchData(&spcvz,&Mz,&Nz,StressbalanceSpcvzEnum); + iomodel->FetchData(&nodeonSSA,NULL,NULL,FlowequationBorderSSAEnum); + if(iomodel->dim==3)iomodel->FetchData(&nodeonHO,NULL,NULL,FlowequationBorderHOEnum); + if(iomodel->dim==3)iomodel->FetchData(&nodeonFS,NULL,NULL,FlowequationBorderFSEnum); + if(iomodel->dim==3)iomodel->FetchData(&nodeonbed,NULL,NULL,MeshVertexonbedEnum); + if(iomodel->dim==3)iomodel->FetchData(&nodeonicesheet,NULL,NULL,MaskVertexongroundediceEnum); + iomodel->FetchData(&vertices_type,NULL,NULL,FlowequationVertexEquationEnum); + iomodel->FetchData(&surface,NULL,NULL,SurfaceEnum); + iomodel->FetchData(&z,NULL,NULL,MeshZEnum); + + /*Initialize counter: */ + count=0; + + /*figure out times: */ + timesx=xNew(Nx); + for(j=0;j(Ny); + for(j=0;j(Nz); + for(j=0;jnumberofvertices;i++){ + if(iomodel->my_vertices[i]){ + + /*Start with adding spcs of coupling: zero at the border SSA/HO for the appropriate dofs*/ + if(reCast(vertices_type[i]==SSAHOApproximationEnum)){ + /*If grionSSA, spc HO dofs: 3 & 4*/ + if (reCast(nodeonHO[i])){ + constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,1,0,StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx. + count++; + constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,2,0,StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx. + count++; + if (!xIsNan(spcvx[i])){ + constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,3,spcvx[i],StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx. + count++; + } + if (!xIsNan(spcvy[i])){ + constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,4,spcvy[i],StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx. + count++; + } + + } + else if (reCast(nodeonSSA[i])){ + constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,3,0,StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx. + count++; + constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,4,0,StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx. + count++; + if (!xIsNan(spcvx[i])){ + constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,1,spcvx[i],StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx. + count++; + } + if (!xIsNan(spcvy[i])){ + constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,2,spcvy[i],StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx. + count++; + } + + } + else _error_("if vertices_type is SSAHO, you shoud have nodeonHO or nodeonSSA"); + } + /*Also add spcs of coupling: zero at the border HO/FS for the appropriate dofs*/ + else if (reCast(vertices_type[i])==HOFSApproximationEnum){ + /*If grion,HO spc FS dofs: 3 4 & 5*/ + if (reCast(nodeonHO[i])){ + constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,3,0,StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx. + count++; + constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,4,0,StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx. + count++; + constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,5,0,StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx. + count++; + if (!xIsNan(spcvx[i])){ + constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,1,spcvx[i],StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx. + count++; + } + if (!xIsNan(spcvy[i])){ + constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,2,spcvy[i],StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx. + count++; + } + + } + else if (reCast(nodeonFS[i])){ //spc HO nodes: 1 & 2 + constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,1,0,StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx. + count++; + constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,2,0,StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx. + count++; + if (!xIsNan(spcvx[i])){ + constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,3,spcvx[i],StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx. + count++; + } + if (!xIsNan(spcvy[i])){ + constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,4,spcvy[i],StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx. + count++; + } + if (!xIsNan(spcvz[i])){ + constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,5,spcvz[i],StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx. + count++; + } + } + else _error_("if vertices_type is HOFS, you shoud have nodeonHO or nodeonFS"); + } + /*Also add spcs of coupling: zero at the border HO/FS for the appropriate dofs*/ + else if (reCast(vertices_type[i])==SSAFSApproximationEnum){ + /*If grion,HO spc FS dofs: 3 4 & 5*/ + if (reCast(nodeonSSA[i])){ + constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,3,0,StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx. + count++; + constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,4,0,StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx. + count++; + constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,5,0,StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx. + count++; + if (!xIsNan(spcvx[i])){ + constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,1,spcvx[i],StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx. + count++; + } + if (!xIsNan(spcvy[i])){ + constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,2,spcvy[i],StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx. + count++; + } + + } + else if (reCast(nodeonFS[i])){ //spc SSA nodes: 1 & 2 + constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,1,0,StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx. + count++; + constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,2,0,StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx. + count++; + if (!xIsNan(spcvx[i])){ + constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,3,spcvx[i],StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx. + count++; + } + if (!xIsNan(spcvy[i])){ + constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,4,spcvy[i],StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx. + count++; + } + if (!xIsNan(spcvz[i])){ + constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,5,spcvz[i],StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx. + count++; + } + } + else _error_("if vertices_type is SSAFS, you shoud have nodeonSSA or nodeonFS"); + } + /*Now add the regular spcs*/ + else{ + if (Mx==iomodel->numberofvertices && !xIsNan(spcvx[i])){ + constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,1,spcvx[i],StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx. + count++; + + } + else if (Mx==iomodel->numberofvertices+1) { + /*figure out times and values: */ + values=xNew(Nx); + spcpresent=false; + for(j=0;j(values[j]))spcpresent=true; //NaN means no spc by default + } + + if(spcpresent){ + constraints->AddObject(new SpcTransient(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,1,Nx,timesx,values,StressbalanceAnalysisEnum)); + count++; + } + xDelete(values); + } + else if (vertices_type[i]==SIAApproximationEnum){ + constraints->AddObject(new SpcDynamic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,1,StressbalanceAnalysisEnum)); + count++; + } + + if (My==iomodel->numberofvertices && !xIsNan(spcvy[i])){ + constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,2,spcvy[i],StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vy. + count++; + } + else if (My==iomodel->numberofvertices+1){ + /*figure out times and values: */ + values=xNew(Ny); + spcpresent=false; + for(j=0;j(values[j]))spcpresent=true; //NaN means no spc by default + } + if(spcpresent){ + constraints->AddObject(new SpcTransient(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,2,Ny,timesy,values,StressbalanceAnalysisEnum)); + count++; + } + xDelete(values); + } + else if (vertices_type[i]==SIAApproximationEnum){ + constraints->AddObject(new SpcDynamic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,2,StressbalanceAnalysisEnum)); + count++; + } + + if (reCast(vertices_type[i])==FSApproximationEnum || (reCast(vertices_type[i])==NoneApproximationEnum)){ + if (Mz==iomodel->numberofvertices && !xIsNan(spcvz[i])){ + constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,3,spcvz[i],StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 2 to vy + count++; + } + else if (Mz==iomodel->numberofvertices+1){ + /*figure out times and values: */ + values=xNew(Nz); + spcpresent=false; + for(j=0;j(values[j]))spcpresent=true; //NaN means no spc by default + } + if(spcpresent){ + constraints->AddObject(new SpcTransient(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,3,Nz,timesz,values,StressbalanceAnalysisEnum)); + count++; + } + xDelete(values); + } + + } + if (reCast(vertices_type[i])==NoneApproximationEnum){ + constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+iomodel->numberofvertices+i+1,1,g*rho_ice*(surface[i]-z[i])/FSreconditioning,StressbalanceAnalysisEnum)); //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 (iomodel->dim==3) if(reCast(nodeonbed[i]) && reCast(nodeonicesheet[i]) && reCast(nodeonFS[i])){ + switch(reCast(vertices_type[i])){ + case SSAFSApproximationEnum: + constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,5,0.,StressbalanceAnalysisEnum)); + count++; + break; + case HOFSApproximationEnum: + constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,5,0.,StressbalanceAnalysisEnum)); + count++; + break; + case FSApproximationEnum: + constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,3,0.,StressbalanceAnalysisEnum)); + count++; + break; + default: _error_("Vertex approximation " << EnumToStringx(reCast(vertices_type[i])) << " not supported"); + } + } + } + } + + /*Free data: */ + iomodel->DeleteData(spcvx,StressbalanceSpcvxEnum); + iomodel->DeleteData(spcvy,StressbalanceSpcvyEnum); + iomodel->DeleteData(spcvz,StressbalanceSpcvzEnum); + iomodel->DeleteData(nodeonSSA,FlowequationBorderSSAEnum); + if(iomodel->dim==3)iomodel->DeleteData(nodeonHO,FlowequationBorderHOEnum); + if(iomodel->dim==3)iomodel->DeleteData(nodeonFS,FlowequationBorderFSEnum); + if(iomodel->dim==3)iomodel->DeleteData(nodeonbed,MeshVertexonbedEnum); + if(iomodel->dim==3)iomodel->DeleteData(nodeonicesheet,MaskVertexongroundediceEnum); + iomodel->DeleteData(vertices_type,FlowequationVertexEquationEnum); + iomodel->DeleteData(surface,SurfaceEnum); + iomodel->DeleteData(z,MeshZEnum); + + /*Free resources:*/ + xDelete(timesx); + xDelete(timesy); + xDelete(timesz); + xDelete(values); + + /*Assign output pointer: */ + *pconstraints=constraints; +} Index: /issm/trunk-jpl/src/c/modules/ModelProcessorx/Stressbalance/CreateLoadsStressbalance.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/ModelProcessorx/Stressbalance/CreateLoadsStressbalance.cpp (revision 15771) +++ /issm/trunk-jpl/src/c/modules/ModelProcessorx/Stressbalance/CreateLoadsStressbalance.cpp (revision 15771) @@ -0,0 +1,89 @@ +/*! \file CreateLoadsStressbalance.c: + */ + +#include "../../../toolkits/toolkits.h" +#include "../../../classes/classes.h" +#include "../../../shared/shared.h" +#include "../ModelProcessorx.h" + +void CreateLoadsStressbalance(Loads** ploads, IoModel* iomodel){ + + /*DataSets*/ + Pengrid *pengrid = NULL; + + /*Intermediary*/ + int segment_width; + int element; + int i; + int count; + int penpair_ids[2]; + bool isSSA,isL1L2,isHO,isFS; + int numpenalties,numberofpressureloads,numrifts,numriftsegments; + IssmDouble *pressureload = NULL; + IssmDouble *elements_type = NULL; + IssmDouble *nodeoniceshelf = NULL; + IssmDouble *riftinfo = NULL; + IssmDouble *nodeonbed = NULL; + IssmDouble *nodeonFS = NULL; + IssmDouble *nodeonicesheet = NULL; + IssmDouble *vertices_type = NULL; + IssmDouble *penalties = NULL; + + /*Fetch parameters: */ + iomodel->Constant(&isL1L2,FlowequationIsL1L2Enum); + iomodel->Constant(&isFS,FlowequationIsFSEnum); + iomodel->Constant(&isSSA,FlowequationIsSSAEnum); + iomodel->Constant(&isHO,FlowequationIsHOEnum); + iomodel->Constant(&numrifts,RiftsNumriftsEnum); + + /*Recover pointer: */ + Loads* loads=*ploads; + + /*Now, is the flag macayaealHO on? otherwise, do nothing: */ + if(!isSSA & !isHO & !isFS & !isL1L2) return; + + /*Initialize counter: */ + count=0; + + /*Create Penpair for penalties: */ + iomodel->FetchData(&penalties,&numpenalties,NULL,StressbalanceVertexPairingEnum); + + for(i=0;imy_vertices[reCast(penalties[2*i+0]-1)]){ + + /*In debugging mode, check that the second node is in the same cpu*/ + _assert_(iomodel->my_vertices[(int)penalties[2*i+1]-1]); + + /*Get node ids*/ + penpair_ids[0]=iomodel->nodecounter+reCast(penalties[2*i+0]); + penpair_ids[1]=iomodel->nodecounter+reCast(penalties[2*i+1]); + + /*Create Load*/ + loads->AddObject(new Penpair(iomodel->loadcounter+count+1,&penpair_ids[0],StressbalanceAnalysisEnum)); + count++; + } + } + + /*free ressources: */ + iomodel->DeleteData(penalties,StressbalanceVertexPairingEnum); + + /*Create Riffront loads for rifts: */ + #ifdef _HAVE_RIFTS_ + if(numrifts){ + iomodel->FetchData(&riftinfo,&numriftsegments,NULL,RiftsRiftstructEnum); + iomodel->FetchData(5,RiftsRiftstructEnum,ThicknessEnum,BedEnum,SurfaceEnum,MaskVertexonfloatingiceEnum); + for(i=0;imy_elements[reCast(*(riftinfo+RIFTINFOSIZE*i+2))-1]){ + loads->AddObject(new Riftfront(iomodel->loadcounter+count+1,i,iomodel,StressbalanceAnalysisEnum)); + count++; + } + } + iomodel->DeleteData(5,RiftsRiftstructEnum,ThicknessEnum,BedEnum,SurfaceEnum,MaskVertexonfloatingiceEnum); + xDelete(riftinfo); + } + #endif + + /*Assign output pointer: */ + *ploads=loads; +} Index: /issm/trunk-jpl/src/c/modules/ModelProcessorx/Stressbalance/CreateNodesStressbalance.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/ModelProcessorx/Stressbalance/CreateNodesStressbalance.cpp (revision 15771) +++ /issm/trunk-jpl/src/c/modules/ModelProcessorx/Stressbalance/CreateNodesStressbalance.cpp (revision 15771) @@ -0,0 +1,133 @@ +/* + * CreateNodesStressbalance.c: + */ + +#include "../../../toolkits/toolkits.h" +#include "../../../classes/classes.h" +#include "../../../shared/shared.h" +#include "../../MeshPartitionx/MeshPartitionx.h" +#include "../ModelProcessorx.h" + +void CreateNodesStressbalance(Nodes** pnodes, IoModel* iomodel){ + + /*Intermediary*/ + bool isSSA,isL1L2,isHO,isFS,iscoupling; + int temp,finiteelement=-1,approximation=-1; + + /*Fetch parameters: */ + iomodel->Constant(&isSSA,FlowequationIsSSAEnum); + iomodel->Constant(&isL1L2,FlowequationIsL1L2Enum); + iomodel->Constant(&isHO,FlowequationIsHOEnum); + iomodel->Constant(&isFS,FlowequationIsFSEnum); + + /*Now, check that we have non SIA elements */ + if(!isSSA & !isL1L2 & !isHO & !isFS) return; + + /*Do we have coupling*/ + if( (isSSA?1.:0.) + (isL1L2?1.:0.) + (isHO?1.:0.) + (isFS?1.:0.) >1.) + iscoupling = true; + else + iscoupling = false; + + /*If no coupling, call Regular CreateNodes, else, use P1 elements only*/ + if(!iscoupling){ + + /*Get finite element type*/ + if(isSSA){ + approximation=SSAApproximationEnum; + iomodel->Constant(&temp,FlowequationFeSSAEnum); + switch(temp){ + case 0 : finiteelement = P1Enum; break; + case 1 : finiteelement = P2Enum; break; + case 2 : finiteelement = P1bubblecondensedEnum; break; + case 3 : finiteelement = P1bubbleEnum; break; + default: _error_("finite element "<Constant(&temp,FlowequationFeHOEnum); + switch(temp){ + case 0 : finiteelement = P1Enum; break; + case 1 : finiteelement = P1xP2Enum; break; + case 2 : finiteelement = P2xP1Enum; break; + case 3 : finiteelement = P2Enum; break; + case 4 : finiteelement = P1bubblecondensedEnum; break; + case 5 : finiteelement = P1bubbleEnum; break; + default: _error_("finite element "<Constant(&temp,FlowequationFeFSEnum); + switch(temp){ + case 0 : finiteelement = P1P1Enum; break; + case 1 : finiteelement = P1P1GLSEnum; break; + case 2 : finiteelement = MINIcondensedEnum; break; + case 3 : finiteelement = MINIEnum; break; + case 4 : finiteelement = TaylorHoodEnum; break; + default: _error_("finite element "<FetchData(8,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,FlowequationBorderSSAEnum,FlowequationBorderFSEnum, + MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,StressbalanceReferentialEnum); + CreateNodes(pnodes,iomodel,StressbalanceAnalysisEnum,finiteelement,approximation); + iomodel->DeleteData(8,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,FlowequationBorderSSAEnum,FlowequationBorderFSEnum, + MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,StressbalanceReferentialEnum); + } + else{ + /*Coupling: we are going to create P1 Elements only*/ + + /*Recover nodes*/ + Nodes* nodes = *pnodes; + Node* node = NULL; + if(!nodes) nodes = new Nodes(); + + iomodel->FetchData(8,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,FlowequationBorderSSAEnum,FlowequationBorderFSEnum, + MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,StressbalanceReferentialEnum); + if(isFS){ + /*P1+ velocity*/ + for(int i=0;inumberofvertices;i++){ + if(iomodel->my_vertices[i]){ + approximation=reCast(iomodel->Data(FlowequationVertexEquationEnum)[i]); + if(approximation==FSApproximationEnum) approximation=FSvelocityEnum; + nodes->AddObject(new Node(iomodel->nodecounter+i+1,i,i,iomodel,StressbalanceAnalysisEnum,approximation)); + } + } + for(int i=0;inumberofelements;i++){ + if(iomodel->my_elements[i]){ + node = new Node(iomodel->nodecounter+iomodel->numberofvertices+i+1,iomodel->numberofvertices+i,0,iomodel,StressbalanceAnalysisEnum,FSvelocityEnum); + node->Deactivate(); + nodes->AddObject(node); + } + } + /*P1 pressure*/ + for(int i=0;inumberofvertices;i++){ + if(iomodel->my_vertices[i]){ + approximation=reCast(iomodel->Data(FlowequationVertexEquationEnum)[i]); + node = new Node(iomodel->nodecounter+iomodel->numberofvertices+iomodel->numberofelements+i+1,iomodel->numberofvertices+iomodel->numberofelements+i,i,iomodel,StressbalanceAnalysisEnum,FSpressureEnum); + if(approximation==HOApproximationEnum || approximation==SSAApproximationEnum){ + node->Deactivate(); + } + nodes->AddObject(node); + } + } + } + else{ + for(int i=0;inumberofvertices;i++){ + if(iomodel->my_vertices[i]){ + nodes->AddObject(new Node(iomodel->nodecounter+i+1,i,i,iomodel,StressbalanceAnalysisEnum,reCast(iomodel->Data(FlowequationVertexEquationEnum)[i]))); + } + } + } + iomodel->DeleteData(8,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,FlowequationBorderSSAEnum,FlowequationBorderFSEnum, + MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,StressbalanceReferentialEnum); + + /*Assign output pointer: */ + *pnodes=nodes; + } +} Index: /issm/trunk-jpl/src/c/modules/ModelProcessorx/Stressbalance/UpdateElementsStressbalance.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/ModelProcessorx/Stressbalance/UpdateElementsStressbalance.cpp (revision 15771) +++ /issm/trunk-jpl/src/c/modules/ModelProcessorx/Stressbalance/UpdateElementsStressbalance.cpp (revision 15771) @@ -0,0 +1,176 @@ +/* + * UpdateElementsStressbalance: + */ +#ifdef HAVE_CONFIG_H + #include +#else +#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!" +#endif + +#include "../../../toolkits/toolkits.h" +#include "../../../classes/classes.h" +#include "../../../shared/shared.h" +#include "../../MeshPartitionx/MeshPartitionx.h" +#include "../ModelProcessorx.h" + +void UpdateElementsStressbalance(Elements* elements, IoModel* iomodel,int analysis_counter,int analysis_type){ + + int materials_type,finiteelement,temp; + int approximation; + int* finiteelement_list=NULL; + bool isSSA,isL1L2,isHO,isFS,iscoupling; + bool control_analysis; + bool dakota_analysis; + + /*Fetch constants needed: */ + iomodel->Constant(&isSSA,FlowequationIsSSAEnum); + iomodel->Constant(&isL1L2,FlowequationIsL1L2Enum); + iomodel->Constant(&isHO,FlowequationIsHOEnum); + iomodel->Constant(&isFS,FlowequationIsFSEnum); + iomodel->Constant(&control_analysis,InversionIscontrolEnum); + iomodel->Constant(&dakota_analysis,QmuIsdakotaEnum); + iomodel->Constant(&materials_type,MaterialsEnum); + + /*Now, is the flag macayaealHO on? otherwise, do nothing: */ + if(!isSSA & !isL1L2 & !isHO & !isFS) return; + + /*Fetch data needed and allocate vectors: */ + iomodel->FetchData(1,FlowequationElementEquationEnum); + finiteelement_list=xNewZeroInit(iomodel->numberofelements); + + + /*Do we have coupling*/ + if( (isSSA?1.:0.) + (isL1L2?1.:0.) + (isHO?1.:0.) + (isFS?1.:0.) >1.) + iscoupling = true; + else + iscoupling = false; + + /*Get finite element type*/ + if(!iscoupling){ + if(isSSA){ + iomodel->Constant(&temp,FlowequationFeSSAEnum); + switch(temp){ + case 0 : finiteelement = P1Enum; break; + case 1 : finiteelement = P2Enum; break; + case 2 : finiteelement = P1bubblecondensedEnum; break; + case 3 : finiteelement = P1bubbleEnum; break; + default: _error_("finite element "<Constant(&temp,FlowequationFeHOEnum); + switch(temp){ + case 0 : finiteelement = P1Enum; break; + case 1 : finiteelement = P1xP2Enum; break; + case 2 : finiteelement = P2xP1Enum; break; + case 3 : finiteelement = P2Enum; break; + case 4 : finiteelement = P1bubblecondensedEnum; break; + case 5 : finiteelement = P1bubbleEnum; break; + default: _error_("finite element "<Constant(&temp,FlowequationFeFSEnum); + switch(temp){ + case 0 : finiteelement = P1P1Enum; break; + case 1 : finiteelement = P1P1GLSEnum; break; + case 2 : finiteelement = MINIcondensedEnum; break; + case 3 : finiteelement = MINIEnum; break; + case 4 : finiteelement = TaylorHoodEnum; break; + default: _error_("finite element "<numberofelements;i++){ + finiteelement_list[i]=finiteelement; + } + } + else{ + if(isFS){ + for(int i=0;inumberofelements;i++){ + approximation=reCast(iomodel->Data(FlowequationElementEquationEnum)[i]); + if(approximation==FSApproximationEnum || approximation==HOFSApproximationEnum || approximation==SSAFSApproximationEnum){ + finiteelement_list[i]=MINIcondensedEnum; + } + else{ + finiteelement_list[i]=P1Enum; + } + } + } + else{ + finiteelement = P1Enum; + for(int i=0;inumberofelements;i++){ + finiteelement_list[i]=finiteelement; + } + } + } + + /*Update elements: */ + int counter=0; + for(int i=0;inumberofelements;i++){ + if(iomodel->my_elements[i]){ + Element* element=(Element*)elements->GetObjectByOffset(counter); + element->Update(i,iomodel,analysis_counter,analysis_type,finiteelement_list[i]); + counter++; + } + } + + /*Create inputs: */ + iomodel->FetchDataToInput(elements,ThicknessEnum); + iomodel->FetchDataToInput(elements,GeometryHydrostaticRatioEnum); + iomodel->FetchDataToInput(elements,SurfaceEnum); + iomodel->FetchDataToInput(elements,BedEnum); + iomodel->FetchDataToInput(elements,FrictionCoefficientEnum); + iomodel->FetchDataToInput(elements,FrictionPEnum); + iomodel->FetchDataToInput(elements,FrictionQEnum); + iomodel->FetchDataToInput(elements,MaskElementonfloatingiceEnum); + iomodel->FetchDataToInput(elements,MaskIcelevelsetEnum); + iomodel->FetchDataToInput(elements,MaterialsRheologyBEnum); + iomodel->FetchDataToInput(elements,MaterialsRheologyNEnum); + iomodel->FetchDataToInput(elements,VxEnum); + iomodel->FetchDataToInput(elements,VyEnum); + iomodel->FetchDataToInput(elements,LoadingforceXEnum); + iomodel->FetchDataToInput(elements,LoadingforceYEnum); + if(materials_type==MatdamageiceEnum){ + iomodel->FetchDataToInput(elements,MaterialsRheologyZEnum); + } + if(iomodel->dim==3){ + iomodel->FetchDataToInput(elements,MeshElementonbedEnum); + iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum); + iomodel->FetchDataToInput(elements,VzEnum); + iomodel->FetchDataToInput(elements,SurfaceforcingsMassBalanceEnum); + iomodel->FetchDataToInput(elements,BasalforcingsMeltingRateEnum); + iomodel->FetchDataToInput(elements,FlowequationBorderFSEnum); + iomodel->FetchDataToInput(elements,LoadingforceZEnum); + } + + if(control_analysis){ + iomodel->FetchDataToInput(elements,InversionVxObsEnum); + iomodel->FetchDataToInput(elements,InversionVyObsEnum); + } + + /*Post-process: */ + elements->InputDuplicate(VxEnum,VxPicardEnum); + elements->InputDuplicate(VxEnum,InversionVxObsEnum); + if(dakota_analysis)elements->InputDuplicate(VxEnum,QmuVxEnum); + + #ifdef _HAVE_ANDROID_ + elements->InputDuplicate(FrictionCoefficientEnum,AndroidFrictionCoefficientEnum); + #endif + + elements->InputDuplicate(VyEnum,VyPicardEnum); + elements->InputDuplicate(VyEnum,InversionVyObsEnum); + if(dakota_analysis)elements->InputDuplicate(VyEnum,QmuVyEnum); + + if(iomodel->dim==3){ + elements->InputDuplicate(VzEnum,VzPicardEnum); + elements->InputDuplicate(VzEnum,InversionVzObsEnum); + if(dakota_analysis)elements->InputDuplicate(VzEnum,QmuVzEnum); + } + + /*Free data: */ + iomodel->DeleteData(1,FlowequationElementEquationEnum); + xDelete(finiteelement_list); +} Index: /issm/trunk-jpl/src/c/modules/ModelProcessorx/StressbalanceSIA/CreateConstraintsStressbalanceSIA.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/ModelProcessorx/StressbalanceSIA/CreateConstraintsStressbalanceSIA.cpp (revision 15771) +++ /issm/trunk-jpl/src/c/modules/ModelProcessorx/StressbalanceSIA/CreateConstraintsStressbalanceSIA.cpp (revision 15771) @@ -0,0 +1,68 @@ +/* + * CreateConstraintsStressbalanceSIA.c: + */ + +#include "../../../toolkits/toolkits.h" +#include "../../../classes/classes.h" +#include "../../../shared/shared.h" +#include "../ModelProcessorx.h" + +void CreateConstraintsStressbalanceSIA(Constraints** pconstraints, IoModel* iomodel){ + + /*Intermediary*/ + int count; + IssmDouble yts; + bool isSIA; + + /*Output*/ + Constraints* constraints = NULL; + SpcStatic* spcstatic = NULL; + + /*Recover pointer: */ + constraints=*pconstraints; + + /*Fetch parameters: */ + iomodel->Constant(&yts,ConstantsYtsEnum); + iomodel->Constant(&isSIA,FlowequationIsSIAEnum); + + /*Now, is the flag isSIA on? otherwise, do nothing: */ + if (!isSIA) return; + + /*Fetch data: */ + iomodel->FetchData(3,StressbalanceSpcvxEnum,StressbalanceSpcvyEnum,FlowequationVertexEquationEnum); + + /*Initialize conunter*/ + count=0; + + /*vx and vy are spc'd if we are not on nodeonSIA: */ + for(int i=0;inumberofvertices;i++){ + /*keep only this partition's nodes:*/ + if((iomodel->my_vertices[i])){ + if (!reCast(iomodel->Data(FlowequationVertexEquationEnum)[i])==SIAApproximationEnum){ + + constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,1,0,StressbalanceSIAAnalysisEnum)); + count++; + + constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,2,0,StressbalanceSIAAnalysisEnum)); + count++; + } + else{ + if (!xIsNan(iomodel->Data(StressbalanceSpcvxEnum)[i])){ + constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,1,iomodel->Data(StressbalanceSpcvxEnum)[i]/yts,StressbalanceSIAAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx. + count++; + } + + if (!xIsNan(iomodel->Data(StressbalanceSpcvyEnum)[i])){ + constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,2,iomodel->Data(StressbalanceSpcvyEnum)[i]/yts,StressbalanceSIAAnalysisEnum)); //add count'th spc, on node i+1, setting dof 2 to vy + count++; + } + } + } + } + + /*Free data: */ + iomodel->DeleteData(3,StressbalanceSpcvxEnum,StressbalanceSpcvyEnum,FlowequationVertexEquationEnum); + + /*Assign output pointer: */ + *pconstraints=constraints; +} Index: /issm/trunk-jpl/src/c/modules/ModelProcessorx/StressbalanceSIA/CreateLoadsStressbalanceSIA.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/ModelProcessorx/StressbalanceSIA/CreateLoadsStressbalanceSIA.cpp (revision 15771) +++ /issm/trunk-jpl/src/c/modules/ModelProcessorx/StressbalanceSIA/CreateLoadsStressbalanceSIA.cpp (revision 15771) @@ -0,0 +1,12 @@ +/*! \file CreateLoadsStressbalanceSIA.c: + */ + +#include "../../../toolkits/toolkits.h" +#include "../../../classes/classes.h" +#include "../../../shared/shared.h" +#include "../ModelProcessorx.h" + +void CreateLoadsStressbalanceSIA(Loads** ploads, IoModel* iomodel){ + + /*No loads*/ +} Index: /issm/trunk-jpl/src/c/modules/ModelProcessorx/StressbalanceSIA/CreateNodesStressbalanceSIA.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/ModelProcessorx/StressbalanceSIA/CreateNodesStressbalanceSIA.cpp (revision 15771) +++ /issm/trunk-jpl/src/c/modules/ModelProcessorx/StressbalanceSIA/CreateNodesStressbalanceSIA.cpp (revision 15771) @@ -0,0 +1,51 @@ +/* + * CreateNodesStressbalanceSIA.c: + */ + +#include "../../../toolkits/toolkits.h" +#include "../../../classes/classes.h" +#include "../../../shared/shared.h" +#include "../../MeshPartitionx/MeshPartitionx.h" +#include "../ModelProcessorx.h" + +void CreateNodesStressbalanceSIA(Nodes** pnodes, IoModel* iomodel){ + + /*Intermediaries*/ + bool isSIA; + Node* node = NULL; + + /*Fetch parameters: */ + iomodel->Constant(&isSIA,FlowequationIsSIAEnum); + + /*Now, is the flag isSIA on? otherwise, do nothing: */ + if(!isSIA) return; + + /*First create nodes*/ + Nodes* nodes=*pnodes; + if(!nodes) nodes = new Nodes(); + + iomodel->FetchData(8,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,FlowequationBorderSSAEnum,FlowequationBorderFSEnum, + MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,StressbalanceReferentialEnum); + + for(int i=0;inumberofvertices;i++){ + if(iomodel->my_vertices[i]){ + + /*Create new node if is in this processor's partition*/ + node = new Node(iomodel->nodecounter+i+1,i,i,iomodel,StressbalanceSIAAnalysisEnum,reCast(iomodel->Data(FlowequationVertexEquationEnum)[i])); + + /*Deactivate node if not SIA*/ + if(reCast(iomodel->Data(FlowequationVertexEquationEnum)[i])!=SIAApproximationEnum){ + node->Deactivate(); + } + + /*Add to Nodes dataset*/ + nodes->AddObject(node); + } + } + + iomodel->DeleteData(8,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,FlowequationBorderSSAEnum,FlowequationBorderFSEnum, + MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,StressbalanceReferentialEnum); + + /*Assign output pointer: */ + *pnodes=nodes; +} Index: /issm/trunk-jpl/src/c/modules/ModelProcessorx/StressbalanceSIA/UpdateElementsStressbalanceSIA.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/ModelProcessorx/StressbalanceSIA/UpdateElementsStressbalanceSIA.cpp (revision 15771) +++ /issm/trunk-jpl/src/c/modules/ModelProcessorx/StressbalanceSIA/UpdateElementsStressbalanceSIA.cpp (revision 15771) @@ -0,0 +1,37 @@ +/* + * UpdateElementsStressbalanceSIA: + */ + +#include "../../../toolkits/toolkits.h" +#include "../../../classes/classes.h" +#include "../../../shared/shared.h" +#include "../../MeshPartitionx/MeshPartitionx.h" +#include "../ModelProcessorx.h" + +void UpdateElementsStressbalanceSIA(Elements* elements, IoModel* iomodel,int analysis_counter,int analysis_type){ + + /*Fetch data needed: */ + bool isSIA; + iomodel->Constant(&isSIA,FlowequationIsSIAEnum); + + /*Now, is the flag SIA on? otherwise, do nothing: */ + if (!isSIA)return; + + iomodel->FetchData(1,FlowequationElementEquationEnum); + + /*Update elements: */ + int counter=0; + for(int i=0;inumberofelements;i++){ + if(iomodel->my_elements[i]){ + Element* element=(Element*)elements->GetObjectByOffset(counter); + element->Update(i,iomodel,analysis_counter,analysis_type,P1Enum); + counter++; + } + } + + iomodel->FetchDataToInput(elements,ThicknessEnum); + iomodel->FetchDataToInput(elements,GeometryHydrostaticRatioEnum); + + /*Free data: */ + iomodel->DeleteData(1,FlowequationElementEquationEnum); +} Index: /issm/trunk-jpl/src/c/modules/ModelProcessorx/StressbalanceVertical/CreateConstraintsStressbalanceVertical.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/ModelProcessorx/StressbalanceVertical/CreateConstraintsStressbalanceVertical.cpp (revision 15771) +++ /issm/trunk-jpl/src/c/modules/ModelProcessorx/StressbalanceVertical/CreateConstraintsStressbalanceVertical.cpp (revision 15771) @@ -0,0 +1,55 @@ +/* + * CreateConstraintsStressbalanceHoriz.c: + */ + +#include "../../../toolkits/toolkits.h" +#include "../../../classes/classes.h" +#include "../../../shared/shared.h" +#include "../ModelProcessorx.h" + +void CreateConstraintsStressbalanceVertical(Constraints** pconstraints, IoModel* iomodel){ + + /*Intermediary*/ + int count; + IssmDouble yts; + + /*Fetch parameters: */ + iomodel->Constant(&yts,ConstantsYtsEnum); + + /*Recover pointer: */ + Constraints* constraints=*pconstraints; + + /*return if 2d mesh*/ + if(iomodel->dim==2) *pconstraints=constraints; + + /*Fetch data: */ + iomodel->FetchData(2,StressbalanceSpcvzEnum,FlowequationBorderFSEnum); + + /*Initialize counter*/ + count=0; + + /*Create spcs from x,y,z, as well as the spc values on those spcs: */ + for(int i=0;inumberofvertices;i++){ + + /*keep only this partition's nodes:*/ + if(iomodel->my_vertices[i]){ + + if (reCast(iomodel->Data(FlowequationBorderFSEnum)[i])){ + constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,1,0,StressbalanceVerticalAnalysisEnum)); //spc to zero as vertical velocity is done in Horiz for FS + count++; + } + else if (!xIsNan(iomodel->Data(StressbalanceSpcvzEnum)[i])){ + constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,1, + iomodel->Data(StressbalanceSpcvzEnum)[i]/yts,StressbalanceVerticalAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx. + count++; + + } + } + } + + /*Free data: */ + iomodel->DeleteData(2,StressbalanceSpcvzEnum,FlowequationBorderFSEnum); + + /*Assign output pointer: */ + *pconstraints=constraints; +} Index: /issm/trunk-jpl/src/c/modules/ModelProcessorx/StressbalanceVertical/CreateLoadsStressbalanceVertical.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/ModelProcessorx/StressbalanceVertical/CreateLoadsStressbalanceVertical.cpp (revision 15771) +++ /issm/trunk-jpl/src/c/modules/ModelProcessorx/StressbalanceVertical/CreateLoadsStressbalanceVertical.cpp (revision 15771) @@ -0,0 +1,13 @@ +/*! \file CreateLoadsStressbalanceVertical.c: + */ + +#include "../../../toolkits/toolkits.h" +#include "../../../classes/classes.h" +#include "../../../shared/shared.h" +#include "../ModelProcessorx.h" + +void CreateLoadsStressbalanceVertical(Loads** ploads, IoModel* iomodel){ + + /*No loads*/ + +} Index: /issm/trunk-jpl/src/c/modules/ModelProcessorx/StressbalanceVertical/CreateNodesStressbalanceVertical.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/ModelProcessorx/StressbalanceVertical/CreateNodesStressbalanceVertical.cpp (revision 15771) +++ /issm/trunk-jpl/src/c/modules/ModelProcessorx/StressbalanceVertical/CreateNodesStressbalanceVertical.cpp (revision 15771) @@ -0,0 +1,19 @@ +/* + * CreateNodesStressbalanceVertical.c: + */ + +#include "../../../toolkits/toolkits.h" +#include "../../../classes/classes.h" +#include "../../../shared/shared.h" +#include "../../MeshPartitionx/MeshPartitionx.h" +#include "../ModelProcessorx.h" + +void CreateNodesStressbalanceVertical(Nodes** pnodes, IoModel* iomodel){ + + /*Now, is the flag macayaealHO on? otherwise, do nothing: */ + if(iomodel->dim==2) return; + + iomodel->FetchData(5,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum); + CreateNodes(pnodes,iomodel,StressbalanceVerticalAnalysisEnum,P1Enum); + iomodel->DeleteData(5,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum); +} Index: /issm/trunk-jpl/src/c/modules/ModelProcessorx/StressbalanceVertical/UpdateElementsStressbalanceVertical.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/ModelProcessorx/StressbalanceVertical/UpdateElementsStressbalanceVertical.cpp (revision 15771) +++ /issm/trunk-jpl/src/c/modules/ModelProcessorx/StressbalanceVertical/UpdateElementsStressbalanceVertical.cpp (revision 15771) @@ -0,0 +1,38 @@ +/* + * UpdateElementsStressbalanceVertical: + */ + +#include "../../../toolkits/toolkits.h" +#include "../../../classes/classes.h" +#include "../../../shared/shared.h" +#include "../../MeshPartitionx/MeshPartitionx.h" +#include "../ModelProcessorx.h" + +void UpdateElementsStressbalanceVertical(Elements* elements, IoModel* iomodel,int analysis_counter,int analysis_type){ + + /*Now, is the model 3d? otherwise, do nothing: */ + if (iomodel->dim==2)return; + + /*Update elements: */ + int counter=0; + for(int i=0;inumberofelements;i++){ + if(iomodel->my_elements[i]){ + Element* element=(Element*)elements->GetObjectByOffset(counter); + element->Update(i,iomodel,analysis_counter,analysis_type,P1Enum); + counter++; + } + } + + iomodel->FetchDataToInput(elements,ThicknessEnum); + iomodel->FetchDataToInput(elements,GeometryHydrostaticRatioEnum); + iomodel->FetchDataToInput(elements,SurfaceEnum); + iomodel->FetchDataToInput(elements,BedEnum); + iomodel->FetchDataToInput(elements,MaskIcelevelsetEnum); + iomodel->FetchDataToInput(elements,MaskElementonfloatingiceEnum); + iomodel->FetchDataToInput(elements,MeshElementonbedEnum); + iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum); + iomodel->FetchDataToInput(elements,BasalforcingsMeltingRateEnum); + iomodel->FetchDataToInput(elements,SurfaceforcingsMassBalanceEnum); + iomodel->FetchDataToInput(elements,VxEnum); + iomodel->FetchDataToInput(elements,VyEnum); +} Index: /issm/trunk-jpl/src/c/modules/OutputRiftsx/OutputRiftsx.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/OutputRiftsx/OutputRiftsx.cpp (revision 15770) +++ /issm/trunk-jpl/src/c/modules/OutputRiftsx/OutputRiftsx.cpp (revision 15771) @@ -1,4 +1,4 @@ /*!\file OutputRiftsx - * \brief: output results from diagnostic solution, for rifts. Notably: fraction of + * \brief: output results from stressbalance solution, for rifts. Notably: fraction of * melange, and penetration. */ Index: /issm/trunk-jpl/src/c/shared/Enum/EnumDefinitions.h =================================================================== --- /issm/trunk-jpl/src/c/shared/Enum/EnumDefinitions.h (revision 15770) +++ /issm/trunk-jpl/src/c/shared/Enum/EnumDefinitions.h (revision 15771) @@ -41,23 +41,23 @@ ConstantsYtsEnum, DependentObjectEnum, - DiagnosticAbstolEnum, - DiagnosticIcefrontEnum, - DiagnosticIsnewtonEnum, - DiagnosticMaxiterEnum, - DiagnosticNumRequestedOutputsEnum, - DiagnosticPenaltyFactorEnum, - DiagnosticReferentialEnum, - DiagnosticReltolEnum, - DiagnosticRequestedOutputsEnum, - DiagnosticRestolEnum, - DiagnosticRiftPenaltyLockEnum, - DiagnosticRiftPenaltyThresholdEnum, - DiagnosticShelfDampeningEnum, - DiagnosticSpcvxEnum, - DiagnosticSpcvyEnum, - DiagnosticSpcvzEnum, - DiagnosticFSreconditioningEnum, - DiagnosticVertexPairingEnum, - DiagnosticViscosityOvershootEnum, + StressbalanceAbstolEnum, + StressbalanceIcefrontEnum, + StressbalanceIsnewtonEnum, + StressbalanceMaxiterEnum, + StressbalanceNumRequestedOutputsEnum, + StressbalancePenaltyFactorEnum, + StressbalanceReferentialEnum, + StressbalanceReltolEnum, + StressbalanceRequestedOutputsEnum, + StressbalanceRestolEnum, + StressbalanceRiftPenaltyLockEnum, + StressbalanceRiftPenaltyThresholdEnum, + StressbalanceShelfDampeningEnum, + StressbalanceSpcvxEnum, + StressbalanceSpcvyEnum, + StressbalanceSpcvzEnum, + StressbalanceFSreconditioningEnum, + StressbalanceVertexPairingEnum, + StressbalanceViscosityOvershootEnum, LoadingforceXEnum, LoadingforceYEnum, @@ -254,5 +254,5 @@ TimesteppingTimeAdaptEnum, TimesteppingTimeStepEnum, - TransientIsdiagnosticEnum, + TransientIsstressbalanceEnum, TransientIsgroundinglineEnum, TransientIsmasstransportEnum, @@ -280,8 +280,8 @@ BedSlopeXAnalysisEnum, BedSlopeYAnalysisEnum, - DiagnosticHorizAnalysisEnum, - DiagnosticSIAAnalysisEnum, - DiagnosticSolutionEnum, - DiagnosticVertAnalysisEnum, + StressbalanceAnalysisEnum, + StressbalanceSIAAnalysisEnum, + StressbalanceSolutionEnum, + StressbalanceVerticalAnalysisEnum, EnthalpyAnalysisEnum, EnthalpySolutionEnum, Index: /issm/trunk-jpl/src/c/shared/Enum/EnumToStringx.cpp =================================================================== --- /issm/trunk-jpl/src/c/shared/Enum/EnumToStringx.cpp (revision 15770) +++ /issm/trunk-jpl/src/c/shared/Enum/EnumToStringx.cpp (revision 15771) @@ -49,23 +49,23 @@ case ConstantsYtsEnum : return "ConstantsYts"; case DependentObjectEnum : return "DependentObject"; - case DiagnosticAbstolEnum : return "DiagnosticAbstol"; - case DiagnosticIcefrontEnum : return "DiagnosticIcefront"; - case DiagnosticIsnewtonEnum : return "DiagnosticIsnewton"; - case DiagnosticMaxiterEnum : return "DiagnosticMaxiter"; - case DiagnosticNumRequestedOutputsEnum : return "DiagnosticNumRequestedOutputs"; - case DiagnosticPenaltyFactorEnum : return "DiagnosticPenaltyFactor"; - case DiagnosticReferentialEnum : return "DiagnosticReferential"; - case DiagnosticReltolEnum : return "DiagnosticReltol"; - case DiagnosticRequestedOutputsEnum : return "DiagnosticRequestedOutputs"; - case DiagnosticRestolEnum : return "DiagnosticRestol"; - case DiagnosticRiftPenaltyLockEnum : return "DiagnosticRiftPenaltyLock"; - case DiagnosticRiftPenaltyThresholdEnum : return "DiagnosticRiftPenaltyThreshold"; - case DiagnosticShelfDampeningEnum : return "DiagnosticShelfDampening"; - case DiagnosticSpcvxEnum : return "DiagnosticSpcvx"; - case DiagnosticSpcvyEnum : return "DiagnosticSpcvy"; - case DiagnosticSpcvzEnum : return "DiagnosticSpcvz"; - case DiagnosticFSreconditioningEnum : return "DiagnosticFSreconditioning"; - case DiagnosticVertexPairingEnum : return "DiagnosticVertexPairing"; - case DiagnosticViscosityOvershootEnum : return "DiagnosticViscosityOvershoot"; + case StressbalanceAbstolEnum : return "StressbalanceAbstol"; + case StressbalanceIcefrontEnum : return "StressbalanceIcefront"; + case StressbalanceIsnewtonEnum : return "StressbalanceIsnewton"; + case StressbalanceMaxiterEnum : return "StressbalanceMaxiter"; + case StressbalanceNumRequestedOutputsEnum : return "StressbalanceNumRequestedOutputs"; + case StressbalancePenaltyFactorEnum : return "StressbalancePenaltyFactor"; + case StressbalanceReferentialEnum : return "StressbalanceReferential"; + case StressbalanceReltolEnum : return "StressbalanceReltol"; + case StressbalanceRequestedOutputsEnum : return "StressbalanceRequestedOutputs"; + case StressbalanceRestolEnum : return "StressbalanceRestol"; + case StressbalanceRiftPenaltyLockEnum : return "StressbalanceRiftPenaltyLock"; + case StressbalanceRiftPenaltyThresholdEnum : return "StressbalanceRiftPenaltyThreshold"; + case StressbalanceShelfDampeningEnum : return "StressbalanceShelfDampening"; + case StressbalanceSpcvxEnum : return "StressbalanceSpcvx"; + case StressbalanceSpcvyEnum : return "StressbalanceSpcvy"; + case StressbalanceSpcvzEnum : return "StressbalanceSpcvz"; + case StressbalanceFSreconditioningEnum : return "StressbalanceFSreconditioning"; + case StressbalanceVertexPairingEnum : return "StressbalanceVertexPairing"; + case StressbalanceViscosityOvershootEnum : return "StressbalanceViscosityOvershoot"; case LoadingforceXEnum : return "LoadingforceX"; case LoadingforceYEnum : return "LoadingforceY"; @@ -262,5 +262,5 @@ case TimesteppingTimeAdaptEnum : return "TimesteppingTimeAdapt"; case TimesteppingTimeStepEnum : return "TimesteppingTimeStep"; - case TransientIsdiagnosticEnum : return "TransientIsdiagnostic"; + case TransientIsstressbalanceEnum : return "TransientIsstressbalance"; case TransientIsgroundinglineEnum : return "TransientIsgroundingline"; case TransientIsmasstransportEnum : return "TransientIsmasstransport"; @@ -286,8 +286,8 @@ case BedSlopeXAnalysisEnum : return "BedSlopeXAnalysis"; case BedSlopeYAnalysisEnum : return "BedSlopeYAnalysis"; - case DiagnosticHorizAnalysisEnum : return "DiagnosticHorizAnalysis"; - case DiagnosticSIAAnalysisEnum : return "DiagnosticSIAAnalysis"; - case DiagnosticSolutionEnum : return "DiagnosticSolution"; - case DiagnosticVertAnalysisEnum : return "DiagnosticVertAnalysis"; + case StressbalanceAnalysisEnum : return "StressbalanceAnalysis"; + case StressbalanceSIAAnalysisEnum : return "StressbalanceSIAAnalysis"; + case StressbalanceSolutionEnum : return "StressbalanceSolution"; + case StressbalanceVerticalAnalysisEnum : return "StressbalanceVerticalAnalysis"; case EnthalpyAnalysisEnum : return "EnthalpyAnalysis"; case EnthalpySolutionEnum : return "EnthalpySolution"; Index: /issm/trunk-jpl/src/c/shared/Enum/StringToEnumx.cpp =================================================================== --- /issm/trunk-jpl/src/c/shared/Enum/StringToEnumx.cpp (revision 15770) +++ /issm/trunk-jpl/src/c/shared/Enum/StringToEnumx.cpp (revision 15771) @@ -49,23 +49,23 @@ else if (strcmp(name,"ConstantsYts")==0) return ConstantsYtsEnum; else if (strcmp(name,"DependentObject")==0) return DependentObjectEnum; - else if (strcmp(name,"DiagnosticAbstol")==0) return DiagnosticAbstolEnum; - else if (strcmp(name,"DiagnosticIcefront")==0) return DiagnosticIcefrontEnum; - else if (strcmp(name,"DiagnosticIsnewton")==0) return DiagnosticIsnewtonEnum; - else if (strcmp(name,"DiagnosticMaxiter")==0) return DiagnosticMaxiterEnum; - else if (strcmp(name,"DiagnosticNumRequestedOutputs")==0) return DiagnosticNumRequestedOutputsEnum; - else if (strcmp(name,"DiagnosticPenaltyFactor")==0) return DiagnosticPenaltyFactorEnum; - else if (strcmp(name,"DiagnosticReferential")==0) return DiagnosticReferentialEnum; - else if (strcmp(name,"DiagnosticReltol")==0) return DiagnosticReltolEnum; - else if (strcmp(name,"DiagnosticRequestedOutputs")==0) return DiagnosticRequestedOutputsEnum; - else if (strcmp(name,"DiagnosticRestol")==0) return DiagnosticRestolEnum; - else if (strcmp(name,"DiagnosticRiftPenaltyLock")==0) return DiagnosticRiftPenaltyLockEnum; - else if (strcmp(name,"DiagnosticRiftPenaltyThreshold")==0) return DiagnosticRiftPenaltyThresholdEnum; - else if (strcmp(name,"DiagnosticShelfDampening")==0) return DiagnosticShelfDampeningEnum; - else if (strcmp(name,"DiagnosticSpcvx")==0) return DiagnosticSpcvxEnum; - else if (strcmp(name,"DiagnosticSpcvy")==0) return DiagnosticSpcvyEnum; - else if (strcmp(name,"DiagnosticSpcvz")==0) return DiagnosticSpcvzEnum; - else if (strcmp(name,"DiagnosticFSreconditioning")==0) return DiagnosticFSreconditioningEnum; - else if (strcmp(name,"DiagnosticVertexPairing")==0) return DiagnosticVertexPairingEnum; - else if (strcmp(name,"DiagnosticViscosityOvershoot")==0) return DiagnosticViscosityOvershootEnum; + else if (strcmp(name,"StressbalanceAbstol")==0) return StressbalanceAbstolEnum; + else if (strcmp(name,"StressbalanceIcefront")==0) return StressbalanceIcefrontEnum; + else if (strcmp(name,"StressbalanceIsnewton")==0) return StressbalanceIsnewtonEnum; + else if (strcmp(name,"StressbalanceMaxiter")==0) return StressbalanceMaxiterEnum; + else if (strcmp(name,"StressbalanceNumRequestedOutputs")==0) return StressbalanceNumRequestedOutputsEnum; + else if (strcmp(name,"StressbalancePenaltyFactor")==0) return StressbalancePenaltyFactorEnum; + else if (strcmp(name,"StressbalanceReferential")==0) return StressbalanceReferentialEnum; + else if (strcmp(name,"StressbalanceReltol")==0) return StressbalanceReltolEnum; + else if (strcmp(name,"StressbalanceRequestedOutputs")==0) return StressbalanceRequestedOutputsEnum; + else if (strcmp(name,"StressbalanceRestol")==0) return StressbalanceRestolEnum; + else if (strcmp(name,"StressbalanceRiftPenaltyLock")==0) return StressbalanceRiftPenaltyLockEnum; + else if (strcmp(name,"StressbalanceRiftPenaltyThreshold")==0) return StressbalanceRiftPenaltyThresholdEnum; + else if (strcmp(name,"StressbalanceShelfDampening")==0) return StressbalanceShelfDampeningEnum; + else if (strcmp(name,"StressbalanceSpcvx")==0) return StressbalanceSpcvxEnum; + else if (strcmp(name,"StressbalanceSpcvy")==0) return StressbalanceSpcvyEnum; + else if (strcmp(name,"StressbalanceSpcvz")==0) return StressbalanceSpcvzEnum; + else if (strcmp(name,"StressbalanceFSreconditioning")==0) return StressbalanceFSreconditioningEnum; + else if (strcmp(name,"StressbalanceVertexPairing")==0) return StressbalanceVertexPairingEnum; + else if (strcmp(name,"StressbalanceViscosityOvershoot")==0) return StressbalanceViscosityOvershootEnum; else if (strcmp(name,"LoadingforceX")==0) return LoadingforceXEnum; else if (strcmp(name,"LoadingforceY")==0) return LoadingforceYEnum; @@ -268,5 +268,5 @@ else if (strcmp(name,"TimesteppingTimeAdapt")==0) return TimesteppingTimeAdaptEnum; else if (strcmp(name,"TimesteppingTimeStep")==0) return TimesteppingTimeStepEnum; - else if (strcmp(name,"TransientIsdiagnostic")==0) return TransientIsdiagnosticEnum; + else if (strcmp(name,"TransientIsstressbalance")==0) return TransientIsstressbalanceEnum; else if (strcmp(name,"TransientIsgroundingline")==0) return TransientIsgroundinglineEnum; else if (strcmp(name,"TransientIsmasstransport")==0) return TransientIsmasstransportEnum; @@ -292,8 +292,8 @@ else if (strcmp(name,"BedSlopeXAnalysis")==0) return BedSlopeXAnalysisEnum; else if (strcmp(name,"BedSlopeYAnalysis")==0) return BedSlopeYAnalysisEnum; - else if (strcmp(name,"DiagnosticHorizAnalysis")==0) return DiagnosticHorizAnalysisEnum; - else if (strcmp(name,"DiagnosticSIAAnalysis")==0) return DiagnosticSIAAnalysisEnum; - else if (strcmp(name,"DiagnosticSolution")==0) return DiagnosticSolutionEnum; - else if (strcmp(name,"DiagnosticVertAnalysis")==0) return DiagnosticVertAnalysisEnum; + else if (strcmp(name,"StressbalanceAnalysis")==0) return StressbalanceAnalysisEnum; + else if (strcmp(name,"StressbalanceSIAAnalysis")==0) return StressbalanceSIAAnalysisEnum; + else if (strcmp(name,"StressbalanceSolution")==0) return StressbalanceSolutionEnum; + else if (strcmp(name,"StressbalanceVerticalAnalysis")==0) return StressbalanceVerticalAnalysisEnum; else if (strcmp(name,"EnthalpyAnalysis")==0) return EnthalpyAnalysisEnum; else if (strcmp(name,"EnthalpySolution")==0) return EnthalpySolutionEnum; Index: /issm/trunk-jpl/src/c/solutionsequences/convergence.cpp =================================================================== --- /issm/trunk-jpl/src/c/solutionsequences/convergence.cpp (revision 15770) +++ /issm/trunk-jpl/src/c/solutionsequences/convergence.cpp (revision 15771) @@ -40,7 +40,7 @@ /*get convergence options*/ - parameters->FindParam(&eps_res,DiagnosticRestolEnum); - parameters->FindParam(&eps_rel,DiagnosticReltolEnum); - parameters->FindParam(&eps_abs,DiagnosticAbstolEnum); + parameters->FindParam(&eps_res,StressbalanceRestolEnum); + parameters->FindParam(&eps_rel,StressbalanceReltolEnum); + parameters->FindParam(&eps_abs,StressbalanceAbstolEnum); parameters->FindParam(&yts,ConstantsYtsEnum); Index: /issm/trunk-jpl/src/c/solutionsequences/solutionsequence_newton.cpp =================================================================== --- /issm/trunk-jpl/src/c/solutionsequences/solutionsequence_newton.cpp (revision 15770) +++ /issm/trunk-jpl/src/c/solutionsequences/solutionsequence_newton.cpp (revision 15771) @@ -33,7 +33,7 @@ /*Recover parameters: */ - femmodel->parameters->FindParam(&max_nonlinear_iterations,DiagnosticMaxiterEnum); + femmodel->parameters->FindParam(&max_nonlinear_iterations,StressbalanceMaxiterEnum); femmodel->parameters->FindParam(&configuration_type,ConfigurationTypeEnum); - femmodel->parameters->FindParam(&newton,DiagnosticIsnewtonEnum); + femmodel->parameters->FindParam(&newton,StressbalanceIsnewtonEnum); femmodel->UpdateConstraintsx(); Index: /issm/trunk-jpl/src/c/solutionsequences/solutionsequence_nonlinear.cpp =================================================================== --- /issm/trunk-jpl/src/c/solutionsequences/solutionsequence_nonlinear.cpp (revision 15770) +++ /issm/trunk-jpl/src/c/solutionsequences/solutionsequence_nonlinear.cpp (revision 15771) @@ -33,6 +33,6 @@ /*Recover parameters: */ - femmodel->parameters->FindParam(&min_mechanical_constraints,DiagnosticRiftPenaltyThresholdEnum); - femmodel->parameters->FindParam(&max_nonlinear_iterations,DiagnosticMaxiterEnum); + femmodel->parameters->FindParam(&min_mechanical_constraints,StressbalanceRiftPenaltyThresholdEnum); + femmodel->parameters->FindParam(&max_nonlinear_iterations,StressbalanceMaxiterEnum); femmodel->parameters->FindParam(&configuration_type,ConfigurationTypeEnum); femmodel->UpdateConstraintsx(); Index: /issm/trunk-jpl/src/c/solutionsequences/solutionsequence_stokescoupling_nonlinear.cpp =================================================================== --- /issm/trunk-jpl/src/c/solutionsequences/solutionsequence_stokescoupling_nonlinear.cpp (revision 15770) +++ /issm/trunk-jpl/src/c/solutionsequences/solutionsequence_stokescoupling_nonlinear.cpp (revision 15771) @@ -35,6 +35,6 @@ /*Recover parameters: */ - femmodel->parameters->FindParam(&min_mechanical_constraints,DiagnosticRiftPenaltyThresholdEnum); - femmodel->parameters->FindParam(&max_nonlinear_iterations,DiagnosticMaxiterEnum); + femmodel->parameters->FindParam(&min_mechanical_constraints,StressbalanceRiftPenaltyThresholdEnum); + femmodel->parameters->FindParam(&max_nonlinear_iterations,StressbalanceMaxiterEnum); femmodel->UpdateConstraintsx(); @@ -43,5 +43,5 @@ /*First get ug_horiz:*/ - femmodel->SetCurrentConfiguration(DiagnosticHorizAnalysisEnum); + femmodel->SetCurrentConfiguration(StressbalanceAnalysisEnum); GetSolutionFromInputsx(&ug_horiz, femmodel->elements, femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters); Reducevectorgtofx(&uf_horiz, ug_horiz, femmodel->nodes,femmodel->parameters); @@ -49,6 +49,6 @@ for(;;){ - /*First diagnostic horiz:*/ - femmodel->SetCurrentConfiguration(DiagnosticHorizAnalysisEnum); + /*First stressbalance horiz:*/ + femmodel->SetCurrentConfiguration(StressbalanceAnalysisEnum); femmodel->parameters->FindParam(&configuration_type,ConfigurationTypeEnum); @@ -71,5 +71,5 @@ /*Second compute vertical velocity: */ - femmodel->SetCurrentConfiguration(DiagnosticVertAnalysisEnum); + femmodel->SetCurrentConfiguration(StressbalanceVerticalAnalysisEnum); femmodel->parameters->FindParam(&configuration_type,ConfigurationTypeEnum); Index: /issm/trunk-jpl/src/m/boundaryconditions/SetIceSheetBC.m =================================================================== --- /issm/trunk-jpl/src/m/boundaryconditions/SetIceSheetBC.m (revision 15770) +++ /issm/trunk-jpl/src/m/boundaryconditions/SetIceSheetBC.m (revision 15771) @@ -1,4 +1,4 @@ function md=SetIceSheetBC(md) -%SETICESHEETBC - Create the boundary conditions for diagnostic and thermal models for an IceSheet with no Ice Front +%SETICESHEETBC - Create the boundary conditions for stressbalance and thermal models for an IceSheet with no Ice Front % % Usage: @@ -9,20 +9,20 @@ %node on Dirichlet pos=find(md.mesh.vertexonboundary); -md.diagnostic.spcvx=NaN*ones(md.mesh.numberofvertices,1); -md.diagnostic.spcvy=NaN*ones(md.mesh.numberofvertices,1); -md.diagnostic.spcvz=NaN*ones(md.mesh.numberofvertices,1); -md.diagnostic.spcvx(pos)=0; -md.diagnostic.spcvy(pos)=0; -md.diagnostic.spcvz(pos)=0; -md.diagnostic.referential=NaN*ones(md.mesh.numberofvertices,6); -md.diagnostic.loadingforce=0*ones(md.mesh.numberofvertices,3); +md.stressbalance.spcvx=NaN*ones(md.mesh.numberofvertices,1); +md.stressbalance.spcvy=NaN*ones(md.mesh.numberofvertices,1); +md.stressbalance.spcvz=NaN*ones(md.mesh.numberofvertices,1); +md.stressbalance.spcvx(pos)=0; +md.stressbalance.spcvy(pos)=0; +md.stressbalance.spcvz(pos)=0; +md.stressbalance.referential=NaN*ones(md.mesh.numberofvertices,6); +md.stressbalance.loadingforce=0*ones(md.mesh.numberofvertices,3); %Dirichlet Values if (length(md.inversion.vx_obs)==md.mesh.numberofvertices & length(md.inversion.vy_obs)==md.mesh.numberofvertices) - disp(' boundary conditions for diagnostic model: spc set as observed velocities'); - md.diagnostic.spcvx(pos)=md.inversion.vx_obs(pos); - md.diagnostic.spcvy(pos)=md.inversion.vy_obs(pos); + disp(' boundary conditions for stressbalance model: spc set as observed velocities'); + md.stressbalance.spcvx(pos)=md.inversion.vx_obs(pos); + md.stressbalance.spcvy(pos)=md.inversion.vy_obs(pos); else - disp(' boundary conditions for diagnostic model: spc set as zero'); + disp(' boundary conditions for stressbalance model: spc set as zero'); end Index: /issm/trunk-jpl/src/m/boundaryconditions/SetIceSheetBC.py =================================================================== --- /issm/trunk-jpl/src/m/boundaryconditions/SetIceSheetBC.py (revision 15770) +++ /issm/trunk-jpl/src/m/boundaryconditions/SetIceSheetBC.py (revision 15771) @@ -5,5 +5,5 @@ def SetIceSheetBC(md): """ - SETICESHEETBC - Create the boundary conditions for diagnostic and thermal models for an IceSheet with no Ice Front + SETICESHEETBC - Create the boundary conditions for stressbalance and thermal models for an IceSheet with no Ice Front Usage: @@ -15,20 +15,20 @@ #node on Dirichlet pos=numpy.nonzero(md.mesh.vertexonboundary) - md.diagnostic.spcvx=float('nan')*numpy.ones((md.mesh.numberofvertices,1)) - md.diagnostic.spcvy=float('nan')*numpy.ones((md.mesh.numberofvertices,1)) - md.diagnostic.spcvz=float('nan')*numpy.ones((md.mesh.numberofvertices,1)) - md.diagnostic.spcvx[pos]=0 - md.diagnostic.spcvy[pos]=0 - md.diagnostic.spcvz[pos]=0 - md.diagnostic.referential=float('nan')*numpy.ones((md.mesh.numberofvertices,6)) - md.diagnostic.loadingforce=0*numpy.ones((md.mesh.numberofvertices,3)) + md.stressbalance.spcvx=float('nan')*numpy.ones((md.mesh.numberofvertices,1)) + md.stressbalance.spcvy=float('nan')*numpy.ones((md.mesh.numberofvertices,1)) + md.stressbalance.spcvz=float('nan')*numpy.ones((md.mesh.numberofvertices,1)) + md.stressbalance.spcvx[pos]=0 + md.stressbalance.spcvy[pos]=0 + md.stressbalance.spcvz[pos]=0 + md.stressbalance.referential=float('nan')*numpy.ones((md.mesh.numberofvertices,6)) + md.stressbalance.loadingforce=0*numpy.ones((md.mesh.numberofvertices,3)) #Dirichlet Values if isinstance(md.inversion.vx_obs,numpy.ndarray) and numpy.size(md.inversion.vx_obs,axis=0)==md.mesh.numberofvertices and isinstance(md.inversion.vy_obs,numpy.ndarray) and numpy.size(md.inversion.vy_obs,axis=0)==md.mesh.numberofvertices: - print " boundary conditions for diagnostic model: spc set as observed velocities" - md.diagnostic.spcvx[pos]=md.inversion.vx_obs[pos] - md.diagnostic.spcvy[pos]=md.inversion.vy_obs[pos] + print " boundary conditions for stressbalance model: spc set as observed velocities" + md.stressbalance.spcvx[pos]=md.inversion.vx_obs[pos] + md.stressbalance.spcvy[pos]=md.inversion.vy_obs[pos] else: - print " boundary conditions for diagnostic model: spc set as zero" + print " boundary conditions for stressbalance model: spc set as zero" #No ice front -> do nothing Index: /issm/trunk-jpl/src/m/boundaryconditions/SetIceShelfBC.m =================================================================== --- /issm/trunk-jpl/src/m/boundaryconditions/SetIceShelfBC.m (revision 15770) +++ /issm/trunk-jpl/src/m/boundaryconditions/SetIceShelfBC.m (revision 15771) @@ -1,8 +1,8 @@ function md=SetIceShelfBC(md,varargin) -%SETICESHELFBC - Create the boundary conditions for diagnostic and thermal models for a Ice Shelf with Ice Front +%SETICESHELFBC - Create the boundary conditions for stressbalance and thermal models for a Ice Shelf with Ice Front % % Neumann BC are used on the ice front (an ANRGUS contour around the ice front % must be given in input) -% Dirichlet BC are used elsewhere for diagnostic +% Dirichlet BC are used elsewhere for stressbalance % % Usage: @@ -28,20 +28,20 @@ end pos=find(md.mesh.vertexonboundary & ~nodeonicefront); -md.diagnostic.spcvx=NaN*ones(md.mesh.numberofvertices,1); -md.diagnostic.spcvy=NaN*ones(md.mesh.numberofvertices,1); -md.diagnostic.spcvz=NaN*ones(md.mesh.numberofvertices,1); -md.diagnostic.spcvx(pos)=0; -md.diagnostic.spcvy(pos)=0; -md.diagnostic.spcvz(pos)=0; -md.diagnostic.referential=NaN*ones(md.mesh.numberofvertices,6); -md.diagnostic.loadingforce=0*ones(md.mesh.numberofvertices,3); +md.stressbalance.spcvx=NaN*ones(md.mesh.numberofvertices,1); +md.stressbalance.spcvy=NaN*ones(md.mesh.numberofvertices,1); +md.stressbalance.spcvz=NaN*ones(md.mesh.numberofvertices,1); +md.stressbalance.spcvx(pos)=0; +md.stressbalance.spcvy(pos)=0; +md.stressbalance.spcvz(pos)=0; +md.stressbalance.referential=NaN*ones(md.mesh.numberofvertices,6); +md.stressbalance.loadingforce=0*ones(md.mesh.numberofvertices,3); %Dirichlet Values if (length(md.inversion.vx_obs)==md.mesh.numberofvertices & length(md.inversion.vy_obs)==md.mesh.numberofvertices) - disp(' boundary conditions for diagnostic model: spc set as observed velocities'); - md.diagnostic.spcvx(pos)=md.inversion.vx_obs(pos); - md.diagnostic.spcvy(pos)=md.inversion.vy_obs(pos); + disp(' boundary conditions for stressbalance model: spc set as observed velocities'); + md.stressbalance.spcvx(pos)=md.inversion.vx_obs(pos); + md.stressbalance.spcvy(pos)=md.inversion.vy_obs(pos); else - disp(' boundary conditions for diagnostic model: spc set as zero'); + disp(' boundary conditions for stressbalance model: spc set as zero'); end Index: /issm/trunk-jpl/src/m/boundaryconditions/SetIceShelfBC.py =================================================================== --- /issm/trunk-jpl/src/m/boundaryconditions/SetIceShelfBC.py (revision 15770) +++ /issm/trunk-jpl/src/m/boundaryconditions/SetIceShelfBC.py (revision 15771) @@ -5,9 +5,9 @@ def SetIceShelfBC(md,icefrontfile=''): """ - SETICESHELFBC - Create the boundary conditions for diagnostic and thermal models for a Ice Shelf with Ice Front + SETICESHELFBC - Create the boundary conditions for stressbalance and thermal models for a Ice Shelf with Ice Front Neumann BC are used on the ice front (an ARGUS contour around the ice front must be given in input) - Dirichlet BC are used elsewhere for diagnostic + Dirichlet BC are used elsewhere for stressbalance Usage: @@ -32,12 +32,12 @@ # pos=find(md.mesh.vertexonboundary & ~nodeonicefront); pos=numpy.nonzero(numpy.logical_and(md.mesh.vertexonboundary,numpy.logical_not(nodeonicefront)))[0] - md.diagnostic.spcvx=float('nan')*numpy.ones((md.mesh.numberofvertices,1)) - md.diagnostic.spcvy=float('nan')*numpy.ones((md.mesh.numberofvertices,1)) - md.diagnostic.spcvz=float('nan')*numpy.ones((md.mesh.numberofvertices,1)) - md.diagnostic.spcvx[pos]=0 - md.diagnostic.spcvy[pos]=0 - md.diagnostic.spcvz[pos]=0 - md.diagnostic.referential=float('nan')*numpy.ones((md.mesh.numberofvertices,6)) - md.diagnostic.loadingforce=0*numpy.ones((md.mesh.numberofvertices,3)) + md.stressbalance.spcvx=float('nan')*numpy.ones((md.mesh.numberofvertices,1)) + md.stressbalance.spcvy=float('nan')*numpy.ones((md.mesh.numberofvertices,1)) + md.stressbalance.spcvz=float('nan')*numpy.ones((md.mesh.numberofvertices,1)) + md.stressbalance.spcvx[pos]=0 + md.stressbalance.spcvy[pos]=0 + md.stressbalance.spcvz[pos]=0 + md.stressbalance.referential=float('nan')*numpy.ones((md.mesh.numberofvertices,6)) + md.stressbalance.loadingforce=0*numpy.ones((md.mesh.numberofvertices,3)) #Dirichlet Values @@ -48,9 +48,9 @@ if numpy.ndim(md.inversion.vy_obs)==1: md.inversion.vy_obs=md.inversion.vy_obs.reshape(-1,1) - print " boundary conditions for diagnostic model: spc set as observed velocities" - md.diagnostic.spcvx[pos]=md.inversion.vx_obs[pos] - md.diagnostic.spcvy[pos]=md.inversion.vy_obs[pos] + print " boundary conditions for stressbalance model: spc set as observed velocities" + md.stressbalance.spcvx[pos]=md.inversion.vx_obs[pos] + md.stressbalance.spcvy[pos]=md.inversion.vy_obs[pos] else: - print " boundary conditions for diagnostic model: spc set as zero" + print " boundary conditions for stressbalance model: spc set as zero" #Icefront position Index: /issm/trunk-jpl/src/m/boundaryconditions/SetMarineIceSheetBC.m =================================================================== --- /issm/trunk-jpl/src/m/boundaryconditions/SetMarineIceSheetBC.m (revision 15770) +++ /issm/trunk-jpl/src/m/boundaryconditions/SetMarineIceSheetBC.m (revision 15771) @@ -1,8 +1,8 @@ function md=SetMarineIceSheetBC(md,varargin) -%SETICEMARINESHEETBC - Create the boundary conditions for diagnostic and thermal models for a Marine Ice Sheet with Ice Front +%SETICEMARINESHEETBC - Create the boundary conditions for stressbalance and thermal models for a Marine Ice Sheet with Ice Front % % Neumann BC are used on the ice front (an ARGUS contour around the ice front % can be given in input, or it will be deduced as onfloatingice & onboundary) -% Dirichlet BC are used elsewhere for diagnostic +% Dirichlet BC are used elsewhere for stressbalance % % Usage: @@ -35,20 +35,20 @@ warning('SetMarineIceSheetBC warning: ice front all around the glacier, no dirichlet found. Dirichlet must be added manually') end -md.diagnostic.spcvx=NaN*ones(md.mesh.numberofvertices,1); -md.diagnostic.spcvy=NaN*ones(md.mesh.numberofvertices,1); -md.diagnostic.spcvz=NaN*ones(md.mesh.numberofvertices,1); -md.diagnostic.spcvx(pos)=0; -md.diagnostic.spcvy(pos)=0; -md.diagnostic.spcvz(pos)=0; -md.diagnostic.referential=NaN*ones(md.mesh.numberofvertices,6); -md.diagnostic.loadingforce=0*ones(md.mesh.numberofvertices,3); +md.stressbalance.spcvx=NaN*ones(md.mesh.numberofvertices,1); +md.stressbalance.spcvy=NaN*ones(md.mesh.numberofvertices,1); +md.stressbalance.spcvz=NaN*ones(md.mesh.numberofvertices,1); +md.stressbalance.spcvx(pos)=0; +md.stressbalance.spcvy(pos)=0; +md.stressbalance.spcvz(pos)=0; +md.stressbalance.referential=NaN*ones(md.mesh.numberofvertices,6); +md.stressbalance.loadingforce=0*ones(md.mesh.numberofvertices,3); %Dirichlet Values if (length(md.inversion.vx_obs)==md.mesh.numberofvertices & length(md.inversion.vy_obs)==md.mesh.numberofvertices) - disp(' boundary conditions for diagnostic model: spc set as observed velocities'); - md.diagnostic.spcvx(pos)=md.inversion.vx_obs(pos); - md.diagnostic.spcvy(pos)=md.inversion.vy_obs(pos); + disp(' boundary conditions for stressbalance model: spc set as observed velocities'); + md.stressbalance.spcvx(pos)=md.inversion.vx_obs(pos); + md.stressbalance.spcvy(pos)=md.inversion.vy_obs(pos); else - disp(' boundary conditions for diagnostic model: spc set as zero'); + disp(' boundary conditions for stressbalance model: spc set as zero'); end Index: /issm/trunk-jpl/src/m/boundaryconditions/SetMarineIceSheetBC.py =================================================================== --- /issm/trunk-jpl/src/m/boundaryconditions/SetMarineIceSheetBC.py (revision 15770) +++ /issm/trunk-jpl/src/m/boundaryconditions/SetMarineIceSheetBC.py (revision 15771) @@ -5,9 +5,9 @@ def SetMarineIceSheetBC(md,icefrontfile=''): """ - SETICEMARINESHEETBC - Create the boundary conditions for diagnostic and thermal models for a Marine Ice Sheet with Ice Front + SETICEMARINESHEETBC - Create the boundary conditions for stressbalance and thermal models for a Marine Ice Sheet with Ice Front Neumann BC are used on the ice front (an ARGUS contour around the ice front can be given in input, or it will be deduced as onfloatingice & onboundary) - Dirichlet BC are used elsewhere for diagnostic + Dirichlet BC are used elsewhere for stressbalance Usage: @@ -40,20 +40,20 @@ print "SetMarineIceSheetBC warning: ice front all around the glacier, no dirichlet found. Dirichlet must be added manually." - md.diagnostic.spcvx=float('nan')*numpy.ones((md.mesh.numberofvertices,1)) - md.diagnostic.spcvy=float('nan')*numpy.ones((md.mesh.numberofvertices,1)) - md.diagnostic.spcvz=float('nan')*numpy.ones((md.mesh.numberofvertices,1)) - md.diagnostic.spcvx[pos]=0 - md.diagnostic.spcvy[pos]=0 - md.diagnostic.spcvz[pos]=0 - md.diagnostic.referential=float('nan')*numpy.ones((md.mesh.numberofvertices,6)) - md.diagnostic.loadingforce=0*numpy.ones((md.mesh.numberofvertices,3)) + md.stressbalance.spcvx=float('nan')*numpy.ones((md.mesh.numberofvertices,1)) + md.stressbalance.spcvy=float('nan')*numpy.ones((md.mesh.numberofvertices,1)) + md.stressbalance.spcvz=float('nan')*numpy.ones((md.mesh.numberofvertices,1)) + md.stressbalance.spcvx[pos]=0 + md.stressbalance.spcvy[pos]=0 + md.stressbalance.spcvz[pos]=0 + md.stressbalance.referential=float('nan')*numpy.ones((md.mesh.numberofvertices,6)) + md.stressbalance.loadingforce=0*numpy.ones((md.mesh.numberofvertices,3)) #Dirichlet Values if isinstance(md.inversion.vx_obs,numpy.ndarray) and numpy.size(md.inversion.vx_obs,axis=0)==md.mesh.numberofvertices and isinstance(md.inversion.vy_obs,numpy.ndarray) and numpy.size(md.inversion.vy_obs,axis=0)==md.mesh.numberofvertices: - print " boundary conditions for diagnostic model: spc set as observed velocities" - md.diagnostic.spcvx[pos]=md.inversion.vx_obs[pos] - md.diagnostic.spcvy[pos]=md.inversion.vy_obs[pos] + print " boundary conditions for stressbalance model: spc set as observed velocities" + md.stressbalance.spcvx[pos]=md.inversion.vx_obs[pos] + md.stressbalance.spcvy[pos]=md.inversion.vy_obs[pos] else: - print " boundary conditions for diagnostic model: spc set as zero" + print " boundary conditions for stressbalance model: spc set as zero" md.hydrology.spcwatercolumn=numpy.zeros((md.mesh.numberofvertices,2)) Index: /issm/trunk-jpl/src/m/classes/flowequation.m =================================================================== --- /issm/trunk-jpl/src/m/classes/flowequation.m (revision 15770) +++ /issm/trunk-jpl/src/m/classes/flowequation.m (revision 15771) @@ -74,5 +74,5 @@ function md = checkconsistency(obj,md,solution,analyses) % {{{ - if ismember(DiagnosticHorizAnalysisEnum(),analyses), + if ismember(StressbalanceAnalysisEnum(),analyses), md = checkfield(md,'flowequation.isSIA','numel',[1],'values',[0 1]); @@ -98,5 +98,5 @@ end end - if ismember(DiagnosticSIAAnalysisEnum(),analyses), + if ismember(StressbalanceSIAAnalysisEnum(),analyses), if any(obj.element_equation==1), if(obj.element_equation & md.mask.elementonfloatingice), Index: /issm/trunk-jpl/src/m/classes/flowequation.py =================================================================== --- /issm/trunk-jpl/src/m/classes/flowequation.py (revision 15770) +++ /issm/trunk-jpl/src/m/classes/flowequation.py (revision 15771) @@ -61,5 +61,5 @@ def checkconsistency(self,md,solution,analyses): # {{{ - if DiagnosticHorizAnalysisEnum() in analyses: + if StressbalanceAnalysisEnum() in analyses: md = checkfield(md,'flowequation.isSIA','numel',[1],'values',[0,1]) md = checkfield(md,'flowequation.isSSA','numel',[1],'values',[0,1]) @@ -82,5 +82,5 @@ md.checkmessage("no element types set for this model") - if DiagnosticSIAAnalysisEnum() in analyses: + if StressbalanceSIAAnalysisEnum() in analyses: if any(self.element_equation==1): if numpy.any(numpy.logical_and(self.element_equation,md.mask.elementonfloatingice)): Index: /issm/trunk-jpl/src/m/classes/friction.m =================================================================== --- /issm/trunk-jpl/src/m/classes/friction.m (revision 15770) +++ /issm/trunk-jpl/src/m/classes/friction.m (revision 15771) @@ -25,5 +25,5 @@ %Early return - if ~ismember(DiagnosticHorizAnalysisEnum(),analyses) & ~ismember(ThermalAnalysisEnum(),analyses), return; end + if ~ismember(StressbalanceAnalysisEnum(),analyses) & ~ismember(ThermalAnalysisEnum(),analyses), return; end md = checkfield(md,'friction.coefficient','NaN',1,'size',[md.mesh.numberofvertices 1]); Index: /issm/trunk-jpl/src/m/classes/friction.py =================================================================== --- /issm/trunk-jpl/src/m/classes/friction.py (revision 15770) +++ /issm/trunk-jpl/src/m/classes/friction.py (revision 15771) @@ -35,5 +35,5 @@ #Early return - if DiagnosticHorizAnalysisEnum() not in analyses and ThermalAnalysisEnum() not in analyses: + if StressbalanceAnalysisEnum() not in analyses and ThermalAnalysisEnum() not in analyses: return md Index: /issm/trunk-jpl/src/m/classes/initialization.m =================================================================== --- /issm/trunk-jpl/src/m/classes/initialization.m (revision 15770) +++ /issm/trunk-jpl/src/m/classes/initialization.m (revision 15771) @@ -30,5 +30,5 @@ end % }}} function md = checkconsistency(obj,md,solution,analyses) % {{{ - if ismember(DiagnosticHorizAnalysisEnum(),analyses) + if ismember(StressbalanceAnalysisEnum(),analyses) if ~(isnan(md.initialization.vx) | isnan(md.initialization.vy)), md = checkfield(md,'initialization.vx','NaN',1,'size',[md.mesh.numberofvertices 1]); Index: /issm/trunk-jpl/src/m/classes/initialization.py =================================================================== --- /issm/trunk-jpl/src/m/classes/initialization.py (revision 15770) +++ /issm/trunk-jpl/src/m/classes/initialization.py (revision 15771) @@ -48,5 +48,5 @@ #}}} def checkconsistency(self,md,solution,analyses): # {{{ - if DiagnosticHorizAnalysisEnum() in analyses: + if StressbalanceAnalysisEnum() 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]) Index: /issm/trunk-jpl/src/m/classes/model/model.m =================================================================== --- /issm/trunk-jpl/src/m/classes/model/model.m (revision 15770) +++ /issm/trunk-jpl/src/m/classes/model/model.m (revision 15771) @@ -29,5 +29,5 @@ balancethickness = 0; - diagnostic = 0; + stressbalance = 0; groundingline = 0; hydrology = 0; @@ -84,6 +84,6 @@ end %2013 April 12 - if numel(md.diagnostic.loadingforce==1) - md.diagnostic.loadingforce=0*ones(md.mesh.numberofvertices,3); + if numel(md.stressbalance.loadingforce==1) + md.stressbalance.loadingforce=0*ones(md.mesh.numberofvertices,3); end %2013 April 17 @@ -91,12 +91,4 @@ disp('Recovering old hydrology class'); md.hydrology=hydrologyshreve(md.materials); - end - %2013 July 25th - if isa(md.diagnostic,'diagnostic'), - disp('Recovering old stressbalance class'); - icefront = md.diagnostic.icefront; - md.diagnostic=stressbalance(md.diagnostic); - md.mask.icelevelset=ones(md.mesh.numberofvertices,1); - md.mask.icelevelset(icefront(:,1:end-2))=0; end end% }}} @@ -184,9 +176,9 @@ %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.diagnostic.loadingforce=project2d(md,md.diagnostic.loadingforce,md.mesh.numberoflayers); + md.stressbalance.spcvx=project2d(md,md.stressbalance.spcvx,md.mesh.numberoflayers); + md.stressbalance.spcvy=project2d(md,md.stressbalance.spcvy,md.mesh.numberoflayers); + md.stressbalance.spcvz=project2d(md,md.stressbalance.spcvz,md.mesh.numberoflayers); + md.stressbalance.referential=project2d(md,md.stressbalance.referential,md.mesh.numberoflayers); + md.stressbalance.loadingforce=project2d(md,md.stressbalance.loadingforce,md.mesh.numberoflayers); md.masstransport.spcthickness=project2d(md,md.masstransport.spcthickness,md.mesh.numberoflayers); md.thermal.spctemperature=project2d(md,md.thermal.spctemperature,md.mesh.numberoflayers); @@ -442,9 +434,9 @@ %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,:)); + if ~isnan(md2.stressbalance.vertex_pairing), + for i=1:size(md1.stressbalance.vertex_pairing,1); + md2.stressbalance.vertex_pairing(i,:)=Pnode(md1.stressbalance.vertex_pairing(i,:)); end - md2.diagnostic.vertex_pairing=md2.diagnostic.vertex_pairing(find(md2.diagnostic.vertex_pairing(:,1)),:); + md2.stressbalance.vertex_pairing=md2.stressbalance.vertex_pairing(find(md2.stressbalance.vertex_pairing(:,1)),:); end if ~isnan(md2.masstransport.vertex_pairing), @@ -480,11 +472,11 @@ 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.stressbalance.spcvx)>1 & numel(md1.stressbalance.spcvy)>2 & numel(md1.stressbalance.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); + md2.stressbalance.spcvx(nodestoflag2)=md2.inversion.vx_obs(nodestoflag2); + md2.stressbalance.spcvy(nodestoflag2)=md2.inversion.vy_obs(nodestoflag2); else - md2.diagnostic.spcvx(nodestoflag2)=NaN; - md2.diagnostic.spcvy(nodestoflag2)=NaN; + md2.stressbalance.spcvx(nodestoflag2)=NaN; + md2.stressbalance.spcvy(nodestoflag2)=NaN; disp(' ') disp('!! extract warning: spc values should be checked !!') @@ -492,5 +484,5 @@ end %put 0 for vz - md2.diagnostic.spcvz(nodestoflag2)=0; + md2.stressbalance.spcvz(nodestoflag2)=0; end if ~isnan(md1.thermal.spctemperature), @@ -711,12 +703,12 @@ %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.stressbalance.spcvx=project3d(md,'vector',md.stressbalance.spcvx,'type','node'); + md.stressbalance.spcvy=project3d(md,'vector',md.stressbalance.spcvy,'type','node'); + md.stressbalance.spcvz=project3d(md,'vector',md.stressbalance.spcvz,'type','node'); md.thermal.spctemperature=project3d(md,'vector',md.thermal.spctemperature,'type','node','layer',md.mesh.numberoflayers,'padding',NaN); md.masstransport.spcthickness=project3d(md,'vector',md.masstransport.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'); - md.diagnostic.loadingforce=project3d(md,'vector',md.diagnostic.loadingforce,'type','node'); + md.stressbalance.referential=project3d(md,'vector',md.stressbalance.referential,'type','node'); + md.stressbalance.loadingforce=project3d(md,'vector',md.stressbalance.loadingforce,'type','node'); %connectivity @@ -864,5 +856,5 @@ if isfield(structmd,'eps_rel'), md.steadystate.reltol=structmd.eps_rel; end if isfield(structmd,'max_steadystate_iterations'), md.steadystate.maxiter=structmd.max_steadystate_iterations; end - if isfield(structmd,'isdiagnostic'), md.transient.isdiagnostic=structmd.isdiagnostic; end + if isfield(structmd,'isdiagnostic'), md.transient.isstressbalance=structmd.isdiagnostic; end if isfield(structmd,'isprognostic'), md.transient.ismasstransport=structmd.isprognostic; end if isfield(structmd,'isthermal'), md.transient.isthermal=structmd.isthermal; end @@ -929,6 +921,5 @@ if isfield(structmd,'z'), md.mesh.z=structmd.z; end if isfield(structmd,'mask'), md.flaim.criterion=structmd.mask; end - if isfield(structmd,'pressureload'), md.diagnostic.icefront=structmd.pressureload; end - if isfield(structmd,'diagnostic_ref'), md.diagnostic.referential=structmd.diagnostic_ref; end + if isfield(structmd,'diagnostic_ref'), md.stressbalance.referential=structmd.diagnostic_ref; end if isfield(structmd,'npart'); md.qmu.numberofpartitions=structmd.npart; end if isfield(structmd,'part'); md.qmu.partition=structmd.part; end @@ -944,28 +935,28 @@ if isfield(structmd,'spcvelocity'), - md.diagnostic.spcvx=NaN*ones(md.mesh.numberofvertices,1); - md.diagnostic.spcvy=NaN*ones(md.mesh.numberofvertices,1); - md.diagnostic.spcvz=NaN*ones(md.mesh.numberofvertices,1); - pos=find(structmd.spcvelocity(:,1)); md.diagnostic.spcvx(pos)=structmd.spcvelocity(pos,4); - pos=find(structmd.spcvelocity(:,2)); md.diagnostic.spcvy(pos)=structmd.spcvelocity(pos,5); - pos=find(structmd.spcvelocity(:,3)); md.diagnostic.spcvz(pos)=structmd.spcvelocity(pos,6); + md.stressbalance.spcvx=NaN*ones(md.mesh.numberofvertices,1); + md.stressbalance.spcvy=NaN*ones(md.mesh.numberofvertices,1); + md.stressbalance.spcvz=NaN*ones(md.mesh.numberofvertices,1); + pos=find(structmd.spcvelocity(:,1)); md.stressbalance.spcvx(pos)=structmd.spcvelocity(pos,4); + pos=find(structmd.spcvelocity(:,2)); md.stressbalance.spcvy(pos)=structmd.spcvelocity(pos,5); + pos=find(structmd.spcvelocity(:,3)); md.stressbalance.spcvz(pos)=structmd.spcvelocity(pos,6); end if isfield(structmd,'spcvx'), - md.diagnostic.spcvx=NaN*ones(md.mesh.numberofvertices,1); - pos=find(~isnan(structmd.spcvx)); md.diagnostic.spcvx(pos)=structmd.spcvx(pos); + md.stressbalance.spcvx=NaN*ones(md.mesh.numberofvertices,1); + pos=find(~isnan(structmd.spcvx)); md.stressbalance.spcvx(pos)=structmd.spcvx(pos); end if isfield(structmd,'spcvy'), - md.diagnostic.spcvy=NaN*ones(md.mesh.numberofvertices,1); - pos=find(~isnan(structmd.spcvy)); md.diagnostic.spcvy(pos)=structmd.spcvy(pos); + md.stressbalance.spcvy=NaN*ones(md.mesh.numberofvertices,1); + pos=find(~isnan(structmd.spcvy)); md.stressbalance.spcvy(pos)=structmd.spcvy(pos); end if isfield(structmd,'spcvz'), - md.diagnostic.spcvz=NaN*ones(md.mesh.numberofvertices,1); - pos=find(~isnan(structmd.spcvz)); md.diagnostic.spcvz(pos)=structmd.spcvz(pos); + md.stressbalance.spcvz=NaN*ones(md.mesh.numberofvertices,1); + pos=find(~isnan(structmd.spcvz)); md.stressbalance.spcvz(pos)=structmd.spcvz(pos); end if isfield(structmd,'pressureload'), if ~isempty(structmd.pressureload) & ismember(structmd.pressureload(end,end),[118 119 120]), - pos=find(structmd.pressureload(:,end)==120); md.diagnostic.icefront(pos,end)=0; - pos=find(structmd.pressureload(:,end)==118); md.diagnostic.icefront(pos,end)=1; - pos=find(structmd.pressureload(:,end)==119); md.diagnostic.icefront(pos,end)=2; + pos=find(structmd.pressureload(:,end)==120); md.stressbalance.icefront(pos,end)=0; + pos=find(structmd.pressureload(:,end)==118); md.stressbalance.icefront(pos,end)=1; + pos=find(structmd.pressureload(:,end)==119); md.stressbalance.icefront(pos,end)=2; end end @@ -1039,10 +1030,9 @@ md.mesh.lowerelements(1:md.mesh.numberofelements2d)=NaN; end - if ~isfield(structmd,'diagnostic_ref'); - md.diagnostic.referential=NaN*ones(md.mesh.numberofvertices,6); + md.stressbalance.referential=NaN*ones(md.mesh.numberofvertices,6); end if ~isfield(structmd,'loadingforce'); - md.diagnostic.loadingforce=0*ones(md.mesh.numberofvertices,3); + md.stressbalance.loadingforce=0*ones(md.mesh.numberofvertices,3); end @@ -1051,4 +1041,9 @@ disp('Recovering old prognostic class'); md.masstransport=masstransport(structmd.prognostic); + end + %2013 August 9 + if isfield(structmd,'diagnostic') & isa(structmd.diagnostic,'diagnostic'), + disp('Recovering old diagnostic class'); + md.stressbalance=masstransport(structmd.diagnostic); end end% }}} @@ -1075,5 +1070,5 @@ md.cluster = generic(); md.balancethickness = balancethickness(); - md.diagnostic = stressbalance(); + md.stressbalance = stressbalance(); md.hydrology = hydrologyshreve(); md.masstransport = masstransport(); @@ -1111,5 +1106,5 @@ disp(sprintf('%19s: %-22s -- %s','cluster' ,['[1x1 ' class(obj.cluster) ']'],'cluster parameters (number of cpus...)')); disp(sprintf('%19s: %-22s -- %s','balancethickness',['[1x1 ' class(obj.balancethickness) ']'],'parameters for balancethickness solution')); - disp(sprintf('%19s: %-22s -- %s','diagnostic' ,['[1x1 ' class(obj.diagnostic) ']'],'parameters for diagnostic solution')); + disp(sprintf('%19s: %-22s -- %s','stressbalance' ,['[1x1 ' class(obj.stressbalance) ']'],'parameters for stressbalance solution')); disp(sprintf('%19s: %-22s -- %s','groundingline' ,['[1x1 ' class(obj.groundingline) ']'],'parameters for groundingline solution')); disp(sprintf('%19s: %-22s -- %s','hydrology' ,['[1x1 ' class(obj.hydrology) ']'],'parameters for hydrology solution')); Index: /issm/trunk-jpl/src/m/classes/model/model.py =================================================================== --- /issm/trunk-jpl/src/m/classes/model/model.py (revision 15770) +++ /issm/trunk-jpl/src/m/classes/model/model.py (revision 15771) @@ -72,5 +72,5 @@ self.balancethickness = balancethickness() - self.diagnostic = stressbalance() + self.stressbalance = stressbalance() self.groundingline = groundingline() self.hydrology = hydrologyshreve() @@ -111,5 +111,5 @@ 'cluster',\ 'balancethickness',\ - 'diagnostic',\ + 'stressbalance',\ 'groundingline',\ 'hydrology',\ @@ -148,5 +148,5 @@ string="%s\n%s" % (string,"%19s: %-22s -- %s" % ("cluster","[%s,%s]" % ("1x1",obj.cluster.__class__.__name__),"cluster parameters (number of cpus...)")) string="%s\n%s" % (string,"%19s: %-22s -- %s" % ("balancethickness","[%s,%s]" % ("1x1",obj.balancethickness.__class__.__name__),"parameters for balancethickness solution")) - string="%s\n%s" % (string,"%19s: %-22s -- %s" % ("diagnostic","[%s,%s]" % ("1x1",obj.diagnostic.__class__.__name__),"parameters for diagnostic solution")) + string="%s\n%s" % (string,"%19s: %-22s -- %s" % ("stressbalance","[%s,%s]" % ("1x1",obj.stressbalance.__class__.__name__),"parameters for stressbalance solution")) string="%s\n%s" % (string,"%19s: %-22s -- %s" % ("groundingline","[%s,%s]" % ("1x1",obj.groundingline.__class__.__name__),"parameters for groundingline solution")) string="%s\n%s" % (string,"%19s: %-22s -- %s" % ("hydrology","[%s,%s]" % ("1x1",obj.hydrology.__class__.__name__),"parameters for hydrology solution")) @@ -344,8 +344,8 @@ #Penalties - if numpy.any(numpy.logical_not(numpy.isnan(md2.diagnostic.vertex_pairing))): - for i in xrange(numpy.size(md1.diagnostic.vertex_pairing,axis=0)): - md2.diagnostic.vertex_pairing[i,:]=Pnode[md1.diagnostic.vertex_pairing[i,:]] - md2.diagnostic.vertex_pairing=md2.diagnostic.vertex_pairing[numpy.nonzero(md2.diagnostic.vertex_pairing[:,0])[0],:] + if numpy.any(numpy.logical_not(numpy.isnan(md2.stressbalance.vertex_pairing))): + for i in xrange(numpy.size(md1.stressbalance.vertex_pairing,axis=0)): + md2.stressbalance.vertex_pairing[i,:]=Pnode[md1.stressbalance.vertex_pairing[i,:]] + md2.stressbalance.vertex_pairing=md2.stressbalance.vertex_pairing[numpy.nonzero(md2.stressbalance.vertex_pairing[:,0])[0],:] if numpy.any(numpy.logical_not(numpy.isnan(md2.masstransport.vertex_pairing))): for i in xrange(numpy.size(md1.masstransport.vertex_pairing,axis=0)): @@ -379,14 +379,14 @@ nodestoflag1=numpy.intersect1d(orphans_node,pos_node) nodestoflag2=Pnode[nodestoflag1].astype(int)-1 - if numpy.size(md1.diagnostic.spcvx)>1 and numpy.size(md1.diagnostic.spcvy)>2 and numpy.size(md1.diagnostic.spcvz)>2: + if numpy.size(md1.stressbalance.spcvx)>1 and numpy.size(md1.stressbalance.spcvy)>2 and numpy.size(md1.stressbalance.spcvz)>2: if numpy.size(md1.inversion.vx_obs)>1 and numpy.size(md1.inversion.vy_obs)>1: - md2.diagnostic.spcvx[nodestoflag2]=md2.inversion.vx_obs[nodestoflag2] - md2.diagnostic.spcvy[nodestoflag2]=md2.inversion.vy_obs[nodestoflag2] + md2.stressbalance.spcvx[nodestoflag2]=md2.inversion.vx_obs[nodestoflag2] + md2.stressbalance.spcvy[nodestoflag2]=md2.inversion.vy_obs[nodestoflag2] else: - md2.diagnostic.spcvx[nodestoflag2]=float('NaN') - md2.diagnostic.spcvy[nodestoflag2]=float('NaN') + md2.stressbalance.spcvx[nodestoflag2]=float('NaN') + md2.stressbalance.spcvy[nodestoflag2]=float('NaN') print "\n!! extract warning: spc values should be checked !!\n\n" #put 0 for vz - md2.diagnostic.spcvz[nodestoflag2]=0 + md2.stressbalance.spcvz[nodestoflag2]=0 if numpy.any(numpy.logical_not(numpy.isnan(md1.thermal.spctemperature))): md2.thermal.spctemperature[nodestoflag2,0]=1 @@ -608,12 +608,12 @@ #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.stressbalance.spcvx=project3d(md,'vector',md.stressbalance.spcvx,'type','node') + md.stressbalance.spcvy=project3d(md,'vector',md.stressbalance.spcvy,'type','node') + md.stressbalance.spcvz=project3d(md,'vector',md.stressbalance.spcvz,'type','node') md.thermal.spctemperature=project3d(md,'vector',md.thermal.spctemperature,'type','node','layer',md.mesh.numberoflayers,'padding',float('NaN')) md.masstransport.spcthickness=project3d(md,'vector',md.masstransport.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') - md.diagnostic.loadingforce=project3d(md,'vector',md.diagnostic.loadingforce,'type','node') + md.stressbalance.referential=project3d(md,'vector',md.stressbalance.referential,'type','node') + md.stressbalance.loadingforce=project3d(md,'vector',md.stressbalance.loadingforce,'type','node') #connectivity Index: /issm/trunk-jpl/src/m/classes/model/planet.m =================================================================== --- /issm/trunk-jpl/src/m/classes/model/planet.m (revision 15770) +++ /issm/trunk-jpl/src/m/classes/model/planet.m (revision 15771) @@ -39,11 +39,11 @@ md.solver = solver(); if ismumps(), - md.solver = addoptions(md.solver,DiagnosticVertAnalysisEnum(),mumpsoptions()); + md.solver = addoptions(md.solver,StressbalanceVerticalAnalysisEnum(),mumpsoptions()); else - md.solver = addoptions(md.solver,DiagnosticVertAnalysisEnum(),iluasmoptions()); + md.solver = addoptions(md.solver,StressbalanceVerticalAnalysisEnum(),iluasmoptions()); end md.cluster = generic(); md.balancethickness = balancethickness(); - md.diagnostic = diagnostic(); + md.stressbalance = stressbalance(); md.hydrology = hydrology(); md.masstransport = masstransport(); Index: /issm/trunk-jpl/src/m/classes/modellist.m =================================================================== --- /issm/trunk-jpl/src/m/classes/modellist.m (revision 15770) +++ /issm/trunk-jpl/src/m/classes/modellist.m (revision 15771) @@ -214,8 +214,8 @@ % obj=solve(obj,varargin) % where varargin is a lit of paired arguments. - % arguments can be: 'analysis_type': 'diagnostic','thermal','masstransport','transient' + % arguments can be: 'analysis_type': 'stressbalance','thermal','masstransport','transient' % % Examples: - % obj=solve(obj,'analysis_type','diagnostic'); + % obj=solve(obj,'analysis_type','stressbalance'); %recover options Index: /issm/trunk-jpl/src/m/classes/oldclasses/diagnostic.m =================================================================== --- /issm/trunk-jpl/src/m/classes/oldclasses/diagnostic.m (revision 15770) +++ /issm/trunk-jpl/src/m/classes/oldclasses/diagnostic.m (revision 15771) @@ -1,8 +1,8 @@ -%DIAGNOSTIC class definition +%STRESSBALANCE class definition % % Usage: -% diagnostic=diagnostic(); - -classdef diagnostic +% stressbalance=stressbalance(); + +classdef stressbalance properties (SetAccess=public) spcvx = NaN; @@ -45,12 +45,12 @@ end - if size(md.diagnostic.icefront,2)==3 || size(md.diagnostic.icefront,2)==5, - front=md.diagnostic.icefront; - md.diagnostic.icefront=[front 1*md.mask.elementonfloatingice(front(:,end))]; + if size(md.stressbalance.icefront,2)==3 || size(md.stressbalance.icefront,2)==5, + front=md.stressbalance.icefront; + md.stressbalance.icefront=[front 1*md.mask.elementonfloatingice(front(:,end))]; end end% }}} end methods - function obj = diagnostic(varargin) % {{{ + function obj = stressbalance(varargin) % {{{ switch nargin case 0 @@ -77,5 +77,5 @@ %coefficient to update the viscosity between each iteration of - %a diagnostic according to the following formula + %a stressbalance according to the following formula %viscosity(n)=viscosity(n)+viscosity_overshoot(viscosity(n)-viscosity(n-1)) obj.viscosity_overshoot=0; @@ -93,42 +93,42 @@ %Early return - 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.spcvy','forcing',1); - if md.mesh.dimension==3, md = checkfield(md,'diagnostic.spcvz','forcing',1); end - md = checkfield(md,'diagnostic.restol','size',[1 1],'>',0,'NaN',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 2]); - md = checkfield(md,'diagnostic.FSreconditioning','size',[1 1],'NaN',1); - md = checkfield(md,'diagnostic.viscosity_overshoot','size',[1 1],'NaN',1); + if ~ismember(StressbalanceAnalysisEnum(),analyses), return; end + %if ~ismember(StressbalanceAnalysisEnum(),analyses) | (solution==TransientSolutionEnum() & md.transient.isstressbalance==0), return; end + + md = checkfield(md,'stressbalance.spcvx','forcing',1); + md = checkfield(md,'stressbalance.spcvy','forcing',1); + if md.mesh.dimension==3, md = checkfield(md,'stressbalance.spcvz','forcing',1); end + md = checkfield(md,'stressbalance.restol','size',[1 1],'>',0,'NaN',1); + md = checkfield(md,'stressbalance.reltol','size',[1 1]); + md = checkfield(md,'stressbalance.abstol','size',[1 1]); + md = checkfield(md,'stressbalance.isnewton','numel',[1],'values',[0 1 2]); + md = checkfield(md,'stressbalance.FSreconditioning','size',[1 1],'NaN',1); + md = checkfield(md,'stressbalance.viscosity_overshoot','size',[1 1],'NaN',1); if md.mesh.dimension==2, - md = checkfield(md,'diagnostic.icefront','size',[NaN 4],'NaN',1); + md = checkfield(md,'stressbalance.icefront','size',[NaN 4],'NaN',1); else - md = checkfield(md,'diagnostic.icefront','size',[NaN 6],'NaN',1); - end - md = checkfield(md,'diagnostic.icefront(:,end)','values',[0 1 2]); - md = checkfield(md,'diagnostic.maxiter','size',[1 1],'>=',1); - md = checkfield(md,'diagnostic.referential','size',[md.mesh.numberofvertices 6]); - md = checkfield(md,'diagnostic.loadingforce','size',[md.mesh.numberofvertices 3]); - if ~isempty(md.diagnostic.requested_outputs), - md = checkfield(md,'diagnostic.requested_outputs','size',[NaN 1]); + md = checkfield(md,'stressbalance.icefront','size',[NaN 6],'NaN',1); + end + md = checkfield(md,'stressbalance.icefront(:,end)','values',[0 1 2]); + md = checkfield(md,'stressbalance.maxiter','size',[1 1],'>=',1); + md = checkfield(md,'stressbalance.referential','size',[md.mesh.numberofvertices 6]); + md = checkfield(md,'stressbalance.loadingforce','size',[md.mesh.numberofvertices 3]); + if ~isempty(md.stressbalance.requested_outputs), + md = checkfield(md,'stressbalance.requested_outputs','size',[NaN 1]); end %singular solution - if ~(any(~isnan(md.diagnostic.spcvx)) & any(~isnan(md.diagnostic.spcvy))), + if ~(any(~isnan(md.stressbalance.spcvx)) & any(~isnan(md.stressbalance.spcvy))), md = checkmessage(md,['model is not well posed (singular). You need at least one node with fixed velocity!']); end %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), - md = checkmessage(md,['Each line of diagnostic.referential should contain either only NaN values or no NaN values']); + if any(sum(isnan(md.stressbalance.referential),2)~=0 & sum(isnan(md.stressbalance.referential),2)~=6), + md = checkmessage(md,['Each line of stressbalance.referential should contain either only NaN values or no NaN values']); end %CHECK THAT THE TWO VECTORS PROVIDED ARE ORTHOGONAL - 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),2))>eps), - md = checkmessage(md,['Vectors in diagnostic.referential (columns 1 to 3 and 4 to 6) must be orthogonal']); + if any(sum(isnan(md.stressbalance.referential),2)==0), + pos=find(sum(isnan(md.stressbalance.referential),2)==0); + if any(abs(dot(md.stressbalance.referential(pos,1:3),md.stressbalance.referential(pos,4:6),2))>eps), + md = checkmessage(md,['Vectors in stressbalance.referential (columns 1 to 3 and 4 to 6) must be orthogonal']); end end @@ -136,13 +136,13 @@ if md.mesh.dimension==3 & md.flowequation.isFS, pos=find(md.mask.vertexongroundedice & md.mesh.vertexonbed); - if any(~isnan(md.diagnostic.referential(pos,:))), + if any(~isnan(md.stressbalance.referential(pos,:))), md = checkmessage(md,['no referential should be specified for basal vertices of grounded ice']); end - md = checkfield(md,'diagnostic.FSreconditioning','>',0); + md = checkfield(md,'stressbalance.FSreconditioning','>',0); end end % }}} function disp(obj) % {{{ - disp(sprintf(' Diagnostic solution parameters:')); + disp(sprintf(' Stressbalance solution parameters:')); disp(sprintf('\n %s','Convergence criteria:')); @@ -204,5 +204,5 @@ 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); + WriteData(fid,'data',data,'enum',StressbalanceIcefrontEnum(),'format','DoubleMat','mattype',3); end % }}} end Index: /issm/trunk-jpl/src/m/classes/qmu/@dakota_method/dakota_method.m =================================================================== --- /issm/trunk-jpl/src/m/classes/qmu/@dakota_method/dakota_method.m (revision 15770) +++ /issm/trunk-jpl/src/m/classes/qmu/@dakota_method/dakota_method.m (revision 15771) @@ -560,5 +560,5 @@ dm.params.initial_trust_radius=-1.; dm.params.covariance=0; - dm.params.regression_diagnostics=false; + dm.params.regression_stressbalances=false; case {'nlssol_sqp'} dm.type ='lsq'; Index: /issm/trunk-jpl/src/m/classes/qmu/@dakota_method/dmeth_params_write.m =================================================================== --- /issm/trunk-jpl/src/m/classes/qmu/@dakota_method/dmeth_params_write.m (revision 15770) +++ /issm/trunk-jpl/src/m/classes/qmu/@dakota_method/dmeth_params_write.m (revision 15771) @@ -300,5 +300,5 @@ param_write(fid,sbeg,'initial_trust_radius',' = ','\n',dm.params); param_write(fid,sbeg,'covariance',' = ','\n',dm.params); - param_write(fid,sbeg,'regression_diagnostics','','\n',dm.params); + param_write(fid,sbeg,'regression_stressbalances','','\n',dm.params); case {'nlssol_sqp'} Index: /issm/trunk-jpl/src/m/classes/steadystate.m =================================================================== --- /issm/trunk-jpl/src/m/classes/steadystate.m (revision 15770) +++ /issm/trunk-jpl/src/m/classes/steadystate.m (revision 15771) @@ -35,6 +35,6 @@ end - if isnan(md.diagnostic.reltol), - md = checkmessage(md,['for a steadystate computation, diagnostic.reltol (relative convergence criterion) must be defined!']); + if isnan(md.stressbalance.reltol), + md = checkmessage(md,['for a steadystate computation, stressbalance.reltol (relative convergence criterion) must be defined!']); end end % }}} Index: /issm/trunk-jpl/src/m/classes/steadystate.py =================================================================== --- /issm/trunk-jpl/src/m/classes/steadystate.py (revision 15770) +++ /issm/trunk-jpl/src/m/classes/steadystate.py (revision 15771) @@ -48,6 +48,6 @@ 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!") + if numpy.isnan(md.stressbalance.reltol): + md.checkmessage("for a steadystate computation, stressbalance.reltol (relative convergence criterion) must be defined!") return md Index: /issm/trunk-jpl/src/m/classes/stressbalance.m =================================================================== --- /issm/trunk-jpl/src/m/classes/stressbalance.m (revision 15770) +++ /issm/trunk-jpl/src/m/classes/stressbalance.m (revision 15771) @@ -77,35 +77,35 @@ %Early return - if ~ismember(DiagnosticHorizAnalysisEnum(),analyses), return; end + if ~ismember(StressbalanceAnalysisEnum(),analyses), return; end - 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); end - md = checkfield(md,'diagnostic.restol','size',[1 1],'>',0,'NaN',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 2]); - md = checkfield(md,'diagnostic.FSreconditioning','size',[1 1],'NaN',1); - md = checkfield(md,'diagnostic.viscosity_overshoot','size',[1 1],'NaN',1); - md = checkfield(md,'diagnostic.maxiter','size',[1 1],'>=',1); - md = checkfield(md,'diagnostic.referential','size',[md.mesh.numberofvertices 6]); - md = checkfield(md,'diagnostic.loadingforce','size',[md.mesh.numberofvertices 3]); - if ~isempty(md.diagnostic.requested_outputs), - md = checkfield(md,'diagnostic.requested_outputs','size',[NaN 1]); + md = checkfield(md,'stressbalance.spcvx','forcing',1); + md = checkfield(md,'stressbalance.spcvy','forcing',1); + if md.mesh.dimension==3, md = checkfield(md,'stressbalance.spcvz','forcing',1); end + md = checkfield(md,'stressbalance.restol','size',[1 1],'>',0,'NaN',1); + md = checkfield(md,'stressbalance.reltol','size',[1 1]); + md = checkfield(md,'stressbalance.abstol','size',[1 1]); + md = checkfield(md,'stressbalance.isnewton','numel',[1],'values',[0 1 2]); + md = checkfield(md,'stressbalance.FSreconditioning','size',[1 1],'NaN',1); + md = checkfield(md,'stressbalance.viscosity_overshoot','size',[1 1],'NaN',1); + md = checkfield(md,'stressbalance.maxiter','size',[1 1],'>=',1); + md = checkfield(md,'stressbalance.referential','size',[md.mesh.numberofvertices 6]); + md = checkfield(md,'stressbalance.loadingforce','size',[md.mesh.numberofvertices 3]); + if ~isempty(md.stressbalance.requested_outputs), + md = checkfield(md,'stressbalance.requested_outputs','size',[NaN 1]); end %singular solution - if ~(any(~isnan(md.diagnostic.spcvx)) & any(~isnan(md.diagnostic.spcvy))), + if ~(any(~isnan(md.stressbalance.spcvx)) & any(~isnan(md.stressbalance.spcvy))), md = checkmessage(md,['model is not well posed (singular). You need at least one node with fixed velocity!']); end %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), - md = checkmessage(md,['Each line of diagnostic.referential should contain either only NaN values or no NaN values']); + if any(sum(isnan(md.stressbalance.referential),2)~=0 & sum(isnan(md.stressbalance.referential),2)~=6), + md = checkmessage(md,['Each line of stressbalance.referential should contain either only NaN values or no NaN values']); end %CHECK THAT THE TWO VECTORS PROVIDED ARE ORTHOGONAL - 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),2))>eps), - md = checkmessage(md,['Vectors in diagnostic.referential (columns 1 to 3 and 4 to 6) must be orthogonal']); + if any(sum(isnan(md.stressbalance.referential),2)==0), + pos=find(sum(isnan(md.stressbalance.referential),2)==0); + if any(abs(dot(md.stressbalance.referential(pos,1:3),md.stressbalance.referential(pos,4:6),2))>eps), + md = checkmessage(md,['Vectors in stressbalance.referential (columns 1 to 3 and 4 to 6) must be orthogonal']); end end @@ -113,8 +113,8 @@ if md.mesh.dimension==3 & md.flowequation.isFS, pos=find(md.mask.vertexongroundedice & md.mesh.vertexonbed); - if any(~isnan(md.diagnostic.referential(pos,:))), + if any(~isnan(md.stressbalance.referential(pos,:))), md = checkmessage(md,['no referential should be specified for basal vertices of grounded ice']); end - md = checkfield(md,'diagnostic.FSreconditioning','>',0); + md = checkfield(md,'stressbalance.FSreconditioning','>',0); end end % }}} @@ -156,21 +156,21 @@ yts=365.0*24.0*3600.0; - WriteData(fid,'object',obj,'class','diagnostic','fieldname','spcvx','format','DoubleMat','mattype',1,'scale',1./yts,'forcinglength',md.mesh.numberofvertices+1); - WriteData(fid,'object',obj,'class','diagnostic','fieldname','spcvy','format','DoubleMat','mattype',1,'scale',1./yts,'forcinglength',md.mesh.numberofvertices+1); - WriteData(fid,'object',obj,'class','diagnostic','fieldname','spcvz','format','DoubleMat','mattype',1,'scale',1./yts,'forcinglength',md.mesh.numberofvertices+1); - WriteData(fid,'object',obj,'class','diagnostic','fieldname','restol','format','Double'); - WriteData(fid,'object',obj,'class','diagnostic','fieldname','reltol','format','Double'); - WriteData(fid,'object',obj,'class','diagnostic','fieldname','abstol','format','Double'); - WriteData(fid,'object',obj,'class','diagnostic','fieldname','isnewton','format','Integer'); - WriteData(fid,'object',obj,'class','diagnostic','fieldname','FSreconditioning','format','Double'); - WriteData(fid,'object',obj,'class','diagnostic','fieldname','viscosity_overshoot','format','Double'); - WriteData(fid,'object',obj,'class','diagnostic','fieldname','maxiter','format','Integer'); - WriteData(fid,'object',obj,'class','diagnostic','fieldname','shelf_dampening','format','Integer'); - WriteData(fid,'object',obj,'class','diagnostic','fieldname','vertex_pairing','format','DoubleMat','mattype',3); - WriteData(fid,'object',obj,'class','diagnostic','fieldname','penalty_factor','format','Double'); - WriteData(fid,'object',obj,'class','diagnostic','fieldname','rift_penalty_lock','format','Integer'); - WriteData(fid,'object',obj,'class','diagnostic','fieldname','rift_penalty_threshold','format','Integer'); - WriteData(fid,'object',obj,'class','diagnostic','fieldname','referential','format','DoubleMat','mattype',1); - WriteData(fid,'object',obj,'class','diagnostic','fieldname','requested_outputs','format','DoubleMat','mattype',3); + WriteData(fid,'object',obj,'class','stressbalance','fieldname','spcvx','format','DoubleMat','mattype',1,'scale',1./yts,'forcinglength',md.mesh.numberofvertices+1); + WriteData(fid,'object',obj,'class','stressbalance','fieldname','spcvy','format','DoubleMat','mattype',1,'scale',1./yts,'forcinglength',md.mesh.numberofvertices+1); + WriteData(fid,'object',obj,'class','stressbalance','fieldname','spcvz','format','DoubleMat','mattype',1,'scale',1./yts,'forcinglength',md.mesh.numberofvertices+1); + WriteData(fid,'object',obj,'class','stressbalance','fieldname','restol','format','Double'); + WriteData(fid,'object',obj,'class','stressbalance','fieldname','reltol','format','Double'); + WriteData(fid,'object',obj,'class','stressbalance','fieldname','abstol','format','Double'); + WriteData(fid,'object',obj,'class','stressbalance','fieldname','isnewton','format','Integer'); + WriteData(fid,'object',obj,'class','stressbalance','fieldname','FSreconditioning','format','Double'); + WriteData(fid,'object',obj,'class','stressbalance','fieldname','viscosity_overshoot','format','Double'); + WriteData(fid,'object',obj,'class','stressbalance','fieldname','maxiter','format','Integer'); + WriteData(fid,'object',obj,'class','stressbalance','fieldname','shelf_dampening','format','Integer'); + WriteData(fid,'object',obj,'class','stressbalance','fieldname','vertex_pairing','format','DoubleMat','mattype',3); + WriteData(fid,'object',obj,'class','stressbalance','fieldname','penalty_factor','format','Double'); + WriteData(fid,'object',obj,'class','stressbalance','fieldname','rift_penalty_lock','format','Integer'); + WriteData(fid,'object',obj,'class','stressbalance','fieldname','rift_penalty_threshold','format','Integer'); + WriteData(fid,'object',obj,'class','stressbalance','fieldname','referential','format','DoubleMat','mattype',1); + WriteData(fid,'object',obj,'class','stressbalance','fieldname','requested_outputs','format','DoubleMat','mattype',3); WriteData(fid,'data',obj.loadingforce(:,1),'format','DoubleMat','mattype',1,'enum',LoadingforceXEnum); WriteData(fid,'data',obj.loadingforce(:,2),'format','DoubleMat','mattype',1,'enum',LoadingforceYEnum); Index: /issm/trunk-jpl/src/m/classes/stressbalance.py =================================================================== --- /issm/trunk-jpl/src/m/classes/stressbalance.py (revision 15770) +++ /issm/trunk-jpl/src/m/classes/stressbalance.py (revision 15771) @@ -107,46 +107,46 @@ #Early return - if DiagnosticHorizAnalysisEnum() not in analyses: + if StressbalanceAnalysisEnum() not in analyses: return md - md = checkfield(md,'diagnostic.spcvx','forcing',1) - md = checkfield(md,'diagnostic.spcvy','forcing',1) + md = checkfield(md,'stressbalance.spcvx','forcing',1) + md = checkfield(md,'stressbalance.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,2]) - md = checkfield(md,'diagnostic.FSreconditioning','size',[1],'NaN',1) - md = checkfield(md,'diagnostic.viscosity_overshoot','size',[1],'NaN',1) - md = checkfield(md,'diagnostic.maxiter','size',[1],'>=',1) - md = checkfield(md,'diagnostic.referential','size',[md.mesh.numberofvertices,6]) - md = checkfield(md,'diagnostic.loadingforce','size',[md.mesh.numberofvertices,3]) - if not md.diagnostic.requested_outputs: - md = checkfield(md,'diagnostic.requested_outputs','size',[float('NaN'),1]) + md = checkfield(md,'stressbalance.spcvz','forcing',1) + md = checkfield(md,'stressbalance.restol','size',[1],'>',0) + md = checkfield(md,'stressbalance.reltol','size',[1]) + md = checkfield(md,'stressbalance.abstol','size',[1]) + md = checkfield(md,'stressbalance.isnewton','numel',[1],'values',[0,1,2]) + md = checkfield(md,'stressbalance.FSreconditioning','size',[1],'NaN',1) + md = checkfield(md,'stressbalance.viscosity_overshoot','size',[1],'NaN',1) + md = checkfield(md,'stressbalance.maxiter','size',[1],'>=',1) + md = checkfield(md,'stressbalance.referential','size',[md.mesh.numberofvertices,6]) + md = checkfield(md,'stressbalance.loadingforce','size',[md.mesh.numberofvertices,3]) + if not md.stressbalance.requested_outputs: + md = checkfield(md,'stressbalance.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)))): +# if ~any((~isnan(md.stressbalance.spcvx)+~isnan(md.stressbalance.spcvy))==2), + if not numpy.any(numpy.logical_and(numpy.logical_not(numpy.isnan(md.stressbalance.spcvx)),numpy.logical_not(numpy.isnan(md.stressbalance.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") +# if any(sum(isnan(md.stressbalance.referential),2)~=0 & sum(isnan(md.stressbalance.referential),2)~=6), + if numpy.any(numpy.logical_and(numpy.sum(numpy.isnan(md.stressbalance.referential),axis=1)!=0,numpy.sum(numpy.isnan(md.stressbalance.referential),axis=1)!=6)): + md.checkmessage("Each line of stressbalance.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] +# if any(sum(isnan(md.stressbalance.referential),2)==0), + if numpy.any(numpy.sum(numpy.isnan(md.stressbalance.referential),axis=1)==0): + pos=[i for i,item in enumerate(numpy.sum(numpy.isnan(md.stressbalance.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.any(numpy.abs(numpy.inner(md.stressbalance.referential[pos,0:2],md.stressbalance.referential[pos,3:5]).diagonal())>sys.float_info.epsilon): +# md.checkmessage("Vectors in stressbalance.referential (columns 1 to 3 and 4 to 6) must be orthogonal") + for item in md.stressbalance.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") + md.checkmessage("Vectors in stressbalance.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.isFS, if md.mesh.dimension==3 and md.flowequation.isFS: pos=numpy.nonzero(numpy.logical_and(md.mask.vertexongroundedice,md.mesh.vertexonbed)) - if numpy.any(numpy.logical_not(numpy.isnan(md.diagnostic.referential[pos,:]))): + if numpy.any(numpy.logical_not(numpy.isnan(md.stressbalance.referential[pos,:]))): md.checkmessage("no referential should be specified for basal vertices of grounded ice") @@ -157,21 +157,21 @@ yts=365.0*24.0*3600.0 - WriteData(fid,'object',self,'class','diagnostic','fieldname','spcvx','format','DoubleMat','mattype',1,'scale',1./yts,'forcinglength',md.mesh.numberofvertices+1) - WriteData(fid,'object',self,'class','diagnostic','fieldname','spcvy','format','DoubleMat','mattype',1,'scale',1./yts,'forcinglength',md.mesh.numberofvertices+1) - WriteData(fid,'object',self,'class','diagnostic','fieldname','spcvz','format','DoubleMat','mattype',1,'scale',1./yts,'forcinglength',md.mesh.numberofvertices+1) - WriteData(fid,'object',self,'class','diagnostic','fieldname','restol','format','Double') - WriteData(fid,'object',self,'class','diagnostic','fieldname','reltol','format','Double') - WriteData(fid,'object',self,'class','diagnostic','fieldname','abstol','format','Double') - WriteData(fid,'object',self,'class','diagnostic','fieldname','isnewton','format','Integer') - WriteData(fid,'object',self,'class','diagnostic','fieldname','FSreconditioning','format','Double') - WriteData(fid,'object',self,'class','diagnostic','fieldname','viscosity_overshoot','format','Double') - WriteData(fid,'object',self,'class','diagnostic','fieldname','maxiter','format','Integer') - WriteData(fid,'object',self,'class','diagnostic','fieldname','shelf_dampening','format','Integer') - WriteData(fid,'object',self,'class','diagnostic','fieldname','vertex_pairing','format','DoubleMat','mattype',3) - WriteData(fid,'object',self,'class','diagnostic','fieldname','penalty_factor','format','Double') - WriteData(fid,'object',self,'class','diagnostic','fieldname','rift_penalty_lock','format','Integer') - WriteData(fid,'object',self,'class','diagnostic','fieldname','rift_penalty_threshold','format','Integer') - WriteData(fid,'object',self,'class','diagnostic','fieldname','referential','format','DoubleMat','mattype',1) - WriteData(fid,'object',self,'class','diagnostic','fieldname','requested_outputs','format','DoubleMat','mattype',3) + WriteData(fid,'object',self,'class','stressbalance','fieldname','spcvx','format','DoubleMat','mattype',1,'scale',1./yts,'forcinglength',md.mesh.numberofvertices+1) + WriteData(fid,'object',self,'class','stressbalance','fieldname','spcvy','format','DoubleMat','mattype',1,'scale',1./yts,'forcinglength',md.mesh.numberofvertices+1) + WriteData(fid,'object',self,'class','stressbalance','fieldname','spcvz','format','DoubleMat','mattype',1,'scale',1./yts,'forcinglength',md.mesh.numberofvertices+1) + WriteData(fid,'object',self,'class','stressbalance','fieldname','restol','format','Double') + WriteData(fid,'object',self,'class','stressbalance','fieldname','reltol','format','Double') + WriteData(fid,'object',self,'class','stressbalance','fieldname','abstol','format','Double') + WriteData(fid,'object',self,'class','stressbalance','fieldname','isnewton','format','Integer') + WriteData(fid,'object',self,'class','stressbalance','fieldname','FSreconditioning','format','Double') + WriteData(fid,'object',self,'class','stressbalance','fieldname','viscosity_overshoot','format','Double') + WriteData(fid,'object',self,'class','stressbalance','fieldname','maxiter','format','Integer') + WriteData(fid,'object',self,'class','stressbalance','fieldname','shelf_dampening','format','Integer') + WriteData(fid,'object',self,'class','stressbalance','fieldname','vertex_pairing','format','DoubleMat','mattype',3) + WriteData(fid,'object',self,'class','stressbalance','fieldname','penalty_factor','format','Double') + WriteData(fid,'object',self,'class','stressbalance','fieldname','rift_penalty_lock','format','Integer') + WriteData(fid,'object',self,'class','stressbalance','fieldname','rift_penalty_threshold','format','Integer') + WriteData(fid,'object',self,'class','stressbalance','fieldname','referential','format','DoubleMat','mattype',1) + WriteData(fid,'object',self,'class','stressbalance','fieldname','requested_outputs','format','DoubleMat','mattype',3) WriteData(fid,'data',self.loadingforce[:,0],'format','DoubleMat','mattype',1,'enum',LoadingforceXEnum()) WriteData(fid,'data',self.loadingforce[:,1],'format','DoubleMat','mattype',1,'enum',LoadingforceYEnum()) Index: /issm/trunk-jpl/src/m/classes/toolkits.m =================================================================== --- /issm/trunk-jpl/src/m/classes/toolkits.m (revision 15770) +++ /issm/trunk-jpl/src/m/classes/toolkits.m (revision 15771) @@ -22,6 +22,6 @@ function obj = addoptions(obj,analysis,varargin) % {{{ % Usage example: - % md.toolkits=addoptions(md.toolkits,DiagnosticHorizAnalysisEnum(),FSoptions()); - % md.toolkits=addoptions(md.toolkits,DiagnosticHorizAnalysisEnum()); + % md.toolkits=addoptions(md.toolkits,StressbalanceAnalysisEnum(),FSoptions()); + % md.toolkits=addoptions(md.toolkits,StressbalanceAnalysisEnum()); %Convert analysis from enum to string Index: /issm/trunk-jpl/src/m/classes/toolkits.py =================================================================== --- /issm/trunk-jpl/src/m/classes/toolkits.py (revision 15770) +++ /issm/trunk-jpl/src/m/classes/toolkits.py (revision 15771) @@ -39,6 +39,6 @@ def addoptions(self,analysis,*args): # {{{ # Usage example: - # md.toolkits=addoptions(md.toolkits,DiagnosticHorizAnalysisEnum(),FSoptions()); - # md.toolkits=addoptions(md.toolkits,DiagnosticHorizAnalysisEnum()); + # md.toolkits=addoptions(md.toolkits,StressbalanceAnalysisEnum(),FSoptions()); + # md.toolkits=addoptions(md.toolkits,StressbalanceAnalysisEnum()); #Convert analysis from enum to string Index: /issm/trunk-jpl/src/m/classes/transient.m =================================================================== --- /issm/trunk-jpl/src/m/classes/transient.m (revision 15770) +++ /issm/trunk-jpl/src/m/classes/transient.m (revision 15771) @@ -7,5 +7,5 @@ properties (SetAccess=public) ismasstransport = 0; - isdiagnostic = 0; + isstressbalance = 0; isthermal = 0; isgroundingline = 0; @@ -24,7 +24,7 @@ function obj = setdefaultparameters(obj) % {{{ - %full analysis: Diagnostic, Masstransport and Thermal but no groundingline migration for now + %full analysis: Stressbalance, Masstransport and Thermal but no groundingline migration for now obj.ismasstransport=1; - obj.isdiagnostic=1; + obj.isstressbalance=1; obj.isthermal=1; obj.isgroundingline=0; @@ -38,5 +38,5 @@ md = checkfield(md,'transient.ismasstransport','numel',[1],'values',[0 1]); - md = checkfield(md,'transient.isdiagnostic','numel',[1],'values',[0 1]); + md = checkfield(md,'transient.isstressbalance','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]); @@ -49,5 +49,5 @@ fielddisplay(obj,'ismasstransport','indicates if a masstransport solution is used in the transient'); - fielddisplay(obj,'isdiagnostic','indicates if a diagnostic solution is used in the transient'); + fielddisplay(obj,'isstressbalance','indicates if a stressbalance solution is used in the transient'); fielddisplay(obj,'isthermal','indicates if a thermal solution is used in the transient'); fielddisplay(obj,'isgroundingline','indicates if a groundingline migration is used in the transient'); @@ -58,5 +58,5 @@ function marshall(obj,md,fid) % {{{ WriteData(fid,'object',obj,'fieldname','ismasstransport','format','Boolean'); - WriteData(fid,'object',obj,'fieldname','isdiagnostic','format','Boolean'); + WriteData(fid,'object',obj,'fieldname','isstressbalance','format','Boolean'); WriteData(fid,'object',obj,'fieldname','isthermal','format','Boolean'); WriteData(fid,'object',obj,'fieldname','isgroundingline','format','Boolean'); Index: /issm/trunk-jpl/src/m/classes/transient.py =================================================================== --- /issm/trunk-jpl/src/m/classes/transient.py (revision 15770) +++ /issm/trunk-jpl/src/m/classes/transient.py (revision 15771) @@ -14,5 +14,5 @@ def __init__(self): # {{{ self.ismasstransport = False - self.isdiagnostic = False + self.isstressbalance = False self.isthermal = False self.isgroundingline = False @@ -27,5 +27,5 @@ string=' transient solution parameters:' string="%s\n%s"%(string,fielddisplay(self,'ismasstransport','indicates if a masstransport 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,'isstressbalance','indicates if a stressbalance 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,'isgroundingline','indicates if a groundingline migration is used in the transient')) @@ -36,7 +36,7 @@ def setdefaultparameters(self): # {{{ - #full analysis: Diagnostic, Masstransport and Thermal but no groundingline migration for now + #full analysis: Stressbalance, Masstransport and Thermal but no groundingline migration for now self.ismasstransport=True - self.isdiagnostic=True + self.isstressbalance=True self.isthermal=True self.isgroundingline=False @@ -52,5 +52,5 @@ md = checkfield(md,'transient.ismasstransport','numel',[1],'values',[0,1]) - md = checkfield(md,'transient.isdiagnostic','numel',[1],'values',[0,1]) + md = checkfield(md,'transient.isstressbalance','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]) @@ -63,5 +63,5 @@ def marshall(self,md,fid): # {{{ WriteData(fid,'object',self,'fieldname','ismasstransport','format','Boolean') - WriteData(fid,'object',self,'fieldname','isdiagnostic','format','Boolean') + WriteData(fid,'object',self,'fieldname','isstressbalance','format','Boolean') WriteData(fid,'object',self,'fieldname','isthermal','format','Boolean') WriteData(fid,'object',self,'fieldname','isgroundingline','format','Boolean') Index: /issm/trunk-jpl/src/m/consistency/ismodelselfconsistent.m =================================================================== --- /issm/trunk-jpl/src/m/consistency/ismodelselfconsistent.m (revision 15770) +++ /issm/trunk-jpl/src/m/consistency/ismodelselfconsistent.m (revision 15771) @@ -45,11 +45,11 @@ switch solutiontype, - case DiagnosticSolutionEnum(), + case StressbalanceSolutionEnum(), numanalyses=5; - analyses=[DiagnosticHorizAnalysisEnum();DiagnosticVertAnalysisEnum();DiagnosticSIAAnalysisEnum();SurfaceSlopeAnalysisEnum();BedSlopeAnalysisEnum()]; + analyses=[StressbalanceAnalysisEnum();StressbalanceVerticalAnalysisEnum();StressbalanceSIAAnalysisEnum();SurfaceSlopeAnalysisEnum();BedSlopeAnalysisEnum()]; case SteadystateSolutionEnum(), numanalyses=7; - analyses=[DiagnosticHorizAnalysisEnum();DiagnosticVertAnalysisEnum();DiagnosticSIAAnalysisEnum();SurfaceSlopeAnalysisEnum();BedSlopeAnalysisEnum();ThermalAnalysisEnum();MeltingAnalysisEnum()]; + analyses=[StressbalanceAnalysisEnum();StressbalanceVerticalAnalysisEnum();StressbalanceSIAAnalysisEnum();SurfaceSlopeAnalysisEnum();BedSlopeAnalysisEnum();ThermalAnalysisEnum();MeltingAnalysisEnum()]; case ThermalSolutionEnum(), @@ -87,5 +87,5 @@ case TransientSolutionEnum(), numanalyses=9; - analyses=[DiagnosticHorizAnalysisEnum();DiagnosticVertAnalysisEnum();DiagnosticSIAAnalysisEnum();SurfaceSlopeAnalysisEnum();BedSlopeAnalysisEnum();ThermalAnalysisEnum();MeltingAnalysisEnum();EnthalpyAnalysisEnum();MasstransportAnalysisEnum()]; + analyses=[StressbalanceAnalysisEnum();StressbalanceVerticalAnalysisEnum();StressbalanceSIAAnalysisEnum();SurfaceSlopeAnalysisEnum();BedSlopeAnalysisEnum();ThermalAnalysisEnum();MeltingAnalysisEnum();EnthalpyAnalysisEnum();MasstransportAnalysisEnum()]; case FlaimSolutionEnum(), Index: /issm/trunk-jpl/src/m/consistency/ismodelselfconsistent.py =================================================================== --- /issm/trunk-jpl/src/m/consistency/ismodelselfconsistent.py (revision 15770) +++ /issm/trunk-jpl/src/m/consistency/ismodelselfconsistent.py (revision 15771) @@ -10,11 +10,11 @@ """ - if solutiontype == DiagnosticSolutionEnum(): + if solutiontype == StressbalanceSolutionEnum(): numanalyses=5 - analyses=[DiagnosticHorizAnalysisEnum(),DiagnosticVertAnalysisEnum(),DiagnosticSIAAnalysisEnum(),SurfaceSlopeAnalysisEnum(),BedSlopeAnalysisEnum()] + analyses=[StressbalanceAnalysisEnum(),StressbalanceVerticalAnalysisEnum(),StressbalanceSIAAnalysisEnum(),SurfaceSlopeAnalysisEnum(),BedSlopeAnalysisEnum()] elif solutiontype == SteadystateSolutionEnum(): numanalyses=7 - analyses=[DiagnosticHorizAnalysisEnum(),DiagnosticVertAnalysisEnum(),DiagnosticSIAAnalysisEnum(),SurfaceSlopeAnalysisEnum(),BedSlopeAnalysisEnum(),ThermalAnalysisEnum(),MeltingAnalysisEnum()] + analyses=[StressbalanceAnalysisEnum(),StressbalanceVerticalAnalysisEnum(),StressbalanceSIAAnalysisEnum(),SurfaceSlopeAnalysisEnum(),BedSlopeAnalysisEnum(),ThermalAnalysisEnum(),MeltingAnalysisEnum()] elif solutiontype == ThermalSolutionEnum(): @@ -48,5 +48,5 @@ elif solutiontype == TransientSolutionEnum(): numanalyses=9 - analyses=[DiagnosticHorizAnalysisEnum(),DiagnosticVertAnalysisEnum(),DiagnosticSIAAnalysisEnum(),SurfaceSlopeAnalysisEnum(),BedSlopeAnalysisEnum(),ThermalAnalysisEnum(),MeltingAnalysisEnum(),EnthalpyAnalysisEnum(),MasstransportAnalysisEnum()] + analyses=[StressbalanceAnalysisEnum(),StressbalanceVerticalAnalysisEnum(),StressbalanceSIAAnalysisEnum(),SurfaceSlopeAnalysisEnum(),BedSlopeAnalysisEnum(),ThermalAnalysisEnum(),MeltingAnalysisEnum(),EnthalpyAnalysisEnum(),MasstransportAnalysisEnum()] elif solutiontype == FlaimSolutionEnum(): Index: /issm/trunk-jpl/src/m/contrib/hack/tres.m =================================================================== --- /issm/trunk-jpl/src/m/contrib/hack/tres.m (revision 15770) +++ /issm/trunk-jpl/src/m/contrib/hack/tres.m (revision 15771) @@ -4,25 +4,25 @@ % Usage: md=tres(md,string) % -% Example: md=tres(md,'diagnostic'); +% Example: md=tres(md,'stressbalance'); %check number of arguments -if strcmpi(string,'diagnostic'), +if strcmpi(string,'stressbalance'), if md.mesh.dimension==2, - md.initialization.vx=md.results.DiagnosticSolution.Vx; - md.initialization.vy=md.results.DiagnosticSolution.Vy; + md.initialization.vx=md.results.StressbalanceSolution.Vx; + md.initialization.vy=md.results.StressbalanceSolution.Vy; else - md.initialization.vx=md.results.DiagnosticSolution.Vx; - md.initialization.vy=md.results.DiagnosticSolution.Vy; - md.initialization.vz=md.results.DiagnosticSolution.Vz; + md.initialization.vx=md.results.StressbalanceSolution.Vx; + md.initialization.vy=md.results.StressbalanceSolution.Vy; + md.initialization.vz=md.results.StressbalanceSolution.Vz; end - md.initialization.vel=md.results.DiagnosticSolution.Vel; + md.initialization.vel=md.results.StressbalanceSolution.Vel; - if isfield(md.results.DiagnosticSolution,'Pressure'), - md.initialization.pressure=md.results.DiagnosticSolution.Pressure; + if isfield(md.results.StressbalanceSolution,'Pressure'), + md.initialization.pressure=md.results.StressbalanceSolution.Pressure; end if ~isempty(md.rifts.riftstruct), - if isfield(md.results.DiagnosticSolution,'riftproperties'), - md.rifts.riftproperties=md.results.DiagnosticSolution.riftproperties; + if isfield(md.results.StressbalanceSolution,'riftproperties'), + md.rifts.riftproperties=md.results.StressbalanceSolution.riftproperties; end end Index: /issm/trunk-jpl/src/m/contrib/massbalance/contourmassbalance.m =================================================================== --- /issm/trunk-jpl/src/m/contrib/massbalance/contourmassbalance.m (revision 15770) +++ /issm/trunk-jpl/src/m/contrib/massbalance/contourmassbalance.m (revision 15771) @@ -19,5 +19,5 @@ %Get segments enveloping contour segments=contourenvelope(md,file); -%md.diagnostic.icefront=segments; plotmodel(md,'data','pressureload','expdisp',file); +%md.stressbalance.icefront=segments; plotmodel(md,'data','pressureload','expdisp',file); %get flag list of elements and nodes inside the contour Index: /issm/trunk-jpl/src/m/enum/EnumDefinitions.py =================================================================== --- /issm/trunk-jpl/src/m/enum/EnumDefinitions.py (revision 15770) +++ /issm/trunk-jpl/src/m/enum/EnumDefinitions.py (revision 15771) @@ -41,23 +41,23 @@ def ConstantsYtsEnum(): return StringToEnum("ConstantsYts")[0] def DependentObjectEnum(): return StringToEnum("DependentObject")[0] -def DiagnosticAbstolEnum(): return StringToEnum("DiagnosticAbstol")[0] -def DiagnosticIcefrontEnum(): return StringToEnum("DiagnosticIcefront")[0] -def DiagnosticIsnewtonEnum(): return StringToEnum("DiagnosticIsnewton")[0] -def DiagnosticMaxiterEnum(): return StringToEnum("DiagnosticMaxiter")[0] -def DiagnosticNumRequestedOutputsEnum(): return StringToEnum("DiagnosticNumRequestedOutputs")[0] -def DiagnosticPenaltyFactorEnum(): return StringToEnum("DiagnosticPenaltyFactor")[0] -def DiagnosticReferentialEnum(): return StringToEnum("DiagnosticReferential")[0] -def DiagnosticReltolEnum(): return StringToEnum("DiagnosticReltol")[0] -def DiagnosticRequestedOutputsEnum(): return StringToEnum("DiagnosticRequestedOutputs")[0] -def DiagnosticRestolEnum(): return StringToEnum("DiagnosticRestol")[0] -def DiagnosticRiftPenaltyLockEnum(): return StringToEnum("DiagnosticRiftPenaltyLock")[0] -def DiagnosticRiftPenaltyThresholdEnum(): return StringToEnum("DiagnosticRiftPenaltyThreshold")[0] -def DiagnosticShelfDampeningEnum(): return StringToEnum("DiagnosticShelfDampening")[0] -def DiagnosticSpcvxEnum(): return StringToEnum("DiagnosticSpcvx")[0] -def DiagnosticSpcvyEnum(): return StringToEnum("DiagnosticSpcvy")[0] -def DiagnosticSpcvzEnum(): return StringToEnum("DiagnosticSpcvz")[0] -def DiagnosticFSreconditioningEnum(): return StringToEnum("DiagnosticFSreconditioning")[0] -def DiagnosticVertexPairingEnum(): return StringToEnum("DiagnosticVertexPairing")[0] -def DiagnosticViscosityOvershootEnum(): return StringToEnum("DiagnosticViscosityOvershoot")[0] +def StressbalanceAbstolEnum(): return StringToEnum("StressbalanceAbstol")[0] +def StressbalanceIcefrontEnum(): return StringToEnum("StressbalanceIcefront")[0] +def StressbalanceIsnewtonEnum(): return StringToEnum("StressbalanceIsnewton")[0] +def StressbalanceMaxiterEnum(): return StringToEnum("StressbalanceMaxiter")[0] +def StressbalanceNumRequestedOutputsEnum(): return StringToEnum("StressbalanceNumRequestedOutputs")[0] +def StressbalancePenaltyFactorEnum(): return StringToEnum("StressbalancePenaltyFactor")[0] +def StressbalanceReferentialEnum(): return StringToEnum("StressbalanceReferential")[0] +def StressbalanceReltolEnum(): return StringToEnum("StressbalanceReltol")[0] +def StressbalanceRequestedOutputsEnum(): return StringToEnum("StressbalanceRequestedOutputs")[0] +def StressbalanceRestolEnum(): return StringToEnum("StressbalanceRestol")[0] +def StressbalanceRiftPenaltyLockEnum(): return StringToEnum("StressbalanceRiftPenaltyLock")[0] +def StressbalanceRiftPenaltyThresholdEnum(): return StringToEnum("StressbalanceRiftPenaltyThreshold")[0] +def StressbalanceShelfDampeningEnum(): return StringToEnum("StressbalanceShelfDampening")[0] +def StressbalanceSpcvxEnum(): return StringToEnum("StressbalanceSpcvx")[0] +def StressbalanceSpcvyEnum(): return StringToEnum("StressbalanceSpcvy")[0] +def StressbalanceSpcvzEnum(): return StringToEnum("StressbalanceSpcvz")[0] +def StressbalanceFSreconditioningEnum(): return StringToEnum("StressbalanceFSreconditioning")[0] +def StressbalanceVertexPairingEnum(): return StringToEnum("StressbalanceVertexPairing")[0] +def StressbalanceViscosityOvershootEnum(): return StringToEnum("StressbalanceViscosityOvershoot")[0] def LoadingforceXEnum(): return StringToEnum("LoadingforceX")[0] def LoadingforceYEnum(): return StringToEnum("LoadingforceY")[0] @@ -254,5 +254,5 @@ def TimesteppingTimeAdaptEnum(): return StringToEnum("TimesteppingTimeAdapt")[0] def TimesteppingTimeStepEnum(): return StringToEnum("TimesteppingTimeStep")[0] -def TransientIsdiagnosticEnum(): return StringToEnum("TransientIsdiagnostic")[0] +def TransientIsstressbalanceEnum(): return StringToEnum("TransientIsstressbalance")[0] def TransientIsgroundinglineEnum(): return StringToEnum("TransientIsgroundingline")[0] def TransientIsmasstransportEnum(): return StringToEnum("TransientIsmasstransport")[0] @@ -278,8 +278,8 @@ def BedSlopeXAnalysisEnum(): return StringToEnum("BedSlopeXAnalysis")[0] def BedSlopeYAnalysisEnum(): return StringToEnum("BedSlopeYAnalysis")[0] -def DiagnosticHorizAnalysisEnum(): return StringToEnum("DiagnosticHorizAnalysis")[0] -def DiagnosticSIAAnalysisEnum(): return StringToEnum("DiagnosticSIAAnalysis")[0] -def DiagnosticSolutionEnum(): return StringToEnum("DiagnosticSolution")[0] -def DiagnosticVertAnalysisEnum(): return StringToEnum("DiagnosticVertAnalysis")[0] +def StressbalanceAnalysisEnum(): return StringToEnum("StressbalanceAnalysis")[0] +def StressbalanceSIAAnalysisEnum(): return StringToEnum("StressbalanceSIAAnalysis")[0] +def StressbalanceSolutionEnum(): return StringToEnum("StressbalanceSolution")[0] +def StressbalanceVerticalAnalysisEnum(): return StringToEnum("StressbalanceVerticalAnalysis")[0] def EnthalpyAnalysisEnum(): return StringToEnum("EnthalpyAnalysis")[0] def EnthalpySolutionEnum(): return StringToEnum("EnthalpySolution")[0] Index: /issm/trunk-jpl/src/m/inversions/MisfitDeinterlace.m =================================================================== --- /issm/trunk-jpl/src/m/inversions/MisfitDeinterlace.m (revision 15770) +++ /issm/trunk-jpl/src/m/inversions/MisfitDeinterlace.m (revision 15771) @@ -6,5 +6,5 @@ % % Example: -% Jstruct=MisfitDeinterlace(md.results.diagnostic.J,md.fit) +% Jstruct=MisfitDeinterlace(md.results.stressbalance.J,md.fit) % % Index: /issm/trunk-jpl/src/m/mech/cfl_step.m =================================================================== --- /issm/trunk-jpl/src/m/mech/cfl_step.m (revision 15770) +++ /issm/trunk-jpl/src/m/mech/cfl_step.m (revision 15771) @@ -8,5 +8,5 @@ % % Example: -% dt=cfl_step(md,md.results.DiagnosticSolution.Vx,md.results.DiagnosticSolution.Vy) +% dt=cfl_step(md,md.results.StressbalanceSolution.Vx,md.results.StressbalanceSolution.Vy) %Check length of velocities Index: /issm/trunk-jpl/src/m/miscellaneous/issmdoc.m =================================================================== --- /issm/trunk-jpl/src/m/miscellaneous/issmdoc.m (revision 15770) +++ /issm/trunk-jpl/src/m/miscellaneous/issmdoc.m (revision 15771) @@ -12,4 +12,4 @@ disp(sprintf('%-63s %s',' md=parameterize(md,''Square.par'');','%fills all the other fields of the model')); disp(sprintf('%-63s %s',' md=setflowequation(md,''SSA'',''all'');','%defines all elements as SSA''s SSA')); -disp(sprintf('%-63s %s',' md=solve(md,DiagnosticSolutionEnum());','%solve for stress balance')); -disp(sprintf('%-63s %s',' plotmodel(md,''data'',md.results.DiagnosticSolution.Vel);','%displays the velocity (type plotdoc for plotmodel help)')); +disp(sprintf('%-63s %s',' md=solve(md,StressbalanceSolutionEnum());','%solve for stress balance')); +disp(sprintf('%-63s %s',' plotmodel(md,''data'',md.results.StressbalanceSolution.Vel);','%displays the velocity (type plotdoc for plotmodel help)')); Index: /issm/trunk-jpl/src/m/parameterization/setflowequation.m =================================================================== --- /issm/trunk-jpl/src/m/parameterization/setflowequation.m (revision 15770) +++ /issm/trunk-jpl/src/m/parameterization/setflowequation.m (revision 15771) @@ -97,5 +97,5 @@ %First modify FSflag to get rid of elements contrained everywhere (spc + border with HO or SSA) if any(FSflag), - fullspcnodes=double((~isnan(md.diagnostic.spcvx)+~isnan(md.diagnostic.spcvy)+~isnan(md.diagnostic.spcvz))==3 | (nodeonHO & nodeonFS)); %find all the nodes on the boundary of the domain without icefront + fullspcnodes=double((~isnan(md.stressbalance.spcvx)+~isnan(md.stressbalance.spcvy)+~isnan(md.stressbalance.spcvz))==3 | (nodeonHO & nodeonFS)); %find all the nodes on the boundary of the domain without icefront fullspcelems=double(sum(fullspcnodes(md.mesh.elements),2)==6); %find all the nodes on the boundary of the domain without icefront FSflag(find(fullspcelems))=0; @@ -117,5 +117,5 @@ %Now take care of the coupling between SSA and HO -md.diagnostic.vertex_pairing=[]; +md.stressbalance.vertex_pairing=[]; nodeonSSAHO=zeros(md.mesh.numberofvertices,1); nodeonHOFS=zeros(md.mesh.numberofvertices,1); @@ -136,5 +136,5 @@ penalties=[penalties; [bordernodes2d bordernodes2d+md.mesh.numberofvertices2d*(i)]]; end - md.diagnostic.vertex_pairing=penalties; + md.stressbalance.vertex_pairing=penalties; end elseif strcmpi(coupling_method,'tiling'), Index: /issm/trunk-jpl/src/m/parameterization/setflowequation.py =================================================================== --- /issm/trunk-jpl/src/m/parameterization/setflowequation.py (revision 15770) +++ /issm/trunk-jpl/src/m/parameterization/setflowequation.py (revision 15771) @@ -91,8 +91,8 @@ #First modify FSflag to get rid of elements contrained everywhere (spc + border with HO or SSA) if any(FSflag): -# fullspcnodes=double((~isnan(md.diagnostic.spcvx)+~isnan(md.diagnostic.spcvy)+~isnan(md.diagnostic.spcvz))==3 | (nodeonHO & nodeonFS)); %find all the nodes on the boundary of the domain without icefront - fullspcnodes=numpy.logical_or(numpy.logical_not(numpy.isnan(md.diagnostic.spcvx)).astype(int)+ \ - numpy.logical_not(numpy.isnan(md.diagnostic.spcvy)).astype(int)+ \ - numpy.logical_not(numpy.isnan(md.diagnostic.spcvz)).astype(int)==3, \ +# fullspcnodes=double((~isnan(md.stressbalance.spcvx)+~isnan(md.stressbalance.spcvy)+~isnan(md.stressbalance.spcvz))==3 | (nodeonHO & nodeonFS)); %find all the nodes on the boundary of the domain without icefront + fullspcnodes=numpy.logical_or(numpy.logical_not(numpy.isnan(md.stressbalance.spcvx)).astype(int)+ \ + numpy.logical_not(numpy.isnan(md.stressbalance.spcvy)).astype(int)+ \ + numpy.logical_not(numpy.isnan(md.stressbalance.spcvz)).astype(int)==3, \ numpy.logical_and(nodeonHO,nodeonFS).reshape(-1,1)).astype(int) #find all the nodes on the boundary of the domain without icefront # fullspcelems=double(sum(fullspcnodes(md.mesh.elements),2)==6); %find all the nodes on the boundary of the domain without icefront @@ -113,5 +113,5 @@ #Now take care of the coupling between SSA and HO - md.diagnostic.vertex_pairing=numpy.array([]) + md.stressbalance.vertex_pairing=numpy.array([]) nodeonSSAHO=numpy.zeros(md.mesh.numberofvertices,bool) nodeonHOFS=numpy.zeros(md.mesh.numberofvertices,bool) @@ -131,5 +131,5 @@ for i in xrange(1,numlayers): penalties=numpy.vstack((penalties,numpy.hstack((bordernodes2d.reshape(-1,1),bordernodes2d.reshape(-1,1)+md.mesh.numberofvertices2d*(i))))) - md.diagnostic.vertex_pairing=penalties + md.stressbalance.vertex_pairing=penalties elif strcmpi(coupling_method,'tiling'): Index: /issm/trunk-jpl/src/m/plot/plot_BC.m =================================================================== --- /issm/trunk-jpl/src/m/plot/plot_BC.m (revision 15770) +++ /issm/trunk-jpl/src/m/plot/plot_BC.m (revision 15771) @@ -10,17 +10,17 @@ if strcmpi(dirichleton,'on'), h1=plot3(... - md.mesh.x(find(~isnan(md.diagnostic.spcvx(1:md.mesh.numberofvertices,1)))),... - md.mesh.y(find(~isnan(md.diagnostic.spcvx(1:md.mesh.numberofvertices,1)))),... - md.mesh.z(find(~isnan(md.diagnostic.spcvx(1:md.mesh.numberofvertices,1)))),... + md.mesh.x(find(~isnan(md.stressbalance.spcvx(1:md.mesh.numberofvertices,1)))),... + md.mesh.y(find(~isnan(md.stressbalance.spcvx(1:md.mesh.numberofvertices,1)))),... + md.mesh.z(find(~isnan(md.stressbalance.spcvx(1:md.mesh.numberofvertices,1)))),... 'ro','MarkerSize',14,'MarkerFaceColor','r'); h2=plot3(... - md.mesh.x(find(~isnan(md.diagnostic.spcvy(1:md.mesh.numberofvertices,1)))),... - md.mesh.y(find(~isnan(md.diagnostic.spcvy(1:md.mesh.numberofvertices,1)))),... - md.mesh.z(find(~isnan(md.diagnostic.spcvy(1:md.mesh.numberofvertices,1)))),... + md.mesh.x(find(~isnan(md.stressbalance.spcvy(1:md.mesh.numberofvertices,1)))),... + md.mesh.y(find(~isnan(md.stressbalance.spcvy(1:md.mesh.numberofvertices,1)))),... + md.mesh.z(find(~isnan(md.stressbalance.spcvy(1:md.mesh.numberofvertices,1)))),... 'bo','MarkerSize',10,'MarkerFaceColor','b'); h3=plot3(... - md.mesh.x(find(~isnan(md.diagnostic.spcvz(1:md.mesh.numberofvertices,1)))),... - md.mesh.y(find(~isnan(md.diagnostic.spcvz(1:md.mesh.numberofvertices,1)))),... - md.mesh.z(find(~isnan(md.diagnostic.spcvz(1:md.mesh.numberofvertices,1)))),... + md.mesh.x(find(~isnan(md.stressbalance.spcvz(1:md.mesh.numberofvertices,1)))),... + md.mesh.y(find(~isnan(md.stressbalance.spcvz(1:md.mesh.numberofvertices,1)))),... + md.mesh.z(find(~isnan(md.stressbalance.spcvz(1:md.mesh.numberofvertices,1)))),... 'yo','MarkerSize',6 ,'MarkerFaceColor','y'); end Index: /issm/trunk-jpl/src/m/plot/plot_referential.m =================================================================== --- /issm/trunk-jpl/src/m/plot/plot_referential.m (revision 15770) +++ /issm/trunk-jpl/src/m/plot/plot_referential.m (revision 15771) @@ -12,7 +12,7 @@ %process mesh and data [x y z elements is2d isplanet]=processmesh(md,[],options); -referential=md.diagnostic.referential; +referential=md.stressbalance.referential; -Xhat=md.diagnostic.referential(:,1:3); +Xhat=md.stressbalance.referential(:,1:3); pos=find(sum(isnan(Xhat),2)); Xhat(pos,:)=repmat([1 0 0],size(pos,1),1); @@ -20,5 +20,5 @@ Xhat=Xhat./[Xhatnorm Xhatnorm Xhatnorm]; -Zhat=md.diagnostic.referential(:,4:6); +Zhat=md.stressbalance.referential(:,4:6); pos=find(sum(isnan(Zhat),2)); Zhat(pos,:)=repmat([0 0 1],size(pos,1),1); @@ -87,5 +87,5 @@ %apply options -options=addfielddefault(options,'title','Diagnostic referential'); +options=addfielddefault(options,'title','Stressbalance referential'); options=addfielddefault(options,'colorbar',0); applyoptions(md,[],options); Index: /issm/trunk-jpl/src/m/plot/plotdoc.m =================================================================== --- /issm/trunk-jpl/src/m/plot/plotdoc.m (revision 15770) +++ /issm/trunk-jpl/src/m/plot/plotdoc.m (revision 15771) @@ -27,5 +27,5 @@ disp(' - ''highlightvertices'': to highlight vertices (use highlight option to enter the vertex list'); disp(' - ''mesh'': draw mesh using trisurf'); -disp(' - ''referential'': diagnostic referential'); +disp(' - ''referential'': stressbalance referential'); disp(' - ''riftvel'': velocities along rifts'); disp(' - ''riftrelvel'': relative velocities along rifts'); Index: /issm/trunk-jpl/src/m/qmu/dakota_m_write.m =================================================================== --- /issm/trunk-jpl/src/m/qmu/dakota_m_write.m (revision 15770) +++ /issm/trunk-jpl/src/m/qmu/dakota_m_write.m (revision 15771) @@ -207,5 +207,5 @@ fprintf(fidm,'%% Run the solution.\n\n'); -fprintf(fidm,['\tmd=solve(md,''diagnostic'',''' package ''');\n\n']); +fprintf(fidm,['\tmd=solve(md,''stressbalance'',''' package ''');\n\n']); end Index: /issm/trunk-jpl/src/m/qmu/examples/direct.m =================================================================== --- /issm/trunk-jpl/src/m/qmu/examples/direct.m (revision 15770) +++ /issm/trunk-jpl/src/m/qmu/examples/direct.m (revision 15771) @@ -1,5 +1,5 @@ %using library mode of Dakota, only for parallel runs. md.qmu.params.direct=true; -md.qmu.params.analysis_driver='diagnostic'; +md.qmu.params.analysis_driver='stressbalance'; md.qmu.params.evaluation_concurrency=1; Index: /issm/trunk-jpl/src/m/qmu/examples/lrel_mmf.m =================================================================== --- /issm/trunk-jpl/src/m/qmu/examples/lrel_mmf.m (revision 15770) +++ /issm/trunk-jpl/src/m/qmu/examples/lrel_mmf.m (revision 15771) @@ -86,5 +86,5 @@ %% sample analysis -%md=solve(md,'analysis_type','diagnostic'); +%md=solve(md,'analysis_type','stressbalance'); %plotmodel(md,'data','mesh') Index: /issm/trunk-jpl/src/m/qmu/examples/samp_direct.m =================================================================== --- /issm/trunk-jpl/src/m/qmu/examples/samp_direct.m (revision 15770) +++ /issm/trunk-jpl/src/m/qmu/examples/samp_direct.m (revision 15771) @@ -50,5 +50,5 @@ md.qmu.params.direct=true; -md.qmu.params.analysis_driver='diagnostic'; +md.qmu.params.analysis_driver='stressbalance'; md.qmu.params.evaluation_concurrency=1; Index: /issm/trunk-jpl/src/m/qmu/preqmu.m =================================================================== --- /issm/trunk-jpl/src/m/qmu/preqmu.m (revision 15770) +++ /issm/trunk-jpl/src/m/qmu/preqmu.m (revision 15771) @@ -1,5 +1,5 @@ function md=preqmu(md,options) %QMU - apply Quantification of Margins and Uncertainties techniques -% to a solution sequence (like diagnostic.m, progonstic.m, etc ...), +% to a solution sequence (like stressbalance.m, progonstic.m, etc ...), % using the Dakota software from Sandia. % Index: /issm/trunk-jpl/src/m/qmu/process_qmu_options.m =================================================================== --- /issm/trunk-jpl/src/m/qmu/process_qmu_options.m (revision 15770) +++ /issm/trunk-jpl/src/m/qmu/process_qmu_options.m (revision 15771) @@ -39,5 +39,5 @@ %check solution type is supported if ~(strcmpi(analysis_type,'control') | ... - strcmpi(analysis_type,'diagnostic') | ... + strcmpi(analysis_type,'stressbalance') | ... strcmpi(analysis_type,'masstransport') | ... strcmpi(analysis_type,'thermal') | ... Index: /issm/trunk-jpl/src/m/regional/BasinConstrain.m =================================================================== --- /issm/trunk-jpl/src/m/regional/BasinConstrain.m (revision 15770) +++ /issm/trunk-jpl/src/m/regional/BasinConstrain.m (revision 15771) @@ -48,6 +48,6 @@ %all elements outside the constraint domain are equivalent to water. all nodes outside are spc'd. -md.diagnostic.spcvx(vertexnotondomain)=md.inversion.vx_obs(vertexnotondomain); -md.diagnostic.spcvy(vertexnotondomain)=md.inversion.vy_obs(vertexnotondomain); +md.stressbalance.spcvx(vertexnotondomain)=md.inversion.vx_obs(vertexnotondomain); +md.stressbalance.spcvy(vertexnotondomain)=md.inversion.vy_obs(vertexnotondomain); md.mask.elementonwater(elementnotondomain)=1; @@ -56,8 +56,8 @@ numpos=unique(md.mesh.elements(pos,:)); nodes=setdiff(1:1:md.mesh.numberofvertices,numpos); -md.diagnostic.spcvx(nodes)=md.inversion.vx_obs(nodes); -md.diagnostic.spcvy(nodes)=md.inversion.vy_obs(nodes); +md.stressbalance.spcvx(nodes)=md.inversion.vx_obs(nodes); +md.stressbalance.spcvy(nodes)=md.inversion.vy_obs(nodes); %make sure icefronts that are completely spc'd are taken out: -free_segments=find((~isnan(md.diagnostic.spcvx(md.diagnostic.icefront(:,1:2))) + ~isnan(md.diagnostic.spcvy(md.diagnostic.icefront(:,1:2))))~=2); -md.diagnostic.icefront=md.diagnostic.icefront(free_segments,:); +free_segments=find((~isnan(md.stressbalance.spcvx(md.stressbalance.icefront(:,1:2))) + ~isnan(md.stressbalance.spcvy(md.stressbalance.icefront(:,1:2))))~=2); +md.stressbalance.icefront=md.stressbalance.icefront(free_segments,:); Index: /issm/trunk-jpl/src/m/regional/BasinConstrainShelf.m =================================================================== --- /issm/trunk-jpl/src/m/regional/BasinConstrainShelf.m (revision 15770) +++ /issm/trunk-jpl/src/m/regional/BasinConstrainShelf.m (revision 15771) @@ -48,6 +48,6 @@ %all elements outside the constraint domain are equivalent to water. all nodes outside are spc'd. -md.diagnostic.spcvx(vertexnotondomain)=md.inversion.vx_obs(vertexnotondomain); -md.diagnostic.spcvy(vertexnotondomain)=md.inversion.vy_obs(vertexnotondomain); +md.stressbalance.spcvx(vertexnotondomain)=md.inversion.vx_obs(vertexnotondomain); +md.stressbalance.spcvy(vertexnotondomain)=md.inversion.vy_obs(vertexnotondomain); md.mask.elementonwater(elementnotondomain)=1; @@ -56,19 +56,19 @@ numpos=unique(md.mesh.elements(pos,:)); nodes=setdiff(1:1:md.mesh.numberofvertices,numpos); -md.diagnostic.spcvx(nodes)=md.inversion.vx_obs(nodes); -md.diagnostic.spcvy(nodes)=md.inversion.vy_obs(nodes); +md.stressbalance.spcvx(nodes)=md.inversion.vx_obs(nodes); +md.stressbalance.spcvy(nodes)=md.inversion.vy_obs(nodes); %make sure any node with NaN velocity is spc'd: %we spc to the smoothed value, so that control methods don't go berserk trying to figure out what reaction force to apply for the spc to stand. pos=find(isnan(md.inversion.vel_obs_raw)); -md.diagnostic.spcvx(pos)=md.inversion.vx_obs(pos); -md.diagnostic.spcvy(pos)=md.inversion.vy_obs(pos); +md.stressbalance.spcvx(pos)=md.inversion.vx_obs(pos); +md.stressbalance.spcvy(pos)=md.inversion.vy_obs(pos); %iceshelves: any vertex on floating ice is spc'd pos=find(md.mask.vertexongroundedice); -md.diagnostic.spcvx(pos)=md.inversion.vx_obs(pos); -md.diagnostic.spcvy(pos)=md.inversion.vy_obs(pos); +md.stressbalance.spcvx(pos)=md.inversion.vx_obs(pos); +md.stressbalance.spcvy(pos)=md.inversion.vy_obs(pos); %make sure icefronts that are completely spc'd are taken out: -free_segments=find((~isnan(md.diagnostic.spcvx(md.diagnostic.icefront(:,1:2))) + ~isnan(md.diagnostic.spcvy(md.diagnostic.icefront(:,1:2))) )~=2); -md.diagnostic.icefront=md.diagnostic.icefront(free_segments,:); +free_segments=find((~isnan(md.stressbalance.spcvx(md.stressbalance.icefront(:,1:2))) + ~isnan(md.stressbalance.spcvy(md.stressbalance.icefront(:,1:2))) )~=2); +md.stressbalance.icefront=md.stressbalance.icefront(free_segments,:); Index: /issm/trunk-jpl/src/m/regional/regionaltransient2d.m =================================================================== --- /issm/trunk-jpl/src/m/regional/regionaltransient2d.m (revision 15770) +++ /issm/trunk-jpl/src/m/regional/regionaltransient2d.m (revision 15771) @@ -115,27 +115,27 @@ %As long as there are recorded time steps, spc the boundaries with velocities if nsteps > 0 - md2.diagnostic.spcvx=md2.diagnostic.spcvx*ones(1,size(spcx,2)); - md2.diagnostic.spcvy=md2.diagnostic.spcvy*ones(1,size(spcy,2)); - md2.diagnostic.spcvz=md2.diagnostic.spcvz*ones(1,size(spcx,2)); + md2.stressbalance.spcvx=md2.stressbalance.spcvx*ones(1,size(spcx,2)); + md2.stressbalance.spcvy=md2.stressbalance.spcvy*ones(1,size(spcy,2)); + md2.stressbalance.spcvz=md2.stressbalance.spcvz*ones(1,size(spcx,2)); md2.masstransport.spcthickness=md2.masstransport.spcthickness*ones(1,size(spct,2)); - md2.diagnostic.spcvx(find(md2.mesh.vertexonboundary),:)=spcx(find(md2.mesh.vertexonboundary),:); - md2.diagnostic.spcvy(find(md2.mesh.vertexonboundary),:)=spcy(find(md2.mesh.vertexonboundary),:); - md2.diagnostic.spcvz(find(md2.mesh.vertexonboundary),:)=0; + md2.stressbalance.spcvx(find(md2.mesh.vertexonboundary),:)=spcx(find(md2.mesh.vertexonboundary),:); + md2.stressbalance.spcvy(find(md2.mesh.vertexonboundary),:)=spcy(find(md2.mesh.vertexonboundary),:); + md2.stressbalance.spcvz(find(md2.mesh.vertexonboundary),:)=0; md2.masstransport.spcthickness(find(md2.mesh.vertexonboundary),:)=spct(find(md2.mesh.vertexonboundary),:); - md2.diagnostic.spcvx=[md2.diagnostic.spcvx; steps]; - md2.diagnostic.spcvy=[md2.diagnostic.spcvy; steps]; - md2.diagnostic.spcvz=[md2.diagnostic.spcvz; steps]; + md2.stressbalance.spcvx=[md2.stressbalance.spcvx; steps]; + md2.stressbalance.spcvy=[md2.stressbalance.spcvy; steps]; + md2.stressbalance.spcvz=[md2.stressbalance.spcvz; steps]; md2.masstransport.spcthickness=[md2.masstransport.spcthickness; steps]; end - %Diagnostic. Don't spc the icefront vertices. - if ~isnan(md2.diagnostic.icefront) + %Stressbalance. Don't spc the icefront vertices. + if ~isnan(md2.stressbalance.icefront) md1s=md1.extract(area); - %md2.diagnostic.icefront=[md2.mesh.segments 2]; + %md2.stressbalance.icefront=[md2.mesh.segments 2]; e2=md2.mesh.segments(:,end); e1=md1s.mesh.segments(:,end); pload = nan*ones(size(md1s.mesh.elements,1),1); - pload(md1s.diagnostic.icefront(:,end-1))=md1s.diagnostic.icefront(:,end); + pload(md1s.stressbalance.icefront(:,end-1))=md1s.stressbalance.icefront(:,end); x2=mean(md2.mesh.x(md2.mesh.elements(e2,:)),2); @@ -145,9 +145,9 @@ pload2=griddata(x1,y1,pload,x2,y2,'nearest'); - md2.diagnostic.icefront=[md2.mesh.segments(~isnan(pload2),:) pload2(~isnan(pload2))]; - md2.diagnostic.spcvx(unique(md2.diagnostic.icefront(:,1:2)),:)=nan; - md2.diagnostic.spcvy(unique(md2.diagnostic.icefront(:,1:2)),:)=nan; - md2.diagnostic.spcvz(unique(md2.diagnostic.icefront(:,1:2)),:)=nan; - md2.masstransport.spcthickness(unique(md2.diagnostic.icefront(:,1:2)),:)=nan; + md2.stressbalance.icefront=[md2.mesh.segments(~isnan(pload2),:) pload2(~isnan(pload2))]; + md2.stressbalance.spcvx(unique(md2.stressbalance.icefront(:,1:2)),:)=nan; + md2.stressbalance.spcvy(unique(md2.stressbalance.icefront(:,1:2)),:)=nan; + md2.stressbalance.spcvz(unique(md2.stressbalance.icefront(:,1:2)),:)=nan; + md2.masstransport.spcthickness(unique(md2.stressbalance.icefront(:,1:2)),:)=nan; end Index: /issm/trunk-jpl/src/m/solve/process_solve_options.m =================================================================== --- /issm/trunk-jpl/src/m/solve/process_solve_options.m (revision 15770) +++ /issm/trunk-jpl/src/m/solve/process_solve_options.m (revision 15771) @@ -9,5 +9,5 @@ %solution_type: check on this option, error out otherwise solution_type=getfieldvalue(options,'solution_type'); -if ~ismember(solution_type,[DiagnosticSolutionEnum(),MasstransportSolutionEnum(),ThermalSolutionEnum(),... +if ~ismember(solution_type,[StressbalanceSolutionEnum(),MasstransportSolutionEnum(),ThermalSolutionEnum(),... SteadystateSolutionEnum(),TransientSolutionEnum(),EnthalpySolutionEnum(),... BalancethicknessSolutionEnum(),BalancethicknessSoftSolutionEnum(),BedSlopeSolutionEnum(),... Index: /issm/trunk-jpl/src/m/solve/process_solve_options.py =================================================================== --- /issm/trunk-jpl/src/m/solve/process_solve_options.py (revision 15770) +++ /issm/trunk-jpl/src/m/solve/process_solve_options.py (revision 15771) @@ -18,5 +18,5 @@ #solution_type: check on this option, error out otherwise solution_type=options.getfieldvalue('solution_type') - if solution_type not in (DiagnosticSolutionEnum(),MasstransportSolutionEnum(),ThermalSolutionEnum(),\ + if solution_type not in (StressbalanceSolutionEnum(),MasstransportSolutionEnum(),ThermalSolutionEnum(),\ SteadystateSolutionEnum(),TransientSolutionEnum(),EnthalpySolutionEnum(),\ BalancethicknessSolutionEnum(),BedSlopeSolutionEnum(),SurfaceSlopeSolutionEnum(),\ Index: /issm/trunk-jpl/src/m/solve/solve.m =================================================================== --- /issm/trunk-jpl/src/m/solve/solve.m (revision 15770) +++ /issm/trunk-jpl/src/m/solve/solve.m (revision 15771) @@ -7,5 +7,5 @@ % % solution types available comprise: -% - DiagnosticSolutionEnum +% - StressbalanceSolutionEnum % - MasstransportSolutionEnum % - ThermalSolutionEnum @@ -22,5 +22,5 @@ % % Examples: -% md=solve(md,DiagnosticSolutionEnum); +% md=solve(md,StressbalanceSolutionEnum); %recover and process solve options Index: /issm/trunk-jpl/src/m/solve/solve.py =================================================================== --- /issm/trunk-jpl/src/m/solve/solve.py (revision 15770) +++ /issm/trunk-jpl/src/m/solve/solve.py (revision 15771) @@ -21,5 +21,5 @@ solution types available comprise: - - DiagnosticSolutionEnum + - StressbalanceSolutionEnum - MasstransportSolutionEnum - ThermalSolutionEnum @@ -36,5 +36,5 @@ Examples: - md=solve(md,DiagnosticSolutionEnum); + md=solve(md,StressbalanceSolutionEnum); """ Index: /issm/trunk-jpl/test/NightlyRun/IdToName.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/IdToName.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/IdToName.m (revision 15771) @@ -6,8 +6,8 @@ switch id, - case 101, name='SquareShelfConstrainedDiagSSA2d'; - case 102, name='SquareShelfConstrainedDiagSSA3d'; - case 103, name='SquareShelfConstrainedDiagHO'; - case 104, name='SquareShelfConstrainedDiagS3d'; + case 101, name='SquareShelfConstrainedStressSSA2d'; + case 102, name='SquareShelfConstrainedStressSSA3d'; + case 103, name='SquareShelfConstrainedStressHO'; + case 104, name='SquareShelfConstrainedStressS3d'; case 105, name='SquareShelfConstrainedMasstransp2d'; case 106, name='SquareShelfConstrainedMasstransp2dDG'; @@ -28,9 +28,9 @@ case 121, name='SquareShelfConstrainedEnthalpyTran'; case 122, name='SquareShelfConstrainedTransHOEnth'; - case 201, name='SquareShelfDiagSSA2d'; - case 202, name='SquareShelfDiagSSA3d'; - case 203, name='SquareShelfDiagHO'; - case 204, name='SquareShelfDiagS3d'; - case 205, name='SquareShelfDiagMHOPenalties'; + case 201, name='SquareShelfStressSSA2d'; + case 202, name='SquareShelfStressSSA3d'; + case 203, name='SquareShelfStressHO'; + case 204, name='SquareShelfStressS3d'; + case 205, name='SquareShelfStressMHOPenalties'; case 206, name='SquareShelfTherStea'; case 207, name='SquareShelfTherTran'; @@ -43,14 +43,14 @@ case 214, name='SquareShelfCMBHO'; case 215, name='SquareShelfCMBS3d'; - case 216, name='SquareShelfDiagSSA2dRift'; + case 216, name='SquareShelfStressSSA2dRift'; case 217, name='SquareShelfConstrained'; case 218, name='SquareShelfConstrainedDakotaB'; - case 219, name='SquareShelfDiagSSAHOTiling'; - case 220, name='SquareShelfDiagHOFS3dTiling'; - case 221, name='SquareShelfDiagSSAFS3dTiling'; - case 222, name='SquareShelfDiagSSA2dTransientIncrHydro'; - case 223, name='SquareShelfDiagSSA2dTransientIncrNonHydro'; - case 224, name='SquareShelfDiagHOTransientIncrHydro'; - case 225, name='SquareShelfDiagHOTransientIncrNonHydro'; + case 219, name='SquareShelfStressSSAHOTiling'; + case 220, name='SquareShelfStressHOFS3dTiling'; + case 221, name='SquareShelfStressSSAFS3dTiling'; + case 222, name='SquareShelfStressSSA2dTransientIncrHydro'; + case 223, name='SquareShelfStressSSA2dTransientIncrNonHydro'; + case 224, name='SquareShelfStressHOTransientIncrHydro'; + case 225, name='SquareShelfStressHOTransientIncrNonHydro'; case 226, name='SquareShelfTranCflSSA2d'; case 227, name='SquareShelfTranCflHO'; @@ -65,20 +65,20 @@ case 236, name='SquareShelfTranIspddIsdeltaSSA2d'; case 237, name='SquareShelfTranIspddIsdeltaSSA3d'; - case 270, name='SquareShelfDiagSSA2dDamage'; + case 270, name='SquareShelfStressSSA2dDamage'; case 272, name='SquareShelfCMZSSA2dDamage'; - case 274, name='SquareShelfDiagSSA2dDamageRift'; - case 280, name='SquareShelfDiagSSA2dP2'; - case 285, name='SquareShelfDiagHOP1xP2'; - case 286, name='SquareShelfDiagHOP2xP1'; - case 287, name='SquareShelfDiagHOP2xP2'; - case 290, name='SquareShelfDiagFSP2P1'; - case 301, name='SquareSheetConstrainedDiagSSA2d'; - case 302, name='SquareSheetConstrainedDiagSIA2d'; - case 303, name='SquareSheetConstrainedDiagHSSA2d'; - case 304, name='SquareSheetConstrainedDiagSSA3d'; - case 305, name='SquareSheetConstrainedDiagSIA3d'; - case 306, name='SquareSheetConstrainedDiagHSSA3d'; - case 307, name='SquareSheetConstrainedDiagHO'; - case 308, name='SquareSheetConstrainedDiagS3d'; + case 274, name='SquareShelfStressSSA2dDamageRift'; + case 280, name='SquareShelfStressSSA2dP2'; + case 285, name='SquareShelfStressHOP1xP2'; + case 286, name='SquareShelfStressHOP2xP1'; + case 287, name='SquareShelfStressHOP2xP2'; + case 290, name='SquareShelfStressFSP2P1'; + case 301, name='SquareSheetConstrainedStressSSA2d'; + case 302, name='SquareSheetConstrainedStressSIA2d'; + case 303, name='SquareSheetConstrainedStressHSSA2d'; + case 304, name='SquareSheetConstrainedStressSSA3d'; + case 305, name='SquareSheetConstrainedStressSIA3d'; + case 306, name='SquareSheetConstrainedStressHSSA3d'; + case 307, name='SquareSheetConstrainedStressHO'; + case 308, name='SquareSheetConstrainedStressS3d'; case 309, name='SquareSheetConstrainedMasstransp2d'; case 320, name='SquareSheetConstrainedMasstransp2dDG'; @@ -105,9 +105,9 @@ case 332, name='SquareSheetConstrainedHydrologyDC'; case 333, name='SquareSheetHydrologyDCTwoLayers'; - case 401, name='SquareSheetShelfDiagSSA2d'; - case 402, name='SquareSheetShelfDiagSSA3d'; - case 403, name='SquareSheetShelfDiagHO'; - case 404, name='SquareSheetShelfDiagS3d'; - case 405, name='SquareSheetShelfDiagMHOPenalties'; + case 401, name='SquareSheetShelfStressSSA2d'; + case 402, name='SquareSheetShelfStressSSA3d'; + case 403, name='SquareSheetShelfStressHO'; + case 404, name='SquareSheetShelfStressS3d'; + case 405, name='SquareSheetShelfStressMHOPenalties'; case 406, name='SquareSheetShelfTherStea'; case 407, name='SquareSheetShelfTherTran'; @@ -123,8 +123,8 @@ case 417, name='SquareSheetShelfDiadSSA3dDakotaSamp'; case 418, name='SquareSheetShelfDiadSSA3dDakotaAreaAverage'; - case 419, name='SquareSheetShelfDiagSSAHOTiling'; + case 419, name='SquareSheetShelfStressSSAHOTiling'; case 420, name='SquareSheetShelfDakotaScaledResponse'; - case 421, name='SquareSheetShelfDiagHOFS3dTiling'; - case 422, name='SquareSheetShelfDiagSSAFS3dTiling'; + case 421, name='SquareSheetShelfStressHOFS3dTiling'; + case 422, name='SquareSheetShelfStressSSAFS3dTiling'; case 423, name='RoundSheetShelfGLMigrationSSA2d'; case 424, name='SquareSheetShelfGroundingLine2dAgressive'; @@ -132,14 +132,14 @@ case 426, name='SquareSheetShelfGroundingLine3dAgressive'; case 427, name='SquareSheetShelfGroundingLine3dSoft'; - case 428, name='SquareSheetShelfDiagSSA2dNewton'; - case 429, name='SquareSheetShelfDiagHONewton'; - case 430, name='SquareSheetShelfDiagS3dNewton'; + case 428, name='SquareSheetShelfStressSSA2dNewton'; + case 429, name='SquareSheetShelfStressHONewton'; + case 430, name='SquareSheetShelfStressS3dNewton'; case 431, name='SquareSheetShelfSteaEnthalpySSA3d'; case 432, name='SquareSheetShelfSteaEnthalpyHO'; case 433, name='RoundSheetShelfGLMigrationSSA3d'; case 434, name='SquareSheetShelfL1L2'; - case 501, name='PigDiagSSA2d'; - case 502, name='PigDiagHO'; - case 503, name='PigDiagS3d'; + case 501, name='PigStressSSA2d'; + case 502, name='PigStressHO'; + case 503, name='PigStressS3d'; case 504, name='PigTranSSA2d'; case 505, name='PigTranSSA3d'; @@ -179,6 +179,6 @@ case 1110, name='ISMIPF'; case 1201, name='EISMINTMassConservation'; - case 1202, name='EISMINTDiag1'; - case 1203, name='EISMINTDiag2'; + case 1202, name='EISMINTStress1'; + case 1203, name='EISMINTStress2'; case 1204, name='EISMINTTran2'; case 1205, name='EISMINTRoundIceSheetStaticSIA'; @@ -209,8 +209,8 @@ case 2082, name='GiaBenchmarksAB2dD2'; case 2083, name='GiaBenchmarksAB2dD3'; - case 3001, name='SquareShelfConstrainedDiagSSA2dAdolc'; - case 3002, name='SquareShelfConstrainedDiagSSA3dAdolc'; - case 3003, name='SquareShelfConstrainedDiagHOAdolc'; - case 3004, name='SquareShelfConstrainedDiagS3dAdolc'; + case 3001, name='SquareShelfConstrainedStressSSA2dAdolc'; + case 3002, name='SquareShelfConstrainedStressSSA3dAdolc'; + case 3003, name='SquareShelfConstrainedStressHOAdolc'; + case 3004, name='SquareShelfConstrainedStressS3dAdolc'; case 3005, name='SquareShelfConstrainedMasstransp2dAdolc'; case 3006, name='SquareShelfConstrainedMasstransp2dDGAdolc'; Index: /issm/trunk-jpl/test/NightlyRun/IdToName.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/IdToName.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/IdToName.py (revision 15771) @@ -10,8 +10,8 @@ idname={ - 101 : 'SquareShelfConstrainedDiagSSA2d', - 102 : 'SquareShelfConstrainedDiagSSA3d', - 103 : 'SquareShelfConstrainedDiagHO', - 104 : 'SquareShelfConstrainedDiagS3d', + 101 : 'SquareShelfConstrainedStressSSA2d', + 102 : 'SquareShelfConstrainedStressSSA3d', + 103 : 'SquareShelfConstrainedStressHO', + 104 : 'SquareShelfConstrainedStressS3d', 105 : 'SquareShelfConstrainedMasstransp2d', 106 : 'SquareShelfConstrainedMasstransp2dDG', @@ -32,9 +32,9 @@ 121 : 'SquareShelfConstrainedEnthalpyTran', 122 : 'SquareShelfConstrainedTransHOEnth', - 201 : 'SquareShelfDiagSSA2d', - 202 : 'SquareShelfDiagSSA3d', - 203 : 'SquareShelfDiagHO', - 204 : 'SquareShelfDiagS3d', - 205 : 'SquareShelfDiagMHOPenalties', + 201 : 'SquareShelfStressSSA2d', + 202 : 'SquareShelfStressSSA3d', + 203 : 'SquareShelfStressHO', + 204 : 'SquareShelfStressS3d', + 205 : 'SquareShelfStressMHOPenalties', 206 : 'SquareShelfTherStea', 207 : 'SquareShelfTherTran', @@ -47,14 +47,14 @@ 214 : 'SquareShelfCMBHO', 215 : 'SquareShelfCMBS3d', - 216 : 'SquareShelfDiagSSA2dRift', + 216 : 'SquareShelfStressSSA2dRift', 217 : 'SquareShelfConstrained', 218 : 'SquareShelfConstrainedDakotaB', - 219 : 'SquareShelfDiagSSAHOTiling', - 220 : 'SquareShelfDiagHOFS3dTiling', - 221 : 'SquareShelfDiagSSAFS3dTiling', - 222 : 'SquareShelfDiagSSA2dTransientIncrHydro', - 223 : 'SquareShelfDiagSSA2dTransientIncrNonHydro', - 224 : 'SquareShelfDiagHOTransientIncrHydro', - 225 : 'SquareShelfDiagHOTransientIncrNonHydro', + 219 : 'SquareShelfStressSSAHOTiling', + 220 : 'SquareShelfStressHOFS3dTiling', + 221 : 'SquareShelfStressSSAFS3dTiling', + 222 : 'SquareShelfStressSSA2dTransientIncrHydro', + 223 : 'SquareShelfStressSSA2dTransientIncrNonHydro', + 224 : 'SquareShelfStressHOTransientIncrHydro', + 225 : 'SquareShelfStressHOTransientIncrNonHydro', 226 : 'SquareShelfTranCflSSA2d', 227 : 'SquareShelfTranCflHO', @@ -69,20 +69,20 @@ 236 : 'SquareShelfTranIspddIsdeltaSSA2d', 237 : 'SquareShelfTranIspddIsdeltaSSA3d', - 270 : 'SquareShelfDiagSSA2dDamage', + 270 : 'SquareShelfStressSSA2dDamage', 272 : 'SquareShelfCMZSSA2dDamage', - 274 : 'SquareShelfDiagSSA2dDamageRift', - 280 : 'SquareShelfDiagSSA2dP2', - 285 : 'SquareShelfDiagHOP1xP2', - 286 : 'SquareShelfDiagHOP2xP1', - 287 : 'SquareShelfDiagHOP2xP2', - 290 : 'SquareShelfDiagFSP2P1', - 301 : 'SquareSheetConstrainedDiagSSA2d', - 302 : 'SquareSheetConstrainedDiagSIA2d', - 303 : 'SquareSheetConstrainedDiagHSSA2d', - 304 : 'SquareSheetConstrainedDiagSSA3d', - 305 : 'SquareSheetConstrainedDiagSIA3d', - 306 : 'SquareSheetConstrainedDiagHSSA3d', - 307 : 'SquareSheetConstrainedDiagHO', - 308 : 'SquareSheetConstrainedDiagS3d', + 274 : 'SquareShelfStressSSA2dDamageRift', + 280 : 'SquareShelfStressSSA2dP2', + 285 : 'SquareShelfStressHOP1xP2', + 286 : 'SquareShelfStressHOP2xP1', + 287 : 'SquareShelfStressHOP2xP2', + 290 : 'SquareShelfStressFSP2P1', + 301 : 'SquareSheetConstrainedStressSSA2d', + 302 : 'SquareSheetConstrainedStressSIA2d', + 303 : 'SquareSheetConstrainedStressHSSA2d', + 304 : 'SquareSheetConstrainedStressSSA3d', + 305 : 'SquareSheetConstrainedStressSIA3d', + 306 : 'SquareSheetConstrainedStressHSSA3d', + 307 : 'SquareSheetConstrainedStressHO', + 308 : 'SquareSheetConstrainedStressS3d', 309 : 'SquareSheetConstrainedMasstransp2d', 320 : 'SquareSheetConstrainedMasstransp2dDG', @@ -109,9 +109,9 @@ 332 : 'SquareSheetConstrainedHydrologyDC', 333 : 'SquareSheetHydrologyDCTwoLayers', - 401 : 'SquareSheetShelfDiagSSA2d', - 402 : 'SquareSheetShelfDiagSSA3d', - 403 : 'SquareSheetShelfDiagHO', - 404 : 'SquareSheetShelfDiagS3d', - 405 : 'SquareSheetShelfDiagMHOPenalties', + 401 : 'SquareSheetShelfStressSSA2d', + 402 : 'SquareSheetShelfStressSSA3d', + 403 : 'SquareSheetShelfStressHO', + 404 : 'SquareSheetShelfStressS3d', + 405 : 'SquareSheetShelfStressMHOPenalties', 406 : 'SquareSheetShelfTherStea', 407 : 'SquareSheetShelfTherTran', @@ -127,8 +127,8 @@ 417 : 'SquareSheetShelfDiadSSA3dDakotaSamp', 418 : 'SquareSheetShelfDiadSSA3dDakotaAreaAverage', - 419 : 'SquareSheetShelfDiagSSAHOTiling', + 419 : 'SquareSheetShelfStressSSAHOTiling', 420 : 'SquareSheetShelfDakotaScaledResponse', - 421 : 'SquareSheetShelfDiagHOFS3dTiling', - 422 : 'SquareSheetShelfDiagSSAFS3dTiling', + 421 : 'SquareSheetShelfStressHOFS3dTiling', + 422 : 'SquareSheetShelfStressSSAFS3dTiling', 423 : 'RoundSheetShelfGLMigrationSSA2d', 424 : 'SquareSheetShelfGroundingLine2dAgressive', @@ -136,14 +136,14 @@ 426 : 'SquareSheetShelfGroundingLine3dAgressive', 427 : 'SquareSheetShelfGroundingLine3dSoft', - 428 : 'SquareSheetShelfDiagSSA2dNewton', - 429 : 'SquareSheetShelfDiagHONewton', - 430 : 'SquareSheetShelfDiagS3dNewton', + 428 : 'SquareSheetShelfStressSSA2dNewton', + 429 : 'SquareSheetShelfStressHONewton', + 430 : 'SquareSheetShelfStressS3dNewton', 431 : 'SquareSheetShelfSteaEnthalpySSA3d', 432 : 'SquareSheetShelfSteaEnthalpyHO', 433 : 'RoundSheetShelfGLMigrationSSA3d', 434 : 'SquareSheetShelfL1L2', - 501 : 'PigDiagSSA2d', - 502 : 'PigDiagHO', - 503 : 'PigDiagS3d', + 501 : 'PigStressSSA2d', + 502 : 'PigStressHO', + 503 : 'PigStressS3d', 504 : 'PigTranSSA2d', 505 : 'PigTranSSA3d', @@ -183,6 +183,6 @@ 1110 : 'ISMIPF', 1201 : 'EISMINTMassConservation', - 1202 : 'EISMINTDiag1', - 1203 : 'EISMINTDiag2', + 1202 : 'EISMINTStress1', + 1203 : 'EISMINTStress2', 1204 : 'EISMINTTran2', 1205 : 'EISMINTRoundIceSheetStaticSIA', @@ -213,8 +213,8 @@ 2082 : 'GiaBenchmarksAB2dD2', 2083 : 'GiaBenchmarksAB2dD3', - 3001 : 'SquareShelfConstrainedDiagSSA2dAdolc', - 3002 : 'SquareShelfConstrainedDiagSSA3dAdolc', - 3003 : 'SquareShelfConstrainedDiagHOAdolc', - 3004 : 'SquareShelfConstrainedDiagS3dAdolc', + 3001 : 'SquareShelfConstrainedStressSSA2dAdolc', + 3002 : 'SquareShelfConstrainedStressSSA3dAdolc', + 3003 : 'SquareShelfConstrainedStressHOAdolc', + 3004 : 'SquareShelfConstrainedStressS3dAdolc', 3005 : 'SquareShelfConstrainedMasstransp2dAdolc', 3006 : 'SquareShelfConstrainedMasstransp2dDGAdolc', Index: /issm/trunk-jpl/test/NightlyRun/android.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/android.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/android.m (revision 15771) @@ -5,6 +5,6 @@ md.cluster=generic('name',oshostname(),'np',3); md.verbose=verbose('mprocessor',true,'module',true,'solution',true,'solver',true,'convergence',true,'control',true,'qmu',true,'autodiff',true); -md.diagnostic.requested_outputs=StressTensorEnum(); -md=solve(md,DiagnosticSolutionEnum()); +md.stressbalance.requested_outputs=StressTensorEnum(); +md=solve(md,StressbalanceSolutionEnum()); @@ -14,5 +14,5 @@ y=md.mesh.y; z=md.mesh.z; -vel=md.results.DiagnosticSolution.Vel; +vel=md.results.StressbalanceSolution.Vel; patch=zeros(nel,12); Index: /issm/trunk-jpl/test/NightlyRun/test101.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test101.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test101.m (revision 15771) @@ -4,6 +4,6 @@ md=setflowequation(md,'SSA','all'); md.cluster=generic('name',oshostname(),'np',3); -md.diagnostic.requested_outputs=StressTensorEnum(); -md=solve(md,DiagnosticSolutionEnum()); +md.stressbalance.requested_outputs=StressTensorEnum(); +md=solve(md,StressbalanceSolutionEnum()); %Fields and tolerances to track changes @@ -13,10 +13,10 @@ 1e-13,1e-13,1e-13}; field_values={... - (md.results.DiagnosticSolution.Vx),... - (md.results.DiagnosticSolution.Vy),... - (md.results.DiagnosticSolution.Vel),... - (md.results.DiagnosticSolution.Pressure),... - (md.results.DiagnosticSolution.StressTensorxx),... - (md.results.DiagnosticSolution.StressTensoryy),... - (md.results.DiagnosticSolution.StressTensorxy),... + (md.results.StressbalanceSolution.Vx),... + (md.results.StressbalanceSolution.Vy),... + (md.results.StressbalanceSolution.Vel),... + (md.results.StressbalanceSolution.Pressure),... + (md.results.StressbalanceSolution.StressTensorxx),... + (md.results.StressbalanceSolution.StressTensoryy),... + (md.results.StressbalanceSolution.StressTensorxy),... }; Index: /issm/trunk-jpl/test/NightlyRun/test101.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test101.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test101.py (revision 15771) @@ -13,6 +13,6 @@ md=setflowequation(md,'SSA','all') md.cluster=generic('name',oshostname(),'np',3) -md.diagnostic.requested_outputs=StressTensorEnum() -md=solve(md,DiagnosticSolutionEnum()) +md.stressbalance.requested_outputs=StressTensorEnum() +md=solve(md,StressbalanceSolutionEnum()) #Fields and tolerances to track changes @@ -22,10 +22,10 @@ 1e-13,1e-13,1e-13] field_values=[\ - md.results.DiagnosticSolution.Vx,\ - md.results.DiagnosticSolution.Vy,\ - md.results.DiagnosticSolution.Vel,\ - md.results.DiagnosticSolution.Pressure,\ - md.results.DiagnosticSolution.StressTensorxx,\ - md.results.DiagnosticSolution.StressTensoryy,\ - md.results.DiagnosticSolution.StressTensorxy,\ + md.results.StressbalanceSolution.Vx,\ + md.results.StressbalanceSolution.Vy,\ + md.results.StressbalanceSolution.Vel,\ + md.results.StressbalanceSolution.Pressure,\ + md.results.StressbalanceSolution.StressTensorxx,\ + md.results.StressbalanceSolution.StressTensoryy,\ + md.results.StressbalanceSolution.StressTensorxy,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test102.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test102.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test102.m (revision 15771) @@ -5,5 +5,5 @@ md=setflowequation(md,'SSA','all'); md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %Fields and tolerances to track changes @@ -11,8 +11,8 @@ field_tolerances={1e-13,1e-13,1e-13,1e-13,1e-13}; field_values={... - (md.results.DiagnosticSolution.Vx),... - (md.results.DiagnosticSolution.Vy),... - (md.results.DiagnosticSolution.Vz),... - (md.results.DiagnosticSolution.Vel),... - (md.results.DiagnosticSolution.Pressure),... + (md.results.StressbalanceSolution.Vx),... + (md.results.StressbalanceSolution.Vy),... + (md.results.StressbalanceSolution.Vz),... + (md.results.StressbalanceSolution.Vel),... + (md.results.StressbalanceSolution.Pressure),... }; Index: /issm/trunk-jpl/test/NightlyRun/test102.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test102.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test102.py (revision 15771) @@ -14,5 +14,5 @@ md=setflowequation(md,'SSA','all') md.cluster=generic('name',oshostname(),'np',3) -md=solve(md,DiagnosticSolutionEnum()) +md=solve(md,StressbalanceSolutionEnum()) #Fields and tolerances to track changes @@ -20,9 +20,9 @@ field_tolerances=[1e-13,1e-13,1e-13,1e-13,1e-13] field_values=[\ - md.results.DiagnosticSolution.Vx,\ - md.results.DiagnosticSolution.Vy,\ - md.results.DiagnosticSolution.Vz,\ - md.results.DiagnosticSolution.Vel,\ - md.results.DiagnosticSolution.Pressure,\ + md.results.StressbalanceSolution.Vx,\ + md.results.StressbalanceSolution.Vy,\ + md.results.StressbalanceSolution.Vz,\ + md.results.StressbalanceSolution.Vel,\ + md.results.StressbalanceSolution.Pressure,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test103.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test103.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test103.m (revision 15771) @@ -5,6 +5,6 @@ md=setflowequation(md,'HO','all'); md.cluster=generic('name',oshostname(),'np',3); -md.diagnostic.requested_outputs=StressTensorEnum(); -md=solve(md,DiagnosticSolutionEnum()); +md.stressbalance.requested_outputs=StressTensorEnum(); +md=solve(md,StressbalanceSolutionEnum()); %Fields and tolerances to track changes @@ -14,14 +14,14 @@ 1e-09,1e-09,1e-09,1e-09,1e-09,1e-09}; field_values={... - (md.results.DiagnosticSolution.Vx),... - (md.results.DiagnosticSolution.Vy),... - (md.results.DiagnosticSolution.Vz),... - (md.results.DiagnosticSolution.Vel),... - (md.results.DiagnosticSolution.Pressure),... - (md.results.DiagnosticSolution.StressTensorxx),... - (md.results.DiagnosticSolution.StressTensoryy),... - (md.results.DiagnosticSolution.StressTensorzz),... - (md.results.DiagnosticSolution.StressTensorxy),... - (md.results.DiagnosticSolution.StressTensorxz),... - (md.results.DiagnosticSolution.StressTensoryz),... + (md.results.StressbalanceSolution.Vx),... + (md.results.StressbalanceSolution.Vy),... + (md.results.StressbalanceSolution.Vz),... + (md.results.StressbalanceSolution.Vel),... + (md.results.StressbalanceSolution.Pressure),... + (md.results.StressbalanceSolution.StressTensorxx),... + (md.results.StressbalanceSolution.StressTensoryy),... + (md.results.StressbalanceSolution.StressTensorzz),... + (md.results.StressbalanceSolution.StressTensorxy),... + (md.results.StressbalanceSolution.StressTensorxz),... + (md.results.StressbalanceSolution.StressTensoryz),... }; Index: /issm/trunk-jpl/test/NightlyRun/test103.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test103.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test103.py (revision 15771) @@ -14,6 +14,6 @@ md=setflowequation(md,'HO','all') md.cluster=generic('name',oshostname(),'np',3) -md.diagnostic.requested_outputs=StressTensorEnum() -md=solve(md,DiagnosticSolutionEnum()) +md.stressbalance.requested_outputs=StressTensorEnum() +md=solve(md,StressbalanceSolutionEnum()) #Fields and tolerances to track changes @@ -23,14 +23,14 @@ 1e-09,1e-09,1e-09,1e-09,1e-09,1e-09] field_values=[\ - md.results.DiagnosticSolution.Vx,\ - md.results.DiagnosticSolution.Vy,\ - md.results.DiagnosticSolution.Vz,\ - md.results.DiagnosticSolution.Vel,\ - md.results.DiagnosticSolution.Pressure,\ - md.results.DiagnosticSolution.StressTensorxx,\ - md.results.DiagnosticSolution.StressTensoryy,\ - md.results.DiagnosticSolution.StressTensorzz,\ - md.results.DiagnosticSolution.StressTensorxy,\ - md.results.DiagnosticSolution.StressTensorxz,\ - md.results.DiagnosticSolution.StressTensoryz,\ + md.results.StressbalanceSolution.Vx,\ + md.results.StressbalanceSolution.Vy,\ + md.results.StressbalanceSolution.Vz,\ + md.results.StressbalanceSolution.Vel,\ + md.results.StressbalanceSolution.Pressure,\ + md.results.StressbalanceSolution.StressTensorxx,\ + md.results.StressbalanceSolution.StressTensoryy,\ + md.results.StressbalanceSolution.StressTensorzz,\ + md.results.StressbalanceSolution.StressTensorxy,\ + md.results.StressbalanceSolution.StressTensorxz,\ + md.results.StressbalanceSolution.StressTensoryz,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test104.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test104.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test104.m (revision 15771) @@ -5,5 +5,5 @@ md=setflowequation(md,'FS','all'); md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %Fields and tolerances to track changes @@ -11,8 +11,8 @@ field_tolerances={1e-08,1e-08,1e-06,1e-08,1e-08}; field_values={... - (md.results.DiagnosticSolution.Vx),... - (md.results.DiagnosticSolution.Vy),... - (md.results.DiagnosticSolution.Vz),... - (md.results.DiagnosticSolution.Vel),... - (md.results.DiagnosticSolution.Pressure),... + (md.results.StressbalanceSolution.Vx),... + (md.results.StressbalanceSolution.Vy),... + (md.results.StressbalanceSolution.Vz),... + (md.results.StressbalanceSolution.Vel),... + (md.results.StressbalanceSolution.Pressure),... }; Index: /issm/trunk-jpl/test/NightlyRun/test104.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test104.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test104.py (revision 15771) @@ -14,5 +14,5 @@ md=setflowequation(md,'FS','all') md.cluster=generic('name',oshostname(),'np',3) -md=solve(md,DiagnosticSolutionEnum()) +md=solve(md,StressbalanceSolutionEnum()) #Fields and tolerances to track changes @@ -20,8 +20,8 @@ field_tolerances=[1e-08,1e-08,1e-06,1e-08,1e-08] field_values=[\ - md.results.DiagnosticSolution.Vx,\ - md.results.DiagnosticSolution.Vy,\ - md.results.DiagnosticSolution.Vz,\ - md.results.DiagnosticSolution.Vel,\ - md.results.DiagnosticSolution.Pressure,\ + md.results.StressbalanceSolution.Vx,\ + md.results.StressbalanceSolution.Vy,\ + md.results.StressbalanceSolution.Vz,\ + md.results.StressbalanceSolution.Vel,\ + md.results.StressbalanceSolution.Pressure,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test109.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test109.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test109.m (revision 15771) @@ -5,5 +5,5 @@ md=setflowequation(md,'SSA','all'); md.cluster=generic('name',oshostname(),'np',3); -md.transient.isdiagnostic=0; +md.transient.isstressbalance=0; md.transient.ismasstransport=0; md.transient.isthermal=1; Index: /issm/trunk-jpl/test/NightlyRun/test109.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test109.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test109.py (revision 15771) @@ -14,5 +14,5 @@ md=setflowequation(md,'SSA','all') md.cluster=generic('name',oshostname(),'np',3) -md.transient.isdiagnostic=False +md.transient.isstressbalance=False md.transient.ismasstransport=False md.transient.isthermal=True Index: /issm/trunk-jpl/test/NightlyRun/test1101.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test1101.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test1101.m (revision 15771) @@ -21,11 +21,11 @@ %Create dirichlet on the bed only - md.diagnostic.spcvx=NaN*ones(md.mesh.numberofvertices,1); - md.diagnostic.spcvy=NaN*ones(md.mesh.numberofvertices,1); - md.diagnostic.spcvz=NaN*ones(md.mesh.numberofvertices,1); + md.stressbalance.spcvx=NaN*ones(md.mesh.numberofvertices,1); + md.stressbalance.spcvy=NaN*ones(md.mesh.numberofvertices,1); + md.stressbalance.spcvz=NaN*ones(md.mesh.numberofvertices,1); pos=find(md.mesh.vertexonbed); - md.diagnostic.spcvx(pos)=0.; - md.diagnostic.spcvy(pos)=0.; + md.stressbalance.spcvx(pos)=0.; + md.stressbalance.spcvy(pos)=0.; %Create MPCs to have periodic boundary conditions @@ -36,15 +36,15 @@ posy2=find(md.mesh.y==max(md.mesh.y) & md.mesh.x~=0. & md.mesh.x~=max(md.mesh.x)); - md.diagnostic.vertex_pairing=[posx,posx2;posy,posy2]; + md.stressbalance.vertex_pairing=[posx,posx2;posy,posy2]; - %Compute the diagnostic + %Compute the stressbalance md.cluster=generic('name',oshostname(),'np',8); - md=solve(md,DiagnosticSolutionEnum()); + md=solve(md,StressbalanceSolutionEnum()); %Plot the results and save them - vx=(md.results.DiagnosticSolution.Vx); - vy=(md.results.DiagnosticSolution.Vy); - vz=(md.results.DiagnosticSolution.Vz); - results{i}=md.results.DiagnosticSolution; + vx=(md.results.StressbalanceSolution.Vx); + vy=(md.results.StressbalanceSolution.Vy); + vz=(md.results.StressbalanceSolution.Vz); + results{i}=md.results.StressbalanceSolution; minvx(i)=min(vx(end-md.mesh.numberofvertices2d+1:end)); maxvx(i)=max(vx(end-md.mesh.numberofvertices2d+1:end)); Index: /issm/trunk-jpl/test/NightlyRun/test1101.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test1101.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test1101.py (revision 15771) @@ -35,11 +35,11 @@ #Create dirichlet on the bed only - md.diagnostic.spcvx=float('NaN')*numpy.ones((md.mesh.numberofvertices,1)) - md.diagnostic.spcvy=float('NaN')*numpy.ones((md.mesh.numberofvertices,1)) - md.diagnostic.spcvz=float('NaN')*numpy.ones((md.mesh.numberofvertices,1)) + md.stressbalance.spcvx=float('NaN')*numpy.ones((md.mesh.numberofvertices,1)) + md.stressbalance.spcvy=float('NaN')*numpy.ones((md.mesh.numberofvertices,1)) + md.stressbalance.spcvz=float('NaN')*numpy.ones((md.mesh.numberofvertices,1)) pos=numpy.nonzero(md.mesh.vertexonbed) - md.diagnostic.spcvx[pos]=0. - md.diagnostic.spcvy[pos]=0. + md.stressbalance.spcvx[pos]=0. + md.stressbalance.spcvy[pos]=0. #Create MPCs to have periodic boundary conditions @@ -50,15 +50,15 @@ posy2=numpy.nonzero(logical_and_n(md.mesh.y==numpy.max(md.mesh.y),md.mesh.x!=0.,md.mesh.x!=numpy.max(md.mesh.x)))[0] - md.diagnostic.vertex_pairing=numpy.vstack((numpy.hstack((posx.reshape(-1,1)+1,posx2.reshape(-1,1)+1)),numpy.hstack((posy.reshape(-1,1)+1,posy2.reshape(-1,1)+1)))) + md.stressbalance.vertex_pairing=numpy.vstack((numpy.hstack((posx.reshape(-1,1)+1,posx2.reshape(-1,1)+1)),numpy.hstack((posy.reshape(-1,1)+1,posy2.reshape(-1,1)+1)))) - #Compute the diagnostic + #Compute the stressbalance md.cluster=generic('name',oshostname(),'np',8) - md=solve(md,DiagnosticSolutionEnum()) + md=solve(md,StressbalanceSolutionEnum()) #Plot the results and save them - vx=md.results.DiagnosticSolution.Vx - vy=md.results.DiagnosticSolution.Vy - vz=md.results.DiagnosticSolution.Vz - results.append(md.results.DiagnosticSolution) + vx=md.results.StressbalanceSolution.Vx + vy=md.results.StressbalanceSolution.Vy + vz=md.results.StressbalanceSolution.Vz + results.append(md.results.StressbalanceSolution) minvx.append(numpy.min(vx[-md.mesh.numberofvertices2d:])) maxvx.append(numpy.max(vx[-md.mesh.numberofvertices2d:])) Index: /issm/trunk-jpl/test/NightlyRun/test1102.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test1102.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test1102.m (revision 15771) @@ -29,7 +29,7 @@ %Create dirichlet on the bed only pos=find(md.mesh.vertexonbed); - md.diagnostic.spcvx(pos)=0.; - md.diagnostic.spcvy(pos)=0.; - md.diagnostic.spcvz(pos)=0.; + md.stressbalance.spcvx(pos)=0.; + md.stressbalance.spcvy(pos)=0.; + md.stressbalance.spcvz(pos)=0.; % %Create MPCs to have periodic boundary conditions @@ -42,19 +42,19 @@ % posy2=find(md.mesh.y==max(md.mesh.y) & md.mesh.x~=0. & md.mesh.x~=max(md.mesh.x) & ~md.mesh.vertexonbed); -% md.diagnostic.vertex_pairing=[posx,posx2;posy,posy2]; +% md.stressbalance.vertex_pairing=[posx,posx2;posy,posy2]; - %Compute the diagnostic - md.diagnostic.abstol=NaN; - md.diagnostic.reltol=NaN; - md.diagnostic.restol=1.; + %Compute the stressbalance + md.stressbalance.abstol=NaN; + md.stressbalance.reltol=NaN; + md.stressbalance.restol=1.; md.cluster=generic('name',oshostname(),'np',8); - md=solve(md,DiagnosticSolutionEnum()); + md=solve(md,StressbalanceSolutionEnum()); %Plot the results and save them - vx=(md.results.DiagnosticSolution.Vx); - vy=(md.results.DiagnosticSolution.Vy); - vz=(md.results.DiagnosticSolution.Vz); - pressure=(md.results.DiagnosticSolution.Pressure); - results{i}=md.results.DiagnosticSolution; + vx=(md.results.StressbalanceSolution.Vx); + vy=(md.results.StressbalanceSolution.Vy); + vz=(md.results.StressbalanceSolution.Vz); + pressure=(md.results.StressbalanceSolution.Pressure); + results{i}=md.results.StressbalanceSolution; minvx(i)=min(vx(end-md.mesh.numberofvertices2d+1:end)); maxvx(i)=max(vx(end-md.mesh.numberofvertices2d+1:end)); Index: /issm/trunk-jpl/test/NightlyRun/test1102.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test1102.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test1102.py (revision 15771) @@ -43,7 +43,7 @@ #Create dirichlet on the bed only pos=numpy.nonzero(md.mesh.vertexonbed) - md.diagnostic.spcvx[pos]=0. - md.diagnostic.spcvy[pos]=0. - md.diagnostic.spcvz[pos]=0. + md.stressbalance.spcvx[pos]=0. + md.stressbalance.spcvy[pos]=0. + md.stressbalance.spcvz[pos]=0. # #Create MPCs to have periodic boundary conditions @@ -56,19 +56,19 @@ # posy2=numpy.nonzero(logical_and_n(md.mesh.y==numpy.max(md.mesh.y),md.mesh.x!=0.,md.mesh.x!=numpy.max(md.mesh.x),numpy.logical_not(md.mesh.vertexonbed)))[0] -# md.diagnostic.vertex_pairing=numpy.vstack((numpy.hstack((posx.reshape(-1,1)+1,posx2.reshape(-1,1)+1)),numpy.hstack((posy.reshape(-1,1)+1,posy2.reshape(-1,1)+1)))) +# md.stressbalance.vertex_pairing=numpy.vstack((numpy.hstack((posx.reshape(-1,1)+1,posx2.reshape(-1,1)+1)),numpy.hstack((posy.reshape(-1,1)+1,posy2.reshape(-1,1)+1)))) - #Compute the diagnostic - md.diagnostic.abstol=float('NaN') - md.diagnostic.reltol=float('NaN') - md.diagnostic.restol=1. + #Compute the stressbalance + md.stressbalance.abstol=float('NaN') + md.stressbalance.reltol=float('NaN') + md.stressbalance.restol=1. md.cluster=generic('name',oshostname(),'np',8) - md=solve(md,DiagnosticSolutionEnum()) + md=solve(md,StressbalanceSolutionEnum()) #Plot the results and save them - vx=md.results.DiagnosticSolution.Vx - vy=md.results.DiagnosticSolution.Vy - vz=md.results.DiagnosticSolution.Vz - pressure=md.results.DiagnosticSolution.Pressure - results.append(md.results.DiagnosticSolution) + vx=md.results.StressbalanceSolution.Vx + vy=md.results.StressbalanceSolution.Vy + vz=md.results.StressbalanceSolution.Vz + pressure=md.results.StressbalanceSolution.Pressure + results.append(md.results.StressbalanceSolution) minvx.append(numpy.min(vx[-md.mesh.numberofvertices2d:])) maxvx.append(numpy.max(vx[-md.mesh.numberofvertices2d:])) Index: /issm/trunk-jpl/test/NightlyRun/test1103.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test1103.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test1103.m (revision 15771) @@ -21,10 +21,10 @@ %Create dirichlet on the bed only - md.diagnostic.spcvx=NaN*ones(md.mesh.numberofvertices,1); - md.diagnostic.spcvy=NaN*ones(md.mesh.numberofvertices,1); - md.diagnostic.spcvz=NaN*ones(md.mesh.numberofvertices,1); + md.stressbalance.spcvx=NaN*ones(md.mesh.numberofvertices,1); + md.stressbalance.spcvy=NaN*ones(md.mesh.numberofvertices,1); + md.stressbalance.spcvz=NaN*ones(md.mesh.numberofvertices,1); pos=find(md.mesh.vertexonbed); - md.diagnostic.spcvx(pos)=0.; - md.diagnostic.spcvy(pos)=0.; + md.stressbalance.spcvx(pos)=0.; + md.stressbalance.spcvy(pos)=0.; %Create MPCs to have periodic boundary conditions @@ -35,15 +35,15 @@ posy2=find(md.mesh.y==max(md.mesh.y) & md.mesh.x~=0. & md.mesh.x~=max(md.mesh.x)); - md.diagnostic.vertex_pairing=[posx,posx2;posy,posy2]; + md.stressbalance.vertex_pairing=[posx,posx2;posy,posy2]; - %Compute the diagnostic + %Compute the stressbalance md.cluster=generic('name',oshostname(),'np',8); - md=solve(md,DiagnosticSolutionEnum()); + md=solve(md,StressbalanceSolutionEnum()); %Plot the results and save them - vx=(md.results.DiagnosticSolution.Vx); - vy=(md.results.DiagnosticSolution.Vy); - vz=(md.results.DiagnosticSolution.Vz); - results{i}=md.results.DiagnosticSolution; + vx=(md.results.StressbalanceSolution.Vx); + vy=(md.results.StressbalanceSolution.Vy); + vz=(md.results.StressbalanceSolution.Vz); + results{i}=md.results.StressbalanceSolution; minvx(i)=min(vx(end-md.mesh.numberofvertices2d+1:end)); maxvx(i)=max(vx(end-md.mesh.numberofvertices2d+1:end)); Index: /issm/trunk-jpl/test/NightlyRun/test1103.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test1103.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test1103.py (revision 15771) @@ -35,10 +35,10 @@ #Create dirichlet on the bed only - md.diagnostic.spcvx=float('NaN')*numpy.ones((md.mesh.numberofvertices,1)) - md.diagnostic.spcvy=float('NaN')*numpy.ones((md.mesh.numberofvertices,1)) - md.diagnostic.spcvz=float('NaN')*numpy.ones((md.mesh.numberofvertices,1)) + md.stressbalance.spcvx=float('NaN')*numpy.ones((md.mesh.numberofvertices,1)) + md.stressbalance.spcvy=float('NaN')*numpy.ones((md.mesh.numberofvertices,1)) + md.stressbalance.spcvz=float('NaN')*numpy.ones((md.mesh.numberofvertices,1)) pos=numpy.nonzero(md.mesh.vertexonbed) - md.diagnostic.spcvx[pos]=0. - md.diagnostic.spcvy[pos]=0. + md.stressbalance.spcvx[pos]=0. + md.stressbalance.spcvy[pos]=0. #Create MPCs to have periodic boundary conditions @@ -49,15 +49,15 @@ posy2=numpy.nonzero(logical_and_n(md.mesh.y==numpy.max(md.mesh.y),md.mesh.x!=0.,md.mesh.x!=numpy.max(md.mesh.x)))[0] - md.diagnostic.vertex_pairing=numpy.vstack((numpy.hstack((posx.reshape(-1,1)+1,posx2.reshape(-1,1)+1)),numpy.hstack((posy.reshape(-1,1)+1,posy2.reshape(-1,1)+1)))) + md.stressbalance.vertex_pairing=numpy.vstack((numpy.hstack((posx.reshape(-1,1)+1,posx2.reshape(-1,1)+1)),numpy.hstack((posy.reshape(-1,1)+1,posy2.reshape(-1,1)+1)))) - #Compute the diagnostic + #Compute the stressbalance md.cluster=generic('name',oshostname(),'np',8) - md=solve(md,DiagnosticSolutionEnum()) + md=solve(md,StressbalanceSolutionEnum()) #Plot the results and save them - vx=md.results.DiagnosticSolution.Vx - vy=md.results.DiagnosticSolution.Vy - vz=md.results.DiagnosticSolution.Vz - results.append(md.results.DiagnosticSolution) + vx=md.results.StressbalanceSolution.Vx + vy=md.results.StressbalanceSolution.Vy + vz=md.results.StressbalanceSolution.Vz + results.append(md.results.StressbalanceSolution) minvx.append(numpy.min(vx[md.mesh.numberofvertices2d:])) maxvx.append(numpy.max(vx[md.mesh.numberofvertices2d:])) Index: /issm/trunk-jpl/test/NightlyRun/test1104.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test1104.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test1104.m (revision 15771) @@ -17,11 +17,11 @@ %Create dirichlet on the bed only - md.diagnostic.spcvx=NaN*ones(md.mesh.numberofvertices,1); - md.diagnostic.spcvy=NaN*ones(md.mesh.numberofvertices,1); - md.diagnostic.spcvz=NaN*ones(md.mesh.numberofvertices,1); + md.stressbalance.spcvx=NaN*ones(md.mesh.numberofvertices,1); + md.stressbalance.spcvy=NaN*ones(md.mesh.numberofvertices,1); + md.stressbalance.spcvz=NaN*ones(md.mesh.numberofvertices,1); pos=find(md.mesh.vertexonbed); - md.diagnostic.spcvx(pos)=0.; - md.diagnostic.spcvy(pos)=0.; + md.stressbalance.spcvx(pos)=0.; + md.stressbalance.spcvy(pos)=0.; %Create MPCs to have periodic boundary conditions @@ -32,22 +32,22 @@ posy2=find(md.mesh.y==max(md.mesh.y) & md.mesh.x~=0. & md.mesh.x~=max(md.mesh.x)); - md.diagnostic.vertex_pairing=[posx,posx2;posy,posy2]; + md.stressbalance.vertex_pairing=[posx,posx2;posy,posy2]; - %Compute the diagnostic - md.diagnostic.abstol=NaN; + %Compute the stressbalance + md.stressbalance.abstol=NaN; md.cluster=generic('name',oshostname(),'np',8); - md=solve(md,DiagnosticSolutionEnum()); + md=solve(md,StressbalanceSolutionEnum()); pos=find(md.mesh.x==0. | md.mesh.y==0. | md.mesh.x==max(md.mesh.x) | md.mesh.y==max(md.mesh.y)); - md.diagnostic.spcvx(pos)=md.results.DiagnosticSolution.Vx(pos); - md.diagnostic.spcvy(pos)=md.results.DiagnosticSolution.Vy(pos); - md.diagnostic.vertex_pairing=[]; + md.stressbalance.spcvx(pos)=md.results.StressbalanceSolution.Vx(pos); + md.stressbalance.spcvy(pos)=md.results.StressbalanceSolution.Vy(pos); + md.stressbalance.vertex_pairing=[]; md=setflowequation(md,'FS','all'); - md=solve(md,DiagnosticSolutionEnum()); + md=solve(md,StressbalanceSolutionEnum()); %Plot the results and save them - vx=(md.results.DiagnosticSolution.Vx); - vy=(md.results.DiagnosticSolution.Vy); - vz=(md.results.DiagnosticSolution.Vz); - results{i}=md.results.DiagnosticSolution; + vx=(md.results.StressbalanceSolution.Vx); + vy=(md.results.StressbalanceSolution.Vy); + vz=(md.results.StressbalanceSolution.Vz); + results{i}=md.results.StressbalanceSolution; plotmodel(md,'data',vx,'data',vy,'data',vz,'layer#all',md.mesh.numberoflayers) Index: /issm/trunk-jpl/test/NightlyRun/test1104.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test1104.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test1104.py (revision 15771) @@ -29,11 +29,11 @@ #Create dirichlet on the bed only - md.diagnostic.spcvx=float('NaN')*numpy.ones((md.mesh.numberofvertices,1)) - md.diagnostic.spcvy=float('NaN')*numpy.ones((md.mesh.numberofvertices,1)) - md.diagnostic.spcvz=float('NaN')*numpy.ones((md.mesh.numberofvertices,1)) + md.stressbalance.spcvx=float('NaN')*numpy.ones((md.mesh.numberofvertices,1)) + md.stressbalance.spcvy=float('NaN')*numpy.ones((md.mesh.numberofvertices,1)) + md.stressbalance.spcvz=float('NaN')*numpy.ones((md.mesh.numberofvertices,1)) pos=numpy.nonzero(md.mesh.vertexonbed) - md.diagnostic.spcvx[pos]=0. - md.diagnostic.spcvy[pos]=0. + md.stressbalance.spcvx[pos]=0. + md.stressbalance.spcvy[pos]=0. #Create MPCs to have periodic boundary conditions @@ -44,22 +44,22 @@ posy2=numpy.nonzero(logical_and_n(md.mesh.y==numpy.max(md.mesh.y),md.mesh.x!=0.,md.mesh.x!=numpy.max(md.mesh.x)))[0] - md.diagnostic.vertex_pairing=numpy.vstack((numpy.hstack((posx.reshape(-1,1)+1,posx2.reshape(-1,1)+1)),numpy.hstack((posy.reshape(-1,1)+1,posy2.reshape(-1,1)+1)))) + md.stressbalance.vertex_pairing=numpy.vstack((numpy.hstack((posx.reshape(-1,1)+1,posx2.reshape(-1,1)+1)),numpy.hstack((posy.reshape(-1,1)+1,posy2.reshape(-1,1)+1)))) - #Compute the diagnostic - md.diagnostic.abstol=float('NaN') + #Compute the stressbalance + md.stressbalance.abstol=float('NaN') md.cluster=generic('name',oshostname(),'np',8) - md=solve(md,DiagnosticSolutionEnum()) + md=solve(md,StressbalanceSolutionEnum()) pos=numpy.nonzero(logical_or_n(md.mesh.x==0.,md.mesh.y==0.,md.mesh.x==numpy.max(md.mesh.x),md.mesh.y==numpy.max(md.mesh.y))) - md.diagnostic.spcvx[pos]=md.results.DiagnosticSolution.Vx[pos] - md.diagnostic.spcvy[pos]=md.results.DiagnosticSolution.Vy[pos] - md.diagnostic.vertex_pairing=numpy.empty((0,2),int) + md.stressbalance.spcvx[pos]=md.results.StressbalanceSolution.Vx[pos] + md.stressbalance.spcvy[pos]=md.results.StressbalanceSolution.Vy[pos] + md.stressbalance.vertex_pairing=numpy.empty((0,2),int) md=setflowequation(md,'FS','all') - md=solve(md,DiagnosticSolutionEnum()) + md=solve(md,StressbalanceSolutionEnum()) #Plot the results and save them - vx=md.results.DiagnosticSolution.Vx - vy=md.results.DiagnosticSolution.Vy - vz=md.results.DiagnosticSolution.Vz - results.append(md.results.DiagnosticSolution) + vx=md.results.StressbalanceSolution.Vx + vy=md.results.StressbalanceSolution.Vy + vz=md.results.StressbalanceSolution.Vz + results.append(md.results.StressbalanceSolution) # plotmodel(md,'data',vx,'data',vy,'data',vz,'layer#all',md.mesh.numberoflayers) Index: /issm/trunk-jpl/test/NightlyRun/test1105.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test1105.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test1105.m (revision 15771) @@ -21,7 +21,7 @@ %Create MPCs to have periodic boundary conditions - md.diagnostic.spcvx=NaN*ones(md.mesh.numberofvertices,1); - md.diagnostic.spcvy=NaN*ones(md.mesh.numberofvertices,1); - md.diagnostic.spcvz=NaN*ones(md.mesh.numberofvertices,1); + md.stressbalance.spcvx=NaN*ones(md.mesh.numberofvertices,1); + md.stressbalance.spcvy=NaN*ones(md.mesh.numberofvertices,1); + md.stressbalance.spcvz=NaN*ones(md.mesh.numberofvertices,1); posx=find(md.mesh.x==0. & md.mesh.y~=0. & md.mesh.y~=L); @@ -31,43 +31,43 @@ posy2=find(md.mesh.y==L & md.mesh.x~=0. & md.mesh.x~=L); - md.diagnostic.vertex_pairing=[posx,posx2;posy,posy2]; + md.stressbalance.vertex_pairing=[posx,posx2;posy,posy2]; %Add spc on the corners pos=find((md.mesh.x==0. | md.mesh.x==L) & (md.mesh.y==0. | md.mesh.y==L) & md.mesh.vertexonbed); - md.diagnostic.spcvx(pos)=0.; - md.diagnostic.spcvy(pos)=0.; + md.stressbalance.spcvx(pos)=0.; + md.stressbalance.spcvy(pos)=0.; if(L==5000.), - md.diagnostic.spcvx(pos)=15.66; - md.diagnostic.spcvy(pos)=-0.1967; + md.stressbalance.spcvx(pos)=15.66; + md.stressbalance.spcvy(pos)=-0.1967; elseif(L==10000.), - md.diagnostic.spcvx(pos)=16.04; - md.diagnostic.spcvy(pos)=-0.1977; + md.stressbalance.spcvx(pos)=16.04; + md.stressbalance.spcvy(pos)=-0.1977; elseif(L==20000.), - md.diagnostic.spcvx(pos)=16.53; - md.diagnostic.spcvy(pos)=-1.27; + md.stressbalance.spcvx(pos)=16.53; + md.stressbalance.spcvy(pos)=-1.27; elseif(L==40000.), - md.diagnostic.spcvx(pos)=17.23; - md.diagnostic.spcvy(pos)=-3.17; + md.stressbalance.spcvx(pos)=17.23; + md.stressbalance.spcvy(pos)=-3.17; elseif(L==80000.), - md.diagnostic.spcvx(pos)=16.68; - md.diagnostic.spcvy(pos)=-2.69; + md.stressbalance.spcvx(pos)=16.68; + md.stressbalance.spcvy(pos)=-2.69; elseif(L==160000.), - md.diagnostic.spcvx(pos)=16.03; - md.diagnostic.spcvy(pos)=-1.27; + md.stressbalance.spcvx(pos)=16.03; + md.stressbalance.spcvy(pos)=-1.27; end %Spc the bed at zero for vz pos=find(md.mesh.vertexonbed); - md.diagnostic.spcvz(pos)=0.; + md.stressbalance.spcvz(pos)=0.; - %Compute the diagnostic + %Compute the stressbalance md.cluster=generic('name',oshostname(),'np',8); - md=solve(md,DiagnosticSolutionEnum()); + md=solve(md,StressbalanceSolutionEnum()); %Plot the results and save them - vx=(md.results.DiagnosticSolution.Vx); - vy=(md.results.DiagnosticSolution.Vy); - vz=(md.results.DiagnosticSolution.Vz); - results{i}=md.results.DiagnosticSolution; + vx=(md.results.StressbalanceSolution.Vx); + vy=(md.results.StressbalanceSolution.Vy); + vz=(md.results.StressbalanceSolution.Vz); + results{i}=md.results.StressbalanceSolution; minvx(i)=min(vx(end-md.mesh.numberofvertices2d+1:end)); maxvx(i)=max(vx(end-md.mesh.numberofvertices2d+1:end)); Index: /issm/trunk-jpl/test/NightlyRun/test1105.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test1105.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test1105.py (revision 15771) @@ -35,7 +35,7 @@ #Create MPCs to have periodic boundary conditions - md.diagnostic.spcvx=float('NaN')*numpy.ones((md.mesh.numberofvertices,1)) - md.diagnostic.spcvy=float('NaN')*numpy.ones((md.mesh.numberofvertices,1)) - md.diagnostic.spcvz=float('NaN')*numpy.ones((md.mesh.numberofvertices,1)) + md.stressbalance.spcvx=float('NaN')*numpy.ones((md.mesh.numberofvertices,1)) + md.stressbalance.spcvy=float('NaN')*numpy.ones((md.mesh.numberofvertices,1)) + md.stressbalance.spcvz=float('NaN')*numpy.ones((md.mesh.numberofvertices,1)) posx=numpy.nonzero(logical_and_n(md.mesh.x==0.,md.mesh.y!=0.,md.mesh.y!=L))[0] @@ -45,42 +45,42 @@ posy2=numpy.nonzero(logical_and_n(md.mesh.y==L,md.mesh.x!=0.,md.mesh.x!=L))[0] - md.diagnostic.vertex_pairing=numpy.vstack((numpy.hstack((posx.reshape(-1,1)+1,posx2.reshape(-1,1)+1)),numpy.hstack((posy.reshape(-1,1)+1,posy2.reshape(-1,1)+1)))) + md.stressbalance.vertex_pairing=numpy.vstack((numpy.hstack((posx.reshape(-1,1)+1,posx2.reshape(-1,1)+1)),numpy.hstack((posy.reshape(-1,1)+1,posy2.reshape(-1,1)+1)))) #Add spc on the corners pos=numpy.nonzero(logical_and_n(numpy.logical_or(md.mesh.x==0.,md.mesh.x==L),numpy.logical_or(md.mesh.y==0.,md.mesh.y==L),md.mesh.vertexonbed)) - md.diagnostic.spcvx[pos]=0. - md.diagnostic.spcvy[pos]=0. + md.stressbalance.spcvx[pos]=0. + md.stressbalance.spcvy[pos]=0. if (L==5000.): - md.diagnostic.spcvx[pos]=15.66 - md.diagnostic.spcvy[pos]=-0.1967 + md.stressbalance.spcvx[pos]=15.66 + md.stressbalance.spcvy[pos]=-0.1967 elif (L==10000.): - md.diagnostic.spcvx[pos]=16.04 - md.diagnostic.spcvy[pos]=-0.1977 + md.stressbalance.spcvx[pos]=16.04 + md.stressbalance.spcvy[pos]=-0.1977 elif (L==20000.): - md.diagnostic.spcvx[pos]=16.53 - md.diagnostic.spcvy[pos]=-1.27 + md.stressbalance.spcvx[pos]=16.53 + md.stressbalance.spcvy[pos]=-1.27 elif (L==40000.): - md.diagnostic.spcvx[pos]=17.23 - md.diagnostic.spcvy[pos]=-3.17 + md.stressbalance.spcvx[pos]=17.23 + md.stressbalance.spcvy[pos]=-3.17 elif (L==80000.): - md.diagnostic.spcvx[pos]=16.68 - md.diagnostic.spcvy[pos]=-2.69 + md.stressbalance.spcvx[pos]=16.68 + md.stressbalance.spcvy[pos]=-2.69 elif (L==160000.): - md.diagnostic.spcvx[pos]=16.03 - md.diagnostic.spcvy[pos]=-1.27 + md.stressbalance.spcvx[pos]=16.03 + md.stressbalance.spcvy[pos]=-1.27 #Spc the bed at zero for vz pos=numpy.nonzero(md.mesh.vertexonbed) - md.diagnostic.spcvz[pos]=0. + md.stressbalance.spcvz[pos]=0. - #Compute the diagnostic + #Compute the stressbalance md.cluster=generic('name',oshostname(),'np',8) - md=solve(md,DiagnosticSolutionEnum()) + md=solve(md,StressbalanceSolutionEnum()) #Plot the results and save them - vx=md.results.DiagnosticSolution.Vx - vy=md.results.DiagnosticSolution.Vy - vz=md.results.DiagnosticSolution.Vz - results.append(md.results.DiagnosticSolution) + vx=md.results.StressbalanceSolution.Vx + vy=md.results.StressbalanceSolution.Vy + vz=md.results.StressbalanceSolution.Vz + results.append(md.results.StressbalanceSolution) minvx.append(numpy.min(vx[-md.mesh.numberofvertices2d:])) maxvx.append(numpy.max(vx[-md.mesh.numberofvertices2d:])) Index: /issm/trunk-jpl/test/NightlyRun/test1106.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test1106.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test1106.m (revision 15771) @@ -15,37 +15,37 @@ %Add spc on the borders pos=find(md.mesh.x==0. | md.mesh.x==max(md.mesh.x) | md.mesh.y==0. | md.mesh.y==max(md.mesh.y)); - md.diagnostic.spcvx(pos)=0.; - md.diagnostic.spcvy(pos)=0.; + md.stressbalance.spcvx(pos)=0.; + md.stressbalance.spcvy(pos)=0.; if(L==5000.), - md.diagnostic.spcvx(pos)=15.66; - md.diagnostic.spcvy(pos)=-0.1967; + md.stressbalance.spcvx(pos)=15.66; + md.stressbalance.spcvy(pos)=-0.1967; elseif(L==10000.), - md.diagnostic.spcvx(pos)=16.04; - md.diagnostic.spcvy(pos)=-0.1977; + md.stressbalance.spcvx(pos)=16.04; + md.stressbalance.spcvy(pos)=-0.1977; elseif(L==20000.), - md.diagnostic.spcvx(pos)=16.53; - md.diagnostic.spcvy(pos)=-1.27; + md.stressbalance.spcvx(pos)=16.53; + md.stressbalance.spcvy(pos)=-1.27; elseif(L==40000.), - md.diagnostic.spcvx(pos)=17.23; - md.diagnostic.spcvy(pos)=-3.17; + md.stressbalance.spcvx(pos)=17.23; + md.stressbalance.spcvy(pos)=-3.17; elseif(L==80000.), - md.diagnostic.spcvx(pos)=16.68; - md.diagnostic.spcvy(pos)=-2.69; + md.stressbalance.spcvx(pos)=16.68; + md.stressbalance.spcvy(pos)=-2.69; elseif(L==160000.), - md.diagnostic.spcvx(pos)=16.03; - md.diagnostic.spcvy(pos)=-1.27; + md.stressbalance.spcvx(pos)=16.03; + md.stressbalance.spcvy(pos)=-1.27; end md=setflowequation(md,'FS','all'); - %Compute the diagnostic + %Compute the stressbalance md.cluster=generic('name',oshostname(),'np',8); - md=solve(md,DiagnosticSolutionEnum()); + md=solve(md,StressbalanceSolutionEnum()); %Plot the results and save them - vx=(md.results.DiagnosticSolution.Vx); - vy=(md.results.DiagnosticSolution.Vy); - vz=(md.results.DiagnosticSolution.Vz); - results{i}=md.results.DiagnosticSolution; + vx=(md.results.StressbalanceSolution.Vx); + vy=(md.results.StressbalanceSolution.Vy); + vz=(md.results.StressbalanceSolution.Vz); + results{i}=md.results.StressbalanceSolution; plotmodel(md,'data',vx,'data',vy,'data',vz,'layer#all',md.mesh.numberoflayers) Index: /issm/trunk-jpl/test/NightlyRun/test1106.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test1106.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test1106.py (revision 15771) @@ -27,36 +27,36 @@ #Add spc on the borders pos=numpy.nonzero(logical_or_n(md.mesh.x==0.,md.mesh.x==numpy.max(md.mesh.x),md.mesh.y==0.,md.mesh.y==numpy.max(md.mesh.y))) - md.diagnostic.spcvx[pos]=0. - md.diagnostic.spcvy[pos]=0. + md.stressbalance.spcvx[pos]=0. + md.stressbalance.spcvy[pos]=0. if (L==5000.): - md.diagnostic.spcvx[pos]=15.66 - md.diagnostic.spcvy[pos]=-0.1967 + md.stressbalance.spcvx[pos]=15.66 + md.stressbalance.spcvy[pos]=-0.1967 elif (L==10000.): - md.diagnostic.spcvx[pos]=16.04 - md.diagnostic.spcvy[pos]=-0.1977 + md.stressbalance.spcvx[pos]=16.04 + md.stressbalance.spcvy[pos]=-0.1977 elif (L==20000.): - md.diagnostic.spcvx[pos]=16.53 - md.diagnostic.spcvy[pos]=-1.27 + md.stressbalance.spcvx[pos]=16.53 + md.stressbalance.spcvy[pos]=-1.27 elif (L==40000.): - md.diagnostic.spcvx[pos]=17.23 - md.diagnostic.spcvy[pos]=-3.17 + md.stressbalance.spcvx[pos]=17.23 + md.stressbalance.spcvy[pos]=-3.17 elif (L==80000.): - md.diagnostic.spcvx[pos]=16.68 - md.diagnostic.spcvy[pos]=-2.69 + md.stressbalance.spcvx[pos]=16.68 + md.stressbalance.spcvy[pos]=-2.69 elif (L==160000.): - md.diagnostic.spcvx[pos]=16.03 - md.diagnostic.spcvy[pos]=-1.27 + md.stressbalance.spcvx[pos]=16.03 + md.stressbalance.spcvy[pos]=-1.27 md=setflowequation(md,'FS','all') - #Compute the diagnostic + #Compute the stressbalance md.cluster=generic('name',oshostname(),'np',8) - md=solve(md,DiagnosticSolutionEnum()) + md=solve(md,StressbalanceSolutionEnum()) #Plot the results and save them - vx=md.results.DiagnosticSolution.Vx - vy=md.results.DiagnosticSolution.Vy - vz=md.results.DiagnosticSolution.Vz - results.append(md.results.DiagnosticSolution) + vx=md.results.StressbalanceSolution.Vx + vy=md.results.StressbalanceSolution.Vy + vz=md.results.StressbalanceSolution.Vz + results.append(md.results.StressbalanceSolution) # plotmodel(md,'data',vx,'data',vy,'data',vz,'layer#all',md.mesh.numberoflayers) Index: /issm/trunk-jpl/test/NightlyRun/test1107.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test1107.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test1107.m (revision 15771) @@ -21,7 +21,7 @@ %We need one grd on dirichlet: the 4 corners are set to zero - md.diagnostic.spcvx=NaN*ones(md.mesh.numberofvertices,1); - md.diagnostic.spcvy=NaN*ones(md.mesh.numberofvertices,1); - md.diagnostic.spcvz=NaN*ones(md.mesh.numberofvertices,1); + md.stressbalance.spcvx=NaN*ones(md.mesh.numberofvertices,1); + md.stressbalance.spcvy=NaN*ones(md.mesh.numberofvertices,1); + md.stressbalance.spcvz=NaN*ones(md.mesh.numberofvertices,1); %Create MPCs to have periodic boundary conditions @@ -32,37 +32,37 @@ posy2=find(md.mesh.y==max(md.mesh.y) & md.mesh.x~=0. & md.mesh.x~=max(md.mesh.x)); - md.diagnostic.vertex_pairing=[posx,posx2;posy,posy2]; + md.stressbalance.vertex_pairing=[posx,posx2;posy,posy2]; %Add spc on the corners pos=find((md.mesh.x==0. | md.mesh.x==L) & (md.mesh.y==0. | md.mesh.y==L) & md.mesh.vertexonbed); - md.diagnostic.spcvy(:)=0.; - md.diagnostic.spcvx(pos)=0.; + md.stressbalance.spcvy(:)=0.; + md.stressbalance.spcvx(pos)=0.; if(L==5000.), - md.diagnostic.spcvx(pos)=16.0912; + md.stressbalance.spcvx(pos)=16.0912; elseif(L==10000.), - md.diagnostic.spcvx(pos)=16.52; + md.stressbalance.spcvx(pos)=16.52; elseif(L==20000.), - md.diagnostic.spcvx(pos)=17.77; + md.stressbalance.spcvx(pos)=17.77; elseif(L==40000.), - md.diagnostic.spcvx(pos)=19.88; + md.stressbalance.spcvx(pos)=19.88; elseif(L==80000.), - md.diagnostic.spcvx(pos)=18.65; + md.stressbalance.spcvx(pos)=18.65; elseif(L==160000.), - md.diagnostic.spcvx(pos)=16.91; + md.stressbalance.spcvx(pos)=16.91; end %Spc the bed at zero for vz pos=find(md.mesh.vertexonbed); - md.diagnostic.spcvz(pos)=0.; + md.stressbalance.spcvz(pos)=0.; - %Compute the diagnostic + %Compute the stressbalance md.cluster=generic('name',oshostname(),'np',8); - md=solve(md,DiagnosticSolutionEnum()); + md=solve(md,StressbalanceSolutionEnum()); %Plot the results and save them - vx=(md.results.DiagnosticSolution.Vx); - vy=(md.results.DiagnosticSolution.Vy); - vz=(md.results.DiagnosticSolution.Vz); - results{i}=md.results.DiagnosticSolution; + vx=(md.results.StressbalanceSolution.Vx); + vy=(md.results.StressbalanceSolution.Vy); + vz=(md.results.StressbalanceSolution.Vz); + results{i}=md.results.StressbalanceSolution; minvx(i)=min(vx(end-md.mesh.numberofvertices2d+1:end)); maxvx(i)=max(vx(end-md.mesh.numberofvertices2d+1:end)); Index: /issm/trunk-jpl/test/NightlyRun/test1107.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test1107.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test1107.py (revision 15771) @@ -35,7 +35,7 @@ #We need one grd on dirichlet: the 4 corners are set to zero - md.diagnostic.spcvx=float('NaN')*numpy.ones((md.mesh.numberofvertices,1)) - md.diagnostic.spcvy=float('NaN')*numpy.ones((md.mesh.numberofvertices,1)) - md.diagnostic.spcvz=float('NaN')*numpy.ones((md.mesh.numberofvertices,1)) + md.stressbalance.spcvx=float('NaN')*numpy.ones((md.mesh.numberofvertices,1)) + md.stressbalance.spcvy=float('NaN')*numpy.ones((md.mesh.numberofvertices,1)) + md.stressbalance.spcvz=float('NaN')*numpy.ones((md.mesh.numberofvertices,1)) #Create MPCs to have periodic boundary conditions @@ -48,36 +48,36 @@ posy2=numpy.nonzero(logical_and_n(md.mesh.y==numpy.max(md.mesh.y),md.mesh.x!=0.,md.mesh.x!=numpy.max(md.mesh.x)))[0] - md.diagnostic.vertex_pairing=numpy.vstack((numpy.hstack((posx.reshape(-1,1)+1,posx2.reshape(-1,1)+1)),numpy.hstack((posy.reshape(-1,1)+1,posy2.reshape(-1,1)+1)))) + md.stressbalance.vertex_pairing=numpy.vstack((numpy.hstack((posx.reshape(-1,1)+1,posx2.reshape(-1,1)+1)),numpy.hstack((posy.reshape(-1,1)+1,posy2.reshape(-1,1)+1)))) #Add spc on the corners pos=numpy.nonzero(logical_and_n(numpy.logical_or(md.mesh.x==0.,md.mesh.x==L),numpy.logical_or(md.mesh.y==0.,md.mesh.y==L),md.mesh.vertexonbed)) - md.diagnostic.spcvy[:]=0. - md.diagnostic.spcvx[pos]=0. + md.stressbalance.spcvy[:]=0. + md.stressbalance.spcvx[pos]=0. if (L==5000.): - md.diagnostic.spcvx[pos]=16.0912 + md.stressbalance.spcvx[pos]=16.0912 elif (L==10000.): - md.diagnostic.spcvx[pos]=16.52 + md.stressbalance.spcvx[pos]=16.52 elif (L==20000.): - md.diagnostic.spcvx[pos]=17.77 + md.stressbalance.spcvx[pos]=17.77 elif (L==40000.): - md.diagnostic.spcvx[pos]=19.88 + md.stressbalance.spcvx[pos]=19.88 elif (L==80000.): - md.diagnostic.spcvx[pos]=18.65 + md.stressbalance.spcvx[pos]=18.65 elif (L==160000.): - md.diagnostic.spcvx[pos]=16.91 + md.stressbalance.spcvx[pos]=16.91 #Spc the bed at zero for vz pos=numpy.nonzero(md.mesh.vertexonbed) - md.diagnostic.spcvz[pos]=0. + md.stressbalance.spcvz[pos]=0. - #Compute the diagnostic + #Compute the stressbalance md.cluster=generic('name',oshostname(),'np',8) - md=solve(md,DiagnosticSolutionEnum()) + md=solve(md,StressbalanceSolutionEnum()) #Plot the results and save them - vx=md.results.DiagnosticSolution.Vx - vy=md.results.DiagnosticSolution.Vy - vz=md.results.DiagnosticSolution.Vz - results.append(md.results.DiagnosticSolution) + vx=md.results.StressbalanceSolution.Vx + vy=md.results.StressbalanceSolution.Vy + vz=md.results.StressbalanceSolution.Vz + results.append(md.results.StressbalanceSolution) minvx.append(numpy.min(vx[-md.mesh.numberofvertices2d:])) maxvx.append(numpy.max(vx[-md.mesh.numberofvertices2d:])) Index: /issm/trunk-jpl/test/NightlyRun/test1108.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test1108.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test1108.m (revision 15771) @@ -18,12 +18,12 @@ %We need one grid on dirichlet: the 4 corners are set to zero - md.diagnostic.spcvx=NaN*ones(md.mesh.numberofvertices,1); - md.diagnostic.spcvy=NaN*ones(md.mesh.numberofvertices,1); - md.diagnostic.spcvz=NaN*ones(md.mesh.numberofvertices,1); + md.stressbalance.spcvx=NaN*ones(md.mesh.numberofvertices,1); + md.stressbalance.spcvy=NaN*ones(md.mesh.numberofvertices,1); + md.stressbalance.spcvz=NaN*ones(md.mesh.numberofvertices,1); pos=find(md.mesh.vertexonbed & (md.mesh.x==0. | md.mesh.x==max(md.mesh.x)) & (md.mesh.y==0. | md.mesh.y==max(md.mesh.y))); - md.diagnostic.spcvx(pos)=0.; - md.diagnostic.spcvy(pos)=0.; - md.diagnostic.spcvz(pos)=0.; + md.stressbalance.spcvx(pos)=0.; + md.stressbalance.spcvy(pos)=0.; + md.stressbalance.spcvz(pos)=0.; %Create MPCs to have periodic boundary conditions @@ -34,28 +34,28 @@ posy2=find(md.mesh.y==max(md.mesh.y) & md.mesh.x~=0. & md.mesh.x~=max(md.mesh.x)); - md.diagnostic.vertex_pairing=[posx,posx2;posy,posy2]; + md.stressbalance.vertex_pairing=[posx,posx2;posy,posy2]; - %Compute the diagnostic + %Compute the stressbalance md.cluster=generic('name',oshostname(),'np',8); md.verbose=verbose('convergence',true); - md=solve(md,DiagnosticSolutionEnum()); - md.diagnostic.reltol=NaN; - md.diagnostic.abstol=NaN; - md.diagnostic.vertex_pairing=[]; + md=solve(md,StressbalanceSolutionEnum()); + md.stressbalance.reltol=NaN; + md.stressbalance.abstol=NaN; + md.stressbalance.vertex_pairing=[]; %We need one grd on dirichlet: the 4 corners are set to zero - md.diagnostic.spcvx=NaN*ones(md.mesh.numberofvertices,1); - md.diagnostic.spcvy=NaN*ones(md.mesh.numberofvertices,1); - md.diagnostic.spcvz=NaN*ones(md.mesh.numberofvertices,1); + md.stressbalance.spcvx=NaN*ones(md.mesh.numberofvertices,1); + md.stressbalance.spcvy=NaN*ones(md.mesh.numberofvertices,1); + md.stressbalance.spcvz=NaN*ones(md.mesh.numberofvertices,1); pos=find(md.mesh.y==0. | md.mesh.x==0. | md.mesh.x==max(md.mesh.x) | md.mesh.y==max(md.mesh.y)); %Don't take the same nodes two times - md.diagnostic.spcvx(pos)=md.results.DiagnosticSolution.Vx(pos); - md.diagnostic.spcvy(pos)=md.results.DiagnosticSolution.Vy(pos); + md.stressbalance.spcvx(pos)=md.results.StressbalanceSolution.Vx(pos); + md.stressbalance.spcvy(pos)=md.results.StressbalanceSolution.Vy(pos); md=setflowequation(md,'FS','all'); - md=solve(md,DiagnosticSolutionEnum()); + md=solve(md,StressbalanceSolutionEnum()); %Plot the results and save them - vx=(md.results.DiagnosticSolution.Vx); - vy=(md.results.DiagnosticSolution.Vy); - vz=(md.results.DiagnosticSolution.Vz); - results{i}=md.results.DiagnosticSolution; + vx=(md.results.StressbalanceSolution.Vx); + vy=(md.results.StressbalanceSolution.Vy); + vz=(md.results.StressbalanceSolution.Vz); + results{i}=md.results.StressbalanceSolution; plotmodel(md,'data',vx,'data',vy,'data',vz,'layer#all',md.mesh.numberoflayers) Index: /issm/trunk-jpl/test/NightlyRun/test1108.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test1108.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test1108.py (revision 15771) @@ -30,12 +30,12 @@ #We need one grd on dirichlet: the 4 corners are set to zero - md.diagnostic.spcvx=float('NaN')*numpy.ones((md.mesh.numberofvertices,1)) - md.diagnostic.spcvy=float('NaN')*numpy.ones((md.mesh.numberofvertices,1)) - md.diagnostic.spcvz=float('NaN')*numpy.ones((md.mesh.numberofvertices,1)) + md.stressbalance.spcvx=float('NaN')*numpy.ones((md.mesh.numberofvertices,1)) + md.stressbalance.spcvy=float('NaN')*numpy.ones((md.mesh.numberofvertices,1)) + md.stressbalance.spcvz=float('NaN')*numpy.ones((md.mesh.numberofvertices,1)) pos=numpy.nonzero(logical_and_n(md.mesh.vertexonbed,numpy.logical_or(md.mesh.x==0.,md.mesh.x==numpy.max(md.mesh.x)),numpy.logical_or(md.mesh.y==0.,md.mesh.y==numpy.max(md.mesh.y)))) - md.diagnostic.spcvx[pos]=0. - md.diagnostic.spcvy[pos]=0. - md.diagnostic.spcvz[pos]=0. + md.stressbalance.spcvx[pos]=0. + md.stressbalance.spcvy[pos]=0. + md.stressbalance.spcvz[pos]=0. #Create MPCs to have periodic boundary conditions @@ -46,28 +46,28 @@ posy2=numpy.nonzero(logical_and_n(md.mesh.y==numpy.max(md.mesh.y),md.mesh.x!=0.,md.mesh.x!=numpy.max(md.mesh.x)))[0] - md.diagnostic.vertex_pairing=numpy.vstack((numpy.hstack((posx.reshape(-1,1)+1,posx2.reshape(-1,1)+1)),numpy.hstack((posy.reshape(-1,1)+1,posy2.reshape(-1,1)+1)))) + md.stressbalance.vertex_pairing=numpy.vstack((numpy.hstack((posx.reshape(-1,1)+1,posx2.reshape(-1,1)+1)),numpy.hstack((posy.reshape(-1,1)+1,posy2.reshape(-1,1)+1)))) - #Compute the diagnostic + #Compute the stressbalance md.cluster=generic('name',oshostname(),'np',8) md.verbose=verbose('convergence',True) - md=solve(md,DiagnosticSolutionEnum()) - md.diagnostic.reltol=float('NaN') - md.diagnostic.abstol=float('NaN') - md.diagnostic.vertex_pairing=numpy.empty((0,2)) + md=solve(md,StressbalanceSolutionEnum()) + md.stressbalance.reltol=float('NaN') + md.stressbalance.abstol=float('NaN') + md.stressbalance.vertex_pairing=numpy.empty((0,2)) #We need one grid on dirichlet: the 4 corners are set to zero - md.diagnostic.spcvx=float('NaN')*numpy.ones((md.mesh.numberofvertices,1)) - md.diagnostic.spcvy=float('NaN')*numpy.ones((md.mesh.numberofvertices,1)) - md.diagnostic.spcvz=float('NaN')*numpy.ones((md.mesh.numberofvertices,1)) + md.stressbalance.spcvx=float('NaN')*numpy.ones((md.mesh.numberofvertices,1)) + md.stressbalance.spcvy=float('NaN')*numpy.ones((md.mesh.numberofvertices,1)) + md.stressbalance.spcvz=float('NaN')*numpy.ones((md.mesh.numberofvertices,1)) pos=numpy.nonzero(logical_or_n(md.mesh.y==0.,md.mesh.x==0.,md.mesh.x==numpy.max(md.mesh.x),md.mesh.y==numpy.max(md.mesh.y))) #Don't take the same nodes two times - md.diagnostic.spcvx[pos]=md.results.DiagnosticSolution.Vx[pos] - md.diagnostic.spcvy[pos]=md.results.DiagnosticSolution.Vy[pos] + md.stressbalance.spcvx[pos]=md.results.StressbalanceSolution.Vx[pos] + md.stressbalance.spcvy[pos]=md.results.StressbalanceSolution.Vy[pos] md=setflowequation(md,'FS','all') - md=solve(md,DiagnosticSolutionEnum()) + md=solve(md,StressbalanceSolutionEnum()) #Plot the results and save them - vx=md.results.DiagnosticSolution.Vx - vy=md.results.DiagnosticSolution.Vy - vz=md.results.DiagnosticSolution.Vz - results.append(md.results.DiagnosticSolution) + vx=md.results.StressbalanceSolution.Vx + vy=md.results.StressbalanceSolution.Vy + vz=md.results.StressbalanceSolution.Vz + results.append(md.results.StressbalanceSolution) # plotmodel(md,'data',vx,'data',vy,'data',vz,'layer#all',md.mesh.numberoflayers) Index: /issm/trunk-jpl/test/NightlyRun/test1109.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test1109.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test1109.m (revision 15771) @@ -28,31 +28,31 @@ posx=find(md.mesh.x==0.); posx2=find(md.mesh.x==max(md.mesh.x)); - md.diagnostic.vertex_pairing=[posx,posx2]; + md.stressbalance.vertex_pairing=[posx,posx2]; %Create spcs on the bed pos=find(md.mesh.vertexonbed); - md.diagnostic.spcvx=NaN*ones(md.mesh.numberofvertices,1); - md.diagnostic.spcvy=NaN*ones(md.mesh.numberofvertices,1); - md.diagnostic.spcvz=NaN*ones(md.mesh.numberofvertices,1); - md.diagnostic.spcvx(pos)=0.; - md.diagnostic.spcvy(pos)=0.; - md.diagnostic.spcvz(pos)=0.; + md.stressbalance.spcvx=NaN*ones(md.mesh.numberofvertices,1); + md.stressbalance.spcvy=NaN*ones(md.mesh.numberofvertices,1); + md.stressbalance.spcvz=NaN*ones(md.mesh.numberofvertices,1); + md.stressbalance.spcvx(pos)=0.; + md.stressbalance.spcvy(pos)=0.; + md.stressbalance.spcvz(pos)=0.; %Remove the spc where there is some sliding (case 3 and 4): if i==3 | i==4, pos=find(md.mesh.y/max(md.mesh.y)>=0.44 & md.mesh.y/max(md.mesh.y)<=0.5); - md.diagnostic.spcvx(pos)=NaN; - md.diagnostic.spcvy(pos)=NaN; - md.diagnostic.spcvz(pos)=NaN; + md.stressbalance.spcvx(pos)=NaN; + md.stressbalance.spcvy(pos)=NaN; + md.stressbalance.spcvz(pos)=NaN; end - %Compute the diagnostic + %Compute the stressbalance md.cluster=generic('name',oshostname(),'np',8); - md=solve(md,DiagnosticSolutionEnum()); + md=solve(md,StressbalanceSolutionEnum()); - vx=(md.results.DiagnosticSolution.Vx); - vy=(md.results.DiagnosticSolution.Vy); - vz=(md.results.DiagnosticSolution.Vz); - results{i}=md.results.DiagnosticSolution; + vx=(md.results.StressbalanceSolution.Vx); + vy=(md.results.StressbalanceSolution.Vy); + vz=(md.results.StressbalanceSolution.Vz); + results{i}=md.results.StressbalanceSolution; if i==1, Index: /issm/trunk-jpl/test/NightlyRun/test1110.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test1110.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test1110.m (revision 15771) @@ -21,18 +21,18 @@ end - md.diagnostic.spcvx=NaN*ones(md.mesh.numberofvertices,1); - md.diagnostic.spcvy=NaN*ones(md.mesh.numberofvertices,1); - md.diagnostic.spcvz=NaN*ones(md.mesh.numberofvertices,1); + md.stressbalance.spcvx=NaN*ones(md.mesh.numberofvertices,1); + md.stressbalance.spcvy=NaN*ones(md.mesh.numberofvertices,1); + md.stressbalance.spcvz=NaN*ones(md.mesh.numberofvertices,1); if (i==1 | i==3), %Create dirichlet on the bed if no slip pos=find(md.mesh.vertexonbed); - md.diagnostic.spcvx(pos)=0.; - md.diagnostic.spcvy(pos)=0.; - md.diagnostic.spcvz(pos)=0.; + md.stressbalance.spcvx(pos)=0.; + md.stressbalance.spcvy(pos)=0.; + md.stressbalance.spcvz(pos)=0.; else pos=find(md.mesh.vertexonbed & (md.mesh.x==0. | md.mesh.x==max(md.mesh.x)) & (md.mesh.y==0. | md.mesh.y==max(md.mesh.y))); - md.diagnostic.spcvx(pos)=100.; %because we need a dirichlet somewhere - md.diagnostic.spcvy(pos)=0.; - md.diagnostic.spcvz(pos)=0.; + md.stressbalance.spcvx(pos)=100.; %because we need a dirichlet somewhere + md.stressbalance.spcvy(pos)=0.; + md.stressbalance.spcvz(pos)=0.; end pos=find(~md.mesh.vertexonbed); @@ -46,5 +46,5 @@ posy2=find(md.mesh.y==max(md.mesh.y)); - md.diagnostic.vertex_pairing=[posx,posx2;posy,posy2]; + md.stressbalance.vertex_pairing=[posx,posx2;posy,posy2]; md.masstransport.vertex_pairing=[posx,posx2;posy,posy2]; @@ -53,7 +53,7 @@ md.settings.output_frequency=50; md.masstransport.stabilization=1; - md.diagnostic.maxiter=1; + md.stressbalance.maxiter=1; - %Compute the diagnostic + %Compute the stressbalance md.cluster=generic('name',oshostname(),'np',8); md.verbose=verbose('convergence',true,'solution',true); Index: /issm/trunk-jpl/test/NightlyRun/test1201.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test1201.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test1201.m (revision 15771) @@ -35,5 +35,5 @@ %solve - md.transient.isdiagnostic=0; + md.transient.isstressbalance=0; md.settings.output_frequency=500; %keep only last step md.verbose=verbose(); Index: /issm/trunk-jpl/test/NightlyRun/test1201.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test1201.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test1201.py (revision 15771) @@ -47,5 +47,5 @@ #solve - md.transient.isdiagnostic=False + md.transient.isstressbalance=False md.settings.output_frequency=500 #keep only last step md.verbose=verbose() Index: /issm/trunk-jpl/test/NightlyRun/test1202.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test1202.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test1202.m (revision 15771) @@ -1,3 +1,3 @@ -%Test on the diagnostic model and the masstransport in 2d. +%Test on the stressbalance model and the masstransport in 2d. printingflag=false; @@ -11,9 +11,9 @@ %Compute solution for SSA's model md.cluster=generic('name',oshostname(),'np',8); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %plot results -vx=(md.results.DiagnosticSolution.Vx); -vy=(md.results.DiagnosticSolution.Vy); +vx=(md.results.StressbalanceSolution.Vx); +vy=(md.results.StressbalanceSolution.Vy); plotmodel(md,'data',vx,'contourlevels',{0,20,40,60,60,100,120,140,160,180,-20,-40,-60,-80,-100,-120,-140,-160,-180}, ... Index: /issm/trunk-jpl/test/NightlyRun/test1202.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test1202.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test1202.py (revision 15771) @@ -10,5 +10,5 @@ """ -Test on the diagnostic model and the masstransport in 2d +Test on the stressbalance model and the masstransport in 2d """ @@ -24,9 +24,9 @@ #Compute solution for SSA's model md.cluster=generic('name',oshostname(),'np',8) -md=solve(md,DiagnosticSolutionEnum()) +md=solve(md,StressbalanceSolutionEnum()) #plot results -vx=md.results.DiagnosticSolution.Vx -vy=md.results.DiagnosticSolution.Vy +vx=md.results.StressbalanceSolution.Vx +vy=md.results.StressbalanceSolution.Vy #plotmodel(md,'data',vx,'contourlevels',{0,20,40,60,60,100,120,140,160,180,-20,-40,-60,-80,-100,-120,-140,-160,-180}, ... Index: /issm/trunk-jpl/test/NightlyRun/test1203.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test1203.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test1203.m (revision 15771) @@ -1,3 +1,3 @@ -%Test on the diagnostic model and the masstransport in 2d +%Test on the stressbalance model and the masstransport in 2d printingflag=false; @@ -11,12 +11,12 @@ %Impose a non zero velocity on the upper boundary condition (y=max(y)) pos=find(md.mesh.y==max(md.mesh.y)); -md.diagnostic.spcvy(pos)=400.*(((md.mesh.x(pos)-100000.)/25000.).^2-ones(size(pos,1),1)).*heaviside((1.+eps)*ones(size(pos,1),1)-((md.mesh.x(pos)-100000.)/25000.).^2); +md.stressbalance.spcvy(pos)=400.*(((md.mesh.x(pos)-100000.)/25000.).^2-ones(size(pos,1),1)).*heaviside((1.+eps)*ones(size(pos,1),1)-((md.mesh.x(pos)-100000.)/25000.).^2); %Compute solution for SSA's model md.cluster=generic('name',oshostname(),'np',8); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); -vx=(md.results.DiagnosticSolution.Vx); -vy=(md.results.DiagnosticSolution.Vy); +vx=(md.results.StressbalanceSolution.Vx); +vy=(md.results.StressbalanceSolution.Vy); %plot results Index: /issm/trunk-jpl/test/NightlyRun/test1203.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test1203.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test1203.py (revision 15771) @@ -11,5 +11,5 @@ """ -Test on the diagnostic model and the masstransport in 2d +Test on the stressbalance model and the masstransport in 2d """ @@ -25,12 +25,12 @@ #Impose a non zero velocity on the upper boundary condition (y=max(y)) pos=numpy.nonzero(md.mesh.y==numpy.max(md.mesh.y)) -md.diagnostic.spcvy[pos]=400.*(((md.mesh.x[pos].reshape(-1,1)-100000.)/25000.)**2-numpy.ones((numpy.size(pos),1)))*heaviside((1.+sys.float_info.epsilon)*numpy.ones((numpy.size(pos),1))-((md.mesh.x[pos].reshape(-1,1)-100000.)/25000.)**2) +md.stressbalance.spcvy[pos]=400.*(((md.mesh.x[pos].reshape(-1,1)-100000.)/25000.)**2-numpy.ones((numpy.size(pos),1)))*heaviside((1.+sys.float_info.epsilon)*numpy.ones((numpy.size(pos),1))-((md.mesh.x[pos].reshape(-1,1)-100000.)/25000.)**2) #Compute solution for SSA's model md.cluster=generic('name',oshostname(),'np',8) -md=solve(md,DiagnosticSolutionEnum()) +md=solve(md,StressbalanceSolutionEnum()) -vx=md.results.DiagnosticSolution.Vx -vy=md.results.DiagnosticSolution.Vy +vx=md.results.StressbalanceSolution.Vx +vy=md.results.StressbalanceSolution.Vy #plot results Index: /issm/trunk-jpl/test/NightlyRun/test1204.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test1204.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test1204.m (revision 15771) @@ -1,3 +1,3 @@ -%Test on the diagnostic model and the masstransport in 2d +%Test on the stressbalance model and the masstransport in 2d printingflag=false; @@ -11,13 +11,13 @@ %Impose a non zero velocity on the upper boundary condition (y=max(y)) pos=find(md.mesh.y==max(md.mesh.y)); -md.diagnostic.spcvy(pos)=400.*(((md.mesh.x(pos)-100000.)/25000.).^2-ones(size(pos,1),1)).*heaviside((1.+eps)*ones(size(pos,1),1)-((md.mesh.x(pos)-100000.)/25000.).^2); +md.stressbalance.spcvy(pos)=400.*(((md.mesh.x(pos)-100000.)/25000.).^2-ones(size(pos,1),1)).*heaviside((1.+eps)*ones(size(pos,1),1)-((md.mesh.x(pos)-100000.)/25000.).^2); %Compute solution for SSA's model md.cluster=generic('name',oshostname(),'np',8); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %plot results -md.initialization.vx=(md.results.DiagnosticSolution.Vx); -md.initialization.vy=(md.results.DiagnosticSolution.Vy); +md.initialization.vx=(md.results.StressbalanceSolution.Vx); +md.initialization.vy=(md.results.StressbalanceSolution.Vy); md.timestepping.time_step=1.; Index: /issm/trunk-jpl/test/NightlyRun/test1204.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test1204.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test1204.py (revision 15771) @@ -11,5 +11,5 @@ """ -Test on the diagnostic model and the masstransport in 2d +Test on the stressbalance model and the masstransport in 2d """ @@ -25,13 +25,13 @@ #Impose a non zero velocity on the upper boundary condition (y=max(y)) pos=numpy.nonzero(md.mesh.y==max(md.mesh.y)) -md.diagnostic.spcvy[pos]=400.*(((md.mesh.x[pos].reshape(-1,1)-100000.)/25000.)**2-numpy.ones((numpy.size(pos),1)))*heaviside((1.+sys.float_info.epsilon)*numpy.ones((numpy.size(pos),1))-((md.mesh.x[pos].reshape(-1,1)-100000.)/25000.)**2) +md.stressbalance.spcvy[pos]=400.*(((md.mesh.x[pos].reshape(-1,1)-100000.)/25000.)**2-numpy.ones((numpy.size(pos),1)))*heaviside((1.+sys.float_info.epsilon)*numpy.ones((numpy.size(pos),1))-((md.mesh.x[pos].reshape(-1,1)-100000.)/25000.)**2) #Compute solution for SSA's model md.cluster=generic('name',oshostname(),'np',8) -md=solve(md,DiagnosticSolutionEnum()) +md=solve(md,StressbalanceSolutionEnum()) #plot results -md.initialization.vx=md.results.DiagnosticSolution.Vx -md.initialization.vy=md.results.DiagnosticSolution.Vy +md.initialization.vx=md.results.StressbalanceSolution.Vx +md.initialization.vy=md.results.StressbalanceSolution.Vy md.timestepping.time_step=1. Index: /issm/trunk-jpl/test/NightlyRun/test1205.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test1205.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test1205.m (revision 15771) @@ -23,15 +23,15 @@ %Spc the nodes on the bed pos=find(md.mesh.vertexonbed); -md.diagnostic.spcvx(pos)=0.; -md.diagnostic.spcvy(pos)=0.; -md.diagnostic.spcvz(pos)=0.; +md.stressbalance.spcvx(pos)=0.; +md.stressbalance.spcvy(pos)=0.; +md.stressbalance.spcvz(pos)=0.; %Now we can solve the problem md.cluster=generic('name',oshostname(),'np',8); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %Calculate the depth averaged velocity field (2d): -vx=(md.results.DiagnosticSolution.Vx); -vy=(md.results.DiagnosticSolution.Vy); +vx=(md.results.StressbalanceSolution.Vx); +vy=(md.results.StressbalanceSolution.Vy); vel=zeros(md.mesh.numberofvertices2d,1); Index: /issm/trunk-jpl/test/NightlyRun/test1205.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test1205.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test1205.py (revision 15771) @@ -36,15 +36,15 @@ #Spc the nodes on the bed pos=numpy.nonzero(md.mesh.vertexonbed) -md.diagnostic.spcvx[pos]=0. -md.diagnostic.spcvy[pos]=0. -md.diagnostic.spcvz[pos]=0. +md.stressbalance.spcvx[pos]=0. +md.stressbalance.spcvy[pos]=0. +md.stressbalance.spcvz[pos]=0. #Now we can solve the problem md.cluster=generic('name',oshostname(),'np',8) -md=solve(md,DiagnosticSolutionEnum()) +md=solve(md,StressbalanceSolutionEnum()) #Calculate the depth averaged velocity field (2d): -vx=md.results.DiagnosticSolution.Vx -vy=md.results.DiagnosticSolution.Vy +vx=md.results.StressbalanceSolution.Vx +vy=md.results.StressbalanceSolution.Vy vel=numpy.zeros((md.mesh.numberofvertices2d,1)) Index: /issm/trunk-jpl/test/NightlyRun/test1206.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test1206.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test1206.m (revision 15771) @@ -23,15 +23,15 @@ %Spc the nodes on the bed pos=find(md.mesh.vertexonbed); -md.diagnostic.spcvx(pos)=0.; -md.diagnostic.spcvy(pos)=0.; -md.diagnostic.spcvz(pos)=0.; +md.stressbalance.spcvx(pos)=0.; +md.stressbalance.spcvy(pos)=0.; +md.stressbalance.spcvz(pos)=0.; %Now we can solve the problem md.cluster=generic('name',oshostname(),'np',8); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %Calculate the depth averaged velocity field (2d): -vx=(md.results.DiagnosticSolution.Vx); -vy=(md.results.DiagnosticSolution.Vy); +vx=(md.results.StressbalanceSolution.Vx); +vy=(md.results.StressbalanceSolution.Vy); vel=zeros(md.mesh.numberofvertices2d,1); Index: /issm/trunk-jpl/test/NightlyRun/test1206.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test1206.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test1206.py (revision 15771) @@ -36,15 +36,15 @@ #Spc the nodes on the bed pos=numpy.nonzero(md.mesh.vertexonbed) -md.diagnostic.spcvx[pos]=0. -md.diagnostic.spcvy[pos]=0. -md.diagnostic.spcvz[pos]=0. +md.stressbalance.spcvx[pos]=0. +md.stressbalance.spcvy[pos]=0. +md.stressbalance.spcvz[pos]=0. #Now we can solve the problem md.cluster=generic('name',oshostname(),'np',8) -md=solve(md,DiagnosticSolutionEnum()) +md=solve(md,StressbalanceSolutionEnum()) #Calculate the depth averaged velocity field (2d): -vx=md.results.DiagnosticSolution.Vx -vy=md.results.DiagnosticSolution.Vy +vx=md.results.StressbalanceSolution.Vx +vy=md.results.StressbalanceSolution.Vy vel=numpy.zeros((md.mesh.numberofvertices2d,1)) Index: /issm/trunk-jpl/test/NightlyRun/test1207.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test1207.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test1207.m (revision 15771) @@ -23,15 +23,15 @@ %Spc the nodes on the bed pos=find(md.mesh.vertexonbed); -md.diagnostic.spcvx(pos)=0.; -md.diagnostic.spcvy(pos)=0.; -md.diagnostic.spcvz(pos)=0.; +md.stressbalance.spcvx(pos)=0.; +md.stressbalance.spcvy(pos)=0.; +md.stressbalance.spcvz(pos)=0.; %Now we can solve the problem md.cluster=generic('name',oshostname(),'np',8); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %Calculate the depth averaged velocity field (2d): -vx=(md.results.DiagnosticSolution.Vx); -vy=(md.results.DiagnosticSolution.Vy); +vx=(md.results.StressbalanceSolution.Vx); +vy=(md.results.StressbalanceSolution.Vy); vel=zeros(md.mesh.numberofvertices2d,1); Index: /issm/trunk-jpl/test/NightlyRun/test1207.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test1207.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test1207.py (revision 15771) @@ -36,15 +36,15 @@ #Spc the nodes on the bed pos=numpy.nonzero(md.mesh.vertexonbed) -md.diagnostic.spcvx[pos]=0. -md.diagnostic.spcvy[pos]=0. -md.diagnostic.spcvz[pos]=0. +md.stressbalance.spcvx[pos]=0. +md.stressbalance.spcvy[pos]=0. +md.stressbalance.spcvz[pos]=0. #Now we can solve the problem md.cluster=generic('name',oshostname(),'np',8) -md=solve(md,DiagnosticSolutionEnum()) +md=solve(md,StressbalanceSolutionEnum()) #Calculate the depth averaged velocity field (2d): -vx=md.results.DiagnosticSolution.Vx -vy=md.results.DiagnosticSolution.Vy +vx=md.results.StressbalanceSolution.Vx +vy=md.results.StressbalanceSolution.Vy vel=numpy.zeros((md.mesh.numberofvertices2d,1)) Index: /issm/trunk-jpl/test/NightlyRun/test1208.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test1208.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test1208.m (revision 15771) @@ -14,7 +14,7 @@ %Spc the nodes on the bed pos=find(md.mesh.vertexonbed); -md.diagnostic.spcvx(pos)=0.; -md.diagnostic.spcvy(pos)=0.; -md.diagnostic.spcvz(pos)=0.; +md.stressbalance.spcvx(pos)=0.; +md.stressbalance.spcvy(pos)=0.; +md.stressbalance.spcvz(pos)=0.; %Adapt the time steps to the resolution Index: /issm/trunk-jpl/test/NightlyRun/test1208.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test1208.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test1208.py (revision 15771) @@ -27,7 +27,7 @@ #Spc the nodes on the bed pos=numpy.nonzero(md.mesh.vertexonbed) -md.diagnostic.spcvx[pos]=0. -md.diagnostic.spcvy[pos]=0. -md.diagnostic.spcvz[pos]=0. +md.stressbalance.spcvx[pos]=0. +md.stressbalance.spcvy[pos]=0. +md.stressbalance.spcvz[pos]=0. #Adapt the time steps to the resolution Index: /issm/trunk-jpl/test/NightlyRun/test121.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test121.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test121.m (revision 15771) @@ -6,5 +6,5 @@ md.cluster=generic('name',oshostname(),'np',3); md.initialization.waterfraction=zeros(md.mesh.numberofvertices,1); -md.transient.isdiagnostic=0; +md.transient.isstressbalance=0; md.transient.ismasstransport=0; md.transient.isthermal=1; Index: /issm/trunk-jpl/test/NightlyRun/test121.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test121.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test121.py (revision 15771) @@ -15,5 +15,5 @@ md.cluster=generic('name',oshostname(),'np',3); md.initialization.waterfraction=numpy.zeros((md.mesh.numberofvertices,1)) -md.transient.isdiagnostic=False +md.transient.isstressbalance=False md.transient.ismasstransport=False md.transient.isthermal=True Index: /issm/trunk-jpl/test/NightlyRun/test1601.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test1601.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test1601.m (revision 15771) @@ -3,5 +3,5 @@ md=parameterize(md,'../Par/SquareShelf.par'); md=setflowequation(md,'SSA','all'); -md.diagnostic.spcvx(find(md.mesh.y>0.))=NaN; +md.stressbalance.spcvx(find(md.mesh.y>0.))=NaN; md.initialization.vx(:)=0.; md.initialization.vy(:)=0.; @@ -9,6 +9,6 @@ md.cluster=generic('name',oshostname(),'np',2); -md=solve(md,DiagnosticSolutionEnum()); -vel0=md.results.DiagnosticSolution.Vel; +md=solve(md,StressbalanceSolutionEnum()); +vel0=md.results.StressbalanceSolution.Vel; theta=30.*pi/180.; @@ -18,8 +18,8 @@ md.mesh.y=sin(theta)*x+cos(theta)*y; -md.diagnostic.referential(:,1:3)=repmat([cos(theta),sin(theta),0],md.mesh.numberofvertices,1); -md.diagnostic.referential(:,4:6)=repmat([0,0,1],md.mesh.numberofvertices,1); -md=solve(md,DiagnosticSolutionEnum()); -vel1=md.results.DiagnosticSolution.Vel; +md.stressbalance.referential(:,1:3)=repmat([cos(theta),sin(theta),0],md.mesh.numberofvertices,1); +md.stressbalance.referential(:,4:6)=repmat([0,0,1],md.mesh.numberofvertices,1); +md=solve(md,StressbalanceSolutionEnum()); +vel1=md.results.StressbalanceSolution.Vel; plotmodel(md,'data',vel0,'data',vel1,'data',vel1-vel0,'title','Cartesian CS','title','Rotated CS','title','difference') @@ -28,9 +28,9 @@ %Now, put CS back to normal except on the side where the spc are applied pos=find(x==0. | x==1000000.); -md.diagnostic.referential(:)=NaN; -md.diagnostic.referential(pos,1:3)=repmat([cos(theta),sin(theta),0],size(pos,1),1); -md.diagnostic.referential(pos,4:6)=repmat([0,0,1],size(pos,1),1); -md=solve(md,DiagnosticSolutionEnum()); -vel2=md.results.DiagnosticSolution.Vel; +md.stressbalance.referential(:)=NaN; +md.stressbalance.referential(pos,1:3)=repmat([cos(theta),sin(theta),0],size(pos,1),1); +md.stressbalance.referential(pos,4:6)=repmat([0,0,1],size(pos,1),1); +md=solve(md,StressbalanceSolutionEnum()); +vel2=md.results.StressbalanceSolution.Vel; plotmodel(md,'data',vel0,'data',vel2,'data',vel2-vel0,'title','Cartesian CS','title','Rotated CS','title','difference') Index: /issm/trunk-jpl/test/NightlyRun/test1601.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test1601.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test1601.py (revision 15771) @@ -14,5 +14,5 @@ md=parameterize(md,'../Par/SquareShelf.py') md=setflowequation(md,'SSA','all') -md.diagnostic.spcvx[numpy.nonzero(md.mesh.y>0.)]=float('NaN') +md.stressbalance.spcvx[numpy.nonzero(md.mesh.y>0.)]=float('NaN') md.initialization.vx[:]=0. md.initialization.vy[:]=0. @@ -20,6 +20,6 @@ md.cluster=generic('name',oshostname(),'np',2) -md=solve(md,DiagnosticSolutionEnum()) -vel0=md.results.DiagnosticSolution.Vel +md=solve(md,StressbalanceSolutionEnum()) +vel0=md.results.StressbalanceSolution.Vel theta=30.*numpy.pi/180. @@ -29,8 +29,8 @@ md.mesh.y=numpy.sin(theta)*x+numpy.cos(theta)*y -md.diagnostic.referential[:,0:3]=numpy.tile([numpy.cos(theta),numpy.sin(theta),0],(md.mesh.numberofvertices,1)) -md.diagnostic.referential[:,3: ]=numpy.tile([0,0,1],(md.mesh.numberofvertices,1)) -md=solve(md,DiagnosticSolutionEnum()) -vel1=md.results.DiagnosticSolution.Vel +md.stressbalance.referential[:,0:3]=numpy.tile([numpy.cos(theta),numpy.sin(theta),0],(md.mesh.numberofvertices,1)) +md.stressbalance.referential[:,3: ]=numpy.tile([0,0,1],(md.mesh.numberofvertices,1)) +md=solve(md,StressbalanceSolutionEnum()) +vel1=md.results.StressbalanceSolution.Vel #plotmodel(md,'data',vel0,'data',vel1,'data',vel1-vel0,'title','Cartesian CS','title','Rotated CS','title','difference') @@ -39,9 +39,9 @@ #Now, put CS back to normal except on the side where the spc are applied pos=numpy.nonzero(numpy.logical_or(x==0.,x==1000000.))[0] -md.diagnostic.referential[:]=float('NaN') -md.diagnostic.referential[pos,0:3]=numpy.tile([numpy.cos(theta),numpy.sin(theta),0],(len(pos),1)) -md.diagnostic.referential[pos,3: ]=numpy.tile([0,0,1],(len(pos),1)) -md=solve(md,DiagnosticSolutionEnum()) -vel2=md.results.DiagnosticSolution.Vel +md.stressbalance.referential[:]=float('NaN') +md.stressbalance.referential[pos,0:3]=numpy.tile([numpy.cos(theta),numpy.sin(theta),0],(len(pos),1)) +md.stressbalance.referential[pos,3: ]=numpy.tile([0,0,1],(len(pos),1)) +md=solve(md,StressbalanceSolutionEnum()) +vel2=md.results.StressbalanceSolution.Vel #plotmodel(md,'data',vel0,'data',vel2,'data',vel2-vel0,'title','Cartesian CS','title','Rotated CS','title','difference') Index: /issm/trunk-jpl/test/NightlyRun/test1602.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test1602.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test1602.m (revision 15771) @@ -4,5 +4,5 @@ md=extrude(md,5,1.); md=setflowequation(md,'HO','all'); -md.diagnostic.spcvx(find(md.mesh.y>0.))=NaN; +md.stressbalance.spcvx(find(md.mesh.y>0.))=NaN; md.initialization.vx(:)=0.; md.initialization.vy(:)=0.; @@ -10,6 +10,6 @@ md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,DiagnosticSolutionEnum()); -vel0=md.results.DiagnosticSolution.Vel; +md=solve(md,StressbalanceSolutionEnum()); +vel0=md.results.StressbalanceSolution.Vel; theta=30.*pi/180.; @@ -19,8 +19,8 @@ md.mesh.y=sin(theta)*x+cos(theta)*y; -md.diagnostic.referential(:,1:3)=repmat([cos(theta),sin(theta),0],md.mesh.numberofvertices,1); -md.diagnostic.referential(:,4:6)=repmat([0,0,1],md.mesh.numberofvertices,1); -md=solve(md,DiagnosticSolutionEnum()); -vel1=md.results.DiagnosticSolution.Vel; +md.stressbalance.referential(:,1:3)=repmat([cos(theta),sin(theta),0],md.mesh.numberofvertices,1); +md.stressbalance.referential(:,4:6)=repmat([0,0,1],md.mesh.numberofvertices,1); +md=solve(md,StressbalanceSolutionEnum()); +vel1=md.results.StressbalanceSolution.Vel; plotmodel(md,'data',vel0,'data',vel1,'data',vel1-vel0,'title','Cartesian CS','title','Rotated CS','title','difference','view#all',2) Index: /issm/trunk-jpl/test/NightlyRun/test1602.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test1602.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test1602.py (revision 15771) @@ -15,5 +15,5 @@ md.extrude(5,1.) md=setflowequation(md,'HO','all') -md.diagnostic.spcvx[numpy.nonzero(md.mesh.y>0.)]=float('NaN') +md.stressbalance.spcvx[numpy.nonzero(md.mesh.y>0.)]=float('NaN') md.initialization.vx[:]=0. md.initialization.vy[:]=0. @@ -21,6 +21,6 @@ md.cluster=generic('name',oshostname(),'np',3) -md=solve(md,DiagnosticSolutionEnum()) -vel0=md.results.DiagnosticSolution.Vel +md=solve(md,StressbalanceSolutionEnum()) +vel0=md.results.StressbalanceSolution.Vel theta=30.*numpy.pi/180. @@ -30,8 +30,8 @@ md.mesh.y=numpy.sin(theta)*x+numpy.cos(theta)*y -md.diagnostic.referential[:,0:3]=numpy.tile([numpy.cos(theta),numpy.sin(theta),0],(md.mesh.numberofvertices,1)) -md.diagnostic.referential[:,3: ]=numpy.tile([0,0,1],(md.mesh.numberofvertices,1)) -md=solve(md,DiagnosticSolutionEnum()) -vel1=md.results.DiagnosticSolution.Vel +md.stressbalance.referential[:,0:3]=numpy.tile([numpy.cos(theta),numpy.sin(theta),0],(md.mesh.numberofvertices,1)) +md.stressbalance.referential[:,3: ]=numpy.tile([0,0,1],(md.mesh.numberofvertices,1)) +md=solve(md,StressbalanceSolutionEnum()) +vel1=md.results.StressbalanceSolution.Vel #plotmodel(md,'data',vel0,'data',vel1,'data',vel1-vel0,'title','Cartesian CS','title','Rotated CS','title','difference','view#all',2) Index: /issm/trunk-jpl/test/NightlyRun/test201.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test201.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test201.m (revision 15771) @@ -4,5 +4,5 @@ md=setflowequation(md,'SSA','all'); md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %Fields and tolerances to track changes @@ -10,7 +10,7 @@ field_tolerances={1e-13,1e-13,1e-13,1e-13}; field_values={... - (md.results.DiagnosticSolution.Vx),... - (md.results.DiagnosticSolution.Vy),... - (md.results.DiagnosticSolution.Vel),... - (md.results.DiagnosticSolution.Pressure),... + (md.results.StressbalanceSolution.Vx),... + (md.results.StressbalanceSolution.Vy),... + (md.results.StressbalanceSolution.Vel),... + (md.results.StressbalanceSolution.Pressure),... }; Index: /issm/trunk-jpl/test/NightlyRun/test201.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test201.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test201.py (revision 15771) @@ -14,5 +14,5 @@ md=setflowequation(md,'SSA','all') md.cluster=generic('name',oshostname(),'np',3) -md=solve(md,DiagnosticSolutionEnum()) +md=solve(md,StressbalanceSolutionEnum()) #Fields and tolerances to track changes @@ -20,7 +20,7 @@ field_tolerances=[1e-13,1e-13,1e-13,1e-13] field_values=[\ - md.results.DiagnosticSolution.Vx,\ - md.results.DiagnosticSolution.Vy,\ - md.results.DiagnosticSolution.Vel,\ - md.results.DiagnosticSolution.Pressure,\ + md.results.StressbalanceSolution.Vx,\ + md.results.StressbalanceSolution.Vy,\ + md.results.StressbalanceSolution.Vel,\ + md.results.StressbalanceSolution.Pressure,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test202.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test202.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test202.m (revision 15771) @@ -5,5 +5,5 @@ md=setflowequation(md,'SSA','all'); md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %Fields and tolerances to track changes @@ -11,8 +11,8 @@ field_tolerances={1e-13,1e-13,1e-13,1e-13,1e-13}; field_values={... - (md.results.DiagnosticSolution.Vx),... - (md.results.DiagnosticSolution.Vy),... - (md.results.DiagnosticSolution.Vz),... - (md.results.DiagnosticSolution.Vel),... - (md.results.DiagnosticSolution.Pressure),... + (md.results.StressbalanceSolution.Vx),... + (md.results.StressbalanceSolution.Vy),... + (md.results.StressbalanceSolution.Vz),... + (md.results.StressbalanceSolution.Vel),... + (md.results.StressbalanceSolution.Pressure),... }; Index: /issm/trunk-jpl/test/NightlyRun/test202.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test202.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test202.py (revision 15771) @@ -15,5 +15,5 @@ md=setflowequation(md,'SSA','all') md.cluster=generic('name',oshostname(),'np',3) -md=solve(md,DiagnosticSolutionEnum()) +md=solve(md,StressbalanceSolutionEnum()) @@ -23,8 +23,8 @@ field_tolerances=[1e-13,1e-13,1e-13,1e-13,1e-13] field_values=[\ - md.results.DiagnosticSolution.Vx,\ - md.results.DiagnosticSolution.Vy,\ - md.results.DiagnosticSolution.Vz,\ - md.results.DiagnosticSolution.Vel,\ - md.results.DiagnosticSolution.Pressure,\ + md.results.StressbalanceSolution.Vx,\ + md.results.StressbalanceSolution.Vy,\ + md.results.StressbalanceSolution.Vz,\ + md.results.StressbalanceSolution.Vel,\ + md.results.StressbalanceSolution.Pressure,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test203.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test203.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test203.m (revision 15771) @@ -5,5 +5,5 @@ md=setflowequation(md,'HO','all'); md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %Fields and tolerances to track changes @@ -11,8 +11,8 @@ field_tolerances={1e-09,1e-09,1e-09,1e-09,1e-09}; field_values={... - (md.results.DiagnosticSolution.Vx),... - (md.results.DiagnosticSolution.Vy),... - (md.results.DiagnosticSolution.Vz),... - (md.results.DiagnosticSolution.Vel),... - (md.results.DiagnosticSolution.Pressure),... + (md.results.StressbalanceSolution.Vx),... + (md.results.StressbalanceSolution.Vy),... + (md.results.StressbalanceSolution.Vz),... + (md.results.StressbalanceSolution.Vel),... + (md.results.StressbalanceSolution.Pressure),... }; Index: /issm/trunk-jpl/test/NightlyRun/test203.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test203.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test203.py (revision 15771) @@ -15,5 +15,5 @@ md=setflowequation(md,'HO','all') md.cluster=generic('name',oshostname(),'np',3) -md=solve(md,DiagnosticSolutionEnum()) +md=solve(md,StressbalanceSolutionEnum()) @@ -23,8 +23,8 @@ field_tolerances=[1e-09,1e-09,1e-09,1e-09,1e-09] field_values=[\ - md.results.DiagnosticSolution.Vx,\ - md.results.DiagnosticSolution.Vy,\ - md.results.DiagnosticSolution.Vz,\ - md.results.DiagnosticSolution.Vel,\ - md.results.DiagnosticSolution.Pressure,\ + md.results.StressbalanceSolution.Vx,\ + md.results.StressbalanceSolution.Vy,\ + md.results.StressbalanceSolution.Vz,\ + md.results.StressbalanceSolution.Vel,\ + md.results.StressbalanceSolution.Pressure,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test204.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test204.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test204.m (revision 15771) @@ -5,5 +5,5 @@ md=setflowequation(md,'FS','all'); md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %Fields and tolerances to track changes @@ -11,8 +11,8 @@ field_tolerances={1e-08,1e-08,1e-07,1e-08,1e-08}; field_values={... - (md.results.DiagnosticSolution.Vx),... - (md.results.DiagnosticSolution.Vy),... - (md.results.DiagnosticSolution.Vz),... - (md.results.DiagnosticSolution.Vel),... - (md.results.DiagnosticSolution.Pressure),... + (md.results.StressbalanceSolution.Vx),... + (md.results.StressbalanceSolution.Vy),... + (md.results.StressbalanceSolution.Vz),... + (md.results.StressbalanceSolution.Vel),... + (md.results.StressbalanceSolution.Pressure),... }; Index: /issm/trunk-jpl/test/NightlyRun/test204.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test204.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test204.py (revision 15771) @@ -15,5 +15,5 @@ md=setflowequation(md,'FS','all') md.cluster=generic('name',oshostname(),'np',3) -md=solve(md,DiagnosticSolutionEnum()) +md=solve(md,StressbalanceSolutionEnum()) @@ -23,8 +23,8 @@ field_tolerances=[1e-08,1e-08,1e-07,1e-08,1e-08] field_values=[\ - md.results.DiagnosticSolution.Vx,\ - md.results.DiagnosticSolution.Vy,\ - md.results.DiagnosticSolution.Vz,\ - md.results.DiagnosticSolution.Vel,\ - md.results.DiagnosticSolution.Pressure,\ + md.results.StressbalanceSolution.Vx,\ + md.results.StressbalanceSolution.Vy,\ + md.results.StressbalanceSolution.Vz,\ + md.results.StressbalanceSolution.Vel,\ + md.results.StressbalanceSolution.Pressure,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test205.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test205.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test205.m (revision 15771) @@ -5,5 +5,5 @@ md=setflowequation(md,'HO','../Exp/SquareHalfRight.exp','fill','SSA','coupling','penalties'); md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %Fields and tolerances to track changes @@ -11,8 +11,8 @@ field_tolerances={1e-05,1e-05,1e-05,1e-05,1e-05}; field_values={... - (md.results.DiagnosticSolution.Vx),... - (md.results.DiagnosticSolution.Vy),... - (md.results.DiagnosticSolution.Vz),... - (md.results.DiagnosticSolution.Vel),... - (md.results.DiagnosticSolution.Pressure),... + (md.results.StressbalanceSolution.Vx),... + (md.results.StressbalanceSolution.Vy),... + (md.results.StressbalanceSolution.Vz),... + (md.results.StressbalanceSolution.Vel),... + (md.results.StressbalanceSolution.Pressure),... }; Index: /issm/trunk-jpl/test/NightlyRun/test205.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test205.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test205.py (revision 15771) @@ -15,5 +15,5 @@ md=setflowequation(md,'HO','../Exp/SquareHalfRight.exp','fill','SSA','coupling','penalties') md.cluster=generic('name',oshostname(),'np',3) -md=solve(md,DiagnosticSolutionEnum()) +md=solve(md,StressbalanceSolutionEnum()) @@ -23,8 +23,8 @@ field_tolerances=[1e-05,1e-05,1e-05,1e-05,1e-05] field_values=[\ -md.results.DiagnosticSolution.Vx,\ -md.results.DiagnosticSolution.Vy,\ -md.results.DiagnosticSolution.Vz,\ -md.results.DiagnosticSolution.Vel,\ -md.results.DiagnosticSolution.Pressure,\ +md.results.StressbalanceSolution.Vx,\ +md.results.StressbalanceSolution.Vy,\ +md.results.StressbalanceSolution.Vz,\ +md.results.StressbalanceSolution.Vel,\ +md.results.StressbalanceSolution.Pressure,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test207.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test207.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test207.m (revision 15771) @@ -5,5 +5,5 @@ md=setflowequation(md,'SSA','all'); md.cluster=generic('name',oshostname(),'np',3); -md.transient.isdiagnostic=0; +md.transient.isstressbalance=0; md.transient.ismasstransport=0; md.transient.isthermal=1; Index: /issm/trunk-jpl/test/NightlyRun/test207.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test207.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test207.py (revision 15771) @@ -15,5 +15,5 @@ md=setflowequation(md,'SSA','all') md.cluster=generic('name',oshostname(),'np',3) -md.transient.isdiagnostic=False +md.transient.isstressbalance=False md.transient.ismasstransport=False md.transient.isthermal=True Index: /issm/trunk-jpl/test/NightlyRun/test211.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test211.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test211.m (revision 15771) @@ -4,5 +4,5 @@ md=extrude(md,3,1.); md=setflowequation(md,'FS','all'); -md.diagnostic.reltol=NaN; +md.stressbalance.reltol=NaN; md.cluster=generic('name',oshostname(),'np',3); md=solve(md,TransientSolutionEnum()); Index: /issm/trunk-jpl/test/NightlyRun/test211.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test211.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test211.py (revision 15771) @@ -14,5 +14,5 @@ md.extrude(3,1.) md=setflowequation(md,'FS','all') -md.diagnostic.reltol=NaN +md.stressbalance.reltol=NaN md.cluster=generic('name',oshostname(),'np',3) md=solve(md,TransientSolutionEnum()) Index: /issm/trunk-jpl/test/NightlyRun/test212.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test212.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test212.m (revision 15771) @@ -18,5 +18,5 @@ md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %Fields and tolerances to track changes @@ -24,10 +24,10 @@ field_tolerances={1e-13,1e-13,1e-13,1e-13,1e-13,1e-13,1e-13,1e-13,1e-13,1e-13}; field_values={... - (md.results.DiagnosticSolution.Gradient1),... - (md.results.DiagnosticSolution.J),... - (md.results.DiagnosticSolution.MaterialsRheologyBbar),... - (md.results.DiagnosticSolution.Pressure),... - (md.results.DiagnosticSolution.Vel),... - (md.results.DiagnosticSolution.Vx),... - (md.results.DiagnosticSolution.Vy) + (md.results.StressbalanceSolution.Gradient1),... + (md.results.StressbalanceSolution.J),... + (md.results.StressbalanceSolution.MaterialsRheologyBbar),... + (md.results.StressbalanceSolution.Pressure),... + (md.results.StressbalanceSolution.Vel),... + (md.results.StressbalanceSolution.Vx),... + (md.results.StressbalanceSolution.Vy) }; Index: /issm/trunk-jpl/test/NightlyRun/test212.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test212.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test212.py (revision 15771) @@ -32,5 +32,5 @@ md.cluster=generic('name',oshostname(),'np',3) -md=solve(md,DiagnosticSolutionEnum()) +md=solve(md,StressbalanceSolutionEnum()) @@ -40,10 +40,10 @@ field_tolerances=[1e-13,1e-13,1e-13,1e-13,1e-13,1e-13,1e-13,1e-13,1e-13,1e-13] field_values=[\ -md.results.DiagnosticSolution.Gradient1,\ -md.results.DiagnosticSolution.J,\ -md.results.DiagnosticSolution.MaterialsRheologyBbar,\ -md.results.DiagnosticSolution.Pressure,\ -md.results.DiagnosticSolution.Vel,\ -md.results.DiagnosticSolution.Vx,\ -md.results.DiagnosticSolution.Vy,\ +md.results.StressbalanceSolution.Gradient1,\ +md.results.StressbalanceSolution.J,\ +md.results.StressbalanceSolution.MaterialsRheologyBbar,\ +md.results.StressbalanceSolution.Pressure,\ +md.results.StressbalanceSolution.Vel,\ +md.results.StressbalanceSolution.Vx,\ +md.results.StressbalanceSolution.Vy,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test213.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test213.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test213.m (revision 15771) @@ -19,5 +19,5 @@ md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %Fields and tolerances to track changes @@ -25,10 +25,10 @@ field_tolerances={1e-13,1e-13,1e-13,1e-13,1e-13,1e-13,1e-13,1e-13,1e-13,1e-13}; field_values={... - (md.results.DiagnosticSolution.Gradient1),... - md.results.DiagnosticSolution.J,... - (md.results.DiagnosticSolution.MaterialsRheologyB),... - (md.results.DiagnosticSolution.Pressure),... - (md.results.DiagnosticSolution.Vel),... - (md.results.DiagnosticSolution.Vx),... - (md.results.DiagnosticSolution.Vy) + (md.results.StressbalanceSolution.Gradient1),... + md.results.StressbalanceSolution.J,... + (md.results.StressbalanceSolution.MaterialsRheologyB),... + (md.results.StressbalanceSolution.Pressure),... + (md.results.StressbalanceSolution.Vel),... + (md.results.StressbalanceSolution.Vx),... + (md.results.StressbalanceSolution.Vy) }; Index: /issm/trunk-jpl/test/NightlyRun/test213.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test213.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test213.py (revision 15771) @@ -33,5 +33,5 @@ md.cluster=generic('name',oshostname(),'np',3) -md=solve(md,DiagnosticSolutionEnum()) +md=solve(md,StressbalanceSolutionEnum()) @@ -42,10 +42,10 @@ #field_tolerances=[1e-13,1e-13,1e-13,1e-13,1e-13,1e-13,1e-13,1e-13,1e-13,1e-13] field_values=[\ - md.results.DiagnosticSolution.Gradient1,\ - md.results.DiagnosticSolution.J,\ - md.results.DiagnosticSolution.MaterialsRheologyB,\ - md.results.DiagnosticSolution.Pressure,\ - md.results.DiagnosticSolution.Vel,\ - md.results.DiagnosticSolution.Vx,\ - md.results.DiagnosticSolution.Vy,\ + md.results.StressbalanceSolution.Gradient1,\ + md.results.StressbalanceSolution.J,\ + md.results.StressbalanceSolution.MaterialsRheologyB,\ + md.results.StressbalanceSolution.Pressure,\ + md.results.StressbalanceSolution.Vel,\ + md.results.StressbalanceSolution.Vx,\ + md.results.StressbalanceSolution.Vy,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test214.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test214.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test214.m (revision 15771) @@ -19,5 +19,5 @@ md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %Fields and tolerances to track changes @@ -25,10 +25,10 @@ field_tolerances={1e-07,1e-08,1e-08,1e-08,1e-08,1e-08,1e-08,1e-08,1e-08,1e-08}; field_values={... - (md.results.DiagnosticSolution.Gradient1),... - (md.results.DiagnosticSolution.J),... - (md.results.DiagnosticSolution.MaterialsRheologyB),... - (md.results.DiagnosticSolution.Pressure),... - (md.results.DiagnosticSolution.Vel),... - (md.results.DiagnosticSolution.Vx),... - (md.results.DiagnosticSolution.Vy) + (md.results.StressbalanceSolution.Gradient1),... + (md.results.StressbalanceSolution.J),... + (md.results.StressbalanceSolution.MaterialsRheologyB),... + (md.results.StressbalanceSolution.Pressure),... + (md.results.StressbalanceSolution.Vel),... + (md.results.StressbalanceSolution.Vx),... + (md.results.StressbalanceSolution.Vy) }; Index: /issm/trunk-jpl/test/NightlyRun/test214.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test214.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test214.py (revision 15771) @@ -33,5 +33,5 @@ md.cluster=generic('name',oshostname(),'np',3) -md=solve(md,DiagnosticSolutionEnum()) +md=solve(md,StressbalanceSolutionEnum()) @@ -41,10 +41,10 @@ field_tolerances=[1e-07,1e-08,1e-08,1e-08,1e-08,1e-08,1e-08,1e-08,1e-08,1e-08] field_values=[\ - md.results.DiagnosticSolution.Gradient1,\ - md.results.DiagnosticSolution.J,\ - md.results.DiagnosticSolution.MaterialsRheologyB,\ - md.results.DiagnosticSolution.Pressure,\ - md.results.DiagnosticSolution.Vel,\ - md.results.DiagnosticSolution.Vx,\ - md.results.DiagnosticSolution.Vy + md.results.StressbalanceSolution.Gradient1,\ + md.results.StressbalanceSolution.J,\ + md.results.StressbalanceSolution.MaterialsRheologyB,\ + md.results.StressbalanceSolution.Pressure,\ + md.results.StressbalanceSolution.Vel,\ + md.results.StressbalanceSolution.Vx,\ + md.results.StressbalanceSolution.Vy ] Index: /issm/trunk-jpl/test/NightlyRun/test215.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test215.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test215.m (revision 15771) @@ -19,5 +19,5 @@ md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %Fields and tolerances to track changes @@ -25,10 +25,10 @@ field_tolerances={1e-08,1e-09,1e-09,1e-09,1e-09,1e-09,1e-09,1e-09,1e-09,1e-09}; field_values={... - (md.results.DiagnosticSolution.Gradient1),... - (md.results.DiagnosticSolution.J),... - (md.results.DiagnosticSolution.MaterialsRheologyB),... - (md.results.DiagnosticSolution.Pressure),... - (md.results.DiagnosticSolution.Vel),... - (md.results.DiagnosticSolution.Vx),... - (md.results.DiagnosticSolution.Vy) + (md.results.StressbalanceSolution.Gradient1),... + (md.results.StressbalanceSolution.J),... + (md.results.StressbalanceSolution.MaterialsRheologyB),... + (md.results.StressbalanceSolution.Pressure),... + (md.results.StressbalanceSolution.Vel),... + (md.results.StressbalanceSolution.Vx),... + (md.results.StressbalanceSolution.Vy) }; Index: /issm/trunk-jpl/test/NightlyRun/test215.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test215.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test215.py (revision 15771) @@ -33,5 +33,5 @@ md.cluster=generic('name',oshostname(),'np',3) -md=solve(md,DiagnosticSolutionEnum()) +md=solve(md,StressbalanceSolutionEnum()) @@ -41,10 +41,10 @@ field_tolerances=[1e-08,1e-09,1e-09,1e-09,1e-09,1e-09,1e-09,1e-09,1e-09,1e-09] field_values=[\ - md.results.DiagnosticSolution.Gradient1,\ - md.results.DiagnosticSolution.J,\ - md.results.DiagnosticSolution.MaterialsRheologyB,\ - md.results.DiagnosticSolution.Pressure,\ - md.results.DiagnosticSolution.Vel,\ - md.results.DiagnosticSolution.Vx,\ - md.results.DiagnosticSolution.Vy + md.results.StressbalanceSolution.Gradient1,\ + md.results.StressbalanceSolution.J,\ + md.results.StressbalanceSolution.MaterialsRheologyB,\ + md.results.StressbalanceSolution.Pressure,\ + md.results.StressbalanceSolution.Vel,\ + md.results.StressbalanceSolution.Vx,\ + md.results.StressbalanceSolution.Vy ] Index: /issm/trunk-jpl/test/NightlyRun/test216.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test216.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test216.m (revision 15771) @@ -9,8 +9,8 @@ md.rifts.riftstruct.fill=MelangeEnum(); md.rifts.riftstruct.fraction=0; -md.diagnostic.rift_penalty_lock=2; -md.diagnostic.rift_penalty_threshold=0; +md.stressbalance.rift_penalty_lock=2; +md.stressbalance.rift_penalty_threshold=0; md.rifts.riftstruct.fractionincrement=.1; -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %Fields and tolerances to track changes @@ -18,7 +18,7 @@ field_tolerances={2e-11,1e-11,1e-11,1e-11}; field_values={... - (md.results.DiagnosticSolution.Vx),... - (md.results.DiagnosticSolution.Vy),... - (md.results.DiagnosticSolution.Vel),... - (md.results.DiagnosticSolution.Pressure),... + (md.results.StressbalanceSolution.Vx),... + (md.results.StressbalanceSolution.Vy),... + (md.results.StressbalanceSolution.Vel),... + (md.results.StressbalanceSolution.Pressure),... }; Index: /issm/trunk-jpl/test/NightlyRun/test216.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test216.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test216.py (revision 15771) @@ -21,8 +21,8 @@ md.rifts.riftstruct[0]['fill']=MelangeEnum() md.rifts.riftstruct[0]['fraction']=0 -md.diagnostic.rift_penalty_lock=2 -md.diagnostic.rift_penalty_threshold=0 +md.stressbalance.rift_penalty_lock=2 +md.stressbalance.rift_penalty_threshold=0 md.rifts.riftstruct[0]['fractionincrement']=0.1 -md=solve(md,DiagnosticSolutionEnum()) +md=solve(md,StressbalanceSolutionEnum()) # Fields and tolerances to track changes @@ -31,7 +31,7 @@ field_tolerances=[2e-11,1e-11,1e-11,1e-11] field_values=[\ - md.results.DiagnosticSolution.Vx,\ - md.results.DiagnosticSolution.Vy,\ - md.results.DiagnosticSolution.Vel,\ - md.results.DiagnosticSolution.Pressure,\ + md.results.StressbalanceSolution.Vx,\ + md.results.StressbalanceSolution.Vy,\ + md.results.StressbalanceSolution.Vel,\ + md.results.StressbalanceSolution.Pressure,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test217.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test217.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test217.m (revision 15771) @@ -10,5 +10,5 @@ %tighten -md.diagnostic.restol=10^-4; +md.stressbalance.restol=10^-4; %needed later @@ -37,17 +37,17 @@ %Boundary conditions: -md.diagnostic.spcvx=NaN*ones(md.mesh.numberofvertices,1); -md.diagnostic.spcvy=NaN*ones(md.mesh.numberofvertices,1); -md.diagnostic.spcvz=NaN*ones(md.mesh.numberofvertices,1); +md.stressbalance.spcvx=NaN*ones(md.mesh.numberofvertices,1); +md.stressbalance.spcvy=NaN*ones(md.mesh.numberofvertices,1); +md.stressbalance.spcvz=NaN*ones(md.mesh.numberofvertices,1); %constrain flanks to 0 normal velocity pos=find(md.mesh.x==xmin | md.mesh.x==xmax); -md.diagnostic.spcvx(pos)=0; -md.diagnostic.spcvz(pos)=NaN; +md.stressbalance.spcvx(pos)=0; +md.stressbalance.spcvz(pos)=NaN; %constrain grounding line to 0 velocity pos=find(md.mesh.y==ymin); -md.diagnostic.spcvx(pos)=0; -md.diagnostic.spcvy(pos)=0; +md.stressbalance.spcvx(pos)=0; +md.stressbalance.spcvy(pos)=0; %icefront @@ -56,5 +56,5 @@ md.mask.icelevelset=1-nodeonicefront; -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %create analytical solution: strain rate is constant = ((rho_ice*g*h)/4B)^3 (Paterson, 4th Edition, page 292. @@ -65,3 +65,3 @@ field_names ={'Vy'}; field_tolerances={1e-13}; -field_values={(md.results.DiagnosticSolution.Vy)}; +field_values={(md.results.StressbalanceSolution.Vy)}; Index: /issm/trunk-jpl/test/NightlyRun/test217.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test217.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test217.py (revision 15771) @@ -21,5 +21,5 @@ # tighten -md.diagnostic.restol=10**-4 +md.stressbalance.restol=10**-4 # needed later @@ -48,17 +48,17 @@ # Boundary conditions: -md.diagnostic.spcvx=float(nan)*ones((md.mesh.numberofvertices,1)) -md.diagnostic.spcvy=float(nan)*ones((md.mesh.numberofvertices,1)) -md.diagnostic.spcvz=float(nan)*ones((md.mesh.numberofvertices,1)) +md.stressbalance.spcvx=float(nan)*ones((md.mesh.numberofvertices,1)) +md.stressbalance.spcvy=float(nan)*ones((md.mesh.numberofvertices,1)) +md.stressbalance.spcvz=float(nan)*ones((md.mesh.numberofvertices,1)) # constrain flanks to 0 normal velocity pos=numpy.nonzero(numpy.logical_or(md.mesh.x==xmin,md.mesh.x==xmax)) -md.diagnostic.spcvx[pos]=0 -md.diagnostic.spcvz[pos]=float(nan) +md.stressbalance.spcvx[pos]=0 +md.stressbalance.spcvz[pos]=float(nan) # constrain grounding line to 0 velocity pos=numpy.nonzero(md.mesh.y==ymin) -md.diagnostic.spcvx[pos]=0 -md.diagnostic.spcvy[pos]=0 +md.stressbalance.spcvx[pos]=0 +md.stressbalance.spcvy[pos]=0 # icefront @@ -68,5 +68,5 @@ md.mask.icelevelset=1-nodeonicefront -md=solve(md,DiagnosticSolutionEnum()) +md=solve(md,StressbalanceSolutionEnum()) # create analytical solution: strain rate is constant = ((rho_ice*g*h)/4B)^3 (Paterson, 4th Edition, page 292. @@ -78,4 +78,4 @@ field_tolerances=[1e-13] field_values=[\ - md.results.DiagnosticSolution.Vy,\ + md.results.StressbalanceSolution.Vy,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test218.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test218.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test218.m (revision 15771) @@ -34,17 +34,17 @@ %Boundary conditions: -md.diagnostic.spcvx=NaN*ones(md.mesh.numberofvertices,1); -md.diagnostic.spcvy=NaN*ones(md.mesh.numberofvertices,1); -md.diagnostic.spcvz=NaN*ones(md.mesh.numberofvertices,1); +md.stressbalance.spcvx=NaN*ones(md.mesh.numberofvertices,1); +md.stressbalance.spcvy=NaN*ones(md.mesh.numberofvertices,1); +md.stressbalance.spcvz=NaN*ones(md.mesh.numberofvertices,1); %constrain flanks to 0 normal velocity pos=find(md.mesh.x==xmin | md.mesh.x==xmax); -md.diagnostic.spcvx(pos)=0; -md.diagnostic.spcvz(pos)=NaN; +md.stressbalance.spcvx(pos)=0; +md.stressbalance.spcvz(pos)=NaN; %constrain grounding line to 0 velocity pos=find(md.mesh.y==ymin); -md.diagnostic.spcvx(pos)=0; -md.diagnostic.spcvy(pos)=0; +md.stressbalance.spcvx(pos)=0; +md.stressbalance.spcvy(pos)=0; %partitioning @@ -65,14 +65,14 @@ %parameters md.qmu.params.direct=true; -md.qmu.params.analysis_driver='diagnostic'; +md.qmu.params.analysis_driver='stressbalance'; md.qmu.params.evaluation_concurrency=1; md.qmu.params.interval_type='forward'; %imperative! -md.diagnostic.reltol=10^-10; %tighten for qmu analysese +md.stressbalance.reltol=10^-10; %tighten for qmu analysese md.qmu.isdakota=1; %solve -md=solve(md,DiagnosticSolutionEnum(),'overwrite','y'); +md=solve(md,StressbalanceSolutionEnum(),'overwrite','y'); %Fields and tolerances to track changes Index: /issm/trunk-jpl/test/NightlyRun/test219.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test219.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test219.m (revision 15771) @@ -5,5 +5,5 @@ md=setflowequation(md,'HO','../Exp/SquareHalfRight.exp','fill','SSA'); md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %Fields and tolerances to track changes @@ -11,8 +11,8 @@ field_tolerances={1e-09,1e-09,1e-09,1e-09,1e-13}; field_values={... - (md.results.DiagnosticSolution.Vx),... - (md.results.DiagnosticSolution.Vy),... - (md.results.DiagnosticSolution.Vz),... - (md.results.DiagnosticSolution.Vel),... - (md.results.DiagnosticSolution.Pressure),... + (md.results.StressbalanceSolution.Vx),... + (md.results.StressbalanceSolution.Vy),... + (md.results.StressbalanceSolution.Vz),... + (md.results.StressbalanceSolution.Vel),... + (md.results.StressbalanceSolution.Pressure),... }; Index: /issm/trunk-jpl/test/NightlyRun/test219.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test219.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test219.py (revision 15771) @@ -15,5 +15,5 @@ md=setflowequation(md,'HO','../Exp/SquareHalfRight.exp','fill','SSA') md.cluster=generic('name',oshostname(),'np',3) -md=solve(md,DiagnosticSolutionEnum()) +md=solve(md,StressbalanceSolutionEnum()) # Fields and tolerances to track changes @@ -22,8 +22,8 @@ field_tolerances=[1e-09,1e-09,1e-09,1e-09,1e-13] field_values=[\ - md.results.DiagnosticSolution.Vx,\ - md.results.DiagnosticSolution.Vy,\ - md.results.DiagnosticSolution.Vz,\ - md.results.DiagnosticSolution.Vel,\ - md.results.DiagnosticSolution.Pressure,\ + md.results.StressbalanceSolution.Vx,\ + md.results.StressbalanceSolution.Vy,\ + md.results.StressbalanceSolution.Vz,\ + md.results.StressbalanceSolution.Vel,\ + md.results.StressbalanceSolution.Pressure,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test220.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test220.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test220.m (revision 15771) @@ -5,5 +5,5 @@ md=setflowequation(md,'FS','../Exp/SquareHalfRight.exp','fill','HO'); md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %Fields and tolerances to track changes @@ -11,8 +11,8 @@ field_tolerances={1e-09,1e-09,1e-06,1e-09,1e-09}; field_values={... - (md.results.DiagnosticSolution.Vx),... - (md.results.DiagnosticSolution.Vy),... - (md.results.DiagnosticSolution.Vz),... - (md.results.DiagnosticSolution.Vel),... - (md.results.DiagnosticSolution.Pressure),... + (md.results.StressbalanceSolution.Vx),... + (md.results.StressbalanceSolution.Vy),... + (md.results.StressbalanceSolution.Vz),... + (md.results.StressbalanceSolution.Vel),... + (md.results.StressbalanceSolution.Pressure),... }; Index: /issm/trunk-jpl/test/NightlyRun/test220.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test220.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test220.py (revision 15771) @@ -15,5 +15,5 @@ md=setflowequation(md,'FS','../Exp/SquareHalfRight.exp','fill','HO') md.cluster=generic('name',oshostname(),'np',3) -md=solve(md,DiagnosticSolutionEnum()) +md=solve(md,StressbalanceSolutionEnum()) # Fields and tolerances to track changes @@ -22,8 +22,8 @@ field_tolerances=[1e-09,1e-09,1e-06,1e-09,1e-09] field_values=[\ - md.results.DiagnosticSolution.Vx,\ - md.results.DiagnosticSolution.Vy,\ - md.results.DiagnosticSolution.Vz,\ - md.results.DiagnosticSolution.Vel,\ - md.results.DiagnosticSolution.Pressure,\ + md.results.StressbalanceSolution.Vx,\ + md.results.StressbalanceSolution.Vy,\ + md.results.StressbalanceSolution.Vz,\ + md.results.StressbalanceSolution.Vel,\ + md.results.StressbalanceSolution.Pressure,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test221.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test221.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test221.m (revision 15771) @@ -5,6 +5,6 @@ md=setflowequation(md,'FS','../Exp/SquareHalfRight.exp','fill','SSA'); md.cluster=generic('name',oshostname(),'np',3); -md.diagnostic.viscosity_overshoot=0; -md=solve(md,DiagnosticSolutionEnum()); +md.stressbalance.viscosity_overshoot=0; +md=solve(md,StressbalanceSolutionEnum()); %Fields and tolerances to track changes @@ -12,8 +12,8 @@ field_tolerances={1e-09,1e-09,1e-06,1e-09,1e-09}; field_values={... - (md.results.DiagnosticSolution.Vx),... - (md.results.DiagnosticSolution.Vy),... - (md.results.DiagnosticSolution.Vz),... - (md.results.DiagnosticSolution.Vel),... - (md.results.DiagnosticSolution.Pressure),... + (md.results.StressbalanceSolution.Vx),... + (md.results.StressbalanceSolution.Vy),... + (md.results.StressbalanceSolution.Vz),... + (md.results.StressbalanceSolution.Vel),... + (md.results.StressbalanceSolution.Pressure),... }; Index: /issm/trunk-jpl/test/NightlyRun/test221.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test221.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test221.py (revision 15771) @@ -14,6 +14,6 @@ md=setflowequation(md,'FS','../Exp/SquareHalfRight.exp','fill','SSA') md.cluster=generic('name',oshostname(),'np',3) -md.diagnostic.viscosity_overshoot=0 -md=solve(md,DiagnosticSolutionEnum()) +md.stressbalance.viscosity_overshoot=0 +md=solve(md,StressbalanceSolutionEnum()) #Fields and tolerances to track changes @@ -21,8 +21,8 @@ field_tolerances=[1e-09,1e-09,1e-06,1e-09,1e-09] field_values=[\ - md.results.DiagnosticSolution.Vx,\ - md.results.DiagnosticSolution.Vy,\ - md.results.DiagnosticSolution.Vz,\ - md.results.DiagnosticSolution.Vel,\ - md.results.DiagnosticSolution.Pressure,\ + md.results.StressbalanceSolution.Vx,\ + md.results.StressbalanceSolution.Vy,\ + md.results.StressbalanceSolution.Vz,\ + md.results.StressbalanceSolution.Vel,\ + md.results.StressbalanceSolution.Pressure,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test232.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test232.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test232.m (revision 15771) @@ -8,5 +8,5 @@ md.timestepping.time_step=1; md.timestepping.final_time=4; -md.transient.isdiagnostic=0; +md.transient.isstressbalance=0; md.transient.ismasstransport=0; md.transient.isthermal=1; Index: /issm/trunk-jpl/test/NightlyRun/test232.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test232.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test232.py (revision 15771) @@ -18,5 +18,5 @@ md.timestepping.time_step=1. md.timestepping.final_time=4. -md.transient.isdiagnostic=False +md.transient.isstressbalance=False md.transient.ismasstransport=False md.transient.isthermal=True Index: /issm/trunk-jpl/test/NightlyRun/test234.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test234.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test234.m (revision 15771) @@ -56,5 +56,5 @@ md.qmu.isdakota=1; -md.diagnostic.reltol=10^-5; %tighten for qmu analyses +md.stressbalance.reltol=10^-5; %tighten for qmu analyses md.transient.requested_outputs=IceVolumeEnum(); Index: /issm/trunk-jpl/test/NightlyRun/test235.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test235.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test235.m (revision 15771) @@ -51,5 +51,5 @@ md.qmu.isdakota=1; -md.diagnostic.reltol=10^-5; %tighten for qmu analyses +md.stressbalance.reltol=10^-5; %tighten for qmu analyses md.transient.requested_outputs=IceVolumeEnum(); Index: /issm/trunk-jpl/test/NightlyRun/test270.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test270.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test270.m (revision 15771) @@ -8,5 +8,5 @@ md=setflowequation(md,'SSA','all'); md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %Fields and tolerances to track changes @@ -14,7 +14,7 @@ field_tolerances={1e-13,1e-13,1e-13,1e-13}; field_values={... - (md.results.DiagnosticSolution.Vx),... - (md.results.DiagnosticSolution.Vy),... - (md.results.DiagnosticSolution.Vel),... - (md.results.DiagnosticSolution.Pressure),... + (md.results.StressbalanceSolution.Vx),... + (md.results.StressbalanceSolution.Vy),... + (md.results.StressbalanceSolution.Vel),... + (md.results.StressbalanceSolution.Pressure),... }; Index: /issm/trunk-jpl/test/NightlyRun/test270.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test270.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test270.py (revision 15771) @@ -20,5 +20,5 @@ md=setflowequation(md,'SSA','all') md.cluster=generic('name',oshostname(),'np',3) -md=solve(md,DiagnosticSolutionEnum()) +md=solve(md,StressbalanceSolutionEnum()) #Fields and tolerances to track changes @@ -26,7 +26,7 @@ field_tolerances=[1e-13,1e-13,1e-13,1e-13] field_values=[\ - md.results.DiagnosticSolution.Vx,\ - md.results.DiagnosticSolution.Vy,\ - md.results.DiagnosticSolution.Vel,\ - md.results.DiagnosticSolution.Pressure,\ + md.results.StressbalanceSolution.Vx,\ + md.results.StressbalanceSolution.Vy,\ + md.results.StressbalanceSolution.Vel,\ + md.results.StressbalanceSolution.Pressure,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test272.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test272.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test272.m (revision 15771) @@ -23,5 +23,5 @@ md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %Fields and tolerances to track changes @@ -29,10 +29,10 @@ field_tolerances={1e-12,1e-12,1e-12,1e-12,1e-12,1e-12,1e-12,1e-12,1e-12,1e-12}; field_values={... - (md.results.DiagnosticSolution.Gradient1),... - (md.results.DiagnosticSolution.J),... - (md.results.DiagnosticSolution.MaterialsRheologyZbar),... - (md.results.DiagnosticSolution.Pressure),... - (md.results.DiagnosticSolution.Vel),... - (md.results.DiagnosticSolution.Vx),... - (md.results.DiagnosticSolution.Vy) + (md.results.StressbalanceSolution.Gradient1),... + (md.results.StressbalanceSolution.J),... + (md.results.StressbalanceSolution.MaterialsRheologyZbar),... + (md.results.StressbalanceSolution.Pressure),... + (md.results.StressbalanceSolution.Vel),... + (md.results.StressbalanceSolution.Vx),... + (md.results.StressbalanceSolution.Vy) }; Index: /issm/trunk-jpl/test/NightlyRun/test272.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test272.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test272.py (revision 15771) @@ -35,5 +35,5 @@ md.cluster=generic('name',oshostname(),'np',3) -md=solve(md,DiagnosticSolutionEnum()) +md=solve(md,StressbalanceSolutionEnum()) #Fields and tolerances to track changes @@ -41,10 +41,10 @@ field_tolerances=[1e-12,1e-12,1e-12,1e-12,1e-12,1e-12,1e-12,1e-12,1e-12,1e-12] field_values=[\ - md.results.DiagnosticSolution.Gradient1,\ - md.results.DiagnosticSolution.J,\ - md.results.DiagnosticSolution.MaterialsRheologyZbar,\ - md.results.DiagnosticSolution.Pressure,\ - md.results.DiagnosticSolution.Vel,\ - md.results.DiagnosticSolution.Vx,\ - md.results.DiagnosticSolution.Vy,\ + md.results.StressbalanceSolution.Gradient1,\ + md.results.StressbalanceSolution.J,\ + md.results.StressbalanceSolution.MaterialsRheologyZbar,\ + md.results.StressbalanceSolution.Pressure,\ + md.results.StressbalanceSolution.Vel,\ + md.results.StressbalanceSolution.Vx,\ + md.results.StressbalanceSolution.Vy,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test274.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test274.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test274.m (revision 15771) @@ -10,5 +10,5 @@ md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %Fields and tolerances to track changes @@ -16,7 +16,7 @@ field_tolerances={1e-11,1e-11,1e-11,1e-11}; field_values={... - (md.results.DiagnosticSolution.Vx),... - (md.results.DiagnosticSolution.Vy),... - (md.results.DiagnosticSolution.Vel),... - (md.results.DiagnosticSolution.Pressure),... + (md.results.StressbalanceSolution.Vx),... + (md.results.StressbalanceSolution.Vy),... + (md.results.StressbalanceSolution.Vel),... + (md.results.StressbalanceSolution.Pressure),... }; Index: /issm/trunk-jpl/test/NightlyRun/test274.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test274.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test274.py (revision 15771) @@ -23,5 +23,5 @@ md.cluster=generic('name',oshostname(),'np',3) -md=solve(md,DiagnosticSolutionEnum()) +md=solve(md,StressbalanceSolutionEnum()) #Fields and tolerances to track changes @@ -29,7 +29,7 @@ field_tolerances=[1e-11,1e-11,1e-11,1e-11] field_values=[\ - md.results.DiagnosticSolution.Vx,\ - md.results.DiagnosticSolution.Vy,\ - md.results.DiagnosticSolution.Vel,\ - md.results.DiagnosticSolution.Pressure,\ + md.results.StressbalanceSolution.Vx,\ + md.results.StressbalanceSolution.Vy,\ + md.results.StressbalanceSolution.Vel,\ + md.results.StressbalanceSolution.Pressure,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test280.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test280.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test280.m (revision 15771) @@ -5,5 +5,5 @@ md.flowequation.fe_SSA=1; md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %Fields and tolerances to track changes @@ -11,7 +11,7 @@ field_tolerances={1e-12,1e-13,1e-13,1e-13}; field_values={... - (md.results.DiagnosticSolution.Vx),... - (md.results.DiagnosticSolution.Vy),... - (md.results.DiagnosticSolution.Vel),... - (md.results.DiagnosticSolution.Pressure),... + (md.results.StressbalanceSolution.Vx),... + (md.results.StressbalanceSolution.Vy),... + (md.results.StressbalanceSolution.Vel),... + (md.results.StressbalanceSolution.Pressure),... }; Index: /issm/trunk-jpl/test/NightlyRun/test280.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test280.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test280.py (revision 15771) @@ -15,5 +15,5 @@ md.flowequation.fe_SSA=1 md.cluster=generic('name',oshostname(),'np',3) -md=solve(md,DiagnosticSolutionEnum()) +md=solve(md,StressbalanceSolutionEnum()) #Fields and tolerances to track changes @@ -21,7 +21,7 @@ field_tolerances=[1e-12,1e-13,1e-13,1e-13] field_values=[\ - md.results.DiagnosticSolution.Vx,\ - md.results.DiagnosticSolution.Vy,\ - md.results.DiagnosticSolution.Vel,\ - md.results.DiagnosticSolution.Pressure,\ + md.results.StressbalanceSolution.Vx,\ + md.results.StressbalanceSolution.Vy,\ + md.results.StressbalanceSolution.Vel,\ + md.results.StressbalanceSolution.Pressure,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test285.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test285.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test285.m (revision 15771) @@ -6,5 +6,5 @@ md.flowequation.fe_HO=1; md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %Fields and tolerances to track changes @@ -12,8 +12,8 @@ field_tolerances={1e-08,1e-08,1e-08,1e-08,1e-13}; field_values={... - (md.results.DiagnosticSolution.Vx),... - (md.results.DiagnosticSolution.Vy),... - (md.results.DiagnosticSolution.Vz),... - (md.results.DiagnosticSolution.Vel),... - (md.results.DiagnosticSolution.Pressure),... + (md.results.StressbalanceSolution.Vx),... + (md.results.StressbalanceSolution.Vy),... + (md.results.StressbalanceSolution.Vz),... + (md.results.StressbalanceSolution.Vel),... + (md.results.StressbalanceSolution.Pressure),... }; Index: /issm/trunk-jpl/test/NightlyRun/test285.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test285.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test285.py (revision 15771) @@ -16,5 +16,5 @@ md.flowequation.fe_HO=1; md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); #Fields and tolerances to track changes @@ -22,8 +22,8 @@ field_tolerances=[1e-08,1e-08,1e-08,1e-08,1e-13]; field_values=[\ - md.results.DiagnosticSolution.Vx,\ - md.results.DiagnosticSolution.Vy,\ - md.results.DiagnosticSolution.Vz,\ - md.results.DiagnosticSolution.Vel,\ - md.results.DiagnosticSolution.Pressure,\ + md.results.StressbalanceSolution.Vx,\ + md.results.StressbalanceSolution.Vy,\ + md.results.StressbalanceSolution.Vz,\ + md.results.StressbalanceSolution.Vel,\ + md.results.StressbalanceSolution.Pressure,\ ]; Index: /issm/trunk-jpl/test/NightlyRun/test286.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test286.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test286.m (revision 15771) @@ -6,5 +6,5 @@ md.flowequation.fe_HO=2; md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %Fields and tolerances to track changes @@ -12,8 +12,8 @@ field_tolerances={1e-9,1e-9,1e-9,1e-9,1e-13}; field_values={... - (md.results.DiagnosticSolution.Vx),... - (md.results.DiagnosticSolution.Vy),... - (md.results.DiagnosticSolution.Vz),... - (md.results.DiagnosticSolution.Vel),... - (md.results.DiagnosticSolution.Pressure),... + (md.results.StressbalanceSolution.Vx),... + (md.results.StressbalanceSolution.Vy),... + (md.results.StressbalanceSolution.Vz),... + (md.results.StressbalanceSolution.Vel),... + (md.results.StressbalanceSolution.Pressure),... }; Index: /issm/trunk-jpl/test/NightlyRun/test286.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test286.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test286.py (revision 15771) @@ -16,5 +16,5 @@ md.flowequation.fe_HO=2; md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); #Fields and tolerances to track changes @@ -22,8 +22,8 @@ field_tolerances=[1e-9,1e-9,1e-9,1e-9,1e-13]; field_values=[\ - md.results.DiagnosticSolution.Vx,\ - md.results.DiagnosticSolution.Vy,\ - md.results.DiagnosticSolution.Vz,\ - md.results.DiagnosticSolution.Vel,\ - md.results.DiagnosticSolution.Pressure,\ + md.results.StressbalanceSolution.Vx,\ + md.results.StressbalanceSolution.Vy,\ + md.results.StressbalanceSolution.Vz,\ + md.results.StressbalanceSolution.Vel,\ + md.results.StressbalanceSolution.Pressure,\ ]; Index: /issm/trunk-jpl/test/NightlyRun/test287.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test287.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test287.m (revision 15771) @@ -6,5 +6,5 @@ md.flowequation.fe_HO=3; md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %Fields and tolerances to track changes @@ -12,8 +12,8 @@ field_tolerances={1e-12,1e-12,1e-12,1e-12,1e-13}; field_values={... - (md.results.DiagnosticSolution.Vx),... - (md.results.DiagnosticSolution.Vy),... - (md.results.DiagnosticSolution.Vz),... - (md.results.DiagnosticSolution.Vel),... - (md.results.DiagnosticSolution.Pressure),... + (md.results.StressbalanceSolution.Vx),... + (md.results.StressbalanceSolution.Vy),... + (md.results.StressbalanceSolution.Vz),... + (md.results.StressbalanceSolution.Vel),... + (md.results.StressbalanceSolution.Pressure),... }; Index: /issm/trunk-jpl/test/NightlyRun/test287.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test287.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test287.py (revision 15771) @@ -16,5 +16,5 @@ md.flowequation.fe_HO=3; md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); #Fields and tolerances to track changes @@ -22,8 +22,8 @@ field_tolerances=[1e-12,1e-12,1e-12,1e-12,1e-13]; field_values=[\ - md.results.DiagnosticSolution.Vx,\ - md.results.DiagnosticSolution.Vy,\ - md.results.DiagnosticSolution.Vz,\ - md.results.DiagnosticSolution.Vel,\ - md.results.DiagnosticSolution.Pressure,\ + md.results.StressbalanceSolution.Vx,\ + md.results.StressbalanceSolution.Vy,\ + md.results.StressbalanceSolution.Vz,\ + md.results.StressbalanceSolution.Vel,\ + md.results.StressbalanceSolution.Pressure,\ ]; Index: /issm/trunk-jpl/test/NightlyRun/test290.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test290.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test290.m (revision 15771) @@ -6,5 +6,5 @@ md.flowequation.fe_FS=4; md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %Fields and tolerances to track changes @@ -12,8 +12,8 @@ field_tolerances={1e-7,1e-7,1e-7,1e-7,1e-7}; field_values={... - (md.results.DiagnosticSolution.Vx),... - (md.results.DiagnosticSolution.Vy),... - (md.results.DiagnosticSolution.Vz),... - (md.results.DiagnosticSolution.Vel),... - (md.results.DiagnosticSolution.Pressure),... + (md.results.StressbalanceSolution.Vx),... + (md.results.StressbalanceSolution.Vy),... + (md.results.StressbalanceSolution.Vz),... + (md.results.StressbalanceSolution.Vel),... + (md.results.StressbalanceSolution.Pressure),... }; Index: /issm/trunk-jpl/test/NightlyRun/test290.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test290.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test290.py (revision 15771) @@ -16,5 +16,5 @@ md.flowequation.fe_FS=4; md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); #Fields and tolerances to track changes @@ -22,8 +22,8 @@ field_tolerances=[1e-7,1e-7,1e-7,1e-7,1e-7]; field_values=[\ - md.results.DiagnosticSolution.Vx,\ - md.results.DiagnosticSolution.Vy,\ - md.results.DiagnosticSolution.Vz,\ - md.results.DiagnosticSolution.Vel,\ - md.results.DiagnosticSolution.Pressure,\ + md.results.StressbalanceSolution.Vx,\ + md.results.StressbalanceSolution.Vy,\ + md.results.StressbalanceSolution.Vz,\ + md.results.StressbalanceSolution.Vel,\ + md.results.StressbalanceSolution.Pressure,\ ]; Index: /issm/trunk-jpl/test/NightlyRun/test3001.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test3001.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test3001.m (revision 15771) @@ -5,9 +5,9 @@ md.cluster=generic('name',oshostname(),'np',1); md.toolkits.DefaultAnalysis=issmsolver(); -md.diagnostic.requested_outputs=StressTensorEnum(); +md.stressbalance.requested_outputs=StressTensorEnum(); md.autodiff.isautodiff=true; md.toolkits.DefaultAnalysis=issmsolver(); md.verbose=verbose('autodiff',true); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %Fields and tolerances to track changes @@ -17,10 +17,10 @@ 1e-13,1e-13,1e-13}; field_values={... - (md.results.DiagnosticSolution.Vx),... - (md.results.DiagnosticSolution.Vy),... - (md.results.DiagnosticSolution.Vel),... - (md.results.DiagnosticSolution.Pressure),... - (md.results.DiagnosticSolution.StressTensorxx),... - (md.results.DiagnosticSolution.StressTensoryy),... - (md.results.DiagnosticSolution.StressTensorxy),... + (md.results.StressbalanceSolution.Vx),... + (md.results.StressbalanceSolution.Vy),... + (md.results.StressbalanceSolution.Vel),... + (md.results.StressbalanceSolution.Pressure),... + (md.results.StressbalanceSolution.StressTensorxx),... + (md.results.StressbalanceSolution.StressTensoryy),... + (md.results.StressbalanceSolution.StressTensorxy),... }; Index: /issm/trunk-jpl/test/NightlyRun/test3001.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test3001.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test3001.py (revision 15771) @@ -13,8 +13,8 @@ md=setflowequation(md,'SSA','all') md.cluster=generic('name',oshostname(),'np',1) -md.diagnostic.requested_outputs=StressTensorEnum() +md.stressbalance.requested_outputs=StressTensorEnum() md.toolkits.DefaultAnalysis=issmsolver() md.autodiff.isautodiff=True -md=solve(md,DiagnosticSolutionEnum()) +md=solve(md,StressbalanceSolutionEnum()) #Fields and tolerances to track changes @@ -24,10 +24,10 @@ 1e-13,1e-13,1e-13] field_values=[\ - md.results.DiagnosticSolution.Vx,\ - md.results.DiagnosticSolution.Vy,\ - md.results.DiagnosticSolution.Vel,\ - md.results.DiagnosticSolution.Pressure,\ - md.results.DiagnosticSolution.StressTensorxx,\ - md.results.DiagnosticSolution.StressTensoryy,\ - md.results.DiagnosticSolution.StressTensorxy,\ + md.results.StressbalanceSolution.Vx,\ + md.results.StressbalanceSolution.Vy,\ + md.results.StressbalanceSolution.Vel,\ + md.results.StressbalanceSolution.Pressure,\ + md.results.StressbalanceSolution.StressTensorxx,\ + md.results.StressbalanceSolution.StressTensoryy,\ + md.results.StressbalanceSolution.StressTensorxy,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test3002.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test3002.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test3002.m (revision 15771) @@ -8,5 +8,5 @@ md.toolkits.DefaultAnalysis=issmsolver(); md.verbose=verbose('autodiff',true); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %Fields and tolerances to track changes @@ -14,8 +14,8 @@ field_tolerances={1e-13,1e-13,1e-13,1e-13,1e-13}; field_values={... - (md.results.DiagnosticSolution.Vx),... - (md.results.DiagnosticSolution.Vy),... - (md.results.DiagnosticSolution.Vz),... - (md.results.DiagnosticSolution.Vel),... - (md.results.DiagnosticSolution.Pressure),... + (md.results.StressbalanceSolution.Vx),... + (md.results.StressbalanceSolution.Vy),... + (md.results.StressbalanceSolution.Vz),... + (md.results.StressbalanceSolution.Vel),... + (md.results.StressbalanceSolution.Pressure),... }; Index: /issm/trunk-jpl/test/NightlyRun/test3002.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test3002.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test3002.py (revision 15771) @@ -16,5 +16,5 @@ md.autodiff.isautodiff=True md.toolkits.DefaultAnalysis=issmsolver() -md=solve(md,DiagnosticSolutionEnum()) +md=solve(md,StressbalanceSolutionEnum()) #Fields and tolerances to track changes @@ -22,8 +22,8 @@ field_tolerances=[1e-13,1e-13,1e-13,1e-13,1e-13] field_values=[\ - md.results.DiagnosticSolution.Vx,\ - md.results.DiagnosticSolution.Vy,\ - md.results.DiagnosticSolution.Vz,\ - md.results.DiagnosticSolution.Vel,\ - md.results.DiagnosticSolution.Pressure,\ + md.results.StressbalanceSolution.Vx,\ + md.results.StressbalanceSolution.Vy,\ + md.results.StressbalanceSolution.Vz,\ + md.results.StressbalanceSolution.Vel,\ + md.results.StressbalanceSolution.Pressure,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test3003.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test3003.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test3003.m (revision 15771) @@ -5,9 +5,9 @@ md=setflowequation(md,'HO','all'); md.cluster=generic('name',oshostname(),'np',1); -md.diagnostic.requested_outputs=StressTensorEnum(); +md.stressbalance.requested_outputs=StressTensorEnum(); md.autodiff.isautodiff=true; md.toolkits.DefaultAnalysis=issmsolver(); md.verbose=verbose('autodiff',true); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %Fields and tolerances to track changes @@ -17,14 +17,14 @@ 1e-09,1e-09,1e-09,1e-09,1e-09,1e-09}; field_values={... - (md.results.DiagnosticSolution.Vx),... - (md.results.DiagnosticSolution.Vy),... - (md.results.DiagnosticSolution.Vz),... - (md.results.DiagnosticSolution.Vel),... - (md.results.DiagnosticSolution.Pressure),... - (md.results.DiagnosticSolution.StressTensorxx),... - (md.results.DiagnosticSolution.StressTensoryy),... - (md.results.DiagnosticSolution.StressTensorzz),... - (md.results.DiagnosticSolution.StressTensorxy),... - (md.results.DiagnosticSolution.StressTensorxz),... - (md.results.DiagnosticSolution.StressTensoryz),... + (md.results.StressbalanceSolution.Vx),... + (md.results.StressbalanceSolution.Vy),... + (md.results.StressbalanceSolution.Vz),... + (md.results.StressbalanceSolution.Vel),... + (md.results.StressbalanceSolution.Pressure),... + (md.results.StressbalanceSolution.StressTensorxx),... + (md.results.StressbalanceSolution.StressTensoryy),... + (md.results.StressbalanceSolution.StressTensorzz),... + (md.results.StressbalanceSolution.StressTensorxy),... + (md.results.StressbalanceSolution.StressTensorxz),... + (md.results.StressbalanceSolution.StressTensoryz),... }; Index: /issm/trunk-jpl/test/NightlyRun/test3003.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test3003.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test3003.py (revision 15771) @@ -14,8 +14,8 @@ md=setflowequation(md,'HO','all') md.cluster=generic('name',oshostname(),'np',1) -md.diagnostic.requested_outputs=StressTensorEnum() +md.stressbalance.requested_outputs=StressTensorEnum() md.toolkits.DefaultAnalysis=issmsolver() md.autodiff.isautodiff=True -md=solve(md,DiagnosticSolutionEnum()) +md=solve(md,StressbalanceSolutionEnum()) #Fields and tolerances to track changes @@ -25,14 +25,14 @@ 1e-09,1e-09,1e-09,1e-09,1e-09,1e-09] field_values=[\ - md.results.DiagnosticSolution.Vx,\ - md.results.DiagnosticSolution.Vy,\ - md.results.DiagnosticSolution.Vz,\ - md.results.DiagnosticSolution.Vel,\ - md.results.DiagnosticSolution.Pressure,\ - md.results.DiagnosticSolution.StressTensorxx,\ - md.results.DiagnosticSolution.StressTensoryy,\ - md.results.DiagnosticSolution.StressTensorzz,\ - md.results.DiagnosticSolution.StressTensorxy,\ - md.results.DiagnosticSolution.StressTensorxz,\ - md.results.DiagnosticSolution.StressTensoryz,\ + md.results.StressbalanceSolution.Vx,\ + md.results.StressbalanceSolution.Vy,\ + md.results.StressbalanceSolution.Vz,\ + md.results.StressbalanceSolution.Vel,\ + md.results.StressbalanceSolution.Pressure,\ + md.results.StressbalanceSolution.StressTensorxx,\ + md.results.StressbalanceSolution.StressTensoryy,\ + md.results.StressbalanceSolution.StressTensorzz,\ + md.results.StressbalanceSolution.StressTensorxy,\ + md.results.StressbalanceSolution.StressTensorxz,\ + md.results.StressbalanceSolution.StressTensoryz,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test3004.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test3004.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test3004.m (revision 15771) @@ -8,5 +8,5 @@ md.toolkits.DefaultAnalysis=issmsolver(); md.verbose=verbose('autodiff',true); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %Fields and tolerances to track changes @@ -14,8 +14,8 @@ field_tolerances={1e-08,1e-08,1e-07,1e-08,1e-08}; field_values={... - (md.results.DiagnosticSolution.Vx),... - (md.results.DiagnosticSolution.Vy),... - (md.results.DiagnosticSolution.Vz),... - (md.results.DiagnosticSolution.Vel),... - (md.results.DiagnosticSolution.Pressure),... + (md.results.StressbalanceSolution.Vx),... + (md.results.StressbalanceSolution.Vy),... + (md.results.StressbalanceSolution.Vz),... + (md.results.StressbalanceSolution.Vel),... + (md.results.StressbalanceSolution.Pressure),... }; Index: /issm/trunk-jpl/test/NightlyRun/test3004.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test3004.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test3004.py (revision 15771) @@ -16,5 +16,5 @@ md.toolkits.DefaultAnalysis=issmsolver() md.autodiff.isautodiff=True -md=solve(md,DiagnosticSolutionEnum()) +md=solve(md,StressbalanceSolutionEnum()) #Fields and tolerances to track changes @@ -22,8 +22,8 @@ field_tolerances=[1e-08,1e-08,1e-07,1e-08,1e-08] field_values=[\ - md.results.DiagnosticSolution.Vx,\ - md.results.DiagnosticSolution.Vy,\ - md.results.DiagnosticSolution.Vz,\ - md.results.DiagnosticSolution.Vel,\ - md.results.DiagnosticSolution.Pressure,\ + md.results.StressbalanceSolution.Vx,\ + md.results.StressbalanceSolution.Vy,\ + md.results.StressbalanceSolution.Vz,\ + md.results.StressbalanceSolution.Vel,\ + md.results.StressbalanceSolution.Pressure,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test3009.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test3009.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test3009.m (revision 15771) @@ -5,5 +5,5 @@ md=setflowequation(md,'SSA','all'); md.cluster=generic('name',oshostname(),'np',1); -md.transient.isdiagnostic=0; +md.transient.isstressbalance=0; md.transient.ismasstransport=0; md.transient.isthermal=1; Index: /issm/trunk-jpl/test/NightlyRun/test3009.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test3009.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test3009.py (revision 15771) @@ -14,5 +14,5 @@ md=setflowequation(md,'SSA','all') md.cluster=generic('name',oshostname(),'np',1) -md.transient.isdiagnostic=False +md.transient.isstressbalance=False md.transient.ismasstransport=False md.transient.isthermal=True Index: /issm/trunk-jpl/test/NightlyRun/test301.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test301.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test301.m (revision 15771) @@ -4,5 +4,5 @@ md=setflowequation(md,'SSA','all'); md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %Fields and tolerances to track changes @@ -10,7 +10,7 @@ field_tolerances={1e-13,1e-13,1e-13,1e-13}; field_values={... - (md.results.DiagnosticSolution.Vx),... - (md.results.DiagnosticSolution.Vy),... - (md.results.DiagnosticSolution.Vel),... - (md.results.DiagnosticSolution.Pressure),... + (md.results.StressbalanceSolution.Vx),... + (md.results.StressbalanceSolution.Vy),... + (md.results.StressbalanceSolution.Vel),... + (md.results.StressbalanceSolution.Pressure),... }; Index: /issm/trunk-jpl/test/NightlyRun/test301.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test301.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test301.py (revision 15771) @@ -13,5 +13,5 @@ md=setflowequation(md,'SSA','all') md.cluster=generic('name',oshostname(),'np',3) -md=solve(md,DiagnosticSolutionEnum()) +md=solve(md,StressbalanceSolutionEnum()) #Fields and tolerances to track changes @@ -19,7 +19,7 @@ field_tolerances=[1e-13,1e-13,1e-13,1e-13] field_values=[\ - md.results.DiagnosticSolution.Vx,\ - md.results.DiagnosticSolution.Vy,\ - md.results.DiagnosticSolution.Vel,\ - md.results.DiagnosticSolution.Pressure,\ + md.results.StressbalanceSolution.Vx,\ + md.results.StressbalanceSolution.Vy,\ + md.results.StressbalanceSolution.Vel,\ + md.results.StressbalanceSolution.Pressure,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test302.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test302.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test302.m (revision 15771) @@ -4,5 +4,5 @@ md=setflowequation(md,'SIA','all'); md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %Fields and tolerances to track changes @@ -10,7 +10,7 @@ field_tolerances={1e-13,1e-13,1e-13,1e-13}; field_values={... - (md.results.DiagnosticSolution.Vx),... - (md.results.DiagnosticSolution.Vy),... - (md.results.DiagnosticSolution.Vel),... - (md.results.DiagnosticSolution.Pressure),... + (md.results.StressbalanceSolution.Vx),... + (md.results.StressbalanceSolution.Vy),... + (md.results.StressbalanceSolution.Vel),... + (md.results.StressbalanceSolution.Pressure),... }; Index: /issm/trunk-jpl/test/NightlyRun/test302.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test302.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test302.py (revision 15771) @@ -13,5 +13,5 @@ md=setflowequation(md,'SIA','all') md.cluster=generic('name',oshostname(),'np',3) -md=solve(md,DiagnosticSolutionEnum()) +md=solve(md,StressbalanceSolutionEnum()) #Fields and tolerances to track changes @@ -19,7 +19,7 @@ field_tolerances=[1e-13,1e-13,1e-13,1e-13] field_values=[\ - md.results.DiagnosticSolution.Vx,\ - md.results.DiagnosticSolution.Vy,\ - md.results.DiagnosticSolution.Vel,\ - md.results.DiagnosticSolution.Pressure,\ + md.results.StressbalanceSolution.Vx,\ + md.results.StressbalanceSolution.Vy,\ + md.results.StressbalanceSolution.Vel,\ + md.results.StressbalanceSolution.Pressure,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test3020.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test3020.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test3020.m (revision 15771) @@ -10,5 +10,5 @@ md.transient.requested_outputs=[IceVolumeEnum();MaxVelEnum()]; md.verbose=verbose('autodiff',true); -md.diagnostic.restol=1e-4; +md.stressbalance.restol=1e-4; md.toolkits.DefaultAnalysis=issmsolver(); Index: /issm/trunk-jpl/test/NightlyRun/test3020.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test3020.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test3020.py (revision 15771) @@ -24,5 +24,5 @@ md.transient.requested_outputs=[IceVolumeEnum(),MaxVelEnum()] md.verbose=verbose('autodiff',True) -md.diagnostic.restol=0.000001 +md.stressbalance.restol=0.000001 md.toolkits.DefaultAnalysis=issmsolver() Index: /issm/trunk-jpl/test/NightlyRun/test3021.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test3021.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test3021.m (revision 15771) @@ -4,9 +4,9 @@ md=setflowequation(md,'SSA','all'); md.cluster=generic('name',oshostname(),'np',3); -md.diagnostic.requested_outputs=StressTensorEnum(); +md.stressbalance.requested_outputs=StressTensorEnum(); md.autodiff.isautodiff=false; md.toolkits.DefaultAnalysis=issmsolver(); md.verbose=verbose('1111111'); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %Fields and tolerances to track changes @@ -16,10 +16,10 @@ 1e-13,1e-13,1e-13}; field_values={... - (md.results.DiagnosticSolution.Vx),... - (md.results.DiagnosticSolution.Vy),... - (md.results.DiagnosticSolution.Vel),... - (md.results.DiagnosticSolution.Pressure),... - (md.results.DiagnosticSolution.StressTensorxx),... - (md.results.DiagnosticSolution.StressTensoryy),... - (md.results.DiagnosticSolution.StressTensorxy),... + (md.results.StressbalanceSolution.Vx),... + (md.results.StressbalanceSolution.Vy),... + (md.results.StressbalanceSolution.Vel),... + (md.results.StressbalanceSolution.Pressure),... + (md.results.StressbalanceSolution.StressTensorxx),... + (md.results.StressbalanceSolution.StressTensoryy),... + (md.results.StressbalanceSolution.StressTensorxy),... }; Index: /issm/trunk-jpl/test/NightlyRun/test303.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test303.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test303.m (revision 15771) @@ -4,5 +4,5 @@ md=setflowequation(md,'SIA','../Exp/SquareHalfRight.exp','fill','SSA'); md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %Fields and tolerances to track changes @@ -10,7 +10,7 @@ field_tolerances={1e-13,1e-13,1e-13,1e-13}; field_values={... - (md.results.DiagnosticSolution.Vx),... - (md.results.DiagnosticSolution.Vy),... - (md.results.DiagnosticSolution.Vel),... - (md.results.DiagnosticSolution.Pressure),... + (md.results.StressbalanceSolution.Vx),... + (md.results.StressbalanceSolution.Vy),... + (md.results.StressbalanceSolution.Vel),... + (md.results.StressbalanceSolution.Pressure),... }; Index: /issm/trunk-jpl/test/NightlyRun/test303.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test303.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test303.py (revision 15771) @@ -13,5 +13,5 @@ md=setflowequation(md,'SIA','../Exp/SquareHalfRight.exp','fill','SSA') md.cluster=generic('name',oshostname(),'np',3) -md=solve(md,DiagnosticSolutionEnum()) +md=solve(md,StressbalanceSolutionEnum()) #Fields and tolerances to track changes @@ -19,7 +19,7 @@ field_tolerances=[1e-13,1e-13,1e-13,1e-13] field_values=[\ - md.results.DiagnosticSolution.Vx,\ - md.results.DiagnosticSolution.Vy,\ - md.results.DiagnosticSolution.Vel,\ - md.results.DiagnosticSolution.Pressure,\ + md.results.StressbalanceSolution.Vx,\ + md.results.StressbalanceSolution.Vy,\ + md.results.StressbalanceSolution.Vel,\ + md.results.StressbalanceSolution.Pressure,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test304.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test304.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test304.m (revision 15771) @@ -5,5 +5,5 @@ md=setflowequation(md,'SSA','all'); md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %Fields and tolerances to track changes @@ -11,8 +11,8 @@ field_tolerances={1e-13,1e-13,1e-13,1e-13,1e-13}; field_values={... - (md.results.DiagnosticSolution.Vx),... - (md.results.DiagnosticSolution.Vy),... - (md.results.DiagnosticSolution.Vz),... - (md.results.DiagnosticSolution.Vel),... - (md.results.DiagnosticSolution.Pressure),... + (md.results.StressbalanceSolution.Vx),... + (md.results.StressbalanceSolution.Vy),... + (md.results.StressbalanceSolution.Vz),... + (md.results.StressbalanceSolution.Vel),... + (md.results.StressbalanceSolution.Pressure),... }; Index: /issm/trunk-jpl/test/NightlyRun/test304.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test304.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test304.py (revision 15771) @@ -14,5 +14,5 @@ md=setflowequation(md,'SSA','all') md.cluster=generic('name',oshostname(),'np',3) -md=solve(md,DiagnosticSolutionEnum()) +md=solve(md,StressbalanceSolutionEnum()) #Fields and tolerances to track changes @@ -20,8 +20,8 @@ field_tolerances=[1e-13,1e-13,1e-13,1e-13,1e-13] field_values=[\ - md.results.DiagnosticSolution.Vx,\ - md.results.DiagnosticSolution.Vy,\ - md.results.DiagnosticSolution.Vz,\ - md.results.DiagnosticSolution.Vel,\ - md.results.DiagnosticSolution.Pressure,\ + md.results.StressbalanceSolution.Vx,\ + md.results.StressbalanceSolution.Vy,\ + md.results.StressbalanceSolution.Vz,\ + md.results.StressbalanceSolution.Vel,\ + md.results.StressbalanceSolution.Pressure,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test305.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test305.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test305.m (revision 15771) @@ -5,5 +5,5 @@ md=setflowequation(md,'SIA','all'); md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %Fields and tolerances to track changes @@ -11,8 +11,8 @@ field_tolerances={1e-13,1e-13,1e-13,1e-13,1e-13}; field_values={... - (md.results.DiagnosticSolution.Vx),... - (md.results.DiagnosticSolution.Vy),... - (md.results.DiagnosticSolution.Vz),... - (md.results.DiagnosticSolution.Vel),... - (md.results.DiagnosticSolution.Pressure),... + (md.results.StressbalanceSolution.Vx),... + (md.results.StressbalanceSolution.Vy),... + (md.results.StressbalanceSolution.Vz),... + (md.results.StressbalanceSolution.Vel),... + (md.results.StressbalanceSolution.Pressure),... }; Index: /issm/trunk-jpl/test/NightlyRun/test305.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test305.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test305.py (revision 15771) @@ -14,5 +14,5 @@ md=setflowequation(md,'SIA','all') md.cluster=generic('name',oshostname(),'np',3) -md=solve(md,DiagnosticSolutionEnum()) +md=solve(md,StressbalanceSolutionEnum()) #Fields and tolerances to track changes @@ -20,8 +20,8 @@ field_tolerances=[1e-13,1e-13,1e-13,1e-13,1e-13] field_values=[\ - md.results.DiagnosticSolution.Vx,\ - md.results.DiagnosticSolution.Vy,\ - md.results.DiagnosticSolution.Vz,\ - md.results.DiagnosticSolution.Vel,\ - md.results.DiagnosticSolution.Pressure,\ + md.results.StressbalanceSolution.Vx,\ + md.results.StressbalanceSolution.Vy,\ + md.results.StressbalanceSolution.Vz,\ + md.results.StressbalanceSolution.Vel,\ + md.results.StressbalanceSolution.Pressure,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test306.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test306.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test306.m (revision 15771) @@ -5,5 +5,5 @@ md=setflowequation(md,'SIA','../Exp/SquareHalfRight.exp','fill','SSA'); md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %Fields and tolerances to track changes @@ -11,8 +11,8 @@ field_tolerances={1e-13,1e-13,1e-13,1e-13,1e-13}; field_values={... - (md.results.DiagnosticSolution.Vx),... - (md.results.DiagnosticSolution.Vy),... - (md.results.DiagnosticSolution.Vz),... - (md.results.DiagnosticSolution.Vel),... - (md.results.DiagnosticSolution.Pressure),... + (md.results.StressbalanceSolution.Vx),... + (md.results.StressbalanceSolution.Vy),... + (md.results.StressbalanceSolution.Vz),... + (md.results.StressbalanceSolution.Vel),... + (md.results.StressbalanceSolution.Pressure),... }; Index: /issm/trunk-jpl/test/NightlyRun/test306.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test306.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test306.py (revision 15771) @@ -14,5 +14,5 @@ md=setflowequation(md,'SIA','../Exp/SquareHalfRight.exp','fill','SSA') md.cluster=generic('name',oshostname(),'np',3) -md=solve(md,DiagnosticSolutionEnum()) +md=solve(md,StressbalanceSolutionEnum()) #Fields and tolerances to track changes @@ -20,8 +20,8 @@ field_tolerances=[1e-13,1e-13,1e-13,1e-13,1e-13] field_values=[\ - md.results.DiagnosticSolution.Vx,\ - md.results.DiagnosticSolution.Vy,\ - md.results.DiagnosticSolution.Vz,\ - md.results.DiagnosticSolution.Vel,\ - md.results.DiagnosticSolution.Pressure,\ + md.results.StressbalanceSolution.Vx,\ + md.results.StressbalanceSolution.Vy,\ + md.results.StressbalanceSolution.Vz,\ + md.results.StressbalanceSolution.Vel,\ + md.results.StressbalanceSolution.Pressure,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test307.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test307.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test307.m (revision 15771) @@ -5,5 +5,5 @@ md=setflowequation(md,'HO','all'); md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %Fields and tolerances to track changes @@ -11,8 +11,8 @@ field_tolerances={1e-09,1e-09,2e-10,2e-10,1e-10}; field_values={... - (md.results.DiagnosticSolution.Vx),... - (md.results.DiagnosticSolution.Vy),... - (md.results.DiagnosticSolution.Vz),... - (md.results.DiagnosticSolution.Vel),... - (md.results.DiagnosticSolution.Pressure),... + (md.results.StressbalanceSolution.Vx),... + (md.results.StressbalanceSolution.Vy),... + (md.results.StressbalanceSolution.Vz),... + (md.results.StressbalanceSolution.Vel),... + (md.results.StressbalanceSolution.Pressure),... }; Index: /issm/trunk-jpl/test/NightlyRun/test307.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test307.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test307.py (revision 15771) @@ -14,5 +14,5 @@ md=setflowequation(md,'HO','all') md.cluster=generic('name',oshostname(),'np',3) -md=solve(md,DiagnosticSolutionEnum()) +md=solve(md,StressbalanceSolutionEnum()) #Fields and tolerances to track changes @@ -20,8 +20,8 @@ field_tolerances=[1e-09,1e-09,2e-10,2e-10,1e-10] field_values=[\ - md.results.DiagnosticSolution.Vx,\ - md.results.DiagnosticSolution.Vy,\ - md.results.DiagnosticSolution.Vz,\ - md.results.DiagnosticSolution.Vel,\ - md.results.DiagnosticSolution.Pressure,\ + md.results.StressbalanceSolution.Vx,\ + md.results.StressbalanceSolution.Vy,\ + md.results.StressbalanceSolution.Vz,\ + md.results.StressbalanceSolution.Vel,\ + md.results.StressbalanceSolution.Pressure,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test308.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test308.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test308.m (revision 15771) @@ -5,5 +5,5 @@ md=setflowequation(md,'FS','all'); md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %Fields and tolerances to track changes @@ -11,8 +11,8 @@ field_tolerances={1e-09,1e-09,1e-09,1e-09,1e-09}; field_values={... - (md.results.DiagnosticSolution.Vx),... - (md.results.DiagnosticSolution.Vy),... - (md.results.DiagnosticSolution.Vz),... - (md.results.DiagnosticSolution.Vel),... - (md.results.DiagnosticSolution.Pressure),... + (md.results.StressbalanceSolution.Vx),... + (md.results.StressbalanceSolution.Vy),... + (md.results.StressbalanceSolution.Vz),... + (md.results.StressbalanceSolution.Vel),... + (md.results.StressbalanceSolution.Pressure),... }; Index: /issm/trunk-jpl/test/NightlyRun/test308.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test308.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test308.py (revision 15771) @@ -14,5 +14,5 @@ md=setflowequation(md,'FS','all') md.cluster=generic('name',oshostname(),'np',3) -md=solve(md,DiagnosticSolutionEnum()) +md=solve(md,StressbalanceSolutionEnum()) #Fields and tolerances to track changes @@ -20,8 +20,8 @@ field_tolerances=[1e-09,1e-09,1e-09,1e-09,1e-09] field_values=[\ - md.results.DiagnosticSolution.Vx,\ - md.results.DiagnosticSolution.Vy,\ - md.results.DiagnosticSolution.Vz,\ - md.results.DiagnosticSolution.Vel,\ - md.results.DiagnosticSolution.Pressure,\ + md.results.StressbalanceSolution.Vx,\ + md.results.StressbalanceSolution.Vy,\ + md.results.StressbalanceSolution.Vz,\ + md.results.StressbalanceSolution.Vel,\ + md.results.StressbalanceSolution.Pressure,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test313.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test313.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test313.m (revision 15771) @@ -6,5 +6,5 @@ md.cluster=generic('name',oshostname(),'np',3); md.verbose=verbose('convergence',true,'solution',true); -md.transient.isdiagnostic=0; +md.transient.isstressbalance=0; md.transient.ismasstransport=0; md.transient.isthermal=1; Index: /issm/trunk-jpl/test/NightlyRun/test313.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test313.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test313.py (revision 15771) @@ -15,5 +15,5 @@ md.cluster=generic('name',oshostname(),'np',3) md.verbose=verbose('convergence',True,'solution',True) -md.transient.isdiagnostic=False +md.transient.isstressbalance=False md.transient.ismasstransport=False md.transient.isthermal=True Index: /issm/trunk-jpl/test/NightlyRun/test319.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test319.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test319.m (revision 15771) @@ -18,5 +18,5 @@ md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %Fields and tolerances to track changes @@ -24,10 +24,10 @@ field_tolerances={1e-12,1e-13,1e-13,1e-13,1e-13,1e-13,1e-13,1e-13,1e-13,1e-13}; field_values={... - (md.results.DiagnosticSolution.Gradient1),... - (md.results.DiagnosticSolution.J),... - (md.results.DiagnosticSolution.FrictionCoefficient),... - (md.results.DiagnosticSolution.Pressure),... - (md.results.DiagnosticSolution.Vel),... - (md.results.DiagnosticSolution.Vx),... - (md.results.DiagnosticSolution.Vy) + (md.results.StressbalanceSolution.Gradient1),... + (md.results.StressbalanceSolution.J),... + (md.results.StressbalanceSolution.FrictionCoefficient),... + (md.results.StressbalanceSolution.Pressure),... + (md.results.StressbalanceSolution.Vel),... + (md.results.StressbalanceSolution.Vx),... + (md.results.StressbalanceSolution.Vy) }; Index: /issm/trunk-jpl/test/NightlyRun/test319.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test319.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test319.py (revision 15771) @@ -30,5 +30,5 @@ md.cluster=generic('name',oshostname(),'np',3) -md=solve(md,DiagnosticSolutionEnum()) +md=solve(md,StressbalanceSolutionEnum()) #Fields and tolerances to track changes @@ -36,10 +36,10 @@ field_tolerances=[1e-12,1e-13,1e-13,1e-13,1e-13,1e-13,1e-13,1e-13,1e-13,1e-13] field_values=[\ - md.results.DiagnosticSolution.Gradient1,\ - md.results.DiagnosticSolution.J,\ - md.results.DiagnosticSolution.FrictionCoefficient,\ - md.results.DiagnosticSolution.Pressure,\ - md.results.DiagnosticSolution.Vel,\ - md.results.DiagnosticSolution.Vx,\ - md.results.DiagnosticSolution.Vy,\ + md.results.StressbalanceSolution.Gradient1,\ + md.results.StressbalanceSolution.J,\ + md.results.StressbalanceSolution.FrictionCoefficient,\ + md.results.StressbalanceSolution.Pressure,\ + md.results.StressbalanceSolution.Vel,\ + md.results.StressbalanceSolution.Vx,\ + md.results.StressbalanceSolution.Vy,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test320.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test320.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test320.m (revision 15771) @@ -19,5 +19,5 @@ md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %Fields and tolerances to track changes @@ -25,10 +25,10 @@ field_tolerances={1e-12,1e-12,1e-12,1e-12,1e-12,1e-12,1e-12,1e-12,1e-12,1e-12}; field_values={... - (md.results.DiagnosticSolution.Gradient1),... - (md.results.DiagnosticSolution.J),... - (md.results.DiagnosticSolution.FrictionCoefficient),... - (md.results.DiagnosticSolution.Pressure),... - (md.results.DiagnosticSolution.Vel),... - (md.results.DiagnosticSolution.Vx),... - (md.results.DiagnosticSolution.Vy) + (md.results.StressbalanceSolution.Gradient1),... + (md.results.StressbalanceSolution.J),... + (md.results.StressbalanceSolution.FrictionCoefficient),... + (md.results.StressbalanceSolution.Pressure),... + (md.results.StressbalanceSolution.Vel),... + (md.results.StressbalanceSolution.Vx),... + (md.results.StressbalanceSolution.Vy) }; Index: /issm/trunk-jpl/test/NightlyRun/test320.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test320.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test320.py (revision 15771) @@ -31,5 +31,5 @@ md.cluster=generic('name',oshostname(),'np',3) -md=solve(md,DiagnosticSolutionEnum()) +md=solve(md,StressbalanceSolutionEnum()) #Fields and tolerances to track changes @@ -37,10 +37,10 @@ field_tolerances=[1e-12,1e-12,1e-12,1e-12,1e-12,1e-12,1e-12,1e-12,1e-12,1e-12] field_values=[\ - md.results.DiagnosticSolution.Gradient1,\ - md.results.DiagnosticSolution.J,\ - md.results.DiagnosticSolution.FrictionCoefficient,\ - md.results.DiagnosticSolution.Pressure,\ - md.results.DiagnosticSolution.Vel,\ - md.results.DiagnosticSolution.Vx,\ - md.results.DiagnosticSolution.Vy,\ + md.results.StressbalanceSolution.Gradient1,\ + md.results.StressbalanceSolution.J,\ + md.results.StressbalanceSolution.FrictionCoefficient,\ + md.results.StressbalanceSolution.Pressure,\ + md.results.StressbalanceSolution.Vel,\ + md.results.StressbalanceSolution.Vx,\ + md.results.StressbalanceSolution.Vy,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test321.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test321.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test321.m (revision 15771) @@ -19,5 +19,5 @@ md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %Fields and tolerances to track changes @@ -25,10 +25,10 @@ field_tolerances={1e-08,1e-07,1e-10,1e-10,1e-09,1e-09,1e-09}; field_values={... - (md.results.DiagnosticSolution.Gradient1),... - (md.results.DiagnosticSolution.J),... - (md.results.DiagnosticSolution.FrictionCoefficient),... - (md.results.DiagnosticSolution.Pressure),... - (md.results.DiagnosticSolution.Vel),... - (md.results.DiagnosticSolution.Vx),... - (md.results.DiagnosticSolution.Vy) + (md.results.StressbalanceSolution.Gradient1),... + (md.results.StressbalanceSolution.J),... + (md.results.StressbalanceSolution.FrictionCoefficient),... + (md.results.StressbalanceSolution.Pressure),... + (md.results.StressbalanceSolution.Vel),... + (md.results.StressbalanceSolution.Vx),... + (md.results.StressbalanceSolution.Vy) }; Index: /issm/trunk-jpl/test/NightlyRun/test321.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test321.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test321.py (revision 15771) @@ -31,5 +31,5 @@ md.cluster=generic('name',oshostname(),'np',3) -md=solve(md,DiagnosticSolutionEnum()) +md=solve(md,StressbalanceSolutionEnum()) #Fields and tolerances to track changes @@ -37,10 +37,10 @@ field_tolerances=[1e-08,1e-07,1e-10,1e-10,1e-09,1e-09,1e-09] field_values=[\ - md.results.DiagnosticSolution.Gradient1,\ - md.results.DiagnosticSolution.J,\ - md.results.DiagnosticSolution.FrictionCoefficient,\ - md.results.DiagnosticSolution.Pressure,\ - md.results.DiagnosticSolution.Vel,\ - md.results.DiagnosticSolution.Vx,\ - md.results.DiagnosticSolution.Vy,\ + md.results.StressbalanceSolution.Gradient1,\ + md.results.StressbalanceSolution.J,\ + md.results.StressbalanceSolution.FrictionCoefficient,\ + md.results.StressbalanceSolution.Pressure,\ + md.results.StressbalanceSolution.Vel,\ + md.results.StressbalanceSolution.Vx,\ + md.results.StressbalanceSolution.Vy,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test322.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test322.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test322.m (revision 15771) @@ -19,5 +19,5 @@ md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %Fields and tolerances to track changes @@ -25,10 +25,10 @@ field_tolerances={1e-06,1e-08,1e-09,1e-09,1e-09,1e-09,1e-09,1e-09,1e-09,1e-09}; field_values={... - (md.results.DiagnosticSolution.Gradient1),... - (md.results.DiagnosticSolution.J),... - (md.results.DiagnosticSolution.FrictionCoefficient),... - (md.results.DiagnosticSolution.Pressure),... - (md.results.DiagnosticSolution.Vel),... - (md.results.DiagnosticSolution.Vx),... - (md.results.DiagnosticSolution.Vy) + (md.results.StressbalanceSolution.Gradient1),... + (md.results.StressbalanceSolution.J),... + (md.results.StressbalanceSolution.FrictionCoefficient),... + (md.results.StressbalanceSolution.Pressure),... + (md.results.StressbalanceSolution.Vel),... + (md.results.StressbalanceSolution.Vx),... + (md.results.StressbalanceSolution.Vy) }; Index: /issm/trunk-jpl/test/NightlyRun/test322.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test322.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test322.py (revision 15771) @@ -31,5 +31,5 @@ md.cluster=generic('name',oshostname(),'np',3) -md=solve(md,DiagnosticSolutionEnum()) +md=solve(md,StressbalanceSolutionEnum()) #Fields and tolerances to track changes @@ -37,10 +37,10 @@ field_tolerances=[1e-06,1e-08,1e-09,1e-09,1e-09,1e-09,1e-09,1e-09,1e-09,1e-09] field_values=[\ - md.results.DiagnosticSolution.Gradient1,\ - md.results.DiagnosticSolution.J,\ - md.results.DiagnosticSolution.FrictionCoefficient,\ - md.results.DiagnosticSolution.Pressure,\ - md.results.DiagnosticSolution.Vel,\ - md.results.DiagnosticSolution.Vx,\ - md.results.DiagnosticSolution.Vy,\ + md.results.StressbalanceSolution.Gradient1,\ + md.results.StressbalanceSolution.J,\ + md.results.StressbalanceSolution.FrictionCoefficient,\ + md.results.StressbalanceSolution.Pressure,\ + md.results.StressbalanceSolution.Vel,\ + md.results.StressbalanceSolution.Vx,\ + md.results.StressbalanceSolution.Vy,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test326.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test326.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test326.m (revision 15771) @@ -6,5 +6,5 @@ md.cluster=generic('name',oshostname(),'np',3); md.initialization.waterfraction=zeros(md.mesh.numberofvertices,1); -md.transient.isdiagnostic=0; +md.transient.isstressbalance=0; md.transient.ismasstransport=0; md.transient.isthermal=1; Index: /issm/trunk-jpl/test/NightlyRun/test326.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test326.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test326.py (revision 15771) @@ -16,5 +16,5 @@ md.cluster=generic('name',oshostname(),'np',3) md.initialization.waterfraction=numpy.zeros((md.mesh.numberofvertices,1)) -md.transient.isdiagnostic=False +md.transient.isstressbalance=False md.transient.ismasstransport=False md.transient.isthermal=True Index: /issm/trunk-jpl/test/NightlyRun/test401.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test401.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test401.m (revision 15771) @@ -4,5 +4,5 @@ md=setflowequation(md,'SSA','all'); md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %Fields and tolerances to track changes @@ -10,7 +10,7 @@ field_tolerances={1e-13,1e-13,1e-13,1e-13}; field_values={... - (md.results.DiagnosticSolution.Vx),... - (md.results.DiagnosticSolution.Vy),... - (md.results.DiagnosticSolution.Vel),... - (md.results.DiagnosticSolution.Pressure),... + (md.results.StressbalanceSolution.Vx),... + (md.results.StressbalanceSolution.Vy),... + (md.results.StressbalanceSolution.Vel),... + (md.results.StressbalanceSolution.Pressure),... }; Index: /issm/trunk-jpl/test/NightlyRun/test401.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test401.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test401.py (revision 15771) @@ -14,5 +14,5 @@ md=setflowequation(md,'SSA','all') md.cluster=generic('name',oshostname(),'np',3) -md=solve(md,DiagnosticSolutionEnum()) +md=solve(md,StressbalanceSolutionEnum()) #Fields and tolerances to track changes @@ -20,7 +20,7 @@ field_tolerances=[1e-13,1e-13,1e-13,1e-13] field_values=[\ - md.results.DiagnosticSolution.Vx,\ - md.results.DiagnosticSolution.Vy,\ - md.results.DiagnosticSolution.Vel,\ - md.results.DiagnosticSolution.Pressure,\ + md.results.StressbalanceSolution.Vx,\ + md.results.StressbalanceSolution.Vy,\ + md.results.StressbalanceSolution.Vel,\ + md.results.StressbalanceSolution.Pressure,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test402.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test402.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test402.m (revision 15771) @@ -5,5 +5,5 @@ md=setflowequation(md,'SSA','all'); md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %Fields and tolerances to track changes @@ -11,8 +11,8 @@ field_tolerances={1e-13,1e-13,1e-13,1e-13,1e-13}; field_values={... - (md.results.DiagnosticSolution.Vx),... - (md.results.DiagnosticSolution.Vy),... - (md.results.DiagnosticSolution.Vz),... - (md.results.DiagnosticSolution.Vel),... - (md.results.DiagnosticSolution.Pressure),... + (md.results.StressbalanceSolution.Vx),... + (md.results.StressbalanceSolution.Vy),... + (md.results.StressbalanceSolution.Vz),... + (md.results.StressbalanceSolution.Vel),... + (md.results.StressbalanceSolution.Pressure),... }; Index: /issm/trunk-jpl/test/NightlyRun/test402.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test402.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test402.py (revision 15771) @@ -15,5 +15,5 @@ md=setflowequation(md,'SSA','all') md.cluster=generic('name',oshostname(),'np',3) -md=solve(md,DiagnosticSolutionEnum()) +md=solve(md,StressbalanceSolutionEnum()) #Fields and tolerances to track changes @@ -21,8 +21,8 @@ field_tolerances=[1e-13,1e-13,1e-13,1e-13,1e-13] field_values=[\ - md.results.DiagnosticSolution.Vx,\ - md.results.DiagnosticSolution.Vy,\ - md.results.DiagnosticSolution.Vz,\ - md.results.DiagnosticSolution.Vel,\ - md.results.DiagnosticSolution.Pressure,\ + md.results.StressbalanceSolution.Vx,\ + md.results.StressbalanceSolution.Vy,\ + md.results.StressbalanceSolution.Vz,\ + md.results.StressbalanceSolution.Vel,\ + md.results.StressbalanceSolution.Pressure,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test403.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test403.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test403.m (revision 15771) @@ -5,5 +5,5 @@ md=setflowequation(md,'HO','all'); md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %Fields and tolerances to track changes @@ -11,8 +11,8 @@ field_tolerances={1e-09,1e-09,1e-09,1e-09,1e-09}; field_values={... - (md.results.DiagnosticSolution.Vx),... - (md.results.DiagnosticSolution.Vy),... - (md.results.DiagnosticSolution.Vz),... - (md.results.DiagnosticSolution.Vel),... - (md.results.DiagnosticSolution.Pressure),... + (md.results.StressbalanceSolution.Vx),... + (md.results.StressbalanceSolution.Vy),... + (md.results.StressbalanceSolution.Vz),... + (md.results.StressbalanceSolution.Vel),... + (md.results.StressbalanceSolution.Pressure),... }; Index: /issm/trunk-jpl/test/NightlyRun/test403.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test403.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test403.py (revision 15771) @@ -15,5 +15,5 @@ md=setflowequation(md,'HO','all') md.cluster=generic('name',oshostname(),'np',3) -md=solve(md,DiagnosticSolutionEnum()) +md=solve(md,StressbalanceSolutionEnum()) #Fields and tolerances to track changes @@ -21,8 +21,8 @@ field_tolerances=[1e-09,1e-09,1e-09,1e-09,1e-09] field_values=[\ - md.results.DiagnosticSolution.Vx,\ - md.results.DiagnosticSolution.Vy,\ - md.results.DiagnosticSolution.Vz,\ - md.results.DiagnosticSolution.Vel,\ - md.results.DiagnosticSolution.Pressure,\ + md.results.StressbalanceSolution.Vx,\ + md.results.StressbalanceSolution.Vy,\ + md.results.StressbalanceSolution.Vz,\ + md.results.StressbalanceSolution.Vel,\ + md.results.StressbalanceSolution.Pressure,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test404.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test404.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test404.m (revision 15771) @@ -5,5 +5,5 @@ md=setflowequation(md,'FS','all'); md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %Fields and tolerances to track changes @@ -11,8 +11,8 @@ field_tolerances={1e-07,1e-07,1e-06,1e-07,1e-07}; field_values={... - (md.results.DiagnosticSolution.Vx),... - (md.results.DiagnosticSolution.Vy),... - (md.results.DiagnosticSolution.Vz),... - (md.results.DiagnosticSolution.Vel),... - (md.results.DiagnosticSolution.Pressure),... + (md.results.StressbalanceSolution.Vx),... + (md.results.StressbalanceSolution.Vy),... + (md.results.StressbalanceSolution.Vz),... + (md.results.StressbalanceSolution.Vel),... + (md.results.StressbalanceSolution.Pressure),... }; Index: /issm/trunk-jpl/test/NightlyRun/test404.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test404.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test404.py (revision 15771) @@ -15,5 +15,5 @@ md=setflowequation(md,'FS','all') md.cluster=generic('name',oshostname(),'np',3) -md=solve(md,DiagnosticSolutionEnum()) +md=solve(md,StressbalanceSolutionEnum()) #Fields and tolerances to track changes @@ -21,8 +21,8 @@ field_tolerances=[1e-07,1e-07,1e-06,1e-07,1e-07] field_values=[\ - md.results.DiagnosticSolution.Vx,\ - md.results.DiagnosticSolution.Vy,\ - md.results.DiagnosticSolution.Vz,\ - md.results.DiagnosticSolution.Vel,\ - md.results.DiagnosticSolution.Pressure,\ + md.results.StressbalanceSolution.Vx,\ + md.results.StressbalanceSolution.Vy,\ + md.results.StressbalanceSolution.Vz,\ + md.results.StressbalanceSolution.Vel,\ + md.results.StressbalanceSolution.Pressure,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test405.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test405.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test405.m (revision 15771) @@ -5,5 +5,5 @@ md=setflowequation(md,'SSA','../Exp/SquareHalfRight.exp','fill','HO','coupling','penalties'); md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %Fields and tolerances to track changes @@ -11,8 +11,8 @@ field_tolerances={5e-05,5e-05,5e-05,5e-05,1e-05}; field_values={... - (md.results.DiagnosticSolution.Vx),... - (md.results.DiagnosticSolution.Vy),... - (md.results.DiagnosticSolution.Vz),... - (md.results.DiagnosticSolution.Vel),... - (md.results.DiagnosticSolution.Pressure),... + (md.results.StressbalanceSolution.Vx),... + (md.results.StressbalanceSolution.Vy),... + (md.results.StressbalanceSolution.Vz),... + (md.results.StressbalanceSolution.Vel),... + (md.results.StressbalanceSolution.Pressure),... }; Index: /issm/trunk-jpl/test/NightlyRun/test405.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test405.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test405.py (revision 15771) @@ -15,5 +15,5 @@ md=setflowequation(md,'SSA','../Exp/SquareHalfRight.exp','fill','HO','coupling','penalties') md.cluster=generic('name',oshostname(),'np',3) -md=solve(md,DiagnosticSolutionEnum()) +md=solve(md,StressbalanceSolutionEnum()) #Fields and tolerances to track changes @@ -21,8 +21,8 @@ field_tolerances=[5e-05,5e-05,5e-05,5e-05,1e-05] field_values=[\ - md.results.DiagnosticSolution.Vx,\ - md.results.DiagnosticSolution.Vy,\ - md.results.DiagnosticSolution.Vz,\ - md.results.DiagnosticSolution.Vel,\ - md.results.DiagnosticSolution.Pressure,\ + md.results.StressbalanceSolution.Vx,\ + md.results.StressbalanceSolution.Vy,\ + md.results.StressbalanceSolution.Vz,\ + md.results.StressbalanceSolution.Vel,\ + md.results.StressbalanceSolution.Pressure,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test407.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test407.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test407.m (revision 15771) @@ -5,5 +5,5 @@ md=setflowequation(md,'HO','all'); md.cluster=generic('name',oshostname(),'np',3); -md.transient.isdiagnostic=0; +md.transient.isstressbalance=0; md.transient.ismasstransport=0; md.transient.isthermal=1; Index: /issm/trunk-jpl/test/NightlyRun/test407.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test407.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test407.py (revision 15771) @@ -15,5 +15,5 @@ md=setflowequation(md,'HO','all') md.cluster=generic('name',oshostname(),'np',3) -md.transient.isdiagnostic=False +md.transient.isstressbalance=False md.transient.ismasstransport=False md.transient.isthermal=True Index: /issm/trunk-jpl/test/NightlyRun/test412.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test412.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test412.m (revision 15771) @@ -25,13 +25,13 @@ %parameters md.qmu.params.direct=true; -md.qmu.params.analysis_driver='diagnostic'; +md.qmu.params.analysis_driver='stressbalance'; md.qmu.params.evaluation_concurrency=1; md.qmu.params.interval_type='forward'; %imperative! -md.diagnostic.reltol=10^-5; %tighten for qmu analysese +md.stressbalance.reltol=10^-5; %tighten for qmu analysese %solve -md=solve(md,DiagnosticSolutionEnum(),'overwrite','y'); +md=solve(md,StressbalanceSolutionEnum(),'overwrite','y'); %Fields and tolerances to track changes Index: /issm/trunk-jpl/test/NightlyRun/test413.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test413.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test413.m (revision 15771) @@ -24,5 +24,5 @@ %parameters md.qmu.params.direct=true; -md.qmu.params.analysis_driver='diagnostic'; +md.qmu.params.analysis_driver='stressbalance'; md.qmu.params.evaluation_concurrency=1; md.qmu.params.interval_type='forward'; @@ -30,9 +30,9 @@ %imperative! -md.diagnostic.reltol=10^-5; %tighten for qmu analyses +md.stressbalance.reltol=10^-5; %tighten for qmu analyses md.qmu.isdakota=1; %solve -md=solve(md,DiagnosticSolutionEnum(),'overwrite','y'); +md=solve(md,StressbalanceSolutionEnum(),'overwrite','y'); %Fields and tolerances to track changes Index: /issm/trunk-jpl/test/NightlyRun/test414.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test414.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test414.m (revision 15771) @@ -8,7 +8,7 @@ %constrain all velocities to 1 m/yr, in the y-direction -md.diagnostic.spcvx=zeros(md.mesh.numberofvertices,1); -md.diagnostic.spcvy=ones(md.mesh.numberofvertices,1); -md.diagnostic.spcvz=zeros(md.mesh.numberofvertices,1); +md.stressbalance.spcvx=zeros(md.mesh.numberofvertices,1); +md.stressbalance.spcvy=ones(md.mesh.numberofvertices,1); +md.stressbalance.spcvz=zeros(md.mesh.numberofvertices,1); %Dakota options @@ -41,12 +41,12 @@ %parameters md.qmu.params.direct=true; -md.qmu.params.analysis_driver='diagnostic'; +md.qmu.params.analysis_driver='stressbalance'; md.qmu.params.evaluation_concurrency=1; md.qmu.params.interval_type='forward'; md.qmu.isdakota=1; -md.diagnostic.reltol=10^-5; %tighten for qmu analyses +md.stressbalance.reltol=10^-5; %tighten for qmu analyses %solve -md=solve(md,DiagnosticSolutionEnum(),'overwrite','y'); +md=solve(md,StressbalanceSolutionEnum(),'overwrite','y'); md.qmu.results=md.results.dakota; Index: /issm/trunk-jpl/test/NightlyRun/test417.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test417.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test417.m (revision 15771) @@ -8,7 +8,7 @@ %constrain all velocities to 1 m/yr, in the y-direction -md.diagnostic.spcvx(:)=0; -md.diagnostic.spcvy(:)=1; -md.diagnostic.spcvz(:)=0; +md.stressbalance.spcvx(:)=0; +md.stressbalance.spcvy(:)=1; +md.stressbalance.spcvz(:)=0; %Dakota options @@ -48,7 +48,7 @@ md.qmu.isdakota=1; -md.diagnostic.reltol=10^-5; %tighten for qmu analyses +md.stressbalance.reltol=10^-5; %tighten for qmu analyses -md=solve(md,DiagnosticSolutionEnum(),'overwrite','y'); +md=solve(md,StressbalanceSolutionEnum(),'overwrite','y'); %Fields and tolerances to track changes Index: /issm/trunk-jpl/test/NightlyRun/test419.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test419.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test419.m (revision 15771) @@ -5,5 +5,5 @@ md=setflowequation(md,'SSA','../Exp/SquareHalfRight.exp','fill','HO'); md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %Fields and tolerances to track changes @@ -11,8 +11,8 @@ field_tolerances={1e-09,1e-09,1e-09,1e-09,1e-09}; field_values={... - (md.results.DiagnosticSolution.Vx),... - (md.results.DiagnosticSolution.Vy),... - (md.results.DiagnosticSolution.Vz),... - (md.results.DiagnosticSolution.Vel),... - (md.results.DiagnosticSolution.Pressure),... + (md.results.StressbalanceSolution.Vx),... + (md.results.StressbalanceSolution.Vy),... + (md.results.StressbalanceSolution.Vz),... + (md.results.StressbalanceSolution.Vel),... + (md.results.StressbalanceSolution.Pressure),... }; Index: /issm/trunk-jpl/test/NightlyRun/test419.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test419.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test419.py (revision 15771) @@ -15,5 +15,5 @@ md=setflowequation(md,'SSA','../Exp/SquareHalfRight.exp','fill','HO') md.cluster=generic('name',oshostname(),'np',3) -md=solve(md,DiagnosticSolutionEnum()) +md=solve(md,StressbalanceSolutionEnum()) #Fields and tolerances to track changes @@ -21,8 +21,8 @@ field_tolerances=[1e-09,1e-09,1e-09,1e-09,1e-09] field_values=[\ - md.results.DiagnosticSolution.Vx,\ - md.results.DiagnosticSolution.Vy,\ - md.results.DiagnosticSolution.Vz,\ - md.results.DiagnosticSolution.Vel,\ - md.results.DiagnosticSolution.Pressure,\ + md.results.StressbalanceSolution.Vx,\ + md.results.StressbalanceSolution.Vy,\ + md.results.StressbalanceSolution.Vz,\ + md.results.StressbalanceSolution.Vel,\ + md.results.StressbalanceSolution.Pressure,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test420.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test420.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test420.m (revision 15771) @@ -23,5 +23,5 @@ %parameters md.qmu.params.direct=true; -md.qmu.params.analysis_driver='diagnostic'; +md.qmu.params.analysis_driver='stressbalance'; md.qmu.params.evaluation_concurrency=1; md.qmu.params.interval_type='forward'; @@ -29,8 +29,8 @@ %imperative! -md.diagnostic.reltol=10^-5; %tighten for qmu analysese +md.stressbalance.reltol=10^-5; %tighten for qmu analysese %solve -md=solve(md,DiagnosticSolutionEnum(),'overwrite','y'); +md=solve(md,StressbalanceSolutionEnum(),'overwrite','y'); md.qmu.results=md.results.dakota; Index: /issm/trunk-jpl/test/NightlyRun/test421.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test421.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test421.m (revision 15771) @@ -5,5 +5,5 @@ md=setflowequation(md,'FS','../Exp/SquareHalfRight.exp','fill','HO'); md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %Fields and tolerances to track changes @@ -11,8 +11,8 @@ field_tolerances={1e-08,2e-09,2e-05,1e-09,2e-09}; field_values={... - (md.results.DiagnosticSolution.Vx),... - (md.results.DiagnosticSolution.Vy),... - (md.results.DiagnosticSolution.Vz),... - (md.results.DiagnosticSolution.Vel),... - (md.results.DiagnosticSolution.Pressure),... + (md.results.StressbalanceSolution.Vx),... + (md.results.StressbalanceSolution.Vy),... + (md.results.StressbalanceSolution.Vz),... + (md.results.StressbalanceSolution.Vel),... + (md.results.StressbalanceSolution.Pressure),... }; Index: /issm/trunk-jpl/test/NightlyRun/test421.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test421.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test421.py (revision 15771) @@ -15,5 +15,5 @@ md=setflowequation(md,'FS','../Exp/SquareHalfRight.exp','fill','HO') md.cluster=generic('name',oshostname(),'np',3) -md=solve(md,DiagnosticSolutionEnum()) +md=solve(md,StressbalanceSolutionEnum()) #Fields and tolerances to track changes @@ -21,8 +21,8 @@ field_tolerances=[1e-08,2e-09,2e-05,1e-09,2e-09] field_values=[\ - md.results.DiagnosticSolution.Vx,\ - md.results.DiagnosticSolution.Vy,\ - md.results.DiagnosticSolution.Vz,\ - md.results.DiagnosticSolution.Vel,\ - md.results.DiagnosticSolution.Pressure,\ + md.results.StressbalanceSolution.Vx,\ + md.results.StressbalanceSolution.Vy,\ + md.results.StressbalanceSolution.Vz,\ + md.results.StressbalanceSolution.Vel,\ + md.results.StressbalanceSolution.Pressure,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test422.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test422.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test422.m (revision 15771) @@ -5,6 +5,6 @@ md=setflowequation(md,'FS','../Exp/SquareHalfRight.exp','fill','SSA'); md.cluster=generic('name',oshostname(),'np',3); -md.diagnostic.reltol=0.4; -md=solve(md,DiagnosticSolutionEnum()); +md.stressbalance.reltol=0.4; +md=solve(md,StressbalanceSolutionEnum()); %Fields and tolerances to track changes @@ -12,8 +12,8 @@ field_tolerances={1e-09,1e-09,2e-06,1e-09,1e-09}; field_values={... - (md.results.DiagnosticSolution.Vx),... - (md.results.DiagnosticSolution.Vy),... - (md.results.DiagnosticSolution.Vz),... - (md.results.DiagnosticSolution.Vel),... - (md.results.DiagnosticSolution.Pressure),... + (md.results.StressbalanceSolution.Vx),... + (md.results.StressbalanceSolution.Vy),... + (md.results.StressbalanceSolution.Vz),... + (md.results.StressbalanceSolution.Vel),... + (md.results.StressbalanceSolution.Pressure),... }; Index: /issm/trunk-jpl/test/NightlyRun/test422.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test422.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test422.py (revision 15771) @@ -15,6 +15,6 @@ md=setflowequation(md,'FS','../Exp/SquareHalfRight.exp','fill','SSA') md.cluster=generic('name',oshostname(),'np',3) -md.diagnostic.reltol=0.4 -md=solve(md,DiagnosticSolutionEnum()) +md.stressbalance.reltol=0.4 +md=solve(md,StressbalanceSolutionEnum()) #Fields and tolerances to track changes @@ -22,8 +22,8 @@ field_tolerances=[1e-09,1e-09,1e-06,1e-09,1e-09] field_values=[\ - md.results.DiagnosticSolution.Vx,\ - md.results.DiagnosticSolution.Vy,\ - md.results.DiagnosticSolution.Vz,\ - md.results.DiagnosticSolution.Vel,\ - md.results.DiagnosticSolution.Pressure,\ + md.results.StressbalanceSolution.Vx,\ + md.results.StressbalanceSolution.Vy,\ + md.results.StressbalanceSolution.Vz,\ + md.results.StressbalanceSolution.Vel,\ + md.results.StressbalanceSolution.Pressure,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test423.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test423.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test423.m (revision 15771) @@ -20,5 +20,5 @@ md.transient.isthermal=0; md.transient.ismasstransport=0; -md.transient.isdiagnostic=1; +md.transient.isstressbalance=1; md.transient.isgroundingline=1; Index: /issm/trunk-jpl/test/NightlyRun/test423.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test423.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test423.py (revision 15771) @@ -31,5 +31,5 @@ md.transient.isthermal=False md.transient.ismasstransport=False -md.transient.isdiagnostic=True +md.transient.isstressbalance=True md.transient.isgroundingline=True Index: /issm/trunk-jpl/test/NightlyRun/test424.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test424.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test424.m (revision 15771) @@ -10,5 +10,5 @@ md.geometry.surface=md.geometry.bed+md.geometry.thickness; md.surfaceforcings.mass_balance(:)=100.; -md.transient.isdiagnostic=0; +md.transient.isstressbalance=0; md.transient.isgroundingline=1; md.groundingline.migration='AgressiveMigration'; Index: /issm/trunk-jpl/test/NightlyRun/test424.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test424.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test424.py (revision 15771) @@ -20,5 +20,5 @@ md.geometry.surface=md.geometry.bed+md.geometry.thickness md.surfaceforcings.mass_balance[:]=100. -md.transient.isdiagnostic=False +md.transient.isstressbalance=False md.transient.isgroundingline=True md.groundingline.migration='AgressiveMigration' Index: /issm/trunk-jpl/test/NightlyRun/test425.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test425.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test425.m (revision 15771) @@ -10,5 +10,5 @@ md.geometry.surface=md.geometry.bed+md.geometry.thickness; md.surfaceforcings.mass_balance(:)=-150.; -md.transient.isdiagnostic=0; +md.transient.isstressbalance=0; md.transient.isgroundingline=1; md.groundingline.migration='SoftMigration'; Index: /issm/trunk-jpl/test/NightlyRun/test425.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test425.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test425.py (revision 15771) @@ -20,5 +20,5 @@ md.geometry.surface=md.geometry.bed+md.geometry.thickness md.surfaceforcings.mass_balance[:]=-150. -md.transient.isdiagnostic=False +md.transient.isstressbalance=False md.transient.isgroundingline=True md.groundingline.migration='SoftMigration' Index: /issm/trunk-jpl/test/NightlyRun/test426.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test426.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test426.m (revision 15771) @@ -11,5 +11,5 @@ md=extrude(md,3,1.); md=setflowequation(md,'SSA','all'); -md.transient.isdiagnostic=0; +md.transient.isstressbalance=0; md.transient.isgroundingline=1; md.groundingline.migration='AgressiveMigration'; Index: /issm/trunk-jpl/test/NightlyRun/test426.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test426.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test426.py (revision 15771) @@ -21,5 +21,5 @@ md.extrude(3,1.); md=setflowequation(md,'SSA','all'); -md.transient.isdiagnostic=False +md.transient.isstressbalance=False md.transient.isgroundingline=True md.groundingline.migration='AgressiveMigration' Index: /issm/trunk-jpl/test/NightlyRun/test427.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test427.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test427.m (revision 15771) @@ -12,5 +12,5 @@ md.surfaceforcings.mass_balance(:)=-150; -md.transient.isdiagnostic=0; +md.transient.isstressbalance=0; md.transient.isgroundingline=1; md.groundingline.migration='SoftMigration'; Index: /issm/trunk-jpl/test/NightlyRun/test427.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test427.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test427.py (revision 15771) @@ -22,5 +22,5 @@ md.surfaceforcings.mass_balance[:]=-150 -md.transient.isdiagnostic=False +md.transient.isstressbalance=False md.transient.isgroundingline=True md.groundingline.migration='SoftMigration' Index: /issm/trunk-jpl/test/NightlyRun/test428.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test428.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test428.m (revision 15771) @@ -3,8 +3,8 @@ md=parameterize(md,'../Par/SquareSheetShelf.par'); md=setflowequation(md,'SSA','all'); -md.diagnostic.isnewton=1; -md.diagnostic.restol=0.0001; +md.stressbalance.isnewton=1; +md.stressbalance.restol=0.0001; md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %Fields and tolerances to track changes @@ -12,7 +12,7 @@ field_tolerances={1e-13,1e-13,1e-13,1e-13}; field_values={... - (md.results.DiagnosticSolution.Vx),... - (md.results.DiagnosticSolution.Vy),... - (md.results.DiagnosticSolution.Vel),... - (md.results.DiagnosticSolution.Pressure),... + (md.results.StressbalanceSolution.Vx),... + (md.results.StressbalanceSolution.Vy),... + (md.results.StressbalanceSolution.Vel),... + (md.results.StressbalanceSolution.Pressure),... }; Index: /issm/trunk-jpl/test/NightlyRun/test428.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test428.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test428.py (revision 15771) @@ -13,8 +13,8 @@ md=parameterize(md,'../Par/SquareSheetShelf.py') md=setflowequation(md,'SSA','all') -md.diagnostic.isnewton=1 -md.diagnostic.restol=0.0001 +md.stressbalance.isnewton=1 +md.stressbalance.restol=0.0001 md.cluster=generic('name',oshostname(),'np',3) -md=solve(md,DiagnosticSolutionEnum()) +md=solve(md,StressbalanceSolutionEnum()) #Fields and tolerances to track changes @@ -22,7 +22,7 @@ field_tolerances=[1e-13,1e-13,1e-13,1e-13] field_values=[\ - md.results.DiagnosticSolution.Vx,\ - md.results.DiagnosticSolution.Vy,\ - md.results.DiagnosticSolution.Vel,\ - md.results.DiagnosticSolution.Pressure,\ + md.results.StressbalanceSolution.Vx,\ + md.results.StressbalanceSolution.Vy,\ + md.results.StressbalanceSolution.Vel,\ + md.results.StressbalanceSolution.Pressure,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test429.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test429.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test429.m (revision 15771) @@ -4,8 +4,8 @@ md=extrude(md,5,1.); md=setflowequation(md,'HO','all'); -md.diagnostic.isnewton=1; -md.diagnostic.restol=0.0001; +md.stressbalance.isnewton=1; +md.stressbalance.restol=0.0001; md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %Fields and tolerances to track changes @@ -13,8 +13,8 @@ field_tolerances={2e-09,1e-09,1e-09,1e-09,1e-09}; field_values={... - (md.results.DiagnosticSolution.Vx),... - (md.results.DiagnosticSolution.Vy),... - (md.results.DiagnosticSolution.Vz),... - (md.results.DiagnosticSolution.Vel),... - (md.results.DiagnosticSolution.Pressure),... + (md.results.StressbalanceSolution.Vx),... + (md.results.StressbalanceSolution.Vy),... + (md.results.StressbalanceSolution.Vz),... + (md.results.StressbalanceSolution.Vel),... + (md.results.StressbalanceSolution.Pressure),... }; Index: /issm/trunk-jpl/test/NightlyRun/test429.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test429.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test429.py (revision 15771) @@ -14,8 +14,8 @@ md.extrude(5,1.) md=setflowequation(md,'HO','all') -md.diagnostic.isnewton=1 -md.diagnostic.restol=0.0001 +md.stressbalance.isnewton=1 +md.stressbalance.restol=0.0001 md.cluster=generic('name',oshostname(),'np',3) -md=solve(md,DiagnosticSolutionEnum()) +md=solve(md,StressbalanceSolutionEnum()) #Fields and tolerances to track changes @@ -23,8 +23,8 @@ field_tolerances=[2e-09,2e-09,1e-09,2e-09,1e-09] field_values=[\ - md.results.DiagnosticSolution.Vx,\ - md.results.DiagnosticSolution.Vy,\ - md.results.DiagnosticSolution.Vz,\ - md.results.DiagnosticSolution.Vel,\ - md.results.DiagnosticSolution.Pressure,\ + md.results.StressbalanceSolution.Vx,\ + md.results.StressbalanceSolution.Vy,\ + md.results.StressbalanceSolution.Vz,\ + md.results.StressbalanceSolution.Vel,\ + md.results.StressbalanceSolution.Pressure,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test430.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test430.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test430.m (revision 15771) @@ -4,8 +4,8 @@ md=extrude(md,3,1.); md=setflowequation(md,'FS','all'); -md.diagnostic.isnewton=1; -md.diagnostic.restol=0.0001; +md.stressbalance.isnewton=1; +md.stressbalance.restol=0.0001; md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %Fields and tolerances to track changes @@ -13,8 +13,8 @@ field_tolerances={1e-07,1e-07,1e-06,1e-07,1e-07}; field_values={... - (md.results.DiagnosticSolution.Vx),... - (md.results.DiagnosticSolution.Vy),... - (md.results.DiagnosticSolution.Vz),... - (md.results.DiagnosticSolution.Vel),... - (md.results.DiagnosticSolution.Pressure),... + (md.results.StressbalanceSolution.Vx),... + (md.results.StressbalanceSolution.Vy),... + (md.results.StressbalanceSolution.Vz),... + (md.results.StressbalanceSolution.Vel),... + (md.results.StressbalanceSolution.Pressure),... }; Index: /issm/trunk-jpl/test/NightlyRun/test430.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test430.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test430.py (revision 15771) @@ -14,8 +14,8 @@ md.extrude(3,1.) md=setflowequation(md,'FS','all') -md.diagnostic.isnewton=1 -md.diagnostic.restol=0.0001 +md.stressbalance.isnewton=1 +md.stressbalance.restol=0.0001 md.cluster=generic('name',oshostname(),'np',3) -md=solve(md,DiagnosticSolutionEnum()) +md=solve(md,StressbalanceSolutionEnum()) #Fields and tolerances to track changes @@ -23,8 +23,8 @@ field_tolerances=[1e-07,1e-07,1e-06,1e-07,1e-07] field_values=[\ - md.results.DiagnosticSolution.Vx,\ - md.results.DiagnosticSolution.Vy,\ - md.results.DiagnosticSolution.Vz,\ - md.results.DiagnosticSolution.Vel,\ - md.results.DiagnosticSolution.Pressure,\ + md.results.StressbalanceSolution.Vx,\ + md.results.StressbalanceSolution.Vy,\ + md.results.StressbalanceSolution.Vz,\ + md.results.StressbalanceSolution.Vel,\ + md.results.StressbalanceSolution.Pressure,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test433.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test433.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test433.m (revision 15771) @@ -21,5 +21,5 @@ md.transient.isthermal=0; md.transient.ismasstransport=0; -md.transient.isdiagnostic=0; +md.transient.isstressbalance=0; md.transient.isgroundingline=1; Index: /issm/trunk-jpl/test/NightlyRun/test433.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test433.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test433.py (revision 15771) @@ -32,5 +32,5 @@ md.transient.isthermal=False md.transient.ismasstransport=False -md.transient.isdiagnostic=False +md.transient.isstressbalance=False md.transient.isgroundingline=True Index: /issm/trunk-jpl/test/NightlyRun/test434.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test434.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test434.m (revision 15771) @@ -5,5 +5,5 @@ md=setflowequation(md,'L1L2','all'); md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %Fields and tolerances to track changes @@ -11,8 +11,8 @@ field_tolerances={1e-06,1e-06,2e-07,1e-06,1e-07}; field_values={... - (md.results.DiagnosticSolution.Vx),... - (md.results.DiagnosticSolution.Vy),... - (md.results.DiagnosticSolution.Vz),... - (md.results.DiagnosticSolution.Vel),... - (md.results.DiagnosticSolution.Pressure),... + (md.results.StressbalanceSolution.Vx),... + (md.results.StressbalanceSolution.Vy),... + (md.results.StressbalanceSolution.Vz),... + (md.results.StressbalanceSolution.Vel),... + (md.results.StressbalanceSolution.Pressure),... }; Index: /issm/trunk-jpl/test/NightlyRun/test434.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test434.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test434.py (revision 15771) @@ -15,5 +15,5 @@ md=setflowequation(md,'L1L2','all') md.cluster=generic('name',oshostname(),'np',3) -md=solve(md,DiagnosticSolutionEnum()) +md=solve(md,StressbalanceSolutionEnum()) #Fields and tolerances to track changes @@ -21,8 +21,8 @@ field_tolerances=[1e-06,1e-06,1e-06,1e-06,1e-07] field_values=[\ - md.results.DiagnosticSolution.Vx,\ - md.results.DiagnosticSolution.Vy,\ - md.results.DiagnosticSolution.Vz,\ - md.results.DiagnosticSolution.Vel,\ - md.results.DiagnosticSolution.Pressure,\ + md.results.StressbalanceSolution.Vx,\ + md.results.StressbalanceSolution.Vy,\ + md.results.StressbalanceSolution.Vz,\ + md.results.StressbalanceSolution.Vel,\ + md.results.StressbalanceSolution.Pressure,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test501.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test501.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test501.m (revision 15771) @@ -4,5 +4,5 @@ md=setflowequation(md,'SSA','all'); md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %Fields and tolerances to track changes @@ -10,7 +10,7 @@ field_tolerances={1e-13,1e-13,1e-13,1e-13}; field_values={... - (md.results.DiagnosticSolution.Vx),... - (md.results.DiagnosticSolution.Vy),... - (md.results.DiagnosticSolution.Vel),... - (md.results.DiagnosticSolution.Pressure),... + (md.results.StressbalanceSolution.Vx),... + (md.results.StressbalanceSolution.Vy),... + (md.results.StressbalanceSolution.Vel),... + (md.results.StressbalanceSolution.Pressure),... }; Index: /issm/trunk-jpl/test/NightlyRun/test501.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test501.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test501.py (revision 15771) @@ -13,5 +13,5 @@ md=setflowequation(md,'SSA','all') md.cluster=generic('name',oshostname(),'np',3) -md=solve(md,DiagnosticSolutionEnum()) +md=solve(md,StressbalanceSolutionEnum()) # Fields and tolerances to track changes @@ -19,7 +19,7 @@ field_tolerances=[1e-13,1e-13,1e-13,1e-13] field_values=[\ - md.results.DiagnosticSolution.Vx,\ - md.results.DiagnosticSolution.Vy,\ - md.results.DiagnosticSolution.Vel,\ - md.results.DiagnosticSolution.Pressure,\ + md.results.StressbalanceSolution.Vx,\ + md.results.StressbalanceSolution.Vy,\ + md.results.StressbalanceSolution.Vel,\ + md.results.StressbalanceSolution.Pressure,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test502.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test502.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test502.m (revision 15771) @@ -5,5 +5,5 @@ md=setflowequation(md,'HO','all'); md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %Fields and tolerances to track changes @@ -11,8 +11,8 @@ field_tolerances={1e-08,1e-08,1e-08,1e-08,1e-08}; field_values={... - (md.results.DiagnosticSolution.Vx),... - (md.results.DiagnosticSolution.Vy),... - (md.results.DiagnosticSolution.Vz),... - (md.results.DiagnosticSolution.Vel),... - (md.results.DiagnosticSolution.Pressure),... + (md.results.StressbalanceSolution.Vx),... + (md.results.StressbalanceSolution.Vy),... + (md.results.StressbalanceSolution.Vz),... + (md.results.StressbalanceSolution.Vel),... + (md.results.StressbalanceSolution.Pressure),... }; Index: /issm/trunk-jpl/test/NightlyRun/test502.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test502.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test502.py (revision 15771) @@ -14,5 +14,5 @@ md=setflowequation(md,'HO','all') md.cluster=generic('name',oshostname(),'np',3) -md=solve(md,DiagnosticSolutionEnum()) +md=solve(md,StressbalanceSolutionEnum()) # Fields and tolerances to track changes @@ -20,8 +20,8 @@ field_tolerances=[1e-08,1e-08,1e-08,1e-08,1e-08] field_values=[\ - md.results.DiagnosticSolution.Vx,\ - md.results.DiagnosticSolution.Vy,\ - md.results.DiagnosticSolution.Vz,\ - md.results.DiagnosticSolution.Vel,\ - md.results.DiagnosticSolution.Pressure,\ + md.results.StressbalanceSolution.Vx,\ + md.results.StressbalanceSolution.Vy,\ + md.results.StressbalanceSolution.Vz,\ + md.results.StressbalanceSolution.Vel,\ + md.results.StressbalanceSolution.Pressure,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test503.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test503.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test503.m (revision 15771) @@ -5,5 +5,5 @@ md=setflowequation(md,'FS','all'); md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %Fields and tolerances to track changes @@ -11,8 +11,8 @@ field_tolerances={1e-09,1e-09,1e-09,1e-09,1e-09}; field_values={... - (md.results.DiagnosticSolution.Vx),... - (md.results.DiagnosticSolution.Vy),... - (md.results.DiagnosticSolution.Vz),... - (md.results.DiagnosticSolution.Vel),... - (md.results.DiagnosticSolution.Pressure),... + (md.results.StressbalanceSolution.Vx),... + (md.results.StressbalanceSolution.Vy),... + (md.results.StressbalanceSolution.Vz),... + (md.results.StressbalanceSolution.Vel),... + (md.results.StressbalanceSolution.Pressure),... }; Index: /issm/trunk-jpl/test/NightlyRun/test503.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test503.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test503.py (revision 15771) @@ -14,5 +14,5 @@ md=setflowequation(md,'FS','all') md.cluster=generic('name',oshostname(),'np',3) -md=solve(md,DiagnosticSolutionEnum()) +md=solve(md,StressbalanceSolutionEnum()) # Fields and tolerances to track changes @@ -20,8 +20,8 @@ field_tolerances=[1e-09,1e-09,1e-09,1e-09,1e-09] field_values=[\ - md.results.DiagnosticSolution.Vx,\ - md.results.DiagnosticSolution.Vy,\ - md.results.DiagnosticSolution.Vz,\ - md.results.DiagnosticSolution.Vel,\ - md.results.DiagnosticSolution.Pressure,\ + md.results.StressbalanceSolution.Vx,\ + md.results.StressbalanceSolution.Vy,\ + md.results.StressbalanceSolution.Vz,\ + md.results.StressbalanceSolution.Vel,\ + md.results.StressbalanceSolution.Pressure,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test511.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test511.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test511.m (revision 15771) @@ -24,5 +24,5 @@ md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %Fields and tolerances to track changes @@ -30,10 +30,10 @@ field_tolerances={1e-11,1e-12,1e-12,1e-09,1e-12,1e-12,1e-12,1e-12,1e-12,1e-12}; field_values={... - (md.results.DiagnosticSolution.Gradient1),... - (md.results.DiagnosticSolution.J),... - (md.results.DiagnosticSolution.MaterialsRheologyB),... - (md.results.DiagnosticSolution.Pressure),... - (md.results.DiagnosticSolution.Vel),... - (md.results.DiagnosticSolution.Vx),... - (md.results.DiagnosticSolution.Vy) + (md.results.StressbalanceSolution.Gradient1),... + (md.results.StressbalanceSolution.J),... + (md.results.StressbalanceSolution.MaterialsRheologyB),... + (md.results.StressbalanceSolution.Pressure),... + (md.results.StressbalanceSolution.Vel),... + (md.results.StressbalanceSolution.Vx),... + (md.results.StressbalanceSolution.Vy) }; Index: /issm/trunk-jpl/test/NightlyRun/test511.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test511.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test511.py (revision 15771) @@ -35,5 +35,5 @@ md.cluster=generic('name',oshostname(),'np',3) -md=solve(md,DiagnosticSolutionEnum()) +md=solve(md,StressbalanceSolutionEnum()) #Fields and tolerances to track changes @@ -41,10 +41,10 @@ field_tolerances=[1e-11,1e-12,1e-12,1e-09,1e-12,1e-12,1e-12,1e-12,1e-12,1e-12] field_values=[\ - md.results.DiagnosticSolution.Gradient1,\ - md.results.DiagnosticSolution.J,\ - md.results.DiagnosticSolution.MaterialsRheologyB,\ - md.results.DiagnosticSolution.Pressure,\ - md.results.DiagnosticSolution.Vel,\ - md.results.DiagnosticSolution.Vx,\ - md.results.DiagnosticSolution.Vy,\ + md.results.StressbalanceSolution.Gradient1,\ + md.results.StressbalanceSolution.J,\ + md.results.StressbalanceSolution.MaterialsRheologyB,\ + md.results.StressbalanceSolution.Pressure,\ + md.results.StressbalanceSolution.Vel,\ + md.results.StressbalanceSolution.Vx,\ + md.results.StressbalanceSolution.Vy,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test512.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test512.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test512.m (revision 15771) @@ -19,5 +19,5 @@ md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,DiagnosticSolutionEnum()); +md=solve(md,StressbalanceSolutionEnum()); %Fields and tolerances to track changes @@ -25,10 +25,10 @@ field_tolerances={1e-11,1e-11,1e-11,1e-11,1e-11,1e-11,1e-11,1e-11,1e-11,1e-11}; field_values={... - (md.results.DiagnosticSolution.Gradient1),... - md.results.DiagnosticSolution.J,... - (md.results.DiagnosticSolution.FrictionCoefficient),... - (md.results.DiagnosticSolution.Pressure),... - (md.results.DiagnosticSolution.Vel),... - (md.results.DiagnosticSolution.Vx),... - (md.results.DiagnosticSolution.Vy) + (md.results.StressbalanceSolution.Gradient1),... + md.results.StressbalanceSolution.J,... + (md.results.StressbalanceSolution.FrictionCoefficient),... + (md.results.StressbalanceSolution.Pressure),... + (md.results.StressbalanceSolution.Vel),... + (md.results.StressbalanceSolution.Vx),... + (md.results.StressbalanceSolution.Vy) }; Index: /issm/trunk-jpl/test/NightlyRun/test512.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test512.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test512.py (revision 15771) @@ -31,5 +31,5 @@ md.cluster=generic('name',oshostname(),'np',3) -md=solve(md,DiagnosticSolutionEnum()) +md=solve(md,StressbalanceSolutionEnum()) # Fields and tolerances to track changes @@ -37,10 +37,10 @@ field_tolerances=[1e-11,1e-11,1e-11,1e-11,1e-11,1e-11,1e-11,1e-11,1e-11,1e-11] field_values=[\ - md.results.DiagnosticSolution.Gradient1,\ - md.results.DiagnosticSolution.J,\ - md.results.DiagnosticSolution.FrictionCoefficient,\ - md.results.DiagnosticSolution.Pressure,\ - md.results.DiagnosticSolution.Vel,\ - md.results.DiagnosticSolution.Vx,\ - md.results.DiagnosticSolution.Vy + md.results.StressbalanceSolution.Gradient1,\ + md.results.StressbalanceSolution.J,\ + md.results.StressbalanceSolution.FrictionCoefficient,\ + md.results.StressbalanceSolution.Pressure,\ + md.results.StressbalanceSolution.Vel,\ + md.results.StressbalanceSolution.Vx,\ + md.results.StressbalanceSolution.Vy ] Index: /issm/trunk-jpl/test/NightlyRun/test515.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test515.m (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test515.m (revision 15771) @@ -6,5 +6,5 @@ md.thermal.stabilization=2; md.cluster=generic('name',oshostname(),'np',3); -md.transient.isdiagnostic=0; +md.transient.isstressbalance=0; md.transient.ismasstransport=0; md.transient.isthermal=1; Index: /issm/trunk-jpl/test/NightlyRun/test515.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test515.py (revision 15770) +++ /issm/trunk-jpl/test/NightlyRun/test515.py (revision 15771) @@ -15,5 +15,5 @@ md.thermal.stabilization=2 md.cluster=generic('name',oshostname(),'np',3) -md.transient.isdiagnostic=False +md.transient.isstressbalance=False md.transient.ismasstransport=False md.transient.isthermal=True Index: /issm/trunk-jpl/test/Par/79North.par =================================================================== --- /issm/trunk-jpl/test/Par/79North.par (revision 15770) +++ /issm/trunk-jpl/test/Par/79North.par (revision 15771) @@ -35,5 +35,5 @@ %Numerical parameters -md.diagnostic.viscosity_overshoot=0.3; +md.stressbalance.viscosity_overshoot=0.3; md.masstransport.stabilization=1; md.thermal.stabilization=1; @@ -42,8 +42,8 @@ md.timestepping.time_step=1.; md.timestepping.final_time=3.; -md.diagnostic.restol=0.05; -md.diagnostic.reltol=0.005; +md.stressbalance.restol=0.05; +md.stressbalance.reltol=0.005; md.steadystate.reltol=0.005; -md.diagnostic.abstol=NaN; +md.stressbalance.abstol=NaN; %Boundary conditions: Index: /issm/trunk-jpl/test/Par/79North.py =================================================================== --- /issm/trunk-jpl/test/Par/79North.py (revision 15770) +++ /issm/trunk-jpl/test/Par/79North.py (revision 15771) @@ -47,5 +47,5 @@ #Numerical parameters -md.diagnostic.viscosity_overshoot=0.3 +md.stressbalance.viscosity_overshoot=0.3 md.masstransport.stabilization=1 md.thermal.stabilization=1 @@ -54,8 +54,8 @@ md.timestepping.time_step=1. md.timestepping.final_time=3. -md.diagnostic.restol=0.05 -md.diagnostic.reltol=0.005 +md.stressbalance.restol=0.05 +md.stressbalance.reltol=0.005 md.steadystate.reltol=0.005 -md.diagnostic.abstol=float('NaN') +md.stressbalance.abstol=float('NaN') #Boundary conditions: Index: /issm/trunk-jpl/test/Par/GiaBenchmarksAB.par =================================================================== --- /issm/trunk-jpl/test/Par/GiaBenchmarksAB.par (revision 15770) +++ /issm/trunk-jpl/test/Par/GiaBenchmarksAB.par (revision 15771) @@ -52,13 +52,13 @@ %Numerical parameters -md.diagnostic.viscosity_overshoot=0.0; +md.stressbalance.viscosity_overshoot=0.0; md.masstransport.stabilization=1.; md.thermal.stabilization=1.; md.verbose=verbose(0); md.settings.waitonlock=30; -md.diagnostic.restol=0.05; +md.stressbalance.restol=0.05; md.steadystate.reltol=0.05; -md.diagnostic.reltol=0.05; -md.diagnostic.abstol=NaN; +md.stressbalance.reltol=0.05; +md.stressbalance.abstol=NaN; md.timestepping.time_step=1.; md.timestepping.final_time=3.; Index: /issm/trunk-jpl/test/Par/GiaBenchmarksCD.par =================================================================== --- /issm/trunk-jpl/test/Par/GiaBenchmarksCD.par (revision 15770) +++ /issm/trunk-jpl/test/Par/GiaBenchmarksCD.par (revision 15771) @@ -51,13 +51,13 @@ %Numerical parameters -md.diagnostic.viscosity_overshoot=0.0; +md.stressbalance.viscosity_overshoot=0.0; md.masstransport.stabilization=1.; md.thermal.stabilization=1.; md.verbose=verbose(0); md.settings.waitonlock=30; -md.diagnostic.restol=0.05; +md.stressbalance.restol=0.05; md.steadystate.reltol=0.05; -md.diagnostic.reltol=0.05; -md.diagnostic.abstol=NaN; +md.stressbalance.reltol=0.05; +md.stressbalance.abstol=NaN; md.timestepping.time_step=1.; md.timestepping.final_time=3.; Index: /issm/trunk-jpl/test/Par/ISMIPA.par =================================================================== --- /issm/trunk-jpl/test/Par/ISMIPA.par (revision 15770) +++ /issm/trunk-jpl/test/Par/ISMIPA.par (revision 15771) @@ -18,5 +18,5 @@ md.materials.rheology_n=3.*ones(md.mesh.numberofelements,1); -disp(' boundary conditions for diagnostic model'); +disp(' boundary conditions for stressbalance model'); %Create node on boundary first (because we cannot use mesh) md=SetIceSheetBC(md); Index: /issm/trunk-jpl/test/Par/ISMIPA.py =================================================================== --- /issm/trunk-jpl/test/Par/ISMIPA.py (revision 15770) +++ /issm/trunk-jpl/test/Par/ISMIPA.py (revision 15771) @@ -21,5 +21,5 @@ md.materials.rheology_n=3.*numpy.ones((md.mesh.numberofelements,1)) -print " boundary conditions for diagnostic model" +print " boundary conditions for stressbalance model" #Create node on boundary first (because we cannot use mesh) md=SetIceSheetBC(md) Index: /issm/trunk-jpl/test/Par/ISMIPB.par =================================================================== --- /issm/trunk-jpl/test/Par/ISMIPB.par (revision 15770) +++ /issm/trunk-jpl/test/Par/ISMIPB.par (revision 15771) @@ -18,5 +18,5 @@ md.materials.rheology_n=3.*ones(md.mesh.numberofelements,1); -disp(' boundary conditions for diagnostic model'); +disp(' boundary conditions for stressbalance model'); %Create node on boundary first (because we cannot use mesh) md=SetIceSheetBC(md); Index: /issm/trunk-jpl/test/Par/ISMIPB.py =================================================================== --- /issm/trunk-jpl/test/Par/ISMIPB.py (revision 15770) +++ /issm/trunk-jpl/test/Par/ISMIPB.py (revision 15771) @@ -21,5 +21,5 @@ md.materials.rheology_n=3.*numpy.ones((md.mesh.numberofelements,1)) -print " boundary conditions for diagnostic model" +print " boundary conditions for stressbalance model" #Create node on boundary first (because we cannot use mesh) md=SetIceSheetBC(md) Index: /issm/trunk-jpl/test/Par/ISMIPC.par =================================================================== --- /issm/trunk-jpl/test/Par/ISMIPC.par (revision 15770) +++ /issm/trunk-jpl/test/Par/ISMIPC.par (revision 15771) @@ -19,5 +19,5 @@ md.materials.rheology_n=3.*ones(md.mesh.numberofelements,1); -disp(' boundary conditions for diagnostic model:'); +disp(' boundary conditions for stressbalance model:'); %Create node on boundary first (because we can not use mesh) md=SetIceSheetBC(md); Index: /issm/trunk-jpl/test/Par/ISMIPC.py =================================================================== --- /issm/trunk-jpl/test/Par/ISMIPC.py (revision 15770) +++ /issm/trunk-jpl/test/Par/ISMIPC.py (revision 15771) @@ -22,5 +22,5 @@ md.materials.rheology_n=3.*numpy.ones((md.mesh.numberofelements,1)) -print " boundary conditions for diagnostic model:" +print " boundary conditions for stressbalance model:" #Create node on boundary first (because we can not use mesh) md=SetIceSheetBC(md) Index: /issm/trunk-jpl/test/Par/ISMIPD.par =================================================================== --- /issm/trunk-jpl/test/Par/ISMIPD.par (revision 15770) +++ /issm/trunk-jpl/test/Par/ISMIPD.par (revision 15771) @@ -18,5 +18,5 @@ md.materials.rheology_n=3.*ones(md.mesh.numberofelements,1); -disp(' boundary conditions for diagnostic model:'); +disp(' boundary conditions for stressbalance model:'); %Create node on boundary first (because we can not use mesh) md=SetIceSheetBC(md); Index: /issm/trunk-jpl/test/Par/ISMIPD.py =================================================================== --- /issm/trunk-jpl/test/Par/ISMIPD.py (revision 15770) +++ /issm/trunk-jpl/test/Par/ISMIPD.py (revision 15771) @@ -21,5 +21,5 @@ md.materials.rheology_n=3.*numpy.ones((md.mesh.numberofelements,1)) -print " boundary conditions for diagnostic model:" +print " boundary conditions for stressbalance model:" #Create node on boundary first (because we can not use mesh) md=SetIceSheetBC(md) Index: /issm/trunk-jpl/test/Par/ISMIPE.par =================================================================== --- /issm/trunk-jpl/test/Par/ISMIPE.par (revision 15770) +++ /issm/trunk-jpl/test/Par/ISMIPE.par (revision 15771) @@ -26,5 +26,5 @@ md.materials.rheology_n=3.*ones(md.mesh.numberofelements,1); -disp(' boundary conditions for diagnostic model:'); +disp(' boundary conditions for stressbalance model:'); %Create node on boundary first (because we can not use mesh) md=SetIceSheetBC(md); Index: /issm/trunk-jpl/test/Par/ISMIPE.py =================================================================== --- /issm/trunk-jpl/test/Par/ISMIPE.py (revision 15770) +++ /issm/trunk-jpl/test/Par/ISMIPE.py (revision 15771) @@ -31,5 +31,5 @@ md.materials.rheology_n=3.*numpy.ones((md.mesh.numberofelements,1)) -print " boundary conditions for diagnostic model:" +print " boundary conditions for stressbalance model:" #Create node on boundary first (because we can not use mesh) md=SetIceSheetBC(md) Index: /issm/trunk-jpl/test/Par/ISMIPF.par =================================================================== --- /issm/trunk-jpl/test/Par/ISMIPF.par (revision 15770) +++ /issm/trunk-jpl/test/Par/ISMIPF.par (revision 15771) @@ -18,8 +18,8 @@ md.materials.rheology_law='None'; -disp(' boundary conditions for diagnostic model'); +disp(' boundary conditions for stressbalance model'); %Create node on boundary first (because we cannot use mesh) md=SetIceSheetBC(md); -md.diagnostic.spcvx=100.*ones(md.mesh.numberofvertices,1); +md.stressbalance.spcvx=100.*ones(md.mesh.numberofvertices,1); md.initialization.vx=zeros(md.mesh.numberofvertices,1); md.initialization.vy=zeros(md.mesh.numberofvertices,1); Index: /issm/trunk-jpl/test/Par/ISMIPF.py =================================================================== --- /issm/trunk-jpl/test/Par/ISMIPF.py (revision 15770) +++ /issm/trunk-jpl/test/Par/ISMIPF.py (revision 15771) @@ -21,8 +21,8 @@ md.materials.rheology_law='None' -print " boundary conditions for diagnostic model" +print " boundary conditions for stressbalance model" #Create node on boundary first (because we cannot use mesh) md=SetIceSheetBC(md) -md.diagnostic.spcvx=100.*numpy.ones((md.mesh.numberofvertices,1)) +md.stressbalance.spcvx=100.*numpy.ones((md.mesh.numberofvertices,1)) md.initialization.vx=numpy.zeros((md.mesh.numberofvertices,1)) md.initialization.vy=numpy.zeros((md.mesh.numberofvertices,1)) Index: /issm/trunk-jpl/test/Par/Pig.par =================================================================== --- /issm/trunk-jpl/test/Par/Pig.par (revision 15770) +++ /issm/trunk-jpl/test/Par/Pig.par (revision 15771) @@ -34,5 +34,5 @@ %Numerical parameters -md.diagnostic.viscosity_overshoot=0.3; +md.stressbalance.viscosity_overshoot=0.3; md.masstransport.stabilization=1; md.verbose=verbose(0); @@ -40,8 +40,8 @@ md.timestepping.time_step=1; md.timestepping.final_time=2; -md.diagnostic.restol=0.05; -md.diagnostic.reltol=1; +md.stressbalance.restol=0.05; +md.stressbalance.reltol=1; md.steadystate.reltol=1; -md.diagnostic.abstol=NaN; +md.stressbalance.abstol=NaN; %Boundary conditions: Index: /issm/trunk-jpl/test/Par/Pig.py =================================================================== --- /issm/trunk-jpl/test/Par/Pig.py (revision 15770) +++ /issm/trunk-jpl/test/Par/Pig.py (revision 15771) @@ -45,5 +45,5 @@ #Numerical parameters -md.diagnostic.viscosity_overshoot=0.3 +md.stressbalance.viscosity_overshoot=0.3 md.masstransport.stabilization=1. md.verbose=verbose(0) @@ -51,8 +51,8 @@ md.timestepping.time_step=1. md.timestepping.final_time=2. -md.diagnostic.restol=0.05 -md.diagnostic.reltol=1. +md.stressbalance.restol=0.05 +md.stressbalance.reltol=1. md.steadystate.reltol=1. -md.diagnostic.abstol=float('nan') +md.stressbalance.abstol=float('nan') #Boundary conditions: Index: /issm/trunk-jpl/test/Par/RoundSheetEISMINT.par =================================================================== --- /issm/trunk-jpl/test/Par/RoundSheetEISMINT.par (revision 15770) +++ /issm/trunk-jpl/test/Par/RoundSheetEISMINT.par (revision 15771) @@ -38,5 +38,5 @@ %Deal with boundary conditions: -disp(' boundary conditions for diagnostic model:'); +disp(' boundary conditions for stressbalance model:'); md=SetMarineIceSheetBC(md,'../Exp/RoundFrontEISMINT.exp'); @@ -45,7 +45,7 @@ md.mesh.x(pos)=0.; md.mesh.y(pos)=0.; %the closest node to the center is changed to be exactly at the center -md.diagnostic.spcvx(pos)=0.; -md.diagnostic.spcvy(pos)=0.; -md.diagnostic.spcvz(pos)=0.; +md.stressbalance.spcvx(pos)=0.; +md.stressbalance.spcvy(pos)=0.; +md.stressbalance.spcvz(pos)=0.; %parallel options Index: /issm/trunk-jpl/test/Par/RoundSheetEISMINT.py =================================================================== --- /issm/trunk-jpl/test/Par/RoundSheetEISMINT.py (revision 15770) +++ /issm/trunk-jpl/test/Par/RoundSheetEISMINT.py (revision 15771) @@ -41,5 +41,5 @@ #Deal with boundary conditions: -print " boundary conditions for diagnostic model:" +print " boundary conditions for stressbalance model:" md=SetMarineIceSheetBC(md,'../Exp/RoundFrontEISMINT.exp') @@ -49,7 +49,7 @@ md.mesh.y[pos]=0. #the closest node to the center is changed to be exactly at the center -md.diagnostic.spcvx[pos]=0. -md.diagnostic.spcvy[pos]=0. -md.diagnostic.spcvz[pos]=0. +md.stressbalance.spcvx[pos]=0. +md.stressbalance.spcvy[pos]=0. +md.stressbalance.spcvz[pos]=0. #parallel options Index: /issm/trunk-jpl/test/Par/RoundSheetShelf.par =================================================================== --- /issm/trunk-jpl/test/Par/RoundSheetShelf.par (revision 15770) +++ /issm/trunk-jpl/test/Par/RoundSheetShelf.par (revision 15771) @@ -75,13 +75,13 @@ %Numerical parameters -md.diagnostic.viscosity_overshoot=0.0; +md.stressbalance.viscosity_overshoot=0.0; md.masstransport.stabilization=1; md.thermal.stabilization=1; md.verbose=verbose(0); md.settings.waitonlock=30; -md.diagnostic.restol=0.05; -md.diagnostic.reltol=0.05; +md.stressbalance.restol=0.05; +md.stressbalance.reltol=0.05; md.steadystate.reltol=0.05; -md.diagnostic.abstol=NaN; +md.stressbalance.abstol=NaN; md.timestepping.time_step=5.; md.timestepping.final_time=5.; @@ -93,17 +93,17 @@ %Deal with boundary conditions: -md.diagnostic.spcvx=NaN*ones(md.mesh.numberofvertices,1); -md.diagnostic.spcvy=NaN*ones(md.mesh.numberofvertices,1); -md.diagnostic.spcvz=NaN*ones(md.mesh.numberofvertices,1); +md.stressbalance.spcvx=NaN*ones(md.mesh.numberofvertices,1); +md.stressbalance.spcvy=NaN*ones(md.mesh.numberofvertices,1); +md.stressbalance.spcvz=NaN*ones(md.mesh.numberofvertices,1); pos=find(md.mesh.x==0 & md.mesh.y==0); -md.diagnostic.spcvx(pos)=0; -md.diagnostic.spcvy(pos)=0; +md.stressbalance.spcvx(pos)=0; +md.stressbalance.spcvy(pos)=0; md.mask.icelevelset(find(md.mesh.vertexonboundary))=0; md.balancethickness.spcthickness=NaN*ones(md.mesh.numberofvertices,1); md.masstransport.spcthickness=NaN*ones(md.mesh.numberofvertices,1); -md.diagnostic.referential=NaN*ones(md.mesh.numberofvertices,6); -md.diagnostic.loadingforce=0*ones(md.mesh.numberofvertices,3); +md.stressbalance.referential=NaN*ones(md.mesh.numberofvertices,6); +md.stressbalance.loadingforce=0*ones(md.mesh.numberofvertices,3); md.thermal.spctemperature=737.*ones(md.mesh.numberofvertices,1); Index: /issm/trunk-jpl/test/Par/RoundSheetShelf.py =================================================================== --- /issm/trunk-jpl/test/Par/RoundSheetShelf.py (revision 15770) +++ /issm/trunk-jpl/test/Par/RoundSheetShelf.py (revision 15771) @@ -83,13 +83,13 @@ #Numerical parameters -md.diagnostic.viscosity_overshoot=0.0 +md.stressbalance.viscosity_overshoot=0.0 md.masstransport.stabilization=1 md.thermal.stabilization=1 md.verbose=verbose(0) md.settings.waitonlock=30 -md.diagnostic.restol=0.05 -md.diagnostic.reltol=0.05 +md.stressbalance.restol=0.05 +md.stressbalance.reltol=0.05 md.steadystate.reltol=0.05 -md.diagnostic.abstol=float('nan') +md.stressbalance.abstol=float('nan') md.timestepping.time_step=5. md.timestepping.final_time=5. @@ -102,11 +102,11 @@ #Deal with boundary conditions: -md.diagnostic.spcvx=float('nan')*numpy.ones((md.mesh.numberofvertices,1)) -md.diagnostic.spcvy=float('nan')*numpy.ones((md.mesh.numberofvertices,1)) -md.diagnostic.spcvz=float('nan')*numpy.ones((md.mesh.numberofvertices,1)) +md.stressbalance.spcvx=float('nan')*numpy.ones((md.mesh.numberofvertices,1)) +md.stressbalance.spcvy=float('nan')*numpy.ones((md.mesh.numberofvertices,1)) +md.stressbalance.spcvz=float('nan')*numpy.ones((md.mesh.numberofvertices,1)) pos=numpy.nonzero(numpy.logical_and(md.mesh.x==0,md.mesh.y==0)) -md.diagnostic.spcvx[pos]=0 -md.diagnostic.spcvy[pos]=0 +md.stressbalance.spcvx[pos]=0 +md.stressbalance.spcvy[pos]=0 pos=numpy.nonzero(md.mesh.vertexonboundary) @@ -114,6 +114,6 @@ md.balancethickness.spcthickness=float('nan')*numpy.ones((md.mesh.numberofvertices,1)) md.masstransport.spcthickness=float('nan')*numpy.ones((md.mesh.numberofvertices,1)) -md.diagnostic.referential=float('nan')*numpy.ones((md.mesh.numberofvertices,6)) -md.diagnostic.loadingforce=0*numpy.ones((md.mesh.numberofvertices,3)) +md.stressbalance.referential=float('nan')*numpy.ones((md.mesh.numberofvertices,6)) +md.stressbalance.loadingforce=0*numpy.ones((md.mesh.numberofvertices,3)) md.thermal.spctemperature=737.*numpy.ones((md.mesh.numberofvertices,1)) Index: /issm/trunk-jpl/test/Par/RoundSheetStaticEISMINT.par =================================================================== --- /issm/trunk-jpl/test/Par/RoundSheetStaticEISMINT.par (revision 15770) +++ /issm/trunk-jpl/test/Par/RoundSheetStaticEISMINT.par (revision 15771) @@ -44,5 +44,5 @@ %Deal with boundary conditions: -disp(' boundary conditions for diagnostic model:'); +disp(' boundary conditions for stressbalance model:'); md=SetMarineIceSheetBC(md,'../Exp/RoundFrontEISMINT.exp'); @@ -51,5 +51,5 @@ md.mesh.x(pos)=0.; md.mesh.y(pos)=0.; %the closest node to the center is changed to be exactly at the center -md.diagnostic.spcvx(pos)=0.; -md.diagnostic.spcvy(pos)=0.; -md.diagnostic.spcvz(pos)=0.; +md.stressbalance.spcvx(pos)=0.; +md.stressbalance.spcvy(pos)=0.; +md.stressbalance.spcvz(pos)=0.; Index: /issm/trunk-jpl/test/Par/RoundSheetStaticEISMINT.py =================================================================== --- /issm/trunk-jpl/test/Par/RoundSheetStaticEISMINT.py (revision 15770) +++ /issm/trunk-jpl/test/Par/RoundSheetStaticEISMINT.py (revision 15771) @@ -47,5 +47,5 @@ #Deal with boundary conditions: -print " boundary conditions for diagnostic model:" +print " boundary conditions for stressbalance model:" md=SetMarineIceSheetBC(md,'../Exp/RoundFrontEISMINT.exp') @@ -55,5 +55,5 @@ md.mesh.y[pos]=0. #the closest node to the center is changed to be exactly at the center -md.diagnostic.spcvx[pos]=0. -md.diagnostic.spcvy[pos]=0. -md.diagnostic.spcvz[pos]=0. +md.stressbalance.spcvx[pos]=0. +md.stressbalance.spcvy[pos]=0. +md.stressbalance.spcvz[pos]=0. Index: /issm/trunk-jpl/test/Par/SquareSheetConstrained.par =================================================================== --- /issm/trunk-jpl/test/Par/SquareSheetConstrained.par (revision 15770) +++ /issm/trunk-jpl/test/Par/SquareSheetConstrained.par (revision 15771) @@ -37,13 +37,13 @@ %Numerical parameters -md.diagnostic.viscosity_overshoot=0.0; +md.stressbalance.viscosity_overshoot=0.0; md.masstransport.stabilization=1.; md.thermal.stabilization=1.; md.verbose=verbose(0); md.settings.waitonlock=30; -md.diagnostic.restol=0.05; +md.stressbalance.restol=0.05; md.steadystate.reltol=0.05; -md.diagnostic.reltol=0.05; -md.diagnostic.abstol=NaN; +md.stressbalance.reltol=0.05; +md.stressbalance.abstol=NaN; md.timestepping.time_step=1.; md.timestepping.final_time=3.; Index: /issm/trunk-jpl/test/Par/SquareSheetConstrained.py =================================================================== --- /issm/trunk-jpl/test/Par/SquareSheetConstrained.py (revision 15770) +++ /issm/trunk-jpl/test/Par/SquareSheetConstrained.py (revision 15771) @@ -47,13 +47,13 @@ #Numerical parameters -md.diagnostic.viscosity_overshoot=0.0 +md.stressbalance.viscosity_overshoot=0.0 md.masstransport.stabilization=1. md.thermal.stabilization=1. md.verbose=verbose(0) md.settings.waitonlock=30 -md.diagnostic.restol=0.05 +md.stressbalance.restol=0.05 md.steadystate.reltol=0.05 -md.diagnostic.reltol=0.05 -md.diagnostic.abstol=float('NaN') +md.stressbalance.reltol=0.05 +md.stressbalance.abstol=float('NaN') md.timestepping.time_step=1. md.timestepping.final_time=3. Index: /issm/trunk-jpl/test/Par/SquareSheetShelf.par =================================================================== --- /issm/trunk-jpl/test/Par/SquareSheetShelf.par (revision 15770) +++ /issm/trunk-jpl/test/Par/SquareSheetShelf.par (revision 15771) @@ -42,13 +42,13 @@ %Numerical parameters -md.diagnostic.viscosity_overshoot=0.0; +md.stressbalance.viscosity_overshoot=0.0; md.masstransport.stabilization=1; md.thermal.stabilization=1; md.verbose=verbose(0); md.settings.waitonlock=30; -md.diagnostic.restol=0.05; +md.stressbalance.restol=0.05; md.steadystate.reltol=0.05; -md.diagnostic.reltol=0.05; -md.diagnostic.abstol=NaN; +md.stressbalance.reltol=0.05; +md.stressbalance.abstol=NaN; md.timestepping.time_step=1.; md.timestepping.final_time=3.; Index: /issm/trunk-jpl/test/Par/SquareSheetShelf.py =================================================================== --- /issm/trunk-jpl/test/Par/SquareSheetShelf.py (revision 15770) +++ /issm/trunk-jpl/test/Par/SquareSheetShelf.py (revision 15771) @@ -53,13 +53,13 @@ #Numerical parameters -md.diagnostic.viscosity_overshoot=0.0 +md.stressbalance.viscosity_overshoot=0.0 md.masstransport.stabilization=1 md.thermal.stabilization=1 md.verbose=verbose(0) md.settings.waitonlock=30 -md.diagnostic.restol=0.05 +md.stressbalance.restol=0.05 md.steadystate.reltol=0.05 -md.diagnostic.reltol=0.05 -md.diagnostic.abstol=float('NaN') +md.stressbalance.reltol=0.05 +md.stressbalance.abstol=float('NaN') md.timestepping.time_step=1. md.timestepping.final_time=3. Index: /issm/trunk-jpl/test/Par/SquareShelf.par =================================================================== --- /issm/trunk-jpl/test/Par/SquareShelf.par (revision 15770) +++ /issm/trunk-jpl/test/Par/SquareShelf.par (revision 15771) @@ -35,13 +35,13 @@ %Numerical parameters -md.diagnostic.viscosity_overshoot=0.3; +md.stressbalance.viscosity_overshoot=0.3; md.masstransport.stabilization=1; md.thermal.stabilization=1; md.settings.waitonlock=30; md.verbose=verbose(0); -md.diagnostic.restol=0.10; +md.stressbalance.restol=0.10; md.steadystate.reltol=0.02; -md.diagnostic.reltol=0.02; -md.diagnostic.abstol=NaN; +md.stressbalance.reltol=0.02; +md.stressbalance.abstol=NaN; md.timestepping.time_step=1; md.timestepping.final_time=3; Index: /issm/trunk-jpl/test/Par/SquareShelf.py =================================================================== --- /issm/trunk-jpl/test/Par/SquareShelf.py (revision 15770) +++ /issm/trunk-jpl/test/Par/SquareShelf.py (revision 15771) @@ -66,13 +66,13 @@ #Numerical parameters -md.diagnostic.viscosity_overshoot = 0.3 +md.stressbalance.viscosity_overshoot = 0.3 md.masstransport.stabilization = 1. md.thermal.stabilization = 1. md.settings.waitonlock = 30 md.verbose=verbose() -md.diagnostic.restol = 0.10 +md.stressbalance.restol = 0.10 md.steadystate.reltol = 0.02 -md.diagnostic.reltol = 0.02 -md.diagnostic.abstol = nan +md.stressbalance.reltol = 0.02 +md.stressbalance.abstol = nan md.timestepping.time_step = 1. md.timestepping.final_time = 3. Index: /issm/trunk-jpl/test/Par/SquareShelf2.par =================================================================== --- /issm/trunk-jpl/test/Par/SquareShelf2.par (revision 15770) +++ /issm/trunk-jpl/test/Par/SquareShelf2.par (revision 15771) @@ -35,13 +35,13 @@ %Numerical parameters -md.diagnostic.viscosity_overshoot=0.3; +md.stressbalance.viscosity_overshoot=0.3; md.masstransport.stabilization=1; md.thermal.stabilization=1; md.settings.waitonlock=30; md.verbose=verbose(0); -md.diagnostic.restol=0.10; +md.stressbalance.restol=0.10; md.steadystate.reltol=0.02; -md.diagnostic.reltol=0.02; -md.diagnostic.abstol=NaN; +md.stressbalance.reltol=0.02; +md.stressbalance.abstol=NaN; md.timestepping.time_step=1; md.timestepping.final_time=3; Index: /issm/trunk-jpl/test/Par/SquareShelf2.py =================================================================== --- /issm/trunk-jpl/test/Par/SquareShelf2.py (revision 15770) +++ /issm/trunk-jpl/test/Par/SquareShelf2.py (revision 15771) @@ -66,13 +66,13 @@ #Numerical parameters -md.diagnostic.viscosity_overshoot = 0.3 +md.stressbalance.viscosity_overshoot = 0.3 md.masstransport.stabilization = 1. md.thermal.stabilization = 1. md.settings.waitonlock = 30 md.verbose=verbose() -md.diagnostic.restol = 0.10 +md.stressbalance.restol = 0.10 md.steadystate.reltol = 0.02 -md.diagnostic.reltol = 0.02 -md.diagnostic.abstol = nan +md.stressbalance.reltol = 0.02 +md.stressbalance.abstol = nan md.timestepping.time_step = 1. md.timestepping.final_time = 3. Index: /issm/trunk-jpl/test/Par/SquareShelfConstrained.par =================================================================== --- /issm/trunk-jpl/test/Par/SquareShelfConstrained.par (revision 15770) +++ /issm/trunk-jpl/test/Par/SquareShelfConstrained.par (revision 15771) @@ -39,13 +39,13 @@ %Numerical parameters -md.diagnostic.viscosity_overshoot=0.0; +md.stressbalance.viscosity_overshoot=0.0; md.masstransport.stabilization=1; md.thermal.stabilization=1; md.verbose=verbose(0); md.settings.waitonlock=30; -md.diagnostic.restol=0.05; -md.diagnostic.reltol=0.05; +md.stressbalance.restol=0.05; +md.stressbalance.reltol=0.05; md.steadystate.reltol=0.05; -md.diagnostic.abstol=NaN; +md.stressbalance.abstol=NaN; md.timestepping.time_step=1; md.timestepping.final_time=3; Index: /issm/trunk-jpl/test/Par/SquareShelfConstrained.py =================================================================== --- /issm/trunk-jpl/test/Par/SquareShelfConstrained.py (revision 15770) +++ /issm/trunk-jpl/test/Par/SquareShelfConstrained.py (revision 15771) @@ -51,13 +51,13 @@ #Numerical parameters -md.diagnostic.viscosity_overshoot=0.0 +md.stressbalance.viscosity_overshoot=0.0 md.masstransport.stabilization=1. md.thermal.stabilization=1. md.verbose = verbose(0) md.settings.waitonlock=30 -md.diagnostic.restol=0.05 -md.diagnostic.reltol=0.05 +md.stressbalance.restol=0.05 +md.stressbalance.reltol=0.05 md.steadystate.reltol=0.05 -md.diagnostic.abstol=float('nan') +md.stressbalance.abstol=float('nan') md.timestepping.time_step=1. md.timestepping.final_time=3. Index: /issm/trunk-jpl/test/Par/SquareThermal.par =================================================================== --- /issm/trunk-jpl/test/Par/SquareThermal.par (revision 15770) +++ /issm/trunk-jpl/test/Par/SquareThermal.par (revision 15771) @@ -35,5 +35,5 @@ %Deal with boundary conditions: -disp(' boundary conditions for diagnostic model'); +disp(' boundary conditions for stressbalance model'); md=SetMarineIceSheetBC(md,'../Exp/SquareFront.exp'); Index: /issm/trunk-jpl/test/Par/SquareThermal.py =================================================================== --- /issm/trunk-jpl/test/Par/SquareThermal.py (revision 15770) +++ /issm/trunk-jpl/test/Par/SquareThermal.py (revision 15771) @@ -39,5 +39,5 @@ #Deal with boundary conditions: -print " boundary conditions for diagnostic model" +print " boundary conditions for stressbalance model" md=SetMarineIceSheetBC(md,'../Exp/SquareFront.exp')