Index: ../trunk-jpl/src/m/boundaryconditions/SetMLHOBC.py =================================================================== --- ../trunk-jpl/src/m/boundaryconditions/SetMLHOBC.py (revision 27030) +++ ../trunk-jpl/src/m/boundaryconditions/SetMLHOBC.py (nonexistent) @@ -1,22 +0,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: ../trunk-jpl/src/m/boundaryconditions/SetMLHOBC.m =================================================================== --- ../trunk-jpl/src/m/boundaryconditions/SetMLHOBC.m (revision 27030) +++ ../trunk-jpl/src/m/boundaryconditions/SetMLHOBC.m (nonexistent) @@ -1,16 +0,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: ../trunk-jpl/src/m/classes/flowequation.m =================================================================== --- ../trunk-jpl/src/m/classes/flowequation.m (revision 27030) +++ ../trunk-jpl/src/m/classes/flowequation.m (revision 27031) @@ -8,7 +8,7 @@ isSIA = 0; isSSA = 0; isL1L2 = 0; - isMLHO = 0; + isMOLHO = 0; isHO = 0; isFS = 0; isNitscheBC = 0; @@ -59,13 +59,14 @@ if isfield(objstruct,'bordermacayeal'),self.borderSSA = objstruct.bordermacayeal; end; 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.']); + %May 31 2022 + if isfield(objstruct,'isMLHO') + self.isMOLHO = objstruct.isMLHO; + end end + end% }}} end methods @@ -103,7 +104,7 @@ md = checkfield(md,'fieldname','flowequation.isSIA','numel',[1],'values',[0 1]); 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]); md = checkfield(md,'fieldname','flowequation.isNitscheBC','numel',[1],'values',[0 1]); @@ -134,7 +135,7 @@ else 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 if ismember('StressbalanceSIAAnalysis',analyses), @@ -152,7 +153,7 @@ fielddisplay(self,'isSIA','is the Shallow Ice Approximation (SIA) used?'); 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?'); fielddisplay(self,'isNitscheBC','is weakly imposed condition used?'); @@ -171,7 +172,7 @@ WriteData(fid,prefix,'object',self,'fieldname','isSIA','format','Boolean'); 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'); WriteData(fid,prefix,'object',self,'fieldname','isNitscheBC','format','Boolean'); @@ -196,7 +197,7 @@ writejsdouble(fid,[modelname '.flowequation.isSIA'],self.isSIA); 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); writejsstring(fid,[modelname '.flowequation.isNitscheBC'],self.isNitscheBC); Index: ../trunk-jpl/src/c/analyses/AdjointHorizAnalysis.cpp =================================================================== --- ../trunk-jpl/src/c/analyses/AdjointHorizAnalysis.cpp (revision 27030) +++ ../trunk-jpl/src/c/analyses/AdjointHorizAnalysis.cpp (revision 27031) @@ -51,10 +51,10 @@ return CreateKMatrixHO(element); 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; default: @@ -219,7 +219,7 @@ xDelete(xyz_list); return Ke; }/*}}}*/ -ElementMatrix* AdjointHorizAnalysis::CreateKMatrixMLHO(Element* element){/*{{{*/ +ElementMatrix* AdjointHorizAnalysis::CreateKMatrixMOLHO(Element* element){/*{{{*/ /* Check if ice in element */ if(!element->IsIceInElement()) return NULL; @@ -291,7 +291,7 @@ vxshear_input->GetInputValue(&vxshear,gauss); 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; @@ -352,7 +352,7 @@ xDelete(basis); return Ke; }/*}}}*/ -ElementMatrix* AdjointHorizAnalysis::CreateKMatrixMLHOVerticalIntergrated(Element* element){/*{{{*/ +ElementMatrix* AdjointHorizAnalysis::CreateKMatrixMOLHOVerticalIntergrated(Element* element){/*{{{*/ /* Check if ice in element */ if(!element->IsIceInElement()) return NULL; @@ -432,7 +432,7 @@ zeta=0.5*(gauss_seg->coord1+1); /* 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] + epsilon[3]*epsilon[3] + epsilon[4]*epsilon[4] + epsilon[0]*epsilon[1]); @@ -617,8 +617,8 @@ return CreatePVectorHO(element); case FSApproximationEnum: return CreatePVectorFS(element); - case MLHOApproximationEnum: - return CreatePVectorMLHO(element); + case MOLHOApproximationEnum: + return CreatePVectorMOLHO(element); case NoneApproximationEnum: return NULL; default: @@ -1104,7 +1104,7 @@ return pe; }/*}}}*/ -ElementVector* AdjointHorizAnalysis::CreatePVectorMLHO(Element* element){/*{{{*/ +ElementVector* AdjointHorizAnalysis::CreatePVectorMOLHO(Element* element){/*{{{*/ /*Intermediaries*/ int domaintype; @@ -1142,7 +1142,7 @@ int numnodes = basalelement->GetNumberOfNodes(); /*Initialize Element vector and vectors*/ - ElementVector* pe = basalelement->NewElementVector(MLHOApproximationEnum); + ElementVector* pe = basalelement->NewElementVector(MOLHOApproximationEnum); IssmDouble* basis = xNew(numnodes); /*Retrieve all inputs and parameters*/ @@ -1211,7 +1211,7 @@ pe->values[i*4+3]+=duy*weight*Jdet*gauss->weight*basis[i]; } else { - _error_("2D vertical is not implemented for MLHO"); + _error_("2D vertical is not implemented for MOLHO"); } } break; @@ -1239,7 +1239,7 @@ pe->values[i*4+3]+=duy*weight*Jdet*gauss->weight*basis[i]; } else{ - _error_("2D vertical is not implemented for MLHO"); + _error_("2D vertical is not implemented for MOLHO"); } } break; @@ -1268,7 +1268,7 @@ pe->values[i*4+3]+=duy*weight*Jdet*gauss->weight*basis[i]; } else{ - _error_("2D vertical is not implemented for MLHO"); + _error_("2D vertical is not implemented for MOLHO"); } } break; @@ -1294,7 +1294,7 @@ pe->values[i*4+3]+=duy*weight*Jdet*gauss->weight*basis[i]; } else{ - _error_("2D vertical is not implemented for MLHO"); + _error_("2D vertical is not implemented for MOLHO"); } } break; @@ -1318,7 +1318,7 @@ pe->values[i*4+3]+=duy*weight*Jdet*gauss->weight*basis[i]; } else{ - _error_("2D vertical is not implemented for MLHO"); + _error_("2D vertical is not implemented for MOLHO"); } } break; @@ -1668,7 +1668,7 @@ case SSAApproximationEnum: GradientJDragSSA(element,gradient,control_interp,control_index); break; 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; default: _error_("approximation " << EnumToStringx(approximation) << " not supported yet"); @@ -1689,7 +1689,7 @@ case SSAApproximationEnum: GradientJBbarSSA(element,gradient,control_interp,control_index); break; 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; default: _error_("approximation " << EnumToStringx(approximation) << " not supported yet"); @@ -1699,7 +1699,7 @@ switch(approximation){ 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; default: _error_("approximation " << EnumToStringx(approximation) << " not supported yet"); @@ -1809,7 +1809,7 @@ /*WARNING: We use SSA as an estimate for now*/ 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..."); /*Intermediaries*/ @@ -1892,10 +1892,10 @@ while(gauss_seg->next()){ 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]; e1[1] = epsilon[2]; @@ -2250,7 +2250,7 @@ xDelete(vertexpidlist); 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..."); }/*}}}*/ void AdjointHorizAnalysis::GradientJBSSA(Element* element,Vector* gradient,int control_interp,int control_index){/*{{{*/ @@ -2650,7 +2650,7 @@ delete gauss; 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)*/ if(element->IsAllFloating()) return; @@ -3271,8 +3271,8 @@ if(approximation==FSApproximationEnum || approximation==NoneApproximationEnum){ InputUpdateFromSolutionFS(solution,element); } - else if (approximation==MLHOApproximationEnum) { - InputUpdateFromSolutionMLHO(solution, element); + else if (approximation==MOLHOApproximationEnum) { + InputUpdateFromSolutionMOLHO(solution, element); } else{ InputUpdateFromSolutionHoriz(solution,element); @@ -3419,7 +3419,7 @@ xDelete(lambday); xDelete(doflist); }/*}}}*/ -void AdjointHorizAnalysis::InputUpdateFromSolutionMLHO(IssmDouble* solution,Element* element){/*{{{*/ +void AdjointHorizAnalysis::InputUpdateFromSolutionMOLHO(IssmDouble* solution,Element* element){/*{{{*/ int i; int* doflist=NULL; @@ -3432,7 +3432,7 @@ int numdof = numnodes * 4; /*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); IssmDouble* lambday = xNew(numnodes); Index: ../trunk-jpl/src/c/analyses/AdjointHorizAnalysis.h =================================================================== --- ../trunk-jpl/src/c/analyses/AdjointHorizAnalysis.h (revision 27030) +++ ../trunk-jpl/src/c/analyses/AdjointHorizAnalysis.h (revision 27031) @@ -27,8 +27,8 @@ ElementMatrix* CreateKMatrix(Element* element); 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); ElementVector* CreatePVector(Element* element); @@ -35,7 +35,7 @@ ElementVector* CreatePVectorFS(Element* element); 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); void GradientJ(Vector* gradient,Element* element,int control_type,int control_interp,int control_index); @@ -44,18 +44,18 @@ void GradientJBinitial(Element* element,Vector* gradient,int control_interp,int control_index); 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); void GradientJDragGradient(Element* element,Vector* gradient,int control_interp,int control_index); 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); void GradientJDragHydroL1L2(Element* element,Vector* gradient,int control_interp,int control_index); @@ -65,7 +65,7 @@ void InputUpdateFromSolution(IssmDouble* solution,Element* element); 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); }; #endif Index: ../trunk-jpl/src/c/analyses/StressbalanceAnalysis.cpp =================================================================== --- ../trunk-jpl/src/c/analyses/StressbalanceAnalysis.cpp (revision 27030) +++ ../trunk-jpl/src/c/analyses/StressbalanceAnalysis.cpp (revision 27031) @@ -30,7 +30,7 @@ IssmDouble g; 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; int My,Ny; @@ -58,15 +58,15 @@ iomodel->FindConstant(&isSIA,"md.flowequation.isSIA"); 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 iscoupling = false; @@ -77,7 +77,7 @@ /*Get finite element type*/ 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"); /*Deduce velocity interpolation from finite element*/ @@ -187,13 +187,13 @@ iomodel->DeleteData(z,"md.mesh.z"); } else{ - if(!isMLHO){ + if(!isMOLHO){ IoModelToConstraintsx(constraints,iomodel,"md.stressbalance.spcvx",StressbalanceAnalysisEnum,finiteelement,0); if(iomodel->domaintype!=Domain2DverticalEnum){ IoModelToConstraintsx(constraints,iomodel,"md.stressbalance.spcvy",StressbalanceAnalysisEnum,finiteelement,1); } } - else{//MLHO + else{//MOLHO IoModelToConstraintsx(constraints,iomodel,"md.stressbalance.spcvx_base",StressbalanceAnalysisEnum,finiteelement,0); IoModelToConstraintsx(constraints,iomodel,"md.stressbalance.spcvx_shear",StressbalanceAnalysisEnum,finiteelement,1); IoModelToConstraintsx(constraints,iomodel,"md.stressbalance.spcvy_base",StressbalanceAnalysisEnum,finiteelement,2); @@ -461,7 +461,7 @@ int i; 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; IssmDouble *penalties = NULL; @@ -469,7 +469,7 @@ /*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"); iomodel->FindConstant(&isHO,"md.flowequation.isHO"); @@ -476,7 +476,7 @@ iomodel->FindConstant(&numrifts,"md.rifts.numrifts"); /*Is this SIA only?*/ - if(!isSSA && !isHO && !isFS && !isL1L2 && !isMLHO) return; + if(!isSSA && !isHO && !isFS && !isL1L2 && !isMOLHO) return; /*Initialize counter: */ count=0; @@ -521,21 +521,21 @@ void StressbalanceAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel,bool isamr){/*{{{*/ /*Intermediary*/ - bool isSSA,isL1L2,isMLHO,isHO,isFS,iscoupling; + bool isSSA,isL1L2,isMOLHO,isHO,isFS,iscoupling; int finiteelement=-1,approximation=-1; /*Fetch parameters: */ 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 iscoupling = false; @@ -552,8 +552,8 @@ approximation = L1L2ApproximationEnum; finiteelement = P1Enum; } - else if(isMLHO){ - approximation = MLHOApproximationEnum; + else if(isMOLHO){ + approximation = MOLHOApproximationEnum; finiteelement = P1Enum; } else if(isHO){ @@ -629,7 +629,7 @@ } break; case L1L2ApproximationEnum: numdofs = 2; break; - case MLHOApproximationEnum: numdofs = 4; break; + case MOLHOApproximationEnum: numdofs = 4; break; case HOApproximationEnum: switch(domaintype){ case Domain3DEnum: numdofs=2; break; @@ -694,7 +694,7 @@ int approximation,frictionlaw; 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; bool ismovingfront; @@ -702,7 +702,7 @@ /*Fetch constants needed: */ 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"); iomodel->FindConstant(&control_analysis,"md.inversion.iscontrol"); @@ -712,7 +712,7 @@ iomodel->FindConstant(&frictionlaw,"md.friction.law"); /*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: */ iomodel->FetchData(1,"md.flowequation.element_equation"); @@ -719,7 +719,7 @@ finiteelement_list=xNewZeroInit(iomodel->numberofelements); /*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 iscoupling = false; @@ -728,7 +728,7 @@ if(!iscoupling){ 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"); for(int i=0;inumberofelements;i++){ @@ -780,11 +780,11 @@ iomodel->FetchDataToInput(inputs,elements,"md.mask.ocean_levelset",MaskOceanLevelsetEnum); 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.); iomodel->FetchDataToInput(inputs,elements,"md.initialization.vy",VyBaseEnum,0.); @@ -989,7 +989,7 @@ parameters->AddObject(iomodel->CopyConstantObject("md.flowequation.isSIA",FlowequationIsSIAEnum)); 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)); parameters->AddObject(iomodel->CopyConstantObject("md.flowequation.fe_FS",FlowequationFeFSEnum)); @@ -1092,7 +1092,7 @@ void StressbalanceAnalysis::Core(FemModel* femmodel){/*{{{*/ /*Intermediaries*/ - bool isSSA,isL1L2,isMLHO,isHO,isFS; + bool isSSA,isL1L2,isMOLHO,isHO,isFS; bool conserve_loads = true; int newton,domaintype,fe_FS; @@ -1099,7 +1099,7 @@ /* recover parameters:*/ 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); femmodel->parameters->FindParam(&fe_FS,FlowequationFeFSEnum); @@ -1106,7 +1106,7 @@ femmodel->parameters->FindParam(&domaintype,DomainTypeEnum); femmodel->parameters->FindParam(&newton,StressbalanceIsnewtonEnum); - if(isFS && !(isSSA || isHO || isL1L2 || isMLHO)){ + if(isFS && !(isSSA || isHO || isL1L2 || isMOLHO)){ femmodel->SetCurrentConfiguration(StressbalanceAnalysisEnum); bool is_schur_cg_solver = false; @@ -1128,7 +1128,7 @@ else 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) solutionsequence_newton(femmodel); @@ -1142,7 +1142,7 @@ extrudefrombase_core(femmodel); } } - 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); } @@ -1194,8 +1194,8 @@ return CreateKMatrixSSA(element); case L1L2ApproximationEnum: return CreateKMatrixL1L2(element); - case MLHOApproximationEnum: - return CreateKMatrixMLHO(element); + case MOLHOApproximationEnum: + return CreateKMatrixMOLHO(element); case HOApproximationEnum: return CreateKMatrixHO(element); case FSApproximationEnum: @@ -1223,8 +1223,8 @@ return CreatePVectorSSA(element); case L1L2ApproximationEnum: return CreatePVectorL1L2(element); - case MLHOApproximationEnum: - return CreatePVectorMLHO(element); + case MOLHOApproximationEnum: + return CreatePVectorMOLHO(element); case HOApproximationEnum: return CreatePVectorHO(element); case FSApproximationEnum: @@ -1252,8 +1252,8 @@ case SSAApproximationEnum: case HOApproximationEnum: case L1L2ApproximationEnum: case SIAApproximationEnum: GetSolutionFromInputsHoriz(solution,element); return; - case MLHOApproximationEnum: - GetSolutionFromInputsMLHO(solution,element); + case MOLHOApproximationEnum: + GetSolutionFromInputsMOLHO(solution,element); return; case SSAHOApproximationEnum: case HOFSApproximationEnum: case SSAFSApproximationEnum: /*the elements around will create the solution*/ @@ -1334,8 +1334,8 @@ case L1L2ApproximationEnum: InputUpdateFromSolutionL1L2(solution,element); return; - case MLHOApproximationEnum: - InputUpdateFromSolutionMLHO(solution,element); + case MOLHOApproximationEnum: + InputUpdateFromSolutionMOLHO(solution,element); return; case SSAHOApproximationEnum: InputUpdateFromSolutionSSAHO(solution,element); @@ -2759,8 +2759,8 @@ if(basalelement->IsSpawnedElement()){basalelement->DeleteMaterials(); delete basalelement;}; }/*}}}*/ -/*MLHO*/ -ElementMatrix* StressbalanceAnalysis::CreateKMatrixMLHO(Element* element){/*{{{*/ +/*MOLHO*/ +ElementMatrix* StressbalanceAnalysis::CreateKMatrixMOLHO(Element* element){/*{{{*/ /* Check if ice in element */ if(!element->IsIceInElement()) return NULL; @@ -2783,8 +2783,8 @@ } /*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); /*clean-up and return*/ @@ -2793,7 +2793,7 @@ delete Ke2; return Ke; }/*}}}*/ -ElementMatrix* StressbalanceAnalysis::CreateKMatrixMLHOFriction(Element* element){/*{{{*/ +ElementMatrix* StressbalanceAnalysis::CreateKMatrixMOLHOFriction(Element* element){/*{{{*/ if(element->IsAllFloating()) return NULL; @@ -2820,7 +2820,7 @@ int numdof = numnodes*dim; /*Initialize Element matrix and vectors*/ - ElementMatrix* Ke = element->NewElementMatrix(MLHOApproximationEnum); + ElementMatrix* Ke = element->NewElementMatrix(MOLHOApproximationEnum); IssmDouble* basis = xNew(numnodes); /*Retrieve all inputs and parameters*/ @@ -2875,7 +2875,7 @@ xDelete(basis); return Ke; }/*}}}*/ -ElementMatrix* StressbalanceAnalysis::CreateKMatrixMLHOViscous(Element* element){/*{{{*/ +ElementMatrix* StressbalanceAnalysis::CreateKMatrixMOLHOViscous(Element* element){/*{{{*/ /* Check if ice in element */ if(!element->IsIceInElement()) return NULL; @@ -2890,7 +2890,7 @@ int numnodes = element->GetNumberOfNodes(); /*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 @@ -2914,7 +2914,7 @@ 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*/ delete gauss; @@ -2989,7 +2989,7 @@ xDelete(basis); return Ke; }/*}}}*/ -ElementVector* StressbalanceAnalysis::CreatePVectorMLHO(Element* element){/*{{{*/ +ElementVector* StressbalanceAnalysis::CreatePVectorMOLHO(Element* element){/*{{{*/ /* Check if ice in element */ if(!element->IsIceInElement()) return NULL; @@ -3012,8 +3012,8 @@ } /*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); /*clean-up and return*/ @@ -3022,7 +3022,7 @@ delete pe2; return pe; }/*}}}*/ -ElementVector* StressbalanceAnalysis::CreatePVectorMLHODrivingStress(Element* element){/*{{{*/ +ElementVector* StressbalanceAnalysis::CreatePVectorMOLHODrivingStress(Element* element){/*{{{*/ /*Intermediaries */ IssmDouble thickness,Jdet,slope[2],n; @@ -3032,7 +3032,7 @@ int numnodes = element->GetNumberOfNodes(); /*Initialize Element vector and vectors*/ - ElementVector* pe = element->NewElementVector(MLHOApproximationEnum); + ElementVector* pe = element->NewElementVector(MOLHOApproximationEnum); IssmDouble* basis = xNew(numnodes); /*Retrieve all inputs and parameters*/ @@ -3061,7 +3061,7 @@ } /*Transform coordinate system*/ - //element->TransformLoadVectorCoord(pe,XYMLHOEnum); + //element->TransformLoadVectorCoord(pe,XYMOLHOEnum); /*Clean up and return*/ xDelete(xyz_list); @@ -3069,7 +3069,7 @@ delete gauss; return pe; }/*}}}*/ -ElementVector* StressbalanceAnalysis::CreatePVectorMLHOFront(Element* element){/*{{{*/ +ElementVector* StressbalanceAnalysis::CreatePVectorMOLHOFront(Element* element){/*{{{*/ /*If no front, return NULL*/ if(!element->IsIcefront()) return NULL; @@ -3085,7 +3085,7 @@ int numnodes = element->GetNumberOfNodes(); /*Initialize Element vector and other vectors*/ - ElementVector* pe = element->NewElementVector(MLHOApproximationEnum); + ElementVector* pe = element->NewElementVector(MOLHOApproximationEnum); IssmDouble* basis = xNew(numnodes); /*Retrieve all inputs and parameters*/ @@ -3134,7 +3134,7 @@ } /*Transform coordinate system*/ - //element->TransformLoadVectorCoord(pe,XYMLHOEnum); + //element->TransformLoadVectorCoord(pe,XYMOLHOEnum); /*Clean up and return*/ xDelete(xyz_list); @@ -3143,7 +3143,7 @@ delete gauss; return pe; }/*}}}*/ -void StressbalanceAnalysis::InputUpdateFromSolutionMLHO(IssmDouble* solution,Element* element){/*{{{*/ +void StressbalanceAnalysis::InputUpdateFromSolutionMOLHO(IssmDouble* solution,Element* element){/*{{{*/ int i,dim,domaintype; IssmDouble rho_ice,g; @@ -3196,7 +3196,7 @@ int numdof = numnodes*dim*2; //2xdim DOFs per node /*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); IssmDouble* vby = xNew(numnodes); @@ -3219,7 +3219,7 @@ if(dim==2) basalelement->TransformSolutionCoord(&values[0],XYEnum); /*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 "<(doflist); if(basalelement->IsSpawnedElement()){basalelement->DeleteMaterials(); delete basalelement;}; }/*}}}*/ -void StressbalanceAnalysis::GetSolutionFromInputsMLHO(Vector* solution,Element* element){/*{{{*/ +void StressbalanceAnalysis::GetSolutionFromInputsMOLHO(Vector* solution,Element* element){/*{{{*/ IssmDouble vbx,vby,vshx,vshy; int domaintype,dim,approximation,dofpernode; @@ -3312,7 +3312,7 @@ int numnodes = element->GetNumberOfNodes(); int numdof = numnodes*dofpernode; element->GetInputValue(&approximation,ApproximationEnum); - if(approximation!=MLHOApproximationEnum) _error_("mesh "<GetDofList(&doflist,approximation,GsetEnum); Index: ../trunk-jpl/src/c/analyses/StressbalanceAnalysis.h =================================================================== --- ../trunk-jpl/src/c/analyses/StressbalanceAnalysis.h (revision 27030) +++ ../trunk-jpl/src/c/analyses/StressbalanceAnalysis.h (revision 27031) @@ -56,15 +56,15 @@ ElementVector* CreatePVectorL1L2Front(Element* element); ElementVector* CreatePVectorL1L2DrivingStress(Element* element); void InputUpdateFromSolutionL1L2(IssmDouble* solution,Element* element); - /*MLHO*/ - ElementMatrix* CreateKMatrixMLHO(Element* element); - ElementMatrix* CreateKMatrixMLHOFriction(Element* element); - ElementMatrix* CreateKMatrixMLHOViscous(Element* element); - ElementVector* CreatePVectorMLHO(Element* element); - ElementVector* CreatePVectorMLHOFront(Element* element); - ElementVector* CreatePVectorMLHODrivingStress(Element* element); - void InputUpdateFromSolutionMLHO(IssmDouble* solution,Element* element); - void GetSolutionFromInputsMLHO(Vector* 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); ElementMatrix* CreateKMatrixHO(Element* element); Index: ../trunk-jpl/src/c/analyses/StressbalanceSIAAnalysis.cpp =================================================================== --- ../trunk-jpl/src/c/analyses/StressbalanceSIAAnalysis.cpp (revision 27030) +++ ../trunk-jpl/src/c/analyses/StressbalanceSIAAnalysis.cpp (revision 27031) @@ -9,13 +9,13 @@ void StressbalanceSIAAnalysis::CreateConstraints(Constraints* constraints,IoModel* iomodel){/*{{{*/ /*Intermediaries*/ - bool isSIA,isSSA,isL1L2,isMLHO,isHO,isFS,iscoupling; + bool isSIA,isSSA,isL1L2,isMOLHO,isHO,isFS,iscoupling; /*Fetch parameters: */ iomodel->FindConstant(&isSIA,"md.flowequation.isSIA"); 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"); @@ -23,7 +23,7 @@ if (!isSIA) 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 iscoupling = false; Index: ../trunk-jpl/src/c/analyses/StressbalanceVerticalAnalysis.cpp =================================================================== --- ../trunk-jpl/src/c/analyses/StressbalanceVerticalAnalysis.cpp (revision 27030) +++ ../trunk-jpl/src/c/analyses/StressbalanceVerticalAnalysis.cpp (revision 27031) @@ -11,7 +11,7 @@ void StressbalanceVerticalAnalysis::CreateConstraints(Constraints* constraints,IoModel* iomodel){/*{{{*/ /*Intermediary*/ - bool isSIA,isSSA,isL1L2,isMLHO,isHO,isFS,iscoupling; + bool isSIA,isSSA,isL1L2,isMOLHO,isHO,isFS,iscoupling; int Mz,Nz; IssmDouble *spcvz = NULL; @@ -22,12 +22,12 @@ iomodel->FindConstant(&isSIA,"md.flowequation.isSIA"); 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 iscoupling = false; Index: ../trunk-jpl/src/c/classes/Elements/Element.cpp =================================================================== --- ../trunk-jpl/src/c/classes/Elements/Element.cpp (revision 27030) +++ ../trunk-jpl/src/c/classes/Elements/Element.cpp (revision 27031) @@ -1040,7 +1040,7 @@ } /*}}}*/ -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*/ int materialstype; @@ -1050,7 +1050,7 @@ IssmDouble eps0=1.e-27; /* 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] + epsilon[3]*epsilon[3] + epsilon[4]*epsilon[4] + epsilon[0]*epsilon[1] + eps0*eps0); @@ -4618,8 +4618,8 @@ epsilon[1] = 0.5*dvx[1]; }/*}}}*/ -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: ../trunk-jpl/src/c/classes/Elements/Element.h =================================================================== --- ../trunk-jpl/src/c/classes/Elements/Element.h (revision 27030) +++ ../trunk-jpl/src/c/classes/Elements/Element.h (revision 27031) @@ -85,7 +85,7 @@ void dViscositydBFS(IssmDouble* pdmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input); 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(); void FindParam(bool* pvalue,int paramenum); @@ -189,7 +189,7 @@ void StrainRateFS(IssmDouble* epsilon,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input); 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); void StressMaxPrincipalCreateInput(void); @@ -350,7 +350,7 @@ virtual int NumberofNodesVelocity(void)=0; 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; virtual void ResetHooks()=0; Index: ../trunk-jpl/src/c/classes/Elements/Penta.cpp =================================================================== --- ../trunk-jpl/src/c/classes/Elements/Penta.cpp (revision 27030) +++ ../trunk-jpl/src/c/classes/Elements/Penta.cpp (revision 27031) @@ -3281,7 +3281,7 @@ return PentaRef::PressureInterpolation(this->element_type); } /*}}}*/ -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 * To project to penta the DOFs are doubled in size Index: ../trunk-jpl/src/c/classes/Elements/Penta.h =================================================================== --- ../trunk-jpl/src/c/classes/Elements/Penta.h (revision 27030) +++ ../trunk-jpl/src/c/classes/Elements/Penta.h (revision 27031) @@ -169,7 +169,7 @@ int NumberofNodesVelocity(void); 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); void ResetHooks(); Index: ../trunk-jpl/src/c/classes/FemModel.cpp =================================================================== --- ../trunk-jpl/src/c/classes/FemModel.cpp (revision 27030) +++ ../trunk-jpl/src/c/classes/FemModel.cpp (revision 27031) @@ -3218,7 +3218,7 @@ this->parameters->FindParam(&temp,FlowequationIsSIAEnum); iomodel->AddConstant(new IoConstant(temp,"md.flowequation.isSIA")); 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")); this->parameters->FindParam(&tempint,MasstransportStabilizationEnum); iomodel->AddConstant(new IoConstant(tempint,"md.masstransport.stabilization")); Index: ../trunk-jpl/src/c/classes/Loads/Penpair.cpp =================================================================== --- ../trunk-jpl/src/c/classes/Loads/Penpair.cpp (revision 27030) +++ ../trunk-jpl/src/c/classes/Loads/Penpair.cpp (revision 27031) @@ -354,9 +354,9 @@ case HOApproximationEnum: return PenaltyCreateKMatrixStressbalanceSSAHO(kmax); default: _error_("Approximation "<coord1+1); /* 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] + epsilon[3]*epsilon[3] + epsilon[4]*epsilon[4] + epsilon[0]*epsilon[1]); @@ -794,7 +794,7 @@ /*Clean up*/ 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*/ /*Intermediaries*/ @@ -816,7 +816,7 @@ zeta=0.5*(gauss_seg->coord1+1); /* 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] + epsilon[3]*epsilon[3] + epsilon[4]*epsilon[4] + epsilon[0]*epsilon[1]); Index: ../trunk-jpl/src/c/classes/Materials/Matice.h =================================================================== --- ../trunk-jpl/src/c/classes/Materials/Matice.h (revision 27030) +++ ../trunk-jpl/src/c/classes/Materials/Matice.h (revision 27031) @@ -77,8 +77,8 @@ 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); void ViscosityBFS(IssmDouble* pmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input,IssmDouble eps_eff){_error_("not supported");}; Index: ../trunk-jpl/src/c/classes/Materials/Matlitho.h =================================================================== --- ../trunk-jpl/src/c/classes/Materials/Matlitho.h (revision 27030) +++ ../trunk-jpl/src/c/classes/Materials/Matlitho.h (revision 27031) @@ -71,8 +71,8 @@ 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");}; void ViscosityBFS(IssmDouble* pmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input,IssmDouble epseff){_error_("not supported");}; Index: ../trunk-jpl/src/c/classes/Node.cpp =================================================================== --- ../trunk-jpl/src/c/classes/Node.cpp (revision 27030) +++ ../trunk-jpl/src/c/classes/Node.cpp (revision 27031) @@ -117,7 +117,7 @@ if(in_approximation==L1L2ApproximationEnum && !reCast(iomodel->Data("md.mesh.vertexonbase")[io_index])){ 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(); } if(in_approximation==SSAHOApproximationEnum && reCast(iomodel->Data("md.flowequation.borderSSA")[io_index])){ Index: ../trunk-jpl/src/c/cores/stressbalance_core.cpp =================================================================== --- ../trunk-jpl/src/c/cores/stressbalance_core.cpp (revision 27030) +++ ../trunk-jpl/src/c/cores/stressbalance_core.cpp (revision 27031) @@ -18,7 +18,7 @@ /*parameters: */ 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; int numoutputs = 0; @@ -30,7 +30,7 @@ femmodel->parameters->FindParam(&isSIA,FlowequationIsSIAEnum); 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); femmodel->parameters->FindParam(&isNitsche,FlowequationIsNitscheEnum); @@ -74,7 +74,7 @@ } /*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); delete analysis; @@ -81,7 +81,7 @@ } /*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*/ bmb_core(femmodel); Index: ../trunk-jpl/src/c/modules/SurfaceAbsVelMisfitx/SurfaceAbsVelMisfitx.cpp =================================================================== --- ../trunk-jpl/src/c/modules/SurfaceAbsVelMisfitx/SurfaceAbsVelMisfitx.cpp (revision 27030) +++ ../trunk-jpl/src/c/modules/SurfaceAbsVelMisfitx/SurfaceAbsVelMisfitx.cpp (revision 27031) @@ -65,7 +65,7 @@ Input* vy_input = NULL; 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); if(numcomponents==2){ Index: ../trunk-jpl/src/c/modules/SurfaceAverageVelMisfitx/SurfaceAverageVelMisfitx.cpp =================================================================== --- ../trunk-jpl/src/c/modules/SurfaceAverageVelMisfitx/SurfaceAverageVelMisfitx.cpp (revision 27030) +++ ../trunk-jpl/src/c/modules/SurfaceAverageVelMisfitx/SurfaceAverageVelMisfitx.cpp (revision 27031) @@ -73,7 +73,7 @@ Input* vy_input = NULL; 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); if(numcomponents==2){ Index: ../trunk-jpl/src/c/modules/SurfaceLogVelMisfitx/SurfaceLogVelMisfitx.cpp =================================================================== --- ../trunk-jpl/src/c/modules/SurfaceLogVelMisfitx/SurfaceLogVelMisfitx.cpp (revision 27030) +++ ../trunk-jpl/src/c/modules/SurfaceLogVelMisfitx/SurfaceLogVelMisfitx.cpp (revision 27031) @@ -67,7 +67,7 @@ Input* vy_input = NULL; 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); if(numcomponents==2){ Index: ../trunk-jpl/src/c/modules/SurfaceLogVxVyMisfitx/SurfaceLogVxVyMisfitx.cpp =================================================================== --- ../trunk-jpl/src/c/modules/SurfaceLogVxVyMisfitx/SurfaceLogVxVyMisfitx.cpp (revision 27030) +++ ../trunk-jpl/src/c/modules/SurfaceLogVxVyMisfitx/SurfaceLogVxVyMisfitx.cpp (revision 27031) @@ -67,7 +67,7 @@ Input* vy_input = NULL; 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); if(numcomponents==2){ Index: ../trunk-jpl/src/c/modules/SurfaceRelVelMisfitx/SurfaceRelVelMisfitx.cpp =================================================================== --- ../trunk-jpl/src/c/modules/SurfaceRelVelMisfitx/SurfaceRelVelMisfitx.cpp (revision 27030) +++ ../trunk-jpl/src/c/modules/SurfaceRelVelMisfitx/SurfaceRelVelMisfitx.cpp (revision 27031) @@ -67,7 +67,7 @@ Input* vy_input = NULL; 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); if(numcomponents==2){ Index: ../trunk-jpl/src/c/shared/Enum/EnumDefinitions.h =================================================================== --- ../trunk-jpl/src/c/shared/Enum/EnumDefinitions.h (revision 27030) +++ ../trunk-jpl/src/c/shared/Enum/EnumDefinitions.h (revision 27031) @@ -169,7 +169,7 @@ FlowequationIsFSEnum, FlowequationIsHOEnum, FlowequationIsL1L2Enum, - FlowequationIsMLHOEnum, + FlowequationIsMOLHOEnum, FlowequationIsSIAEnum, FlowequationIsSSAEnum, FlowequationIsNitscheEnum, @@ -1383,7 +1383,7 @@ InversionVzObsEnum, JEnum, L1L2ApproximationEnum, - MLHOApproximationEnum, + MOLHOApproximationEnum, L2ProjectionBaseAnalysisEnum, L2ProjectionEPLAnalysisEnum, LACrouzeixRaviartEnum, Index: ../trunk-jpl/src/c/shared/Enum/Enumjl.vim =================================================================== --- ../trunk-jpl/src/c/shared/Enum/Enumjl.vim (revision 27030) +++ ../trunk-jpl/src/c/shared/Enum/Enumjl.vim (revision 27031) @@ -105,6 +105,7 @@ syn keyword juliaConstC CalvingLawEnum syn keyword juliaConstC CalvingMinthicknessEnum syn keyword juliaConstC CalvingTestSpeedfactorEnum +syn keyword juliaConstC CalvingTestIndependentRateEnum syn keyword juliaConstC CalvingUseParamEnum syn keyword juliaConstC CalvingScaleThetaEnum syn keyword juliaConstC CalvingAmpAlphaEnum @@ -167,7 +168,7 @@ syn keyword juliaConstC FlowequationIsFSEnum syn keyword juliaConstC FlowequationIsHOEnum syn keyword juliaConstC FlowequationIsL1L2Enum -syn keyword juliaConstC FlowequationIsMLHOEnum +syn keyword juliaConstC FlowequationIsMOLHOEnum syn keyword juliaConstC FlowequationIsSIAEnum syn keyword juliaConstC FlowequationIsSSAEnum syn keyword juliaConstC FlowequationIsNitscheEnum @@ -650,6 +651,7 @@ syn keyword juliaConstC BottomPressureOldEnum syn keyword juliaConstC CalvingCalvingrateEnum syn keyword juliaConstC CalvingHabFractionEnum +syn keyword juliaConstC CalvingAblationrateEnum syn keyword juliaConstC CalvingMeltingrateEnum syn keyword juliaConstC CalvingStressThresholdFloatingiceEnum syn keyword juliaConstC CalvingStressThresholdGroundediceEnum @@ -1375,7 +1377,7 @@ syn keyword juliaConstC InversionVzObsEnum syn keyword juliaConstC JEnum syn keyword juliaConstC L1L2ApproximationEnum -syn keyword juliaConstC MLHOApproximationEnum +syn keyword juliaConstC MOLHOApproximationEnum syn keyword juliaConstC L2ProjectionBaseAnalysisEnum syn keyword juliaConstC L2ProjectionEPLAnalysisEnum syn keyword juliaConstC LACrouzeixRaviartEnum Index: ../trunk-jpl/src/c/shared/io/Marshalling/IoCodeConversions.cpp =================================================================== --- ../trunk-jpl/src/c/shared/io/Marshalling/IoCodeConversions.cpp (revision 27030) +++ ../trunk-jpl/src/c/shared/io/Marshalling/IoCodeConversions.cpp (revision 27031) @@ -344,7 +344,7 @@ case 1: return SIAApproximationEnum; case 2: return SSAApproximationEnum; case 3: return L1L2ApproximationEnum; - case 4: return MLHOApproximationEnum; + case 4: return MOLHOApproximationEnum; case 5: return HOApproximationEnum; case 6: return FSApproximationEnum; case 7: return SSAHOApproximationEnum; @@ -359,7 +359,7 @@ case 1: return SIAApproximationEnum; case 2: return SSAApproximationEnum; case 3: return L1L2ApproximationEnum; - case 4: return MLHOApproximationEnum; + case 4: return MOLHOApproximationEnum; case 5: return HOApproximationEnum; case 6: return FSApproximationEnum; case 7: return SSAHOApproximationEnum; Index: ../trunk-jpl/src/m/boundaryconditions/SetMOLHOBC.py =================================================================== --- ../trunk-jpl/src/m/boundaryconditions/SetMOLHOBC.py (nonexistent) +++ ../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: ../trunk-jpl/src/m/classes/flowequation.py =================================================================== --- ../trunk-jpl/src/m/classes/flowequation.py (revision 27030) +++ ../trunk-jpl/src/m/classes/flowequation.py (revision 27031) @@ -18,7 +18,7 @@ self.isSIA = 0 self.isSSA = 0 self.isL1L2 = 0 - self.isMLHO = 0 + self.isMOLHO = 0 self.isHO = 0 self.isFS = 0 self.isNitscheBC = 0 @@ -45,7 +45,7 @@ s += '{}\n'.format(fielddisplay(self, 'isSIA', "is the Shallow Ice Approximation (SIA) used?")) 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?")) s += '{}\n'.format(fielddisplay(self, 'isNitscheBC', "is weakly imposed condition used?")) @@ -89,7 +89,7 @@ md = checkfield(md, 'fieldname', 'flowequation.isSIA', 'numel', [1], 'values', [0, 1]) 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]) md = checkfield(md, 'fieldname', 'flowequation.isNitscheBC', 'numel', [1], 'values', [0, 1]) @@ -120,7 +120,7 @@ else: 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: if any(self.element_equation == 1): @@ -133,7 +133,7 @@ WriteData(fid, prefix, 'object', self, 'fieldname', 'isSIA', 'format', 'Boolean') 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') WriteData(fid, prefix, 'object', self, 'fieldname', 'isNitscheBC', 'format', 'Boolean') Index: ../trunk-jpl/src/m/classes/stressbalance.m =================================================================== --- ../trunk-jpl/src/m/classes/stressbalance.m (revision 27030) +++ ../trunk-jpl/src/m/classes/stressbalance.m (revision 27031) @@ -35,8 +35,8 @@ self.referential=project3d(md,'vector',self.referential,'type','node'); 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'); self.spcvx_shear=project3d(md,'vector',self.spcvx_shear,'type','poly','degree',4); @@ -133,8 +133,8 @@ end 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); md = checkfield(md,'fieldname','stressbalance.spcvx_shear','Inf',1,'timeseries',1); @@ -168,7 +168,7 @@ fielddisplay(self,'spcvy','y-axis velocity constraint (NaN means no constraint) [m/yr]'); 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]'); fielddisplay(self,'spcvx_shear','x-axis shear velocity constraint (NaN means no constraint) [m/yr]'); @@ -225,8 +225,8 @@ outputs = [outputs defaultoutputs(self,md)]; %add defaults 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); WriteData(fid,prefix,'object',self,'class','stressbalance','fieldname','spcvx_shear','format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1,'yts',md.constants.yts); Index: ../trunk-jpl/src/m/parameterization/setflowequation.m =================================================================== --- ../trunk-jpl/src/m/parameterization/setflowequation.m (revision 27030) +++ ../trunk-jpl/src/m/parameterization/setflowequation.m (revision 27031) @@ -2,7 +2,7 @@ %SETFLOWEQUATION - associate a solution type to each element % % 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. % If user wants every element outside the domain to be @@ -10,7 +10,7 @@ % an empty string '' will be considered as an empty domain % 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: % md=setflowequation(md,varargin) @@ -38,7 +38,7 @@ SSAflag = FlagElements(md,getfieldvalue(options,'SSA','')); HOflag = FlagElements(md,getfieldvalue(options,'HO','')); L1L2flag = FlagElements(md,getfieldvalue(options,'L1L2','')); -MLHOflag = FlagElements(md,getfieldvalue(options,'MLHO','')); +MOLHOflag = FlagElements(md,getfieldvalue(options,'MOLHO','')); FSflag = FlagElements(md,getfieldvalue(options,'FS','')); filltype = getfieldvalue(options,'fill','none'); displayunused(options); @@ -53,12 +53,12 @@ end %check that each element has at least one flag -if any(SIAflag+SSAflag+HOflag+L1L2flag+MLHOflag+FSflag==0), +if any(SIAflag+SSAflag+HOflag+L1L2flag+MOLHOflag+FSflag==0), error('elements type not assigned, supported models are ''SIA'',''SSA'',''HO'' and ''FS''') end %check that each element has only one flag -if any(SIAflag+SSAflag+HOflag+L1L2flag+MLHOflag+FSflag>1), +if any(SIAflag+SSAflag+HOflag+L1L2flag+MOLHOflag+FSflag>1), disp('setflowequation.m: Warning: some elements have several types, higher order type is used for them') SIAflag(find(SIAflag & SSAflag))=0; SIAflag(find(SIAflag & HOflag))=0; @@ -69,8 +69,8 @@ if any(L1L2flag) & any(SIAflag | SSAflag | HOflag | FSflag) 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 %Check that no HO or FS for 2d mesh @@ -90,7 +90,7 @@ nodeonSSA=zeros(md.mesh.numberofvertices,1); nodeonSSA(md.mesh.elements(find(SSAflag),:))=1; 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); @@ -247,7 +247,7 @@ md.flowequation.element_equation(find(SIAflag))=1; 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; md.flowequation.element_equation(find(SSAHOflag))=7; @@ -263,7 +263,7 @@ md.flowequation.vertex_equation=zeros(md.mesh.numberofvertices,1); 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; %DO SIA LAST! Otherwise spcs might not be set up correctly (SIA should have priority) @@ -286,7 +286,7 @@ md.flowequation.isSIA = double(any(md.flowequation.element_equation == 1)); 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: ../trunk-jpl/src/m/plot/plot_elementstype.m =================================================================== --- ../trunk-jpl/src/m/plot/plot_elementstype.m (revision 27030) +++ ../trunk-jpl/src/m/plot/plot_elementstype.m (revision 27031) @@ -36,7 +36,7 @@ patch( 'Faces', [C A D F],'Vertices', [x y z],'CData', i,'FaceColor','flat','EdgeColor',edgecolor); end end -legend(p,'None','SIA','SSA','L1L2','MLHO','HO',... +legend(p,'None','SIA','SSA','L1L2','MOLHO','HO',... 'SSAHO','FS','SSAFS','HOFS'); %apply options Index: ../trunk-jpl/test/NightlyRun/test128.py =================================================================== --- ../trunk-jpl/test/NightlyRun/test128.py (revision 27030) +++ ../trunk-jpl/test/NightlyRun/test128.py (revision 27031) @@ -1,6 +1,6 @@ -#Test Name: SquareShelfConstrainedTranMLHO2d +#Test Name: SquareShelfConstrainedTranMOLHO2d from model import * -from SetMLHOBC import SetMLHOBC +from SetMOLHOBC import SetMOLHOBC from socket import gethostname from triangle import * from setmask import * @@ -12,11 +12,11 @@ md = triangle(model(), '../Exp/Square.exp', 150000) 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') #Fields and tolerances to track changes Index: ../trunk-jpl/test/NightlyRun/test248.py =================================================================== --- ../trunk-jpl/test/NightlyRun/test248.py (revision 27030) +++ ../trunk-jpl/test/NightlyRun/test248.py (revision 27031) @@ -1,4 +1,4 @@ -#Test Name: SquareShelfStressMLHO2d +#Test Name: SquareShelfStressMOLHO2d from model import * from socket import gethostname from triangle import triangle @@ -6,15 +6,15 @@ from parameterize import parameterize 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') #Fields and tolerances to track changes Index: ../trunk-jpl/test/NightlyRun/test254.py =================================================================== --- ../trunk-jpl/test/NightlyRun/test254.py (revision 27030) +++ ../trunk-jpl/test/NightlyRun/test254.py (revision 27031) @@ -1,4 +1,4 @@ -#Test Name: SquareShelfConstrainedMLHO +#Test Name: SquareShelfConstrainedMOLHO from model import * from socket import gethostname import numpy as np @@ -8,13 +8,13 @@ from setflowequation import setflowequation from paterson import paterson from solve import solve -from SetMLHOBC import SetMLHOBC +from SetMOLHOBC import SetMOLHOBC from generic import generic 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) # redo the parameter file for this special shelf. @@ -70,7 +70,7 @@ md.mask.ice_levelset = -1 + nodeonicefront md.stressbalance.requested_outputs = ['default', 'VySurface', 'VyShear', 'VyBase'] -md = SetMLHOBC(md) +md = SetMOLHOBC(md) md = solve(md, 'Stressbalance') # create analytical solution: strain rate is constant = ((rho_ice * g * h) / 4B)^3 (Paterson, 4th Edition, page 292. Index: ../trunk-jpl/src/m/parameterization/setflowequation.py =================================================================== --- ../trunk-jpl/src/m/parameterization/setflowequation.py (revision 27030) +++ ../trunk-jpl/src/m/parameterization/setflowequation.py (revision 27031) @@ -8,7 +8,7 @@ """SETFLOWEQUATION - associate a solution type to each element 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 element flags. @@ -44,7 +44,7 @@ SSAflag = FlagElements(md, options.getfieldvalue('SSA', '')) 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') @@ -56,21 +56,21 @@ elif 'HO' in filltype: 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 SIAflag[np.where(np.logical_and(SIAflag, HOflag))] = False 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 if md.mesh.domaintype == '2Dhorizontal': @@ -88,8 +88,8 @@ nodeonSSA[md.mesh.elements[np.where(SSAflag), :] - 1] = True 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 nodeonFS = np.zeros(md.mesh.numberofvertices, bool) @@ -240,7 +240,7 @@ md.flowequation.element_equation[np.where(SIAflag)] = 1 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 md.flowequation.element_equation[np.where(SSAHOflag)] = 7 @@ -258,7 +258,7 @@ md.flowequation.vertex_equation[pos] = 2 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) md.flowequation.vertex_equation[pos] = 5 @@ -282,7 +282,7 @@ md.flowequation.isSIA = any(md.flowequation.element_equation == 1) 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: ../trunk-jpl/test/NightlyRun/test128.m =================================================================== --- ../trunk-jpl/test/NightlyRun/test128.m (revision 27030) +++ ../trunk-jpl/test/NightlyRun/test128.m (revision 27031) @@ -1,12 +1,12 @@ -%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'); %Fields and tolerances to track changes Index: ../trunk-jpl/test/NightlyRun/test248.m =================================================================== --- ../trunk-jpl/test/NightlyRun/test248.m (revision 27030) +++ ../trunk-jpl/test/NightlyRun/test248.m (revision 27031) @@ -1,11 +1,11 @@ -%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'); %Fields and tolerances to track changes Index: ../trunk-jpl/test/NightlyRun/test254.m =================================================================== --- ../trunk-jpl/test/NightlyRun/test254.m (revision 27030) +++ ../trunk-jpl/test/NightlyRun/test254.m (revision 27031) @@ -1,8 +1,8 @@ -%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); %redo the parameter file for this special shelf. @@ -57,7 +57,7 @@ md.mask.ice_levelset=-1+nodeonicefront; md.stressbalance.requested_outputs={'default','VySurface','VyShear','VyBase'}; -md=SetMLHOBC(md); +md=SetMOLHOBC(md); md=solve(md,'Stressbalance'); %create analytical solution: strain rate is constant = ((rho_ice*g*h)/4B)^3 (Paterson, 4th Edition, page 292. Index: ../trunk-jpl/test/NightlyRun/test256.m =================================================================== --- ../trunk-jpl/test/NightlyRun/test256.m (revision 27030) +++ ../trunk-jpl/test/NightlyRun/test256.m (revision 27031) @@ -1,12 +1,12 @@ -%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'); %Fields and tolerances to track changes Index: ../trunk-jpl/test/NightlyRun/test127.py =================================================================== --- ../trunk-jpl/test/NightlyRun/test127.py (revision 27030) +++ ../trunk-jpl/test/NightlyRun/test127.py (revision 27031) @@ -1,4 +1,4 @@ -#Test Name: SquareShelfConstrainedStressMLHO2d +#Test Name: SquareShelfConstrainedStressMOLHO2d from model import * from socket import gethostname from triangle import triangle @@ -8,15 +8,15 @@ from solve import solve 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'] md.outputdefinition.definitions = [massfluxatgate('name', 'MassFlux1', 'profilename', '../Exp/MassFlux1.exp', 'definitionstring', 'Outputdefinition1'), @@ -25,7 +25,7 @@ massfluxatgate('name', 'MassFlux4', 'profilename', '../Exp/MassFlux4.exp', 'definitionstring', 'Outputdefinition4'), 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') #Fields and tolerances to track changes Index: ../trunk-jpl/test/NightlyRun/test129.py =================================================================== --- ../trunk-jpl/test/NightlyRun/test129.py (revision 27030) +++ ../trunk-jpl/test/NightlyRun/test129.py (revision 27031) @@ -1,7 +1,7 @@ -#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 * from parameterize import * @@ -13,7 +13,7 @@ md = triangle(model(), '../Exp/Square.exp', 150000.) 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'] @@ -23,7 +23,7 @@ # time steps and resolution md.timestepping.final_time = 19 md.settings.output_frequency = 2 -md = SetMLHOBC(md) +md = SetMOLHOBC(md) md = solve(md, 'Transient') md2 = copy.deepcopy(md) Index: ../trunk-jpl/test/NightlyRun/test249.py =================================================================== --- ../trunk-jpl/test/NightlyRun/test249.py (revision 27030) +++ ../trunk-jpl/test/NightlyRun/test249.py (revision 27031) @@ -1,4 +1,4 @@ -#Test Name: SquareShelfTranMLHO2d +#Test Name: SquareShelfTranMOLHO2d from model import * from socket import gethostname @@ -8,16 +8,16 @@ from setflowequation import setflowequation from solve import solve from generic import generic -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.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: ../trunk-jpl/test/NightlyRun/test255.py =================================================================== --- ../trunk-jpl/test/NightlyRun/test255.py (revision 27030) +++ ../trunk-jpl/test/NightlyRun/test255.py (revision 27031) @@ -1,4 +1,4 @@ -#Test Name: SquareShelfStressMLHO2dTransientIncrHydro +#Test Name: SquareShelfStressMOLHO2dTransientIncrHydro from model import * from socket import gethostname from triangle import triangle @@ -6,15 +6,15 @@ from parameterize import parameterize 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') #Fields and tolerances to track changes Index: ../trunk-jpl/test/NightlyRun/test256.py =================================================================== --- ../trunk-jpl/test/NightlyRun/test256.py (revision 27030) +++ ../trunk-jpl/test/NightlyRun/test256.py (revision 27031) @@ -1,4 +1,4 @@ -#Test Name: SquareShelfStressMLHO2dTransientIncrNonHydro +#Test Name: SquareShelfStressMOLHO2dTransientIncrNonHydro from model import * from socket import gethostname from triangle import triangle @@ -6,18 +6,18 @@ from parameterize import parameterize 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.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') #Fields and tolerances to track changes Index: ../trunk-jpl/test/NightlyRun/test332.py =================================================================== --- ../trunk-jpl/test/NightlyRun/test332.py (revision 27030) +++ ../trunk-jpl/test/NightlyRun/test332.py (revision 27031) @@ -1,4 +1,4 @@ -#Test Name: SquareSheetConstrainedTranMLHO2d +#Test Name: SquareSheetConstrainedTranMOLHO2d from model import * from socket import gethostname from triangle import triangle @@ -6,14 +6,14 @@ from parameterize import parameterize 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') #Fields and tolerances to track changes Index: ../trunk-jpl/test/NightlyRun/test334.py =================================================================== --- ../trunk-jpl/test/NightlyRun/test334.py (revision 27030) +++ ../trunk-jpl/test/NightlyRun/test334.py (revision 27031) @@ -1,4 +1,4 @@ -#Test Name: SquareShelfCMBMLHO +#Test Name: SquareShelfCMBMOLHO from model import * from socket import gethostname import numpy as np @@ -8,12 +8,12 @@ from setflowequation import setflowequation 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 @@ -32,7 +32,7 @@ md.cluster = generic('name', gethostname(), 'np', 3) -md = SetMLHOBC(md) +md = SetMOLHOBC(md) md = solve(md, 'Stressbalance') Index: ../trunk-jpl/test/NightlyRun/test446.py =================================================================== --- ../trunk-jpl/test/NightlyRun/test446.py (revision 27030) +++ ../trunk-jpl/test/NightlyRun/test446.py (revision 27031) @@ -1,4 +1,4 @@ -#Test Name: SquareSheetShelfStressMLHO2d +#Test Name: SquareSheetShelfStressMOLHO2d from model import * from socket import gethostname from triangle import triangle @@ -6,15 +6,15 @@ from parameterize import parameterize 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') #Fields and tolerances to track changes Index: ../trunk-jpl/test/NightlyRun/test448.py =================================================================== --- ../trunk-jpl/test/NightlyRun/test448.py (revision 27030) +++ ../trunk-jpl/test/NightlyRun/test448.py (revision 27031) @@ -1,4 +1,4 @@ -#Test Name: RoundSheetShelfGLMigrationMLHO2d +#Test Name: RoundSheetShelfGLMigrationMOLHO2d import numpy as np from model import * from socket import gethostname @@ -7,7 +7,7 @@ from parameterize import parameterize from setflowequation import setflowequation from solve import solve -from SetMLHOBC import SetMLHOBC +from SetMOLHOBC import SetMOLHOBC radius = 1.e6 @@ -27,7 +27,7 @@ flags[pos] = 1 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) md.transient.isthermal = False @@ -38,7 +38,7 @@ #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 vel_agressive = md.results.TransientSolution[0].Vel Index: ../trunk-jpl/test/NightlyRun/test518.py =================================================================== --- ../trunk-jpl/test/NightlyRun/test518.py (revision 27030) +++ ../trunk-jpl/test/NightlyRun/test518.py (revision 27031) @@ -1,5 +1,5 @@ -#Test Name: PigStressMLHO2d +#Test Name: PigStressMOLHO2d from model import * from socket import gethostname from triangle import triangle @@ -7,16 +7,16 @@ from parameterize import parameterize from setflowequation import setflowequation from solve import solve -from SetMLHOBC import SetMLHOBC +from SetMOLHOBC import SetMOLHOBC md = triangle(model(), '../Exp/Pig.exp', 20000.) 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') #Fields and tolerances to track changes Index: ../trunk-jpl/test/NightlyRun/test332.m =================================================================== --- ../trunk-jpl/test/NightlyRun/test332.m (revision 27030) +++ ../trunk-jpl/test/NightlyRun/test332.m (revision 27031) @@ -1,10 +1,10 @@ -%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'); %Fields and tolerances to track changes Index: ../trunk-jpl/test/NightlyRun/test334.m =================================================================== --- ../trunk-jpl/test/NightlyRun/test334.m (revision 27030) +++ ../trunk-jpl/test/NightlyRun/test334.m (revision 27031) @@ -1,8 +1,8 @@ -%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 md.inversion.iscontrol=1; @@ -19,7 +19,7 @@ md.verbose.control=true; md.cluster=generic('name',oshostname(),'np',3); -md=SetMLHOBC(md); +md=SetMOLHOBC(md); md=solve(md,'Stressbalance'); %Fields and tolerances to track changes Index: ../trunk-jpl/test/NightlyRun/test446.m =================================================================== --- ../trunk-jpl/test/NightlyRun/test446.m (revision 27030) +++ ../trunk-jpl/test/NightlyRun/test446.m (revision 27031) @@ -1,11 +1,11 @@ -%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'); %Fields and tolerances to track changes Index: ../trunk-jpl/test/NightlyRun/test448.m =================================================================== --- ../trunk-jpl/test/NightlyRun/test448.m (revision 27030) +++ ../trunk-jpl/test/NightlyRun/test448.m (revision 27031) @@ -1,4 +1,4 @@ -%Test Name: RoundSheetShelfGLMigrationMLHO2d +%Test Name: RoundSheetShelfGLMigrationMOLHO2d radius=1.e6; shelfextent=2.e5; @@ -15,7 +15,7 @@ flags(pos)=1; 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); md.transient.isthermal=0; @@ -24,7 +24,7 @@ md.transient.isstressbalance=1; md.transient.isgroundingline=1; -md=SetMLHOBC(md); +md=SetMOLHOBC(md); %test different grounding line dynamics. md.groundingline.migration='AggressiveMigration'; md=solve(md,'Transient'); Index: ../trunk-jpl/test/NightlyRun/test518.m =================================================================== --- ../trunk-jpl/test/NightlyRun/test518.m (revision 27030) +++ ../trunk-jpl/test/NightlyRun/test518.m (revision 27031) @@ -1,11 +1,11 @@ -%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'); %Fields and tolerances to track changes Index: ../trunk-jpl/test/NightlyRun/test810.m =================================================================== --- ../trunk-jpl/test/NightlyRun/test810.m (revision 27030) +++ ../trunk-jpl/test/NightlyRun/test810.m (revision 27031) @@ -1,8 +1,8 @@ -%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); @@ -14,7 +14,7 @@ md.transient.isthermal=0; md.transient.isgroundingline=1; -md=SetMLHOBC(md); +md=SetMOLHOBC(md); md=solve(md,'Transient'); %Fields and tolerances to track changes Index: ../trunk-jpl/test/NightlyRun/test330.py =================================================================== --- ../trunk-jpl/test/NightlyRun/test330.py (revision 27030) +++ ../trunk-jpl/test/NightlyRun/test330.py (revision 27031) @@ -1,4 +1,4 @@ -#Test Name: SquareSheetConstrainedStressMLHO2d +#Test Name: SquareSheetConstrainedStressMOLHO2d from model import * from socket import gethostname from triangle import triangle @@ -6,16 +6,16 @@ from parameterize import parameterize 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.stressbalance.requested_outputs = ['default', 'VxSurface', 'VySurface', 'VxShear', 'VyShear', 'VxBase', 'VyBase'] -md = SetMLHOBC(md) +md = SetMOLHOBC(md) md = solve(md, 'Stressbalance') #Fields and tolerances to track changes Index: ../trunk-jpl/test/NightlyRun/test333.py =================================================================== --- ../trunk-jpl/test/NightlyRun/test333.py (revision 27030) +++ ../trunk-jpl/test/NightlyRun/test333.py (revision 27031) @@ -1,4 +1,4 @@ -#Test Name: SquareSheetConstrainedCMDragMLHO +#Test Name: SquareSheetConstrainedCMDragMOLHO import numpy as np from model import * from socket import gethostname @@ -7,13 +7,13 @@ from parameterize import parameterize from setflowequation import setflowequation from solve import solve -from SetMLHOBC import SetMLHOBC +from SetMOLHOBC import SetMOLHOBC md = triangle(model(), '../Exp/Square.exp', 200000.) md = setmask(md, '', '') md = parameterize(md, '../Par/SquareSheetConstrained.py') -md = setflowequation(md, 'MLHO', 'all') +md = setflowequation(md, 'MOLHO', 'all') #control parameters @@ -32,7 +32,7 @@ md.inversion.vy_obs = md.initialization.vy md.cluster = generic('name', gethostname(), 'np', 3) -md = SetMLHOBC(md) +md = SetMOLHOBC(md) md = solve(md, 'Stressbalance') #Fields and tolerances to track changes Index: ../trunk-jpl/test/NightlyRun/test335.py =================================================================== --- ../trunk-jpl/test/NightlyRun/test335.py (revision 27030) +++ ../trunk-jpl/test/NightlyRun/test335.py (revision 27031) @@ -1,4 +1,4 @@ -#Test Name: SquareSheetConstrainedStressMLHO2d +#Test Name: SquareSheetConstrainedStressMOLHO2d from model import * from socket import gethostname from triangle import triangle @@ -6,14 +6,14 @@ from parameterize import parameterize from setflowequation import setflowequation from solve import solve -from SetMLHOBC import SetMLHOBC +from SetMOLHOBC import SetMOLHOBC md = triangle(model(), '../Exp/Square.exp', 200000.) 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) md.stressbalance.requested_outputs = ['default', 'VxSurface', 'VySurface', 'VxShear', 'VyShear', 'VxBase', 'VyBase'] Index: ../trunk-jpl/test/NightlyRun/test447.py =================================================================== --- ../trunk-jpl/test/NightlyRun/test447.py (revision 27030) +++ ../trunk-jpl/test/NightlyRun/test447.py (revision 27031) @@ -1,4 +1,4 @@ -#Test Name: SquareSheetShelfTranMLHO2d +#Test Name: SquareSheetShelfTranMOLHO2d import numpy as np from model import * from socket import gethostname @@ -7,7 +7,7 @@ from parameterize import parameterize from setflowequation import setflowequation from solve import solve -from SetMLHOBC import SetMLHOBC +from SetMOLHOBC import SetMOLHOBC from frictioncoulomb import frictioncoulomb from generic import generic @@ -24,10 +24,10 @@ md.friction.coefficientcoulomb = 0.02 * np.ones(md.mesh.numberofvertices) 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') #Fields and tolerances to track changes Index: ../trunk-jpl/test/NightlyRun/test449.py =================================================================== --- ../trunk-jpl/test/NightlyRun/test449.py (revision 27030) +++ ../trunk-jpl/test/NightlyRun/test449.py (revision 27031) @@ -1,4 +1,4 @@ -#Test Name: MISMIP3DMLHO +#Test Name: MISMIP3DMOLHO import numpy as np from model import * from socket import gethostname @@ -7,7 +7,7 @@ from parameterize import parameterize from setflowequation import setflowequation from solve import solve -from SetMLHOBC import SetMLHOBC +from SetMOLHOBC import SetMOLHOBC from generic import generic @@ -23,7 +23,7 @@ pos = np.where(md.mask.ocean_levelset >= 0.) 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: md.mask.ice_levelset = -np.ones((md.mesh.numberofvertices, )) @@ -58,7 +58,7 @@ md.timestepping.time_step = 10 md.cluster = generic('name', gethostname(), 'np', 3) -md = SetMLHOBC(md) +md = SetMOLHOBC(md) md = solve(md, 'Transient') #print md.results.TransientSolution[0].BasalforcingsFloatingiceMeltingRate #print md.results.TransientSolution[1].BasalforcingsFloatingiceMeltingRate Index: ../trunk-jpl/test/NightlyRun/test519.py =================================================================== --- ../trunk-jpl/test/NightlyRun/test519.py (revision 27030) +++ ../trunk-jpl/test/NightlyRun/test519.py (revision 27031) @@ -1,4 +1,4 @@ -#Test Name: PigTranMLHO2d +#Test Name: PigTranMOLHO2d import numpy as np from model import * from socket import gethostname @@ -7,17 +7,17 @@ from parameterize import parameterize from setflowequation import setflowequation from solve import solve -from SetMLHOBC import SetMLHOBC +from SetMOLHOBC import SetMOLHOBC from generic import generic md = triangle(model(), '../Exp/Pig.exp', 20000.) 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') # Fields and tolerances to track changes Index: ../trunk-jpl/test/NightlyRun/test810.py =================================================================== --- ../trunk-jpl/test/NightlyRun/test810.py (revision 27030) +++ ../trunk-jpl/test/NightlyRun/test810.py (revision 27031) @@ -1,4 +1,4 @@ -#Test Name: ValleyGlacierLevelsetMLHO2d +#Test Name: ValleyGlacierLevelsetMOLHO2d from model import * from socket import gethostname from triangle import triangle @@ -6,13 +6,13 @@ from parameterize import parameterize from setflowequation import setflowequation from solve import solve -from SetMLHOBC import SetMLHOBC +from SetMOLHOBC import SetMOLHOBC md = triangle(model(), '../Exp/Square.exp', 50000) md = setmask(md, '', '') 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) #Transient @@ -22,7 +22,7 @@ md.transient.issmb = True md.transient.isthermal = False md.transient.isgroundingline = True -md = SetMLHOBC(md) +md = SetMOLHOBC(md) md = solve(md, 'Transient') Index: ../trunk-jpl/test/NightlyRun/test812.py =================================================================== --- ../trunk-jpl/test/NightlyRun/test812.py (revision 27030) +++ ../trunk-jpl/test/NightlyRun/test812.py (revision 27031) @@ -1,4 +1,4 @@ -#Test Name: SquareShelfLevelsetCalvingMLHO2dLevermann +#Test Name: SquareShelfLevelsetCalvingMOLHO2dLevermann import numpy as np from socket import gethostname from model import * @@ -7,12 +7,12 @@ from setmask import setmask 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) x = md.mesh.x @@ -44,7 +44,7 @@ md.transient.requested_outputs = ['default', 'StrainRateparallel', 'StrainRateperpendicular', 'Calvingratex', 'Calvingratey', 'CalvingCalvingrate'] -md = SetMLHOBC(md); +md = SetMOLHOBC(md); md = solve(md, 'Transient') #Fields and tolerances to track changes Index: ../trunk-jpl/test/NightlyRun/test812.m =================================================================== --- ../trunk-jpl/test/NightlyRun/test812.m (revision 27030) +++ ../trunk-jpl/test/NightlyRun/test812.m (revision 27031) @@ -1,8 +1,8 @@ -%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); %Do not kill ice bergs as all is floating @@ -34,7 +34,7 @@ md.transient.requested_outputs={'default','StrainRateparallel','StrainRateperpendicular','Calvingratex','Calvingratey','CalvingCalvingrate'}; -md=SetMLHOBC(md); +md=SetMOLHOBC(md); md=solve(md,'Transient'); %Fields and tolerances to track changes Index: ../trunk-jpl/test/NightlyRun/test811.py =================================================================== --- ../trunk-jpl/test/NightlyRun/test811.py (revision 27030) +++ ../trunk-jpl/test/NightlyRun/test811.py (revision 27031) @@ -1,4 +1,4 @@ -#Test Name: ValleyGlacierLevelsetCalvingMLHO2d +#Test Name: ValleyGlacierLevelsetCalvingMOLHO2d import numpy as np from model import * from socket import gethostname @@ -7,13 +7,13 @@ from parameterize import parameterize from setflowequation import setflowequation from solve import solve -from SetMLHOBC import SetMLHOBC +from SetMOLHOBC import SetMOLHOBC from generic import generic md = triangle(model(), '../Exp/Square.exp', 50000) 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) #Transient @@ -28,7 +28,7 @@ md.frontalforcings.meltingrate = np.zeros((md.mesh.numberofvertices)) md.levelset.migration_max = 1e10 -md = SetMLHOBC(md) +md = SetMOLHOBC(md) md = solve(md, 'Transient') #Fields and tolerances to track changes Index: ../trunk-jpl/test/NightlyRun/test127.m =================================================================== --- ../trunk-jpl/test/NightlyRun/test127.m (revision 27030) +++ ../trunk-jpl/test/NightlyRun/test127.m (revision 27031) @@ -1,12 +1,12 @@ -%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'}; md.outputdefinition.definitions={... @@ -17,7 +17,7 @@ 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'); %Fields and tolerances to track changes Index: ../trunk-jpl/test/NightlyRun/test129.m =================================================================== --- ../trunk-jpl/test/NightlyRun/test129.m (revision 27030) +++ ../trunk-jpl/test/NightlyRun/test129.m (revision 27031) @@ -1,8 +1,8 @@ -%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'}; @@ -13,7 +13,7 @@ md.timestepping.final_time=19; md.settings.output_frequency=2; -md=SetMLHOBC(md); +md=SetMOLHOBC(md); md=solve(md,'Transient'); md2=solve(md,'Transient','restart',1); Index: ../trunk-jpl/test/NightlyRun/test249.m =================================================================== --- ../trunk-jpl/test/NightlyRun/test249.m (revision 27030) +++ ../trunk-jpl/test/NightlyRun/test249.m (revision 27031) @@ -1,12 +1,12 @@ -%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'); %Fields and tolerances to track changes Index: ../trunk-jpl/test/NightlyRun/test255.m =================================================================== --- ../trunk-jpl/test/NightlyRun/test255.m (revision 27030) +++ ../trunk-jpl/test/NightlyRun/test255.m (revision 27031) @@ -1,11 +1,11 @@ -%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'); %Fields and tolerances to track changes Index: ../trunk-jpl/test/NightlyRun/test330.m =================================================================== --- ../trunk-jpl/test/NightlyRun/test330.m (revision 27030) +++ ../trunk-jpl/test/NightlyRun/test330.m (revision 27031) @@ -1,11 +1,11 @@ -%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'); %Fields and tolerances to track changes Index: ../trunk-jpl/test/NightlyRun/test333.m =================================================================== --- ../trunk-jpl/test/NightlyRun/test333.m (revision 27030) +++ ../trunk-jpl/test/NightlyRun/test333.m (revision 27031) @@ -1,8 +1,8 @@ -%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 md.inversion.iscontrol=1; @@ -18,7 +18,7 @@ md.inversion.vx_obs=md.initialization.vx; md.inversion.vy_obs=md.initialization.vy; md.cluster=generic('name',oshostname(),'np',3); -md=SetMLHOBC(md); +md=SetMOLHOBC(md); md=solve(md,'Stressbalance'); %Fields and tolerances to track changes Index: ../trunk-jpl/test/NightlyRun/test335.m =================================================================== --- ../trunk-jpl/test/NightlyRun/test335.m (revision 27030) +++ ../trunk-jpl/test/NightlyRun/test335.m (revision 27031) @@ -1,12 +1,12 @@ -%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'); %Fields and tolerances to track changes Index: ../trunk-jpl/test/NightlyRun/test447.m =================================================================== --- ../trunk-jpl/test/NightlyRun/test447.m (revision 27030) +++ ../trunk-jpl/test/NightlyRun/test447.m (revision 27031) @@ -1,4 +1,4 @@ -%Test Name: SquareSheetShelfTranMLHO2d +%Test Name: SquareSheetShelfTranMOLHO2d md=triangle(model(),'../Exp/Square.exp',150000.); md=setmask(md,'../Exp/SquareShelf.exp',''); md=parameterize(md,'../Par/SquareSheetShelf.par'); @@ -12,10 +12,10 @@ md.friction.coefficientcoulomb=0.02*ones(md.mesh.numberofvertices,1); 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'); %Fields and tolerances to track changes Index: ../trunk-jpl/test/NightlyRun/test449.m =================================================================== --- ../trunk-jpl/test/NightlyRun/test449.m (revision 27030) +++ ../trunk-jpl/test/NightlyRun/test449.m (revision 27031) @@ -1,4 +1,4 @@ -%Test Name: MISMIP3DMLHO +%Test Name: MISMIP3DMOLHO md=triangle(model(),'../Exp/Square.exp',100000.); md=setmask(md,'../Exp/SquareShelf.exp',''); md=parameterize(md,'../Par/SquareSheetShelf.par'); @@ -11,7 +11,7 @@ pos=find(md.mask.ocean_levelset>=0); 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: md.mask.ice_levelset=-ones(md.mesh.numberofvertices,1); @@ -44,7 +44,7 @@ md.timestepping.time_step=10; md.cluster=generic('name',oshostname(),'np',3); -md=SetMLHOBC(md); +md=SetMOLHOBC(md); md=solve(md,'Transient'); %Fields and tolerances to track changes Index: ../trunk-jpl/test/NightlyRun/test519.m =================================================================== --- ../trunk-jpl/test/NightlyRun/test519.m (revision 27030) +++ ../trunk-jpl/test/NightlyRun/test519.m (revision 27031) @@ -1,14 +1,14 @@ -%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; [md.mesh.lat,md.mesh.long] = xy2ll(md.mesh.x,md.mesh.y,-1); 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'); %Fields and tolerances to track changes Index: ../trunk-jpl/test/NightlyRun/test811.m =================================================================== --- ../trunk-jpl/test/NightlyRun/test811.m (revision 27030) +++ ../trunk-jpl/test/NightlyRun/test811.m (revision 27031) @@ -1,8 +1,8 @@ -%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); %Transient @@ -17,7 +17,7 @@ md.frontalforcings.meltingrate=zeros(md.mesh.numberofvertices,1); md.levelset.migration_max = 1e10; -md=SetMLHOBC(md); +md=SetMOLHOBC(md); md=solve(md,'Transient'); %Fields and tolerances to track changes