Index: /issm/trunk-jpl/m4/issm_options.m4 =================================================================== --- /issm/trunk-jpl/m4/issm_options.m4 (revision 15766) +++ /issm/trunk-jpl/m4/issm_options.m4 (revision 15767) @@ -1523,21 +1523,21 @@ AC_MSG_RESULT($HAVE_THERMAL) dnl }}} - dnl with-prognostic{{{ - AC_ARG_WITH([prognostic], - AS_HELP_STRING([--with-prognostic = YES], [compile with prognostic capabilities (default is yes)]), - [PROGNOSTIC=$withval],[PROGNOSTIC=yes]) - AC_MSG_CHECKING(for prognostic capability compilation) - - if test "x$PROGNOSTIC" = "xyes"; then + dnl with-masstransport{{{ + AC_ARG_WITH([masstransport], + AS_HELP_STRING([--with-masstransport = YES], [compile with masstransport capabilities (default is yes)]), + [MASSTRANSPORT=$withval],[MASSTRANSPORT=yes]) + AC_MSG_CHECKING(for masstransport capability compilation) + + if test "x$MASSTRANSPORT" = "xyes"; then dnl defaults - HAVE_PROGNOSTIC=yes - - AC_DEFINE([_HAVE_PROGNOSTIC_],[1],[with prognostic capability]) - else - HAVE_PROGNOSTIC=no - fi - AM_CONDITIONAL([PROGNOSTIC], [test x$HAVE_PROGNOSTIC = xyes]) - AC_MSG_RESULT($HAVE_PROGNOSTIC) + HAVE_MASSTRANSPORT=yes + + AC_DEFINE([_HAVE_MASSTRANSPORT_],[1],[with masstransport capability]) + else + HAVE_MASSTRANSPORT=no + fi + AM_CONDITIONAL([MASSTRANSPORT], [test x$HAVE_MASSTRANSPORT = xyes]) + AC_MSG_RESULT($HAVE_MASSTRANSPORT) dnl }}} dnl with-control{{{ Index: /issm/trunk-jpl/src/ad/validation/Update/update.m =================================================================== --- /issm/trunk-jpl/src/ad/validation/Update/update.m (revision 15766) +++ /issm/trunk-jpl/src/ad/validation/Update/update.m (revision 15767) @@ -12,6 +12,6 @@ md.verbose=verbose('solution',true); -md=solve(md,PrognosticSolutionEnum); +md=solve(md,MasstransportSolutionEnum); -thickness=md.results.PrognosticSolution.Thickness; +thickness=md.results.MasstransportSolution.Thickness; save ../Validation/Archive.mat thickness; Index: /issm/trunk-jpl/src/ad/validation/Validation/validation.m =================================================================== --- /issm/trunk-jpl/src/ad/validation/Validation/validation.m (revision 15766) +++ /issm/trunk-jpl/src/ad/validation/Validation/validation.m (revision 15767) @@ -22,5 +22,5 @@ s=load('Archive.mat'); h0=s.thickness; - h=md.results.PrognosticSolution.Thickness; + h=md.results.MasstransportSolution.Thickness; error_diff=full(max(abs(h-h0))/(max(abs(h0))+eps)); if (error_diff>tolerance); Index: /issm/trunk-jpl/src/c/Makefile.am =================================================================== --- /issm/trunk-jpl/src/c/Makefile.am (revision 15766) +++ /issm/trunk-jpl/src/c/Makefile.am (revision 15767) @@ -366,10 +366,10 @@ steadystate_sources = ./analyses/steadystate_core.cpp #}}} -#Prognostic sources {{{ -prognostic_sources = ./modules/ModelProcessorx/Prognostic/UpdateElementsPrognostic.cpp\ - ./modules/ModelProcessorx/Prognostic/CreateNodesPrognostic.cpp\ - ./modules/ModelProcessorx/Prognostic/CreateConstraintsPrognostic.cpp\ - ./modules/ModelProcessorx/Prognostic/CreateLoadsPrognostic.cpp\ - ./analyses/prognostic_core.cpp +#Masstransport sources {{{ +masstransport_sources = ./modules/ModelProcessorx/Masstransport/UpdateElementsMasstransport.cpp\ + ./modules/ModelProcessorx/Masstransport/CreateNodesMasstransport.cpp\ + ./modules/ModelProcessorx/Masstransport/CreateConstraintsMasstransport.cpp\ + ./modules/ModelProcessorx/Masstransport/CreateLoadsMasstransport.cpp\ + ./analyses/masstransport_core.cpp #}}} #Thermal sources {{{ @@ -870,6 +870,6 @@ endif -if PROGNOSTIC -issm_sources += $(prognostic_sources) +if MASSTRANSPORT +issm_sources += $(masstransport_sources) endif Index: /issm/trunk-jpl/src/c/analyses/AnalysisConfiguration.cpp =================================================================== --- /issm/trunk-jpl/src/c/analyses/AnalysisConfiguration.cpp (revision 15766) +++ /issm/trunk-jpl/src/c/analyses/AnalysisConfiguration.cpp (revision 15767) @@ -71,8 +71,8 @@ break; - case PrognosticSolutionEnum: + case MasstransportSolutionEnum: numanalyses=1; analyses=xNew(numanalyses); - analyses[0]=PrognosticAnalysisEnum; + analyses[0]=MasstransportAnalysisEnum; break; @@ -118,5 +118,5 @@ analyses[6]=MeltingAnalysisEnum; analyses[7]=EnthalpyAnalysisEnum; - analyses[8]=PrognosticAnalysisEnum; + analyses[8]=MasstransportAnalysisEnum; break; Index: /issm/trunk-jpl/src/c/analyses/CorePointerFromSolutionEnum.cpp =================================================================== --- /issm/trunk-jpl/src/c/analyses/CorePointerFromSolutionEnum.cpp (revision 15766) +++ /issm/trunk-jpl/src/c/analyses/CorePointerFromSolutionEnum.cpp (revision 15767) @@ -93,9 +93,9 @@ #endif break; - case PrognosticSolutionEnum: - #ifdef _HAVE_PROGNOSTIC_ - solutioncore=&prognostic_core; + case MasstransportSolutionEnum: + #ifdef _HAVE_MASSTRANSPORT_ + solutioncore=&masstransport_core; #else - _error_("ISSM was not compiled with prognostic capabilities. Exiting"); + _error_("ISSM was not compiled with masstransport capabilities. Exiting"); #endif break; Index: /issm/trunk-jpl/src/c/analyses/analyses.h =================================================================== --- /issm/trunk-jpl/src/c/analyses/analyses.h (revision 15766) +++ /issm/trunk-jpl/src/c/analyses/analyses.h (revision 15767) @@ -28,5 +28,5 @@ void control_core(FemModel* femmodel); void controltao_core(FemModel* femmodel); -void prognostic_core(FemModel* femmodel); +void masstransport_core(FemModel* femmodel); void balancethickness_core(FemModel* femmodel); void slopecompute_core(FemModel* femmodel); Index: /issm/trunk-jpl/src/c/analyses/masstransport_core.cpp =================================================================== --- /issm/trunk-jpl/src/c/analyses/masstransport_core.cpp (revision 15767) +++ /issm/trunk-jpl/src/c/analyses/masstransport_core.cpp (revision 15767) @@ -0,0 +1,58 @@ +/*!\file: masstransport_core.cpp + * \brief: core of the masstransport 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 masstransport_core(FemModel* femmodel){ + + /*parameters: */ + bool save_results; + bool issmbgradients,ispdd,isdelta18o; + int solution_type; + int *requested_outputs = NULL; + int numoutputs=0; + + /*activate formulation: */ + femmodel->SetCurrentConfiguration(MasstransportAnalysisEnum); + + /*recover parameters: */ + femmodel->parameters->FindParam(&save_results,SaveResultsEnum); + femmodel->parameters->FindParam(&issmbgradients,SurfaceforcingsIssmbgradientsEnum); + femmodel->parameters->FindParam(&ispdd,SurfaceforcingsIspddEnum); + femmodel->parameters->FindParam(&isdelta18o,SurfaceforcingsIsdelta18oEnum); + femmodel->parameters->FindParam(&solution_type,SolutionTypeEnum); + femmodel->parameters->FindParam(&numoutputs,MasstransportNumRequestedOutputsEnum); + if(numoutputs) femmodel->parameters->FindParam(&requested_outputs,&numoutputs,MasstransportRequestedOutputsEnum); + + if(issmbgradients){ + if(VerboseSolution())_printf_(" call smb gradients module\n\n"); + SmbGradientsx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters); + } + if(ispdd){ + if(isdelta18o){ + if(VerboseSolution()) _printf0_(" call Delta18oParametrization module\n"); + Delta18oParameterizationx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters); + } + if(VerboseSolution()) _printf0_(" call positive degree day module\n"); + PositiveDegreeDayx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters); + } + if(VerboseSolution()) _printf0_(" call computational core\n"); + 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,ThicknessEnum); + femmodel->RequestedOutputsx(requested_outputs,numoutputs); + } + + if(solution_type==MasstransportSolutionEnum)femmodel->RequestedDependentsx(); + + /*Free ressources:*/ + xDelete(requested_outputs); +} Index: sm/trunk-jpl/src/c/analyses/prognostic_core.cpp =================================================================== --- /issm/trunk-jpl/src/c/analyses/prognostic_core.cpp (revision 15766) +++ (revision ) @@ -1,58 +1,0 @@ -/*!\file: prognostic_core.cpp - * \brief: core of the prognostic 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 prognostic_core(FemModel* femmodel){ - - /*parameters: */ - bool save_results; - bool issmbgradients,ispdd,isdelta18o; - int solution_type; - int *requested_outputs = NULL; - int numoutputs=0; - - /*activate formulation: */ - femmodel->SetCurrentConfiguration(PrognosticAnalysisEnum); - - /*recover parameters: */ - femmodel->parameters->FindParam(&save_results,SaveResultsEnum); - femmodel->parameters->FindParam(&issmbgradients,SurfaceforcingsIssmbgradientsEnum); - femmodel->parameters->FindParam(&ispdd,SurfaceforcingsIspddEnum); - femmodel->parameters->FindParam(&isdelta18o,SurfaceforcingsIsdelta18oEnum); - femmodel->parameters->FindParam(&solution_type,SolutionTypeEnum); - femmodel->parameters->FindParam(&numoutputs,PrognosticNumRequestedOutputsEnum); - if(numoutputs) femmodel->parameters->FindParam(&requested_outputs,&numoutputs,PrognosticRequestedOutputsEnum); - - if(issmbgradients){ - if(VerboseSolution())_printf_(" call smb gradients module\n\n"); - SmbGradientsx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters); - } - if(ispdd){ - if(isdelta18o){ - if(VerboseSolution()) _printf0_(" call Delta18oParametrization module\n"); - Delta18oParameterizationx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters); - } - if(VerboseSolution()) _printf0_(" call positive degree day module\n"); - PositiveDegreeDayx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters); - } - if(VerboseSolution()) _printf0_(" call computational core\n"); - 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,ThicknessEnum); - femmodel->RequestedOutputsx(requested_outputs,numoutputs); - } - - if(solution_type==PrognosticSolutionEnum)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 15766) +++ /issm/trunk-jpl/src/c/analyses/transient_core.cpp (revision 15767) @@ -21,5 +21,5 @@ /*parameters: */ IssmDouble starttime,finaltime,dt,yts; - bool isdiagnostic,isprognostic,isthermal,isgroundingline,isenthalpy,isdelta18o,isgia; + bool isdiagnostic,ismasstransport,isthermal,isgroundingline,isenthalpy,isdelta18o,isgia; bool save_results,dakota_analysis; bool time_adapt=false; @@ -43,5 +43,5 @@ femmodel->parameters->FindParam(&time_adapt,TimesteppingTimeAdaptEnum); femmodel->parameters->FindParam(&isdiagnostic,TransientIsdiagnosticEnum); - femmodel->parameters->FindParam(&isprognostic,TransientIsprognosticEnum); + femmodel->parameters->FindParam(&ismasstransport,TransientIsmasstransportEnum); femmodel->parameters->FindParam(&isthermal,TransientIsthermalEnum); femmodel->parameters->FindParam(&isgia,TransientIsgiaEnum); @@ -69,5 +69,5 @@ if(isthermal && dim==3){ //Update Vertex Position after updating Thickness and Bed - femmodel->SetCurrentConfiguration(PrognosticAnalysisEnum); + femmodel->SetCurrentConfiguration(MasstransportAnalysisEnum); femmodel->UpdateVertexPositionsx(); InputDuplicatex(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,QmuVxMeshEnum,VxMeshEnum); @@ -126,7 +126,7 @@ } - if(isprognostic){ + if(ismasstransport){ if(VerboseSolution()) _printf0_(" computing new thickness\n"); - prognostic_core(femmodel); + masstransport_core(femmodel); if(VerboseSolution()) _printf0_(" updating vertices positions\n"); femmodel->UpdateVertexPositionsx(); Index: /issm/trunk-jpl/src/c/classes/Elements/Penta.cpp =================================================================== --- /issm/trunk-jpl/src/c/classes/Elements/Penta.cpp (revision 15766) +++ /issm/trunk-jpl/src/c/classes/Elements/Penta.cpp (revision 15767) @@ -467,6 +467,6 @@ return CreateBasalMassMatrix(); break; - case PrognosticAnalysisEnum: - return CreateKMatrixPrognostic(); + case MasstransportAnalysisEnum: + return CreateKMatrixMasstransport(); break; #ifdef _HAVE_BALANCED_ @@ -502,6 +502,6 @@ } /*}}}*/ -/*FUNCTION Penta::CreateKMatrixPrognostic {{{*/ -ElementMatrix* Penta::CreateKMatrixPrognostic(void){ +/*FUNCTION Penta::CreateKMatrixMasstransport {{{*/ +ElementMatrix* Penta::CreateKMatrixMasstransport(void){ if (!IsOnBed()) return NULL; @@ -512,5 +512,5 @@ Tria* tria=(Tria*)SpawnTria(0); //lower face is 0, upper face is 1. - ElementMatrix* Ke=tria->CreateKMatrixPrognostic(); + ElementMatrix* Ke=tria->CreateKMatrixMasstransport(); delete tria->material; delete tria; @@ -663,6 +663,6 @@ return CreatePVectorSlope(); break; - case PrognosticAnalysisEnum: - return CreatePVectorPrognostic(); + case MasstransportAnalysisEnum: + return CreatePVectorMasstransport(); break; #ifdef _HAVE_BALANCED_ @@ -687,6 +687,6 @@ } /*}}}*/ -/*FUNCTION Penta::CreatePVectorPrognostic {{{*/ -ElementVector* Penta::CreatePVectorPrognostic(void){ +/*FUNCTION Penta::CreatePVectorMasstransport {{{*/ +ElementVector* Penta::CreatePVectorMasstransport(void){ if (!IsOnBed()) return NULL; @@ -698,5 +698,5 @@ /*Call Tria function*/ Tria* tria=(Tria*)SpawnTria(0); //lower face is 0, upper face is 1. - ElementVector* pe=tria->CreatePVectorPrognostic(); + ElementVector* pe=tria->CreatePVectorMasstransport(); delete tria->material; delete tria; @@ -2260,6 +2260,6 @@ InputUpdateFromSolutionOneDofCollapsed(solution,SurfaceSlopeYEnum); break; - case PrognosticAnalysisEnum: - InputUpdateFromSolutionPrognostic(solution); + case MasstransportAnalysisEnum: + InputUpdateFromSolutionMasstransport(solution); break; #ifdef _HAVE_BALANCED_ @@ -2281,6 +2281,6 @@ } /*}}}*/ -/*FUNCTION Penta::InputUpdateFromSolutionPrognostic{{{*/ -void Penta::InputUpdateFromSolutionPrognostic(IssmDouble* solution){ +/*FUNCTION Penta::InputUpdateFromSolutionMasstransport{{{*/ +void Penta::InputUpdateFromSolutionMasstransport(IssmDouble* solution){ const int numdof = NDOF1*NUMVERTICES; @@ -2305,5 +2305,5 @@ /*Use the dof list to index into the solution vector and extrude it */ - this->parameters->FindParam(&minthickness,PrognosticMinThicknessEnum); + this->parameters->FindParam(&minthickness,MasstransportMinThicknessEnum); for(i=0;iparameters->FindParam(&hydroadjustment,PrognosticHydrostaticAdjustmentEnum); + /*Fing MasstransportHydrostaticAdjustment to figure out how to update the geometry:*/ + this->parameters->FindParam(&hydroadjustment,MasstransportHydrostaticAdjustmentEnum); /*recover material parameters: */ Index: /issm/trunk-jpl/src/c/classes/Elements/Penta.h =================================================================== --- /issm/trunk-jpl/src/c/classes/Elements/Penta.h (revision 15766) +++ /issm/trunk-jpl/src/c/classes/Elements/Penta.h (revision 15767) @@ -180,7 +180,7 @@ ElementMatrix* CreateBasalMassMatrix(void); ElementMatrix* CreateKMatrix(void); - ElementMatrix* CreateKMatrixPrognostic(void); + ElementMatrix* CreateKMatrixMasstransport(void); ElementVector* CreatePVector(void); - ElementVector* CreatePVectorPrognostic(void); + ElementVector* CreatePVectorMasstransport(void); ElementVector* CreatePVectorSlope(void); void GetAreaCoordinates(IssmDouble *area_coordinates,IssmDouble xyz_zero[3][3],IssmDouble xyz_list[6][3],int numpoints); @@ -210,5 +210,5 @@ Penta* GetBasalElement(void); void InputExtrude(int enum_type,int object_type); - void InputUpdateFromSolutionPrognostic(IssmDouble* solutiong); + void InputUpdateFromSolutionMasstransport(IssmDouble* solutiong); void InputUpdateFromSolutionOneDof(IssmDouble* solutiong,int enum_type); void InputUpdateFromSolutionOneDofCollapsed(IssmDouble* solutiong,int enum_type); Index: /issm/trunk-jpl/src/c/classes/Elements/Tria.cpp =================================================================== --- /issm/trunk-jpl/src/c/classes/Elements/Tria.cpp (revision 15766) +++ /issm/trunk-jpl/src/c/classes/Elements/Tria.cpp (revision 15767) @@ -226,6 +226,6 @@ return CreateMassMatrix(); break; - case PrognosticAnalysisEnum: - return CreateKMatrixPrognostic(); + case MasstransportAnalysisEnum: + return CreateKMatrixMasstransport(); break; #ifdef _HAVE_HYDROLOGY_ @@ -368,6 +368,6 @@ return CreatePVectorSlope(); break; - case PrognosticAnalysisEnum: - return CreatePVectorPrognostic(); + case MasstransportAnalysisEnum: + return CreatePVectorMasstransport(); break; #ifdef _HAVE_HYDROLOGY_ @@ -1613,6 +1613,6 @@ InputUpdateFromSolutionOneDof(solution,SurfaceSlopeYEnum); break; - case PrognosticAnalysisEnum: - InputUpdateFromSolutionPrognostic(solution); + case MasstransportAnalysisEnum: + InputUpdateFromSolutionMasstransport(solution); break; default: @@ -1648,6 +1648,6 @@ } /*}}}*/ -/*FUNCTION Tria::InputUpdateFromSolutionPrognostic{{{*/ -void Tria::InputUpdateFromSolutionPrognostic(IssmDouble* solution){ +/*FUNCTION Tria::InputUpdateFromSolutionMasstransport{{{*/ +void Tria::InputUpdateFromSolutionMasstransport(IssmDouble* solution){ /*Intermediaries*/ @@ -1669,5 +1669,5 @@ /*Use the dof list to index into the solution vector: */ - this->parameters->FindParam(&minthickness,PrognosticMinThicknessEnum); + this->parameters->FindParam(&minthickness,MasstransportMinThicknessEnum); for(i=0;iparameters->FindParam(&hydroadjustment,PrognosticHydrostaticAdjustmentEnum); + /*Fing MasstransportHydrostaticAdjustment to figure out how to update the geometry:*/ + this->parameters->FindParam(&hydroadjustment,MasstransportHydrostaticAdjustmentEnum); rho_ice=matpar->GetRhoIce(); rho_water=matpar->GetRhoWater(); @@ -2402,5 +2402,5 @@ /*Fetch parameters: */ iomodel->Constant(&yts,ConstantsYtsEnum); - iomodel->Constant(&progstabilization,PrognosticStabilizationEnum); + iomodel->Constant(&progstabilization,MasstransportStabilizationEnum); iomodel->Constant(&balancestabilization,BalancethicknessStabilizationEnum); iomodel->Constant(&fe_ssa,FlowequationFeSSAEnum); @@ -5624,6 +5624,6 @@ Ke->values,1); - GetBPrognostic(B,&xyz_list[0][0], gauss); - GetBprimePrognostic(Bprime,&xyz_list[0][0], gauss); + GetBMasstransport(B,&xyz_list[0][0], gauss); + GetBprimeMasstransport(Bprime,&xyz_list[0][0], gauss); dvxdx=dvx[0]; @@ -6278,13 +6278,13 @@ #endif -#ifdef _HAVE_PROGNOSTIC_ -/*FUNCTION Tria::CreateKMatrixPrognostic {{{*/ -ElementMatrix* Tria::CreateKMatrixPrognostic(void){ +#ifdef _HAVE_MASSTRANSPORT_ +/*FUNCTION Tria::CreateKMatrixMasstransport {{{*/ +ElementMatrix* Tria::CreateKMatrixMasstransport(void){ switch(GetElementType()){ case P1Enum: case P2Enum: - return CreateKMatrixPrognostic_CG(); + return CreateKMatrixMasstransport_CG(); case P1DGEnum: - return CreateKMatrixPrognostic_DG(); + return CreateKMatrixMasstransport_DG(); default: _error_("Element type " << EnumToStringx(GetElementType()) << " not supported yet"); @@ -6292,6 +6292,6 @@ } /*}}}*/ -/*FUNCTION Tria::CreateKMatrixPrognostic_CG {{{*/ -ElementMatrix* Tria::CreateKMatrixPrognostic_CG(void){ +/*FUNCTION Tria::CreateKMatrixMasstransport_CG {{{*/ +ElementMatrix* Tria::CreateKMatrixMasstransport_CG(void){ /*Intermediaries */ @@ -6317,5 +6317,5 @@ this->parameters->FindParam(&dt,TimesteppingTimeStepEnum); this->parameters->FindParam(&dim,MeshDimensionEnum); - this->parameters->FindParam(&stabilization,PrognosticStabilizationEnum); + this->parameters->FindParam(&stabilization,MasstransportStabilizationEnum); Input* vxaverage_input=NULL; Input* vyaverage_input=NULL; @@ -6351,6 +6351,6 @@ &Ke->values[0],1); - GetBPrognostic(B,&xyz_list[0][0],gauss); - GetBprimePrognostic(Bprime,&xyz_list[0][0],gauss); + GetBMasstransport(B,&xyz_list[0][0],gauss); + GetBprimeMasstransport(Bprime,&xyz_list[0][0],gauss); dvxdx=dvx[0]; @@ -6411,6 +6411,6 @@ } /*}}}*/ -/*FUNCTION Tria::CreateKMatrixPrognostic_DG {{{*/ -ElementMatrix* Tria::CreateKMatrixPrognostic_DG(void){ +/*FUNCTION Tria::CreateKMatrixMasstransport_DG {{{*/ +ElementMatrix* Tria::CreateKMatrixMasstransport_DG(void){ /*Intermediaries */ @@ -6463,7 +6463,7 @@ &Ke->values[0],1); - /*WARNING: B and Bprime are inverted compared to usual prognostic!!!!*/ - GetBPrognostic(Bprime, &xyz_list[0][0], gauss); - GetBprimePrognostic(B, &xyz_list[0][0], gauss); + /*WARNING: B and Bprime are inverted compared to usual masstransport!!!!*/ + GetBMasstransport(Bprime, &xyz_list[0][0], gauss); + GetBprimeMasstransport(B, &xyz_list[0][0], gauss); D_scalar=-dt*gauss->weight*Jdettria; @@ -6487,12 +6487,12 @@ } /*}}}*/ -/*FUNCTION Tria::CreatePVectorPrognostic{{{*/ -ElementVector* Tria::CreatePVectorPrognostic(void){ +/*FUNCTION Tria::CreatePVectorMasstransport{{{*/ +ElementVector* Tria::CreatePVectorMasstransport(void){ switch(GetElementType()){ case P1Enum: case P2Enum: - return CreatePVectorPrognostic_CG(); + return CreatePVectorMasstransport_CG(); case P1DGEnum: - return CreatePVectorPrognostic_DG(); + return CreatePVectorMasstransport_DG(); default: _error_("Element type " << EnumToStringx(GetElementType()) << " not supported yet"); @@ -6500,6 +6500,6 @@ } /*}}}*/ -/*FUNCTION Tria::CreatePVectorPrognostic_CG {{{*/ -ElementVector* Tria::CreatePVectorPrognostic_CG(void){ +/*FUNCTION Tria::CreatePVectorMasstransport_CG {{{*/ +ElementVector* Tria::CreatePVectorMasstransport_CG(void){ /*Intermediaries */ @@ -6550,6 +6550,6 @@ } /*}}}*/ -/*FUNCTION Tria::CreatePVectorPrognostic_DG {{{*/ -ElementVector* Tria::CreatePVectorPrognostic_DG(void){ +/*FUNCTION Tria::CreatePVectorMasstransport_DG {{{*/ +ElementVector* Tria::CreatePVectorMasstransport_DG(void){ /*Intermediaries */ @@ -6796,6 +6796,6 @@ GetJacobianDeterminant(&Jdettria, &xyz_list[0][0],gauss); - GetBPrognostic(B,&xyz_list[0][0],gauss); - GetBprimePrognostic(Bprime,&xyz_list[0][0],gauss); + GetBMasstransport(B,&xyz_list[0][0],gauss); + GetBprimeMasstransport(Bprime,&xyz_list[0][0],gauss); vxaverage_input->GetInputValue(&vx,gauss); @@ -6892,7 +6892,7 @@ GetJacobianDeterminant(&Jdettria, &xyz_list[0][0],gauss); - /*WARNING: B and Bprime are inverted compared to usual prognostic!!!!*/ - GetBPrognostic(Bprime,&xyz_list[0][0],gauss); - GetBprimePrognostic(B,&xyz_list[0][0],gauss); + /*WARNING: B and Bprime are inverted compared to usual masstransport!!!!*/ + GetBMasstransport(Bprime,&xyz_list[0][0],gauss); + GetBprimeMasstransport(B,&xyz_list[0][0],gauss); vx_input->GetInputValue(&vx,gauss); Index: /issm/trunk-jpl/src/c/classes/Elements/Tria.h =================================================================== --- /issm/trunk-jpl/src/c/classes/Elements/Tria.h (revision 15766) +++ /issm/trunk-jpl/src/c/classes/Elements/Tria.h (revision 15767) @@ -185,7 +185,7 @@ ElementMatrix* CreateKMatrixBalancethickness_CG(void); ElementMatrix* CreateKMatrixMelting(void); - ElementMatrix* CreateKMatrixPrognostic(void); - ElementMatrix* CreateKMatrixPrognostic_CG(void); - ElementMatrix* CreateKMatrixPrognostic_DG(void); + ElementMatrix* CreateKMatrixMasstransport(void); + ElementMatrix* CreateKMatrixMasstransport_CG(void); + ElementMatrix* CreateKMatrixMasstransport_DG(void); ElementMatrix* CreateMassMatrix(void); ElementVector* CreatePVector(void); @@ -193,7 +193,7 @@ ElementVector* CreatePVectorBalancethickness_DG(void); ElementVector* CreatePVectorBalancethickness_CG(void); - ElementVector* CreatePVectorPrognostic(void); - ElementVector* CreatePVectorPrognostic_CG(void); - ElementVector* CreatePVectorPrognostic_DG(void); + ElementVector* CreatePVectorMasstransport(void); + ElementVector* CreatePVectorMasstransport_CG(void); + ElementVector* CreatePVectorMasstransport_DG(void); ElementVector* CreatePVectorSlope(void); IssmDouble GetArea(void); @@ -216,5 +216,5 @@ void GetStrainRate2d(IssmDouble* epsilon,IssmDouble* xyz_list, GaussTria* gauss, Input* vx_input, Input* vy_input); void InputUpdateFromSolutionOneDof(IssmDouble* solution,int enum_type); - void InputUpdateFromSolutionPrognostic(IssmDouble* solution); + void InputUpdateFromSolutionMasstransport(IssmDouble* solution); bool IsInput(int name); void SetClone(int* minranks); Index: /issm/trunk-jpl/src/c/classes/Elements/TriaRef.cpp =================================================================== --- /issm/trunk-jpl/src/c/classes/Elements/TriaRef.cpp (revision 15766) +++ /issm/trunk-jpl/src/c/classes/Elements/TriaRef.cpp (revision 15767) @@ -202,6 +202,6 @@ } /*}}}*/ -/*FUNCTION TriaRef::GetBPrognostic{{{*/ -void TriaRef::GetBPrognostic(IssmDouble* B, IssmDouble* xyz_list, GaussTria* gauss){ +/*FUNCTION TriaRef::GetBMasstransport{{{*/ +void TriaRef::GetBMasstransport(IssmDouble* B, IssmDouble* xyz_list, GaussTria* gauss){ /*Compute B matrix. B=[B1 B2 B3] where Bi is of size 3*NDOF2. * For node i, Bi can be expressed in the actual coordinate system @@ -303,6 +303,6 @@ } /*}}}*/ -/*FUNCTION TriaRef::GetBprimePrognostic{{{*/ -void TriaRef::GetBprimePrognostic(IssmDouble* Bprime, IssmDouble* xyz_list, GaussTria* gauss){ +/*FUNCTION TriaRef::GetBprimeMasstransport{{{*/ +void TriaRef::GetBprimeMasstransport(IssmDouble* Bprime, IssmDouble* xyz_list, GaussTria* gauss){ /*Compute B' matrix. B'=[B1' B2' B3'] where Bi' is of size 3*NDOF2. * For node i, Bi' can be expressed in the actual coordinate system Index: /issm/trunk-jpl/src/c/classes/Elements/TriaRef.h =================================================================== --- /issm/trunk-jpl/src/c/classes/Elements/TriaRef.h (revision 15766) +++ /issm/trunk-jpl/src/c/classes/Elements/TriaRef.h (revision 15767) @@ -27,6 +27,6 @@ void GetBprimeSSA(IssmDouble* Bprime, IssmDouble* xyz_list, GaussTria* gauss); void GetBprimeSSAFS(IssmDouble* Bprime, IssmDouble* xyz_list, GaussTria* gauss); - void GetBprimePrognostic(IssmDouble* Bprime, IssmDouble* xyz_list, GaussTria* gauss); - void GetBPrognostic(IssmDouble* B, IssmDouble* xyz_list, GaussTria* gauss); + void GetBprimeMasstransport(IssmDouble* Bprime, IssmDouble* xyz_list, GaussTria* gauss); + void GetBMasstransport(IssmDouble* B, IssmDouble* xyz_list, GaussTria* gauss); void GetBHydro(IssmDouble* B, IssmDouble* xyz_list, GaussTria* gauss); void GetBSSAFriction(IssmDouble* L, IssmDouble* xyz_list,GaussTria* gauss); Index: /issm/trunk-jpl/src/c/classes/Loads/Numericalflux.cpp =================================================================== --- /issm/trunk-jpl/src/c/classes/Loads/Numericalflux.cpp (revision 15766) +++ /issm/trunk-jpl/src/c/classes/Loads/Numericalflux.cpp (revision 15767) @@ -254,6 +254,6 @@ /*Just branch to the correct element stiffness matrix generator, according to the type of analysis we are carrying out: */ switch(analysis_type){ - case PrognosticAnalysisEnum: - Ke=CreateKMatrixPrognostic(); + case MasstransportAnalysisEnum: + Ke=CreateKMatrixMasstransport(); break; case BalancethicknessAnalysisEnum: @@ -284,6 +284,6 @@ switch(analysis_type){ - case PrognosticAnalysisEnum: - pe=CreatePVectorPrognostic(); + case MasstransportAnalysisEnum: + pe=CreatePVectorMasstransport(); break; case BalancethicknessAnalysisEnum: @@ -422,6 +422,6 @@ /*Numericalflux management*/ -/*FUNCTION Numericalflux::CreateKMatrixPrognostic{{{*/ -ElementMatrix* Numericalflux::CreateKMatrixPrognostic(void){ +/*FUNCTION Numericalflux::CreateKMatrixMasstransport{{{*/ +ElementMatrix* Numericalflux::CreateKMatrixMasstransport(void){ int type; @@ -430,7 +430,7 @@ switch(type){ case InternalEnum: - return CreateKMatrixPrognosticInternal(); + return CreateKMatrixMasstransportInternal(); case BoundaryEnum: - return CreateKMatrixPrognosticBoundary(); + return CreateKMatrixMasstransportBoundary(); default: _error_("type not supported yet"); @@ -438,6 +438,6 @@ } /*}}}*/ -/*FUNCTION Numericalflux::CreateKMatrixPrognosticInternal {{{*/ -ElementMatrix* Numericalflux::CreateKMatrixPrognosticInternal(void){ +/*FUNCTION Numericalflux::CreateKMatrixMasstransportInternal {{{*/ +ElementMatrix* Numericalflux::CreateKMatrixMasstransportInternal(void){ /* constants*/ @@ -503,6 +503,6 @@ } /*}}}*/ -/*FUNCTION Numericalflux::CreateKMatrixPrognosticBoundary {{{*/ -ElementMatrix* Numericalflux::CreateKMatrixPrognosticBoundary(void){ +/*FUNCTION Numericalflux::CreateKMatrixMasstransportBoundary {{{*/ +ElementMatrix* Numericalflux::CreateKMatrixMasstransportBoundary(void){ /* constants*/ @@ -758,6 +758,6 @@ } /*}}}*/ -/*FUNCTION Numericalflux::CreatePVectorPrognostic{{{*/ -ElementVector* Numericalflux::CreatePVectorPrognostic(void){ +/*FUNCTION Numericalflux::CreatePVectorMasstransport{{{*/ +ElementVector* Numericalflux::CreatePVectorMasstransport(void){ int type; @@ -766,7 +766,7 @@ switch(type){ case InternalEnum: - return CreatePVectorPrognosticInternal(); + return CreatePVectorMasstransportInternal(); case BoundaryEnum: - return CreatePVectorPrognosticBoundary(); + return CreatePVectorMasstransportBoundary(); default: _error_("type not supported yet"); @@ -774,6 +774,6 @@ } /*}}}*/ -/*FUNCTION Numericalflux::CreatePVectorPrognosticInternal{{{*/ -ElementVector* Numericalflux::CreatePVectorPrognosticInternal(void){ +/*FUNCTION Numericalflux::CreatePVectorMasstransportInternal{{{*/ +ElementVector* Numericalflux::CreatePVectorMasstransportInternal(void){ /*Nothing added to PVector*/ @@ -782,6 +782,6 @@ } /*}}}*/ -/*FUNCTION Numericalflux::CreatePVectorPrognosticBoundary{{{*/ -ElementVector* Numericalflux::CreatePVectorPrognosticBoundary(void){ +/*FUNCTION Numericalflux::CreatePVectorMasstransportBoundary{{{*/ +ElementVector* Numericalflux::CreatePVectorMasstransportBoundary(void){ /* constants*/ @@ -806,5 +806,5 @@ Input* vxaverage_input =tria->inputs->GetInput(VxEnum); _assert_(vxaverage_input); Input* vyaverage_input =tria->inputs->GetInput(VyEnum); _assert_(vyaverage_input); - Input* spcthickness_input=tria->inputs->GetInput(PrognosticSpcthicknessEnum); _assert_(spcthickness_input); + Input* spcthickness_input=tria->inputs->GetInput(MasstransportSpcthicknessEnum); _assert_(spcthickness_input); GetNormal(&normal[0],xyz_list); Index: /issm/trunk-jpl/src/c/classes/Loads/Numericalflux.h =================================================================== --- /issm/trunk-jpl/src/c/classes/Loads/Numericalflux.h (revision 15766) +++ /issm/trunk-jpl/src/c/classes/Loads/Numericalflux.h (revision 15767) @@ -78,7 +78,7 @@ /*Numericalflux management:{{{*/ void GetNormal(IssmDouble* normal,IssmDouble xyz_list[4][3]); - ElementMatrix* CreateKMatrixPrognostic(void); - ElementMatrix* CreateKMatrixPrognosticInternal(void); - ElementMatrix* CreateKMatrixPrognosticBoundary(void); + ElementMatrix* CreateKMatrixMasstransport(void); + ElementMatrix* CreateKMatrixMasstransportInternal(void); + ElementMatrix* CreateKMatrixMasstransportBoundary(void); ElementMatrix* CreateKMatrixBalancethickness(void); ElementMatrix* CreateKMatrixBalancethicknessInternal(void); @@ -87,7 +87,7 @@ ElementMatrix* CreateKMatrixAdjointBalancethicknessInternal(void); ElementMatrix* CreateKMatrixAdjointBalancethicknessBoundary(void); - ElementVector* CreatePVectorPrognostic(void); - ElementVector* CreatePVectorPrognosticInternal(void); - ElementVector* CreatePVectorPrognosticBoundary(void); + ElementVector* CreatePVectorMasstransport(void); + ElementVector* CreatePVectorMasstransportInternal(void); + ElementVector* CreatePVectorMasstransportBoundary(void); ElementVector* CreatePVectorBalancethickness(void); ElementVector* CreatePVectorBalancethicknessInternal(void); Index: /issm/trunk-jpl/src/c/classes/Loads/Penpair.cpp =================================================================== --- /issm/trunk-jpl/src/c/classes/Loads/Penpair.cpp (revision 15766) +++ /issm/trunk-jpl/src/c/classes/Loads/Penpair.cpp (revision 15767) @@ -176,6 +176,6 @@ Ke=PenaltyCreateKMatrixDiagnosticHoriz(kmax); break; - case PrognosticAnalysisEnum: - Ke=PenaltyCreateKMatrixPrognostic(kmax); + case MasstransportAnalysisEnum: + Ke=PenaltyCreateKMatrixMasstransport(kmax); break; default: @@ -391,6 +391,6 @@ } /*}}}*/ -/*FUNCTION Penpair::PenaltyCreateKMatrixPrognostic {{{*/ -ElementMatrix* Penpair::PenaltyCreateKMatrixPrognostic(IssmDouble kmax){ +/*FUNCTION Penpair::PenaltyCreateKMatrixMasstransport {{{*/ +ElementMatrix* Penpair::PenaltyCreateKMatrixMasstransport(IssmDouble kmax){ const int numdof=NUMVERTICES*NDOF1; @@ -401,5 +401,5 @@ /*recover parameters: */ - parameters->FindParam(&penalty_factor,PrognosticPenaltyFactorEnum); + parameters->FindParam(&penalty_factor,MasstransportPenaltyFactorEnum); //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 15766) +++ /issm/trunk-jpl/src/c/classes/Loads/Penpair.h (revision 15767) @@ -70,5 +70,5 @@ ElementMatrix* PenaltyCreateKMatrixDiagnosticSSAHO(IssmDouble kmax); ElementMatrix* PenaltyCreateKMatrixDiagnosticFS(IssmDouble kmax); - ElementMatrix* PenaltyCreateKMatrixPrognostic(IssmDouble kmax); + ElementMatrix* PenaltyCreateKMatrixMasstransport(IssmDouble kmax); /*}}}*/ }; Index: /issm/trunk-jpl/src/c/classes/Node.cpp =================================================================== --- /issm/trunk-jpl/src/c/classes/Node.cpp (revision 15766) +++ /issm/trunk-jpl/src/c/classes/Node.cpp (revision 15767) @@ -92,5 +92,5 @@ /*2d solutions in 3d, we need to constrain all the nodes that are not on base*/ if( - analysis_type==PrognosticAnalysisEnum || + analysis_type==MasstransportAnalysisEnum || analysis_type==MeltingAnalysisEnum || analysis_type==BedSlopeAnalysisEnum || Index: /issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateDataSets.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateDataSets.cpp (revision 15766) +++ /issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateDataSets.cpp (revision 15767) @@ -141,10 +141,10 @@ #endif - #ifdef _HAVE_PROGNOSTIC_ - case PrognosticAnalysisEnum: - CreateNodesPrognostic(pnodes, iomodel); - CreateConstraintsPrognostic(pconstraints,iomodel); - CreateLoadsPrognostic(ploads,iomodel); - UpdateElementsPrognostic(elements,iomodel,analysis_counter,analysis_type); + #ifdef _HAVE_MASSTRANSPORT_ + case MasstransportAnalysisEnum: + CreateNodesMasstransport(pnodes, iomodel); + CreateConstraintsMasstransport(pconstraints,iomodel); + CreateLoadsMasstransport(ploads,iomodel); + UpdateElementsMasstransport(elements,iomodel,analysis_counter,analysis_type); break; #endif Index: /issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateParameters.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateParameters.cpp (revision 15766) +++ /issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateParameters.cpp (revision 15767) @@ -65,9 +65,9 @@ parameters->AddObject(iomodel->CopyConstantObject(TimesteppingTimeStepEnum)); parameters->AddObject(iomodel->CopyConstantObject(TimesteppingCflCoefficientEnum)); - parameters->AddObject(iomodel->CopyConstantObject(PrognosticHydrostaticAdjustmentEnum)); - parameters->AddObject(iomodel->CopyConstantObject(PrognosticStabilizationEnum)); + parameters->AddObject(iomodel->CopyConstantObject(MasstransportHydrostaticAdjustmentEnum)); + parameters->AddObject(iomodel->CopyConstantObject(MasstransportStabilizationEnum)); parameters->AddObject(iomodel->CopyConstantObject(DiagnosticPenaltyFactorEnum)); - parameters->AddObject(iomodel->CopyConstantObject(PrognosticMinThicknessEnum)); - parameters->AddObject(iomodel->CopyConstantObject(PrognosticPenaltyFactorEnum)); + parameters->AddObject(iomodel->CopyConstantObject(MasstransportMinThicknessEnum)); + parameters->AddObject(iomodel->CopyConstantObject(MasstransportPenaltyFactorEnum)); parameters->AddObject(iomodel->CopyConstantObject(ThermalPenaltyFactorEnum)); parameters->AddObject(iomodel->CopyConstantObject(SettingsLowmemEnum)); @@ -93,5 +93,5 @@ parameters->AddObject(iomodel->CopyConstantObject(GroundinglineMigrationEnum)); parameters->AddObject(iomodel->CopyConstantObject(TransientIsdiagnosticEnum)); - parameters->AddObject(iomodel->CopyConstantObject(TransientIsprognosticEnum)); + parameters->AddObject(iomodel->CopyConstantObject(TransientIsmasstransportEnum)); parameters->AddObject(iomodel->CopyConstantObject(TransientIsthermalEnum)); parameters->AddObject(iomodel->CopyConstantObject(TransientIsgroundinglineEnum)); @@ -162,8 +162,8 @@ iomodel->DeleteData(requestedoutputs,SteadystateRequestedOutputsEnum); - iomodel->FetchData(&requestedoutputs,&numoutputs,NULL,PrognosticRequestedOutputsEnum); - parameters->AddObject(new IntParam(PrognosticNumRequestedOutputsEnum,numoutputs)); - if(numoutputs)parameters->AddObject(new IntVecParam(PrognosticRequestedOutputsEnum,requestedoutputs,numoutputs)); - iomodel->DeleteData(requestedoutputs,PrognosticRequestedOutputsEnum); + iomodel->FetchData(&requestedoutputs,&numoutputs,NULL,MasstransportRequestedOutputsEnum); + parameters->AddObject(new IntParam(MasstransportNumRequestedOutputsEnum,numoutputs)); + if(numoutputs)parameters->AddObject(new IntVecParam(MasstransportRequestedOutputsEnum,requestedoutputs,numoutputs)); + iomodel->DeleteData(requestedoutputs,MasstransportRequestedOutputsEnum); /*Deal with mass flux segments: {{{*/ Index: /issm/trunk-jpl/src/c/modules/ModelProcessorx/DistributeNumDofs.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/ModelProcessorx/DistributeNumDofs.cpp (revision 15766) +++ /issm/trunk-jpl/src/c/modules/ModelProcessorx/DistributeNumDofs.cpp (revision 15767) @@ -100,5 +100,5 @@ numdofs=1; break; - case PrognosticAnalysisEnum: + case MasstransportAnalysisEnum: numdofs=1; break; Index: /issm/trunk-jpl/src/c/modules/ModelProcessorx/ElementsAndVerticesPartitioning.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/ModelProcessorx/ElementsAndVerticesPartitioning.cpp (revision 15766) +++ /issm/trunk-jpl/src/c/modules/ModelProcessorx/ElementsAndVerticesPartitioning.cpp (revision 15767) @@ -117,5 +117,5 @@ } xDelete(vertex_pairing); - iomodel->FetchData(&vertex_pairing,&numvertex_pairing,NULL,PrognosticVertexPairingEnum); + iomodel->FetchData(&vertex_pairing,&numvertex_pairing,NULL,MasstransportVertexPairingEnum); for(i=0;iConstant(&stabilization,MasstransportStabilizationEnum); + + /*Recover pointer: */ + Constraints* constraints=*pconstraints; + + /*Do not add constraints in DG, they are weakly imposed*/ + if(stabilization!=3){ + IoModelToConstraintsx(constraints,iomodel,MasstransportSpcthicknessEnum,MasstransportAnalysisEnum,P1Enum); + } + + /*Assign output pointer: */ + *pconstraints=constraints; +} Index: /issm/trunk-jpl/src/c/modules/ModelProcessorx/Masstransport/CreateLoadsMasstransport.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/ModelProcessorx/Masstransport/CreateLoadsMasstransport.cpp (revision 15767) +++ /issm/trunk-jpl/src/c/modules/ModelProcessorx/Masstransport/CreateLoadsMasstransport.cpp (revision 15767) @@ -0,0 +1,83 @@ +/*! \file CreateLoadsMasstransport.c: + */ + +#include "../../../toolkits/toolkits.h" +#include "../../../classes/classes.h" +#include "../../../shared/shared.h" +#include "../ModelProcessorx.h" + +void CreateLoadsMasstransport(Loads** ploads, IoModel* iomodel){ + + /*Intermediaries*/ + int element; + int penpair_ids[2]; + int count=0; + int stabilization; + int numvertex_pairing; + + /*Fetch parameters: */ + iomodel->Constant(&stabilization,MasstransportStabilizationEnum); + + /*Recover pointer: */ + Loads* loads=*ploads; + + /*Loads only in DG*/ + if (stabilization==3){ + + /*Get faces and elements*/ + CreateFaces(iomodel); + iomodel->FetchData(1,ThicknessEnum); + + /*First load data:*/ + for(int i=0;inumberoffaces;i++){ + + /*Get left and right elements*/ + element=iomodel->faces[4*i+2]-1; //faces are [node1 node2 elem1 elem2] + + /*Now, if this element is not in the partition, pass: */ + if(!iomodel->my_elements[element]) continue; + + /* Add load */ + loads->AddObject(new Numericalflux(iomodel->loadcounter+i+1,i,i,iomodel,MasstransportAnalysisEnum)); + } + + /*Free data: */ + iomodel->DeleteData(1,ThicknessEnum); + } + + /*Create Penpair for vertex_pairing: */ + IssmDouble *vertex_pairing=NULL; + IssmDouble *nodeonbed=NULL; + iomodel->FetchData(&vertex_pairing,&numvertex_pairing,NULL,MasstransportVertexPairingEnum); + iomodel->FetchData(&nodeonbed,NULL,NULL,MeshVertexonbedEnum); + + for(int i=0;imy_vertices[reCast(vertex_pairing[2*i+0])-1]){ + + /*In debugging mode, check that the second node is in the same cpu*/ + _assert_(iomodel->my_vertices[reCast(vertex_pairing[2*i+1])-1]); + + /*Skip if one of the two is not on the bed*/ + if(!(reCast(nodeonbed[reCast(vertex_pairing[2*i+0])-1])) || !(reCast(nodeonbed[reCast(vertex_pairing[2*i+1])-1]))) continue; + + /*Get node ids*/ + penpair_ids[0]=iomodel->nodecounter+reCast(vertex_pairing[2*i+0]); + penpair_ids[1]=iomodel->nodecounter+reCast(vertex_pairing[2*i+1]); + + /*Create Load*/ + loads->AddObject(new Penpair( + iomodel->loadcounter+count+1, + &penpair_ids[0], + MasstransportAnalysisEnum)); + count++; + } + } + + /*free ressources: */ + iomodel->DeleteData(vertex_pairing,MasstransportVertexPairingEnum); + iomodel->DeleteData(nodeonbed,MeshVertexonbedEnum); + + /*Assign output pointer: */ + *ploads=loads; +} Index: /issm/trunk-jpl/src/c/modules/ModelProcessorx/Masstransport/CreateNodesMasstransport.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/ModelProcessorx/Masstransport/CreateNodesMasstransport.cpp (revision 15767) +++ /issm/trunk-jpl/src/c/modules/ModelProcessorx/Masstransport/CreateNodesMasstransport.cpp (revision 15767) @@ -0,0 +1,29 @@ +/* + * CreateNodesMasstransport.c: + */ + +#include "../../../toolkits/toolkits.h" +#include "../../../classes/classes.h" +#include "../../../shared/shared.h" +#include "../../MeshPartitionx/MeshPartitionx.h" +#include "../ModelProcessorx.h" + +void CreateNodesMasstransport(Nodes** pnodes, IoModel* iomodel){ + + /*Fetch parameters: */ + int stabilization; + iomodel->Constant(&stabilization,MasstransportStabilizationEnum); + + /*Check in 3d*/ + if(stabilization==3 && iomodel->dim==3) _error_("DG 3d not implemented yet"); + + /*Create Nodes either DG or CG depending on stabilization*/ + iomodel->FetchData(5,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum); + if(stabilization!=3){ + CreateNodes(pnodes,iomodel,MasstransportAnalysisEnum,P1Enum); + } + else{ + CreateNodes(pnodes,iomodel,MasstransportAnalysisEnum,P1DGEnum); + } + iomodel->DeleteData(5,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum); +} Index: /issm/trunk-jpl/src/c/modules/ModelProcessorx/Masstransport/UpdateElementsMasstransport.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/ModelProcessorx/Masstransport/UpdateElementsMasstransport.cpp (revision 15767) +++ /issm/trunk-jpl/src/c/modules/ModelProcessorx/Masstransport/UpdateElementsMasstransport.cpp (revision 15767) @@ -0,0 +1,99 @@ +/* + * UpdateElementsMasstransport: + */ + +#include "../../../toolkits/toolkits.h" +#include "../../../classes/classes.h" +#include "../../../shared/shared.h" +#include "../../MeshPartitionx/MeshPartitionx.h" +#include "../ModelProcessorx.h" + +void UpdateElementsMasstransport(Elements* elements, IoModel* iomodel,int analysis_counter,int analysis_type){ + + int stabilization,finiteelement; + bool dakota_analysis; + bool issmbgradients; + bool ispdd; + bool isdelta18o; + + /*Fetch data needed: */ + iomodel->Constant(&stabilization,MasstransportStabilizationEnum); + iomodel->Constant(&dakota_analysis,QmuIsdakotaEnum); + iomodel->Constant(&ispdd,SurfaceforcingsIspddEnum); + iomodel->Constant(&isdelta18o,SurfaceforcingsIsdelta18oEnum); + iomodel->Constant(&issmbgradients,SurfaceforcingsIssmbgradientsEnum); + + /*Finite element type*/ + finiteelement = P1Enum; + if(stabilization==3){ + finiteelement = P1DGEnum; + } + + /*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); + counter++; + } + } + + iomodel->FetchDataToInput(elements,ThicknessEnum); + iomodel->FetchDataToInput(elements,SurfaceEnum); + iomodel->FetchDataToInput(elements,BedEnum); + iomodel->FetchDataToInput(elements,BathymetryEnum); + iomodel->FetchDataToInput(elements,MaskIcelevelsetEnum); + iomodel->FetchDataToInput(elements,MaskElementonfloatingiceEnum); + iomodel->FetchDataToInput(elements,BasalforcingsMeltingRateEnum); + iomodel->FetchDataToInput(elements,BasalforcingsMeltingRateCorrectionEnum); + iomodel->FetchDataToInput(elements,VxEnum); + iomodel->FetchDataToInput(elements,VyEnum); + + if(stabilization==3){ + iomodel->FetchDataToInput(elements,MasstransportSpcthicknessEnum); //for DG, we need the spc in the element + } + + if(dakota_analysis){ + elements->InputDuplicate(BedEnum,QmuBedEnum); + elements->InputDuplicate(ThicknessEnum,QmuThicknessEnum); + elements->InputDuplicate(SurfaceEnum,QmuSurfaceEnum); + elements->InputDuplicate(BasalforcingsMeltingRateEnum,QmuMeltingEnum); + elements->InputDuplicate(VxEnum,QmuVxEnum); + elements->InputDuplicate(VyEnum,QmuVyEnum); + } + + if(iomodel->dim==3){ + iomodel->FetchDataToInput(elements,MeshElementonbedEnum); + iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum); + iomodel->FetchDataToInput(elements,PressureEnum); + iomodel->FetchDataToInput(elements,TemperatureEnum); + iomodel->FetchDataToInput(elements,VzEnum); + if(dakota_analysis){ + elements->InputDuplicate(PressureEnum,QmuPressureEnum); + elements->InputDuplicate(TemperatureEnum,QmuTemperatureEnum); + elements->InputDuplicate(VzEnum,QmuVzEnum); + } + } + if(issmbgradients){ + iomodel->FetchDataToInput(elements,SurfaceforcingsHrefEnum); + iomodel->FetchDataToInput(elements,SurfaceforcingsSmbrefEnum); + iomodel->FetchDataToInput(elements,SurfaceforcingsBPosEnum); + iomodel->FetchDataToInput(elements,SurfaceforcingsBNegEnum); + } + if(ispdd){ + iomodel->FetchDataToInput(elements,ThermalSpctemperatureEnum); + if(isdelta18o){ + iomodel->FetchDataToInput(elements,SurfaceforcingsTemperaturesLgmEnum); + iomodel->FetchDataToInput(elements,SurfaceforcingsTemperaturesPresentdayEnum); + iomodel->FetchDataToInput(elements,SurfaceforcingsPrecipitationsPresentdayEnum); + } + else{ + iomodel->FetchDataToInput(elements,SurfaceforcingsPrecipitationEnum); + iomodel->FetchDataToInput(elements,SurfaceforcingsMonthlytemperaturesEnum); + } + } + if(~ispdd & ~issmbgradients){ + iomodel->FetchDataToInput(elements,SurfaceforcingsMassBalanceEnum); + } +} Index: /issm/trunk-jpl/src/c/modules/ModelProcessorx/ModelProcessorx.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/ModelProcessorx/ModelProcessorx.cpp (revision 15766) +++ /issm/trunk-jpl/src/c/modules/ModelProcessorx/ModelProcessorx.cpp (revision 15767) @@ -16,5 +16,5 @@ int i,analysis_type,verbose; - bool isthermal,isprognostic,isdiagnostic,isgroundingline,isenthalpy; + bool isthermal,ismasstransport,isdiagnostic,isgroundingline,isenthalpy; /*output: */ @@ -34,5 +34,5 @@ iomodel->Constant(&isthermal,TransientIsthermalEnum); iomodel->Constant(&isenthalpy,ThermalIsenthalpyEnum); - iomodel->Constant(&isprognostic,TransientIsprognosticEnum); + iomodel->Constant(&ismasstransport,TransientIsmasstransportEnum); iomodel->Constant(&isdiagnostic,TransientIsdiagnosticEnum); iomodel->Constant(&isgroundingline,TransientIsgroundinglineEnum); @@ -56,5 +56,5 @@ if(solution_type==TransientSolutionEnum && analysis_type==MeltingAnalysisEnum && isenthalpy==true) continue; if(solution_type==TransientSolutionEnum && analysis_type==EnthalpyAnalysisEnum && isenthalpy==false) continue; - if(solution_type==TransientSolutionEnum && analysis_type==PrognosticAnalysisEnum && isprognostic==false && isgroundingline==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; Index: /issm/trunk-jpl/src/c/modules/ModelProcessorx/ModelProcessorx.h =================================================================== --- /issm/trunk-jpl/src/c/modules/ModelProcessorx/ModelProcessorx.h (revision 15766) +++ /issm/trunk-jpl/src/c/modules/ModelProcessorx/ModelProcessorx.h (revision 15767) @@ -99,9 +99,9 @@ void UpdateElementsMelting(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type); -/*prognostic:*/ -void CreateNodesPrognostic(Nodes** pnodes,IoModel* iomodel); -void CreateConstraintsPrognostic(Constraints** pconstraints,IoModel* iomodel); -void CreateLoadsPrognostic(Loads** ploads, IoModel* iomodel); -void UpdateElementsPrognostic(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type); +/*masstransport:*/ +void CreateNodesMasstransport(Nodes** pnodes,IoModel* iomodel); +void CreateConstraintsMasstransport(Constraints** pconstraints,IoModel* iomodel); +void CreateLoadsMasstransport(Loads** ploads, IoModel* iomodel); +void UpdateElementsMasstransport(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type); /*balancedthickness:*/ Index: /issm/trunk-jpl/src/c/shared/Enum/EnumDefinitions.h =================================================================== --- /issm/trunk-jpl/src/c/shared/Enum/EnumDefinitions.h (revision 15766) +++ /issm/trunk-jpl/src/c/shared/Enum/EnumDefinitions.h (revision 15767) @@ -187,12 +187,12 @@ MeshZEnum, MiscellaneousNameEnum, //FIXME: only used by qmu, should not be marshalled (already in queueing script) - PrognosticHydrostaticAdjustmentEnum, - PrognosticMinThicknessEnum, - PrognosticPenaltyFactorEnum, - PrognosticSpcthicknessEnum, - PrognosticStabilizationEnum, - PrognosticVertexPairingEnum, - PrognosticNumRequestedOutputsEnum, - PrognosticRequestedOutputsEnum, + MasstransportHydrostaticAdjustmentEnum, + MasstransportMinThicknessEnum, + MasstransportPenaltyFactorEnum, + MasstransportSpcthicknessEnum, + MasstransportStabilizationEnum, + MasstransportVertexPairingEnum, + MasstransportNumRequestedOutputsEnum, + MasstransportRequestedOutputsEnum, QmuIsdakotaEnum, MassFluxSegmentsEnum, @@ -256,5 +256,5 @@ TransientIsdiagnosticEnum, TransientIsgroundinglineEnum, - TransientIsprognosticEnum, + TransientIsmasstransportEnum, TransientIsthermalEnum, TransientIsgiaEnum, @@ -293,6 +293,6 @@ HydrologySolutionEnum, MeltingAnalysisEnum, - PrognosticAnalysisEnum, - PrognosticSolutionEnum, + MasstransportAnalysisEnum, + MasstransportSolutionEnum, SteadystateSolutionEnum, SurfaceSlopeAnalysisEnum, Index: /issm/trunk-jpl/src/c/shared/Enum/EnumToStringx.cpp =================================================================== --- /issm/trunk-jpl/src/c/shared/Enum/EnumToStringx.cpp (revision 15766) +++ /issm/trunk-jpl/src/c/shared/Enum/EnumToStringx.cpp (revision 15767) @@ -195,12 +195,12 @@ case MeshZEnum : return "MeshZ"; case MiscellaneousNameEnum : return "MiscellaneousName"; - case PrognosticHydrostaticAdjustmentEnum : return "PrognosticHydrostaticAdjustment"; - case PrognosticMinThicknessEnum : return "PrognosticMinThickness"; - case PrognosticPenaltyFactorEnum : return "PrognosticPenaltyFactor"; - case PrognosticSpcthicknessEnum : return "PrognosticSpcthickness"; - case PrognosticStabilizationEnum : return "PrognosticStabilization"; - case PrognosticVertexPairingEnum : return "PrognosticVertexPairing"; - case PrognosticNumRequestedOutputsEnum : return "PrognosticNumRequestedOutputs"; - case PrognosticRequestedOutputsEnum : return "PrognosticRequestedOutputs"; + case MasstransportHydrostaticAdjustmentEnum : return "MasstransportHydrostaticAdjustment"; + case MasstransportMinThicknessEnum : return "MasstransportMinThickness"; + case MasstransportPenaltyFactorEnum : return "MasstransportPenaltyFactor"; + case MasstransportSpcthicknessEnum : return "MasstransportSpcthickness"; + case MasstransportStabilizationEnum : return "MasstransportStabilization"; + case MasstransportVertexPairingEnum : return "MasstransportVertexPairing"; + case MasstransportNumRequestedOutputsEnum : return "MasstransportNumRequestedOutputs"; + case MasstransportRequestedOutputsEnum : return "MasstransportRequestedOutputs"; case QmuIsdakotaEnum : return "QmuIsdakota"; case MassFluxSegmentsEnum : return "MassFluxSegments"; @@ -264,5 +264,5 @@ case TransientIsdiagnosticEnum : return "TransientIsdiagnostic"; case TransientIsgroundinglineEnum : return "TransientIsgroundingline"; - case TransientIsprognosticEnum : return "TransientIsprognostic"; + case TransientIsmasstransportEnum : return "TransientIsmasstransport"; case TransientIsthermalEnum : return "TransientIsthermal"; case TransientIsgiaEnum : return "TransientIsgia"; @@ -299,6 +299,6 @@ case HydrologySolutionEnum : return "HydrologySolution"; case MeltingAnalysisEnum : return "MeltingAnalysis"; - case PrognosticAnalysisEnum : return "PrognosticAnalysis"; - case PrognosticSolutionEnum : return "PrognosticSolution"; + case MasstransportAnalysisEnum : return "MasstransportAnalysis"; + case MasstransportSolutionEnum : return "MasstransportSolution"; case SteadystateSolutionEnum : return "SteadystateSolution"; case SurfaceSlopeAnalysisEnum : return "SurfaceSlopeAnalysis"; Index: /issm/trunk-jpl/src/c/shared/Enum/StringToEnumx.cpp =================================================================== --- /issm/trunk-jpl/src/c/shared/Enum/StringToEnumx.cpp (revision 15766) +++ /issm/trunk-jpl/src/c/shared/Enum/StringToEnumx.cpp (revision 15767) @@ -198,12 +198,12 @@ else if (strcmp(name,"MeshZ")==0) return MeshZEnum; else if (strcmp(name,"MiscellaneousName")==0) return MiscellaneousNameEnum; - else if (strcmp(name,"PrognosticHydrostaticAdjustment")==0) return PrognosticHydrostaticAdjustmentEnum; - else if (strcmp(name,"PrognosticMinThickness")==0) return PrognosticMinThicknessEnum; - else if (strcmp(name,"PrognosticPenaltyFactor")==0) return PrognosticPenaltyFactorEnum; - else if (strcmp(name,"PrognosticSpcthickness")==0) return PrognosticSpcthicknessEnum; - else if (strcmp(name,"PrognosticStabilization")==0) return PrognosticStabilizationEnum; - else if (strcmp(name,"PrognosticVertexPairing")==0) return PrognosticVertexPairingEnum; - else if (strcmp(name,"PrognosticNumRequestedOutputs")==0) return PrognosticNumRequestedOutputsEnum; - else if (strcmp(name,"PrognosticRequestedOutputs")==0) return PrognosticRequestedOutputsEnum; + else if (strcmp(name,"MasstransportHydrostaticAdjustment")==0) return MasstransportHydrostaticAdjustmentEnum; + else if (strcmp(name,"MasstransportMinThickness")==0) return MasstransportMinThicknessEnum; + else if (strcmp(name,"MasstransportPenaltyFactor")==0) return MasstransportPenaltyFactorEnum; + else if (strcmp(name,"MasstransportSpcthickness")==0) return MasstransportSpcthicknessEnum; + else if (strcmp(name,"MasstransportStabilization")==0) return MasstransportStabilizationEnum; + else if (strcmp(name,"MasstransportVertexPairing")==0) return MasstransportVertexPairingEnum; + else if (strcmp(name,"MasstransportNumRequestedOutputs")==0) return MasstransportNumRequestedOutputsEnum; + else if (strcmp(name,"MasstransportRequestedOutputs")==0) return MasstransportRequestedOutputsEnum; else if (strcmp(name,"QmuIsdakota")==0) return QmuIsdakotaEnum; else if (strcmp(name,"MassFluxSegments")==0) return MassFluxSegmentsEnum; @@ -270,5 +270,5 @@ else if (strcmp(name,"TransientIsdiagnostic")==0) return TransientIsdiagnosticEnum; else if (strcmp(name,"TransientIsgroundingline")==0) return TransientIsgroundinglineEnum; - else if (strcmp(name,"TransientIsprognostic")==0) return TransientIsprognosticEnum; + else if (strcmp(name,"TransientIsmasstransport")==0) return TransientIsmasstransportEnum; else if (strcmp(name,"TransientIsthermal")==0) return TransientIsthermalEnum; else if (strcmp(name,"TransientIsgia")==0) return TransientIsgiaEnum; @@ -305,6 +305,6 @@ else if (strcmp(name,"HydrologySolution")==0) return HydrologySolutionEnum; else if (strcmp(name,"MeltingAnalysis")==0) return MeltingAnalysisEnum; - else if (strcmp(name,"PrognosticAnalysis")==0) return PrognosticAnalysisEnum; - else if (strcmp(name,"PrognosticSolution")==0) return PrognosticSolutionEnum; + else if (strcmp(name,"MasstransportAnalysis")==0) return MasstransportAnalysisEnum; + else if (strcmp(name,"MasstransportSolution")==0) return MasstransportSolutionEnum; else if (strcmp(name,"SteadystateSolution")==0) return SteadystateSolutionEnum; else if (strcmp(name,"SurfaceSlopeAnalysis")==0) return SurfaceSlopeAnalysisEnum; Index: /issm/trunk-jpl/src/m/boundaryconditions/SetIceSheetBC.m =================================================================== --- /issm/trunk-jpl/src/m/boundaryconditions/SetIceSheetBC.m (revision 15766) +++ /issm/trunk-jpl/src/m/boundaryconditions/SetIceSheetBC.m (revision 15767) @@ -47,5 +47,5 @@ end -md.prognostic.spcthickness=NaN*ones(md.mesh.numberofvertices,1); +md.masstransport.spcthickness=NaN*ones(md.mesh.numberofvertices,1); md.balancethickness.spcthickness=NaN*ones(md.mesh.numberofvertices,1); Index: /issm/trunk-jpl/src/m/boundaryconditions/SetIceSheetBC.py =================================================================== --- /issm/trunk-jpl/src/m/boundaryconditions/SetIceSheetBC.py (revision 15766) +++ /issm/trunk-jpl/src/m/boundaryconditions/SetIceSheetBC.py (revision 15767) @@ -48,5 +48,5 @@ print " no balancethickness.thickening_rate specified: values set as zero" - md.prognostic.spcthickness=float('nan')*numpy.ones((md.mesh.numberofvertices,1)) + md.masstransport.spcthickness=float('nan')*numpy.ones((md.mesh.numberofvertices,1)) md.balancethickness.spcthickness=float('nan')*numpy.ones((md.mesh.numberofvertices,1)) Index: /issm/trunk-jpl/src/m/boundaryconditions/SetIceShelfBC.m =================================================================== --- /issm/trunk-jpl/src/m/boundaryconditions/SetIceShelfBC.m (revision 15766) +++ /issm/trunk-jpl/src/m/boundaryconditions/SetIceShelfBC.m (revision 15767) @@ -67,5 +67,5 @@ end -md.prognostic.spcthickness=NaN*ones(md.mesh.numberofvertices,1); +md.masstransport.spcthickness=NaN*ones(md.mesh.numberofvertices,1); md.balancethickness.spcthickness=NaN*ones(md.mesh.numberofvertices,1); Index: /issm/trunk-jpl/src/m/boundaryconditions/SetIceShelfBC.py =================================================================== --- /issm/trunk-jpl/src/m/boundaryconditions/SetIceShelfBC.py (revision 15766) +++ /issm/trunk-jpl/src/m/boundaryconditions/SetIceShelfBC.py (revision 15767) @@ -72,5 +72,5 @@ print " no balancethickness.thickening_rate specified: values set as zero" - md.prognostic.spcthickness=float('nan')*numpy.ones((md.mesh.numberofvertices,1)) + md.masstransport.spcthickness=float('nan')*numpy.ones((md.mesh.numberofvertices,1)) md.balancethickness.spcthickness=float('nan')*numpy.ones((md.mesh.numberofvertices,1)) Index: /issm/trunk-jpl/src/m/boundaryconditions/SetMarineIceSheetBC.m =================================================================== --- /issm/trunk-jpl/src/m/boundaryconditions/SetMarineIceSheetBC.m (revision 15766) +++ /issm/trunk-jpl/src/m/boundaryconditions/SetMarineIceSheetBC.m (revision 15767) @@ -78,5 +78,5 @@ end -md.prognostic.spcthickness=NaN*ones(md.mesh.numberofvertices,1); +md.masstransport.spcthickness=NaN*ones(md.mesh.numberofvertices,1); md.balancethickness.spcthickness=NaN*ones(md.mesh.numberofvertices,1); Index: /issm/trunk-jpl/src/m/boundaryconditions/SetMarineIceSheetBC.py =================================================================== --- /issm/trunk-jpl/src/m/boundaryconditions/SetMarineIceSheetBC.py (revision 15766) +++ /issm/trunk-jpl/src/m/boundaryconditions/SetMarineIceSheetBC.py (revision 15767) @@ -79,5 +79,5 @@ print " no balancethickness.thickening_rate specified: values set as zero" - md.prognostic.spcthickness=float('nan')*numpy.ones((md.mesh.numberofvertices,1)) + md.masstransport.spcthickness=float('nan')*numpy.ones((md.mesh.numberofvertices,1)) md.balancethickness.spcthickness=float('nan')*numpy.ones((md.mesh.numberofvertices,1)) Index: /issm/trunk-jpl/src/m/classes/basalforcings.m =================================================================== --- /issm/trunk-jpl/src/m/classes/basalforcings.m (revision 15766) +++ /issm/trunk-jpl/src/m/classes/basalforcings.m (revision 15767) @@ -24,5 +24,5 @@ function md = checkconsistency(obj,md,solution,analyses) % {{{ - if ismember(PrognosticAnalysisEnum(),analyses) & ~(solution==TransientSolutionEnum() & md.transient.isprognostic==0), + if ismember(MasstransportAnalysisEnum(),analyses) & ~(solution==TransientSolutionEnum() & md.transient.ismasstransport==0), md = checkfield(md,'basalforcings.melting_rate','NaN',1,'forcing',1); end Index: /issm/trunk-jpl/src/m/classes/basalforcings.py =================================================================== --- /issm/trunk-jpl/src/m/classes/basalforcings.py (revision 15766) +++ /issm/trunk-jpl/src/m/classes/basalforcings.py (revision 15767) @@ -35,5 +35,5 @@ def checkconsistency(self,md,solution,analyses): # {{{ - if PrognosticAnalysisEnum() in analyses and not (solution==TransientSolutionEnum() and not md.transient.isprognostic): + if MasstransportAnalysisEnum() in analyses and not (solution==TransientSolutionEnum() and not md.transient.ismasstransport): md = checkfield(md,'basalforcings.melting_rate','NaN',1,'forcing',1) Index: /issm/trunk-jpl/src/m/classes/gia.m =================================================================== --- /issm/trunk-jpl/src/m/classes/gia.m (revision 15766) +++ /issm/trunk-jpl/src/m/classes/gia.m (revision 15767) @@ -29,12 +29,12 @@ md = checkfield(md,'gia.cross_section_shape','numel',[1],'values',[1,2]); - %be sure that if we are running a prognostic ice flow model coupled with gia, that thickness forcings + %be sure that if we are running a masstransport ice flow model coupled with gia, that thickness forcings %are not provided into the future. - if solution==TransientSolutionEnum() & md.transient.isprognostic & md.transient.isgia, + if solution==TransientSolutionEnum() & md.transient.ismasstransport & md.transient.isgia, %figure out if thickness is a transient forcing: if size(md.geometry.thickness,1)==md.mesh.numberofvertices+1, %recover the furthest time "in time": if(thickness(end,end)~=md.timestepping.start_time), - md = checkmessage(md,['if isprognostic is on, transient thickness forcing'... + md = checkmessage(md,['if ismasstransport is on, transient thickness forcing'... ' for the gia model should not be provided in the future.'... ' Synchronize your start_time to correspond to the most recent transient'... Index: /issm/trunk-jpl/src/m/classes/gia.py =================================================================== --- /issm/trunk-jpl/src/m/classes/gia.py (revision 15766) +++ /issm/trunk-jpl/src/m/classes/gia.py (revision 15767) @@ -46,5 +46,5 @@ md = checkfield(md,'gia.cross_section_shape','numel',[1],'values',[1,2]) - #be sure that if we are running a prognostic ice flow model coupled with gia, that thickness forcings + #be sure that if we are running a masstransport ice flow model coupled with gia, that thickness forcings #are not provided into the future. Index: /issm/trunk-jpl/src/m/classes/initialization.m =================================================================== --- /issm/trunk-jpl/src/m/classes/initialization.m (revision 15766) +++ /issm/trunk-jpl/src/m/classes/initialization.m (revision 15767) @@ -36,5 +36,5 @@ end end - if ismember(PrognosticAnalysisEnum(),analyses), + if ismember(MasstransportAnalysisEnum(),analyses), md = checkfield(md,'initialization.vx','NaN',1,'size',[md.mesh.numberofvertices 1]); md = checkfield(md,'initialization.vy','NaN',1,'size',[md.mesh.numberofvertices 1]); Index: /issm/trunk-jpl/src/m/classes/initialization.py =================================================================== --- /issm/trunk-jpl/src/m/classes/initialization.py (revision 15766) +++ /issm/trunk-jpl/src/m/classes/initialization.py (revision 15767) @@ -52,5 +52,5 @@ md = checkfield(md,'initialization.vx','NaN',1,'size',[md.mesh.numberofvertices]) md = checkfield(md,'initialization.vy','NaN',1,'size',[md.mesh.numberofvertices]) - if PrognosticAnalysisEnum() in analyses: + if MasstransportAnalysisEnum() in analyses: md = checkfield(md,'initialization.vx','NaN',1,'size',[md.mesh.numberofvertices]) md = checkfield(md,'initialization.vy','NaN',1,'size',[md.mesh.numberofvertices]) Index: /issm/trunk-jpl/src/m/classes/masstransport.m =================================================================== --- /issm/trunk-jpl/src/m/classes/masstransport.m (revision 15767) +++ /issm/trunk-jpl/src/m/classes/masstransport.m (revision 15767) @@ -0,0 +1,76 @@ +%MASSTRANSPORT class definition +% +% Usage: +% masstransport=masstransport(); + +classdef masstransport + properties (SetAccess=public) + spcthickness = NaN; + min_thickness = 0; + hydrostatic_adjustment = 0; + stabilization = 0; + vertex_pairing = NaN; + penalty_factor = 0; + requested_outputs = NaN; + end + methods + function obj = masstransport(varargin) % {{{ + switch nargin + case 0 + obj=setdefaultparameters(obj); + otherwise + error('constructor not supported'); + end + end % }}} + function obj = setdefaultparameters(obj) % {{{ + + %Type of stabilization to use 0:nothing 1:artificial_diffusivity 3:Discontinuous Galerkin + obj.stabilization=1; + + %Factor applied to compute the penalties kappa=max(stiffness matrix)*10^penalty_factor + obj.penalty_factor=3; + + %Minimum ice thickness that can be used + obj.min_thickness=1; + + %Hydrostatic adjustment + obj.hydrostatic_adjustment='Absolute'; + end % }}} + function md = checkconsistency(obj,md,solution,analyses) % {{{ + + %Early return + if ~ismember(MasstransportAnalysisEnum(),analyses) | (solution==TransientSolutionEnum() & md.transient.ismasstransport==0), return; end + + md = checkfield(md,'masstransport.spcthickness','forcing',1); + md = checkfield(md,'masstransport.hydrostatic_adjustment','values',{'Absolute' 'Incremental'}); + md = checkfield(md,'masstransport.stabilization','values',[0 1 2 3]); + md = checkfield(md,'masstransport.min_thickness','>',0); + if ~isempty(md.masstransport.requested_outputs), + md = checkfield(md,'masstransport.requested_outputs','size',[NaN 1]); + end + + end % }}} + function disp(obj) % {{{ + disp(sprintf(' Masstransport solution parameters:')); + fielddisplay(obj,'spcthickness','thickness constraints (NaN means no constraint) [m]'); + fielddisplay(obj,'min_thickness','minimum ice thickness allowed [m]'); + fielddisplay(obj,'hydrostatic_adjustment','adjustment of ice shelves surface and bed elevations: ''Incremental'' or ''Absolute'' '); + fielddisplay(obj,'stabilization','0: no, 1: artificial_diffusivity, 2: streamline upwinding, 3: discontinuous Galerkin'); + + disp(sprintf('\n %s','Penalty options:')); + fielddisplay(obj,'penalty_factor','offset used by penalties: penalty = Kmax*10^offset'); + fielddisplay(obj,'vertex_pairing','pairs of vertices that are penalized'); + fielddisplay(obj,'requested_outputs','additional outputs requested'); + + end % }}} + function marshall(obj,md,fid) % {{{ + WriteData(fid,'object',obj,'fieldname','spcthickness','format','DoubleMat','mattype',1,'forcinglength',md.mesh.numberofvertices+1); + WriteData(fid,'object',obj,'fieldname','min_thickness','format','Double'); + WriteData(fid,'data',StringToEnum(obj.hydrostatic_adjustment),'format','Integer','enum',MasstransportHydrostaticAdjustmentEnum()); + WriteData(fid,'object',obj,'fieldname','stabilization','format','Integer'); + WriteData(fid,'object',obj,'fieldname','vertex_pairing','format','DoubleMat','mattype',3); + WriteData(fid,'object',obj,'fieldname','penalty_factor','format','Double'); + WriteData(fid,'object',obj,'fieldname','requested_outputs','format','DoubleMat','mattype',3); + end % }}} + end +end Index: /issm/trunk-jpl/src/m/classes/masstransport.py =================================================================== --- /issm/trunk-jpl/src/m/classes/masstransport.py (revision 15767) +++ /issm/trunk-jpl/src/m/classes/masstransport.py (revision 15767) @@ -0,0 +1,77 @@ +from fielddisplay import fielddisplay +from EnumDefinitions import * +from StringToEnum import StringToEnum +from checkfield import * +from WriteData import * + +class masstransport(object): + """ + MASSTRANSPORT class definition + + Usage: + masstransport=masstransport(); + """ + + def __init__(self): # {{{ + self.spcthickness = float('NaN') + self.min_thickness = 0 + self.hydrostatic_adjustment = 0 + self.stabilization = 0 + self.vertex_pairing = float('NaN') + self.penalty_factor = 0 + self.requested_outputs = float('NaN') + + #set defaults + self.setdefaultparameters() + + #}}} + def __repr__(self): # {{{ + string=' Masstransport solution parameters:' + string="%s\n%s"%(string,fielddisplay(self,'spcthickness','thickness constraints (NaN means no constraint) [m]')) + string="%s\n%s"%(string,fielddisplay(self,'min_thickness','minimum ice thickness allowed [m]')) + string="%s\n%s"%(string,fielddisplay(self,'hydrostatic_adjustment','adjustment of ice shelves surface and bed elevations: ''Incremental'' or ''Absolute'' ')) + string="%s\n%s"%(string,fielddisplay(self,'stabilization','0: no, 1: artificial_diffusivity, 2: streamline upwinding, 3: discontinuous Galerkin')) + string="%s\n%s"%(string,fielddisplay(self,'requested_outputs','additional outputs requested')) + + return string + #}}} + def setdefaultparameters(self): # {{{ + + #Type of stabilization to use 0:nothing 1:artificial_diffusivity 3:Discontinuous Galerkin + self.stabilization=1 + + #Factor applied to compute the penalties kappa=max(stiffness matrix)*10^penalty_factor + self.penalty_factor=3 + + #Minimum ice thickness that can be used + self.min_thickness=1 + + #Hydrostatic adjustment + self.hydrostatic_adjustment='Absolute' + + return self + #}}} + def checkconsistency(self,md,solution,analyses): # {{{ + + #Early return + if (MasstransportAnalysisEnum() not in analyses) or (solution==TransientSolutionEnum() and not md.transient.ismasstransport): + return md + + md = checkfield(md,'masstransport.spcthickness','forcing',1) + md = checkfield(md,'masstransport.hydrostatic_adjustment','values',['Absolute','Incremental']) + md = checkfield(md,'masstransport.stabilization','values',[0,1,2,3]) + md = checkfield(md,'masstransport.min_thickness','>',0) + if not md.masstransport.requested_outputs: + md = checkfield(md,'masstransport.requested_outputs','size',[float('NaN'),1]) + + return md + # }}} + def marshall(self,md,fid): # {{{ + WriteData(fid,'object',self,'fieldname','spcthickness','format','DoubleMat','mattype',1,'forcinglength',md.mesh.numberofvertices+1) + WriteData(fid,'object',self,'fieldname','min_thickness','format','Double') + WriteData(fid,'data',StringToEnum(self.hydrostatic_adjustment)[0],'format','Integer','enum',MasstransportHydrostaticAdjustmentEnum()) + WriteData(fid,'object',self,'fieldname','stabilization','format','Integer') + WriteData(fid,'object',self,'fieldname','vertex_pairing','format','DoubleMat','mattype',3) + WriteData(fid,'object',self,'fieldname','penalty_factor','format','Double') + WriteData(fid,'object',self,'fieldname','requested_outputs','format','DoubleMat','mattype',3); + # }}} Index: /issm/trunk-jpl/src/m/classes/mesh.m =================================================================== --- /issm/trunk-jpl/src/m/classes/mesh.m (revision 15766) +++ /issm/trunk-jpl/src/m/classes/mesh.m (revision 15767) @@ -112,6 +112,6 @@ %Solution specific checks switch(solution), - case PrognosticSolutionEnum(), - if md.prognostic.stabilization==3, + case MasstransportSolutionEnum(), + if md.masstransport.stabilization==3, md = checkfield(md,'mesh.dimension','values',2,'message','Discontinuous Galerkin only supported for 2d meshes'); end @@ -121,5 +121,5 @@ end case TransientSolutionEnum(), - if md.transient.isprognostic & md.prognostic.stabilization==3, + if md.transient.ismasstransport & md.masstransport.stabilization==3, md = checkfield(md,'mesh.dimension','values',2,'message','Discontinuous Galerkin only supported for 2d meshes'); end Index: /issm/trunk-jpl/src/m/classes/mesh.py =================================================================== --- /issm/trunk-jpl/src/m/classes/mesh.py (revision 15766) +++ /issm/trunk-jpl/src/m/classes/mesh.py (revision 15767) @@ -149,6 +149,6 @@ #Solution specific checks - if solution==PrognosticSolutionEnum(): - if md.prognostic.stabilization==3: + if solution==MasstransportSolutionEnum(): + if md.masstransport.stabilization==3: md = checkfield(md,'mesh.dimension','values',2,'message',"Discontinuous Galerkin only supported for 2d meshes") elif solution==BalancethicknessSolutionEnum(): @@ -156,5 +156,5 @@ md = checkfield(md,'mesh.dimension','values',2,'message',"Discontinuous Galerkin only supported for 2d meshes") elif solution==TransientSolutionEnum(): - if md.transient.isprognostic and md.prognostic.stabilization==3: + if md.transient.ismasstransport and md.masstransport.stabilization==3: md = checkfield(md,'mesh.dimension','values',2,'message',"Discontinuous Galerkin only supported for 2d meshes") elif solution==ThermalSolutionEnum(): Index: /issm/trunk-jpl/src/m/classes/model/model.m =================================================================== --- /issm/trunk-jpl/src/m/classes/model/model.m (revision 15766) +++ /issm/trunk-jpl/src/m/classes/model/model.m (revision 15767) @@ -32,5 +32,5 @@ groundingline = 0; hydrology = 0; - prognostic = 0; + masstransport = 0; thermal = 0; steadystate = 0; @@ -92,15 +92,12 @@ md.hydrology=hydrologyshreve(md.materials); end - %2013 Juli 25th + %2013 July 25th if isa(md.diagnostic,'diagnostic'), disp('Recovering old stressbalance class'); icefront = md.diagnostic.icefront; md.diagnostic=stressbalance(md.diagnostic); - - %Deal with front md.mask.icelevelset=ones(md.mesh.numberofvertices,1); md.mask.icelevelset(icefront(:,1:end-2))=0; end - end% }}} end @@ -192,5 +189,5 @@ md.diagnostic.referential=project2d(md,md.diagnostic.referential,md.mesh.numberoflayers); md.diagnostic.loadingforce=project2d(md,md.diagnostic.loadingforce,md.mesh.numberoflayers); - md.prognostic.spcthickness=project2d(md,md.prognostic.spcthickness,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); @@ -451,9 +448,9 @@ md2.diagnostic.vertex_pairing=md2.diagnostic.vertex_pairing(find(md2.diagnostic.vertex_pairing(:,1)),:); end - if ~isnan(md2.prognostic.vertex_pairing), - for i=1:size(md1.prognostic.vertex_pairing,1); - md2.prognostic.vertex_pairing(i,:)=Pnode(md1.prognostic.vertex_pairing(i,:)); + if ~isnan(md2.masstransport.vertex_pairing), + for i=1:size(md1.masstransport.vertex_pairing,1); + md2.masstransport.vertex_pairing(i,:)=Pnode(md1.masstransport.vertex_pairing(i,:)); end - md2.prognostic.vertex_pairing=md2.prognostic.vertex_pairing(find(md2.prognostic.vertex_pairing(:,1)),:); + md2.masstransport.vertex_pairing=md2.masstransport.vertex_pairing(find(md2.masstransport.vertex_pairing(:,1)),:); end @@ -718,5 +715,5 @@ md.diagnostic.spcvz=project3d(md,'vector',md.diagnostic.spcvz,'type','node'); md.thermal.spctemperature=project3d(md,'vector',md.thermal.spctemperature,'type','node','layer',md.mesh.numberoflayers,'padding',NaN); - md.prognostic.spcthickness=project3d(md,'vector',md.prognostic.spcthickness,'type','node'); + md.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'); @@ -845,9 +842,9 @@ if isfield(structmd,'time_adapt'), md.timestepping.time_adapt=structmd.time_adapt; end if isfield(structmd,'cfl_coefficient'), md.timestepping.cfl_coefficient=structmd.cfl_coefficient; end - if isfield(structmd,'spcthickness'), md.prognostic.spcthickness=structmd.spcthickness; end - if isfield(structmd,'artificial_diffusivity'), md.prognostic.stabilization=structmd.artificial_diffusivity; end - if isfield(structmd,'hydrostatic_adjustment'), md.prognostic.hydrostatic_adjustment=structmd.hydrostatic_adjustment; end - if isfield(structmd,'penalties'), md.prognostic.vertex_pairing=structmd.penalties; end - if isfield(structmd,'penalty_offset'), md.prognostic.penalty_factor=structmd.penalty_offset; end + if isfield(structmd,'spcthickness'), md.masstransport.spcthickness=structmd.spcthickness; end + if isfield(structmd,'artificial_diffusivity'), md.masstransport.stabilization=structmd.artificial_diffusivity; end + if isfield(structmd,'hydrostatic_adjustment'), md.masstransport.hydrostatic_adjustment=structmd.hydrostatic_adjustment; end + if isfield(structmd,'penalties'), md.masstransport.vertex_pairing=structmd.penalties; end + if isfield(structmd,'penalty_offset'), md.masstransport.penalty_factor=structmd.penalty_offset; end if isfield(structmd,'B'), md.materials.rheology_B=structmd.B; end if isfield(structmd,'n'), md.materials.rheology_n=structmd.n; end @@ -868,5 +865,5 @@ 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,'isprognostic'), md.transient.isprognostic=structmd.isprognostic; end + if isfield(structmd,'ismasstransport'), md.transient.ismasstransport=structmd.ismasstransport; end if isfield(structmd,'isthermal'), md.transient.isthermal=structmd.isthermal; end if isfield(structmd,'control_analysis'), md.inversion.iscontrol=structmd.control_analysis; end @@ -1025,12 +1022,12 @@ if isfield(structmd,'artificial_diffusivity') & structmd.artificial_diffusivity==2, md.thermal.stabilization=2; - md.prognostic.stabilization=1; + md.masstransport.stabilization=1; md.balancethickness.stabilization=1; end - if isnumeric(md.prognostic.hydrostatic_adjustment) - if md.prognostic.hydrostatic_adjustment==269, - md.prognostic.hydrostatic_adjustment='Incremental'; + if isnumeric(md.masstransport.hydrostatic_adjustment) + if md.masstransport.hydrostatic_adjustment==269, + md.masstransport.hydrostatic_adjustment='Incremental'; else - md.prognostic.hydrostatic_adjustment='Absolute'; + md.masstransport.hydrostatic_adjustment='Absolute'; end end @@ -1078,5 +1075,5 @@ md.diagnostic = stressbalance(); md.hydrology = hydrologyshreve(); - md.prognostic = prognostic(); + md.masstransport = masstransport(); md.thermal = thermal(); md.steadystate = steadystate(); @@ -1115,5 +1112,5 @@ 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')); - disp(sprintf('%19s: %-22s -- %s','prognostic' ,['[1x1 ' class(obj.prognostic) ']'],'parameters for prognostic solution')); + disp(sprintf('%19s: %-22s -- %s','masstransport' ,['[1x1 ' class(obj.masstransport) ']'],'parameters for masstransport solution')); disp(sprintf('%19s: %-22s -- %s','thermal' ,['[1x1 ' class(obj.thermal) ']'],'parameters for thermal solution')); disp(sprintf('%19s: %-22s -- %s','steadystate' ,['[1x1 ' class(obj.steadystate) ']'],'parameters for steadystate solution')); Index: /issm/trunk-jpl/src/m/classes/model/model.py =================================================================== --- /issm/trunk-jpl/src/m/classes/model/model.py (revision 15766) +++ /issm/trunk-jpl/src/m/classes/model/model.py (revision 15767) @@ -24,5 +24,5 @@ from groundingline import groundingline from hydrologyshreve import hydrologyshreve -from prognostic import prognostic +from masstransport import masstransport from thermal import thermal from steadystate import steadystate @@ -75,5 +75,5 @@ self.groundingline = groundingline() self.hydrology = hydrologyshreve() - self.prognostic = prognostic() + self.masstransport = masstransport() self.thermal = thermal() self.steadystate = steadystate() @@ -114,5 +114,5 @@ 'groundingline',\ 'hydrology',\ - 'prognostic',\ + 'masstransport',\ 'thermal',\ 'steadystate',\ @@ -151,5 +151,5 @@ 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")) - string="%s\n%s" % (string,"%19s: %-22s -- %s" % ("prognostic","[%s,%s]" % ("1x1",obj.prognostic.__class__.__name__),"parameters for prognostic solution")) + string="%s\n%s" % (string,"%19s: %-22s -- %s" % ("masstransport","[%s,%s]" % ("1x1",obj.masstransport.__class__.__name__),"parameters for masstransport solution")) string="%s\n%s" % (string,"%19s: %-22s -- %s" % ("thermal","[%s,%s]" % ("1x1",obj.thermal.__class__.__name__),"parameters for thermal solution")) string="%s\n%s" % (string,"%19s: %-22s -- %s" % ("steadystate","[%s,%s]" % ("1x1",obj.steadystate.__class__.__name__),"parameters for steadystate solution")) @@ -348,8 +348,8 @@ 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.prognostic.vertex_pairing))): - for i in xrange(numpy.size(md1.prognostic.vertex_pairing,axis=0)): - md2.prognostic.vertex_pairing[i,:]=Pnode[md1.prognostic.vertex_pairing[i,:]] - md2.prognostic.vertex_pairing=md2.prognostic.vertex_pairing[numpy.nonzero(md2.prognostic.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)): + md2.masstransport.vertex_pairing[i,:]=Pnode[md1.masstransport.vertex_pairing[i,:]] + md2.masstransport.vertex_pairing=md2.masstransport.vertex_pairing[numpy.nonzero(md2.masstransport.vertex_pairing[:,0])[0],:] #recreate segments @@ -612,5 +612,5 @@ md.diagnostic.spcvz=project3d(md,'vector',md.diagnostic.spcvz,'type','node') md.thermal.spctemperature=project3d(md,'vector',md.thermal.spctemperature,'type','node','layer',md.mesh.numberoflayers,'padding',float('NaN')) - md.prognostic.spcthickness=project3d(md,'vector',md.prognostic.spcthickness,'type','node') + 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') Index: /issm/trunk-jpl/src/m/classes/model/planet.m =================================================================== --- /issm/trunk-jpl/src/m/classes/model/planet.m (revision 15766) +++ /issm/trunk-jpl/src/m/classes/model/planet.m (revision 15767) @@ -47,5 +47,5 @@ md.diagnostic = diagnostic(); md.hydrology = hydrology(); - md.prognostic = prognostic(); + md.masstransport = masstransport(); md.thermal = thermal(); md.steadystate = steadystate(); Index: /issm/trunk-jpl/src/m/classes/modellist.m =================================================================== --- /issm/trunk-jpl/src/m/classes/modellist.m (revision 15766) +++ /issm/trunk-jpl/src/m/classes/modellist.m (revision 15767) @@ -214,5 +214,5 @@ % obj=solve(obj,varargin) % where varargin is a lit of paired arguments. - % arguments can be: 'analysis_type': 'diagnostic','thermal','prognostic','transient' + % arguments can be: 'analysis_type': 'diagnostic','thermal','masstransport','transient' % % Examples: Index: /issm/trunk-jpl/src/m/classes/oldclasses/prognostic.m =================================================================== --- /issm/trunk-jpl/src/m/classes/oldclasses/prognostic.m (revision 15767) +++ /issm/trunk-jpl/src/m/classes/oldclasses/prognostic.m (revision 15767) @@ -0,0 +1,76 @@ +%MASSTRANSPORT class definition +% +% Usage: +% prognostic=prognostic(); + +classdef prognostic + properties (SetAccess=public) + spcthickness = NaN; + min_thickness = 0; + hydrostatic_adjustment = 0; + stabilization = 0; + vertex_pairing = NaN; + penalty_factor = 0; + requested_outputs = NaN; + end + methods + function obj = prognostic(varargin) % {{{ + switch nargin + case 0 + obj=setdefaultparameters(obj); + otherwise + error('constructor not supported'); + end + end % }}} + function obj = setdefaultparameters(obj) % {{{ + + %Type of stabilization to use 0:nothing 1:artificial_diffusivity 3:Discontinuous Galerkin + obj.stabilization=1; + + %Factor applied to compute the penalties kappa=max(stiffness matrix)*10^penalty_factor + obj.penalty_factor=3; + + %Minimum ice thickness that can be used + obj.min_thickness=1; + + %Hydrostatic adjustment + obj.hydrostatic_adjustment='Absolute'; + end % }}} + function md = checkconsistency(obj,md,solution,analyses) % {{{ + + %Early return + if ~ismember(PrognosticAnalysisEnum(),analyses) | (solution==TransientSolutionEnum() & md.transient.isprognostic==0), return; end + + md = checkfield(md,'prognostic.spcthickness','forcing',1); + md = checkfield(md,'prognostic.hydrostatic_adjustment','values',{'Absolute' 'Incremental'}); + md = checkfield(md,'prognostic.stabilization','values',[0 1 2 3]); + md = checkfield(md,'prognostic.min_thickness','>',0); + if ~isempty(md.prognostic.requested_outputs), + md = checkfield(md,'prognostic.requested_outputs','size',[NaN 1]); + end + + end % }}} + function disp(obj) % {{{ + disp(sprintf(' Prognostic solution parameters:')); + fielddisplay(obj,'spcthickness','thickness constraints (NaN means no constraint) [m]'); + fielddisplay(obj,'min_thickness','minimum ice thickness allowed [m]'); + fielddisplay(obj,'hydrostatic_adjustment','adjustment of ice shelves surface and bed elevations: ''Incremental'' or ''Absolute'' '); + fielddisplay(obj,'stabilization','0: no, 1: artificial_diffusivity, 2: streamline upwinding, 3: discontinuous Galerkin'); + + disp(sprintf('\n %s','Penalty options:')); + fielddisplay(obj,'penalty_factor','offset used by penalties: penalty = Kmax*10^offset'); + fielddisplay(obj,'vertex_pairing','pairs of vertices that are penalized'); + fielddisplay(obj,'requested_outputs','additional outputs requested'); + + end % }}} + function marshall(obj,md,fid) % {{{ + WriteData(fid,'object',obj,'fieldname','spcthickness','format','DoubleMat','mattype',1,'forcinglength',md.mesh.numberofvertices+1); + WriteData(fid,'object',obj,'fieldname','min_thickness','format','Double'); + WriteData(fid,'data',StringToEnum(obj.hydrostatic_adjustment),'format','Integer','enum',PrognosticHydrostaticAdjustmentEnum()); + WriteData(fid,'object',obj,'fieldname','stabilization','format','Integer'); + WriteData(fid,'object',obj,'fieldname','vertex_pairing','format','DoubleMat','mattype',3); + WriteData(fid,'object',obj,'fieldname','penalty_factor','format','Double'); + WriteData(fid,'object',obj,'fieldname','requested_outputs','format','DoubleMat','mattype',3); + end % }}} + end +end Index: /issm/trunk-jpl/src/m/classes/planetmesh.m =================================================================== --- /issm/trunk-jpl/src/m/classes/planetmesh.m (revision 15766) +++ /issm/trunk-jpl/src/m/classes/planetmesh.m (revision 15767) @@ -70,10 +70,10 @@ %Solution specific checks switch(solution), - case PrognosticSolutionEnum(), - if md.prognostic.stabilization==3, + case MasstransportSolutionEnum(), + if md.masstransport.stabilization==3, md = checkfield(md,'planetmesh.dimension','values',2,'message','Discontinuous Galerkin only supported for 2d planetmeshes'); end case TransientSolutionEnum(), - if md.transient.isprognostic & md.prognostic.stabilization==3, + if md.transient.ismasstransport & md.masstransport.stabilization==3, md = checkfield(md,'planetmesh.dimension','values',2,'message','Discontinuous Galerkin only supported for 2d planetmeshes'); end Index: sm/trunk-jpl/src/m/classes/prognostic.m =================================================================== --- /issm/trunk-jpl/src/m/classes/prognostic.m (revision 15766) +++ (revision ) @@ -1,76 +1,0 @@ -%PROGNOSTIC class definition -% -% Usage: -% prognostic=prognostic(); - -classdef prognostic - properties (SetAccess=public) - spcthickness = NaN; - min_thickness = 0; - hydrostatic_adjustment = 0; - stabilization = 0; - vertex_pairing = NaN; - penalty_factor = 0; - requested_outputs = NaN; - end - methods - function obj = prognostic(varargin) % {{{ - switch nargin - case 0 - obj=setdefaultparameters(obj); - otherwise - error('constructor not supported'); - end - end % }}} - function obj = setdefaultparameters(obj) % {{{ - - %Type of stabilization to use 0:nothing 1:artificial_diffusivity 3:Discontinuous Galerkin - obj.stabilization=1; - - %Factor applied to compute the penalties kappa=max(stiffness matrix)*10^penalty_factor - obj.penalty_factor=3; - - %Minimum ice thickness that can be used - obj.min_thickness=1; - - %Hydrostatic adjustment - obj.hydrostatic_adjustment='Absolute'; - end % }}} - function md = checkconsistency(obj,md,solution,analyses) % {{{ - - %Early return - if ~ismember(PrognosticAnalysisEnum(),analyses) | (solution==TransientSolutionEnum() & md.transient.isprognostic==0), return; end - - md = checkfield(md,'prognostic.spcthickness','forcing',1); - md = checkfield(md,'prognostic.hydrostatic_adjustment','values',{'Absolute' 'Incremental'}); - md = checkfield(md,'prognostic.stabilization','values',[0 1 2 3]); - md = checkfield(md,'prognostic.min_thickness','>',0); - if ~isempty(md.prognostic.requested_outputs), - md = checkfield(md,'prognostic.requested_outputs','size',[NaN 1]); - end - - end % }}} - function disp(obj) % {{{ - disp(sprintf(' Prognostic solution parameters:')); - fielddisplay(obj,'spcthickness','thickness constraints (NaN means no constraint) [m]'); - fielddisplay(obj,'min_thickness','minimum ice thickness allowed [m]'); - fielddisplay(obj,'hydrostatic_adjustment','adjustment of ice shelves surface and bed elevations: ''Incremental'' or ''Absolute'' '); - fielddisplay(obj,'stabilization','0: no, 1: artificial_diffusivity, 2: streamline upwinding, 3: discontinuous Galerkin'); - - disp(sprintf('\n %s','Penalty options:')); - fielddisplay(obj,'penalty_factor','offset used by penalties: penalty = Kmax*10^offset'); - fielddisplay(obj,'vertex_pairing','pairs of vertices that are penalized'); - fielddisplay(obj,'requested_outputs','additional outputs requested'); - - end % }}} - function marshall(obj,md,fid) % {{{ - WriteData(fid,'object',obj,'fieldname','spcthickness','format','DoubleMat','mattype',1,'forcinglength',md.mesh.numberofvertices+1); - WriteData(fid,'object',obj,'fieldname','min_thickness','format','Double'); - WriteData(fid,'data',StringToEnum(obj.hydrostatic_adjustment),'format','Integer','enum',PrognosticHydrostaticAdjustmentEnum()); - WriteData(fid,'object',obj,'fieldname','stabilization','format','Integer'); - WriteData(fid,'object',obj,'fieldname','vertex_pairing','format','DoubleMat','mattype',3); - WriteData(fid,'object',obj,'fieldname','penalty_factor','format','Double'); - WriteData(fid,'object',obj,'fieldname','requested_outputs','format','DoubleMat','mattype',3); - end % }}} - end -end Index: sm/trunk-jpl/src/m/classes/prognostic.py =================================================================== --- /issm/trunk-jpl/src/m/classes/prognostic.py (revision 15766) +++ (revision ) @@ -1,77 +1,0 @@ -from fielddisplay import fielddisplay -from EnumDefinitions import * -from StringToEnum import StringToEnum -from checkfield import * -from WriteData import * - -class prognostic(object): - """ - PROGNOSTIC class definition - - Usage: - prognostic=prognostic(); - """ - - def __init__(self): # {{{ - self.spcthickness = float('NaN') - self.min_thickness = 0 - self.hydrostatic_adjustment = 0 - self.stabilization = 0 - self.vertex_pairing = float('NaN') - self.penalty_factor = 0 - self.requested_outputs = float('NaN') - - #set defaults - self.setdefaultparameters() - - #}}} - def __repr__(self): # {{{ - string=' Prognostic solution parameters:' - string="%s\n%s"%(string,fielddisplay(self,'spcthickness','thickness constraints (NaN means no constraint) [m]')) - string="%s\n%s"%(string,fielddisplay(self,'min_thickness','minimum ice thickness allowed [m]')) - string="%s\n%s"%(string,fielddisplay(self,'hydrostatic_adjustment','adjustment of ice shelves surface and bed elevations: ''Incremental'' or ''Absolute'' ')) - string="%s\n%s"%(string,fielddisplay(self,'stabilization','0: no, 1: artificial_diffusivity, 2: streamline upwinding, 3: discontinuous Galerkin')) - string="%s\n%s"%(string,fielddisplay(self,'requested_outputs','additional outputs requested')) - - return string - #}}} - def setdefaultparameters(self): # {{{ - - #Type of stabilization to use 0:nothing 1:artificial_diffusivity 3:Discontinuous Galerkin - self.stabilization=1 - - #Factor applied to compute the penalties kappa=max(stiffness matrix)*10^penalty_factor - self.penalty_factor=3 - - #Minimum ice thickness that can be used - self.min_thickness=1 - - #Hydrostatic adjustment - self.hydrostatic_adjustment='Absolute' - - return self - #}}} - def checkconsistency(self,md,solution,analyses): # {{{ - - #Early return - if (PrognosticAnalysisEnum() not in analyses) or (solution==TransientSolutionEnum() and not md.transient.isprognostic): - return md - - md = checkfield(md,'prognostic.spcthickness','forcing',1) - md = checkfield(md,'prognostic.hydrostatic_adjustment','values',['Absolute','Incremental']) - md = checkfield(md,'prognostic.stabilization','values',[0,1,2,3]) - md = checkfield(md,'prognostic.min_thickness','>',0) - if not md.prognostic.requested_outputs: - md = checkfield(md,'prognostic.requested_outputs','size',[float('NaN'),1]) - - return md - # }}} - def marshall(self,md,fid): # {{{ - WriteData(fid,'object',self,'fieldname','spcthickness','format','DoubleMat','mattype',1,'forcinglength',md.mesh.numberofvertices+1) - WriteData(fid,'object',self,'fieldname','min_thickness','format','Double') - WriteData(fid,'data',StringToEnum(self.hydrostatic_adjustment)[0],'format','Integer','enum',PrognosticHydrostaticAdjustmentEnum()) - WriteData(fid,'object',self,'fieldname','stabilization','format','Integer') - WriteData(fid,'object',self,'fieldname','vertex_pairing','format','DoubleMat','mattype',3) - WriteData(fid,'object',self,'fieldname','penalty_factor','format','Double') - WriteData(fid,'object',self,'fieldname','requested_outputs','format','DoubleMat','mattype',3); - # }}} Index: /issm/trunk-jpl/src/m/classes/surfaceforcings.m =================================================================== --- /issm/trunk-jpl/src/m/classes/surfaceforcings.m (revision 15766) +++ /issm/trunk-jpl/src/m/classes/surfaceforcings.m (revision 15767) @@ -44,5 +44,5 @@ function md = checkconsistency(obj,md,solution,analyses) % {{{ - if ismember(PrognosticAnalysisEnum(),analyses), + if ismember(MasstransportAnalysisEnum(),analyses), md = checkfield(md,'surfaceforcings.ispdd','numel',[1],'values',[0 1]); md = checkfield(md,'surfaceforcings.issmbgradients','numel',[1],'values',[0 1]); Index: /issm/trunk-jpl/src/m/classes/surfaceforcings.py =================================================================== --- /issm/trunk-jpl/src/m/classes/surfaceforcings.py (revision 15766) +++ /issm/trunk-jpl/src/m/classes/surfaceforcings.py (revision 15767) @@ -72,5 +72,5 @@ def checkconsistency(self,md,solution,analyses): # {{{ - if PrognosticAnalysisEnum() in analyses: + if MasstransportAnalysisEnum() in analyses: md = checkfield(md,'surfaceforcings.ispdd','numel',[1],'values',[0,1]) md = checkfield(md,'surfaceforcings.issmbgradients','numel',[1],'values',[0,1]) Index: /issm/trunk-jpl/src/m/classes/transient.m =================================================================== --- /issm/trunk-jpl/src/m/classes/transient.m (revision 15766) +++ /issm/trunk-jpl/src/m/classes/transient.m (revision 15767) @@ -6,5 +6,5 @@ classdef transient properties (SetAccess=public) - isprognostic = 0; + ismasstransport = 0; isdiagnostic = 0; isthermal = 0; @@ -24,6 +24,6 @@ function obj = setdefaultparameters(obj) % {{{ - %full analysis: Diagnostic, Prognostic and Thermal but no groundingline migration for now - obj.isprognostic=1; + %full analysis: Diagnostic, Masstransport and Thermal but no groundingline migration for now + obj.ismasstransport=1; obj.isdiagnostic=1; obj.isthermal=1; @@ -37,5 +37,5 @@ if solution~=TransientSolutionEnum(), return; end - md = checkfield(md,'transient.isprognostic','numel',[1],'values',[0 1]); + md = checkfield(md,'transient.ismasstransport','numel',[1],'values',[0 1]); md = checkfield(md,'transient.isdiagnostic','numel',[1],'values',[0 1]); md = checkfield(md,'transient.isthermal','numel',[1],'values',[0 1]); @@ -48,5 +48,5 @@ disp(sprintf(' transient solution parameters:')); - fielddisplay(obj,'isprognostic','indicates if a prognostic solution is used in the transient'); + 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,'isthermal','indicates if a thermal solution is used in the transient'); @@ -57,5 +57,5 @@ end % }}} function marshall(obj,md,fid) % {{{ - WriteData(fid,'object',obj,'fieldname','isprognostic','format','Boolean'); + WriteData(fid,'object',obj,'fieldname','ismasstransport','format','Boolean'); WriteData(fid,'object',obj,'fieldname','isdiagnostic','format','Boolean'); WriteData(fid,'object',obj,'fieldname','isthermal','format','Boolean'); Index: /issm/trunk-jpl/src/m/classes/transient.py =================================================================== --- /issm/trunk-jpl/src/m/classes/transient.py (revision 15766) +++ /issm/trunk-jpl/src/m/classes/transient.py (revision 15767) @@ -13,5 +13,5 @@ def __init__(self): # {{{ - self.isprognostic = False + self.ismasstransport = False self.isdiagnostic = False self.isthermal = False @@ -26,5 +26,5 @@ def __repr__(self): # {{{ string=' transient solution parameters:' - string="%s\n%s"%(string,fielddisplay(self,'isprognostic','indicates if a prognostic solution is used in the transient')) + string="%s\n%s"%(string,fielddisplay(self,'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,'isthermal','indicates if a thermal solution is used in the transient')) @@ -36,6 +36,6 @@ def setdefaultparameters(self): # {{{ - #full analysis: Diagnostic, Prognostic and Thermal but no groundingline migration for now - self.isprognostic=True + #full analysis: Diagnostic, Masstransport and Thermal but no groundingline migration for now + self.ismasstransport=True self.isdiagnostic=True self.isthermal=True @@ -51,5 +51,5 @@ return md - md = checkfield(md,'transient.isprognostic','numel',[1],'values',[0,1]) + md = checkfield(md,'transient.ismasstransport','numel',[1],'values',[0,1]) md = checkfield(md,'transient.isdiagnostic','numel',[1],'values',[0,1]) md = checkfield(md,'transient.isthermal','numel',[1],'values',[0,1]) @@ -62,5 +62,5 @@ # }}} def marshall(self,md,fid): # {{{ - WriteData(fid,'object',self,'fieldname','isprognostic','format','Boolean') + WriteData(fid,'object',self,'fieldname','ismasstransport','format','Boolean') WriteData(fid,'object',self,'fieldname','isdiagnostic','format','Boolean') WriteData(fid,'object',self,'fieldname','isthermal','format','Boolean') Index: /issm/trunk-jpl/src/m/consistency/ismodelselfconsistent.m =================================================================== --- /issm/trunk-jpl/src/m/consistency/ismodelselfconsistent.m (revision 15766) +++ /issm/trunk-jpl/src/m/consistency/ismodelselfconsistent.m (revision 15767) @@ -61,7 +61,7 @@ analyses=[EnthalpyAnalysisEnum()]; - case PrognosticSolutionEnum(), + case MasstransportSolutionEnum(), numanalyses=1; - analyses=[PrognosticAnalysisEnum()]; + analyses=[MasstransportAnalysisEnum()]; case BalancethicknessSolutionEnum(), @@ -87,5 +87,5 @@ case TransientSolutionEnum(), numanalyses=9; - analyses=[DiagnosticHorizAnalysisEnum();DiagnosticVertAnalysisEnum();DiagnosticSIAAnalysisEnum();SurfaceSlopeAnalysisEnum();BedSlopeAnalysisEnum();ThermalAnalysisEnum();MeltingAnalysisEnum();EnthalpyAnalysisEnum();PrognosticAnalysisEnum()]; + analyses=[DiagnosticHorizAnalysisEnum();DiagnosticVertAnalysisEnum();DiagnosticSIAAnalysisEnum();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 15766) +++ /issm/trunk-jpl/src/m/consistency/ismodelselfconsistent.py (revision 15767) @@ -26,7 +26,7 @@ analyses=[EnthalpyAnalysisEnum()] - elif solutiontype == PrognosticSolutionEnum(): + elif solutiontype == MasstransportSolutionEnum(): numanalyses=1 - analyses=[PrognosticAnalysisEnum()] + analyses=[MasstransportAnalysisEnum()] elif solutiontype == BalancethicknessSolutionEnum(): @@ -48,5 +48,5 @@ elif solutiontype == TransientSolutionEnum(): numanalyses=9 - analyses=[DiagnosticHorizAnalysisEnum(),DiagnosticVertAnalysisEnum(),DiagnosticSIAAnalysisEnum(),SurfaceSlopeAnalysisEnum(),BedSlopeAnalysisEnum(),ThermalAnalysisEnum(),MeltingAnalysisEnum(),EnthalpyAnalysisEnum(),PrognosticAnalysisEnum()] + analyses=[DiagnosticHorizAnalysisEnum(),DiagnosticVertAnalysisEnum(),DiagnosticSIAAnalysisEnum(),SurfaceSlopeAnalysisEnum(),BedSlopeAnalysisEnum(),ThermalAnalysisEnum(),MeltingAnalysisEnum(),EnthalpyAnalysisEnum(),MasstransportAnalysisEnum()] elif solutiontype == FlaimSolutionEnum(): Index: /issm/trunk-jpl/src/m/enum/EnumDefinitions.py =================================================================== --- /issm/trunk-jpl/src/m/enum/EnumDefinitions.py (revision 15766) +++ /issm/trunk-jpl/src/m/enum/EnumDefinitions.py (revision 15767) @@ -187,12 +187,12 @@ def MeshZEnum(): return StringToEnum("MeshZ")[0] def MiscellaneousNameEnum(): return StringToEnum("MiscellaneousName")[0] -def PrognosticHydrostaticAdjustmentEnum(): return StringToEnum("PrognosticHydrostaticAdjustment")[0] -def PrognosticMinThicknessEnum(): return StringToEnum("PrognosticMinThickness")[0] -def PrognosticPenaltyFactorEnum(): return StringToEnum("PrognosticPenaltyFactor")[0] -def PrognosticSpcthicknessEnum(): return StringToEnum("PrognosticSpcthickness")[0] -def PrognosticStabilizationEnum(): return StringToEnum("PrognosticStabilization")[0] -def PrognosticVertexPairingEnum(): return StringToEnum("PrognosticVertexPairing")[0] -def PrognosticNumRequestedOutputsEnum(): return StringToEnum("PrognosticNumRequestedOutputs")[0] -def PrognosticRequestedOutputsEnum(): return StringToEnum("PrognosticRequestedOutputs")[0] +def MasstransportHydrostaticAdjustmentEnum(): return StringToEnum("MasstransportHydrostaticAdjustment")[0] +def MasstransportMinThicknessEnum(): return StringToEnum("MasstransportMinThickness")[0] +def MasstransportPenaltyFactorEnum(): return StringToEnum("MasstransportPenaltyFactor")[0] +def MasstransportSpcthicknessEnum(): return StringToEnum("MasstransportSpcthickness")[0] +def MasstransportStabilizationEnum(): return StringToEnum("MasstransportStabilization")[0] +def MasstransportVertexPairingEnum(): return StringToEnum("MasstransportVertexPairing")[0] +def MasstransportNumRequestedOutputsEnum(): return StringToEnum("MasstransportNumRequestedOutputs")[0] +def MasstransportRequestedOutputsEnum(): return StringToEnum("MasstransportRequestedOutputs")[0] def QmuIsdakotaEnum(): return StringToEnum("QmuIsdakota")[0] def MassFluxSegmentsEnum(): return StringToEnum("MassFluxSegments")[0] @@ -256,5 +256,5 @@ def TransientIsdiagnosticEnum(): return StringToEnum("TransientIsdiagnostic")[0] def TransientIsgroundinglineEnum(): return StringToEnum("TransientIsgroundingline")[0] -def TransientIsprognosticEnum(): return StringToEnum("TransientIsprognostic")[0] +def TransientIsmasstransportEnum(): return StringToEnum("TransientIsmasstransport")[0] def TransientIsthermalEnum(): return StringToEnum("TransientIsthermal")[0] def TransientIsgiaEnum(): return StringToEnum("TransientIsgia")[0] @@ -291,6 +291,6 @@ def HydrologySolutionEnum(): return StringToEnum("HydrologySolution")[0] def MeltingAnalysisEnum(): return StringToEnum("MeltingAnalysis")[0] -def PrognosticAnalysisEnum(): return StringToEnum("PrognosticAnalysis")[0] -def PrognosticSolutionEnum(): return StringToEnum("PrognosticSolution")[0] +def MasstransportAnalysisEnum(): return StringToEnum("MasstransportAnalysis")[0] +def MasstransportSolutionEnum(): return StringToEnum("MasstransportSolution")[0] def SteadystateSolutionEnum(): return StringToEnum("SteadystateSolution")[0] def SurfaceSlopeAnalysisEnum(): return StringToEnum("SurfaceSlopeAnalysis")[0] Index: /issm/trunk-jpl/src/m/enum/MasstransportAnalysisEnum.m =================================================================== --- /issm/trunk-jpl/src/m/enum/MasstransportAnalysisEnum.m (revision 15767) +++ /issm/trunk-jpl/src/m/enum/MasstransportAnalysisEnum.m (revision 15767) @@ -0,0 +1,11 @@ +function macro=MasstransportAnalysisEnum() +%MASSTRANSPORTANALYSISENUM - Enum of MasstransportAnalysis +% +% WARNING: DO NOT MODIFY THIS FILE +% this file has been automatically generated by src/c/shared/Enum/Synchronize.sh +% Please read src/c/shared/Enum/README for more information +% +% Usage: +% macro=MasstransportAnalysisEnum() + +macro=StringToEnum('MasstransportAnalysis'); Index: /issm/trunk-jpl/src/m/enum/MasstransportHydrostaticAdjustmentEnum.m =================================================================== --- /issm/trunk-jpl/src/m/enum/MasstransportHydrostaticAdjustmentEnum.m (revision 15767) +++ /issm/trunk-jpl/src/m/enum/MasstransportHydrostaticAdjustmentEnum.m (revision 15767) @@ -0,0 +1,11 @@ +function macro=MasstransportHydrostaticAdjustmentEnum() +%MASSTRANSPORTHYDROSTATICADJUSTMENTENUM - Enum of MasstransportHydrostaticAdjustment +% +% WARNING: DO NOT MODIFY THIS FILE +% this file has been automatically generated by src/c/shared/Enum/Synchronize.sh +% Please read src/c/shared/Enum/README for more information +% +% Usage: +% macro=MasstransportHydrostaticAdjustmentEnum() + +macro=StringToEnum('MasstransportHydrostaticAdjustment'); Index: /issm/trunk-jpl/src/m/enum/MasstransportMinThicknessEnum.m =================================================================== --- /issm/trunk-jpl/src/m/enum/MasstransportMinThicknessEnum.m (revision 15767) +++ /issm/trunk-jpl/src/m/enum/MasstransportMinThicknessEnum.m (revision 15767) @@ -0,0 +1,11 @@ +function macro=MasstransportMinThicknessEnum() +%MASSTRANSPORTMINTHICKNESSENUM - Enum of MasstransportMinThickness +% +% WARNING: DO NOT MODIFY THIS FILE +% this file has been automatically generated by src/c/shared/Enum/Synchronize.sh +% Please read src/c/shared/Enum/README for more information +% +% Usage: +% macro=MasstransportMinThicknessEnum() + +macro=StringToEnum('MasstransportMinThickness'); Index: /issm/trunk-jpl/src/m/enum/MasstransportNumRequestedOutputsEnum.m =================================================================== --- /issm/trunk-jpl/src/m/enum/MasstransportNumRequestedOutputsEnum.m (revision 15767) +++ /issm/trunk-jpl/src/m/enum/MasstransportNumRequestedOutputsEnum.m (revision 15767) @@ -0,0 +1,11 @@ +function macro=MasstransportNumRequestedOutputsEnum() +%MASSTRANSPORTNUMREQUESTEDOUTPUTSENUM - Enum of MasstransportNumRequestedOutputs +% +% WARNING: DO NOT MODIFY THIS FILE +% this file has been automatically generated by src/c/shared/Enum/Synchronize.sh +% Please read src/c/shared/Enum/README for more information +% +% Usage: +% macro=MasstransportNumRequestedOutputsEnum() + +macro=StringToEnum('MasstransportNumRequestedOutputs'); Index: /issm/trunk-jpl/src/m/enum/MasstransportPenaltyFactorEnum.m =================================================================== --- /issm/trunk-jpl/src/m/enum/MasstransportPenaltyFactorEnum.m (revision 15767) +++ /issm/trunk-jpl/src/m/enum/MasstransportPenaltyFactorEnum.m (revision 15767) @@ -0,0 +1,11 @@ +function macro=MasstransportPenaltyFactorEnum() +%MASSTRANSPORTPENALTYFACTORENUM - Enum of MasstransportPenaltyFactor +% +% WARNING: DO NOT MODIFY THIS FILE +% this file has been automatically generated by src/c/shared/Enum/Synchronize.sh +% Please read src/c/shared/Enum/README for more information +% +% Usage: +% macro=MasstransportPenaltyFactorEnum() + +macro=StringToEnum('MasstransportPenaltyFactor'); Index: /issm/trunk-jpl/src/m/enum/MasstransportRequestedOutputsEnum.m =================================================================== --- /issm/trunk-jpl/src/m/enum/MasstransportRequestedOutputsEnum.m (revision 15767) +++ /issm/trunk-jpl/src/m/enum/MasstransportRequestedOutputsEnum.m (revision 15767) @@ -0,0 +1,11 @@ +function macro=MasstransportRequestedOutputsEnum() +%MASSTRANSPORTREQUESTEDOUTPUTSENUM - Enum of MasstransportRequestedOutputs +% +% WARNING: DO NOT MODIFY THIS FILE +% this file has been automatically generated by src/c/shared/Enum/Synchronize.sh +% Please read src/c/shared/Enum/README for more information +% +% Usage: +% macro=MasstransportRequestedOutputsEnum() + +macro=StringToEnum('MasstransportRequestedOutputs'); Index: /issm/trunk-jpl/src/m/enum/MasstransportSolutionEnum.m =================================================================== --- /issm/trunk-jpl/src/m/enum/MasstransportSolutionEnum.m (revision 15767) +++ /issm/trunk-jpl/src/m/enum/MasstransportSolutionEnum.m (revision 15767) @@ -0,0 +1,11 @@ +function macro=MasstransportSolutionEnum() +%MASSTRANSPORTSOLUTIONENUM - Enum of MasstransportSolution +% +% WARNING: DO NOT MODIFY THIS FILE +% this file has been automatically generated by src/c/shared/Enum/Synchronize.sh +% Please read src/c/shared/Enum/README for more information +% +% Usage: +% macro=MasstransportSolutionEnum() + +macro=StringToEnum('MasstransportSolution'); Index: /issm/trunk-jpl/src/m/enum/MasstransportSpcthicknessEnum.m =================================================================== --- /issm/trunk-jpl/src/m/enum/MasstransportSpcthicknessEnum.m (revision 15767) +++ /issm/trunk-jpl/src/m/enum/MasstransportSpcthicknessEnum.m (revision 15767) @@ -0,0 +1,11 @@ +function macro=MasstransportSpcthicknessEnum() +%MASSTRANSPORTSPCTHICKNESSENUM - Enum of MasstransportSpcthickness +% +% WARNING: DO NOT MODIFY THIS FILE +% this file has been automatically generated by src/c/shared/Enum/Synchronize.sh +% Please read src/c/shared/Enum/README for more information +% +% Usage: +% macro=MasstransportSpcthicknessEnum() + +macro=StringToEnum('MasstransportSpcthickness'); Index: /issm/trunk-jpl/src/m/enum/MasstransportStabilizationEnum.m =================================================================== --- /issm/trunk-jpl/src/m/enum/MasstransportStabilizationEnum.m (revision 15767) +++ /issm/trunk-jpl/src/m/enum/MasstransportStabilizationEnum.m (revision 15767) @@ -0,0 +1,11 @@ +function macro=MasstransportStabilizationEnum() +%MASSTRANSPORTSTABILIZATIONENUM - Enum of MasstransportStabilization +% +% WARNING: DO NOT MODIFY THIS FILE +% this file has been automatically generated by src/c/shared/Enum/Synchronize.sh +% Please read src/c/shared/Enum/README for more information +% +% Usage: +% macro=MasstransportStabilizationEnum() + +macro=StringToEnum('MasstransportStabilization'); Index: /issm/trunk-jpl/src/m/enum/MasstransportVertexPairingEnum.m =================================================================== --- /issm/trunk-jpl/src/m/enum/MasstransportVertexPairingEnum.m (revision 15767) +++ /issm/trunk-jpl/src/m/enum/MasstransportVertexPairingEnum.m (revision 15767) @@ -0,0 +1,11 @@ +function macro=MasstransportVertexPairingEnum() +%MASSTRANSPORTVERTEXPAIRINGENUM - Enum of MasstransportVertexPairing +% +% WARNING: DO NOT MODIFY THIS FILE +% this file has been automatically generated by src/c/shared/Enum/Synchronize.sh +% Please read src/c/shared/Enum/README for more information +% +% Usage: +% macro=MasstransportVertexPairingEnum() + +macro=StringToEnum('MasstransportVertexPairing'); Index: sm/trunk-jpl/src/m/enum/PrognosticAnalysisEnum.m =================================================================== --- /issm/trunk-jpl/src/m/enum/PrognosticAnalysisEnum.m (revision 15766) +++ (revision ) @@ -1,11 +1,0 @@ -function macro=PrognosticAnalysisEnum() -%PROGNOSTICANALYSISENUM - Enum of PrognosticAnalysis -% -% WARNING: DO NOT MODIFY THIS FILE -% this file has been automatically generated by src/c/shared/Enum/Synchronize.sh -% Please read src/c/shared/Enum/README for more information -% -% Usage: -% macro=PrognosticAnalysisEnum() - -macro=StringToEnum('PrognosticAnalysis'); Index: sm/trunk-jpl/src/m/enum/PrognosticHydrostaticAdjustmentEnum.m =================================================================== --- /issm/trunk-jpl/src/m/enum/PrognosticHydrostaticAdjustmentEnum.m (revision 15766) +++ (revision ) @@ -1,11 +1,0 @@ -function macro=PrognosticHydrostaticAdjustmentEnum() -%PROGNOSTICHYDROSTATICADJUSTMENTENUM - Enum of PrognosticHydrostaticAdjustment -% -% WARNING: DO NOT MODIFY THIS FILE -% this file has been automatically generated by src/c/shared/Enum/Synchronize.sh -% Please read src/c/shared/Enum/README for more information -% -% Usage: -% macro=PrognosticHydrostaticAdjustmentEnum() - -macro=StringToEnum('PrognosticHydrostaticAdjustment'); Index: sm/trunk-jpl/src/m/enum/PrognosticMinThicknessEnum.m =================================================================== --- /issm/trunk-jpl/src/m/enum/PrognosticMinThicknessEnum.m (revision 15766) +++ (revision ) @@ -1,11 +1,0 @@ -function macro=PrognosticMinThicknessEnum() -%PROGNOSTICMINTHICKNESSENUM - Enum of PrognosticMinThickness -% -% WARNING: DO NOT MODIFY THIS FILE -% this file has been automatically generated by src/c/shared/Enum/Synchronize.sh -% Please read src/c/shared/Enum/README for more information -% -% Usage: -% macro=PrognosticMinThicknessEnum() - -macro=StringToEnum('PrognosticMinThickness'); Index: sm/trunk-jpl/src/m/enum/PrognosticNumRequestedOutputsEnum.m =================================================================== --- /issm/trunk-jpl/src/m/enum/PrognosticNumRequestedOutputsEnum.m (revision 15766) +++ (revision ) @@ -1,11 +1,0 @@ -function macro=PrognosticNumRequestedOutputsEnum() -%PROGNOSTICNUMREQUESTEDOUTPUTSENUM - Enum of PrognosticNumRequestedOutputs -% -% WARNING: DO NOT MODIFY THIS FILE -% this file has been automatically generated by src/c/shared/Enum/Synchronize.sh -% Please read src/c/shared/Enum/README for more information -% -% Usage: -% macro=PrognosticNumRequestedOutputsEnum() - -macro=StringToEnum('PrognosticNumRequestedOutputs'); Index: sm/trunk-jpl/src/m/enum/PrognosticPenaltyFactorEnum.m =================================================================== --- /issm/trunk-jpl/src/m/enum/PrognosticPenaltyFactorEnum.m (revision 15766) +++ (revision ) @@ -1,11 +1,0 @@ -function macro=PrognosticPenaltyFactorEnum() -%PROGNOSTICPENALTYFACTORENUM - Enum of PrognosticPenaltyFactor -% -% WARNING: DO NOT MODIFY THIS FILE -% this file has been automatically generated by src/c/shared/Enum/Synchronize.sh -% Please read src/c/shared/Enum/README for more information -% -% Usage: -% macro=PrognosticPenaltyFactorEnum() - -macro=StringToEnum('PrognosticPenaltyFactor'); Index: sm/trunk-jpl/src/m/enum/PrognosticRequestedOutputsEnum.m =================================================================== --- /issm/trunk-jpl/src/m/enum/PrognosticRequestedOutputsEnum.m (revision 15766) +++ (revision ) @@ -1,11 +1,0 @@ -function macro=PrognosticRequestedOutputsEnum() -%PROGNOSTICREQUESTEDOUTPUTSENUM - Enum of PrognosticRequestedOutputs -% -% WARNING: DO NOT MODIFY THIS FILE -% this file has been automatically generated by src/c/shared/Enum/Synchronize.sh -% Please read src/c/shared/Enum/README for more information -% -% Usage: -% macro=PrognosticRequestedOutputsEnum() - -macro=StringToEnum('PrognosticRequestedOutputs'); Index: sm/trunk-jpl/src/m/enum/PrognosticSolutionEnum.m =================================================================== --- /issm/trunk-jpl/src/m/enum/PrognosticSolutionEnum.m (revision 15766) +++ (revision ) @@ -1,11 +1,0 @@ -function macro=PrognosticSolutionEnum() -%PROGNOSTICSOLUTIONENUM - Enum of PrognosticSolution -% -% WARNING: DO NOT MODIFY THIS FILE -% this file has been automatically generated by src/c/shared/Enum/Synchronize.sh -% Please read src/c/shared/Enum/README for more information -% -% Usage: -% macro=PrognosticSolutionEnum() - -macro=StringToEnum('PrognosticSolution'); Index: sm/trunk-jpl/src/m/enum/PrognosticSpcthicknessEnum.m =================================================================== --- /issm/trunk-jpl/src/m/enum/PrognosticSpcthicknessEnum.m (revision 15766) +++ (revision ) @@ -1,11 +1,0 @@ -function macro=PrognosticSpcthicknessEnum() -%PROGNOSTICSPCTHICKNESSENUM - Enum of PrognosticSpcthickness -% -% WARNING: DO NOT MODIFY THIS FILE -% this file has been automatically generated by src/c/shared/Enum/Synchronize.sh -% Please read src/c/shared/Enum/README for more information -% -% Usage: -% macro=PrognosticSpcthicknessEnum() - -macro=StringToEnum('PrognosticSpcthickness'); Index: sm/trunk-jpl/src/m/enum/PrognosticStabilizationEnum.m =================================================================== --- /issm/trunk-jpl/src/m/enum/PrognosticStabilizationEnum.m (revision 15766) +++ (revision ) @@ -1,11 +1,0 @@ -function macro=PrognosticStabilizationEnum() -%PROGNOSTICSTABILIZATIONENUM - Enum of PrognosticStabilization -% -% WARNING: DO NOT MODIFY THIS FILE -% this file has been automatically generated by src/c/shared/Enum/Synchronize.sh -% Please read src/c/shared/Enum/README for more information -% -% Usage: -% macro=PrognosticStabilizationEnum() - -macro=StringToEnum('PrognosticStabilization'); Index: sm/trunk-jpl/src/m/enum/PrognosticVertexPairingEnum.m =================================================================== --- /issm/trunk-jpl/src/m/enum/PrognosticVertexPairingEnum.m (revision 15766) +++ (revision ) @@ -1,11 +1,0 @@ -function macro=PrognosticVertexPairingEnum() -%PROGNOSTICVERTEXPAIRINGENUM - Enum of PrognosticVertexPairing -% -% WARNING: DO NOT MODIFY THIS FILE -% this file has been automatically generated by src/c/shared/Enum/Synchronize.sh -% Please read src/c/shared/Enum/README for more information -% -% Usage: -% macro=PrognosticVertexPairingEnum() - -macro=StringToEnum('PrognosticVertexPairing'); Index: /issm/trunk-jpl/src/m/enum/TransientIsmasstransportEnum.m =================================================================== --- /issm/trunk-jpl/src/m/enum/TransientIsmasstransportEnum.m (revision 15767) +++ /issm/trunk-jpl/src/m/enum/TransientIsmasstransportEnum.m (revision 15767) @@ -0,0 +1,11 @@ +function macro=TransientIsmasstransportEnum() +%TRANSIENTISMASSTRANSPORTENUM - Enum of TransientIsmasstransport +% +% WARNING: DO NOT MODIFY THIS FILE +% this file has been automatically generated by src/c/shared/Enum/Synchronize.sh +% Please read src/c/shared/Enum/README for more information +% +% Usage: +% macro=TransientIsmasstransportEnum() + +macro=StringToEnum('TransientIsmasstransport'); Index: sm/trunk-jpl/src/m/enum/TransientIsprognosticEnum.m =================================================================== --- /issm/trunk-jpl/src/m/enum/TransientIsprognosticEnum.m (revision 15766) +++ (revision ) @@ -1,11 +1,0 @@ -function macro=TransientIsprognosticEnum() -%TRANSIENTISPROGNOSTICENUM - Enum of TransientIsprognostic -% -% WARNING: DO NOT MODIFY THIS FILE -% this file has been automatically generated by src/c/shared/Enum/Synchronize.sh -% Please read src/c/shared/Enum/README for more information -% -% Usage: -% macro=TransientIsprognosticEnum() - -macro=StringToEnum('TransientIsprognostic'); Index: /issm/trunk-jpl/src/m/qmu/process_qmu_options.m =================================================================== --- /issm/trunk-jpl/src/m/qmu/process_qmu_options.m (revision 15766) +++ /issm/trunk-jpl/src/m/qmu/process_qmu_options.m (revision 15767) @@ -40,5 +40,5 @@ if ~(strcmpi(analysis_type,'control') | ... strcmpi(analysis_type,'diagnostic') | ... - strcmpi(analysis_type,'prognostic') | ... + strcmpi(analysis_type,'masstransport') | ... strcmpi(analysis_type,'thermal') | ... strcmpi(analysis_type,'parameters') | ... Index: /issm/trunk-jpl/src/m/regional/regionaltransient2d.m =================================================================== --- /issm/trunk-jpl/src/m/regional/regionaltransient2d.m (revision 15766) +++ /issm/trunk-jpl/src/m/regional/regionaltransient2d.m (revision 15767) @@ -118,13 +118,13 @@ md2.diagnostic.spcvy=md2.diagnostic.spcvy*ones(1,size(spcy,2)); md2.diagnostic.spcvz=md2.diagnostic.spcvz*ones(1,size(spcx,2)); - md2.prognostic.spcthickness=md2.prognostic.spcthickness*ones(1,size(spct,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.prognostic.spcthickness(find(md2.mesh.vertexonboundary),:)=spct(find(md2.mesh.vertexonboundary),:); + 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.prognostic.spcthickness=[md2.prognostic.spcthickness; steps]; + md2.masstransport.spcthickness=[md2.masstransport.spcthickness; steps]; end @@ -149,5 +149,5 @@ md2.diagnostic.spcvy(unique(md2.diagnostic.icefront(:,1:2)),:)=nan; md2.diagnostic.spcvz(unique(md2.diagnostic.icefront(:,1:2)),:)=nan; - md2.prognostic.spcthickness(unique(md2.diagnostic.icefront(:,1:2)),:)=nan; + md2.masstransport.spcthickness(unique(md2.diagnostic.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 15766) +++ /issm/trunk-jpl/src/m/solve/process_solve_options.m (revision 15767) @@ -9,5 +9,5 @@ %solution_type: check on this option, error out otherwise solution_type=getfieldvalue(options,'solution_type'); -if ~ismember(solution_type,[DiagnosticSolutionEnum(),PrognosticSolutionEnum(),ThermalSolutionEnum(),... +if ~ismember(solution_type,[DiagnosticSolutionEnum(),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 15766) +++ /issm/trunk-jpl/src/m/solve/process_solve_options.py (revision 15767) @@ -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(),PrognosticSolutionEnum(),ThermalSolutionEnum(),\ + if solution_type not in (DiagnosticSolutionEnum(),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 15766) +++ /issm/trunk-jpl/src/m/solve/solve.m (revision 15767) @@ -8,5 +8,5 @@ % solution types available comprise: % - DiagnosticSolutionEnum -% - PrognosticSolutionEnum +% - MasstransportSolutionEnum % - ThermalSolutionEnum % - SteadystateSolutionEnum Index: /issm/trunk-jpl/src/m/solve/solve.py =================================================================== --- /issm/trunk-jpl/src/m/solve/solve.py (revision 15766) +++ /issm/trunk-jpl/src/m/solve/solve.py (revision 15767) @@ -22,5 +22,5 @@ solution types available comprise: - DiagnosticSolutionEnum - - PrognosticSolutionEnum + - MasstransportSolutionEnum - ThermalSolutionEnum - SteadystateSolutionEnum Index: /issm/trunk-jpl/test/NightlyRun/IdToName.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/IdToName.m (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/IdToName.m (revision 15767) @@ -10,7 +10,7 @@ case 103, name='SquareShelfConstrainedDiagHO'; case 104, name='SquareShelfConstrainedDiagS3d'; - case 105, name='SquareShelfConstrainedProg2d'; - case 106, name='SquareShelfConstrainedProg2dDG'; - case 107, name='SquareShelfConstrainedProg3d'; + case 105, name='SquareShelfConstrainedMasstransp2d'; + case 106, name='SquareShelfConstrainedMasstransp2dDG'; + case 107, name='SquareShelfConstrainedMasstransp3d'; case 108, name='SquareShelfConstrainedTherStea'; case 109, name='SquareShelfConstrainedTherTran'; @@ -46,7 +46,7 @@ case 217, name='SquareShelfConstrained'; case 218, name='SquareShelfConstrainedDakotaB'; - case 219, name='SquareShelfDiagMHOTiling'; - case 220, name='SquareShelfDiagPS3dTiling'; - case 221, name='SquareShelfDiagMS3dTiling'; + case 219, name='SquareShelfDiagSSAHOTiling'; + case 220, name='SquareShelfDiagHOFS3dTiling'; + case 221, name='SquareShelfDiagSSAFS3dTiling'; case 222, name='SquareShelfDiagSSA2dTransientIncrHydro'; case 223, name='SquareShelfDiagSSA2dTransientIncrNonHydro'; @@ -81,7 +81,7 @@ case 307, name='SquareSheetConstrainedDiagHO'; case 308, name='SquareSheetConstrainedDiagS3d'; - case 309, name='SquareSheetConstrainedProg2d'; - case 320, name='SquareSheetConstrainedProg2dDG'; - case 311, name='SquareSheetConstrainedProg3d'; + case 309, name='SquareSheetConstrainedMasstransp2d'; + case 320, name='SquareSheetConstrainedMasstransp2dDG'; + case 311, name='SquareSheetConstrainedMasstransp3d'; case 312, name='SquareSheetConstrainedTherStea'; case 313, name='SquareSheetConstrainedTherTran'; @@ -123,8 +123,8 @@ case 417, name='SquareSheetShelfDiadSSA3dDakotaSamp'; case 418, name='SquareSheetShelfDiadSSA3dDakotaAreaAverage'; - case 419, name='SquareSheetShelfDiagMHOTiling'; + case 419, name='SquareSheetShelfDiagSSAHOTiling'; case 420, name='SquareSheetShelfDakotaScaledResponse'; - case 421, name='SquareSheetShelfDiagPS3dTiling'; - case 422, name='SquareSheetShelfDiagMS3dTiling'; + case 421, name='SquareSheetShelfDiagHOFS3dTiling'; + case 422, name='SquareSheetShelfDiagSSAFS3dTiling'; case 423, name='RoundSheetShelfGLMigrationSSA2d'; case 424, name='SquareSheetShelfGroundingLine2dAgressive'; @@ -155,7 +155,7 @@ case 515, name='PigTherTranSUPG'; case 516, name='PigTherSteaSUPG'; - case 601, name='79NorthProg2d'; - case 602, name='79NorthProg2dDG'; - case 603, name='79NorthProg3d'; + case 601, name='79NorthMasstransp2d'; + case 602, name='79NorthMasstransp2dDG'; + case 603, name='79NorthMasstransp3d'; case 604, name='79NorthSurfSlop2d'; case 605, name='79NorthSurfSlop3d'; @@ -213,11 +213,11 @@ case 3003, name='SquareShelfConstrainedDiagHOAdolc'; case 3004, name='SquareShelfConstrainedDiagS3dAdolc'; - case 3005, name='SquareShelfConstrainedProg2dAdolc'; - case 3006, name='SquareShelfConstrainedProg2dDGAdolc'; - case 3007, name='SquareShelfConstrainedProg3dAdolc'; + case 3005, name='SquareShelfConstrainedMasstransp2dAdolc'; + case 3006, name='SquareShelfConstrainedMasstransp2dDGAdolc'; + case 3007, name='SquareShelfConstrainedMasstransp3dAdolc'; case 3008, name='SquareShelfConstrainedTherSteaAdolc'; case 3009, name='SquareShelfConstrainedTherTranAdolc'; case 3010, name='SquareShelfConstrainedTranSSA2dAdolc'; - case 3015, name='SquareShelfConstrainedProg2dAdolcForwardDifference'; + case 3015, name='SquareShelfConstrainedMasstransp2dAdolcForwardDifference'; case 3019, name='SquareShelfConstrainedTherTranAdolcReverseVsForward'; Index: /issm/trunk-jpl/test/NightlyRun/IdToName.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/IdToName.py (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/IdToName.py (revision 15767) @@ -14,7 +14,7 @@ 103 : 'SquareShelfConstrainedDiagHO', 104 : 'SquareShelfConstrainedDiagS3d', - 105 : 'SquareShelfConstrainedProg2d', - 106 : 'SquareShelfConstrainedProg2dDG', - 107 : 'SquareShelfConstrainedProg3d', + 105 : 'SquareShelfConstrainedMasstransp2d', + 106 : 'SquareShelfConstrainedMasstransp2dDG', + 107 : 'SquareShelfConstrainedMasstransp3d', 108 : 'SquareShelfConstrainedTherStea', 109 : 'SquareShelfConstrainedTherTran', @@ -50,7 +50,7 @@ 217 : 'SquareShelfConstrained', 218 : 'SquareShelfConstrainedDakotaB', - 219 : 'SquareShelfDiagMHOTiling', - 220 : 'SquareShelfDiagPS3dTiling', - 221 : 'SquareShelfDiagMS3dTiling', + 219 : 'SquareShelfDiagSSAHOTiling', + 220 : 'SquareShelfDiagHOFS3dTiling', + 221 : 'SquareShelfDiagSSAFS3dTiling', 222 : 'SquareShelfDiagSSA2dTransientIncrHydro', 223 : 'SquareShelfDiagSSA2dTransientIncrNonHydro', @@ -85,7 +85,7 @@ 307 : 'SquareSheetConstrainedDiagHO', 308 : 'SquareSheetConstrainedDiagS3d', - 309 : 'SquareSheetConstrainedProg2d', - 320 : 'SquareSheetConstrainedProg2dDG', - 311 : 'SquareSheetConstrainedProg3d', + 309 : 'SquareSheetConstrainedMasstransp2d', + 320 : 'SquareSheetConstrainedMasstransp2dDG', + 311 : 'SquareSheetConstrainedMasstransp3d', 312 : 'SquareSheetConstrainedTherStea', 313 : 'SquareSheetConstrainedTherTran', @@ -127,8 +127,8 @@ 417 : 'SquareSheetShelfDiadSSA3dDakotaSamp', 418 : 'SquareSheetShelfDiadSSA3dDakotaAreaAverage', - 419 : 'SquareSheetShelfDiagMHOTiling', + 419 : 'SquareSheetShelfDiagSSAHOTiling', 420 : 'SquareSheetShelfDakotaScaledResponse', - 421 : 'SquareSheetShelfDiagPS3dTiling', - 422 : 'SquareSheetShelfDiagMS3dTiling', + 421 : 'SquareSheetShelfDiagHOFS3dTiling', + 422 : 'SquareSheetShelfDiagSSAFS3dTiling', 423 : 'RoundSheetShelfGLMigrationSSA2d', 424 : 'SquareSheetShelfGroundingLine2dAgressive', @@ -159,7 +159,7 @@ 515 : 'PigTherTranSUPG', 516 : 'PigTherSteaSUPG', - 601 : '79NorthProg2d', - 602 : '79NorthProg2dDG', - 603 : '79NorthProg3d', + 601 : '79NorthMasstransp2d', + 602 : '79NorthMasstransp2dDG', + 603 : '79NorthMasstransp3d', 604 : '79NorthSurfSlop2d', 605 : '79NorthSurfSlop3d', @@ -217,11 +217,11 @@ 3003 : 'SquareShelfConstrainedDiagHOAdolc', 3004 : 'SquareShelfConstrainedDiagS3dAdolc', - 3005 : 'SquareShelfConstrainedProg2dAdolc', - 3006 : 'SquareShelfConstrainedProg2dDGAdolc', - 3007 : 'SquareShelfConstrainedProg3dAdolc', + 3005 : 'SquareShelfConstrainedMasstransp2dAdolc', + 3006 : 'SquareShelfConstrainedMasstransp2dDGAdolc', + 3007 : 'SquareShelfConstrainedMasstransp3dAdolc', 3008 : 'SquareShelfConstrainedTherSteaAdolc', 3009 : 'SquareShelfConstrainedTherTranAdolc', 3010 : 'SquareShelfConstrainedTranSSA2dAdolc', - 3015 : 'SquareShelfConstrainedProg2dAdolcForwardDifference', + 3015 : 'SquareShelfConstrainedMasstransp2dAdolcForwardDifference', 3019 : 'SquareShelfConstrainedTherTranAdolcReverseVsForward', } Index: /issm/trunk-jpl/test/NightlyRun/test105.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test105.m (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test105.m (revision 15767) @@ -4,5 +4,5 @@ md=setflowequation(md,'SSA','all'); md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,PrognosticSolutionEnum()); +md=solve(md,MasstransportSolutionEnum()); %Fields and tolerances to track changes @@ -10,4 +10,4 @@ field_tolerances={1e-13}; field_values={... - (md.results.PrognosticSolution.Thickness),... + (md.results.MasstransportSolution.Thickness),... }; Index: /issm/trunk-jpl/test/NightlyRun/test105.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test105.py (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test105.py (revision 15767) @@ -13,5 +13,5 @@ md=setflowequation(md,'SSA','all') md.cluster=generic('name',oshostname(),'np',3) -md=solve(md,PrognosticSolutionEnum()) +md=solve(md,MasstransportSolutionEnum()) #Fields and tolerances to track changes @@ -19,4 +19,4 @@ field_tolerances=[1e-13] field_values=[\ - md.results.PrognosticSolution.Thickness,\ + md.results.MasstransportSolution.Thickness,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test106.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test106.m (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test106.m (revision 15767) @@ -5,7 +5,7 @@ md=setflowequation(md,'SSA','all'); md.cluster=generic('name',oshostname(),'np',3); -md.prognostic.stabilization=3; -md.prognostic.spcthickness=md.geometry.thickness; -md=solve(md,PrognosticSolutionEnum()); +md.masstransport.stabilization=3; +md.masstransport.spcthickness=md.geometry.thickness; +md=solve(md,MasstransportSolutionEnum()); %Fields and tolerances to track changes @@ -13,4 +13,4 @@ field_tolerances={1e-13}; field_values={... - (md.results.PrognosticSolution.Thickness),... + (md.results.MasstransportSolution.Thickness),... }; Index: /issm/trunk-jpl/test/NightlyRun/test106.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test106.py (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test106.py (revision 15767) @@ -15,7 +15,7 @@ md=setflowequation(md,'SSA','all') md.cluster=generic('name',oshostname(),'np',3) -md.prognostic.stabilization=3 -md.prognostic.spcthickness=md.geometry.thickness -md=solve(md,PrognosticSolutionEnum()) +md.masstransport.stabilization=3 +md.masstransport.spcthickness=md.geometry.thickness +md=solve(md,MasstransportSolutionEnum()) #Fields and tolerances to track changes @@ -23,4 +23,4 @@ field_tolerances=[1e-13] field_values=[\ - md.results.PrognosticSolution.Thickness,\ + md.results.MasstransportSolution.Thickness,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test107.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test107.m (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test107.m (revision 15767) @@ -5,5 +5,5 @@ md=extrude(md,5,3.); md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,PrognosticSolutionEnum()); +md=solve(md,MasstransportSolutionEnum()); %Fields and tolerances to track changes @@ -11,4 +11,4 @@ field_tolerances={1e-13}; field_values={... - (md.results.PrognosticSolution.Thickness),... + (md.results.MasstransportSolution.Thickness),... }; Index: /issm/trunk-jpl/test/NightlyRun/test107.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test107.py (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test107.py (revision 15767) @@ -14,5 +14,5 @@ md.extrude(5,3.) md.cluster=generic('name',oshostname(),'np',3) -md=solve(md,PrognosticSolutionEnum()) +md=solve(md,MasstransportSolutionEnum()) #Fields and tolerances to track changes @@ -20,4 +20,4 @@ field_tolerances=[1e-13] field_values=[\ - md.results.PrognosticSolution.Thickness,\ + md.results.MasstransportSolution.Thickness,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test109.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test109.m (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test109.m (revision 15767) @@ -6,5 +6,5 @@ md.cluster=generic('name',oshostname(),'np',3); md.transient.isdiagnostic=0; -md.transient.isprognostic=0; +md.transient.ismasstransport=0; md.transient.isthermal=1; md.transient.isgroundingline=0; Index: /issm/trunk-jpl/test/NightlyRun/test109.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test109.py (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test109.py (revision 15767) @@ -15,5 +15,5 @@ md.cluster=generic('name',oshostname(),'np',3) md.transient.isdiagnostic=False -md.transient.isprognostic=False +md.transient.ismasstransport=False md.transient.isthermal=True md.transient.isgroundingline=False Index: /issm/trunk-jpl/test/NightlyRun/test1110.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test1110.m (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test1110.m (revision 15767) @@ -47,10 +47,10 @@ md.diagnostic.vertex_pairing=[posx,posx2;posy,posy2]; - md.prognostic.vertex_pairing=[posx,posx2;posy,posy2]; + md.masstransport.vertex_pairing=[posx,posx2;posy,posy2]; md.timestepping.time_step=3.; md.timestepping.final_time=300.; md.settings.output_frequency=50; - md.prognostic.stabilization=1; + md.masstransport.stabilization=1; md.diagnostic.maxiter=1; Index: /issm/trunk-jpl/test/NightlyRun/test1201.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test1201.m (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test1201.m (revision 15767) @@ -5,5 +5,5 @@ for stabilization=1:3; - %The goal is to test the prognostic model + %The goal is to test the masstransport model md=bamg(model(),'domain','../Exp/SquareEISMINT.exp','hmax',3000.); md=setmask(md,'all',''); @@ -19,7 +19,7 @@ %Stabilization if stabilization==2, - md.prognostic.stabilization=0; + md.masstransport.stabilization=0; else - md.prognostic.stabilization=stabilization; + md.masstransport.stabilization=stabilization; end @@ -27,9 +27,9 @@ pos=find(md.mesh.y>199999.9); times=0:1:500; - md.prognostic.spcthickness=NaN*ones(md.mesh.numberofvertices+1,length(times)); - md.prognostic.spcthickness(end,:)=times; - md.prognostic.spcthickness(pos,:)=repmat(500.+100.*sin(2.*pi*times/200.),length(pos),1); + md.masstransport.spcthickness=NaN*ones(md.mesh.numberofvertices+1,length(times)); + md.masstransport.spcthickness(end,:)=times; + md.masstransport.spcthickness(pos,:)=repmat(500.+100.*sin(2.*pi*times/200.),length(pos),1); if stabilization==3, - pos=find(isnan(md.prognostic.spcthickness)); md.prognostic.spcthickness(pos)=500.; %No NaN for DG + pos=find(isnan(md.masstransport.spcthickness)); md.masstransport.spcthickness(pos)=500.; %No NaN for DG end Index: /issm/trunk-jpl/test/NightlyRun/test1201.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test1201.py (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test1201.py (revision 15767) @@ -18,5 +18,5 @@ for stabilization in xrange(1,4): - #The goal is to test the prognostic model + #The goal is to test the masstransport model md=bamg(model(),'domain','../Exp/SquareEISMINT.exp','hmax',3000.) md=setmask(md,'all','') @@ -32,17 +32,17 @@ #Stabilization if stabilization==2: - md.prognostic.stabilization=0 + md.masstransport.stabilization=0 else: - md.prognostic.stabilization=stabilization + md.masstransport.stabilization=stabilization #spc thickness pos=numpy.nonzero(md.mesh.y>199999.9)[0] times=numpy.arange(0,501) - md.prognostic.spcthickness=float('NaN')*numpy.ones((md.mesh.numberofvertices+1,numpy.size(times))) - md.prognostic.spcthickness[-1,:]=times - md.prognostic.spcthickness[pos,:]=numpy.tile(500.+100.*numpy.sin(2.*numpy.pi*times/200.),(numpy.size(pos),1)) + md.masstransport.spcthickness=float('NaN')*numpy.ones((md.mesh.numberofvertices+1,numpy.size(times))) + md.masstransport.spcthickness[-1,:]=times + md.masstransport.spcthickness[pos,:]=numpy.tile(500.+100.*numpy.sin(2.*numpy.pi*times/200.),(numpy.size(pos),1)) if stabilization==3: - pos=numpy.nonzero(numpy.isnan(md.prognostic.spcthickness)) - md.prognostic.spcthickness[pos]=500. #No NaN for DG + pos=numpy.nonzero(numpy.isnan(md.masstransport.spcthickness)) + md.masstransport.spcthickness[pos]=500. #No NaN for DG #solve Index: /issm/trunk-jpl/test/NightlyRun/test1202.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test1202.m (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test1202.m (revision 15767) @@ -1,3 +1,3 @@ -%Test on the diagnostic model and the prognostic in 2d. +%Test on the diagnostic model and the masstransport in 2d. printingflag=false; Index: /issm/trunk-jpl/test/NightlyRun/test1202.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test1202.py (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test1202.py (revision 15767) @@ -10,5 +10,5 @@ """ -Test on the diagnostic model and the prognostic in 2d +Test on the diagnostic model and the masstransport in 2d """ Index: /issm/trunk-jpl/test/NightlyRun/test1203.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test1203.m (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test1203.m (revision 15767) @@ -1,3 +1,3 @@ -%Test on the diagnostic model and the prognostic in 2d +%Test on the diagnostic model and the masstransport in 2d printingflag=false; Index: /issm/trunk-jpl/test/NightlyRun/test1203.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test1203.py (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test1203.py (revision 15767) @@ -11,5 +11,5 @@ """ -Test on the diagnostic model and the prognostic in 2d +Test on the diagnostic model and the masstransport in 2d """ Index: /issm/trunk-jpl/test/NightlyRun/test1204.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test1204.m (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test1204.m (revision 15767) @@ -1,3 +1,3 @@ -%Test on the diagnostic model and the prognostic in 2d +%Test on the diagnostic model and the masstransport in 2d printingflag=false; @@ -23,5 +23,5 @@ md.timestepping.time_step=1.; md.timestepping.final_time=5000.; -md.prognostic.stabilization=1; +md.masstransport.stabilization=1; md=solve(md,TransientSolutionEnum()); Index: /issm/trunk-jpl/test/NightlyRun/test1204.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test1204.py (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test1204.py (revision 15767) @@ -11,5 +11,5 @@ """ -Test on the diagnostic model and the prognostic in 2d +Test on the diagnostic model and the masstransport in 2d """ @@ -37,5 +37,5 @@ md.timestepping.time_step=1. md.timestepping.final_time=5000. -md.prognostic.stabilization=1 +md.masstransport.stabilization=1 md=solve(md,TransientSolutionEnum()) Index: /issm/trunk-jpl/test/NightlyRun/test1208.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test1208.m (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test1208.m (revision 15767) @@ -22,5 +22,5 @@ md.settings.output_frequency=500; md.timestepping.final_time=30000.; -md.prognostic.stabilization=1; +md.masstransport.stabilization=1; md.thermal.stabilization=1; Index: /issm/trunk-jpl/test/NightlyRun/test1208.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test1208.py (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test1208.py (revision 15767) @@ -35,5 +35,5 @@ md.settings.output_frequency=500 md.timestepping.final_time=30000. -md.prognostic.stabilization=1 +md.masstransport.stabilization=1 md.thermal.stabilization=1 Index: /issm/trunk-jpl/test/NightlyRun/test121.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test121.m (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test121.m (revision 15767) @@ -7,5 +7,5 @@ md.initialization.waterfraction=zeros(md.mesh.numberofvertices,1); md.transient.isdiagnostic=0; -md.transient.isprognostic=0; +md.transient.ismasstransport=0; md.transient.isthermal=1; md.transient.isgroundingline=0; Index: /issm/trunk-jpl/test/NightlyRun/test121.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test121.py (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test121.py (revision 15767) @@ -16,5 +16,5 @@ md.initialization.waterfraction=numpy.zeros((md.mesh.numberofvertices,1)) md.transient.isdiagnostic=False -md.transient.isprognostic=False +md.transient.ismasstransport=False md.transient.isthermal=True md.transient.isgroundingline=False Index: /issm/trunk-jpl/test/NightlyRun/test1501.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test1501.m (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test1501.m (revision 15767) @@ -17,9 +17,9 @@ md.basalforcings.melting_rate= smb; -md=solve(md,PrognosticSolutionEnum()); +md=solve(md,MasstransportSolutionEnum()); for i=1:10 - md=solve(md,PrognosticSolutionEnum()); - md.surfaceforcings.mass_balance= md.surfaceforcings.mass_balance - ((md.results.PrognosticSolution.Thickness)-md.geometry.thickness); + md=solve(md,MasstransportSolutionEnum()); + md.surfaceforcings.mass_balance= md.surfaceforcings.mass_balance - ((md.results.MasstransportSolution.Thickness)-md.geometry.thickness); end Index: /issm/trunk-jpl/test/NightlyRun/test1501.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test1501.py (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test1501.py (revision 15767) @@ -28,9 +28,9 @@ md.basalforcings.melting_rate= smb -md=solve(md,PrognosticSolutionEnum()) +md=solve(md,MasstransportSolutionEnum()) for i in xrange(1,11): - md=solve(md,PrognosticSolutionEnum()) - md.surfaceforcings.mass_balance= md.surfaceforcings.mass_balance - ((md.results.PrognosticSolution.Thickness)-md.geometry.thickness) + md=solve(md,MasstransportSolutionEnum()) + md.surfaceforcings.mass_balance= md.surfaceforcings.mass_balance - ((md.results.MasstransportSolution.Thickness)-md.geometry.thickness) #Set up transient Index: /issm/trunk-jpl/test/NightlyRun/test1502.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test1502.m (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test1502.m (revision 15767) @@ -18,9 +18,9 @@ md.basalforcings.melting_rate= smb; -md=solve(md,PrognosticSolutionEnum()); +md=solve(md,MasstransportSolutionEnum()); for i=1:10 - md=solve(md,PrognosticSolutionEnum()); - md.surfaceforcings.mass_balance= md.surfaceforcings.mass_balance - ((md.results.PrognosticSolution.Thickness)-md.geometry.thickness); + md=solve(md,MasstransportSolutionEnum()); + md.surfaceforcings.mass_balance= md.surfaceforcings.mass_balance - ((md.results.MasstransportSolution.Thickness)-md.geometry.thickness); end Index: /issm/trunk-jpl/test/NightlyRun/test1502.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test1502.py (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test1502.py (revision 15767) @@ -29,9 +29,9 @@ md.basalforcings.melting_rate= smb -md=solve(md,PrognosticSolutionEnum()) +md=solve(md,MasstransportSolutionEnum()) for i in xrange(1,11): - md=solve(md,PrognosticSolutionEnum()) - md.surfaceforcings.mass_balance= md.surfaceforcings.mass_balance - ((md.results.PrognosticSolution.Thickness)-md.geometry.thickness) + md=solve(md,MasstransportSolutionEnum()) + md.surfaceforcings.mass_balance= md.surfaceforcings.mass_balance - ((md.results.MasstransportSolution.Thickness)-md.geometry.thickness) #Set up transient Index: /issm/trunk-jpl/test/NightlyRun/test207.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test207.m (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test207.m (revision 15767) @@ -6,5 +6,5 @@ md.cluster=generic('name',oshostname(),'np',3); md.transient.isdiagnostic=0; -md.transient.isprognostic=0; +md.transient.ismasstransport=0; md.transient.isthermal=1; md.transient.isgroundingline=0; Index: /issm/trunk-jpl/test/NightlyRun/test207.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test207.py (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test207.py (revision 15767) @@ -16,5 +16,5 @@ md.cluster=generic('name',oshostname(),'np',3) md.transient.isdiagnostic=False -md.transient.isprognostic=False +md.transient.ismasstransport=False md.transient.isthermal=True md.transient.isgroundingline=False Index: /issm/trunk-jpl/test/NightlyRun/test222.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test222.m (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test222.m (revision 15767) @@ -4,5 +4,5 @@ md=setflowequation(md,'SSA','all'); md.cluster=generic('name',oshostname(),'np',3); -md.prognostic.hydrostatic_adjustment='Incremental'; +md.masstransport.hydrostatic_adjustment='Incremental'; md=solve(md,TransientSolutionEnum()); Index: /issm/trunk-jpl/test/NightlyRun/test222.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test222.py (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test222.py (revision 15767) @@ -13,5 +13,5 @@ md=setflowequation(md,'SSA','all') md.cluster=generic('name',oshostname(),'np',3) -md.prognostic.hydrostatic_adjustment='Incremental' +md.masstransport.hydrostatic_adjustment='Incremental' md=solve(md,TransientSolutionEnum()) Index: /issm/trunk-jpl/test/NightlyRun/test223.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test223.m (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test223.m (revision 15767) @@ -5,5 +5,5 @@ md.geometry.bed=md.geometry.bed+50.; md.geometry.surface=md.geometry.surface+50.; md.cluster=generic('name',oshostname(),'np',1); -md.prognostic.hydrostatic_adjustment='Incremental'; +md.masstransport.hydrostatic_adjustment='Incremental'; md=solve(md,TransientSolutionEnum()); Index: /issm/trunk-jpl/test/NightlyRun/test223.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test223.py (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test223.py (revision 15767) @@ -15,5 +15,5 @@ md.geometry.surface=md.geometry.surface+50. md.cluster=generic('name',oshostname(),'np',1) -md.prognostic.hydrostatic_adjustment='Incremental' +md.masstransport.hydrostatic_adjustment='Incremental' md=solve(md,TransientSolutionEnum()) Index: /issm/trunk-jpl/test/NightlyRun/test224.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test224.m (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test224.m (revision 15767) @@ -5,5 +5,5 @@ md=setflowequation(md,'HO','all'); md.cluster=generic('name',oshostname(),'np',3); -md.prognostic.hydrostatic_adjustment='Incremental'; +md.masstransport.hydrostatic_adjustment='Incremental'; md=solve(md,TransientSolutionEnum()); Index: /issm/trunk-jpl/test/NightlyRun/test224.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test224.py (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test224.py (revision 15767) @@ -14,5 +14,5 @@ md=setflowequation(md,'HO','all') md.cluster=generic('name',oshostname(),'np',3) -md.prognostic.hydrostatic_adjustment='Incremental' +md.masstransport.hydrostatic_adjustment='Incremental' md=solve(md,TransientSolutionEnum()) Index: /issm/trunk-jpl/test/NightlyRun/test225.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test225.m (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test225.m (revision 15767) @@ -6,5 +6,5 @@ md=setflowequation(md,'HO','all'); md.cluster=generic('name',oshostname(),'np',3); -md.prognostic.hydrostatic_adjustment='Incremental'; +md.masstransport.hydrostatic_adjustment='Incremental'; md=solve(md,TransientSolutionEnum()); Index: /issm/trunk-jpl/test/NightlyRun/test225.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test225.py (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test225.py (revision 15767) @@ -16,5 +16,5 @@ md=setflowequation(md,'HO','all') md.cluster=generic('name',oshostname(),'np',3) -md.prognostic.hydrostatic_adjustment='Incremental' +md.masstransport.hydrostatic_adjustment='Incremental' md=solve(md,TransientSolutionEnum()) Index: /issm/trunk-jpl/test/NightlyRun/test232.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test232.m (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test232.m (revision 15767) @@ -9,5 +9,5 @@ md.timestepping.final_time=4; md.transient.isdiagnostic=0; -md.transient.isprognostic=0; +md.transient.ismasstransport=0; md.transient.isthermal=1; md.transient.isgroundingline=0; Index: /issm/trunk-jpl/test/NightlyRun/test232.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test232.py (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test232.py (revision 15767) @@ -19,5 +19,5 @@ md.timestepping.final_time=4. md.transient.isdiagnostic=False -md.transient.isprognostic=False +md.transient.ismasstransport=False md.transient.isthermal=True md.transient.isgroundingline=False Index: /issm/trunk-jpl/test/NightlyRun/test3005.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test3005.m (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test3005.m (revision 15767) @@ -7,5 +7,5 @@ md.toolkits.DefaultAnalysis=issmsolver(); md.verbose=verbose('autodiff',true); -md=solve(md,PrognosticSolutionEnum()); +md=solve(md,MasstransportSolutionEnum()); %Fields and tolerances to track changes @@ -13,4 +13,4 @@ field_tolerances={1e-13}; field_values={... - (md.results.PrognosticSolution.Thickness),... + (md.results.MasstransportSolution.Thickness),... }; Index: /issm/trunk-jpl/test/NightlyRun/test3005.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test3005.py (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test3005.py (revision 15767) @@ -15,5 +15,5 @@ md.toolkits.DefaultAnalysis=issmsolver() md.autodiff.isautodiff=True -md=solve(md,PrognosticSolutionEnum()) +md=solve(md,MasstransportSolutionEnum()) #Fields and tolerances to track changes @@ -21,4 +21,4 @@ field_tolerances=[1e-13] field_values=[\ - md.results.PrognosticSolution.Thickness,\ + md.results.MasstransportSolution.Thickness,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test3006.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test3006.m (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test3006.m (revision 15767) @@ -5,10 +5,10 @@ md=setflowequation(md,'SSA','all'); md.cluster=generic('name',oshostname(),'np',1); -md.prognostic.stabilization=3; -md.prognostic.spcthickness=md.geometry.thickness; +md.masstransport.stabilization=3; +md.masstransport.spcthickness=md.geometry.thickness; md.autodiff.isautodiff=true; md.toolkits.DefaultAnalysis=issmsolver(); md.verbose=verbose('autodiff',true); -md=solve(md,PrognosticSolutionEnum()); +md=solve(md,MasstransportSolutionEnum()); %Fields and tolerances to track changes @@ -16,4 +16,4 @@ field_tolerances={1e-13}; field_values={... - (md.results.PrognosticSolution.Thickness),... + (md.results.MasstransportSolution.Thickness),... }; Index: /issm/trunk-jpl/test/NightlyRun/test3006.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test3006.py (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test3006.py (revision 15767) @@ -15,9 +15,9 @@ md=setflowequation(md,'SSA','all') md.cluster=generic('name',oshostname(),'np',1) -md.prognostic.stabilization=3 -md.prognostic.spcthickness=md.geometry.thickness +md.masstransport.stabilization=3 +md.masstransport.spcthickness=md.geometry.thickness md.toolkits.DefaultAnalysis=issmsolver() md.autodiff.isautodiff=True -md=solve(md,PrognosticSolutionEnum()) +md=solve(md,MasstransportSolutionEnum()) #Fields and tolerances to track changes @@ -25,4 +25,4 @@ field_tolerances=[1e-13] field_values=[\ - md.results.PrognosticSolution.Thickness,\ + md.results.MasstransportSolution.Thickness,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test3007.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test3007.m (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test3007.m (revision 15767) @@ -8,5 +8,5 @@ md.verbose=verbose('autodiff',true); md.toolkits.DefaultAnalysis=issmsolver(); -md=solve(md,PrognosticSolutionEnum()); +md=solve(md,MasstransportSolutionEnum()); %Fields and tolerances to track changes @@ -14,4 +14,4 @@ field_tolerances={1e-13}; field_values={... - (md.results.PrognosticSolution.Thickness),... + (md.results.MasstransportSolution.Thickness),... }; Index: /issm/trunk-jpl/test/NightlyRun/test3007.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test3007.py (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test3007.py (revision 15767) @@ -16,5 +16,5 @@ md.toolkits.DefaultAnalysis=issmsolver() md.autodiff.isautodiff=True -md=solve(md,PrognosticSolutionEnum()) +md=solve(md,MasstransportSolutionEnum()) #Fields and tolerances to track changes @@ -22,4 +22,4 @@ field_tolerances=[1e-13] field_values=[\ - md.results.PrognosticSolution.Thickness,\ + md.results.MasstransportSolution.Thickness,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test3009.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test3009.m (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test3009.m (revision 15767) @@ -6,5 +6,5 @@ md.cluster=generic('name',oshostname(),'np',1); md.transient.isdiagnostic=0; -md.transient.isprognostic=0; +md.transient.ismasstransport=0; md.transient.isthermal=1; md.transient.isgroundingline=0; Index: /issm/trunk-jpl/test/NightlyRun/test3009.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test3009.py (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test3009.py (revision 15767) @@ -15,5 +15,5 @@ md.cluster=generic('name',oshostname(),'np',1) md.transient.isdiagnostic=False -md.transient.isprognostic=False +md.transient.ismasstransport=False md.transient.isthermal=True md.transient.isgroundingline=False Index: /issm/trunk-jpl/test/NightlyRun/test3015.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test3015.m (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test3015.m (revision 15767) @@ -8,5 +8,5 @@ md=setflowequation(md,'SSA','all'); md.cluster=generic('name',oshostname(),'np',1); -md.prognostic.requested_outputs=IceVolumeEnum(); +md.masstransport.requested_outputs=IceVolumeEnum(); md.verbose=verbose('autodiff',true); md.toolkits.DefaultAnalysis=issmsolver(); @@ -42,6 +42,6 @@ md=SetIceShelfBC(md); -md=solve(md,PrognosticSolutionEnum()); -V0=md.results.PrognosticSolution.IceVolume; +md=solve(md,MasstransportSolutionEnum()); +V0=md.results.MasstransportSolution.IceVolume; %backward @@ -53,6 +53,6 @@ md=SetIceShelfBC(md); -md=solve(md,PrognosticSolutionEnum()); -V2=md.results.PrognosticSolution.IceVolume; +md=solve(md,MasstransportSolutionEnum()); +V2=md.results.MasstransportSolution.IceVolume; %compute resulting derivative @@ -67,7 +67,7 @@ md=SetIceShelfBC(md); -md=solve(md,PrognosticSolutionEnum()); +md=solve(md,MasstransportSolutionEnum()); %retrieve directly -dVdh_ad=md.results.PrognosticSolution.AutodiffJacobian; +dVdh_ad=md.results.MasstransportSolution.AutodiffJacobian; disp(sprintf('dV/dh: analytical: %16.16g\n using adolc: %16.16g\n',dVdh_an,dVdh_ad)); Index: /issm/trunk-jpl/test/NightlyRun/test3015.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test3015.py (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test3015.py (revision 15767) @@ -22,5 +22,5 @@ md=setflowequation(md,'SSA','all') md.cluster=generic('name',oshostname(),'np',3) -md.prognostic.requested_outputs=IceVolumeEnum() +md.masstransport.requested_outputs=IceVolumeEnum() md.verbose=verbose('autodiff',True) @@ -55,6 +55,6 @@ md=SetIceShelfBC(md) -md=solve(md,PrognosticSolutionEnum()) -V0=md.results.PrognosticSolution.IceVolume +md=solve(md,MasstransportSolutionEnum()) +V0=md.results.MasstransportSolution.IceVolume #backward @@ -66,6 +66,6 @@ md=SetIceShelfBC(md) -md=solve(md,PrognosticSolutionEnum()) -V2=md.results.PrognosticSolution.IceVolume +md=solve(md,MasstransportSolutionEnum()) +V2=md.results.MasstransportSolution.IceVolume #compute resulting derivative @@ -80,7 +80,7 @@ md=SetIceShelfBC(md) -md=solve(md,PrognosticSolutionEnum()) +md=solve(md,MasstransportSolutionEnum()) #retrieve directly -dVdh_ad=md.results.PrognosticSolution.AutodiffJacobian +dVdh_ad=md.results.MasstransportSolution.AutodiffJacobian print "dV/dh: analytical: #16.16g\n using adolc: #16.16g\n" % (dVdh_an,dVdh_ad) Index: /issm/trunk-jpl/test/NightlyRun/test309.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test309.m (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test309.m (revision 15767) @@ -4,5 +4,5 @@ md=setflowequation(md,'SSA','all'); md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,PrognosticSolutionEnum()); +md=solve(md,MasstransportSolutionEnum()); %Fields and tolerances to track changes @@ -10,4 +10,4 @@ field_tolerances={1e-13}; field_values={... - (md.results.PrognosticSolution.Thickness),... + (md.results.MasstransportSolution.Thickness),... }; Index: /issm/trunk-jpl/test/NightlyRun/test309.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test309.py (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test309.py (revision 15767) @@ -13,5 +13,5 @@ md=setflowequation(md,'SSA','all') md.cluster=generic('name',oshostname(),'np',3) -md=solve(md,PrognosticSolutionEnum()) +md=solve(md,MasstransportSolutionEnum()) #Fields and tolerances to track changes @@ -19,4 +19,4 @@ field_tolerances=[1e-13] field_values=[\ - md.results.PrognosticSolution.Thickness,\ + md.results.MasstransportSolution.Thickness,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test310.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test310.m (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test310.m (revision 15767) @@ -4,8 +4,8 @@ md=parameterize(md,'../Par/SquareSheetConstrained.par'); md=setflowequation(md,'SSA','all'); -md.prognostic.stabilization=3; -md.prognostic.spcthickness=md.geometry.thickness; +md.masstransport.stabilization=3; +md.masstransport.spcthickness=md.geometry.thickness; md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,PrognosticSolutionEnum()); +md=solve(md,MasstransportSolutionEnum()); %Fields and tolerances to track changes @@ -13,4 +13,4 @@ field_tolerances={1e-13}; field_values={... - (md.results.PrognosticSolution.Thickness),... + (md.results.MasstransportSolution.Thickness),... }; Index: /issm/trunk-jpl/test/NightlyRun/test310.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test310.py (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test310.py (revision 15767) @@ -14,8 +14,8 @@ md=parameterize(md,'../Par/SquareSheetConstrained.py') md=setflowequation(md,'SSA','all') -md.prognostic.stabilization=3 -md.prognostic.spcthickness=md.geometry.thickness +md.masstransport.stabilization=3 +md.masstransport.spcthickness=md.geometry.thickness md.cluster=generic('name',oshostname(),'np',3) -md=solve(md,PrognosticSolutionEnum()) +md=solve(md,MasstransportSolutionEnum()) #Fields and tolerances to track changes @@ -23,4 +23,4 @@ field_tolerances=[1e-13] field_values=[\ - md.results.PrognosticSolution.Thickness,\ + md.results.MasstransportSolution.Thickness,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test311.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test311.m (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test311.m (revision 15767) @@ -5,5 +5,5 @@ md=extrude(md,5,0.5); md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,PrognosticSolutionEnum()); +md=solve(md,MasstransportSolutionEnum()); %Fields and tolerances to track changes @@ -11,4 +11,4 @@ field_tolerances={1e-13}; field_values={... - (md.results.PrognosticSolution.Thickness),... + (md.results.MasstransportSolution.Thickness),... }; Index: /issm/trunk-jpl/test/NightlyRun/test311.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test311.py (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test311.py (revision 15767) @@ -14,5 +14,5 @@ md.extrude(5,0.5) md.cluster=generic('name',oshostname(),'np',3) -md=solve(md,PrognosticSolutionEnum()) +md=solve(md,MasstransportSolutionEnum()) #Fields and tolerances to track changes @@ -20,4 +20,4 @@ field_tolerances=[1e-13] field_values=[\ - md.results.PrognosticSolution.Thickness,\ + md.results.MasstransportSolution.Thickness,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test313.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test313.m (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test313.m (revision 15767) @@ -7,5 +7,5 @@ md.verbose=verbose('convergence',true,'solution',true); md.transient.isdiagnostic=0; -md.transient.isprognostic=0; +md.transient.ismasstransport=0; md.transient.isthermal=1; md.transient.isgroundingline=0; Index: /issm/trunk-jpl/test/NightlyRun/test313.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test313.py (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test313.py (revision 15767) @@ -16,5 +16,5 @@ md.verbose=verbose('convergence',True,'solution',True) md.transient.isdiagnostic=False -md.transient.isprognostic=False +md.transient.ismasstransport=False md.transient.isthermal=True md.transient.isgroundingline=False Index: /issm/trunk-jpl/test/NightlyRun/test326.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test326.m (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test326.m (revision 15767) @@ -7,5 +7,5 @@ md.initialization.waterfraction=zeros(md.mesh.numberofvertices,1); md.transient.isdiagnostic=0; -md.transient.isprognostic=0; +md.transient.ismasstransport=0; md.transient.isthermal=1; md.transient.isgroundingline=0; Index: /issm/trunk-jpl/test/NightlyRun/test326.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test326.py (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test326.py (revision 15767) @@ -17,5 +17,5 @@ md.initialization.waterfraction=numpy.zeros((md.mesh.numberofvertices,1)) md.transient.isdiagnostic=False -md.transient.isprognostic=False +md.transient.ismasstransport=False md.transient.isthermal=True md.transient.isgroundingline=False Index: /issm/trunk-jpl/test/NightlyRun/test407.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test407.m (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test407.m (revision 15767) @@ -6,5 +6,5 @@ md.cluster=generic('name',oshostname(),'np',3); md.transient.isdiagnostic=0; -md.transient.isprognostic=0; +md.transient.ismasstransport=0; md.transient.isthermal=1; md.transient.isgroundingline=0; Index: /issm/trunk-jpl/test/NightlyRun/test407.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test407.py (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test407.py (revision 15767) @@ -16,5 +16,5 @@ md.cluster=generic('name',oshostname(),'np',3) md.transient.isdiagnostic=False -md.transient.isprognostic=False +md.transient.ismasstransport=False md.transient.isthermal=True md.transient.isgroundingline=False Index: /issm/trunk-jpl/test/NightlyRun/test423.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test423.m (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test423.m (revision 15767) @@ -19,5 +19,5 @@ md.transient.isthermal=0; -md.transient.isprognostic=0; +md.transient.ismasstransport=0; md.transient.isdiagnostic=1; md.transient.isgroundingline=1; Index: /issm/trunk-jpl/test/NightlyRun/test423.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test423.py (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test423.py (revision 15767) @@ -30,5 +30,5 @@ md.transient.isthermal=False -md.transient.isprognostic=False +md.transient.ismasstransport=False md.transient.isdiagnostic=True md.transient.isgroundingline=True Index: /issm/trunk-jpl/test/NightlyRun/test433.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test433.m (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test433.m (revision 15767) @@ -20,5 +20,5 @@ md.transient.isthermal=0; -md.transient.isprognostic=0; +md.transient.ismasstransport=0; md.transient.isdiagnostic=0; md.transient.isgroundingline=1; Index: /issm/trunk-jpl/test/NightlyRun/test433.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test433.py (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test433.py (revision 15767) @@ -31,5 +31,5 @@ md.transient.isthermal=False -md.transient.isprognostic=False +md.transient.ismasstransport=False md.transient.isdiagnostic=False md.transient.isgroundingline=True Index: /issm/trunk-jpl/test/NightlyRun/test515.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test515.m (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test515.m (revision 15767) @@ -7,5 +7,5 @@ md.cluster=generic('name',oshostname(),'np',3); md.transient.isdiagnostic=0; -md.transient.isprognostic=0; +md.transient.ismasstransport=0; md.transient.isthermal=1; md.transient.isgroundingline=0; Index: /issm/trunk-jpl/test/NightlyRun/test515.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test515.py (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test515.py (revision 15767) @@ -16,5 +16,5 @@ md.cluster=generic('name',oshostname(),'np',3) md.transient.isdiagnostic=False -md.transient.isprognostic=False +md.transient.ismasstransport=False md.transient.isthermal=True md.transient.isgroundingline=False Index: /issm/trunk-jpl/test/NightlyRun/test601.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test601.m (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test601.m (revision 15767) @@ -4,5 +4,5 @@ md=setflowequation(md,'SSA','all'); md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,PrognosticSolutionEnum()); +md=solve(md,MasstransportSolutionEnum()); %Fields and tolerances to track changes @@ -10,4 +10,4 @@ field_tolerances={1e-13}; field_values={... - (md.results.PrognosticSolution.Thickness),... + (md.results.MasstransportSolution.Thickness),... }; Index: /issm/trunk-jpl/test/NightlyRun/test601.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test601.py (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test601.py (revision 15767) @@ -13,5 +13,5 @@ md=setflowequation(md,'SSA','all') md.cluster=generic('name',oshostname(),'np',3) -md=solve(md,PrognosticSolutionEnum()) +md=solve(md,MasstransportSolutionEnum()) #Fields and tolerances to track changes @@ -19,4 +19,4 @@ field_tolerances=[1e-13] field_values=[\ - md.results.PrognosticSolution.Thickness,\ + md.results.MasstransportSolution.Thickness,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test602.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test602.m (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test602.m (revision 15767) @@ -4,8 +4,8 @@ md=parameterize(md,'../Par/79North.par'); md=setflowequation(md,'SSA','all'); -md.prognostic.stabilization=3; -md.prognostic.spcthickness=md.geometry.thickness; +md.masstransport.stabilization=3; +md.masstransport.spcthickness=md.geometry.thickness; md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,PrognosticSolutionEnum()); +md=solve(md,MasstransportSolutionEnum()); %Fields and tolerances to track changes @@ -13,4 +13,4 @@ field_tolerances={1e-13}; field_values={... - (md.results.PrognosticSolution.Thickness),... + (md.results.MasstransportSolution.Thickness),... }; Index: /issm/trunk-jpl/test/NightlyRun/test602.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test602.py (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test602.py (revision 15767) @@ -15,8 +15,8 @@ md=parameterize(md,'../Par/79North.py') md=setflowequation(md,'SSA','all') -md.prognostic.stabilization=3 -md.prognostic.spcthickness=md.geometry.thickness +md.masstransport.stabilization=3 +md.masstransport.spcthickness=md.geometry.thickness md.cluster=generic('name',oshostname(),'np',3) -md=solve(md,PrognosticSolutionEnum()) +md=solve(md,MasstransportSolutionEnum()) #Fields and tolerances to track changes @@ -24,4 +24,4 @@ field_tolerances=[1e-13] field_values=[\ - md.results.PrognosticSolution.Thickness,\ + md.results.MasstransportSolution.Thickness,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test603.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test603.m (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test603.m (revision 15767) @@ -5,5 +5,5 @@ md=setflowequation(md,'SSA','all'); md.cluster=generic('name',oshostname(),'np',3); -md=solve(md,PrognosticSolutionEnum()); +md=solve(md,MasstransportSolutionEnum()); %Fields and tolerances to track changes @@ -11,4 +11,4 @@ field_tolerances={1e-13}; field_values={... - (md.results.PrognosticSolution.Thickness),... + (md.results.MasstransportSolution.Thickness),... }; Index: /issm/trunk-jpl/test/NightlyRun/test603.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test603.py (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test603.py (revision 15767) @@ -15,5 +15,5 @@ md=setflowequation(md,'SSA','all') md.cluster=generic('name',oshostname(),'np',3) -md=solve(md,PrognosticSolutionEnum()) +md=solve(md,MasstransportSolutionEnum()) #Fields and tolerances to track changes @@ -21,4 +21,4 @@ field_tolerances=[1e-13] field_values=[\ - md.results.PrognosticSolution.Thickness,\ + md.results.MasstransportSolution.Thickness,\ ] Index: /issm/trunk-jpl/test/NightlyRun/test611.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test611.m (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test611.m (revision 15767) @@ -6,5 +6,5 @@ %control parameters md.inversion.nsteps=2; -md.prognostic.stabilization=1; +md.masstransport.stabilization=1; md.inversion.iscontrol=1; md.inversion.control_parameters={'BalancethicknessThickeningRate'}; Index: /issm/trunk-jpl/test/NightlyRun/test611.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test611.py (revision 15766) +++ /issm/trunk-jpl/test/NightlyRun/test611.py (revision 15767) @@ -16,5 +16,5 @@ #control parameters md.inversion.nsteps=2 -md.prognostic.stabilization=1 +md.masstransport.stabilization=1 md.inversion.iscontrol=1 md.inversion.control_parameters=['BalancethicknessThickeningRate'] Index: /issm/trunk-jpl/test/Par/79North.par =================================================================== --- /issm/trunk-jpl/test/Par/79North.par (revision 15766) +++ /issm/trunk-jpl/test/Par/79North.par (revision 15767) @@ -36,5 +36,5 @@ %Numerical parameters md.diagnostic.viscosity_overshoot=0.3; -md.prognostic.stabilization=1; +md.masstransport.stabilization=1; md.thermal.stabilization=1; md.verbose=verbose(0); @@ -51,5 +51,5 @@ pos=find(md.mesh.vertexonboundary); md.balancethickness.spcthickness(pos)=md.geometry.thickness(pos); -md.prognostic.spcthickness(pos)=md.geometry.thickness(pos); +md.masstransport.spcthickness(pos)=md.geometry.thickness(pos); %Change name so that no test have the same name Index: /issm/trunk-jpl/test/Par/79North.py =================================================================== --- /issm/trunk-jpl/test/Par/79North.py (revision 15766) +++ /issm/trunk-jpl/test/Par/79North.py (revision 15767) @@ -48,5 +48,5 @@ #Numerical parameters md.diagnostic.viscosity_overshoot=0.3 -md.prognostic.stabilization=1 +md.masstransport.stabilization=1 md.thermal.stabilization=1 md.verbose=verbose(0) @@ -63,5 +63,5 @@ pos=numpy.nonzero(md.mesh.vertexonboundary) md.balancethickness.spcthickness[pos]=md.geometry.thickness[pos] -md.prognostic.spcthickness[pos]=md.geometry.thickness[pos] +md.masstransport.spcthickness[pos]=md.geometry.thickness[pos] #Change name so that no test have the same name Index: /issm/trunk-jpl/test/Par/GiaBenchmarksAB.par =================================================================== --- /issm/trunk-jpl/test/Par/GiaBenchmarksAB.par (revision 15766) +++ /issm/trunk-jpl/test/Par/GiaBenchmarksAB.par (revision 15767) @@ -53,5 +53,5 @@ %Numerical parameters md.diagnostic.viscosity_overshoot=0.0; -md.prognostic.stabilization=1.; +md.masstransport.stabilization=1.; md.thermal.stabilization=1.; md.verbose=verbose(0); Index: /issm/trunk-jpl/test/Par/GiaBenchmarksCD.par =================================================================== --- /issm/trunk-jpl/test/Par/GiaBenchmarksCD.par (revision 15766) +++ /issm/trunk-jpl/test/Par/GiaBenchmarksCD.par (revision 15767) @@ -52,5 +52,5 @@ %Numerical parameters md.diagnostic.viscosity_overshoot=0.0; -md.prognostic.stabilization=1.; +md.masstransport.stabilization=1.; md.thermal.stabilization=1.; md.verbose=verbose(0); Index: /issm/trunk-jpl/test/Par/ISMIPF.par =================================================================== --- /issm/trunk-jpl/test/Par/ISMIPF.par (revision 15766) +++ /issm/trunk-jpl/test/Par/ISMIPF.par (revision 15767) @@ -31,6 +31,6 @@ md.balancethickness.spcthickness=NaN*ones(md.mesh.numberofvertices,1); md.balancethickness.spcthickness(pos)=md.geometry.thickness(pos); -md.prognostic.spcthickness=NaN*ones(md.mesh.numberofvertices,1); -md.prognostic.spcthickness(pos)=md.geometry.thickness(pos); +md.masstransport.spcthickness=NaN*ones(md.mesh.numberofvertices,1); +md.masstransport.spcthickness(pos)=md.geometry.thickness(pos); md.thermal.spctemperature=255.*ones(md.mesh.numberofvertices,1); md.basalforcings.geothermalflux=0.4*ones(md.mesh.numberofvertices,1); @@ -42,5 +42,5 @@ md.timestepping.time_step=1.; md.timestepping.final_time=10.; -md.prognostic.stabilization=1; +md.masstransport.stabilization=1; md.thermal.stabilization=1; md.thermal.penalty_threshold=10^5; Index: /issm/trunk-jpl/test/Par/ISMIPF.py =================================================================== --- /issm/trunk-jpl/test/Par/ISMIPF.py (revision 15766) +++ /issm/trunk-jpl/test/Par/ISMIPF.py (revision 15767) @@ -34,6 +34,6 @@ md.balancethickness.spcthickness=float('NaN')*numpy.ones((md.mesh.numberofvertices,1)) md.balancethickness.spcthickness[pos]=md.geometry.thickness[pos] -md.prognostic.spcthickness=float('NaN')*numpy.ones((md.mesh.numberofvertices,1)) -md.prognostic.spcthickness[pos]=md.geometry.thickness[pos] +md.masstransport.spcthickness=float('NaN')*numpy.ones((md.mesh.numberofvertices,1)) +md.masstransport.spcthickness[pos]=md.geometry.thickness[pos] md.thermal.spctemperature=255.*numpy.ones((md.mesh.numberofvertices,1)) md.basalforcings.geothermalflux=0.4*numpy.ones((md.mesh.numberofvertices,1)) @@ -45,5 +45,5 @@ md.timestepping.time_step=1. md.timestepping.final_time=10. -md.prognostic.stabilization=1 +md.masstransport.stabilization=1 md.thermal.stabilization=1 md.thermal.penalty_threshold=10**5 Index: /issm/trunk-jpl/test/Par/Pig.par =================================================================== --- /issm/trunk-jpl/test/Par/Pig.par (revision 15766) +++ /issm/trunk-jpl/test/Par/Pig.par (revision 15767) @@ -35,5 +35,5 @@ %Numerical parameters md.diagnostic.viscosity_overshoot=0.3; -md.prognostic.stabilization=1; +md.masstransport.stabilization=1; md.verbose=verbose(0); md.settings.waitonlock=30; Index: /issm/trunk-jpl/test/Par/Pig.py =================================================================== --- /issm/trunk-jpl/test/Par/Pig.py (revision 15766) +++ /issm/trunk-jpl/test/Par/Pig.py (revision 15767) @@ -46,5 +46,5 @@ #Numerical parameters md.diagnostic.viscosity_overshoot=0.3 -md.prognostic.stabilization=1. +md.masstransport.stabilization=1. md.verbose=verbose(0) md.settings.waitonlock=30 Index: /issm/trunk-jpl/test/Par/RoundSheetShelf.par =================================================================== --- /issm/trunk-jpl/test/Par/RoundSheetShelf.par (revision 15766) +++ /issm/trunk-jpl/test/Par/RoundSheetShelf.par (revision 15767) @@ -76,5 +76,5 @@ %Numerical parameters md.diagnostic.viscosity_overshoot=0.0; -md.prognostic.stabilization=1; +md.masstransport.stabilization=1; md.thermal.stabilization=1; md.verbose=verbose(0); @@ -103,5 +103,5 @@ md.mask.icelevelset(find(md.mesh.vertexonboundary))=0; md.balancethickness.spcthickness=NaN*ones(md.mesh.numberofvertices,1); -md.prognostic.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); Index: /issm/trunk-jpl/test/Par/RoundSheetShelf.py =================================================================== --- /issm/trunk-jpl/test/Par/RoundSheetShelf.py (revision 15766) +++ /issm/trunk-jpl/test/Par/RoundSheetShelf.py (revision 15767) @@ -84,5 +84,5 @@ #Numerical parameters md.diagnostic.viscosity_overshoot=0.0 -md.prognostic.stabilization=1 +md.masstransport.stabilization=1 md.thermal.stabilization=1 md.verbose=verbose(0) @@ -113,5 +113,5 @@ md.mask.icelevelset[pos]=0 md.balancethickness.spcthickness=float('nan')*numpy.ones((md.mesh.numberofvertices,1)) -md.prognostic.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)) Index: /issm/trunk-jpl/test/Par/SquareEISMINT.par =================================================================== --- /issm/trunk-jpl/test/Par/SquareEISMINT.par (revision 15766) +++ /issm/trunk-jpl/test/Par/SquareEISMINT.par (revision 15767) @@ -39,7 +39,7 @@ md.balancethickness.spcthickness=NaN*ones(md.mesh.numberofvertices,1); md.balancethickness.spcthickness(pos)=500.; -md.prognostic.spcthickness=NaN*ones(md.mesh.numberofvertices,1); -md.prognostic.spcthickness(pos)=500.; -md.prognostic.stabilization=0; %Better result with no artificial diffusivity +md.masstransport.spcthickness=NaN*ones(md.mesh.numberofvertices,1); +md.masstransport.spcthickness(pos)=500.; +md.masstransport.stabilization=0; %Better result with no artificial diffusivity md.thermal.stabilization=0; md.timestepping.final_time=500.; Index: /issm/trunk-jpl/test/Par/SquareEISMINT.py =================================================================== --- /issm/trunk-jpl/test/Par/SquareEISMINT.py (revision 15766) +++ /issm/trunk-jpl/test/Par/SquareEISMINT.py (revision 15767) @@ -42,7 +42,7 @@ md.balancethickness.spcthickness=float('NaN')*numpy.ones((md.mesh.numberofvertices,1)) md.balancethickness.spcthickness[pos]=500. -md.prognostic.spcthickness=float('NaN')*numpy.ones((md.mesh.numberofvertices,1)) -md.prognostic.spcthickness[pos]=500. -md.prognostic.stabilization=0 #Better result with no artificial diffusivity +md.masstransport.spcthickness=float('NaN')*numpy.ones((md.mesh.numberofvertices,1)) +md.masstransport.spcthickness[pos]=500. +md.masstransport.stabilization=0 #Better result with no artificial diffusivity md.thermal.stabilization=0 md.timestepping.final_time=500. Index: /issm/trunk-jpl/test/Par/SquareSheetConstrained.par =================================================================== --- /issm/trunk-jpl/test/Par/SquareSheetConstrained.par (revision 15766) +++ /issm/trunk-jpl/test/Par/SquareSheetConstrained.par (revision 15767) @@ -38,5 +38,5 @@ %Numerical parameters md.diagnostic.viscosity_overshoot=0.0; -md.prognostic.stabilization=1.; +md.masstransport.stabilization=1.; md.thermal.stabilization=1.; md.verbose=verbose(0); Index: /issm/trunk-jpl/test/Par/SquareSheetConstrained.py =================================================================== --- /issm/trunk-jpl/test/Par/SquareSheetConstrained.py (revision 15766) +++ /issm/trunk-jpl/test/Par/SquareSheetConstrained.py (revision 15767) @@ -48,5 +48,5 @@ #Numerical parameters md.diagnostic.viscosity_overshoot=0.0 -md.prognostic.stabilization=1. +md.masstransport.stabilization=1. md.thermal.stabilization=1. md.verbose=verbose(0) Index: /issm/trunk-jpl/test/Par/SquareSheetShelf.par =================================================================== --- /issm/trunk-jpl/test/Par/SquareSheetShelf.par (revision 15766) +++ /issm/trunk-jpl/test/Par/SquareSheetShelf.par (revision 15767) @@ -43,5 +43,5 @@ %Numerical parameters md.diagnostic.viscosity_overshoot=0.0; -md.prognostic.stabilization=1; +md.masstransport.stabilization=1; md.thermal.stabilization=1; md.verbose=verbose(0); Index: /issm/trunk-jpl/test/Par/SquareSheetShelf.py =================================================================== --- /issm/trunk-jpl/test/Par/SquareSheetShelf.py (revision 15766) +++ /issm/trunk-jpl/test/Par/SquareSheetShelf.py (revision 15767) @@ -54,5 +54,5 @@ #Numerical parameters md.diagnostic.viscosity_overshoot=0.0 -md.prognostic.stabilization=1 +md.masstransport.stabilization=1 md.thermal.stabilization=1 md.verbose=verbose(0) Index: /issm/trunk-jpl/test/Par/SquareShelf.par =================================================================== --- /issm/trunk-jpl/test/Par/SquareShelf.par (revision 15766) +++ /issm/trunk-jpl/test/Par/SquareShelf.par (revision 15767) @@ -36,5 +36,5 @@ %Numerical parameters md.diagnostic.viscosity_overshoot=0.3; -md.prognostic.stabilization=1; +md.masstransport.stabilization=1; md.thermal.stabilization=1; md.settings.waitonlock=30; Index: /issm/trunk-jpl/test/Par/SquareShelf.py =================================================================== --- /issm/trunk-jpl/test/Par/SquareShelf.py (revision 15766) +++ /issm/trunk-jpl/test/Par/SquareShelf.py (revision 15767) @@ -67,5 +67,5 @@ #Numerical parameters md.diagnostic.viscosity_overshoot = 0.3 -md.prognostic.stabilization = 1. +md.masstransport.stabilization = 1. md.thermal.stabilization = 1. md.settings.waitonlock = 30 Index: /issm/trunk-jpl/test/Par/SquareShelf2.par =================================================================== --- /issm/trunk-jpl/test/Par/SquareShelf2.par (revision 15766) +++ /issm/trunk-jpl/test/Par/SquareShelf2.par (revision 15767) @@ -36,5 +36,5 @@ %Numerical parameters md.diagnostic.viscosity_overshoot=0.3; -md.prognostic.stabilization=1; +md.masstransport.stabilization=1; md.thermal.stabilization=1; md.settings.waitonlock=30; Index: /issm/trunk-jpl/test/Par/SquareShelf2.py =================================================================== --- /issm/trunk-jpl/test/Par/SquareShelf2.py (revision 15766) +++ /issm/trunk-jpl/test/Par/SquareShelf2.py (revision 15767) @@ -67,5 +67,5 @@ #Numerical parameters md.diagnostic.viscosity_overshoot = 0.3 -md.prognostic.stabilization = 1. +md.masstransport.stabilization = 1. md.thermal.stabilization = 1. md.settings.waitonlock = 30 Index: /issm/trunk-jpl/test/Par/SquareShelfConstrained.par =================================================================== --- /issm/trunk-jpl/test/Par/SquareShelfConstrained.par (revision 15766) +++ /issm/trunk-jpl/test/Par/SquareShelfConstrained.par (revision 15767) @@ -40,5 +40,5 @@ %Numerical parameters md.diagnostic.viscosity_overshoot=0.0; -md.prognostic.stabilization=1; +md.masstransport.stabilization=1; md.thermal.stabilization=1; md.verbose=verbose(0); Index: /issm/trunk-jpl/test/Par/SquareShelfConstrained.py =================================================================== --- /issm/trunk-jpl/test/Par/SquareShelfConstrained.py (revision 15766) +++ /issm/trunk-jpl/test/Par/SquareShelfConstrained.py (revision 15767) @@ -52,5 +52,5 @@ #Numerical parameters md.diagnostic.viscosity_overshoot=0.0 -md.prognostic.stabilization=1. +md.masstransport.stabilization=1. md.thermal.stabilization=1. md.verbose = verbose(0)