Changeset 27031

Timestamp:

05/31/22 06:20:44 (3 years ago)

Author:

Mathieu Morlighem

Message:

CHG: moving MLHO to MOLHO

Location:

issm/trunk-jpl

Files:

• src/c/analyses/AdjointHorizAnalysis.cpp (modified) (23 diffs)
• src/c/analyses/AdjointHorizAnalysis.h (modified) (5 diffs)
• src/c/analyses/StressbalanceAnalysis.cpp (modified) (51 diffs)
• src/c/analyses/StressbalanceAnalysis.h (modified) (1 diff)
• src/c/analyses/StressbalanceSIAAnalysis.cpp (modified) (3 diffs)
• src/c/analyses/StressbalanceVerticalAnalysis.cpp (modified) (2 diffs)
• src/c/classes/Elements/Element.cpp (modified) (3 diffs)
• src/c/classes/Elements/Element.h (modified) (3 diffs)
• src/c/classes/Elements/Penta.cpp (modified) (1 diff)
• src/c/classes/Elements/Penta.h (modified) (1 diff)
• src/c/classes/FemModel.cpp (modified) (1 diff)
• src/c/classes/Loads/Penpair.cpp (modified) (1 diff)
• src/c/classes/Materials/Material.h (modified) (1 diff)
• src/c/classes/Materials/Matestar.cpp (modified) (1 diff)
• src/c/classes/Materials/Matestar.h (modified) (1 diff)
• src/c/classes/Materials/Matice.cpp (modified) (4 diffs)
• src/c/classes/Materials/Matice.h (modified) (1 diff)
• src/c/classes/Materials/Matlitho.h (modified) (1 diff)
• src/c/classes/Node.cpp (modified) (1 diff)
• src/c/cores/stressbalance_core.cpp (modified) (4 diffs)
• src/c/modules/SurfaceAbsVelMisfitx/SurfaceAbsVelMisfitx.cpp (modified) (1 diff)
• src/c/modules/SurfaceAverageVelMisfitx/SurfaceAverageVelMisfitx.cpp (modified) (1 diff)
• src/c/modules/SurfaceLogVelMisfitx/SurfaceLogVelMisfitx.cpp (modified) (1 diff)
• src/c/modules/SurfaceLogVxVyMisfitx/SurfaceLogVxVyMisfitx.cpp (modified) (1 diff)
• src/c/modules/SurfaceRelVelMisfitx/SurfaceRelVelMisfitx.cpp (modified) (1 diff)
• src/c/shared/Enum/Enum.vim (modified) (13 diffs)
• src/c/shared/Enum/EnumDefinitions.h (modified) (2 diffs)
• src/c/shared/Enum/EnumToStringx.cpp (modified) (4 diffs)
• src/c/shared/Enum/Enumjl.vim (modified) (4 diffs)
• src/c/shared/Enum/StringToEnumx.cpp (modified) (17 diffs)
• src/c/shared/io/Marshalling/IoCodeConversions.cpp (modified) (2 diffs)
• src/m/boundaryconditions/SetMOLHOBC.m (moved) (moved from issm/trunk-jpl/src/m/boundaryconditions/SetMLHOBC.m ) (1 diff)
• src/m/boundaryconditions/SetMOLHOBC.py (moved) (moved from issm/trunk-jpl/src/m/boundaryconditions/SetMLHOBC.py ) (1 diff)
• src/m/classes/flowequation.js (modified) (6 diffs)
• src/m/classes/flowequation.m (modified) (7 diffs)
• src/m/classes/flowequation.py (modified) (5 diffs)
• src/m/classes/inversion.m (modified) (1 diff)
• src/m/classes/inversion.py (modified) (1 diff)
• src/m/classes/stressbalance.m (modified) (4 diffs)
• src/m/classes/stressbalance.py (modified) (4 diffs)
• src/m/parameterization/setflowequation.js (modified) (9 diffs)
• src/m/parameterization/setflowequation.m (modified) (9 diffs)
• src/m/parameterization/setflowequation.py (modified) (8 diffs)
• src/m/plot/plot_elementstype.m (modified) (1 diff)
• test/NightlyRun/test127.m (modified) (2 diffs)
• test/NightlyRun/test127.py (modified) (3 diffs)
• test/NightlyRun/test128.m (modified) (1 diff)
• test/NightlyRun/test128.py (modified) (2 diffs)
• test/NightlyRun/test129.m (modified) (2 diffs)
• test/NightlyRun/test129.py (modified) (3 diffs)
• test/NightlyRun/test248.m (modified) (1 diff)
• test/NightlyRun/test248.py (modified) (2 diffs)
• test/NightlyRun/test249.m (modified) (1 diff)
• test/NightlyRun/test249.py (modified) (3 diffs)
• test/NightlyRun/test254.m (modified) (2 diffs)
• test/NightlyRun/test254.py (modified) (4 diffs)
• test/NightlyRun/test255.m (modified) (1 diff)
• test/NightlyRun/test255.py (modified) (2 diffs)
• test/NightlyRun/test256.m (modified) (1 diff)
• test/NightlyRun/test256.py (modified) (3 diffs)
• test/NightlyRun/test330.m (modified) (1 diff)
• test/NightlyRun/test330.py (modified) (3 diffs)
• test/NightlyRun/test332.m (modified) (1 diff)
• test/NightlyRun/test332.py (modified) (2 diffs)
• test/NightlyRun/test333.m (modified) (2 diffs)
• test/NightlyRun/test333.py (modified) (4 diffs)
• test/NightlyRun/test334.m (modified) (2 diffs)
• test/NightlyRun/test334.py (modified) (3 diffs)
• test/NightlyRun/test335.m (modified) (1 diff)
• test/NightlyRun/test335.py (modified) (3 diffs)
• test/NightlyRun/test446.m (modified) (1 diff)
• test/NightlyRun/test446.py (modified) (2 diffs)
• test/NightlyRun/test447.m (modified) (2 diffs)
• test/NightlyRun/test447.py (modified) (3 diffs)
• test/NightlyRun/test448.m (modified) (3 diffs)
• test/NightlyRun/test448.py (modified) (4 diffs)
• test/NightlyRun/test449.m (modified) (3 diffs)
• test/NightlyRun/test449.py (modified) (4 diffs)
• test/NightlyRun/test518.m (modified) (1 diff)
• test/NightlyRun/test518.py (modified) (3 diffs)
• test/NightlyRun/test519.m (modified) (2 diffs)
• test/NightlyRun/test519.py (modified) (3 diffs)
• test/NightlyRun/test810.m (modified) (2 diffs)
• test/NightlyRun/test810.py (modified) (4 diffs)
• test/NightlyRun/test811.m (modified) (2 diffs)
• test/NightlyRun/test811.py (modified) (4 diffs)
• test/NightlyRun/test812.m (modified) (2 diffs)
• test/NightlyRun/test812.py (modified) (3 diffs)

issm/trunk-jpl/src/c/analyses/AdjointHorizAnalysis.cpp

@@ -52 +52 @@
                 case FSApproximationEnum: 
                         return CreateKMatrixFS(element);
-      case MLHOApproximationEnum:
+      case MOLHOApproximationEnum:
                 // a more accurate option, but integrate in the vertical direction numerically.
-                //      return CreateKMatrixMLHOVerticalIntergrated(element);
-                        return CreateKMatrixMLHO(element);
+                //      return CreateKMatrixMOLHOVerticalIntergrated(element);
+                        return CreateKMatrixMOLHO(element);
                 case NoneApproximationEnum:
                         return NULL;
@@ -220 +220 @@
         return Ke;
 }/*}}}*/
-ElementMatrix* AdjointHorizAnalysis::CreateKMatrixMLHO(Element* element){/*{{{*/
+ElementMatrix* AdjointHorizAnalysis::CreateKMatrixMOLHO(Element* element){/*{{{*/
 
         /* Check if ice in element */
@@ -292 +292 @@
       vyshear_input->GetInputValue(&vyshear,gauss);
 
-                element->material->ViscosityMLHOAdjoint(&viscosity[0],dim,xyz_list,gauss,vxbase_input,vybase_input,vxshear_input,vyshear_input,thickness_input,n_input);
+                element->material->ViscosityMOLHOAdjoint(&viscosity[0],dim,xyz_list,gauss,vxbase_input,vybase_input,vxshear_input,vyshear_input,thickness_input,n_input);
 
                 effmu = 2.0*(1-n)/2.0/n;
@@ -353 +353 @@
    return Ke;
 }/*}}}*/
-ElementMatrix* AdjointHorizAnalysis::CreateKMatrixMLHOVerticalIntergrated(Element* element){/*{{{*/
+ElementMatrix* AdjointHorizAnalysis::CreateKMatrixMOLHOVerticalIntergrated(Element* element){/*{{{*/
 
         /* Check if ice in element */
@@ -433 +433 @@
 
                    /* eps_eff^2 = exx^2 + eyy^2 + exy^2 + exz^2 + eyz^2 + exx*eyy (for a given zeta)*/
-                        element->StrainRateMLHO(&epsilon[0],xyz_list,gauss,
+                        element->StrainRateMOLHO(&epsilon[0],xyz_list,gauss,
                   vxbase_input,vybase_input,vxshear_input,vyshear_input,thickness_input,n_input,zeta);
                         epsilon_eff=sqrt(epsilon[0]*epsilon[0] + epsilon[1]*epsilon[1] + epsilon[2]*epsilon[2]
@@ -618 +618 @@
                 case FSApproximationEnum: 
                         return CreatePVectorFS(element);
-      case MLHOApproximationEnum:
-                        return CreatePVectorMLHO(element);
+      case MOLHOApproximationEnum:
+                        return CreatePVectorMOLHO(element);
                 case NoneApproximationEnum:
                         return NULL;
@@ -1105 +1105 @@
 
 }/*}}}*/
-ElementVector* AdjointHorizAnalysis::CreatePVectorMLHO(Element* element){/*{{{*/
+ElementVector* AdjointHorizAnalysis::CreatePVectorMOLHO(Element* element){/*{{{*/
 
         /*Intermediaries*/
@@ -1143 +1143 @@
 
         /*Initialize Element vector and vectors*/
-        ElementVector* pe    = basalelement->NewElementVector(MLHOApproximationEnum);
+        ElementVector* pe    = basalelement->NewElementVector(MOLHOApproximationEnum);
         IssmDouble*    basis = xNew<IssmDouble>(numnodes);
 
@@ -1212 +1212 @@
                                                 }
                                                 else {
-                                                        _error_("2D vertical is not implemented for MLHO");
+                                                        _error_("2D vertical is not implemented for MOLHO");
                                                 }
                                         }
@@ -1240 +1240 @@
                                                 }
                                                 else{
-                                                        _error_("2D vertical is not implemented for MLHO");
+                                                        _error_("2D vertical is not implemented for MOLHO");
                                                 }
                                         }
@@ -1269 +1269 @@
                                                 }
                                                 else{
-                                                        _error_("2D vertical is not implemented for MLHO");
+                                                        _error_("2D vertical is not implemented for MOLHO");
                                                 }
                                         }
@@ -1295 +1295 @@
                                                 }
                                                 else{
-                                                        _error_("2D vertical is not implemented for MLHO");
+                                                        _error_("2D vertical is not implemented for MOLHO");
                                                 }
                                         }
@@ -1319 +1319 @@
                                                 }
                                                 else{
-                                                        _error_("2D vertical is not implemented for MLHO");
+                                                        _error_("2D vertical is not implemented for MOLHO");
                                                 }
                                         }
@@ -1669 +1669 @@
                                 case L1L2ApproximationEnum:GradientJDragL1L2(element,gradient,control_interp,control_index); break;
                                 case HOApproximationEnum:  GradientJDragHO( element,gradient,control_interp,control_index); break;
-                                case MLHOApproximationEnum:  GradientJDragMLHO( element,gradient,control_interp,control_index); break;
+                                case MOLHOApproximationEnum:  GradientJDragMOLHO( element,gradient,control_interp,control_index); break;
                                 case FSApproximationEnum:  GradientJDragFS( element,gradient,control_interp,control_index); break;
                                 case NoneApproximationEnum: /*Gradient is 0*/                    break;
@@ -1690 +1690 @@
                                 case L1L2ApproximationEnum:GradientJBbarL1L2(element,gradient,control_interp,control_index); break;
                                 case HOApproximationEnum:  GradientJBbarHO( element,gradient,control_interp,control_index); break;
-                                case MLHOApproximationEnum:  GradientJBbarMLHO( element,gradient,control_interp,control_index); break;
+                                case MOLHOApproximationEnum:  GradientJBbarMOLHO( element,gradient,control_interp,control_index); break;
                                 case FSApproximationEnum:  GradientJBbarFS( element,gradient,control_interp,control_index); break;
                                 case NoneApproximationEnum: /*Gradient is 0*/                    break;
@@ -1700 +1700 @@
                                 case SSAApproximationEnum: GradientJBSSA(element,gradient,control_interp,control_index); break;
                                 case HOApproximationEnum:  GradientJBHO( element,gradient,control_interp,control_index); break;
-                        //      case MLHOApproximationEnum:  GradientJBMLHO( element,gradient,control_interp,control_index); break;
+                        //      case MOLHOApproximationEnum:  GradientJBMOLHO( element,gradient,control_interp,control_index); break;
                                 case FSApproximationEnum:  GradientJBFS( element,gradient,control_interp,control_index); break;
                                 case NoneApproximationEnum: /*Gradient is 0*/                    break;
@@ -1810 +1810 @@
         this->GradientJBbarSSA(element,gradient,control_interp,control_index);
 }/*}}}*/
