Index: /issm/trunk-jpl/src/c/analyses/AdjointHorizAnalysis.cpp =================================================================== --- /issm/trunk-jpl/src/c/analyses/AdjointHorizAnalysis.cpp (revision 27030) +++ /issm/trunk-jpl/src/c/analyses/AdjointHorizAnalysis.cpp (revision 27031) @@ -52,8 +52,8 @@ 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,5 +220,5 @@ return Ke; }/*}}}*/ -ElementMatrix* AdjointHorizAnalysis::CreateKMatrixMLHO(Element* element){/*{{{*/ +ElementMatrix* AdjointHorizAnalysis::CreateKMatrixMOLHO(Element* element){/*{{{*/ /* Check if ice in element */ @@ -292,5 +292,5 @@ 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,5 +353,5 @@ return Ke; }/*}}}*/ -ElementMatrix* AdjointHorizAnalysis::CreateKMatrixMLHOVerticalIntergrated(Element* element){/*{{{*/ +ElementMatrix* AdjointHorizAnalysis::CreateKMatrixMOLHOVerticalIntergrated(Element* element){/*{{{*/ /* Check if ice in element */ @@ -433,5 +433,5 @@ /* 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,6 +618,6 @@ case FSApproximationEnum: return CreatePVectorFS(element); - case MLHOApproximationEnum: - return CreatePVectorMLHO(element); + case MOLHOApproximationEnum: + return CreatePVectorMOLHO(element); case NoneApproximationEnum: return NULL; @@ -1105,5 +1105,5 @@ }/*}}}*/ -ElementVector* AdjointHorizAnalysis::CreatePVectorMLHO(Element* element){/*{{{*/ +ElementVector* AdjointHorizAnalysis::CreatePVectorMOLHO(Element* element){/*{{{*/ /*Intermediaries*/ @@ -1143,5 +1143,5 @@ /*Initialize Element vector and vectors*/ - ElementVector* pe = basalelement->NewElementVector(MLHOApproximationEnum); + ElementVector* pe = basalelement->NewElementVector(MOLHOApproximationEnum); IssmDouble* basis = xNew(numnodes); @@ -1212,5 +1212,5 @@ } else { - _error_("2D vertical is not implemented for MLHO"); + _error_("2D vertical is not implemented for MOLHO"); } } @@ -1240,5 +1240,5 @@ } else{ - _error_("2D vertical is not implemented for MLHO"); + _error_("2D vertical is not implemented for MOLHO"); } } @@ -1269,5 +1269,5 @@ } else{ - _error_("2D vertical is not implemented for MLHO"); + _error_("2D vertical is not implemented for MOLHO"); } } @@ -1295,5 +1295,5 @@ } else{ - _error_("2D vertical is not implemented for MLHO"); + _error_("2D vertical is not implemented for MOLHO"); } } @@ -1319,5 +1319,5 @@ } else{ - _error_("2D vertical is not implemented for MLHO"); + _error_("2D vertical is not implemented for MOLHO"); } } @@ -1669,5 +1669,5 @@ 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,5 +1690,5 @@ 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,5 +1700,5 @@ 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,5 +1810,5 @@ this->GradientJBbarSSA(element,gradient,control_interp,control_index); }/*}}}*/ -void AdjointHorizAnalysis::GradientJBbarMLHO(Element* element,Vector* gradient,int control_interp,int control_index){/*{{{*/ +void AdjointHorizAnalysis::GradientJBbarMOLHO(Element* element,Vector* gradient,int control_interp,int control_index){/*{{{*/ if(control_interp!=P1Enum) _error_("not implemented yet..."); @@ -1893,8 +1893,8 @@ 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,5 +2251,5 @@ delete gauss; }/*}}}*/ -void AdjointHorizAnalysis::GradientJBMLHO(Element* element,Vector* gradient,int control_interp,int control_index){/*{{{*/ +void AdjointHorizAnalysis::GradientJBMOLHO(Element* element,Vector* gradient,int control_interp,int control_index){/*{{{*/ _error_("not implemented yet..."); }/*}}}*/ @@ -2651,5 +2651,5 @@ delete friction; }/*}}}*/ -void AdjointHorizAnalysis::GradientJDragMLHO(Element* element,Vector* gradient,int control_interp,int control_index){/*{{{*/ +void AdjointHorizAnalysis::GradientJDragMOLHO(Element* element,Vector* gradient,int control_interp,int control_index){/*{{{*/ /*return if floating (gradient is 0)*/ @@ -3272,6 +3272,6 @@ InputUpdateFromSolutionFS(solution,element); } - else if (approximation==MLHOApproximationEnum) { - InputUpdateFromSolutionMLHO(solution, element); + else if (approximation==MOLHOApproximationEnum) { + InputUpdateFromSolutionMOLHO(solution, element); } else{ @@ -3420,5 +3420,5 @@ xDelete(doflist); }/*}}}*/ -void AdjointHorizAnalysis::InputUpdateFromSolutionMLHO(IssmDouble* solution,Element* element){/*{{{*/ +void AdjointHorizAnalysis::InputUpdateFromSolutionMOLHO(IssmDouble* solution,Element* element){/*{{{*/ int i; int* doflist=NULL; @@ -3433,5 +3433,5 @@ /*Fetch dof list and allocate solution vectors*/ - element->GetDofListLocal(&doflist,MLHOApproximationEnum,GsetEnum); + element->GetDofListLocal(&doflist,MOLHOApproximationEnum,GsetEnum); IssmDouble* values = xNew(numdof); IssmDouble* lambdax = xNew(numnodes); Index: /issm/trunk-jpl/src/c/analyses/AdjointHorizAnalysis.h =================================================================== --- /issm/trunk-jpl/src/c/analyses/AdjointHorizAnalysis.h (revision 27030) +++ /issm/trunk-jpl/src/c/analyses/AdjointHorizAnalysis.h (revision 27031) @@ -28,6 +28,6 @@ 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,5 +36,5 @@ ElementVector* CreatePVectorL1L2(Element* element); ElementVector* CreatePVectorHO(Element* element); - ElementVector* CreatePVectorMLHO(Element* element); + ElementVector* CreatePVectorMOLHO(Element* element); ElementVector* CreatePVectorSSA(Element* element); void GetSolutionFromInputs(Vector* solution,Element* element); @@ -45,10 +45,10 @@ void GradientJBbarL1L2(Element* element,Vector* gradient,int control_interp,int control_index); void GradientJBbarHO(Element* element,Vector* gradient,int control_interp,int control_index); - void GradientJBbarMLHO(Element* element,Vector* gradient,int control_interp,int control_index); + void GradientJBbarMOLHO(Element* element,Vector* gradient,int control_interp,int control_index); void GradientJBbarSSA(Element* element,Vector* gradient,int control_interp,int control_index); void GradientJBFS(Element* element,Vector* gradient,int control_interp,int control_index); void GradientJBGradient(Element* element,Vector* gradient,int control_interp,int control_index); void GradientJBHO(Element* element,Vector* gradient,int control_interp,int control_index); - void GradientJBMLHO(Element* element,Vector* gradient,int control_interp,int control_index); + void GradientJBMOLHO(Element* element,Vector* gradient,int control_interp,int control_index); void GradientJBSSA(Element* element,Vector* gradient,int control_interp,int control_index); void GradientJDragFS(Element* element,Vector* gradient,int control_interp,int control_index); @@ -56,5 +56,5 @@ void GradientJDragL1L2(Element* element,Vector* gradient,int control_interp,int control_index); void GradientJDragHO(Element* element,Vector* gradient,int control_interp,int control_index); - void GradientJDragMLHO(Element* element,Vector* gradient,int control_interp,int control_index); + void GradientJDragMOLHO(Element* element,Vector* gradient,int control_interp,int control_index); void GradientJDragSSA(Element* element,Vector* gradient,int control_interp,int control_index); void GradientJDragHydroFS(Element* element,Vector* gradient,int control_interp,int control_index); @@ -66,5 +66,5 @@ 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); }; Index: /issm/trunk-jpl/src/c/analyses/StressbalanceAnalysis.cpp =================================================================== --- /issm/trunk-jpl/src/c/analyses/StressbalanceAnalysis.cpp (revision 27030) +++ /issm/trunk-jpl/src/c/analyses/StressbalanceAnalysis.cpp (revision 27031) @@ -31,5 +31,5 @@ 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,13 +59,13 @@ 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,5 +78,5 @@ 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,5 +188,5 @@ } else{ - if(!isMLHO){ + if(!isMOLHO){ IoModelToConstraintsx(constraints,iomodel,"md.stressbalance.spcvx",StressbalanceAnalysisEnum,finiteelement,0); if(iomodel->domaintype!=Domain2DverticalEnum){ @@ -194,5 +194,5 @@ } } - 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,5 +462,5 @@ 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,5 +470,5 @@ /*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,5 +477,5 @@ /*Is this SIA only?*/ - if(!isSSA && !isHO && !isFS && !isL1L2 && !isMLHO) return; + if(!isSSA && !isHO && !isFS && !isL1L2 && !isMOLHO) return; /*Initialize counter: */ @@ -522,5 +522,5 @@ /*Intermediary*/ - bool isSSA,isL1L2,isMLHO,isHO,isFS,iscoupling; + bool isSSA,isL1L2,isMOLHO,isHO,isFS,iscoupling; int finiteelement=-1,approximation=-1; @@ -528,13 +528,13 @@ 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,6 +553,6 @@ finiteelement = P1Enum; } - else if(isMLHO){ - approximation = MLHOApproximationEnum; + else if(isMOLHO){ + approximation = MOLHOApproximationEnum; finiteelement = P1Enum; } @@ -630,5 +630,5 @@ break; case L1L2ApproximationEnum: numdofs = 2; break; - case MLHOApproximationEnum: numdofs = 4; break; + case MOLHOApproximationEnum: numdofs = 4; break; case HOApproximationEnum: switch(domaintype){ @@ -695,5 +695,5 @@ 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,5 +703,5 @@ 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,5 +713,5 @@ /*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,5 +720,5 @@ /*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,5 +729,5 @@ 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,9 +781,9 @@ 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,5 +990,5 @@ 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,5 +1093,5 @@ /*Intermediaries*/ - bool isSSA,isL1L2,isMLHO,isHO,isFS; + bool isSSA,isL1L2,isMOLHO,isHO,isFS; bool conserve_loads = true; int newton,domaintype,fe_FS; @@ -1100,5 +1100,5 @@ 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,5 +1107,5 @@ femmodel->parameters->FindParam(&newton,StressbalanceIsnewtonEnum); - if(isFS && !(isSSA || isHO || isL1L2 || isMLHO)){ + if(isFS && !(isSSA || isHO || isL1L2 || isMOLHO)){ femmodel->SetCurrentConfiguration(StressbalanceAnalysisEnum); @@ -1129,5 +1129,5 @@ 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,5 +1143,5 @@ } } - 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,6 +1195,6 @@ case L1L2ApproximationEnum: return CreateKMatrixL1L2(element); - case MLHOApproximationEnum: - return CreateKMatrixMLHO(element); + case MOLHOApproximationEnum: + return CreateKMatrixMOLHO(element); case HOApproximationEnum: return CreateKMatrixHO(element); @@ -1224,6 +1224,6 @@ case L1L2ApproximationEnum: return CreatePVectorL1L2(element); - case MLHOApproximationEnum: - return CreatePVectorMLHO(element); + case MOLHOApproximationEnum: + return CreatePVectorMOLHO(element); case HOApproximationEnum: return CreatePVectorHO(element); @@ -1253,6 +1253,6 @@ GetSolutionFromInputsHoriz(solution,element); return; - case MLHOApproximationEnum: - GetSolutionFromInputsMLHO(solution,element); + case MOLHOApproximationEnum: + GetSolutionFromInputsMOLHO(solution,element); return; case SSAHOApproximationEnum: case HOFSApproximationEnum: case SSAFSApproximationEnum: @@ -1335,6 +1335,6 @@ InputUpdateFromSolutionL1L2(solution,element); return; - case MLHOApproximationEnum: - InputUpdateFromSolutionMLHO(solution,element); + case MOLHOApproximationEnum: + InputUpdateFromSolutionMOLHO(solution,element); return; case SSAHOApproximationEnum: @@ -2760,6 +2760,6 @@ }/*}}}*/ -/*MLHO*/ -ElementMatrix* StressbalanceAnalysis::CreateKMatrixMLHO(Element* element){/*{{{*/ +/*MOLHO*/ +ElementMatrix* StressbalanceAnalysis::CreateKMatrixMOLHO(Element* element){/*{{{*/ /* Check if ice in element */ @@ -2784,6 +2784,6 @@ /*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,5 +2794,5 @@ return Ke; }/*}}}*/ -ElementMatrix* StressbalanceAnalysis::CreateKMatrixMLHOFriction(Element* element){/*{{{*/ +ElementMatrix* StressbalanceAnalysis::CreateKMatrixMOLHOFriction(Element* element){/*{{{*/ if(element->IsAllFloating()) return NULL; @@ -2821,5 +2821,5 @@ /*Initialize Element matrix and vectors*/ - ElementMatrix* Ke = element->NewElementMatrix(MLHOApproximationEnum); + ElementMatrix* Ke = element->NewElementMatrix(MOLHOApproximationEnum); IssmDouble* basis = xNew(numnodes); @@ -2876,5 +2876,5 @@ return Ke; }/*}}}*/ -ElementMatrix* StressbalanceAnalysis::CreateKMatrixMLHOViscous(Element* element){/*{{{*/ +ElementMatrix* StressbalanceAnalysis::CreateKMatrixMOLHOViscous(Element* element){/*{{{*/ /* Check if ice in element */ @@ -2891,5 +2891,5 @@ /*Initialize Element matrix and vectors*/ - ElementMatrix* Ke = element->NewElementMatrix(MLHOApproximationEnum); + ElementMatrix* Ke = element->NewElementMatrix(MOLHOApproximationEnum); IssmDouble* dbasis = xNew(2*numnodes); // like SSA IssmDouble* basis = xNew(numnodes); // like SSA @@ -2915,5 +2915,5 @@ 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;iTransformStiffnessMatrixCoord(Ke,XYMLHOEnum); + //basalelement->TransformStiffnessMatrixCoord(Ke,XYMOLHOEnum); /*Clean up and return*/ @@ -2990,5 +2990,5 @@ return Ke; }/*}}}*/ -ElementVector* StressbalanceAnalysis::CreatePVectorMLHO(Element* element){/*{{{*/ +ElementVector* StressbalanceAnalysis::CreatePVectorMOLHO(Element* element){/*{{{*/ /* Check if ice in element */ @@ -3013,6 +3013,6 @@ /*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,5 +3023,5 @@ return pe; }/*}}}*/ -ElementVector* StressbalanceAnalysis::CreatePVectorMLHODrivingStress(Element* element){/*{{{*/ +ElementVector* StressbalanceAnalysis::CreatePVectorMOLHODrivingStress(Element* element){/*{{{*/ /*Intermediaries */ @@ -3033,5 +3033,5 @@ /*Initialize Element vector and vectors*/ - ElementVector* pe = element->NewElementVector(MLHOApproximationEnum); + ElementVector* pe = element->NewElementVector(MOLHOApproximationEnum); IssmDouble* basis = xNew(numnodes); @@ -3062,5 +3062,5 @@ /*Transform coordinate system*/ - //element->TransformLoadVectorCoord(pe,XYMLHOEnum); + //element->TransformLoadVectorCoord(pe,XYMOLHOEnum); /*Clean up and return*/ @@ -3070,5 +3070,5 @@ return pe; }/*}}}*/ -ElementVector* StressbalanceAnalysis::CreatePVectorMLHOFront(Element* element){/*{{{*/ +ElementVector* StressbalanceAnalysis::CreatePVectorMOLHOFront(Element* element){/*{{{*/ /*If no front, return NULL*/ @@ -3086,5 +3086,5 @@ /*Initialize Element vector and other vectors*/ - ElementVector* pe = element->NewElementVector(MLHOApproximationEnum); + ElementVector* pe = element->NewElementVector(MOLHOApproximationEnum); IssmDouble* basis = xNew(numnodes); @@ -3135,5 +3135,5 @@ /*Transform coordinate system*/ - //element->TransformLoadVectorCoord(pe,XYMLHOEnum); + //element->TransformLoadVectorCoord(pe,XYMOLHOEnum); /*Clean up and return*/ @@ -3144,5 +3144,5 @@ return pe; }/*}}}*/ -void StressbalanceAnalysis::InputUpdateFromSolutionMLHO(IssmDouble* solution,Element* element){/*{{{*/ +void StressbalanceAnalysis::InputUpdateFromSolutionMOLHO(IssmDouble* solution,Element* element){/*{{{*/ int i,dim,domaintype; @@ -3197,5 +3197,5 @@ /*Fetch dof list and allocate solution vectors*/ - basalelement->GetDofListLocal(&doflist,MLHOApproximationEnum,GsetEnum); + basalelement->GetDofListLocal(&doflist,MOLHOApproximationEnum,GsetEnum); IssmDouble* values = xNew(numdof); IssmDouble* vbx = xNew(numnodes); @@ -3220,5 +3220,5 @@ /*Ok, we have vx and vy in values, fill in vx and vy arrays: */ - for(i=0;iGetInputListOnNodes(&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 "<IsSpawnedElement()){basalelement->DeleteMaterials(); delete basalelement;}; }/*}}}*/ -void StressbalanceAnalysis::GetSolutionFromInputsMLHO(Vector* solution,Element* element){/*{{{*/ +void StressbalanceAnalysis::GetSolutionFromInputsMOLHO(Vector* solution,Element* element){/*{{{*/ IssmDouble vbx,vby,vshx,vshy; @@ -3313,5 +3313,5 @@ int numdof = numnodes*dofpernode; element->GetInputValue(&approximation,ApproximationEnum); - if(approximation!=MLHOApproximationEnum) _error_("mesh "<* 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* solution,Element* element); /*HO*/ ElementMatrix* CreateJacobianMatrixHO(Element* element); Index: /issm/trunk-jpl/src/c/analyses/StressbalanceSIAAnalysis.cpp =================================================================== --- /issm/trunk-jpl/src/c/analyses/StressbalanceSIAAnalysis.cpp (revision 27030) +++ /issm/trunk-jpl/src/c/analyses/StressbalanceSIAAnalysis.cpp (revision 27031) @@ -10,5 +10,5 @@ /*Intermediaries*/ - bool isSIA,isSSA,isL1L2,isMLHO,isHO,isFS,iscoupling; + bool isSIA,isSSA,isL1L2,isMOLHO,isHO,isFS,iscoupling; /*Fetch parameters: */ @@ -16,5 +16,5 @@ 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,5 +24,5 @@ /*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 Index: /issm/trunk-jpl/src/c/analyses/StressbalanceVerticalAnalysis.cpp =================================================================== --- /issm/trunk-jpl/src/c/analyses/StressbalanceVerticalAnalysis.cpp (revision 27030) +++ /issm/trunk-jpl/src/c/analyses/StressbalanceVerticalAnalysis.cpp (revision 27031) @@ -12,5 +12,5 @@ /*Intermediary*/ - bool isSIA,isSSA,isL1L2,isMLHO,isHO,isFS,iscoupling; + bool isSIA,isSSA,isL1L2,isMOLHO,isHO,isFS,iscoupling; int Mz,Nz; IssmDouble *spcvz = NULL; @@ -23,10 +23,10 @@ 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 Index: /issm/trunk-jpl/src/c/classes/Elements/Element.cpp =================================================================== --- /issm/trunk-jpl/src/c/classes/Elements/Element.cpp (revision 27030) +++ /issm/trunk-jpl/src/c/classes/Elements/Element.cpp (revision 27031) @@ -1041,5 +1041,5 @@ } /*}}}*/ -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,5 +1051,5 @@ /* 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,6 +4619,6 @@ }/*}}}*/ -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] Index: /issm/trunk-jpl/src/c/classes/Elements/Element.h =================================================================== --- /issm/trunk-jpl/src/c/classes/Elements/Element.h (revision 27030) +++ /issm/trunk-jpl/src/c/classes/Elements/Element.h (revision 27031) @@ -86,5 +86,5 @@ 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,5 +190,5 @@ 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,5 +351,5 @@ virtual void PotentialUngrounding(Vector* 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; Index: /issm/trunk-jpl/src/c/classes/Elements/Penta.cpp =================================================================== --- /issm/trunk-jpl/src/c/classes/Elements/Penta.cpp (revision 27030) +++ /issm/trunk-jpl/src/c/classes/Elements/Penta.cpp (revision 27031) @@ -3282,5 +3282,5 @@ } /*}}}*/ -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 Index: /issm/trunk-jpl/src/c/classes/Elements/Penta.h =================================================================== --- /issm/trunk-jpl/src/c/classes/Elements/Penta.h (revision 27030) +++ /issm/trunk-jpl/src/c/classes/Elements/Penta.h (revision 27031) @@ -170,5 +170,5 @@ void PotentialUngrounding(Vector* 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); Index: /issm/trunk-jpl/src/c/classes/FemModel.cpp =================================================================== --- /issm/trunk-jpl/src/c/classes/FemModel.cpp (revision 27030) +++ /issm/trunk-jpl/src/c/classes/FemModel.cpp (revision 27031) @@ -3219,5 +3219,5 @@ 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")); Index: /issm/trunk-jpl/src/c/classes/Loads/Penpair.cpp =================================================================== --- /issm/trunk-jpl/src/c/classes/Loads/Penpair.cpp (revision 27030) +++ /issm/trunk-jpl/src/c/classes/Loads/Penpair.cpp (revision 27031) @@ -355,7 +355,7 @@ default: _error_("Approximation "<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,5 +795,5 @@ 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,5 +817,5 @@ /* 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] Index: /issm/trunk-jpl/src/c/classes/Materials/Matice.h =================================================================== --- /issm/trunk-jpl/src/c/classes/Materials/Matice.h (revision 27030) +++ /issm/trunk-jpl/src/c/classes/Materials/Matice.h (revision 27031) @@ -78,6 +78,6 @@ 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); Index: /issm/trunk-jpl/src/c/classes/Materials/Matlitho.h =================================================================== --- /issm/trunk-jpl/src/c/classes/Materials/Matlitho.h (revision 27030) +++ /issm/trunk-jpl/src/c/classes/Materials/Matlitho.h (revision 27031) @@ -72,6 +72,6 @@ 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");}; Index: /issm/trunk-jpl/src/c/classes/Node.cpp =================================================================== --- /issm/trunk-jpl/src/c/classes/Node.cpp (revision 27030) +++ /issm/trunk-jpl/src/c/classes/Node.cpp (revision 27031) @@ -118,5 +118,5 @@ this->HardDeactivate(); } - if(in_approximation==MLHOApproximationEnum && !reCast(iomodel->Data("md.mesh.vertexonbase")[io_index])){ + if(in_approximation==MOLHOApproximationEnum && !reCast(iomodel->Data("md.mesh.vertexonbase")[io_index])){ this->HardDeactivate(); } Index: /issm/trunk-jpl/src/c/cores/stressbalance_core.cpp =================================================================== --- /issm/trunk-jpl/src/c/cores/stressbalance_core.cpp (revision 27030) +++ /issm/trunk-jpl/src/c/cores/stressbalance_core.cpp (revision 27031) @@ -19,5 +19,5 @@ 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,5 +31,5 @@ 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,5 +75,5 @@ /*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,5 +82,5 @@ /*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*/ Index: /issm/trunk-jpl/src/c/modules/SurfaceAbsVelMisfitx/SurfaceAbsVelMisfitx.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/SurfaceAbsVelMisfitx/SurfaceAbsVelMisfitx.cpp (revision 27030) +++ /issm/trunk-jpl/src/c/modules/SurfaceAbsVelMisfitx/SurfaceAbsVelMisfitx.cpp (revision 27031) @@ -66,5 +66,5 @@ 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); Index: /issm/trunk-jpl/src/c/modules/SurfaceAverageVelMisfitx/SurfaceAverageVelMisfitx.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/SurfaceAverageVelMisfitx/SurfaceAverageVelMisfitx.cpp (revision 27030) +++ /issm/trunk-jpl/src/c/modules/SurfaceAverageVelMisfitx/SurfaceAverageVelMisfitx.cpp (revision 27031) @@ -74,5 +74,5 @@ 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); Index: /issm/trunk-jpl/src/c/modules/SurfaceLogVelMisfitx/SurfaceLogVelMisfitx.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/SurfaceLogVelMisfitx/SurfaceLogVelMisfitx.cpp (revision 27030) +++ /issm/trunk-jpl/src/c/modules/SurfaceLogVelMisfitx/SurfaceLogVelMisfitx.cpp (revision 27031) @@ -68,5 +68,5 @@ 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); Index: /issm/trunk-jpl/src/c/modules/SurfaceLogVxVyMisfitx/SurfaceLogVxVyMisfitx.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/SurfaceLogVxVyMisfitx/SurfaceLogVxVyMisfitx.cpp (revision 27030) +++ /issm/trunk-jpl/src/c/modules/SurfaceLogVxVyMisfitx/SurfaceLogVxVyMisfitx.cpp (revision 27031) @@ -68,5 +68,5 @@ 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); Index: /issm/trunk-jpl/src/c/modules/SurfaceRelVelMisfitx/SurfaceRelVelMisfitx.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/SurfaceRelVelMisfitx/SurfaceRelVelMisfitx.cpp (revision 27030) +++ /issm/trunk-jpl/src/c/modules/SurfaceRelVelMisfitx/SurfaceRelVelMisfitx.cpp (revision 27031) @@ -68,5 +68,5 @@ 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); Index: /issm/trunk-jpl/src/c/shared/Enum/Enum.vim =================================================================== --- /issm/trunk-jpl/src/c/shared/Enum/Enum.vim (revision 27030) +++ /issm/trunk-jpl/src/c/shared/Enum/Enum.vim (revision 27031) @@ -113,4 +113,5 @@ syn keyword cConstant CalvingMinthicknessEnum syn keyword cConstant CalvingTestSpeedfactorEnum +syn keyword cConstant CalvingTestIndependentRateEnum syn keyword cConstant CalvingUseParamEnum syn keyword cConstant CalvingScaleThetaEnum @@ -175,5 +176,5 @@ 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,4 +659,5 @@ syn keyword cConstant CalvingCalvingrateEnum syn keyword cConstant CalvingHabFractionEnum +syn keyword cConstant CalvingAblationrateEnum syn keyword cConstant CalvingMeltingrateEnum syn keyword cConstant CalvingStressThresholdFloatingiceEnum @@ -1383,5 +1385,5 @@ 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,5 +1624,4 @@ syn keyword cType Cfsurfacesquare syn keyword cType Channel -syn keyword cType classes syn keyword cType Constraint syn keyword cType Constraints @@ -1629,6 +1630,6 @@ 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,6 +1644,6 @@ 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,10 +1652,9 @@ 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,5 +1672,4 @@ syn keyword cType IssmDirectApplicInterface syn keyword cType IssmParallelDirectApplicInterface -syn keyword cType krigingobjects syn keyword cType Load syn keyword cType Loads @@ -1683,5 +1682,4 @@ syn keyword cType Matice syn keyword cType Matlitho -syn keyword cType matrixobjects syn keyword cType MatrixParam syn keyword cType Misfit @@ -1696,6 +1694,6 @@ 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,11 +1709,11 @@ 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,4 +1734,8 @@ 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 Index: /issm/trunk-jpl/src/c/shared/Enum/EnumDefinitions.h =================================================================== --- /issm/trunk-jpl/src/c/shared/Enum/EnumDefinitions.h (revision 27030) +++ /issm/trunk-jpl/src/c/shared/Enum/EnumDefinitions.h (revision 27031) @@ -170,5 +170,5 @@ FlowequationIsHOEnum, FlowequationIsL1L2Enum, - FlowequationIsMLHOEnum, + FlowequationIsMOLHOEnum, FlowequationIsSIAEnum, FlowequationIsSSAEnum, @@ -1384,5 +1384,5 @@ JEnum, L1L2ApproximationEnum, - MLHOApproximationEnum, + MOLHOApproximationEnum, L2ProjectionBaseAnalysisEnum, L2ProjectionEPLAnalysisEnum, Index: /issm/trunk-jpl/src/c/shared/Enum/EnumToStringx.cpp =================================================================== --- /issm/trunk-jpl/src/c/shared/Enum/EnumToStringx.cpp (revision 27030) +++ /issm/trunk-jpl/src/c/shared/Enum/EnumToStringx.cpp (revision 27031) @@ -115,4 +115,5 @@ case CalvingMinthicknessEnum : return "CalvingMinthickness"; case CalvingTestSpeedfactorEnum : return "CalvingTestSpeedfactor"; + case CalvingTestIndependentRateEnum : return "CalvingTestIndependentRate"; case CalvingUseParamEnum : return "CalvingUseParam"; case CalvingScaleThetaEnum : return "CalvingScaleTheta"; @@ -177,5 +178,5 @@ 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,4 +661,5 @@ case CalvingCalvingrateEnum : return "CalvingCalvingrate"; case CalvingHabFractionEnum : return "CalvingHabFraction"; + case CalvingAblationrateEnum : return "CalvingAblationrate"; case CalvingMeltingrateEnum : return "CalvingMeltingrate"; case CalvingStressThresholdFloatingiceEnum : return "CalvingStressThresholdFloatingice"; @@ -1385,5 +1387,5 @@ case JEnum : return "J"; case L1L2ApproximationEnum : return "L1L2Approximation"; - case MLHOApproximationEnum : return "MLHOApproximation"; + case MOLHOApproximationEnum : return "MOLHOApproximation"; case L2ProjectionBaseAnalysisEnum : return "L2ProjectionBaseAnalysis"; case L2ProjectionEPLAnalysisEnum : return "L2ProjectionEPLAnalysis"; Index: /issm/trunk-jpl/src/c/shared/Enum/Enumjl.vim =================================================================== --- /issm/trunk-jpl/src/c/shared/Enum/Enumjl.vim (revision 27030) +++ /issm/trunk-jpl/src/c/shared/Enum/Enumjl.vim (revision 27031) @@ -106,4 +106,5 @@ syn keyword juliaConstC CalvingMinthicknessEnum syn keyword juliaConstC CalvingTestSpeedfactorEnum +syn keyword juliaConstC CalvingTestIndependentRateEnum syn keyword juliaConstC CalvingUseParamEnum syn keyword juliaConstC CalvingScaleThetaEnum @@ -168,5 +169,5 @@ 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,4 +652,5 @@ syn keyword juliaConstC CalvingCalvingrateEnum syn keyword juliaConstC CalvingHabFractionEnum +syn keyword juliaConstC CalvingAblationrateEnum syn keyword juliaConstC CalvingMeltingrateEnum syn keyword juliaConstC CalvingStressThresholdFloatingiceEnum @@ -1376,5 +1378,5 @@ syn keyword juliaConstC JEnum syn keyword juliaConstC L1L2ApproximationEnum -syn keyword juliaConstC MLHOApproximationEnum +syn keyword juliaConstC MOLHOApproximationEnum syn keyword juliaConstC L2ProjectionBaseAnalysisEnum syn keyword juliaConstC L2ProjectionEPLAnalysisEnum Index: /issm/trunk-jpl/src/c/shared/Enum/StringToEnumx.cpp =================================================================== --- /issm/trunk-jpl/src/c/shared/Enum/StringToEnumx.cpp (revision 27030) +++ /issm/trunk-jpl/src/c/shared/Enum/StringToEnumx.cpp (revision 27031) @@ -115,4 +115,5 @@ 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,9 +137,9 @@ 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,5 +181,5 @@ 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,9 +260,9 @@ 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,9 +383,9 @@ 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,9 +506,9 @@ 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,9 +629,9 @@ 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,4 +676,5 @@ 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,10 +752,10 @@ 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,10 +875,10 @@ 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,10 +998,10 @@ 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,10 +1121,10 @@ 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,10 +1244,10 @@ 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,10 +1367,10 @@ 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,5 +1420,5 @@ 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,10 +1490,10 @@ 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,10 +1613,10 @@ 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; Index: /issm/trunk-jpl/src/c/shared/io/Marshalling/IoCodeConversions.cpp =================================================================== --- /issm/trunk-jpl/src/c/shared/io/Marshalling/IoCodeConversions.cpp (revision 27030) +++ /issm/trunk-jpl/src/c/shared/io/Marshalling/IoCodeConversions.cpp (revision 27031) @@ -345,5 +345,5 @@ 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,5 +360,5 @@ case 2: return SSAApproximationEnum; case 3: return L1L2ApproximationEnum; - case 4: return MLHOApproximationEnum; + case 4: return MOLHOApproximationEnum; case 5: return HOApproximationEnum; case 6: return FSApproximationEnum; Index: sm/trunk-jpl/src/m/boundaryconditions/SetMLHOBC.m =================================================================== --- /issm/trunk-jpl/src/m/boundaryconditions/SetMLHOBC.m (revision 27030) +++ (revision ) @@ -1,16 +1,0 @@ -function md=SetMLHOBC(md) -%SETMLHOBC - Create the boundary conditions for stressbalance for MLHO: VxBase, VyBase, VxShear, VyShear -% -% Usage: -% md=SetMLHOBC(md) -% - - -%node on Dirichlet -if md.flowequation.isMLHO - md.stressbalance.spcvx_base=md.stressbalance.spcvx; - md.stressbalance.spcvy_base=md.stressbalance.spcvy; - - md.stressbalance.spcvx_shear=NaN*ones(size(md.stressbalance.spcvx_base)); - md.stressbalance.spcvy_shear=NaN*ones(size(md.stressbalance.spcvy_base)); -end Index: sm/trunk-jpl/src/m/boundaryconditions/SetMLHOBC.py =================================================================== --- /issm/trunk-jpl/src/m/boundaryconditions/SetMLHOBC.py (revision 27030) +++ (revision ) @@ -1,22 +1,0 @@ -import numpy as np - - -def SetMLHOBC(md): - """ - SETMLHOBC - Create the boundary conditions for stressbalance for MLHO: VxBase, VyBase, VxShear, VyShear - - Usage: - md = SetIceShelfBC(md, varargin) - - Example: - md = SetIceShelfBC(md) - - """ - - #node on Dirichlet (boundary and ~icefront) - md.stressbalance.spcvx_base = md.stressbalance.spcvx - md.stressbalance.spcvy_base = md.stressbalance.spcvy - md.stressbalance.spcvx_shear = np.nan * md.stressbalance.spcvx - md.stressbalance.spcvy_shear = np.nan * md.stressbalance.spcvy - - return md Index: /issm/trunk-jpl/src/m/boundaryconditions/SetMOLHOBC.m =================================================================== --- /issm/trunk-jpl/src/m/boundaryconditions/SetMOLHOBC.m (revision 27031) +++ /issm/trunk-jpl/src/m/boundaryconditions/SetMOLHOBC.m (revision 27031) @@ -0,0 +1,16 @@ +function md=SetMOLHOBC(md) +%SETMOLHOBC - Create the boundary conditions for stressbalance for MOLHO: VxBase, VyBase, VxShear, VyShear +% +% Usage: +% md=SetMOLHOBC(md) +% + + +%node on Dirichlet +if md.flowequation.isMOLHO + md.stressbalance.spcvx_base=md.stressbalance.spcvx; + md.stressbalance.spcvy_base=md.stressbalance.spcvy; + + md.stressbalance.spcvx_shear=NaN*ones(size(md.stressbalance.spcvx_base)); + md.stressbalance.spcvy_shear=NaN*ones(size(md.stressbalance.spcvy_base)); +end Index: /issm/trunk-jpl/src/m/boundaryconditions/SetMOLHOBC.py =================================================================== --- /issm/trunk-jpl/src/m/boundaryconditions/SetMOLHOBC.py (revision 27031) +++ /issm/trunk-jpl/src/m/boundaryconditions/SetMOLHOBC.py (revision 27031) @@ -0,0 +1,21 @@ +import numpy as np + +def SetMOLHOBC(md): + """ + SETMOLHOBC - Create the boundary conditions for stressbalance for MOLHO: VxBase, VyBase, VxShear, VyShear + + Usage: + md = SetIceShelfBC(md, varargin) + + Example: + md = SetIceShelfBC(md) + + """ + + #node on Dirichlet (boundary and ~icefront) + md.stressbalance.spcvx_base = md.stressbalance.spcvx + md.stressbalance.spcvy_base = md.stressbalance.spcvy + md.stressbalance.spcvx_shear = np.nan * md.stressbalance.spcvx + md.stressbalance.spcvy_shear = np.nan * md.stressbalance.spcvy + + return md Index: /issm/trunk-jpl/src/m/classes/flowequation.js =================================================================== --- /issm/trunk-jpl/src/m/classes/flowequation.js (revision 27030) +++ /issm/trunk-jpl/src/m/classes/flowequation.js (revision 27031) @@ -22,5 +22,5 @@ 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,11 +41,11 @@ }// }}} - 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,5 +59,5 @@ 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,5 +93,5 @@ 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,5 +108,5 @@ 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,5 +138,5 @@ this.isSSA = 0; this.isL1L2 = 0; - this.isMLHO = 0; + this.isMOLHO = 0; this.isHO = 0; this.isFS = 0; Index: /issm/trunk-jpl/src/m/classes/flowequation.m =================================================================== --- /issm/trunk-jpl/src/m/classes/flowequation.m (revision 27030) +++ /issm/trunk-jpl/src/m/classes/flowequation.m (revision 27031) @@ -9,5 +9,5 @@ isSSA = 0; isL1L2 = 0; - isMLHO = 0; + isMOLHO = 0; isHO = 0; isFS = 0; @@ -60,10 +60,11 @@ 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,5 +105,5 @@ 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,5 +136,5 @@ 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,5 +154,5 @@ 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,5 +173,5 @@ 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,5 +198,5 @@ 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); Index: /issm/trunk-jpl/src/m/classes/flowequation.py =================================================================== --- /issm/trunk-jpl/src/m/classes/flowequation.py (revision 27030) +++ /issm/trunk-jpl/src/m/classes/flowequation.py (revision 27031) @@ -19,5 +19,5 @@ self.isSSA = 0 self.isL1L2 = 0 - self.isMLHO = 0 + self.isMOLHO = 0 self.isHO = 0 self.isFS = 0 @@ -46,5 +46,5 @@ 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,5 +90,5 @@ 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,5 +121,5 @@ 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,5 +134,5 @@ 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') Index: /issm/trunk-jpl/src/m/classes/inversion.m =================================================================== --- /issm/trunk-jpl/src/m/classes/inversion.m (revision 27030) +++ /issm/trunk-jpl/src/m/classes/inversion.m (revision 27031) @@ -104,6 +104,6 @@ %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 Index: /issm/trunk-jpl/src/m/classes/inversion.py =================================================================== --- /issm/trunk-jpl/src/m/classes/inversion.py (revision 27030) +++ /issm/trunk-jpl/src/m/classes/inversion.py (revision 27031) @@ -151,6 +151,6 @@ # 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) Index: /issm/trunk-jpl/src/m/classes/stressbalance.m =================================================================== --- /issm/trunk-jpl/src/m/classes/stressbalance.m (revision 27030) +++ /issm/trunk-jpl/src/m/classes/stressbalance.m (revision 27031) @@ -36,6 +36,6 @@ 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,6 +134,6 @@ 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,5 +169,5 @@ 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,6 +226,6 @@ 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); Index: /issm/trunk-jpl/src/m/classes/stressbalance.py =================================================================== --- /issm/trunk-jpl/src/m/classes/stressbalance.py (revision 27030) +++ /issm/trunk-jpl/src/m/classes/stressbalance.py (revision 27031) @@ -59,5 +59,5 @@ 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,5 +86,5 @@ 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,5 +176,5 @@ 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,6 +215,6 @@ 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) Index: /issm/trunk-jpl/src/m/parameterization/setflowequation.js =================================================================== --- /issm/trunk-jpl/src/m/parameterization/setflowequation.js (revision 27030) +++ /issm/trunk-jpl/src/m/parameterization/setflowequation.js (revision 27031) @@ -3,5 +3,5 @@ // // 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,5 +11,5 @@ // 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,5 +38,5 @@ 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,9 +55,9 @@ //check that each element has at least one flag - for(var i=0;i1), +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,6 +70,6 @@ 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,5 +91,5 @@ 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,5 +248,5 @@ 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,5 +264,5 @@ 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,5 +287,5 @@ 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)); Index: /issm/trunk-jpl/src/m/parameterization/setflowequation.py =================================================================== --- /issm/trunk-jpl/src/m/parameterization/setflowequation.py (revision 27030) +++ /issm/trunk-jpl/src/m/parameterization/setflowequation.py (revision 27031) @@ -9,5 +9,5 @@ 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,5 +45,5 @@ 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,9 +57,9 @@ 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,9 +67,9 @@ 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,6 +89,6 @@ 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,5 +241,5 @@ 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,5 +259,5 @@ 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,5 +283,5 @@ 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) Index: /issm/trunk-jpl/src/m/plot/plot_elementstype.m =================================================================== --- /issm/trunk-jpl/src/m/plot/plot_elementstype.m (revision 27030) +++ /issm/trunk-jpl/src/m/plot/plot_elementstype.m (revision 27031) @@ -37,5 +37,5 @@ end end -legend(p,'None','SIA','SSA','L1L2','MLHO','HO',... +legend(p,'None','SIA','SSA','L1L2','MOLHO','HO',... 'SSAHO','FS','SSAFS','HOFS'); Index: /issm/trunk-jpl/test/NightlyRun/test127.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test127.m (revision 27030) +++ /issm/trunk-jpl/test/NightlyRun/test127.m (revision 27031) @@ -1,11 +1,11 @@ -%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,5 +18,5 @@ massfluxatgate('name','MassFlux6','profilename',['../Exp/MassFlux6.exp'],'definitionstring','Outputdefinition6')... }; -md=SetMLHOBC(md); +md=SetMOLHOBC(md); md=solve(md,'Stressbalance'); Index: /issm/trunk-jpl/test/NightlyRun/test127.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test127.py (revision 27030) +++ /issm/trunk-jpl/test/NightlyRun/test127.py (revision 27031) @@ -1,3 +1,3 @@ -#Test Name: SquareShelfConstrainedStressMLHO2d +#Test Name: SquareShelfConstrainedStressMOLHO2d from model import * from socket import gethostname @@ -9,13 +9,13 @@ 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,5 +26,5 @@ 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') Index: /issm/trunk-jpl/test/NightlyRun/test128.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test128.m (revision 27030) +++ /issm/trunk-jpl/test/NightlyRun/test128.m (revision 27031) @@ -1,11 +1,11 @@ -%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'); Index: /issm/trunk-jpl/test/NightlyRun/test128.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test128.py (revision 27030) +++ /issm/trunk-jpl/test/NightlyRun/test128.py (revision 27031) @@ -1,5 +1,5 @@ -#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,9 +13,9 @@ 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') Index: /issm/trunk-jpl/test/NightlyRun/test129.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test129.m (revision 27030) +++ /issm/trunk-jpl/test/NightlyRun/test129.m (revision 27031) @@ -1,7 +1,7 @@ -%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,5 +14,5 @@ md.settings.output_frequency=2; -md=SetMLHOBC(md); +md=SetMOLHOBC(md); md=solve(md,'Transient'); md2=solve(md,'Transient','restart',1); Index: /issm/trunk-jpl/test/NightlyRun/test129.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test129.py (revision 27030) +++ /issm/trunk-jpl/test/NightlyRun/test129.py (revision 27031) @@ -1,6 +1,6 @@ -#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,5 +14,5 @@ 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,5 +24,5 @@ md.timestepping.final_time = 19 md.settings.output_frequency = 2 -md = SetMLHOBC(md) +md = SetMOLHOBC(md) md = solve(md, 'Transient') Index: /issm/trunk-jpl/test/NightlyRun/test248.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test248.m (revision 27030) +++ /issm/trunk-jpl/test/NightlyRun/test248.m (revision 27031) @@ -1,10 +1,10 @@ -%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'); Index: /issm/trunk-jpl/test/NightlyRun/test248.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test248.py (revision 27030) +++ /issm/trunk-jpl/test/NightlyRun/test248.py (revision 27031) @@ -1,3 +1,3 @@ -#Test Name: SquareShelfStressMLHO2d +#Test Name: SquareShelfStressMOLHO2d from model import * from socket import gethostname @@ -7,13 +7,13 @@ 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') Index: /issm/trunk-jpl/test/NightlyRun/test249.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test249.m (revision 27030) +++ /issm/trunk-jpl/test/NightlyRun/test249.m (revision 27031) @@ -1,11 +1,11 @@ -%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'); Index: /issm/trunk-jpl/test/NightlyRun/test249.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test249.py (revision 27030) +++ /issm/trunk-jpl/test/NightlyRun/test249.py (revision 27031) @@ -1,3 +1,3 @@ -#Test Name: SquareShelfTranMLHO2d +#Test Name: SquareShelfTranMOLHO2d from model import * @@ -9,5 +9,5 @@ from solve import solve from generic import generic -from SetMLHOBC import SetMLHOBC +from SetMOLHOBC import SetMOLHOBC md = triangle(model(), '../Exp/Square.exp', 150000) @@ -15,8 +15,8 @@ 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') Index: /issm/trunk-jpl/test/NightlyRun/test254.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test254.m (revision 27030) +++ /issm/trunk-jpl/test/NightlyRun/test254.m (revision 27031) @@ -1,7 +1,7 @@ -%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,5 +58,5 @@ md.stressbalance.requested_outputs={'default','VySurface','VyShear','VyBase'}; -md=SetMLHOBC(md); +md=SetMOLHOBC(md); md=solve(md,'Stressbalance'); Index: /issm/trunk-jpl/test/NightlyRun/test254.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test254.py (revision 27030) +++ /issm/trunk-jpl/test/NightlyRun/test254.py (revision 27031) @@ -1,3 +1,3 @@ -#Test Name: SquareShelfConstrainedMLHO +#Test Name: SquareShelfConstrainedMOLHO from model import * from socket import gethostname @@ -9,5 +9,5 @@ from paterson import paterson from solve import solve -from SetMLHOBC import SetMLHOBC +from SetMOLHOBC import SetMOLHOBC from generic import generic @@ -15,5 +15,5 @@ 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,5 +71,5 @@ md.stressbalance.requested_outputs = ['default', 'VySurface', 'VyShear', 'VyBase'] -md = SetMLHOBC(md) +md = SetMOLHOBC(md) md = solve(md, 'Stressbalance') Index: /issm/trunk-jpl/test/NightlyRun/test255.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test255.m (revision 27030) +++ /issm/trunk-jpl/test/NightlyRun/test255.m (revision 27031) @@ -1,10 +1,10 @@ -%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'); Index: /issm/trunk-jpl/test/NightlyRun/test255.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test255.py (revision 27030) +++ /issm/trunk-jpl/test/NightlyRun/test255.py (revision 27031) @@ -1,3 +1,3 @@ -#Test Name: SquareShelfStressMLHO2dTransientIncrHydro +#Test Name: SquareShelfStressMOLHO2dTransientIncrHydro from model import * from socket import gethostname @@ -7,13 +7,13 @@ 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') Index: /issm/trunk-jpl/test/NightlyRun/test256.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test256.m (revision 27030) +++ /issm/trunk-jpl/test/NightlyRun/test256.m (revision 27031) @@ -1,11 +1,11 @@ -%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'); Index: /issm/trunk-jpl/test/NightlyRun/test256.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test256.py (revision 27030) +++ /issm/trunk-jpl/test/NightlyRun/test256.py (revision 27031) @@ -1,3 +1,3 @@ -#Test Name: SquareShelfStressMLHO2dTransientIncrNonHydro +#Test Name: SquareShelfStressMOLHO2dTransientIncrNonHydro from model import * from socket import gethostname @@ -7,5 +7,5 @@ from setflowequation import setflowequation from solve import solve -from SetMLHOBC import SetMLHOBC +from SetMOLHOBC import SetMOLHOBC @@ -13,10 +13,10 @@ 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') Index: /issm/trunk-jpl/test/NightlyRun/test330.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test330.m (revision 27030) +++ /issm/trunk-jpl/test/NightlyRun/test330.m (revision 27031) @@ -1,10 +1,10 @@ -%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'); Index: /issm/trunk-jpl/test/NightlyRun/test330.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test330.py (revision 27030) +++ /issm/trunk-jpl/test/NightlyRun/test330.py (revision 27031) @@ -1,3 +1,3 @@ -#Test Name: SquareSheetConstrainedStressMLHO2d +#Test Name: SquareSheetConstrainedStressMOLHO2d from model import * from socket import gethostname @@ -7,5 +7,5 @@ from setflowequation import setflowequation from solve import solve -from SetMLHOBC import SetMLHOBC +from SetMOLHOBC import SetMOLHOBC @@ -13,8 +13,8 @@ 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') Index: /issm/trunk-jpl/test/NightlyRun/test332.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test332.m (revision 27030) +++ /issm/trunk-jpl/test/NightlyRun/test332.m (revision 27031) @@ -1,9 +1,9 @@ -%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'); Index: /issm/trunk-jpl/test/NightlyRun/test332.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test332.py (revision 27030) +++ /issm/trunk-jpl/test/NightlyRun/test332.py (revision 27031) @@ -1,3 +1,3 @@ -#Test Name: SquareSheetConstrainedTranMLHO2d +#Test Name: SquareSheetConstrainedTranMOLHO2d from model import * from socket import gethostname @@ -7,12 +7,12 @@ 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') Index: /issm/trunk-jpl/test/NightlyRun/test333.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test333.m (revision 27030) +++ /issm/trunk-jpl/test/NightlyRun/test333.m (revision 27031) @@ -1,7 +1,7 @@ -%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,5 +19,5 @@ md.cluster=generic('name',oshostname(),'np',3); -md=SetMLHOBC(md); +md=SetMOLHOBC(md); md=solve(md,'Stressbalance'); Index: /issm/trunk-jpl/test/NightlyRun/test333.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test333.py (revision 27030) +++ /issm/trunk-jpl/test/NightlyRun/test333.py (revision 27031) @@ -1,3 +1,3 @@ -#Test Name: SquareSheetConstrainedCMDragMLHO +#Test Name: SquareSheetConstrainedCMDragMOLHO import numpy as np from model import * @@ -8,5 +8,5 @@ from setflowequation import setflowequation from solve import solve -from SetMLHOBC import SetMLHOBC +from SetMOLHOBC import SetMOLHOBC @@ -14,5 +14,5 @@ md = setmask(md, '', '') md = parameterize(md, '../Par/SquareSheetConstrained.py') -md = setflowequation(md, 'MLHO', 'all') +md = setflowequation(md, 'MOLHO', 'all') #control parameters @@ -33,5 +33,5 @@ md.cluster = generic('name', gethostname(), 'np', 3) -md = SetMLHOBC(md) +md = SetMOLHOBC(md) md = solve(md, 'Stressbalance') Index: /issm/trunk-jpl/test/NightlyRun/test334.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test334.m (revision 27030) +++ /issm/trunk-jpl/test/NightlyRun/test334.m (revision 27031) @@ -1,7 +1,7 @@ -%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,5 +20,5 @@ md.cluster=generic('name',oshostname(),'np',3); -md=SetMLHOBC(md); +md=SetMOLHOBC(md); md=solve(md,'Stressbalance'); Index: /issm/trunk-jpl/test/NightlyRun/test334.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test334.py (revision 27030) +++ /issm/trunk-jpl/test/NightlyRun/test334.py (revision 27031) @@ -1,3 +1,3 @@ -#Test Name: SquareShelfCMBMLHO +#Test Name: SquareShelfCMBMOLHO from model import * from socket import gethostname @@ -9,10 +9,10 @@ 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,5 +33,5 @@ md.cluster = generic('name', gethostname(), 'np', 3) -md = SetMLHOBC(md) +md = SetMOLHOBC(md) md = solve(md, 'Stressbalance') Index: /issm/trunk-jpl/test/NightlyRun/test335.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test335.m (revision 27030) +++ /issm/trunk-jpl/test/NightlyRun/test335.m (revision 27031) @@ -1,11 +1,11 @@ -%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'); Index: /issm/trunk-jpl/test/NightlyRun/test335.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test335.py (revision 27030) +++ /issm/trunk-jpl/test/NightlyRun/test335.py (revision 27031) @@ -1,3 +1,3 @@ -#Test Name: SquareSheetConstrainedStressMLHO2d +#Test Name: SquareSheetConstrainedStressMOLHO2d from model import * from socket import gethostname @@ -7,5 +7,5 @@ from setflowequation import setflowequation from solve import solve -from SetMLHOBC import SetMLHOBC +from SetMOLHOBC import SetMOLHOBC @@ -13,6 +13,6 @@ 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) Index: /issm/trunk-jpl/test/NightlyRun/test446.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test446.m (revision 27030) +++ /issm/trunk-jpl/test/NightlyRun/test446.m (revision 27031) @@ -1,10 +1,10 @@ -%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'); Index: /issm/trunk-jpl/test/NightlyRun/test446.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test446.py (revision 27030) +++ /issm/trunk-jpl/test/NightlyRun/test446.py (revision 27031) @@ -1,3 +1,3 @@ -#Test Name: SquareSheetShelfStressMLHO2d +#Test Name: SquareSheetShelfStressMOLHO2d from model import * from socket import gethostname @@ -7,13 +7,13 @@ 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') Index: /issm/trunk-jpl/test/NightlyRun/test447.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test447.m (revision 27030) +++ /issm/trunk-jpl/test/NightlyRun/test447.m (revision 27031) @@ -1,3 +1,3 @@ -%Test Name: SquareSheetShelfTranMLHO2d +%Test Name: SquareSheetShelfTranMOLHO2d md=triangle(model(),'../Exp/Square.exp',150000.); md=setmask(md,'../Exp/SquareShelf.exp',''); @@ -13,8 +13,8 @@ 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'); Index: /issm/trunk-jpl/test/NightlyRun/test447.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test447.py (revision 27030) +++ /issm/trunk-jpl/test/NightlyRun/test447.py (revision 27031) @@ -1,3 +1,3 @@ -#Test Name: SquareSheetShelfTranMLHO2d +#Test Name: SquareSheetShelfTranMOLHO2d import numpy as np from model import * @@ -8,5 +8,5 @@ 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,8 +25,8 @@ 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') Index: /issm/trunk-jpl/test/NightlyRun/test448.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test448.m (revision 27030) +++ /issm/trunk-jpl/test/NightlyRun/test448.m (revision 27031) @@ -1,3 +1,3 @@ -%Test Name: RoundSheetShelfGLMigrationMLHO2d +%Test Name: RoundSheetShelfGLMigrationMOLHO2d radius=1.e6; shelfextent=2.e5; @@ -16,5 +16,5 @@ 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,5 +25,5 @@ md.transient.isgroundingline=1; -md=SetMLHOBC(md); +md=SetMOLHOBC(md); %test different grounding line dynamics. md.groundingline.migration='AggressiveMigration'; Index: /issm/trunk-jpl/test/NightlyRun/test448.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test448.py (revision 27030) +++ /issm/trunk-jpl/test/NightlyRun/test448.py (revision 27031) @@ -1,3 +1,3 @@ -#Test Name: RoundSheetShelfGLMigrationMLHO2d +#Test Name: RoundSheetShelfGLMigrationMOLHO2d import numpy as np from model import * @@ -8,5 +8,5 @@ from setflowequation import setflowequation from solve import solve -from SetMLHOBC import SetMLHOBC +from SetMOLHOBC import SetMOLHOBC @@ -28,5 +28,5 @@ 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,5 +39,5 @@ #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 Index: /issm/trunk-jpl/test/NightlyRun/test449.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test449.m (revision 27030) +++ /issm/trunk-jpl/test/NightlyRun/test449.m (revision 27031) @@ -1,3 +1,3 @@ -%Test Name: MISMIP3DMLHO +%Test Name: MISMIP3DMOLHO md=triangle(model(),'../Exp/Square.exp',100000.); md=setmask(md,'../Exp/SquareShelf.exp',''); @@ -12,5 +12,5 @@ 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,5 +45,5 @@ md.cluster=generic('name',oshostname(),'np',3); -md=SetMLHOBC(md); +md=SetMOLHOBC(md); md=solve(md,'Transient'); Index: /issm/trunk-jpl/test/NightlyRun/test449.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test449.py (revision 27030) +++ /issm/trunk-jpl/test/NightlyRun/test449.py (revision 27031) @@ -1,3 +1,3 @@ -#Test Name: MISMIP3DMLHO +#Test Name: MISMIP3DMOLHO import numpy as np from model import * @@ -8,5 +8,5 @@ from setflowequation import setflowequation from solve import solve -from SetMLHOBC import SetMLHOBC +from SetMOLHOBC import SetMOLHOBC from generic import generic @@ -24,5 +24,5 @@ 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,5 +59,5 @@ md.cluster = generic('name', gethostname(), 'np', 3) -md = SetMLHOBC(md) +md = SetMOLHOBC(md) md = solve(md, 'Transient') #print md.results.TransientSolution[0].BasalforcingsFloatingiceMeltingRate Index: /issm/trunk-jpl/test/NightlyRun/test518.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test518.m (revision 27030) +++ /issm/trunk-jpl/test/NightlyRun/test518.m (revision 27031) @@ -1,10 +1,10 @@ -%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'); Index: /issm/trunk-jpl/test/NightlyRun/test518.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test518.py (revision 27030) +++ /issm/trunk-jpl/test/NightlyRun/test518.py (revision 27031) @@ -1,4 +1,4 @@ -#Test Name: PigStressMLHO2d +#Test Name: PigStressMOLHO2d from model import * from socket import gethostname @@ -8,5 +8,5 @@ from setflowequation import setflowequation from solve import solve -from SetMLHOBC import SetMLHOBC +from SetMOLHOBC import SetMOLHOBC @@ -14,8 +14,8 @@ 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') Index: /issm/trunk-jpl/test/NightlyRun/test519.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test519.m (revision 27030) +++ /issm/trunk-jpl/test/NightlyRun/test519.m (revision 27031) @@ -1,7 +1,7 @@ -%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,5 +9,5 @@ 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'); Index: /issm/trunk-jpl/test/NightlyRun/test519.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test519.py (revision 27030) +++ /issm/trunk-jpl/test/NightlyRun/test519.py (revision 27031) @@ -1,3 +1,3 @@ -#Test Name: PigTranMLHO2d +#Test Name: PigTranMOLHO2d import numpy as np from model import * @@ -8,5 +8,5 @@ from setflowequation import setflowequation from solve import solve -from SetMLHOBC import SetMLHOBC +from SetMOLHOBC import SetMOLHOBC from generic import generic @@ -14,9 +14,9 @@ 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') Index: /issm/trunk-jpl/test/NightlyRun/test810.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test810.m (revision 27030) +++ /issm/trunk-jpl/test/NightlyRun/test810.m (revision 27031) @@ -1,7 +1,7 @@ -%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,5 +15,5 @@ md.transient.isgroundingline=1; -md=SetMLHOBC(md); +md=SetMOLHOBC(md); md=solve(md,'Transient'); Index: /issm/trunk-jpl/test/NightlyRun/test810.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test810.py (revision 27030) +++ /issm/trunk-jpl/test/NightlyRun/test810.py (revision 27031) @@ -1,3 +1,3 @@ -#Test Name: ValleyGlacierLevelsetMLHO2d +#Test Name: ValleyGlacierLevelsetMOLHO2d from model import * from socket import gethostname @@ -7,5 +7,5 @@ from setflowequation import setflowequation from solve import solve -from SetMLHOBC import SetMLHOBC +from SetMOLHOBC import SetMOLHOBC md = triangle(model(), '../Exp/Square.exp', 50000) @@ -13,5 +13,5 @@ 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,5 +23,5 @@ md.transient.isthermal = False md.transient.isgroundingline = True -md = SetMLHOBC(md) +md = SetMOLHOBC(md) md = solve(md, 'Transient') Index: /issm/trunk-jpl/test/NightlyRun/test811.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test811.m (revision 27030) +++ /issm/trunk-jpl/test/NightlyRun/test811.m (revision 27031) @@ -1,7 +1,7 @@ -%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,5 +18,5 @@ md.levelset.migration_max = 1e10; -md=SetMLHOBC(md); +md=SetMOLHOBC(md); md=solve(md,'Transient'); Index: /issm/trunk-jpl/test/NightlyRun/test811.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test811.py (revision 27030) +++ /issm/trunk-jpl/test/NightlyRun/test811.py (revision 27031) @@ -1,3 +1,3 @@ -#Test Name: ValleyGlacierLevelsetCalvingMLHO2d +#Test Name: ValleyGlacierLevelsetCalvingMOLHO2d import numpy as np from model import * @@ -8,5 +8,5 @@ from setflowequation import setflowequation from solve import solve -from SetMLHOBC import SetMLHOBC +from SetMOLHOBC import SetMOLHOBC from generic import generic @@ -14,5 +14,5 @@ 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,5 +29,5 @@ md.levelset.migration_max = 1e10 -md = SetMLHOBC(md) +md = SetMOLHOBC(md) md = solve(md, 'Transient') Index: /issm/trunk-jpl/test/NightlyRun/test812.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test812.m (revision 27030) +++ /issm/trunk-jpl/test/NightlyRun/test812.m (revision 27031) @@ -1,7 +1,7 @@ -%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,5 +35,5 @@ md.transient.requested_outputs={'default','StrainRateparallel','StrainRateperpendicular','Calvingratex','Calvingratey','CalvingCalvingrate'}; -md=SetMLHOBC(md); +md=SetMOLHOBC(md); md=solve(md,'Transient'); Index: /issm/trunk-jpl/test/NightlyRun/test812.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test812.py (revision 27030) +++ /issm/trunk-jpl/test/NightlyRun/test812.py (revision 27031) @@ -1,3 +1,3 @@ -#Test Name: SquareShelfLevelsetCalvingMLHO2dLevermann +#Test Name: SquareShelfLevelsetCalvingMOLHO2dLevermann import numpy as np from socket import gethostname @@ -8,10 +8,10 @@ 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,5 +45,5 @@ md.transient.requested_outputs = ['default', 'StrainRateparallel', 'StrainRateperpendicular', 'Calvingratex', 'Calvingratey', 'CalvingCalvingrate'] -md = SetMLHOBC(md); +md = SetMOLHOBC(md); md = solve(md, 'Transient')