-void           AdjointHorizAnalysis::GradientJBbarMLHO(Element* element,Vector<IssmDouble>* gradient,int control_interp,int control_index){/*{{{*/
+void           AdjointHorizAnalysis::GradientJBbarMOLHO(Element* element,Vector<IssmDouble>* gradient,int control_interp,int control_index){/*{{{*/
 
    if(control_interp!=P1Enum) _error_("not implemented yet...");
@@ -1893 +1893 @@
                         zeta=0.5*(gauss_seg->coord1+1);
 
-                        basalelement->StrainRateMLHO(&epsilon[0],xyz_list,gauss,
+                        basalelement->StrainRateMOLHO(&epsilon[0],xyz_list,gauss,
                   vxbase_input,vybase_input,vxshear_input,vyshear_input,thickness_input,n_input,zeta);
 
-                        basalelement->dViscositydBMLHO(&dmudB,dim,xyz_list,gauss,vxbase_input,vybase_input,vxshear_input,vyshear_input,thickness_input,n_input,zeta);
+                        basalelement->dViscositydBMOLHO(&dmudB,dim,xyz_list,gauss,vxbase_input,vybase_input,vxshear_input,vyshear_input,thickness_input,n_input,zeta);
 
                         e1[0] = 2.0*epsilon[0]+epsilon[1];
@@ -2251 +2251 @@
         delete gauss;
 }/*}}}*/
-void           AdjointHorizAnalysis::GradientJBMLHO(Element* element,Vector<IssmDouble>* gradient,int control_interp,int control_index){/*{{{*/
+void           AdjointHorizAnalysis::GradientJBMOLHO(Element* element,Vector<IssmDouble>* gradient,int control_interp,int control_index){/*{{{*/
         _error_("not implemented yet...");
 }/*}}}*/
@@ -2651 +2651 @@
         delete friction;
 }/*}}}*/
-void           AdjointHorizAnalysis::GradientJDragMLHO(Element* element,Vector<IssmDouble>* gradient,int control_interp,int control_index){/*{{{*/
+void           AdjointHorizAnalysis::GradientJDragMOLHO(Element* element,Vector<IssmDouble>* gradient,int control_interp,int control_index){/*{{{*/
 
         /*return if floating (gradient is 0)*/
@@ -3272 +3272 @@
                 InputUpdateFromSolutionFS(solution,element);
         }
-        else if (approximation==MLHOApproximationEnum) {
-                InputUpdateFromSolutionMLHO(solution, element);
+        else if (approximation==MOLHOApproximationEnum) {
+                InputUpdateFromSolutionMOLHO(solution, element);
         }
         else{
@@ -3420 +3420 @@
         xDelete<int>(doflist);
 }/*}}}*/
-void           AdjointHorizAnalysis::InputUpdateFromSolutionMLHO(IssmDouble* solution,Element* element){/*{{{*/
+void           AdjointHorizAnalysis::InputUpdateFromSolutionMOLHO(IssmDouble* solution,Element* element){/*{{{*/
         int  i;
         int* doflist=NULL;
@@ -3433 +3433 @@
 
         /*Fetch dof list and allocate solution vectors*/
-        element->GetDofListLocal(&doflist,MLHOApproximationEnum,GsetEnum);
+        element->GetDofListLocal(&doflist,MOLHOApproximationEnum,GsetEnum);
         IssmDouble* values    = xNew<IssmDouble>(numdof);
         IssmDouble* lambdax   = xNew<IssmDouble>(numnodes);

issm/trunk-jpl/src/c/analyses/AdjointHorizAnalysis.h

@@ -28 +28 @@
                 ElementMatrix* CreateKMatrixFS(Element* element);
                 ElementMatrix* CreateKMatrixHO(Element* element);
-                ElementMatrix* CreateKMatrixMLHO(Element* element);
-                ElementMatrix* CreateKMatrixMLHOVerticalIntergrated(Element* element);
+                ElementMatrix* CreateKMatrixMOLHO(Element* element);
+                ElementMatrix* CreateKMatrixMOLHOVerticalIntergrated(Element* element);
                 ElementMatrix* CreateKMatrixL1L2(Element* element);
                 ElementMatrix* CreateKMatrixSSA(Element* element);
@@ -36 +36 @@
                 ElementVector* CreatePVectorL1L2(Element* element);
                 ElementVector* CreatePVectorHO(Element* element);
-                ElementVector* CreatePVectorMLHO(Element* element);
+                ElementVector* CreatePVectorMOLHO(Element* element);
                 ElementVector* CreatePVectorSSA(Element* element);
                 void           GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element);
@@ -45 +45 @@
                 void           GradientJBbarL1L2(Element* element,Vector<IssmDouble>* gradient,int control_interp,int control_index);
                 void           GradientJBbarHO(Element* element,Vector<IssmDouble>* gradient,int control_interp,int control_index);
-                void           GradientJBbarMLHO(Element* element,Vector<IssmDouble>* gradient,int control_interp,int control_index);
+                void           GradientJBbarMOLHO(Element* element,Vector<IssmDouble>* gradient,int control_interp,int control_index);
                 void           GradientJBbarSSA(Element* element,Vector<IssmDouble>* gradient,int control_interp,int control_index);
                 void           GradientJBFS(Element* element,Vector<IssmDouble>* gradient,int control_interp,int control_index);
                 void           GradientJBGradient(Element* element,Vector<IssmDouble>* gradient,int control_interp,int control_index);
                 void           GradientJBHO(Element* element,Vector<IssmDouble>* gradient,int control_interp,int control_index);
-                void           GradientJBMLHO(Element* element,Vector<IssmDouble>* gradient,int control_interp,int control_index);
+                void           GradientJBMOLHO(Element* element,Vector<IssmDouble>* gradient,int control_interp,int control_index);
                 void           GradientJBSSA(Element* element,Vector<IssmDouble>* gradient,int control_interp,int control_index);
                 void           GradientJDragFS(Element* element,Vector<IssmDouble>* gradient,int control_interp,int control_index);
@@ -56 +56 @@
                 void           GradientJDragL1L2(Element* element,Vector<IssmDouble>* gradient,int control_interp,int control_index);
                 void           GradientJDragHO(Element* element,Vector<IssmDouble>* gradient,int control_interp,int control_index);
-                void           GradientJDragMLHO(Element* element,Vector<IssmDouble>* gradient,int control_interp,int control_index);
+                void           GradientJDragMOLHO(Element* element,Vector<IssmDouble>* gradient,int control_interp,int control_index);
                 void           GradientJDragSSA(Element* element,Vector<IssmDouble>* gradient,int control_interp,int control_index);
                 void           GradientJDragHydroFS(Element* element,Vector<IssmDouble>* gradient,int control_interp,int control_index);
@@ -66 +66 @@
                 void           InputUpdateFromSolutionFS(IssmDouble* solution,Element* element);
                 void           InputUpdateFromSolutionHoriz(IssmDouble* solution,Element* element);
-                void           InputUpdateFromSolutionMLHO(IssmDouble* solution,Element* element);
+                void           InputUpdateFromSolutionMOLHO(IssmDouble* solution,Element* element);
                 void           UpdateConstraints(FemModel* femmodel);
 };

issm/trunk-jpl/src/c/analyses/StressbalanceAnalysis.cpp

@@ -31 +31 @@
         IssmDouble rho_ice;
         IssmDouble FSreconditioning;
-        bool       isSIA,isSSA,isL1L2,isMLHO,isHO,isFS,iscoupling;
+        bool       isSIA,isSSA,isL1L2,isMOLHO,isHO,isFS,iscoupling;
         bool       spcpresent = false;
         int        Mx,Nx;
@@ -59 +59 @@
         iomodel->FindConstant(&isSSA,"md.flowequation.isSSA");
         iomodel->FindConstant(&isL1L2,"md.flowequation.isL1L2");
-        iomodel->FindConstant(&isMLHO,"md.flowequation.isMLHO");
+        iomodel->FindConstant(&isMOLHO,"md.flowequation.isMOLHO");
         iomodel->FindConstant(&isHO,"md.flowequation.isHO");
         iomodel->FindConstant(&isFS,"md.flowequation.isFS");
 
         /*Is this model only SIA??*/
-        if(!isSSA && !isHO && !isFS && !isL1L2 && !isMLHO) return;
+        if(!isSSA && !isHO && !isFS && !isL1L2 && !isMOLHO) return;
 
         /*Do we have coupling*/
-        if((isSIA?1.:0.) + (isSSA?1.:0.) + (isL1L2?1.:0.) + (isMLHO?1.:0.) + (isHO?1.:0.) + (isFS?1.:0.) >1.)
+        if((isSIA?1.:0.) + (isSSA?1.:0.) + (isL1L2?1.:0.) + (isMOLHO?1.:0.) + (isHO?1.:0.) + (isFS?1.:0.) >1.)
          iscoupling = true;
         else
@@ -78 +78 @@
                 if(isSSA)       iomodel->FindConstant(&finiteelement,"md.flowequation.fe_SSA");
                 else if(isL1L2) finiteelement = P1Enum;
-                else if(isMLHO) finiteelement = P1Enum;
+                else if(isMOLHO) finiteelement = P1Enum;
                 else if(isHO)   iomodel->FindConstant(&finiteelement,"md.flowequation.fe_HO");
                 else if(isFS){  iomodel->FindConstant(&finiteelement,"md.flowequation.fe_FS");
@@ -188 +188 @@
                 }
                 else{
-                        if(!isMLHO){
+                        if(!isMOLHO){
                                 IoModelToConstraintsx(constraints,iomodel,"md.stressbalance.spcvx",StressbalanceAnalysisEnum,finiteelement,0);
                                 if(iomodel->domaintype!=Domain2DverticalEnum){
@@ -194 +194 @@
                                 }
                         }
-                        else{//MLHO 
+                        else{//MOLHO 
                                 IoModelToConstraintsx(constraints,iomodel,"md.stressbalance.spcvx_base",StressbalanceAnalysisEnum,finiteelement,0);
                                 IoModelToConstraintsx(constraints,iomodel,"md.stressbalance.spcvx_shear",StressbalanceAnalysisEnum,finiteelement,1);
@@ -462 +462 @@
         int         count;
         int         penpair_ids[2];
-        bool        isSSA,isL1L2,isMLHO,isHO,isFS;
+        bool        isSSA,isL1L2,isMOLHO,isHO,isFS;
         int         numpenalties,numrifts,numriftsegments;
         IssmDouble *riftinfo       = NULL;
@@ -470 +470 @@
         /*Fetch parameters: */
         iomodel->FindConstant(&isL1L2,"md.flowequation.isL1L2");
-        iomodel->FindConstant(&isMLHO,"md.flowequation.isMLHO");
+        iomodel->FindConstant(&isMOLHO,"md.flowequation.isMOLHO");
         iomodel->FindConstant(&isFS,"md.flowequation.isFS");
         iomodel->FindConstant(&isSSA,"md.flowequation.isSSA");
@@ -477 +477 @@
 
         /*Is this SIA only?*/
-        if(!isSSA && !isHO && !isFS && !isL1L2 && !isMLHO) return;
+        if(!isSSA && !isHO && !isFS && !isL1L2 && !isMOLHO) return;
 
         /*Initialize counter: */
@@ -522 +522 @@
 
         /*Intermediary*/
-        bool isSSA,isL1L2,isMLHO,isHO,isFS,iscoupling;
+        bool isSSA,isL1L2,isMOLHO,isHO,isFS,iscoupling;
         int  finiteelement=-1,approximation=-1;
 
@@ -528 +528 @@
         iomodel->FindConstant(&isSSA,"md.flowequation.isSSA");
         iomodel->FindConstant(&isL1L2,"md.flowequation.isL1L2");
-        iomodel->FindConstant(&isMLHO,"md.flowequation.isMLHO");
+        iomodel->FindConstant(&isMOLHO,"md.flowequation.isMOLHO");
         iomodel->FindConstant(&isHO,"md.flowequation.isHO");
         iomodel->FindConstant(&isFS,"md.flowequation.isFS");
 
         /*Now, check that we have non SIA elements */
-        if(!isSSA && !isL1L2 && !isMLHO && !isHO && !isFS) return;
+        if(!isSSA && !isL1L2 && !isMOLHO && !isHO && !isFS) return;
 
         /*Do we have coupling*/
-        if( (isSSA?1.:0.) + (isL1L2?1.:0.) + (isMLHO?1.:0.) + (isHO?1.:0.) + (isFS?1.:0.) >1.)
+        if( (isSSA?1.:0.) + (isL1L2?1.:0.) + (isMOLHO?1.:0.) + (isHO?1.:0.) + (isFS?1.:0.) >1.)
          iscoupling = true;
         else
@@ -553 +553 @@
                         finiteelement = P1Enum;
                 }
-                else if(isMLHO){
-                        approximation = MLHOApproximationEnum;
+                else if(isMOLHO){
+                        approximation = MOLHOApproximationEnum;
                         finiteelement = P1Enum;
                 }
@@ -630 +630 @@
                          break;
                 case L1L2ApproximationEnum: numdofs = 2; break;
-                case MLHOApproximationEnum: numdofs = 4; break;
+                case MOLHOApproximationEnum: numdofs = 4; break;
                 case HOApproximationEnum:
                          switch(domaintype){
@@ -695 +695 @@
         int    FrictionCoupling;
         int*   finiteelement_list=NULL;
-        bool   isSSA,isL1L2,isMLHO,isHO,isFS,iscoupling;
+        bool   isSSA,isL1L2,isMOLHO,isHO,isFS,iscoupling;
         bool   control_analysis;
         bool   dakota_analysis;
@@ -703 +703 @@
         iomodel->FindConstant(&isSSA,"md.flowequation.isSSA");
         iomodel->FindConstant(&isL1L2,"md.flowequation.isL1L2");
-        iomodel->FindConstant(&isMLHO,"md.flowequation.isMLHO");
+        iomodel->FindConstant(&isMOLHO,"md.flowequation.isMOLHO");
         iomodel->FindConstant(&isHO,"md.flowequation.isHO");
         iomodel->FindConstant(&isFS,"md.flowequation.isFS");
@@ -713 +713 @@
 
         /*return if no processing required*/
-        if(!isSSA && !isL1L2 && !isMLHO && !isHO && !isFS) return;
+        if(!isSSA && !isL1L2 && !isMOLHO && !isHO && !isFS) return;
 
         /*Fetch data needed and allocate vectors: */
@@ -720 +720 @@
 
         /*Do we have coupling*/
-        if( (isSSA?1.:0.) + (isL1L2?1.:0.) + (isMLHO?1.:0.) + (isHO?1.:0.) + (isFS?1.:0.) >1.)
+        if( (isSSA?1.:0.) + (isL1L2?1.:0.) + (isMOLHO?1.:0.) + (isHO?1.:0.) + (isFS?1.:0.) >1.)
          iscoupling = true;
         else
@@ -729 +729 @@
                 if(isSSA)       iomodel->FindConstant(&finiteelement,"md.flowequation.fe_SSA");
                 else if(isL1L2) finiteelement = P1Enum;
-                else if(isMLHO) finiteelement = P1Enum;
+                else if(isMOLHO) finiteelement = P1Enum;
                 else if(isHO)   iomodel->FindConstant(&finiteelement,"md.flowequation.fe_HO");
                 else if(isFS)   iomodel->FindConstant(&finiteelement,"md.flowequation.fe_FS");
@@ -781 +781 @@
         iomodel->FetchDataToInput(inputs,elements,"md.initialization.vx",VxEnum,0.);
         iomodel->FetchDataToInput(inputs,elements,"md.initialization.vy",VyEnum,0.);
-        /*MLHO*/
-        if(isMLHO){
+        /*MOLHO*/
+        if(isMOLHO){
                 iomodel->FetchDataToInput(inputs,elements,"md.initialization.vx",VxShearEnum,0.);
                 iomodel->FetchDataToInput(inputs,elements,"md.initialization.vy",VyShearEnum,0.);
-                /*3D MLHO also need to have VxBase and VyBase for reconstruting Vx and Vy*/
+                /*3D MOLHO also need to have VxBase and VyBase for reconstruting Vx and Vy*/
                 if (iomodel->domaintype==Domain3DEnum) {
                         iomodel->FetchDataToInput(inputs,elements,"md.initialization.vx",VxBaseEnum,0.);
@@ -990 +990 @@
         parameters->AddObject(iomodel->CopyConstantObject("md.flowequation.isSSA",FlowequationIsSSAEnum));
         parameters->AddObject(iomodel->CopyConstantObject("md.flowequation.isL1L2",FlowequationIsL1L2Enum));
-        parameters->AddObject(iomodel->CopyConstantObject("md.flowequation.isMLHO",FlowequationIsMLHOEnum));
+        parameters->AddObject(iomodel->CopyConstantObject("md.flowequation.isMOLHO",FlowequationIsMOLHOEnum));
         parameters->AddObject(iomodel->CopyConstantObject("md.flowequation.isHO",FlowequationIsHOEnum));
         parameters->AddObject(iomodel->CopyConstantObject("md.flowequation.isFS",FlowequationIsFSEnum));
@@ -1093 +1093 @@
 
         /*Intermediaries*/
-        bool isSSA,isL1L2,isMLHO,isHO,isFS;
+        bool isSSA,isL1L2,isMOLHO,isHO,isFS;
         bool conserve_loads = true;
         int  newton,domaintype,fe_FS;
@@ -1100 +1100 @@
         femmodel->parameters->FindParam(&isSSA,FlowequationIsSSAEnum);
         femmodel->parameters->FindParam(&isL1L2,FlowequationIsL1L2Enum);
-        femmodel->parameters->FindParam(&isMLHO,FlowequationIsMLHOEnum);
+        femmodel->parameters->FindParam(&isMOLHO,FlowequationIsMOLHOEnum);
         femmodel->parameters->FindParam(&isHO,FlowequationIsHOEnum);
         femmodel->parameters->FindParam(&isFS,FlowequationIsFSEnum);
@@ -1107 +1107 @@
         femmodel->parameters->FindParam(&newton,StressbalanceIsnewtonEnum);
 
-        if(isFS && !(isSSA || isHO || isL1L2 || isMLHO)){
+        if(isFS && !(isSSA || isHO || isL1L2 || isMOLHO)){
                 femmodel->SetCurrentConfiguration(StressbalanceAnalysisEnum);
 
@@ -1129 +1129 @@
                  solutionsequence_nonlinear(femmodel,conserve_loads);
         }
-        else if(!isFS && (isSSA || isHO || isL1L2 || isMLHO)){
+        else if(!isFS && (isSSA || isHO || isL1L2 || isMOLHO)){
                 femmodel->SetCurrentConfiguration(StressbalanceAnalysisEnum);
                 if(newton>0)
@@ -1143 +1143 @@
                 }
         }
-        else if ((isSSA || isL1L2 || isMLHO || isHO) && isFS){
+        else if ((isSSA || isL1L2 || isMOLHO || isHO) && isFS){
                 if(VerboseSolution()) _printf0_("   computing coupling between lower order models and FS\n");
                 solutionsequence_FScoupling_nonlinear(femmodel,conserve_loads);
@@ -1195 +1195 @@
                 case L1L2ApproximationEnum:
                         return CreateKMatrixL1L2(element);
-                case MLHOApproximationEnum:
-                        return CreateKMatrixMLHO(element);
+                case MOLHOApproximationEnum:
+                        return CreateKMatrixMOLHO(element);
                 case HOApproximationEnum:
                         return CreateKMatrixHO(element);
@@ -1224 +1224 @@
                 case L1L2ApproximationEnum:
                         return CreatePVectorL1L2(element);
-                case MLHOApproximationEnum:
-                        return CreatePVectorMLHO(element);
+                case MOLHOApproximationEnum:
+                        return CreatePVectorMOLHO(element);
                 case HOApproximationEnum:
                         return CreatePVectorHO(element);
@@ -1253 +1253 @@
                         GetSolutionFromInputsHoriz(solution,element);
                         return;
-                case MLHOApproximationEnum:
-                        GetSolutionFromInputsMLHO(solution,element);
+                case MOLHOApproximationEnum:
+                        GetSolutionFromInputsMOLHO(solution,element);
                         return;
                 case SSAHOApproximationEnum: case HOFSApproximationEnum: case SSAFSApproximationEnum:
@@ -1335 +1335 @@
                         InputUpdateFromSolutionL1L2(solution,element);
                         return;
-                case MLHOApproximationEnum:
-                        InputUpdateFromSolutionMLHO(solution,element);
+                case MOLHOApproximationEnum:
+                        InputUpdateFromSolutionMOLHO(solution,element);
                         return;
                 case SSAHOApproximationEnum:
@@ -2760 +2760 @@
 }/*}}}*/
 
-/*MLHO*/
-ElementMatrix* StressbalanceAnalysis::CreateKMatrixMLHO(Element* element){/*{{{*/
+/*MOLHO*/
+ElementMatrix* StressbalanceAnalysis::CreateKMatrixMOLHO(Element* element){/*{{{*/
 
         /* Check if ice in element */
@@ -2784 +2784 @@
 
         /*compute all stiffness matrices for this element*/
-        ElementMatrix* Ke1=CreateKMatrixMLHOViscous(basalelement);
-        ElementMatrix* Ke2=CreateKMatrixMLHOFriction(basalelement);
+        ElementMatrix* Ke1=CreateKMatrixMOLHOViscous(basalelement);
+        ElementMatrix* Ke2=CreateKMatrixMOLHOFriction(basalelement);
         ElementMatrix* Ke =new ElementMatrix(Ke1,Ke2);
 
@@ -2794 +2794 @@
         return Ke;
 }/*}}}*/
-ElementMatrix* StressbalanceAnalysis::CreateKMatrixMLHOFriction(Element* element){/*{{{*/
+ElementMatrix* StressbalanceAnalysis::CreateKMatrixMOLHOFriction(Element* element){/*{{{*/
 
         if(element->IsAllFloating()) return NULL;
@@ -2821 +2821 @@
 
         /*Initialize Element matrix and vectors*/
-        ElementMatrix* Ke = element->NewElementMatrix(MLHOApproximationEnum);
+        ElementMatrix* Ke = element->NewElementMatrix(MOLHOApproximationEnum);
         IssmDouble*    basis  = xNew<IssmDouble>(numnodes);
 
@@ -2876 +2876 @@
         return Ke;
 }/*}}}*/
-ElementMatrix* StressbalanceAnalysis::CreateKMatrixMLHOViscous(Element* element){/*{{{*/
+ElementMatrix* StressbalanceAnalysis::CreateKMatrixMOLHOViscous(Element* element){/*{{{*/
 
         /* Check if ice in element */
@@ -2891 +2891 @@
 
         /*Initialize Element matrix and vectors*/
-        ElementMatrix* Ke     = element->NewElementMatrix(MLHOApproximationEnum);
+        ElementMatrix* Ke     = element->NewElementMatrix(MOLHOApproximationEnum);
         IssmDouble*    dbasis = xNew<IssmDouble>(2*numnodes); // like SSA
         IssmDouble*    basis  = xNew<IssmDouble>(numnodes); // like SSA
@@ -2915 +2915 @@
                 thickness_input->GetInputValue(&thickness, gauss);
                 n_input->GetInputValue(&n,gauss);
-                element->material->ViscosityMLHO(&viscosity[0],dim,xyz_list,gauss,vxbase_input,vybase_input,vxshear_input,vyshear_input,thickness_input,n_input);
+                element->material->ViscosityMOLHO(&viscosity[0],dim,xyz_list,gauss,vxbase_input,vybase_input,vxshear_input,vyshear_input,thickness_input,n_input);
 
                 for(int i=0;i<numnodes;i++){//shape functions on tria element
@@ -2981 +2981 @@
 
         /*Transform Coordinate System*/
-        //basalelement->TransformStiffnessMatrixCoord(Ke,XYMLHOEnum);
+        //basalelement->TransformStiffnessMatrixCoord(Ke,XYMOLHOEnum);
 
         /*Clean up and return*/
@@ -2990 +2990 @@
         return Ke;
 }/*}}}*/
-ElementVector* StressbalanceAnalysis::CreatePVectorMLHO(Element* element){/*{{{*/
+ElementVector* StressbalanceAnalysis::CreatePVectorMOLHO(Element* element){/*{{{*/
 
         /* Check if ice in element */
@@ -3013 +3013 @@
 
         /*compute all load vectors for this element*/
-        ElementVector* pe1=CreatePVectorMLHODrivingStress(basalelement);
-        ElementVector* pe2=CreatePVectorMLHOFront(basalelement);
+        ElementVector* pe1=CreatePVectorMOLHODrivingStress(basalelement);
+        ElementVector* pe2=CreatePVectorMOLHOFront(basalelement);
         ElementVector* pe =new ElementVector(pe1,pe2);
 
@@ -3023 +3023 @@
         return pe;
 }/*}}}*/
-ElementVector* StressbalanceAnalysis::CreatePVectorMLHODrivingStress(Element* element){/*{{{*/
+ElementVector* StressbalanceAnalysis::CreatePVectorMOLHODrivingStress(Element* element){/*{{{*/
 
         /*Intermediaries */
@@ -3033 +3033 @@
 
         /*Initialize Element vector and vectors*/
-        ElementVector* pe    = element->NewElementVector(MLHOApproximationEnum);
+        ElementVector* pe    = element->NewElementVector(MOLHOApproximationEnum);
         IssmDouble*    basis = xNew<IssmDouble>(numnodes);
 
@@ -3062 +3062 @@
 
         /*Transform coordinate system*/
-        //element->TransformLoadVectorCoord(pe,XYMLHOEnum);
+        //element->TransformLoadVectorCoord(pe,XYMOLHOEnum);
 
         /*Clean up and return*/
@@ -3070 +3070 @@
         return pe;
 }/*}}}*/
-ElementVector* StressbalanceAnalysis::CreatePVectorMLHOFront(Element* element){/*{{{*/
+ElementVector* StressbalanceAnalysis::CreatePVectorMOLHOFront(Element* element){/*{{{*/
 
         /*If no front, return NULL*/
@@ -3086 +3086 @@
 
         /*Initialize Element vector and other vectors*/
-        ElementVector* pe    = element->NewElementVector(MLHOApproximationEnum);
+        ElementVector* pe    = element->NewElementVector(MOLHOApproximationEnum);
         IssmDouble*    basis = xNew<IssmDouble>(numnodes);
 
@@ -3135 +3135 @@
 
         /*Transform coordinate system*/
-        //element->TransformLoadVectorCoord(pe,XYMLHOEnum);
+        //element->TransformLoadVectorCoord(pe,XYMOLHOEnum);
 
         /*Clean up and return*/
@@ -3144 +3144 @@
         return pe;
 }/*}}}*/
-void           StressbalanceAnalysis::InputUpdateFromSolutionMLHO(IssmDouble* solution,Element* element){/*{{{*/
+void           StressbalanceAnalysis::InputUpdateFromSolutionMOLHO(IssmDouble* solution,Element* element){/*{{{*/
 
         int         i,dim,domaintype;
@@ -3197 +3197 @@
 
         /*Fetch dof list and allocate solution vectors*/
-        basalelement->GetDofListLocal(&doflist,MLHOApproximationEnum,GsetEnum); 
+        basalelement->GetDofListLocal(&doflist,MOLHOApproximationEnum,GsetEnum); 
         IssmDouble* values    = xNew<IssmDouble>(numdof);
         IssmDouble* vbx       = xNew<IssmDouble>(numnodes);
@@ -3220 +3220 @@
 
    /*Ok, we have vx and vy in values, fill in vx and vy arrays: */
-   for(i=0;i<numnodes;i++){ //numnodes of the 2D mesh in which the MLHO is written
+   for(i=0;i<numnodes;i++){ //numnodes of the 2D mesh in which the MOLHO is written
       vbx[i] =values[i*4+0]; //base vx
       vshx[i]=values[i*4+1]; //shear vx
@@ -3257 +3257 @@
    switch(domaintype){
       case Domain2DhorizontalEnum:
-                        for(i=0;i<numnodes;i++){ //numnodes of the 2D mesh in which the MLHO is written
+                        for(i=0;i<numnodes;i++){ //numnodes of the 2D mesh in which the MOLHO is written
                                 vx[i]=vbx[i]+vshx[i]*(n[i]+1)/(n[i]+2);
                                 vy[i]=vby[i]+vshy[i]*(n[i]+1)/(n[i]+2);
@@ -3269 +3269 @@
                    basalelement->GetInputListOnNodes(&H[0],ThicknessEnum,0.);
                    basalelement->GetInputListOnNodes(&s[0],SurfaceEnum,0.);
-                        element->Recover3DMLHOInput(VxEnum, numnodes, vbx, vshx, n, H, s);
-                        element->Recover3DMLHOInput(VyEnum, numnodes, vby, vshy, n, H, s);
+                        element->Recover3DMOLHOInput(VxEnum, numnodes, vbx, vshx, n, H, s);
+                        element->Recover3DMOLHOInput(VyEnum, numnodes, vby, vshy, n, H, s);
                         break;
                 default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
@@ -3294 +3294 @@
         if(basalelement->IsSpawnedElement()){basalelement->DeleteMaterials(); delete basalelement;};
 }/*}}}*/
-void           StressbalanceAnalysis::GetSolutionFromInputsMLHO(Vector<IssmDouble>* solution,Element* element){/*{{{*/
+void           StressbalanceAnalysis::GetSolutionFromInputsMOLHO(Vector<IssmDouble>* solution,Element* element){/*{{{*/
 
         IssmDouble   vbx,vby,vshx,vshy;
@@ -3313 +3313 @@
         int numdof   = numnodes*dofpernode;
         element->GetInputValue(&approximation,ApproximationEnum);
-        if(approximation!=MLHOApproximationEnum) _error_("mesh "<<EnumToStringx(approximation)<<" not supported here");
+        if(approximation!=MOLHOApproximationEnum) _error_("mesh "<<EnumToStringx(approximation)<<" not supported here");
 
         /*Fetch dof list and allocate solution vector*/

issm/trunk-jpl/src/c/analyses/StressbalanceAnalysis.h

@@ -57 +57 @@
                 ElementVector* CreatePVectorL1L2DrivingStress(Element* element);
                 void           InputUpdateFromSolutionL1L2(IssmDouble* solution,Element* element);
-                /*MLHO*/
-                ElementMatrix* CreateKMatrixMLHO(Element* element);
-                ElementMatrix* CreateKMatrixMLHOFriction(Element* element);
-                ElementMatrix* CreateKMatrixMLHOViscous(Element* element);
-                ElementVector* CreatePVectorMLHO(Element* element);
-                ElementVector* CreatePVectorMLHOFront(Element* element);
-                ElementVector* CreatePVectorMLHODrivingStress(Element* element);
-                void           InputUpdateFromSolutionMLHO(IssmDouble* solution,Element* element);
-                void           GetSolutionFromInputsMLHO(Vector<IssmDouble>* solution,Element* element);
+                /*MOLHO*/
+                ElementMatrix* CreateKMatrixMOLHO(Element* element);
+                ElementMatrix* CreateKMatrixMOLHOFriction(Element* element);
+                ElementMatrix* CreateKMatrixMOLHOViscous(Element* element);
+                ElementVector* CreatePVectorMOLHO(Element* element);
+                ElementVector* CreatePVectorMOLHOFront(Element* element);
+                ElementVector* CreatePVectorMOLHODrivingStress(Element* element);
+                void           InputUpdateFromSolutionMOLHO(IssmDouble* solution,Element* element);
+                void           GetSolutionFromInputsMOLHO(Vector<IssmDouble>* solution,Element* element);
                 /*HO*/
                 ElementMatrix* CreateJacobianMatrixHO(Element* element);

issm/trunk-jpl/src/c/analyses/StressbalanceSIAAnalysis.cpp

@@ -10 +10 @@
 
         /*Intermediaries*/
-        bool       isSIA,isSSA,isL1L2,isMLHO,isHO,isFS,iscoupling;
+        bool       isSIA,isSSA,isL1L2,isMOLHO,isHO,isFS,iscoupling;
 
         /*Fetch parameters: */
@@ -16 +16 @@
         iomodel->FindConstant(&isSSA,"md.flowequation.isSSA");
         iomodel->FindConstant(&isL1L2,"md.flowequation.isL1L2");
-        iomodel->FindConstant(&isMLHO,"md.flowequation.isMLHO");
+        iomodel->FindConstant(&isMOLHO,"md.flowequation.isMOLHO");
         iomodel->FindConstant(&isHO,"md.flowequation.isHO");
         iomodel->FindConstant(&isFS,"md.flowequation.isFS");
@@ -24 +24 @@
 
         /*Do we have coupling*/
-        if((isSIA?1.:0.) + (isSSA?1.:0.) + (isL1L2?1.:0.) + (isMLHO?1.:0.) + (isHO?1.:0.) + (isFS?1.:0.) >1.)
+        if((isSIA?1.:0.) + (isSSA?1.:0.) + (isL1L2?1.:0.) + (isMOLHO?1.:0.) + (isHO?1.:0.) + (isFS?1.:0.) >1.)
          iscoupling = true;
         else

issm/trunk-jpl/src/c/analyses/StressbalanceVerticalAnalysis.cpp

@@ -12 +12 @@
 
         /*Intermediary*/
-        bool        isSIA,isSSA,isL1L2,isMLHO,isHO,isFS,iscoupling;
+        bool        isSIA,isSSA,isL1L2,isMOLHO,isHO,isFS,iscoupling;
         int         Mz,Nz;
         IssmDouble *spcvz = NULL;
@@ -23 +23 @@
         iomodel->FindConstant(&isSSA,"md.flowequation.isSSA");
         iomodel->FindConstant(&isL1L2,"md.flowequation.isL1L2");
-        iomodel->FindConstant(&isMLHO,"md.flowequation.isMLHO");
+        iomodel->FindConstant(&isMOLHO,"md.flowequation.isMOLHO");
         iomodel->FindConstant(&isHO,"md.flowequation.isHO");
         iomodel->FindConstant(&isFS,"md.flowequation.isFS");
 
         /*Do we have coupling*/
-        if((isSIA?1.:0.) + (isSSA?1.:0.) + (isL1L2?1.:0.) + (isMLHO?1.:0.) + (isHO?1.:0.) + (isFS?1.:0.) >1.)
+        if((isSIA?1.:0.) + (isSSA?1.:0.) + (isL1L2?1.:0.) + (isMOLHO?1.:0.) + (isHO?1.:0.) + (isFS?1.:0.) >1.)
          iscoupling = true;
         else

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

@@ -1041 +1041 @@
 }
 /*}}}*/
-void       Element::dViscositydBMLHO(IssmDouble* pdmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vxbase_input,Input* vybase_input, Input* vxshear_input ,Input* vyshear_input,Input* thickness_input,Input* n_input, IssmDouble zeta){/*{{{*/
+void       Element::dViscositydBMOLHO(IssmDouble* pdmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vxbase_input,Input* vybase_input, Input* vxshear_input ,Input* vyshear_input,Input* thickness_input,Input* n_input, IssmDouble zeta){/*{{{*/
 
         /*Intermediaries*/
@@ -1051 +1051 @@
 
         /* eps_eff^2 = exx^2 + eyy^2 + exy^2 + exz^2 + eyz^2 + exx*eyy */
-   this->StrainRateMLHO(&epsilon[0],xyz_list,gauss,
+   this->StrainRateMOLHO(&epsilon[0],xyz_list,gauss,
                                 vxbase_input,vybase_input,vxshear_input,vyshear_input,thickness_input,n_input,zeta);
    eps_eff=sqrt(epsilon[0]*epsilon[0] + epsilon[1]*epsilon[1] + epsilon[2]*epsilon[2]
@@ -4619 +4619 @@
 
 }/*}}}*/
-void       Element::StrainRateMLHO(IssmDouble* epsilon,IssmDouble* xyz_list,Gauss* gauss,Input* vxbase_input,Input* vybase_input,Input* vxshear_input,Input* vyshear_input,Input* thickness_input,Input* n_input,IssmDouble zeta){/*{{{*/
-        /*Compute the 2d Blatter/MLHO Strain Rate (5 components) for a given vertical coordinate (zeta):
+void       Element::StrainRateMOLHO(IssmDouble* epsilon,IssmDouble* xyz_list,Gauss* gauss,Input* vxbase_input,Input* vybase_input,Input* vxshear_input,Input* vyshear_input,Input* thickness_input,Input* n_input,IssmDouble zeta){/*{{{*/
+        /*Compute the 2d Blatter/MOLHO Strain Rate (5 components) for a given vertical coordinate (zeta):
          *
          * epsilon=[exx eyy exy exz eyz]

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

@@ -86 +86 @@
                 void               dViscositydBHO(IssmDouble* pdmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input);
                 void               dViscositydBSSA(IssmDouble* pdmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input);
-                void               dViscositydBMLHO(IssmDouble* pdmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vxbase_input,Input* vybase_input, Input* vxshear_input ,Input* vyshear_input,Input* thickness_input,Input* n_input, IssmDouble zeta);
+                void               dViscositydBMOLHO(IssmDouble* pdmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vxbase_input,Input* vybase_input, Input* vxshear_input ,Input* vyshear_input,Input* thickness_input,Input* n_input, IssmDouble zeta);
                 void               dViscositydDSSA(IssmDouble* pdmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input);
                 void               Echo();
@@ -190 +190 @@
                 void               StrainRateHO(IssmDouble* epsilon,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input);
                 void               StrainRateHO2dvertical(IssmDouble* epsilon,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input);
-                void               StrainRateMLHO(IssmDouble* epsilon,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vxshear_input,Input* vyshear_input,Input* thickness_input,Input* n_input,IssmDouble zeta);
+                void               StrainRateMOLHO(IssmDouble* epsilon,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vxshear_input,Input* vyshear_input,Input* thickness_input,Input* n_input,IssmDouble zeta);
                 void               StrainRateSSA(IssmDouble* epsilon,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input);
                 void               StrainRateSSA1d(IssmDouble* epsilon,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input);
@@ -351 +351 @@
                 virtual void       PotentialUngrounding(Vector<IssmDouble>* potential_sheet_ungrounding)=0;
                 virtual int        PressureInterpolation()=0;
-      virtual void       Recover3DMLHOInput(int targetVel_enum, int numnodes, IssmDouble* vb,  IssmDouble* vsh, IssmDouble* n, IssmDouble* H, IssmDouble* s){_error_("not implemented yet");};
+      virtual void       Recover3DMOLHOInput(int targetVel_enum, int numnodes, IssmDouble* vb,  IssmDouble* vsh, IssmDouble* n, IssmDouble* H, IssmDouble* s){_error_("not implemented yet");};
                 virtual void       ReduceMatrices(ElementMatrix* Ke,ElementVector* pe)=0;
                 virtual void       ResetFSBasalBoundaryCondition()=0;

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

@@ -3282 +3282 @@
 }
 /*}}}*/
-void       Penta::Recover3DMLHOInput(int targetVel_enum, int numnodes, IssmDouble* vb,  IssmDouble* vsh, IssmDouble* n, IssmDouble* H, IssmDouble* s){/*{{{*/
+void       Penta::Recover3DMOLHOInput(int targetVel_enum, int numnodes, IssmDouble* vb,  IssmDouble* vsh, IssmDouble* n, IssmDouble* H, IssmDouble* s){/*{{{*/
    /* Recover the velocity acording to v=vb+(1-\zeta^{n+1})vsh, where \zeta=(s-z)/H
     * The variables vb, vsh, n, H and s are all from the 2D horizontal mesh(Tria), with "numnodes" DOFs

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

@@ -170 +170 @@
                 void           PotentialUngrounding(Vector<IssmDouble>* potential_sheet_ungrounding);
                 int            PressureInterpolation();
-      void           Recover3DMLHOInput(int targetVel_enum, int numnodes, IssmDouble* vb,  IssmDouble* vsh, IssmDouble* n, IssmDouble* H, IssmDouble* s);
+      void           Recover3DMOLHOInput(int targetVel_enum, int numnodes, IssmDouble* vb,  IssmDouble* vsh, IssmDouble* n, IssmDouble* H, IssmDouble* s);
                 void           ReduceMatrices(ElementMatrix* Ke,ElementVector* pe);
                 void           ResetFSBasalBoundaryCondition(void);

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

@@ -3219 +3219 @@
         this->parameters->FindParam(&temp,FlowequationIsSSAEnum); iomodel->AddConstant(new IoConstant(temp,"md.flowequation.isSSA"));
         this->parameters->FindParam(&temp,FlowequationIsL1L2Enum); iomodel->AddConstant(new IoConstant(temp,"md.flowequation.isL1L2"));
-        this->parameters->FindParam(&temp,FlowequationIsMLHOEnum); iomodel->AddConstant(new IoConstant(temp,"md.flowequation.isMLHO"));
+        this->parameters->FindParam(&temp,FlowequationIsMOLHOEnum); iomodel->AddConstant(new IoConstant(temp,"md.flowequation.isMOLHO"));
         this->parameters->FindParam(&temp,FlowequationIsHOEnum); iomodel->AddConstant(new IoConstant(temp,"md.flowequation.isHO"));
         this->parameters->FindParam(&temp,FlowequationIsFSEnum); iomodel->AddConstant(new IoConstant(temp,"md.flowequation.isFS"));

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

@@ -355 +355 @@
                                 default: _error_("Approximation "<<EnumToStringx(approximation1)<<" not supported yet");
                         }
-                case MLHOApproximationEnum:
-                        switch(approximation1){
-                                case MLHOApproximationEnum:   return PenaltyCreateKMatrixStressbalanceSSAHO(kmax); 
+                case MOLHOApproximationEnum:
+                        switch(approximation1){
+                                case MOLHOApproximationEnum:   return PenaltyCreateKMatrixStressbalanceSSAHO(kmax); 
                                 default: _error_("Approximation "<<EnumToStringx(approximation1)<<" not supported yet");
                         }

issm/trunk-jpl/src/c/classes/Materials/Material.h

@@ -51 +51 @@
                 virtual void       ViscosityFS(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input)=0;
                 virtual void       ViscosityHO(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input)=0;
-                virtual void       ViscosityMLHO(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vxshear_input,Input* vyshear_input,Input* thickness_input,Input* n_input)=0;
-                virtual void       ViscosityMLHOAdjoint(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vxshear_input,Input* vyshear_input,Input* thickness_input,Input* n_input)=0;
+                virtual void       ViscosityMOLHO(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vxshear_input,Input* vyshear_input,Input* thickness_input,Input* n_input)=0;
+                virtual void       ViscosityMOLHOAdjoint(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vxshear_input,Input* vyshear_input,Input* thickness_input,Input* n_input)=0;
                 virtual void       ViscosityL1L2(IssmDouble* pviscosity,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* surf)=0;
                 virtual void       ViscositySSA(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input)=0;

issm/trunk-jpl/src/c/classes/Materials/Matestar.cpp

@@ -567 +567 @@
         *pviscosity=GetViscosityGeneral(vx,vy,vz,&dvx[0],&dvy[0],&dvz[0],eps_eff,isdepthaveraged,gauss);
 }/*}}}*/
-void  Matestar::ViscosityMLHO(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vxshear_input,Input* vyshear_input,Input* thickness_input,Input* n_input){/*{{{*/
-        _error_("not implemented yet");
-}/*}}}*/
-void  Matestar::ViscosityMLHOAdjoint(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vxshear_input,Input* vyshear_input,Input* thickness_input,Input* n_input){/*{{{*/
+void  Matestar::ViscosityMOLHO(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vxshear_input,Input* vyshear_input,Input* thickness_input,Input* n_input){/*{{{*/
+        _error_("not implemented yet");
+}/*}}}*/
+void  Matestar::ViscosityMOLHOAdjoint(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vxshear_input,Input* vyshear_input,Input* thickness_input,Input* n_input){/*{{{*/
         _error_("not implemented yet");
 }/*}}}*/

issm/trunk-jpl/src/c/classes/Materials/Matestar.h

@@ -76 +76 @@
                 void       ViscosityFS(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input);
                 void       ViscosityHO(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input);
-                void       ViscosityMLHO(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vxshear_input,Input* vyshear_input,Input* thickness_input,Input* n_input);
-                void       ViscosityMLHOAdjoint(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vxshear_input,Input* vyshear_input,Input* thickness_input,Input* n_input);
+                void       ViscosityMOLHO(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vxshear_input,Input* vyshear_input,Input* thickness_input,Input* n_input);
+                void       ViscosityMOLHOAdjoint(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vxshear_input,Input* vyshear_input,Input* thickness_input,Input* n_input);
                 void       ViscosityL1L2(IssmDouble* pviscosity,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* surf);
                 void       ViscositySSA(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input);

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

@@ -734 +734 @@
         *pviscosity=viscosity;
 }/*}}}*/
-void  Matice::ViscosityMLHO(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vxbase_input,Input* vybase_input,Input* vxshear_input,Input* vyshear_input,Input* thickness_input,Input* n_input){/*{{{*/
+void  Matice::ViscosityMOLHO(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vxbase_input,Input* vybase_input,Input* vxshear_input,Input* vyshear_input,Input* thickness_input,Input* n_input){/*{{{*/
 
         /*Intermediaries*/
@@ -755 +755 @@
 
                 /* eps_eff^2 = exx^2 + eyy^2 + exy^2 + exz^2 + eyz^2 + exx*eyy (for a given zeta)*/
-                element->StrainRateMLHO(&epsilon[0],xyz_list,gauss,
+                element->StrainRateMOLHO(&epsilon[0],xyz_list,gauss,
                                                 vxbase_input,vybase_input,vxshear_input,vyshear_input,thickness_input,n_input,zeta);
                 epsilon_eff=sqrt(epsilon[0]*epsilon[0] + epsilon[1]*epsilon[1] + epsilon[2]*epsilon[2] 
@@ -795 +795 @@
         delete gauss_seg;
 }/*}}}*/
-void  Matice::ViscosityMLHOAdjoint(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vxbase_input,Input* vybase_input,Input* vxshear_input,Input* vyshear_input,Input* thickness_input,Input* n_input){/*{{{*/
+void  Matice::ViscosityMOLHOAdjoint(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vxbase_input,Input* vybase_input,Input* vxshear_input,Input* vyshear_input,Input* thickness_input,Input* n_input){/*{{{*/
 
         /* To compute the additional 5 terms in the viscosity appear in the adjoint equation*/
@@ -817 +817 @@
 
                 /* eps_eff^2 = exx^2 + eyy^2 + exy^2 + exz^2 + eyz^2 + exx*eyy (for a given zeta)*/
-                element->StrainRateMLHO(&epsilon[0],xyz_list,gauss,
+                element->StrainRateMOLHO(&epsilon[0],xyz_list,gauss,
                                                 vxbase_input,vybase_input,vxshear_input,vyshear_input,thickness_input,n_input,zeta);
                 epsilon_eff=sqrt(epsilon[0]*epsilon[0] + epsilon[1]*epsilon[1] + epsilon[2]*epsilon[2] 

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

@@ -78 +78 @@
                 void       ViscosityFS(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input);
                 void       ViscosityHO(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input);
-                void       ViscosityMLHO(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vxshear_input,Input* vyshear_input,Input* thickness_input,Input* n_input);
-                void       ViscosityMLHOAdjoint(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vxshear_input,Input* vyshear_input,Input* thickness_input,Input* n_input);
+                void       ViscosityMOLHO(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vxshear_input,Input* vyshear_input,Input* thickness_input,Input* n_input);
+                void       ViscosityMOLHOAdjoint(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vxshear_input,Input* vyshear_input,Input* thickness_input,Input* n_input);
                 void       ViscosityL1L2(IssmDouble* pviscosity,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* surf);
                 void       ViscositySSA(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input);

issm/trunk-jpl/src/c/classes/Materials/Matlitho.h

@@ -72 +72 @@
                 void       ViscosityFS(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input){_error_("not supported");};
                 void       ViscosityHO(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input){_error_("not supported");};
-                void       ViscosityMLHO(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vxshear_input,Input* vyshear_input,Input* thickness_input,Input* n_input){_error_("not supported");};
-                void       ViscosityMLHOAdjoint(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vxshear_input,Input* vyshear_input,Input* thickness_input,Input* n_input){_error_("not supported");};
+                void       ViscosityMOLHO(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vxshear_input,Input* vyshear_input,Input* thickness_input,Input* n_input){_error_("not supported");};
+                void       ViscosityMOLHOAdjoint(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vxshear_input,Input* vyshear_input,Input* thickness_input,Input* n_input){_error_("not supported");};
                 void       ViscosityL1L2(IssmDouble* pviscosity,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* surf){_error_("not supported");};
                 void       ViscositySSA(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input){_error_("not supported");};

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

@@ -118 +118 @@
                                 this->HardDeactivate();
                         }
-                        if(in_approximation==MLHOApproximationEnum && !reCast<int>(iomodel->Data("md.mesh.vertexonbase")[io_index])){
+                        if(in_approximation==MOLHOApproximationEnum && !reCast<int>(iomodel->Data("md.mesh.vertexonbase")[io_index])){
                                 this->HardDeactivate();
                         }

issm/trunk-jpl/src/c/cores/stressbalance_core.cpp

@@ -19 +19 @@
         bool       dakota_analysis,control_analysis;
         int        domaintype;
-        bool       isSIA,isSSA,isL1L2,isMLHO,isHO,isFS,isNitsche;
+        bool       isSIA,isSSA,isL1L2,isMOLHO,isHO,isFS,isNitsche;
         bool       save_results;
         int        solution_type;
@@ -31 +31 @@
         femmodel->parameters->FindParam(&isSSA,FlowequationIsSSAEnum);
         femmodel->parameters->FindParam(&isL1L2,FlowequationIsL1L2Enum);
-        femmodel->parameters->FindParam(&isMLHO,FlowequationIsMLHOEnum);
+        femmodel->parameters->FindParam(&isMOLHO,FlowequationIsMOLHOEnum);
         femmodel->parameters->FindParam(&isHO,FlowequationIsHOEnum);
         femmodel->parameters->FindParam(&isFS,FlowequationIsFSEnum);
@@ -75 +75 @@
 
         /*Compute stressbalance for SSA L1L2 HO and FS*/
-        if(isSSA || isL1L2 || isMLHO || isHO || isFS){
+        if(isSSA || isL1L2 || isMOLHO || isHO || isFS){
                 analysis = new StressbalanceAnalysis();
                 analysis->Core(femmodel);
@@ -82 +82 @@
 
         /*Compute vertical velocities*/
-        if (domaintype==Domain3DEnum && (isSIA || isSSA || isL1L2 || isMLHO || isHO)){
+        if (domaintype==Domain3DEnum && (isSIA || isSSA || isL1L2 || isMOLHO || isHO)){
 
                 /*We need basal melt rates for vertical velocity*/

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

@@ -66 +66 @@
         Input* vyobs_input  = NULL;
 
-        /*Read SurfaceEnum from 2D models:SSA, L1L2, MLHO*/
+        /*Read SurfaceEnum from 2D models:SSA, L1L2, MOLHO*/
         if (domaintype == Domain2DhorizontalEnum) {
                 vx_input = topelement->GetInput(VxSurfaceEnum);                                 _assert_(vx_input);

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

@@ -74 +74 @@
    Input* vyobs_input  = NULL;
 
-   /*Read SurfaceEnum from 2D models:SSA, L1L2, MLHO*/
+   /*Read SurfaceEnum from 2D models:SSA, L1L2, MOLHO*/
    if (domaintype == Domain2DhorizontalEnum) {
       vx_input = topelement->GetInput(VxSurfaceEnum);             _assert_(vx_input);

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

@@ -68 +68 @@
    Input* vyobs_input  = NULL;
 
-   /*Read SurfaceEnum from 2D models:SSA, L1L2, MLHO*/
+   /*Read SurfaceEnum from 2D models:SSA, L1L2, MOLHO*/
    if (domaintype == Domain2DhorizontalEnum) {
       vx_input = topelement->GetInput(VxSurfaceEnum);             _assert_(vx_input);

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

@@ -68 +68 @@
    Input* vyobs_input  = NULL;
 
-   /*Read SurfaceEnum from 2D models:SSA, L1L2, MLHO*/
+   /*Read SurfaceEnum from 2D models:SSA, L1L2, MOLHO*/
    if (domaintype == Domain2DhorizontalEnum) {
       vx_input = topelement->GetInput(VxSurfaceEnum);             _assert_(vx_input);

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

@@ -68 +68 @@
    Input* vyobs_input  = NULL;
 
-   /*Read SurfaceEnum from 2D models:SSA, L1L2, MLHO*/
+   /*Read SurfaceEnum from 2D models:SSA, L1L2, MOLHO*/
    if (domaintype == Domain2DhorizontalEnum) {
       vx_input = topelement->GetInput(VxSurfaceEnum);             _assert_(vx_input);

issm/trunk-jpl/src/c/shared/Enum/Enum.vim

@@ -113 +113 @@
 syn keyword cConstant CalvingMinthicknessEnum
 syn keyword cConstant CalvingTestSpeedfactorEnum
+syn keyword cConstant CalvingTestIndependentRateEnum
 syn keyword cConstant CalvingUseParamEnum
 syn keyword cConstant CalvingScaleThetaEnum
@@ -175 +176 @@
 syn keyword cConstant FlowequationIsHOEnum
 syn keyword cConstant FlowequationIsL1L2Enum
-syn keyword cConstant FlowequationIsMLHOEnum
+syn keyword cConstant FlowequationIsMOLHOEnum
 syn keyword cConstant FlowequationIsSIAEnum
 syn keyword cConstant FlowequationIsSSAEnum
@@ -658 +659 @@
 syn keyword cConstant CalvingCalvingrateEnum
 syn keyword cConstant CalvingHabFractionEnum
+syn keyword cConstant CalvingAblationrateEnum
 syn keyword cConstant CalvingMeltingrateEnum
 syn keyword cConstant CalvingStressThresholdFloatingiceEnum
@@ -1383 +1385 @@
 syn keyword cConstant JEnum
 syn keyword cConstant L1L2ApproximationEnum
-syn keyword cConstant MLHOApproximationEnum
+syn keyword cConstant MOLHOApproximationEnum
 syn keyword cConstant L2ProjectionBaseAnalysisEnum
 syn keyword cConstant L2ProjectionEPLAnalysisEnum
@@ -1622 +1624 @@
 syn keyword cType Cfsurfacesquare
 syn keyword cType Channel
-syn keyword cType classes
 syn keyword cType Constraint
 syn keyword cType Constraints
@@ -1629 +1630 @@
 syn keyword cType ControlInput
 syn keyword cType Covertree
+syn keyword cType DataSetParam
 syn keyword cType DatasetInput
-syn keyword cType DataSetParam
 syn keyword cType Definition
 syn keyword cType DependentObject
@@ -1643 +1644 @@
 syn keyword cType ElementInput
 syn keyword cType ElementMatrix
+syn keyword cType ElementVector
 syn keyword cType Elements
-syn keyword cType ElementVector
 syn keyword cType ExponentialVariogram
 syn keyword cType ExternalResult
@@ -1651 +1652 @@
 syn keyword cType Friction
 syn keyword cType Gauss
-syn keyword cType GaussianVariogram
-syn keyword cType gaussobjects
 syn keyword cType GaussPenta
 syn keyword cType GaussSeg
 syn keyword cType GaussTetra
 syn keyword cType GaussTria
+syn keyword cType GaussianVariogram
 syn keyword cType GenericExternalResult
 syn keyword cType GenericOption
@@ -1672 +1672 @@
 syn keyword cType IssmDirectApplicInterface
 syn keyword cType IssmParallelDirectApplicInterface
-syn keyword cType krigingobjects
 syn keyword cType Load
 syn keyword cType Loads
@@ -1683 +1682 @@
 syn keyword cType Matice
 syn keyword cType Matlitho
-syn keyword cType matrixobjects
 syn keyword cType MatrixParam
 syn keyword cType Misfit
@@ -1696 +1694 @@
 syn keyword cType Observations
 syn keyword cType Option
+syn keyword cType OptionUtilities
 syn keyword cType Options
-syn keyword cType OptionUtilities
 syn keyword cType Param
 syn keyword cType Parameters
@@ -1711 +1709 @@
 syn keyword cType Regionaloutput
 syn keyword cType Results
+syn keyword cType RiftStruct
 syn keyword cType Riftfront
-syn keyword cType RiftStruct
 syn keyword cType SealevelGeometry
 syn keyword cType Seg
 syn keyword cType SegInput
+syn keyword cType SegRef
 syn keyword cType Segment
-syn keyword cType SegRef
 syn keyword cType SpcDynamic
 syn keyword cType SpcStatic
@@ -1736 +1734 @@
 syn keyword cType Vertex
 syn keyword cType Vertices
+syn keyword cType classes
+syn keyword cType gaussobjects
+syn keyword cType krigingobjects
+syn keyword cType matrixobjects
 syn keyword cType AdjointBalancethickness2Analysis
 syn keyword cType AdjointBalancethicknessAnalysis

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

@@ -170 +170 @@
         FlowequationIsHOEnum,
         FlowequationIsL1L2Enum,
-        FlowequationIsMLHOEnum,
+        FlowequationIsMOLHOEnum,
         FlowequationIsSIAEnum,
         FlowequationIsSSAEnum,
@@ -1384 +1384 @@
         JEnum,
         L1L2ApproximationEnum,
-        MLHOApproximationEnum,
+        MOLHOApproximationEnum,
         L2ProjectionBaseAnalysisEnum,
         L2ProjectionEPLAnalysisEnum,

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

@@ -115 +115 @@
                 case CalvingMinthicknessEnum : return "CalvingMinthickness";
                 case CalvingTestSpeedfactorEnum : return "CalvingTestSpeedfactor";
+                case CalvingTestIndependentRateEnum : return "CalvingTestIndependentRate";
                 case CalvingUseParamEnum : return "CalvingUseParam";
                 case CalvingScaleThetaEnum : return "CalvingScaleTheta";
@@ -177 +178 @@
                 case FlowequationIsHOEnum : return "FlowequationIsHO";
                 case FlowequationIsL1L2Enum : return "FlowequationIsL1L2";
-                case FlowequationIsMLHOEnum : return "FlowequationIsMLHO";
+                case FlowequationIsMOLHOEnum : return "FlowequationIsMOLHO";
                 case FlowequationIsSIAEnum : return "FlowequationIsSIA";
                 case FlowequationIsSSAEnum : return "FlowequationIsSSA";
@@ -660 +661 @@
                 case CalvingCalvingrateEnum : return "CalvingCalvingrate";
                 case CalvingHabFractionEnum : return "CalvingHabFraction";
+                case CalvingAblationrateEnum : return "CalvingAblationrate";
                 case CalvingMeltingrateEnum : return "CalvingMeltingrate";
                 case CalvingStressThresholdFloatingiceEnum : return "CalvingStressThresholdFloatingice";
@@ -1385 +1387 @@
                 case JEnum : return "J";
                 case L1L2ApproximationEnum : return "L1L2Approximation";
-                case MLHOApproximationEnum : return "MLHOApproximation";
+                case MOLHOApproximationEnum : return "MOLHOApproximation";
                 case L2ProjectionBaseAnalysisEnum : return "L2ProjectionBaseAnalysis";
                 case L2ProjectionEPLAnalysisEnum : return "L2ProjectionEPLAnalysis";

issm/trunk-jpl/src/c/shared/Enum/Enumjl.vim

@@ -106 +106 @@
 syn keyword juliaConstC CalvingMinthicknessEnum
 syn keyword juliaConstC CalvingTestSpeedfactorEnum
+syn keyword juliaConstC CalvingTestIndependentRateEnum
 syn keyword juliaConstC CalvingUseParamEnum
 syn keyword juliaConstC CalvingScaleThetaEnum
@@ -168 +169 @@
 syn keyword juliaConstC FlowequationIsHOEnum
 syn keyword juliaConstC FlowequationIsL1L2Enum
-syn keyword juliaConstC FlowequationIsMLHOEnum
+syn keyword juliaConstC FlowequationIsMOLHOEnum
 syn keyword juliaConstC FlowequationIsSIAEnum
 syn keyword juliaConstC FlowequationIsSSAEnum
@@ -651 +652 @@
 syn keyword juliaConstC CalvingCalvingrateEnum
 syn keyword juliaConstC CalvingHabFractionEnum
+syn keyword juliaConstC CalvingAblationrateEnum
 syn keyword juliaConstC CalvingMeltingrateEnum
 syn keyword juliaConstC CalvingStressThresholdFloatingiceEnum
@@ -1376 +1378 @@
 syn keyword juliaConstC JEnum
 syn keyword juliaConstC L1L2ApproximationEnum
-syn keyword juliaConstC MLHOApproximationEnum
+syn keyword juliaConstC MOLHOApproximationEnum
 syn keyword juliaConstC L2ProjectionBaseAnalysisEnum
 syn keyword juliaConstC L2ProjectionEPLAnalysisEnum

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

@@ -115 +115 @@
               else if (strcmp(name,"CalvingMinthickness")==0) return CalvingMinthicknessEnum;
               else if (strcmp(name,"CalvingTestSpeedfactor")==0) return CalvingTestSpeedfactorEnum;
+              else if (strcmp(name,"CalvingTestIndependentRate")==0) return CalvingTestIndependentRateEnum;
               else if (strcmp(name,"CalvingUseParam")==0) return CalvingUseParamEnum;
               else if (strcmp(name,"CalvingScaleTheta")==0) return CalvingScaleThetaEnum;
@@ -136 +137 @@
               else if (strcmp(name,"CumBslcOceanPartition")==0) return CumBslcOceanPartitionEnum;
               else if (strcmp(name,"CumGmtslc")==0) return CumGmtslcEnum;
-              else if (strcmp(name,"CumGmslc")==0) return CumGmslcEnum;
          else stage=2;
    }
    if(stage==2){
-              if (strcmp(name,"DamageC1")==0) return DamageC1Enum;
+              if (strcmp(name,"CumGmslc")==0) return CumGmslcEnum;
+              else if (strcmp(name,"DamageC1")==0) return DamageC1Enum;
               else if (strcmp(name,"DamageC2")==0) return DamageC2Enum;
               else if (strcmp(name,"DamageC3")==0) return DamageC3Enum;
@@ -180 +181 @@
               else if (strcmp(name,"FlowequationIsHO")==0) return FlowequationIsHOEnum;
               else if (strcmp(name,"FlowequationIsL1L2")==0) return FlowequationIsL1L2Enum;
-              else if (strcmp(name,"FlowequationIsMLHO")==0) return FlowequationIsMLHOEnum;
+              else if (strcmp(name,"FlowequationIsMOLHO")==0) return FlowequationIsMOLHOEnum;
               else if (strcmp(name,"FlowequationIsSIA")==0) return FlowequationIsSIAEnum;
               else if (strcmp(name,"FlowequationIsSSA")==0) return FlowequationIsSSAEnum;
@@ -259 +260 @@
               else if (strcmp(name,"InversionAlgorithm")==0) return InversionAlgorithmEnum;
               else if (strcmp(name,"InversionControlParameters")==0) return InversionControlParametersEnum;
-              else if (strcmp(name,"InversionControlScalingFactors")==0) return InversionControlScalingFactorsEnum;
          else stage=3;
    }
    if(stage==3){
-              if (strcmp(name,"InversionCostFunctions")==0) return InversionCostFunctionsEnum;
+              if (strcmp(name,"InversionControlScalingFactors")==0) return InversionControlScalingFactorsEnum;
+              else if (strcmp(name,"InversionCostFunctions")==0) return InversionCostFunctionsEnum;
               else if (strcmp(name,"InversionDxmin")==0) return InversionDxminEnum;
               else if (strcmp(name,"InversionGatol")==0) return InversionGatolEnum;
@@ -382 +383 @@
               else if (strcmp(name,"SamplingSeed")==0) return SamplingSeedEnum;
               else if (strcmp(name,"SaveResults")==0) return SaveResultsEnum;
-              else if (strcmp(name,"SolidearthPartitionIce")==0) return SolidearthPartitionIceEnum;
          else stage=4;
    }
    if(stage==4){
-              if (strcmp(name,"SolidearthPartitionHydro")==0) return SolidearthPartitionHydroEnum;
+              if (strcmp(name,"SolidearthPartitionIce")==0) return SolidearthPartitionIceEnum;
+              else if (strcmp(name,"SolidearthPartitionHydro")==0) return SolidearthPartitionHydroEnum;
               else if (strcmp(name,"SolidearthPartitionOcean")==0) return SolidearthPartitionOceanEnum;
               else if (strcmp(name,"SolidearthNpartIce")==0) return SolidearthNpartIceEnum;
@@ -505 +506 @@
               else if (strcmp(name,"SmbK")==0) return SmbKEnum;
               else if (strcmp(name,"SmbLapseRates")==0) return SmbLapseRatesEnum;
-              else if (strcmp(name,"SmbNumBasins")==0) return SmbNumBasinsEnum;
          else stage=5;
    }
    if(stage==5){
-              if (strcmp(name,"SmbNumElevationBins")==0) return SmbNumElevationBinsEnum;
+              if (strcmp(name,"SmbNumBasins")==0) return SmbNumBasinsEnum;
+              else if (strcmp(name,"SmbNumElevationBins")==0) return SmbNumElevationBinsEnum;
               else if (strcmp(name,"SmbNumRequestedOutputs")==0) return SmbNumRequestedOutputsEnum;
               else if (strcmp(name,"SmbPfac")==0) return SmbPfacEnum;
@@ -628 +629 @@
               else if (strcmp(name,"BasalforcingsFloatingiceMeltingRate")==0) return BasalforcingsFloatingiceMeltingRateEnum;
               else if (strcmp(name,"BasalforcingsGeothermalflux")==0) return BasalforcingsGeothermalfluxEnum;
-              else if (strcmp(name,"BasalforcingsGroundediceMeltingRate")==0) return BasalforcingsGroundediceMeltingRateEnum;
          else stage=6;
    }
    if(stage==6){
-              if (strcmp(name,"BasalforcingsLinearBasinId")==0) return BasalforcingsLinearBasinIdEnum;
+              if (strcmp(name,"BasalforcingsGroundediceMeltingRate")==0) return BasalforcingsGroundediceMeltingRateEnum;
+              else if (strcmp(name,"BasalforcingsLinearBasinId")==0) return BasalforcingsLinearBasinIdEnum;
               else if (strcmp(name,"BasalforcingsPerturbationMeltingRate")==0) return BasalforcingsPerturbationMeltingRateEnum;
               else if (strcmp(name,"BasalforcingsSpatialDeepwaterElevation")==0) return BasalforcingsSpatialDeepwaterElevationEnum;
@@ -675 +676 @@
               else if (strcmp(name,"CalvingCalvingrate")==0) return CalvingCalvingrateEnum;
               else if (strcmp(name,"CalvingHabFraction")==0) return CalvingHabFractionEnum;
+              else if (strcmp(name,"CalvingAblationrate")==0) return CalvingAblationrateEnum;
               else if (strcmp(name,"CalvingMeltingrate")==0) return CalvingMeltingrateEnum;
               else if (strcmp(name,"CalvingStressThresholdFloatingice")==0) return CalvingStressThresholdFloatingiceEnum;
@@ -750 +752 @@
               else if (strcmp(name,"FrictionP")==0) return FrictionPEnum;
               else if (strcmp(name,"FrictionPressureAdjustedTemperature")==0) return FrictionPressureAdjustedTemperatureEnum;
-              else if (strcmp(name,"FrictionQ")==0) return FrictionQEnum;
-              else if (strcmp(name,"FrictionSedimentCompressibilityCoefficient")==0) return FrictionSedimentCompressibilityCoefficientEnum;
          else stage=7;
    }
    if(stage==7){
-              if (strcmp(name,"FrictionTillFrictionAngle")==0) return FrictionTillFrictionAngleEnum;
+              if (strcmp(name,"FrictionQ")==0) return FrictionQEnum;
+              else if (strcmp(name,"FrictionSedimentCompressibilityCoefficient")==0) return FrictionSedimentCompressibilityCoefficientEnum;
+              else if (strcmp(name,"FrictionTillFrictionAngle")==0) return FrictionTillFrictionAngleEnum;
               else if (strcmp(name,"FrictionWaterLayer")==0) return FrictionWaterLayerEnum;
               else if (strcmp(name,"Frictionf")==0) return FrictionfEnum;
@@ -873 +875 @@
               else if (strcmp(name,"SealevelBarystaticIceWeights")==0) return SealevelBarystaticIceWeightsEnum;
               else if (strcmp(name,"SealevelBarystaticIceArea")==0) return SealevelBarystaticIceAreaEnum;
-              else if (strcmp(name,"SealevelBarystaticIceLatbar")==0) return SealevelBarystaticIceLatbarEnum;
-              else if (strcmp(name,"SealevelBarystaticIceLongbar")==0) return SealevelBarystaticIceLongbarEnum;
          else stage=8;
    }
    if(stage==8){
-              if (strcmp(name,"SealevelBarystaticIceLoad")==0) return SealevelBarystaticIceLoadEnum;
+              if (strcmp(name,"SealevelBarystaticIceLatbar")==0) return SealevelBarystaticIceLatbarEnum;
+              else if (strcmp(name,"SealevelBarystaticIceLongbar")==0) return SealevelBarystaticIceLongbarEnum;
+              else if (strcmp(name,"SealevelBarystaticIceLoad")==0) return SealevelBarystaticIceLoadEnum;
               else if (strcmp(name,"SealevelBarystaticHydroMask")==0) return SealevelBarystaticHydroMaskEnum;
               else if (strcmp(name,"SealevelBarystaticHydroWeights")==0) return SealevelBarystaticHydroWeightsEnum;
@@ -996 +998 @@
               else if (strcmp(name,"SmbGdnini")==0) return SmbGdniniEnum;
               else if (strcmp(name,"SmbGsp")==0) return SmbGspEnum;
-              else if (strcmp(name,"SmbGspini")==0) return SmbGspiniEnum;
-              else if (strcmp(name,"SmbHref")==0) return SmbHrefEnum;
          else stage=9;
    }
    if(stage==9){
-              if (strcmp(name,"SmbIsInitialized")==0) return SmbIsInitializedEnum;
+              if (strcmp(name,"SmbGspini")==0) return SmbGspiniEnum;
+              else if (strcmp(name,"SmbHref")==0) return SmbHrefEnum;
+              else if (strcmp(name,"SmbIsInitialized")==0) return SmbIsInitializedEnum;
               else if (strcmp(name,"SmbMAdd")==0) return SmbMAddEnum;
               else if (strcmp(name,"SmbMassBalance")==0) return SmbMassBalanceEnum;
@@ -1119 +1121 @@
               else if (strcmp(name,"VxSurface")==0) return VxSurfaceEnum;
               else if (strcmp(name,"VyAverage")==0) return VyAverageEnum;
-              else if (strcmp(name,"VyBase")==0) return VyBaseEnum;
-              else if (strcmp(name,"Vy")==0) return VyEnum;
          else stage=10;
    }
    if(stage==10){
-              if (strcmp(name,"VyMesh")==0) return VyMeshEnum;
+              if (strcmp(name,"VyBase")==0) return VyBaseEnum;
+              else if (strcmp(name,"Vy")==0) return VyEnum;
+              else if (strcmp(name,"VyMesh")==0) return VyMeshEnum;
               else if (strcmp(name,"VyObs")==0) return VyObsEnum;
               else if (strcmp(name,"VyShear")==0) return VyShearEnum;
@@ -1242 +1244 @@
               else if (strcmp(name,"Outputdefinition96")==0) return Outputdefinition96Enum;
               else if (strcmp(name,"Outputdefinition97")==0) return Outputdefinition97Enum;
-              else if (strcmp(name,"Outputdefinition98")==0) return Outputdefinition98Enum;
-              else if (strcmp(name,"Outputdefinition99")==0) return Outputdefinition99Enum;
          else stage=11;
    }
    if(stage==11){
-              if (strcmp(name,"Outputdefinition9")==0) return Outputdefinition9Enum;
+              if (strcmp(name,"Outputdefinition98")==0) return Outputdefinition98Enum;
+              else if (strcmp(name,"Outputdefinition99")==0) return Outputdefinition99Enum;
+              else if (strcmp(name,"Outputdefinition9")==0) return Outputdefinition9Enum;
               else if (strcmp(name,"Outputdefinition100")==0) return Outputdefinition100Enum;
               else if (strcmp(name,"InputsEND")==0) return InputsENDEnum;
@@ -1365 +1367 @@
               else if (strcmp(name,"GaussTetra")==0) return GaussTetraEnum;
               else if (strcmp(name,"GaussTria")==0) return GaussTriaEnum;
-              else if (strcmp(name,"GenericOption")==0) return GenericOptionEnum;
-              else if (strcmp(name,"GenericParam")==0) return GenericParamEnum;
          else stage=12;
    }
    if(stage==12){
-              if (strcmp(name,"GenericExternalResult")==0) return GenericExternalResultEnum;
+              if (strcmp(name,"GenericOption")==0) return GenericOptionEnum;
+              else if (strcmp(name,"GenericParam")==0) return GenericParamEnum;
+              else if (strcmp(name,"GenericExternalResult")==0) return GenericExternalResultEnum;
               else if (strcmp(name,"Gradient1")==0) return Gradient1Enum;
               else if (strcmp(name,"Gradient2")==0) return Gradient2Enum;
@@ -1418 +1420 @@
               else if (strcmp(name,"J")==0) return JEnum;
               else if (strcmp(name,"L1L2Approximation")==0) return L1L2ApproximationEnum;
-              else if (strcmp(name,"MLHOApproximation")==0) return MLHOApproximationEnum;
+              else if (strcmp(name,"MOLHOApproximation")==0) return MOLHOApproximationEnum;
               else if (strcmp(name,"L2ProjectionBaseAnalysis")==0) return L2ProjectionBaseAnalysisEnum;
               else if (strcmp(name,"L2ProjectionEPLAnalysis")==0) return L2ProjectionEPLAnalysisEnum;
@@ -1488 +1490 @@
               else if (strcmp(name,"Nodal")==0) return NodalEnum;
               else if (strcmp(name,"Nodalvalue")==0) return NodalvalueEnum;
-              else if (strcmp(name,"NodeSId")==0) return NodeSIdEnum;
-              else if (strcmp(name,"NoneApproximation")==0) return NoneApproximationEnum;
          else stage=13;
    }
    if(stage==13){
-              if (strcmp(name,"None")==0) return NoneEnum;
+              if (strcmp(name,"NodeSId")==0) return NodeSIdEnum;
+              else if (strcmp(name,"NoneApproximation")==0) return NoneApproximationEnum;
+              else if (strcmp(name,"None")==0) return NoneEnum;
               else if (strcmp(name,"Numberedcostfunction")==0) return NumberedcostfunctionEnum;
               else if (strcmp(name,"NyeCO2")==0) return NyeCO2Enum;
@@ -1611 +1613 @@
               else if (strcmp(name,"TotalSmbScaled")==0) return TotalSmbScaledEnum;
               else if (strcmp(name,"TransientArrayParam")==0) return TransientArrayParamEnum;
-              else if (strcmp(name,"TransientInput")==0) return TransientInputEnum;
-              else if (strcmp(name,"TransientParam")==0) return TransientParamEnum;
          else stage=14;
    }
    if(stage==14){
-              if (strcmp(name,"TransientSolution")==0) return TransientSolutionEnum;
+              if (strcmp(name,"TransientInput")==0) return TransientInputEnum;
+              else if (strcmp(name,"TransientParam")==0) return TransientParamEnum;
+              else if (strcmp(name,"TransientSolution")==0) return TransientSolutionEnum;
               else if (strcmp(name,"Tria")==0) return TriaEnum;
               else if (strcmp(name,"TriaInput")==0) return TriaInputEnum;

issm/trunk-jpl/src/c/shared/io/Marshalling/IoCodeConversions.cpp

@@ -345 +345 @@
                 case 2: return SSAApproximationEnum;
                 case 3: return L1L2ApproximationEnum;
-                case 4: return MLHOApproximationEnum;
+                case 4: return MOLHOApproximationEnum;
                 case 5: return HOApproximationEnum;
                 case 6: return FSApproximationEnum;
@@ -360 +360 @@
                 case 2: return SSAApproximationEnum;
                 case 3: return L1L2ApproximationEnum;
-                case 4: return MLHOApproximationEnum;
+                case 4: return MOLHOApproximationEnum;
                 case 5: return HOApproximationEnum;
                 case 6: return FSApproximationEnum;

issm/trunk-jpl/src/m/boundaryconditions/SetMOLHOBC.m

@@ -1 @@
-function md=SetMLHOBC(md)
-%SETMLHOBC - Create the boundary conditions for stressbalance for MLHO: VxBase, VyBase, VxShear, VyShear
+function md=SetMOLHOBC(md)
+%SETMOLHOBC - Create the boundary conditions for stressbalance for MOLHO: VxBase, VyBase, VxShear, VyShear
 %
 %   Usage:
-%      md=SetMLHOBC(md)
+%      md=SetMOLHOBC(md)
 %
 
 
 %node on Dirichlet
-if md.flowequation.isMLHO
+if md.flowequation.isMOLHO
         md.stressbalance.spcvx_base=md.stressbalance.spcvx;
         md.stressbalance.spcvy_base=md.stressbalance.spcvy;

issm/trunk-jpl/src/m/boundaryconditions/SetMOLHOBC.py

@@ -1 +1 @@
 import numpy as np
 
-
-def SetMLHOBC(md):
+def SetMOLHOBC(md):
     """
-    SETMLHOBC - Create the boundary conditions for stressbalance for MLHO: VxBase, VyBase, VxShear, VyShear
+    SETMOLHOBC - Create the boundary conditions for stressbalance for MOLHO: VxBase, VyBase, VxShear, VyShear
 
        Usage:

issm/trunk-jpl/src/m/classes/flowequation.js

@@ -22 +22 @@
                 fielddisplay(this,'isSSA','is the Shelfy-Stream Approximation (SSA) used ?');
                 fielddisplay(this,'isL1L2','is the L1L2 approximation used ?');
-                fielddisplay(this,'isMLHO','is the Mono-Layer Higher-Order approximation used?');
+                fielddisplay(this,'isMOLHO','is the MOno-Layer Higher-Order (MOLHO) approximation used?');
                 fielddisplay(this,'isHO','is the Higher-Order (HO) approximation used ?');
                 fielddisplay(this,'isFS','are the Full-FS (FS) equations used ?');
@@ -41 +41 @@
 
         }// }}}
-    this.extrude = function(md) {//{{{
-        this.element_equation=project3d(md,'vector',this.element_equation,'type','element');
-        this.vertex_equation=project3d(md,'vector',this.vertex_equation,'type','node');
-        this.borderSSA=project3d(md,'vector',this.borderSSA,'type','node');
-        this.borderHO=project3d(md,'vector',this.borderHO,'type','node');
-        this.borderFS=project3d(md,'vector',this.borderFS,'type','node');
-        return this;
+        this.extrude = function(md) {//{{{
+                this.element_equation=project3d(md,'vector',this.element_equation,'type','element');
+                this.vertex_equation=project3d(md,'vector',this.vertex_equation,'type','node');
+                this.borderSSA=project3d(md,'vector',this.borderSSA,'type','node');
+                this.borderHO=project3d(md,'vector',this.borderHO,'type','node');
+                this.borderFS=project3d(md,'vector',this.borderFS,'type','node');
+                return this;
     }//}}}
                 this.checkconsistency = function(md,solution,analyses) {//{{{
@@ -59 +59 @@
                         checkfield(md,'fieldname','flowequation.isSSA','numel',[1],'values',[0, 1]);
                         checkfield(md,'fieldname','flowequation.isL1L2','numel',[1],'values',[0, 1]);
-                        checkfield(md,'fieldname','flowequation.isMLHO','numel',[1],'values',[0, 1]);
+                        checkfield(md,'fieldname','flowequation.isMOLHO','numel',[1],'values',[0, 1]);
                         checkfield(md,'fieldname','flowequation.isHO','numel',[1],'values',[0, 1]);
                         checkfield(md,'fieldname','flowequation.isFS','numel',[1],'values',[0, 1]);
@@ -93 +93 @@
                         else throw Error('Case not supported yet');
                         
-                        if (!(this.isSIA | this.isSSA | this.isL1L2 | this.isMLHO | this.isHO | this.isFS)){
+                        if (!(this.isSIA | this.isSSA | this.isL1L2 | this.isMOLHO | this.isHO | this.isFS)){
                                 checkmessage(md,['no element types set for this model']);
                         }
@@ -108 +108 @@
                         WriteData(fid,prefix,'object',this,'fieldname','isSSA','format','Boolean');
                         WriteData(fid,prefix,'object',this,'fieldname','isL1L2','format','Boolean');
-                        WriteData(fid,prefix,'object',this,'fieldname','isMLHO','format','Boolean');
+                        WriteData(fid,prefix,'object',this,'fieldname','isMOLHO','format','Boolean');
                         WriteData(fid,prefix,'object',this,'fieldname','isHO','format','Boolean');
                         WriteData(fid,prefix,'object',this,'fieldname','isFS','format','Boolean');
@@ -138 +138 @@
         this.isSSA                          = 0;
         this.isL1L2                         = 0;
-        this.isMLHO                         = 0;
+        this.isMOLHO                         = 0;
         this.isHO                           = 0;
         this.isFS                           = 0;

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

@@ -9 +9 @@
                 isSSA                          = 0;
                 isL1L2                         = 0;
-                isMLHO                         = 0;
+                isMOLHO                         = 0;
                 isHO                           = 0;
                 isFS                           = 0;
@@ -60 +60 @@
                                 if isfield(objstruct,'borderpattyn'),  self.borderHO  = objstruct.borderpattyn;   end; 
                                 if isfield(objstruct,'borderstokes'),  self.borderFS  = objstruct.borderstokes;   end; 
-                        end
-
-                        %Nov 6 2021
-                        if any(self.vertex_equation==4)
-                                disp(['Monolayer Higher-Order (MLHO) detected in md.flowequation, this is still under development. Please double check your settings.']);
-                        end
+
+                                %May 31 2022
+                                if isfield(objstruct,'isMLHO')
+                                        self.isMOLHO = objstruct.isMLHO;
+                                end
+                        end
+
 
                 end% }}}
@@ -104 +105 @@
                         md = checkfield(md,'fieldname','flowequation.isSSA','numel',[1],'values',[0 1]);
                         md = checkfield(md,'fieldname','flowequation.isL1L2','numel',[1],'values',[0 1]);
-                        md = checkfield(md,'fieldname','flowequation.isMLHO','numel',[1],'values',[0 1]);
+                        md = checkfield(md,'fieldname','flowequation.isMOLHO','numel',[1],'values',[0 1]);
                         md = checkfield(md,'fieldname','flowequation.isHO','numel',[1],'values',[0 1]);
                         md = checkfield(md,'fieldname','flowequation.isFS','numel',[1],'values',[0 1]);
@@ -135 +136 @@
                                 error('Case not supported yet');
                         end
-                        if ~(self.isSIA || self.isSSA || self.isL1L2 || self.isMLHO || self.isHO || self.isFS),
+                        if ~(self.isSIA || self.isSSA || self.isL1L2 || self.isMOLHO || self.isHO || self.isFS),
                                 md = checkmessage(md,['no element types set for this model']);
                         end
@@ -153 +154 @@
                         fielddisplay(self,'isSSA','is the Shelfy-Stream Approximation (SSA) used?');
                         fielddisplay(self,'isL1L2','is the L1L2 approximation used?');
-                        fielddisplay(self,'isMLHO','is the Mono-Layer Higher-Order approximation used?');
+                        fielddisplay(self,'isMOLHO','is the MOno-Layer Higher-Order (MOLHO) approximation used?');
                         fielddisplay(self,'isHO','is the Higher-Order (HO) approximation used?');
                         fielddisplay(self,'isFS','are the Full-FS (FS) equations used?');
@@ -172 +173 @@
                         WriteData(fid,prefix,'object',self,'fieldname','isSSA','format','Boolean');
                         WriteData(fid,prefix,'object',self,'fieldname','isL1L2','format','Boolean');
-                        WriteData(fid,prefix,'object',self,'fieldname','isMLHO','format','Boolean');
+                        WriteData(fid,prefix,'object',self,'fieldname','isMOLHO','format','Boolean');
                         WriteData(fid,prefix,'object',self,'fieldname','isHO','format','Boolean');
                         WriteData(fid,prefix,'object',self,'fieldname','isFS','format','Boolean');
@@ -197 +198 @@
                         writejsdouble(fid,[modelname '.flowequation.isSSA'],self.isSSA);
                         writejsdouble(fid,[modelname '.flowequation.isL1L2'],self.isL1L2);
-                        writejsdouble(fid,[modelname '.flowequation.isMLHO'],self.isMLHO);
+                        writejsdouble(fid,[modelname '.flowequation.isMOLHO'],self.isMOLHO);
                         writejsdouble(fid,[modelname '.flowequation.isHO'],self.isHO);
                         writejsdouble(fid,[modelname '.flowequation.isFS'],self.isFS);

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

@@ -19 +19 @@
         self.isSSA = 0
         self.isL1L2 = 0
-        self.isMLHO = 0
+        self.isMOLHO = 0
         self.isHO = 0
         self.isFS = 0
@@ -46 +46 @@
         s += '{}\n'.format(fielddisplay(self, 'isSSA', "is the Shelfy-Stream Approximation (SSA) used?"))
         s += '{}\n'.format(fielddisplay(self, 'isL1L2', "are L1L2 equations used?"))
-        s += '{}\n'.format(fielddisplay(self, 'isMLHO', "are Mono-layer Higher-Order equations used?"))
+        s += '{}\n'.format(fielddisplay(self, 'isMOLHO', "are MOno-layer Higher-Order (MOLHO) equations used?"))
         s += '{}\n'.format(fielddisplay(self, 'isHO', "is the Higher-Order (HO) approximation used?"))
         s += '{}\n'.format(fielddisplay(self, 'isFS', "are the Full-FS (FS) equations used?"))
@@ -90 +90 @@
         md = checkfield(md, 'fieldname', 'flowequation.isSSA', 'numel', [1], 'values', [0, 1])
         md = checkfield(md, 'fieldname', 'flowequation.isL1L2', 'numel', [1], 'values', [0, 1])
-        md = checkfield(md, 'fieldname', 'flowequation.isMLHO', 'numel', [1], 'values', [0, 1])
+        md = checkfield(md, 'fieldname', 'flowequation.isMOLHO', 'numel', [1], 'values', [0, 1])
         md = checkfield(md, 'fieldname', 'flowequation.isHO', 'numel', [1], 'values', [0, 1])
         md = checkfield(md, 'fieldname', 'flowequation.isFS', 'numel', [1], 'values', [0, 1])
@@ -121 +121 @@
             raise RuntimeError('Case not supported yet')
 
-        if not (self.isSIA or self.isSSA or self.isL1L2 or self.isMLHO or self.isHO or self.isFS):
+        if not (self.isSIA or self.isSSA or self.isL1L2 or self.isMOLHO or self.isHO or self.isFS):
             md.checkmessage("no element types set for this model")
         if 'StressbalanceSIAAnalysis' in analyses:
@@ -134 +134 @@
         WriteData(fid, prefix, 'object', self, 'fieldname', 'isSSA', 'format', 'Boolean')
         WriteData(fid, prefix, 'object', self, 'fieldname', 'isL1L2', 'format', 'Boolean')
-        WriteData(fid, prefix, 'object', self, 'fieldname', 'isMLHO', 'format', 'Boolean')
+        WriteData(fid, prefix, 'object', self, 'fieldname', 'isMOLHO', 'format', 'Boolean')
         WriteData(fid, prefix, 'object', self, 'fieldname', 'isHO', 'format', 'Boolean')
         WriteData(fid, prefix, 'object', self, 'fieldname', 'isFS', 'format', 'Boolean')

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

@@ -104 +104 @@
                         %Only SSA, HO and FS are supported right now
                         if strcmp(solution,'StressbalanceSolution')
-                                if ~(md.flowequation.isSSA || md.flowequation.isMLHO || md.flowequation.isHO || md.flowequation.isFS || md.flowequation.isL1L2),
-                                        md = checkmessage(md,['inversion can only be performed for SSA, MLHO, HO or FS ice flow models']);
+                                if ~(md.flowequation.isSSA || md.flowequation.isMOLHO || md.flowequation.isHO || md.flowequation.isFS || md.flowequation.isL1L2),
+                                        md = checkmessage(md,['inversion can only be performed for SSA, MOLHO, HO or FS ice flow models']);
                                 end
                         end

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

@@ -151 +151 @@
         # Only SSA, HO and FS are supported right now
         if solution == 'StressbalanceSolution':
-            if not (md.flowequation.isSSA or md.flowequation.isMLHO or md.flowequation.isHO or md.flowequation.isFS or md.flowequation.isL1L2):
-                md.checkmessage("'inversion can only be performed for SSA, MLHO, HO or FS ice flow models")
+            if not (md.flowequation.isSSA or md.flowequation.isMOLHO or md.flowequation.isHO or md.flowequation.isFS or md.flowequation.isL1L2):
+                md.checkmessage("'inversion can only be performed for SSA, MOLHO, HO or FS ice flow models")
         if solution == 'BalancethicknessSolution':
             md = checkfield(md, 'fieldname', 'inversion.thickness_obs', 'size', [md.mesh.numberofvertices], 'NaN', 1, 'Inf', 1)

issm/trunk-jpl/src/m/classes/stressbalance.m

@@ -36 +36 @@
                         self.loadingforce=project3d(md,'vector',self.loadingforce,'type','node');
 
-                        % for MLHO
-                        if md.flowequation.isMLHO
+                        % for MOLHO
+                        if md.flowequation.isMOLHO
                                 self.spcvx_base=project3d(md,'vector',self.spcvx_base,'type','node');
                                 self.spcvy_base=project3d(md,'vector',self.spcvy_base,'type','node');
@@ -134 +134 @@
                                 md = checkfield(md,'fieldname','stressbalance.FSreconditioning','>',0);
                         end
-                        % CHECK THIS ONLY WORKS FOR MLHO
-                        if md.flowequation.isMLHO
+                        % CHECK THIS ONLY WORKS FOR MOLHO
+                        if md.flowequation.isMOLHO
                                 md = checkfield(md,'fieldname','stressbalance.spcvx_base','Inf',1,'timeseries',1);
                                 md = checkfield(md,'fieldname','stressbalance.spcvy_base','Inf',1,'timeseries',1);
@@ -169 +169 @@
                         fielddisplay(self,'spcvz','z-axis velocity constraint (NaN means no constraint) [m/yr]');
 
-                        disp(sprintf('\n      %s','MLHO boundary conditions:'));
+                        disp(sprintf('\n      %s','MOLHO boundary conditions:'));
                         fielddisplay(self,'spcvx_base','x-axis basal velocity constraint (NaN means no constraint) [m/yr]');
                         fielddisplay(self,'spcvy_base','y-axis basal velocity constraint (NaN means no constraint) [m/yr]');
@@ -226 +226 @@
                         end
                         WriteData(fid,prefix,'data',outputs,'name','md.stressbalance.requested_outputs','format','StringArray');
-                        % for MLHO
-                        if (md.flowequation.isMLHO)
+                        % for MOLHO
+                        if (md.flowequation.isMOLHO)
                                 WriteData(fid,prefix,'object',self,'class','stressbalance','fieldname','spcvx_base','format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1,'yts',md.constants.yts);
                                 WriteData(fid,prefix,'object',self,'class','stressbalance','fieldname','spcvy_base','format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1,'yts',md.constants.yts);

issm/trunk-jpl/src/m/classes/stressbalance.py

@@ -59 +59 @@
         s += '{}\n'.format(fielddisplay(self, 'spcvz', 'z-axis velocity constraint (NaN means no constraint) [m / yr]'))
         s += '{}\n'.format(fielddisplay(self, 'icefront', 'segments on ice front list (last column 0: Air, 1: Water, 2: Ice'))
-        s += '      MLHO boundary conditions:\n'
+        s += '      MOLHO boundary conditions:\n'
         s += '{}\n'.format(fielddisplay(self, 'spcvx_base', 'x-axis basal velocity constraint (NaN means no constraint) [m / yr]'))
         s += '{}\n'.format(fielddisplay(self, 'spcvy_base', 'y-axis basal velocity constraint (NaN means no constraint) [m / yr]'))
@@ -86 +86 @@
         self.loadingforce = project3d(md, 'vector', self.loadingforce, 'type', 'node')
 
-        if md.flowequation.isMLHO:
+        if md.flowequation.isMOLHO:
             self.spcvx_base = project3d(md, 'vector', self.spcvx_base, 'type', 'node')
             self.spcvy_base = project3d(md, 'vector', self.spcvy_base, 'type', 'node')
@@ -176 +176 @@
             if np.any(np.logical_not(np.isnan(md.stressbalance.referential[pos, :]))):
                 md.checkmessage("no referential should be specified for basal vertices of grounded ice")
-        if md.flowequation.isMLHO:
+        if md.flowequation.isMOLHO:
             md = checkfield(md, 'fieldname', 'stressbalance.spcvx_base', 'Inf', 1, 'timeseries', 1)
             md = checkfield(md, 'fieldname', 'stressbalance.spcvy_base', 'Inf', 1, 'timeseries', 1)
@@ -215 +215 @@
             outputs = outputscopy
         WriteData(fid, prefix, 'data', outputs, 'name', 'md.stressbalance.requested_outputs', 'format', 'StringArray')
-        # MLHO
-        if md.flowequation.isMLHO:
+        # MOLHO
+        if md.flowequation.isMOLHO:
             WriteData(fid, prefix, 'object', self, 'class', 'stressbalance', 'fieldname', 'spcvx_base', 'format', 'DoubleMat', 'mattype', 1, 'scale', 1. / yts, 'timeserieslength', md.mesh.numberofvertices + 1, 'yts', yts)
             WriteData(fid, prefix, 'object', self, 'class', 'stressbalance', 'fieldname', 'spcvy_base', 'format', 'DoubleMat', 'mattype', 1, 'scale', 1. / yts, 'timeserieslength', md.mesh.numberofvertices + 1, 'yts', yts)

issm/trunk-jpl/src/m/parameterization/setflowequation.js

@@ -3 +3 @@
 //
 //   This routine works like plotmodel: it works with an even number of inputs
-//   'SIA','SSA','L1L2','MLHO','HO','FS' and 'fill' are the possible options
+//   'SIA','SSA','L1L2','MOLHO','HO','FS' and 'fill' are the possible options
 //   that must be followed by the corresponding exp file or flags list
 //   It can either be a domain file (argus type, .exp extension), or an array of element flags. 
@@ -11 +11 @@
 //   a string 'all' will be considered as the entire domain
 //   You can specify the type of coupling, 'penalties' or 'tiling', to use with the input 'coupling'
-//   NB: L1L2 and MLHO cannot currently be coupled to any other ice flow model
+//   NB: L1L2 and MOLHO cannot currently be coupled to any other ice flow model
 //
 //   Usage:
@@ -38 +38 @@
         HOflag   = FlagElements(md,options.getfieldvalue('HO',''));
         L1L2flag = FlagElements(md,options.getfieldvalue('L1L2',''));
-        MLHOflag = FlagElements(md,options.getfieldvalue('MLHO',''));
+        MOLHOflag = FlagElements(md,options.getfieldvalue('MOLHO',''));
         FSflag   = FlagElements(md,options.getfieldvalue('FS',''));
         filltype = options.getfieldvalue('fill','none');
@@ -55 +55 @@
 
         //check that each element has at least one flag
-        for(var i=0;i<md.mesh.numberofelements;i++)if((SIAflag[i] + SSAflag[i] + HOflag[i] + L1L2flag[i] + MLHOflag[i] + FSflag[i])==0)
+        for(var i=0;i<md.mesh.numberofelements;i++)if((SIAflag[i] + SSAflag[i] + HOflag[i] + L1L2flag[i] + MOLHOflag[i] + FSflag[i])==0)
         throw Error("elements type not assigned, supported models are 'SIA','SSA','HO' and 'FS'");
 
         //check that each element has only one flag
-        if (ArrayAnyAboveStrict(ArrayXPY(SIAflag,SSAflag,HOflag,L1L2flag,MLHOflag),1)){
+        if (ArrayAnyAboveStrict(ArrayXPY(SIAflag,SSAflag,HOflag,L1L2flag,MOLHOflag),1)){
                 console.log('setflowequation warning message: some elements have several types, higher order type is used for them')
 
@@ -71 +71 @@
         //check that L1L2 is not coupled to any other model for now
         if (ArrayAnyEqual(L1L2flag,1) & ArrayAnyEqual(ArrayOr(SIAflag,SSAflag,HOflag,FSflag),1)) throw Error('L1L2 cannot be coupled to any other model');
-        if (ArrayAnyEqual(MLHOflag,1) & ArrayAnyEqual(ArrayOr(SIAflag,SSAflag,HOflag,FSflag),1)) throw Error('MLHO cannot be coupled to any other model');
+        if (ArrayAnyEqual(MOLHOflag,1) & ArrayAnyEqual(ArrayOr(SIAflag,SSAflag,HOflag,FSflag),1)) throw Error('MOLHO cannot be coupled to any other model');
 
         //Check that no HO or FS for 2d mesh
@@ -100 +100 @@
         for(var i=0;i<pos.length;i++) for(var j=0;j<md.mesh.elements[0].length;j++) nodeonL1L2[md.mesh.elements[pos[i]][j]-1]=1;
 
-        nodeonMLHO=NewArrayFill(md.mesh.numberofvertices,0);
-        pos=ArrayFind(MLHOflag,1);
-        for(var i=0;i<pos.length;i++) for(var j=0;j<md.mesh.elements[0].length;j++) nodeonMLHO[md.mesh.elements[pos[i]][j]-1]=1;
+        nodeonMOLHO=NewArrayFill(md.mesh.numberofvertices,0);
+        pos=ArrayFind(MOLHOflag,1);
+        for(var i=0;i<pos.length;i++) for(var j=0;j<md.mesh.elements[0].length;j++) nodeonMOLHO[md.mesh.elements[pos[i]][j]-1]=1;
 
         nodeonFS=NewArrayFill(md.mesh.numberofvertices,0);
@@ -262 +262 @@
         pos=ArrayFind(SSAflag,1);for(var i=0;i<pos.length;i++)md.flowequation.element_equation[pos[i]]=2;
         pos=ArrayFind(L1L2flag,1);for(var i=0;i<pos.length;i++)md.flowequation.element_equation[pos[i]]=3;
-        pos=ArrayFind(MLHOflag,1);for(var i=0;i<pos.length;i++)md.flowequation.element_equation[pos[i]]=4;
+        pos=ArrayFind(MOLHOflag,1);for(var i=0;i<pos.length;i++)md.flowequation.element_equation[pos[i]]=4;
         pos=ArrayFind(HOflag,1);for(var i=0;i<pos.length;i++)md.flowequation.element_equation[pos[i]]=5;
         pos=ArrayFind(FSflag,1);for(var i=0;i<pos.length;i++)md.flowequation.element_equation[pos[i]]=6;
@@ -281 +281 @@
         pos=ArrayFind(nodeonSSA,1);for(var i=0;i<pos.length;i++)md.flowequation.vertex_equation[pos[i]]=2;
         pos=ArrayFind(nodeonL1L2,1);for(var i=0;i<pos.length;i++)md.flowequation.vertex_equation[pos[i]]=3;
-        pos=ArrayFind(nodeonMLHO,1);for(var i=0;i<pos.length;i++)md.flowequation.vertex_equation[pos[i]]=4;
+        pos=ArrayFind(nodeonMOLHO,1);for(var i=0;i<pos.length;i++)md.flowequation.vertex_equation[pos[i]]=4;
         pos=ArrayFind(nodeonHO,1);for(var i=0;i<pos.length;i++)md.flowequation.vertex_equation[pos[i]]=5;
         pos=ArrayFind(nodeonFS,1);for(var i=0;i<pos.length;i++)md.flowequation.vertex_equation[pos[i]]=6;
@@ -301 +301 @@
         md.flowequation.isSSA  = ArrayAnyEqual(md.flowequation.element_equation,2);
         md.flowequation.isL1L2 = ArrayAnyEqual(md.flowequation.element_equation,3);
-        md.flowequation.isMLHO = ArrayAnyEqual(md.flowequation.element_equation,4);
+        md.flowequation.isMOLHO = ArrayAnyEqual(md.flowequation.element_equation,4);
         md.flowequation.isHO   = ArrayAnyEqual(md.flowequation.element_equation,5);
         md.flowequation.isFS   = ArrayAnyEqual(md.flowequation.element_equation,6);

issm/trunk-jpl/src/m/parameterization/setflowequation.m

@@ -3 +3 @@
 %
 %   This routine works like plotmodel: it works with an even number of inputs
-%   'SIA','SSA','L1L2','MLHO','HO','FS' and 'fill' are the possible options
+%   'SIA','SSA','L1L2','MOLHO','HO','FS' and 'fill' are the possible options
 %   that must be followed by the corresponding exp file or flags list
 %   It can either be a domain file (argus type, .exp extension), or an array of element flags. 
@@ -11 +11 @@
 %   a string 'all' will be considered as the entire domain
 %   You can specify the type of coupling, 'penalties' or 'tiling', to use with the input 'coupling'
-%   NB: L1L2 and MLHO cannot currently be coupled to any other ice flow model
+%   NB: L1L2 and MOLHO cannot currently be coupled to any other ice flow model
 %
 %   Usage:
@@ -39 +39 @@
 HOflag   = FlagElements(md,getfieldvalue(options,'HO',''));
 L1L2flag = FlagElements(md,getfieldvalue(options,'L1L2',''));
-MLHOflag = FlagElements(md,getfieldvalue(options,'MLHO',''));
+MOLHOflag = FlagElements(md,getfieldvalue(options,'MOLHO',''));
 FSflag   = FlagElements(md,getfieldvalue(options,'FS',''));
 filltype = getfieldvalue(options,'fill','none');
@@ -54 +54 @@
 
 %check that each element has at least one flag
-if any(SIAflag+SSAflag+HOflag+L1L2flag+MLHOflag+FSflag==0),
+if any(SIAflag+SSAflag+HOflag+L1L2flag+MOLHOflag+FSflag==0),
         error('elements type not assigned, supported models are ''SIA'',''SSA'',''HO'' and ''FS''')
 end
 
 %check that each element has only one flag
-if any(SIAflag+SSAflag+HOflag+L1L2flag+MLHOflag+FSflag>1),
+if any(SIAflag+SSAflag+HOflag+L1L2flag+MOLHOflag+FSflag>1),
         disp('setflowequation.m: Warning: some elements have several types, higher order type is used for them')
         SIAflag(find(SIAflag & SSAflag))=0;
@@ -70 +70 @@
         error('L1L2 cannot be coupled to any other model');
 end
-if any(MLHOflag) & any(SIAflag | SSAflag | HOflag | FSflag)
-        error('MLHO cannot be coupled to any other model');
+if any(MOLHOflag) & any(SIAflag | SSAflag | HOflag | FSflag)
+        error('MOLHO cannot be coupled to any other model');
 end
 
@@ -91 +91 @@
 nodeonHO=zeros(md.mesh.numberofvertices,1);   nodeonHO(md.mesh.elements(find(HOflag),:))=1;
 nodeonL1L2=zeros(md.mesh.numberofvertices,1); nodeonL1L2(md.mesh.elements(find(L1L2flag),:))=1;
-nodeonMLHO=zeros(md.mesh.numberofvertices,1); nodeonMLHO(md.mesh.elements(find(MLHOflag),:))=1;
+nodeonMOLHO=zeros(md.mesh.numberofvertices,1); nodeonMOLHO(md.mesh.elements(find(MOLHOflag),:))=1;
 nodeonFS=zeros(md.mesh.numberofvertices,1);
 noneflag=zeros(md.mesh.numberofelements,1);
@@ -248 +248 @@
 md.flowequation.element_equation(find(SSAflag))=2;
 md.flowequation.element_equation(find(L1L2flag))=3;
-md.flowequation.element_equation(find(MLHOflag))=4;
+md.flowequation.element_equation(find(MOLHOflag))=4;
 md.flowequation.element_equation(find(HOflag))=5;
 md.flowequation.element_equation(find(FSflag))=6;
@@ -264 +264 @@
 pos=find(nodeonSSA);  md.flowequation.vertex_equation(pos)=2;
 pos=find(nodeonL1L2); md.flowequation.vertex_equation(pos)=3;
-pos=find(nodeonMLHO); md.flowequation.vertex_equation(pos)=4;
+pos=find(nodeonMOLHO); md.flowequation.vertex_equation(pos)=4;
 pos=find(nodeonHO);   md.flowequation.vertex_equation(pos)=5;
 pos=find(nodeonFS);   md.flowequation.vertex_equation(pos)=6;
@@ -287 +287 @@
 md.flowequation.isSSA  = double(any(md.flowequation.element_equation == 2));
 md.flowequation.isL1L2 = double(any(md.flowequation.element_equation == 3));
-md.flowequation.isMLHO = double(any(md.flowequation.element_equation == 4));
+md.flowequation.isMOLHO = double(any(md.flowequation.element_equation == 4));
 md.flowequation.isHO   = double(any(md.flowequation.element_equation == 5));
 md.flowequation.isFS   = double(any(md.flowequation.element_equation == 6));

issm/trunk-jpl/src/m/parameterization/setflowequation.py

@@ -9 +9 @@
 
     This routine works like plotmodel: it works with an even number of inputs
-    'SIA', 'SSA', 'HO', 'L1L2', 'MLHO', 'FS' and 'fill' are the possible 
+    'SIA', 'SSA', 'HO', 'L1L2', 'MOLHO', 'FS' and 'fill' are the possible 
     options that must be followed by the corresponding exp file or flags list. 
     It can either be a domain file (argus type, .exp extension), or an array of 
@@ -45 +45 @@
     HOflag = FlagElements(md, options.getfieldvalue('HO', ''))
     L1L2flag = FlagElements(md, options.getfieldvalue('L1L2', ''))
-    MLHOflag = FlagElements(md, options.getfieldvalue('MLHO', ''))
+    MOLHOflag = FlagElements(md, options.getfieldvalue('MOLHO', ''))
     FSflag = FlagElements(md, options.getfieldvalue('FS', ''))
     filltype = options.getfieldvalue('fill', 'none')
@@ -57 +57 @@
         HOflag = ~SIAflag & ~SSAflag & ~FSflag
     #check that each element has at least one flag
-    if not any(SIAflag + SSAflag + L1L2flag + MLHOflag + HOflag + FSflag):
+    if not any(SIAflag + SSAflag + L1L2flag + MOLHOflag + HOflag + FSflag):
         raise TypeError("elements type not assigned, supported models are 'SIA', 'SSA', 'HO' and 'FS'")
 
     #check that each element has only one flag
-    if any(SIAflag + SSAflag + L1L2flag + MLHOflag + HOflag + FSflag > 1):
+    if any(SIAflag + SSAflag + L1L2flag + MOLHOflag + HOflag + FSflag > 1):
         print('Warning: setflowequation.py: some elements have several types, higher order type is used for them')
         SIAflag[np.where(np.logical_and(SIAflag, SSAflag))] = False
@@ -67 +67 @@
         SSAflag[np.where(np.logical_and(SSAflag, HOflag))] = False
 
-        #check that L1L2 and MLHO is not coupled to any other model for now
+        #check that L1L2 and MOLHO is not coupled to any other model for now
         if any(L1L2flag) and any(SIAflag + SSAflag + HOflag + FSflag):
             raise TypeError('L1L2 cannot be coupled to any other model')
-        if any(MLHOflag) and any(SIAflag + SSAflag + HOflag + FSflag):
-            raise TypeError('MLHO cannot be coupled to any other model')
+        if any(MOLHOflag) and any(SIAflag + SSAflag + HOflag + FSflag):
+            raise TypeError('MOLHO cannot be coupled to any other model')
 
         #Check that no HO or FS for 2d mesh
@@ -89 +89 @@
     nodeonL1L2 = np.zeros(md.mesh.numberofvertices, bool)
     nodeonL1L2[md.mesh.elements[np.where(L1L2flag), :] - 1] = True
-    nodeonMLHO = np.zeros(md.mesh.numberofvertices, bool)
-    nodeonMLHO[md.mesh.elements[np.where(MLHOflag), :] - 1] = True
+    nodeonMOLHO = np.zeros(md.mesh.numberofvertices, bool)
+    nodeonMOLHO[md.mesh.elements[np.where(MOLHOflag), :] - 1] = True
     nodeonHO = np.zeros(md.mesh.numberofvertices, bool)
     nodeonHO[md.mesh.elements[np.where(HOflag), :] - 1] = True
@@ -241 +241 @@
     md.flowequation.element_equation[np.where(SSAflag)] = 2
     md.flowequation.element_equation[np.where(L1L2flag)] = 3
-    md.flowequation.element_equation[np.where(MLHOflag)] = 4
+    md.flowequation.element_equation[np.where(MOLHOflag)] = 4
     md.flowequation.element_equation[np.where(HOflag)] = 5
     md.flowequation.element_equation[np.where(FSflag)] = 6
@@ -259 +259 @@
     pos = np.where(nodeonL1L2)
     md.flowequation.vertex_equation[pos] = 3
-    pos = np.where(nodeonMLHO)
+    pos = np.where(nodeonMOLHO)
     md.flowequation.vertex_equation[pos] = 4
     pos = np.where(nodeonHO)
@@ -283 +283 @@
     md.flowequation.isSSA = any(md.flowequation.element_equation == 2)
     md.flowequation.isL1L2= any(md.flowequation.element_equation == 3)
-    md.flowequation.isMLHO= any(md.flowequation.element_equation == 4)
+    md.flowequation.isMOLHO= any(md.flowequation.element_equation == 4)
     md.flowequation.isHO = any(md.flowequation.element_equation == 5)
     md.flowequation.isFS = any(md.flowequation.element_equation == 6)

issm/trunk-jpl/src/m/plot/plot_elementstype.m

@@ -37 +37 @@
         end
 end
-legend(p,'None','SIA','SSA','L1L2','MLHO','HO',...
+legend(p,'None','SIA','SSA','L1L2','MOLHO','HO',...
                 'SSAHO','FS','SSAFS','HOFS');
 

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

@@ -1 @@
-%Test Name: SquareShelfConstrainedStressMLHO2d
+%Test Name: SquareShelfConstrainedStressMOLHO2d
 md=triangle(model(),'../Exp/Square.exp',50000.);
 md=setmask(md,'all','');
 md=parameterize(md,'../Par/SquareShelfConstrained.par');
-md=setflowequation(md,'MLHO','all');
+md=setflowequation(md,'MOLHO','all');
 md.cluster=generic('name',oshostname(),'np',2);
 
 %output
-%FIXME compute the stress components for MLHO
+%FIXME compute the stress components for MOLHO
 md.stressbalance.requested_outputs={'default','VxSurface','VySurface','VxShear','VyShear','VxBase','VyBase','MassFlux1','MassFlux2','MassFlux3','MassFlux4','MassFlux5','MassFlux6'};
 %md.stressbalance.requested_outputs={'default','DeviatoricStressxx','DeviatoricStressyy','DeviatoricStressxy','MassFlux1','MassFlux2','MassFlux3','MassFlux4','MassFlux5','MassFlux6'};
@@ -18 +18 @@
         massfluxatgate('name','MassFlux6','profilename',['../Exp/MassFlux6.exp'],'definitionstring','Outputdefinition6')...
         };
-md=SetMLHOBC(md);
+md=SetMOLHOBC(md);
 md=solve(md,'Stressbalance');
 

issm/trunk-jpl/test/NightlyRun/test127.py

@@ -1 @@
-#Test Name: SquareShelfConstrainedStressMLHO2d
+#Test Name: SquareShelfConstrainedStressMOLHO2d
 from model import *
 from socket import gethostname
@@ -9 +9 @@
 from massfluxatgate import massfluxatgate
 from generic import generic
-from SetMLHOBC import SetMLHOBC
+from SetMOLHOBC import SetMOLHOBC
 
 md = triangle(model(), '../Exp/Square.exp', 50000)
 md = setmask(md, 'all', '')
 md = parameterize(md, '../Par/SquareShelfConstrained.py')
-md = setflowequation(md, 'MLHO', 'all')
+md = setflowequation(md, 'MOLHO', 'all')
 md.cluster = generic('name', gethostname(), 'np', 2)
 #outputs
-#FIXME compute the stress components for MLHO
+#FIXME compute the stress components for MOLHO
 md.stressbalance.requested_outputs = ['default', 'VxSurface', 'VySurface', 'VxShear', 'VyShear', 'VxBase', 'VyBase', 'MassFlux1', 'MassFlux2', 'MassFlux3', 'MassFlux4', 'MassFlux5', 'MassFlux6']
 #md.stressbalance.requested_outputs = ['default', 'DeviatoricStressxx', 'DeviatoricStressyy', 'DeviatoricStressxy', 'MassFlux1', 'MassFlux2', 'MassFlux3', 'MassFlux4', 'MassFlux5', 'MassFlux6']
@@ -26 +26 @@
                                    massfluxatgate('name', 'MassFlux5', 'profilename', '../Exp/MassFlux5.exp', 'definitionstring', 'Outputdefinition5'),
                                    massfluxatgate('name', 'MassFlux6', 'profilename', '../Exp/MassFlux6.exp', 'definitionstring', 'Outputdefinition6')]
-md = SetMLHOBC(md)
+md = SetMOLHOBC(md)
 md = solve(md, 'Stressbalance')
 

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

@@ -1 @@
-%Test Name: SquareShelfConstrainedTranMLHO2d
+%Test Name: SquareShelfConstrainedTranMOLHO2d
 md=triangle(model(),'../Exp/Square.exp',150000.);
 md=setmask(md,'all','');
 md=parameterize(md,'../Par/SquareShelfConstrained.par');
-md=setflowequation(md,'MLHO','all');
+md=setflowequation(md,'MOLHO','all');
 md.cluster=generic('name',oshostname(),'np',3);
 md.transient.requested_outputs={'IceVolume','VxShear','VyShear','VxBase','VyBase','VxSurface','VySurface'};
 
-md=SetMLHOBC(md);
+md=SetMOLHOBC(md);
 md=solve(md,'Transient');
 

issm/trunk-jpl/test/NightlyRun/test128.py

@@ -1 @@
-#Test Name: SquareShelfConstrainedTranMLHO2d
+#Test Name: SquareShelfConstrainedTranMOLHO2d
 from model import *
-from SetMLHOBC import SetMLHOBC
+from SetMOLHOBC import SetMOLHOBC
 from socket import gethostname
 from triangle import *
@@ -13 +13 @@
 md = setmask(md, 'all', '')
 md = parameterize(md, '../Par/SquareShelfConstrained.py')
-md = setflowequation(md, 'MLHO', 'all')
+md = setflowequation(md, 'MOLHO', 'all')
 md.cluster = generic('name', gethostname(), 'np', 3)
 md.transient.requested_outputs = ['IceVolume','VxSurface','VySurface','VxShear','VyShear','VxBase','VyBase']
 
-md = SetMLHOBC(md)
+md = SetMOLHOBC(md)
 md = solve(md, 'Transient')
 

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

@@ -1 @@
-%Test Name: SquareShelfConstrainedRestartTranMLHO2d
+%Test Name: SquareShelfConstrainedRestartTranMOLHO2d
 md=triangle(model(),'../Exp/Square.exp',150000.);
 md=setmask(md,'all','');
 md=parameterize(md,'../Par/SquareShelfConstrained.par');
-md=setflowequation(md,'MLHO','all');
+md=setflowequation(md,'MOLHO','all');
 md.cluster=generic('name',oshostname(),'np',1);
 md.transient.requested_outputs={'IceVolume','TotalSmb','VxShear','VyShear','VxBase','VyBase','VxSurface','VySurface'};
@@ -14 +14 @@
 md.settings.output_frequency=2;
 
-md=SetMLHOBC(md);
+md=SetMOLHOBC(md);
 md=solve(md,'Transient');
 md2=solve(md,'Transient','restart',1);

issm/trunk-jpl/test/NightlyRun/test129.py

@@ -1 @@
-#Test Name: SquareShelfConstrainedRestartTranMLHO2d
+#Test Name: SquareShelfConstrainedRestartTranMOLHO2d
 from model import *
 from socket import gethostname
-from SetMLHOBC import SetMLHOBC
+from SetMOLHOBC import SetMOLHOBC
 from triangle import *
 from setmask import *
@@ -14 +14 @@
 md = setmask(md, 'all', '')
 md = parameterize(md, '../Par/SquareShelfConstrained.py')
-md = setflowequation(md, 'MLHO', 'all')
+md = setflowequation(md, 'MOLHO', 'all')
 md.cluster = generic('name', gethostname(), 'np', 1)
 md.transient.requested_outputs = ['IceVolume', 'TotalSmb', 'VxShear','VyShear','VxBase','VyBase','VxSurface','VySurface']
@@ -24 +24 @@
 md.timestepping.final_time = 19
 md.settings.output_frequency = 2
-md = SetMLHOBC(md)
+md = SetMOLHOBC(md)
 
 md = solve(md, 'Transient')

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

@@ -1 @@
-%Test Name: SquareShelfStressMLHO2d
+%Test Name: SquareShelfStressMOLHO2d
 md=triangle(model(),'../Exp/Square.exp',150000.);
 md=setmask(md,'all','');
 md=parameterize(md,'../Par/SquareShelf.par');
-md=setflowequation(md,'MLHO','all');
+md=setflowequation(md,'MOLHO','all');
 md.cluster=generic('name',oshostname(),'np',3);
 md.stressbalance.requested_outputs={'default','VxSurface','VySurface','VxShear','VyShear','VxBase','VyBase'};
-md=SetMLHOBC(md);
+md=SetMOLHOBC(md);
 md=solve(md,'Stressbalance');
 

issm/trunk-jpl/test/NightlyRun/test248.py

@@ -1 @@
-#Test Name: SquareShelfStressMLHO2d
+#Test Name: SquareShelfStressMOLHO2d
 from model import *
 from socket import gethostname
@@ -7 +7 @@
 from setflowequation import setflowequation
 from solve import solve
-from SetMLHOBC import SetMLHOBC
+from SetMOLHOBC import SetMOLHOBC
 
 md = triangle(model(), '../Exp/Square.exp', 150000)
 md = setmask(md, 'all', '')
 md = parameterize(md, '../Par/SquareShelf.py')
-md = setflowequation(md, 'MLHO', 'all')
+md = setflowequation(md, 'MOLHO', 'all')
 md.cluster = generic('name', gethostname(), 'np', 3)
 md.stressbalance.requested_outputs = ['default', 'VxSurface', 'VySurface', 'VxShear', 'VyShear', 'VxBase', 'VyBase']
-md = SetMLHOBC(md)
+md = SetMOLHOBC(md)
 md = solve(md, 'Stressbalance')
 

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

@@ -1 @@
-%Test Name: SquareShelfTranMLHO2d
+%Test Name: SquareShelfTranMOLHO2d
 md=triangle(model(),'../Exp/Square.exp',150000.);
 md=setmask(md,'all','');
 md=parameterize(md,'../Par/SquareShelf.par');
-md=setflowequation(md,'MLHO','all');
+md=setflowequation(md,'MOLHO','all');
 md.cluster=generic('name',oshostname(),'np',3);
 md.transient.requested_outputs={'default','FloatingArea','GroundedArea','TotalGroundedBmb','TotalFloatingBmb'};
 md.basalforcings.floatingice_melting_rate(:)=1;
-md=SetMLHOBC(md);
+md=SetMOLHOBC(md);
 md=solve(md,'Transient');
 

issm/trunk-jpl/test/NightlyRun/test249.py

@@ -1 @@
-#Test Name: SquareShelfTranMLHO2d
+#Test Name: SquareShelfTranMOLHO2d
 
 from model import *
@@ -9 +9 @@
 from solve import solve
 from generic import generic
-from SetMLHOBC import SetMLHOBC
+from SetMOLHOBC import SetMOLHOBC
 
 md = triangle(model(), '../Exp/Square.exp', 150000)
@@ -15 +15 @@
 md = parameterize(md, '../Par/SquareShelf.py')
 md.basalforcings.floatingice_melting_rate[:] = 1.
-md = setflowequation(md, 'MLHO', 'all')
+md = setflowequation(md, 'MOLHO', 'all')
 md.cluster = generic('name', gethostname(), 'np', 3)
 md.transient.requested_outputs = ['default', 'FloatingArea', 'GroundedArea', 'TotalFloatingBmb', 'TotalGroundedBmb']
-md = SetMLHOBC(md)
+md = SetMOLHOBC(md)
 md = solve(md, 'Transient')
 

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

@@ -1 @@
-%Test Name: SquareShelfConstrainedMLHO
+%Test Name: SquareShelfConstrainedMOLHO
 md=triangle(model(),'../Exp/Square.exp',150000.);
 md=setmask(md,'all','');
 md=parameterize(md,'../Par/SquareShelf.par');
-md=setflowequation(md,'MLHO','all');
+md=setflowequation(md,'MOLHO','all');
 md.cluster=generic('name',oshostname(),'np',3);
 
@@ -58 +58 @@
 
 md.stressbalance.requested_outputs={'default','VySurface','VyShear','VyBase'};
-md=SetMLHOBC(md);
+md=SetMOLHOBC(md);
 md=solve(md,'Stressbalance');
 

issm/trunk-jpl/test/NightlyRun/test254.py

@@ -1 @@
-#Test Name: SquareShelfConstrainedMLHO
+#Test Name: SquareShelfConstrainedMOLHO
 from model import *
 from socket import gethostname
@@ -9 +9 @@
 from paterson import paterson
 from solve import solve
-from SetMLHOBC import SetMLHOBC
+from SetMOLHOBC import SetMOLHOBC
 from generic import generic
 
@@ -15 +15 @@
 md = setmask(md, 'all', '')
 md = parameterize(md, '../Par/SquareShelf.py')
-md = setflowequation(md, 'MLHO', 'all')
+md = setflowequation(md, 'MOLHO', 'all')
 md.cluster = generic('name', gethostname(), 'np', 3)
 
@@ -71 +71 @@
 
 md.stressbalance.requested_outputs = ['default', 'VySurface', 'VyShear', 'VyBase']
-md = SetMLHOBC(md)
+md = SetMOLHOBC(md)
 md = solve(md, 'Stressbalance')
 

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

@@ -1 @@
-%Test Name: SquareShelfStressMLHO2dTransientIncrHydro
+%Test Name: SquareShelfStressMOLHO2dTransientIncrHydro
 md=triangle(model(),'../Exp/Square.exp',150000.);
 md=setmask(md,'all','');
 md=parameterize(md,'../Par/SquareShelf.par');
-md=setflowequation(md,'MLHO','all');
+md=setflowequation(md,'MOLHO','all');
 md.cluster=generic('name',oshostname(),'np',3);
 md.masstransport.hydrostatic_adjustment='Incremental';
-md=SetMLHOBC(md);
+md=SetMOLHOBC(md);
 md=solve(md,'Transient');
 

issm/trunk-jpl/test/NightlyRun/test255.py

@@ -1 @@
-#Test Name: SquareShelfStressMLHO2dTransientIncrHydro
+#Test Name: SquareShelfStressMOLHO2dTransientIncrHydro
 from model import *
 from socket import gethostname
@@ -7 +7 @@
 from setflowequation import setflowequation
 from solve import solve
-from SetMLHOBC import SetMLHOBC
+from SetMOLHOBC import SetMOLHOBC
 
 md = triangle(model(), '../Exp/Square.exp', 150000.)
 md = setmask(md, 'all', '')
 md = parameterize(md, '../Par/SquareShelf.py')
-md = setflowequation(md, 'MLHO', 'all')
+md = setflowequation(md, 'MOLHO', 'all')
 md.cluster = generic('name', gethostname(), 'np', 3)
 md.masstransport.hydrostatic_adjustment = 'Incremental'
-md = SetMLHOBC(md)
+md = SetMOLHOBC(md)
 md = solve(md, 'Transient')
 

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

@@ -1 @@
-%Test Name: SquareShelfStressMLHO2dTransientIncrNonHydro
+%Test Name: SquareShelfStressMOLHO2dTransientIncrNonHydro
 md=triangle(model(),'../Exp/Square.exp',150000.);
 md=setmask(md,'all','');
 md=parameterize(md,'../Par/SquareShelf.par');
-md=setflowequation(md,'MLHO','all');
+md=setflowequation(md,'MOLHO','all');
 md.geometry.base=md.geometry.base+50.; md.geometry.surface=md.geometry.surface+50.;
 md.cluster=generic('name',oshostname(),'np',1);
 md.masstransport.hydrostatic_adjustment='Incremental';
-md=SetMLHOBC(md);
+md=SetMOLHOBC(md);
 md=solve(md,'Transient');
 

issm/trunk-jpl/test/NightlyRun/test256.py

@@ -1 @@
-#Test Name: SquareShelfStressMLHO2dTransientIncrNonHydro
+#Test Name: SquareShelfStressMOLHO2dTransientIncrNonHydro
 from model import *
 from socket import gethostname
@@ -7 +7 @@
 from setflowequation import setflowequation
 from solve import solve
-from SetMLHOBC import SetMLHOBC
+from SetMOLHOBC import SetMOLHOBC
 
 
@@ -13 +13 @@
 md = setmask(md, 'all', '')
 md = parameterize(md, '../Par/SquareShelf.py')
-md = setflowequation(md, 'MLHO', 'all')
+md = setflowequation(md, 'MOLHO', 'all')
 md.geometry.base = md.geometry.base + 50.
 md.geometry.surface = md.geometry.surface + 50.
 md.cluster = generic('name', gethostname(), 'np', 1)
 md.masstransport.hydrostatic_adjustment = 'Incremental'
-md = SetMLHOBC(md)
+md = SetMOLHOBC(md)
 md = solve(md, 'Transient')
 

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

@@ -1 @@
-%Test Name: SquareSheetConstrainedStressMLHO2d
+%Test Name: SquareSheetConstrainedStressMOLHO2d
 md=triangle(model(),'../Exp/Square.exp',150000.);
 md=setmask(md,'','');
 md=parameterize(md,'../Par/SquareSheetConstrained.par');
-md=setflowequation(md,'MLHO','all');
+md=setflowequation(md,'MOLHO','all');
 md.cluster=generic('name',oshostname(),'np',3);
 md.stressbalance.requested_outputs={'default','VxSurface','VySurface','VxShear','VyShear','VxBase','VyBase'};
-md=SetMLHOBC(md);
+md=SetMOLHOBC(md);
 md=solve(md,'Stressbalance');
 

issm/trunk-jpl/test/NightlyRun/test330.py

@@ -1 @@
-#Test Name: SquareSheetConstrainedStressMLHO2d
+#Test Name: SquareSheetConstrainedStressMOLHO2d
 from model import *
 from socket import gethostname
@@ -7 +7 @@
 from setflowequation import setflowequation
 from solve import solve
-from SetMLHOBC import SetMLHOBC
+from SetMOLHOBC import SetMOLHOBC
 
 
@@ -13 +13 @@
 md = setmask(md, '', '')
 md = parameterize(md, '../Par/SquareSheetConstrained.py')
-md = setflowequation(md, 'MLHO', 'all')
+md = setflowequation(md, 'MOLHO', 'all')
 md.cluster = generic('name', gethostname(), 'np', 3)
 md.stressbalance.requested_outputs = ['default', 'VxSurface', 'VySurface', 'VxShear', 'VyShear', 'VxBase', 'VyBase']
-md = SetMLHOBC(md)
+md = SetMOLHOBC(md)
 md = solve(md, 'Stressbalance')
 

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

@@ -1 @@
-%Test Name: SquareSheetConstrainedTranMLHO2d
+%Test Name: SquareSheetConstrainedTranMOLHO2d
 md=triangle(model(),'../Exp/Square.exp',150000.);
 md=setmask(md,'','');
 md=parameterize(md,'../Par/SquareSheetConstrained.par');
-md=setflowequation(md,'MLHO','all');
+md=setflowequation(md,'MOLHO','all');
 md.cluster=generic('name',oshostname(),'np',3);
-md=SetMLHOBC(md);
+md=SetMOLHOBC(md);
 md=solve(md,'Transient');
 

issm/trunk-jpl/test/NightlyRun/test332.py

@@ -1 @@
-#Test Name: SquareSheetConstrainedTranMLHO2d
+#Test Name: SquareSheetConstrainedTranMOLHO2d
 from model import *
 from socket import gethostname
@@ -7 +7 @@
 from setflowequation import setflowequation
 from solve import solve
-from SetMLHOBC import SetMLHOBC
+from SetMOLHOBC import SetMOLHOBC
 
 md = triangle(model(), '../Exp/Square.exp', 150000.)
 md = setmask(md, '', '')
 md = parameterize(md, '../Par/SquareSheetConstrained.py')
-md = setflowequation(md, 'MLHO', 'all')
+md = setflowequation(md, 'MOLHO', 'all')
 md.cluster = generic('name', gethostname(), 'np', 3)
-md = SetMLHOBC(md)
+md = SetMOLHOBC(md)
 md = solve(md, 'Transient')
 

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

@@ -1 @@
-%Test Name: SquareSheetConstrainedCMDragMLHO
+%Test Name: SquareSheetConstrainedCMDragMOLHO
 md=triangle(model(),'../Exp/Square.exp',200000.);
 md=setmask(md,'','');
 md=parameterize(md,'../Par/SquareSheetConstrained.par');
-md=setflowequation(md,'MLHO','all');
+md=setflowequation(md,'MOLHO','all');
 
 %control parameters
@@ -19 +19 @@
 
 md.cluster=generic('name',oshostname(),'np',3);
-md=SetMLHOBC(md);
+md=SetMOLHOBC(md);
 md=solve(md,'Stressbalance');
 

issm/trunk-jpl/test/NightlyRun/test333.py

@@ -1 @@
-#Test Name: SquareSheetConstrainedCMDragMLHO
+#Test Name: SquareSheetConstrainedCMDragMOLHO
 import numpy as np
 from model import *
@@ -8 +8 @@
 from setflowequation import setflowequation
 from solve import solve
-from SetMLHOBC import SetMLHOBC
+from SetMOLHOBC import SetMOLHOBC
 
 
@@ -14 +14 @@
 md = setmask(md, '', '')
 md = parameterize(md, '../Par/SquareSheetConstrained.py')
-md = setflowequation(md, 'MLHO', 'all')
+md = setflowequation(md, 'MOLHO', 'all')
 
 #control parameters
@@ -33 +33 @@
 
 md.cluster = generic('name', gethostname(), 'np', 3)
-md = SetMLHOBC(md)
+md = SetMOLHOBC(md)
 md = solve(md, 'Stressbalance')
 

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

@@ -1 @@
-%Test Name: SquareShelfCMBMLHO
+%Test Name: SquareShelfCMBMOLHO
 md=triangle(model(),'../Exp/Square.exp',200000.);
 md=setmask(md,'all','');
 md=parameterize(md,'../Par/SquareShelf.par');
-md=setflowequation(md,'MLHO','all');
+md=setflowequation(md,'MOLHO','all');
 
 %control parameters
@@ -20 +20 @@
 
 md.cluster=generic('name',oshostname(),'np',3);
-md=SetMLHOBC(md);
+md=SetMOLHOBC(md);
 md=solve(md,'Stressbalance');
 

issm/trunk-jpl/test/NightlyRun/test334.py

@@ -1 @@
-#Test Name: SquareShelfCMBMLHO
+#Test Name: SquareShelfCMBMOLHO
 from model import *
 from socket import gethostname
@@ -9 +9 @@
 from solve import solve
 from generic import generic
-from SetMLHOBC import SetMLHOBC
+from SetMOLHOBC import SetMOLHOBC
 
 md = triangle(model(), '../Exp/Square.exp', 200000)
 md = setmask(md, 'all', '')
 md = parameterize(md, '../Par/SquareShelf.py')
-md = setflowequation(md, 'MLHO', 'all')
+md = setflowequation(md, 'MOLHO', 'all')
 
 # control parameters
@@ -33 +33 @@
 
 md.cluster = generic('name', gethostname(), 'np', 3)
-md = SetMLHOBC(md)
+md = SetMOLHOBC(md)
 md = solve(md, 'Stressbalance')
 

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

@@ -1 @@
-%Test Name: SquareSheetConstrainedStressMLHO3d
+%Test Name: SquareSheetConstrainedStressMOLHO3d
 md=triangle(model(),'../Exp/Square.exp',200000.);
 md=setmask(md,'','');
 md=parameterize(md,'../Par/SquareSheetConstrained.par');
-md=setflowequation(md,'MLHO','all');
+md=setflowequation(md,'MOLHO','all');
 md = extrude(md, 5, 1);
 md.cluster=generic('name',oshostname(),'np',3);
 md.stressbalance.requested_outputs={'default','VxSurface','VySurface','VxShear','VyShear','VxBase','VyBase'};
-md=SetMLHOBC(md);
+md=SetMOLHOBC(md);
 md=solve(md,'Stressbalance');
 

issm/trunk-jpl/test/NightlyRun/test335.py

@@ -1 @@
-#Test Name: SquareSheetConstrainedStressMLHO2d
+#Test Name: SquareSheetConstrainedStressMOLHO2d
 from model import *
 from socket import gethostname
@@ -7 +7 @@
 from setflowequation import setflowequation
 from solve import solve
-from SetMLHOBC import SetMLHOBC
+from SetMOLHOBC import SetMOLHOBC
 
 
@@ -13 +13 @@
 md = setmask(md, '', '')
 md = parameterize(md, '../Par/SquareSheetConstrained.py')
-md = setflowequation(md, 'MLHO', 'all')
-md = SetMLHOBC(md)
+md = setflowequation(md, 'MOLHO', 'all')
+md = SetMOLHOBC(md)
 md.extrude(5, 1.)
 md.cluster = generic('name', gethostname(), 'np', 3)

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

@@ -1 @@
-%Test Name: SquareSheetShelfStressMLHO2d
+%Test Name: SquareSheetShelfStressMOLHO2d
 md=triangle(model(),'../Exp/Square.exp',150000.);
 md=setmask(md,'../Exp/SquareShelf.exp','');
 md=parameterize(md,'../Par/SquareSheetShelf.par');
-md=setflowequation(md,'MLHO','all');
+md=setflowequation(md,'MOLHO','all');
 md.cluster=generic('name',oshostname(),'np',3);
 md.stressbalance.requested_outputs={'default','VxSurface','VySurface','VxShear','VyShear','VxBase','VyBase'};
-md=SetMLHOBC(md);
+md=SetMOLHOBC(md);
 md=solve(md,'Stressbalance');
 

issm/trunk-jpl/test/NightlyRun/test446.py

@@ -1 @@
-#Test Name: SquareSheetShelfStressMLHO2d
+#Test Name: SquareSheetShelfStressMOLHO2d
 from model import *
 from socket import gethostname
@@ -7 +7 @@
 from setflowequation import setflowequation
 from solve import solve
-from SetMLHOBC import SetMLHOBC
+from SetMOLHOBC import SetMOLHOBC
 
 md = triangle(model(), '../Exp/Square.exp', 150000.)
 md = setmask(md, '../Exp/SquareShelf.exp', '')
 md = parameterize(md, '../Par/SquareSheetShelf.py')
-md = setflowequation(md, 'MLHO', 'all')
+md = setflowequation(md, 'MOLHO', 'all')
 md.cluster = generic('name', gethostname(), 'np', 3)
 md.stressbalance.requested_outputs = ['default', 'VxSurface', 'VySurface', 'VxShear', 'VyShear', 'VxBase', 'VyBase']
-md = SetMLHOBC(md);
+md = SetMOLHOBC(md);
 md = solve(md, 'Stressbalance')
 

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

@@ -1 @@
-%Test Name: SquareSheetShelfTranMLHO2d
+%Test Name: SquareSheetShelfTranMOLHO2d
 md=triangle(model(),'../Exp/Square.exp',150000.);
 md=setmask(md,'../Exp/SquareShelf.exp','');
@@ -13 +13 @@
 md.transient.isthermal=0;
 md.transient.isgroundingline=1;
-md=setflowequation(md,'MLHO','all');
+md=setflowequation(md,'MOLHO','all');
 md.cluster=generic('name',oshostname(),'np',3);
 md.transient.requested_outputs={'default','GroundedArea','FloatingArea','TotalFloatingBmb','TotalGroundedBmb','TotalSmb'};
-md=SetMLHOBC(md);
+md=SetMOLHOBC(md);
 md=solve(md,'Transient');
 

issm/trunk-jpl/test/NightlyRun/test447.py

@@ -1 @@
-#Test Name: SquareSheetShelfTranMLHO2d
+#Test Name: SquareSheetShelfTranMOLHO2d
 import numpy as np
 from model import *
@@ -8 +8 @@
 from setflowequation import setflowequation
 from solve import solve
-from SetMLHOBC import SetMLHOBC
+from SetMOLHOBC import SetMOLHOBC
 from frictioncoulomb import frictioncoulomb
 from generic import generic
@@ -25 +25 @@
 md.transient.isthermal = False
 md.transient.isgroundingline = True
-md = setflowequation(md, 'MLHO', 'all')
+md = setflowequation(md, 'MOLHO', 'all')
 md.cluster = generic('name', gethostname(), 'np', 3)
 md.transient.requested_outputs = ['default', 'GroundedArea', 'FloatingArea', 'TotalFloatingBmb', 'TotalGroundedBmb', 'TotalSmb']
-md = SetMLHOBC(md)
+md = SetMOLHOBC(md)
 md = solve(md, 'Transient')
 

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

@@ -1 @@
-%Test Name: RoundSheetShelfGLMigrationMLHO2d
+%Test Name: RoundSheetShelfGLMigrationMOLHO2d
 radius=1.e6;
 shelfextent=2.e5;
@@ -16 +16 @@
 md=setmask(md,flags,''); 
 md=parameterize(md,'../Par/RoundSheetShelf.par');
-md=setflowequation(md,'MLHO','all');
+md=setflowequation(md,'MOLHO','all');
 md.cluster=generic('name',oshostname(),'np',3);
 
@@ -25 +25 @@
 md.transient.isgroundingline=1;
 
-md=SetMLHOBC(md);
+md=SetMOLHOBC(md);
 %test different grounding line dynamics.
 md.groundingline.migration='AggressiveMigration';

issm/trunk-jpl/test/NightlyRun/test448.py

@@ -1 @@
-#Test Name: RoundSheetShelfGLMigrationMLHO2d
+#Test Name: RoundSheetShelfGLMigrationMOLHO2d
 import numpy as np
 from model import *
@@ -8 +8 @@
 from setflowequation import setflowequation
 from solve import solve
-from SetMLHOBC import SetMLHOBC
+from SetMOLHOBC import SetMOLHOBC
 
 
@@ -28 +28 @@
 md = setmask(md, flags, '')
 md = parameterize(md, '../Par/RoundSheetShelf.py')
-md = setflowequation(md, 'MLHO', 'all')
+md = setflowequation(md, 'MOLHO', 'all')
 md.cluster = generic('name', gethostname(), 'np', 3)
 
@@ -39 +39 @@
 #test different grounding line dynamics.
 md.groundingline.migration = 'AggressiveMigration'
-md = SetMLHOBC(md)
+md = SetMOLHOBC(md)
 md = solve(md, 'Transient')
 element_on_iceshelf_agressive = md.results.TransientSolution[0].MaskOceanLevelset

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

@@ -1 @@
-%Test Name: MISMIP3DMLHO
+%Test Name: MISMIP3DMOLHO
 md=triangle(model(),'../Exp/Square.exp',100000.);
 md=setmask(md,'../Exp/SquareShelf.exp','');
@@ -12 +12 @@
 md.geometry.base(pos)=md.geometry.bed(pos);
 md.geometry.surface=md.geometry.base+md.geometry.thickness;
-md=setflowequation(md,'MLHO','all');
+md=setflowequation(md,'MOLHO','all');
 
 %Boundary conditions:
@@ -45 +45 @@
 
 md.cluster=generic('name',oshostname(),'np',3);
-md=SetMLHOBC(md);
+md=SetMOLHOBC(md);
 md=solve(md,'Transient');
 

issm/trunk-jpl/test/NightlyRun/test449.py

@@ -1 @@
-#Test Name: MISMIP3DMLHO
+#Test Name: MISMIP3DMOLHO
 import numpy as np
 from model import *
@@ -8 +8 @@
 from setflowequation import setflowequation
 from solve import solve
-from SetMLHOBC import SetMLHOBC
+from SetMOLHOBC import SetMOLHOBC
 from generic import generic
 
@@ -24 +24 @@
 md.geometry.base[pos] = md.geometry.bed[pos]
 md.geometry.surface = md.geometry.base + md.geometry.thickness
-md = setflowequation(md, 'MLHO', 'all')
+md = setflowequation(md, 'MOLHO', 'all')
 
 #Boundary conditions:
@@ -59 +59 @@
 
 md.cluster = generic('name', gethostname(), 'np', 3)
-md = SetMLHOBC(md)
+md = SetMOLHOBC(md)
 md = solve(md, 'Transient')
 #print md.results.TransientSolution[0].BasalforcingsFloatingiceMeltingRate

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

@@ -1 @@
-%Test Name: PigStressMLHO2d
+%Test Name: PigStressMOLHO2d
 md=triangle(model(),'../Exp/Pig.exp',20000.);
 md=setmask(md,'../Exp/PigShelves.exp','../Exp/PigIslands.exp');
 md=parameterize(md,'../Par/Pig.par');
-md=setflowequation(md,'MLHO','all');
+md=setflowequation(md,'MOLHO','all');
 md.cluster=generic('name',oshostname(),'np',3);
 md.stressbalance.requested_outputs={'default','VxSurface','VySurface','VxShear','VyShear','VxBase','VyBase'};
-md=SetMLHOBC(md);
+md=SetMOLHOBC(md);
 md=solve(md,'Stressbalance');
 

issm/trunk-jpl/test/NightlyRun/test518.py

@@ -1 +1 @@
 
-#Test Name: PigStressMLHO2d
+#Test Name: PigStressMOLHO2d
 from model import *
 from socket import gethostname
@@ -8 +8 @@
 from setflowequation import setflowequation
 from solve import solve
-from SetMLHOBC import SetMLHOBC
+from SetMOLHOBC import SetMOLHOBC
 
 
@@ -14 +14 @@
 md = setmask(md, '../Exp/PigShelves.exp', '../Exp/PigIslands.exp')
 md = parameterize(md, '../Par/Pig.py')
-md = setflowequation(md, 'MLHO', 'all')
+md = setflowequation(md, 'MOLHO', 'all')
 md.cluster = generic('name', gethostname(), 'np', 3)
 md.stressbalance.requested_outputs = ['default', 'VxSurface', 'VySurface', 'VxShear', 'VyShear', 'VxBase', 'VyBase']
-md = SetMLHOBC(md)
+md = SetMOLHOBC(md)
 md = solve(md, 'Stressbalance')
 

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

@@ -1 @@
-%Test Name: PigTranMLHO2d
+%Test Name: PigTranMOLHO2d
 md=triangle(model(),'../Exp/Pig.exp',20000.);
 md=setmask(md,'../Exp/PigShelves.exp','../Exp/PigIslands.exp');
 md=parameterize(md,'../Par/Pig.par');
-md=setflowequation(md,'MLHO','all');
+md=setflowequation(md,'MOLHO','all');
 md.cluster=generic('name',oshostname(),'np',3);
 md.geometry.bed=md.geometry.base;
@@ -9 +9 @@
 md.mesh.scale_factor=0.9*ones(md.mesh.numberofvertices,1);
 md.transient.requested_outputs={'default','IceVolume','IceVolumeScaled','GroundedArea','GroundedAreaScaled','FloatingArea','FloatingAreaScaled','TotalSmb','TotalSmbScaled','TotalFloatingBmb','TotalFloatingBmbScaled'};
-md=SetMLHOBC(md);
+md=SetMOLHOBC(md);
 md=solve(md,'Transient');
 

issm/trunk-jpl/test/NightlyRun/test519.py

@@ -1 @@
-#Test Name: PigTranMLHO2d
+#Test Name: PigTranMOLHO2d
 import numpy as np
 from model import *
@@ -8 +8 @@
 from setflowequation import setflowequation
 from solve import solve
-from SetMLHOBC import SetMLHOBC
+from SetMOLHOBC import SetMOLHOBC
 from generic import generic
 
@@ -14 +14 @@
 md = setmask(md, '../Exp/PigShelves.exp', '../Exp/PigIslands.exp')
 md = parameterize(md, '../Par/Pig.py')
-md = setflowequation(md, 'MLHO', 'all')
+md = setflowequation(md, 'MOLHO', 'all')
 md.mesh.scale_factor = 0.9 * np.ones((md.mesh.numberofvertices))
 md.transient.requested_outputs = ['default', 'IceVolume', 'IceVolumeScaled', 'GroundedArea', 'GroundedAreaScaled', 'FloatingArea', 'FloatingAreaScaled', 'TotalSmb', 'TotalSmbScaled', 'TotalFloatingBmb', 'TotalFloatingBmbScaled']
 md.cluster = generic('name', gethostname(), 'np', 3)
-md = SetMLHOBC(md)
+md = SetMOLHOBC(md)
 md = solve(md, 'Transient')
 

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

@@ -1 @@
-%Test Name: ValleyGlacierLevelsetMLHO2d
+%Test Name: ValleyGlacierLevelsetMOLHO2d
 md=triangle(model(),'../Exp/Square.exp',50000);
 md=setmask(md,'','');
 md=parameterize(md,'../Par/ValleyGlacierShelf.par');
-md=setflowequation(md,'MLHO','all');
+md=setflowequation(md,'MOLHO','all');
 md.levelset.stabilization=2;
 md.cluster=generic('name',oshostname(),'np',3);
@@ -15 +15 @@
 md.transient.isgroundingline=1;
 
-md=SetMLHOBC(md);
+md=SetMOLHOBC(md);
 md=solve(md,'Transient');
 

issm/trunk-jpl/test/NightlyRun/test810.py

@@ -1 @@
-#Test Name: ValleyGlacierLevelsetMLHO2d
+#Test Name: ValleyGlacierLevelsetMOLHO2d
 from model import *
 from socket import gethostname
@@ -7 +7 @@
 from setflowequation import setflowequation
 from solve import solve
-from SetMLHOBC import SetMLHOBC
+from SetMOLHOBC import SetMOLHOBC
 
 md = triangle(model(), '../Exp/Square.exp', 50000)
@@ -13 +13 @@
 md = parameterize(md, '../Par/ValleyGlacierShelf.py')
 md.levelset.stabilization = 2
-md = setflowequation(md, 'MLHO', 'all')
+md = setflowequation(md, 'MOLHO', 'all')
 md.cluster = generic('name', gethostname(), 'np', 3)
 
@@ -23 +23 @@
 md.transient.isthermal = False
 md.transient.isgroundingline = True
-md = SetMLHOBC(md)
+md = SetMOLHOBC(md)
 
 md = solve(md, 'Transient')

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

@@ -1 @@
-%Test Name: ValleyGlacierLevelsetCalvingMLHO2d
+%Test Name: ValleyGlacierLevelsetCalvingMOLHO2d
 md=triangle(model(),'../Exp/Square.exp',50000);
 md=setmask(md,'','');
 md=parameterize(md,'../Par/ValleyGlacierShelf.par');
-md=setflowequation(md,'MLHO','all');
+md=setflowequation(md,'MOLHO','all');
 md.cluster=generic('name',oshostname(),'np',3);
 
@@ -18 +18 @@
 md.levelset.migration_max = 1e10;
 
-md=SetMLHOBC(md);
+md=SetMOLHOBC(md);
 md=solve(md,'Transient');
 

issm/trunk-jpl/test/NightlyRun/test811.py

@@ -1 @@
-#Test Name: ValleyGlacierLevelsetCalvingMLHO2d
+#Test Name: ValleyGlacierLevelsetCalvingMOLHO2d
 import numpy as np
 from model import *
@@ -8 +8 @@
 from setflowequation import setflowequation
 from solve import solve
-from SetMLHOBC import SetMLHOBC
+from SetMOLHOBC import SetMOLHOBC
 from generic import generic
 
@@ -14 +14 @@
 md = setmask(md, '', '')
 md = parameterize(md, '../Par/ValleyGlacierShelf.py')
-md = setflowequation(md, 'MLHO', 'all')
+md = setflowequation(md, 'MOLHO', 'all')
 md.cluster = generic('name', gethostname(), 'np', 3)
 
@@ -29 +29 @@
 md.levelset.migration_max = 1e10
 
-md = SetMLHOBC(md)
+md = SetMOLHOBC(md)
 md = solve(md, 'Transient')
 

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

@@ -1 @@
-%Test Name: SquareShelfLevelsetCalvingMLHO2dLevermann
+%Test Name: SquareShelfLevelsetCalvingMOLHO2dLevermann
 md=triangle(model(),'../Exp/Square.exp',50000.);
 md=setmask(md,'all','');
 md=parameterize(md,'../Par/SquareShelf.par');
-md=setflowequation(md,'MLHO','all');
+md=setflowequation(md,'MOLHO','all');
 md.cluster=generic('name',oshostname(),'np',3);
 
@@ -35 +35 @@
 md.transient.requested_outputs={'default','StrainRateparallel','StrainRateperpendicular','Calvingratex','Calvingratey','CalvingCalvingrate'};
 
-md=SetMLHOBC(md);
+md=SetMOLHOBC(md);
 md=solve(md,'Transient');
 

issm/trunk-jpl/test/NightlyRun/test812.py

@@ -1 @@
-#Test Name: SquareShelfLevelsetCalvingMLHO2dLevermann
+#Test Name: SquareShelfLevelsetCalvingMOLHO2dLevermann
 import numpy as np
 from socket import gethostname
@@ -8 +8 @@
 from solve import solve
 from triangle import triangle
-from SetMLHOBC import SetMLHOBC
+from SetMOLHOBC import SetMOLHOBC
 
 md = triangle(model(), '../Exp/Square.exp', 50000.)
 md = setmask(md, 'all', '')
 md = parameterize(md, '../Par/SquareShelf.py')
-md = setflowequation(md, 'MLHO', 'all')
+md = setflowequation(md, 'MOLHO', 'all')
 md.cluster = generic('name', gethostname(), 'np', 3)
 
@@ -45 +45 @@
 md.transient.requested_outputs = ['default', 'StrainRateparallel', 'StrainRateperpendicular', 'Calvingratex', 'Calvingratey', 'CalvingCalvingrate']
 
-md = SetMLHOBC(md);
+md = SetMOLHOBC(md);
 md = solve(md, 'Transient')