Index: /issm/trunk-jpl/src/c/Makefile.am =================================================================== --- /issm/trunk-jpl/src/c/Makefile.am (revision 20662) +++ /issm/trunk-jpl/src/c/Makefile.am (revision 20663) @@ -61,5 +61,5 @@ ./classes/Materials/Materials.cpp\ ./classes/Materials/Matice.cpp\ - ./classes/Materials/Matbafl.cpp\ + ./classes/Materials/Matearl.cpp\ ./classes/Materials/Matpar.cpp\ ./classes/Constraints/Constraints.cpp\ Index: /issm/trunk-jpl/src/c/classes/Elements/Penta.cpp =================================================================== --- /issm/trunk-jpl/src/c/classes/Elements/Penta.cpp (revision 20662) +++ /issm/trunk-jpl/src/c/classes/Elements/Penta.cpp (revision 20663) @@ -2257,5 +2257,5 @@ if(this->material->IsDamage())this->InputDepthAverageAtBase(DamageDEnum,DamageDbarEnum); break; - case MatbaflEnum: + case MatearlEnum: this->InputDepthAverageAtBase(MaterialsRheologyKoEnum,MaterialsRheologyKobarEnum); this->InputDepthAverageAtBase(MaterialsRheologyEcEnum,MaterialsRheologyEcbarEnum); @@ -2275,5 +2275,5 @@ this->inputs->DeleteInput(DamageDbarEnum); break; - case MatbaflEnum: + case MatearlEnum: break; default: Index: sm/trunk-jpl/src/c/classes/Materials/Matbafl.cpp =================================================================== --- /issm/trunk-jpl/src/c/classes/Materials/Matbafl.cpp (revision 20662) +++ (revision ) @@ -1,509 +1,0 @@ -/*!\file Matbafl.c - * \brief: implementation of the Matbafl object - */ - -#ifdef HAVE_CONFIG_H - #include -#else -#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!" -#endif - -#include "./Matbafl.h" -#include "./Materials.h" -#include "../Inputs/Input.h" -#include "../Inputs/Inputs.h" -#include "../Inputs/TriaInput.h" -#include "../Inputs/PentaInput.h" -#include "../Inputs/ControlInput.h" -#include "../Elements/Element.h" -#include "../Elements/Tria.h" -#include "../Elements/Penta.h" -#include "../Params/Parameters.h" -#include "../Vertex.h" -#include "../Hook.h" -#include "../Node.h" -#include "../IoModel.h" -#include "../../shared/shared.h" - -/*Matbafl constructors and destructor*/ -Matbafl::Matbafl(){/*{{{*/ - this->helement=NULL; - this->element=NULL; - return; -} -/*}}}*/ -Matbafl::Matbafl(int matbafl_mid,int index, IoModel* iomodel){/*{{{*/ - - /*Intermediaries:*/ - int matbafl_eid; - - /*Initialize id*/ - this->mid=matbafl_mid; - - /*Hooks: */ - matbafl_eid=index+1; - this->helement=new Hook(&matbafl_eid,1); - this->element=NULL; - - return; -} -/*}}}*/ -Matbafl::~Matbafl(){/*{{{*/ - delete helement; - return; -} -/*}}}*/ - -/*Object virtual functions definitions:*/ -Object* Matbafl::copy() {/*{{{*/ - - /*Output*/ - Matbafl* matbafl=NULL; - - /*Initialize output*/ - matbafl=new Matbafl(); - - /*copy fields: */ - matbafl->mid=this->mid; - matbafl->helement=(Hook*)this->helement->copy(); - matbafl->element =(Element*)this->helement->delivers(); - - return matbafl; -} -/*}}}*/ -Material* Matbafl::copy2(Element* element_in) {/*{{{*/ - - /*Output*/ - Matbafl* matbafl=NULL; - - /*Initialize output*/ - matbafl=new Matbafl(); - - /*copy fields: */ - matbafl->mid=this->mid; - matbafl->helement=(Hook*)this->helement->copy(); - matbafl->element =element_in; - - return matbafl; -} -/*}}}*/ -void Matbafl::DeepEcho(void){/*{{{*/ - - _printf_("Matbafl:\n"); - _printf_(" mid: " << mid << "\n"); - _printf_(" element:\n"); - helement->Echo(); -} -/*}}}*/ -void Matbafl::Echo(void){/*{{{*/ - - _printf_("Matbafl:\n"); - _printf_(" mid: " << mid << "\n"); - _printf_(" element:\n"); - helement->Echo(); -} -/*}}}*/ -int Matbafl::Id(void){ return mid; }/*{{{*/ -/*}}}*/ -int Matbafl::ObjectEnum(void){/*{{{*/ - - return MatbaflEnum; - -} -/*}}}*/ -void Matbafl::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/ - - if(marshall_direction==MARSHALLING_BACKWARD)helement=new Hook(); - - MARSHALLING_ENUM(MatbaflEnum); - MARSHALLING(mid); - this->helement->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction); - this->element=(Element*)this->helement->delivers(); - -} -/*}}}*/ - -/*Matbafl management*/ -void Matbafl::Configure(Elements* elementsin){/*{{{*/ - - /*Take care of hooking up all objects for this element, ie links the objects in the hooks to their respective - * datasets, using internal ids and offsets hidden in hooks: */ - helement->configure((DataSet*)elementsin); - this->element = (Element*)helement->delivers(); -} -/*}}}*/ -void Matbafl::SetCurrentConfiguration(Elements* elementsin,Loads* loadsin,Nodes* nodesin,Vertices* verticesin,Materials* materialsin,Parameters* parametersin){/*{{{*/ - -} -/*}}}*/ -IssmDouble Matbafl::GetA(){/*{{{*/ - _error_("not implemented yet"); -} -/*}}}*/ -IssmDouble Matbafl::GetAbar(){/*{{{*/ - _error_("not implemented yet"); -} -/*}}}*/ -IssmDouble Matbafl::GetB(){/*{{{*/ - _error_("not implemented yet"); -} -/*}}}*/ -IssmDouble Matbafl::GetBbar(){/*{{{*/ - - _error_("not implemented yet"); -} -/*}}}*/ -IssmDouble Matbafl::GetN(){/*{{{*/ - _error_("not implemented yet"); -} -/*}}}*/ -IssmDouble Matbafl::GetD(){/*{{{*/ - _error_("not implemented yet"); -} -/*}}}*/ -IssmDouble Matbafl::GetDbar(){/*{{{*/ - - _error_("not implemented yet"); -} -/*}}}*/ -bool Matbafl::IsDamage(){/*{{{*/ - - _error_("not implemented yet"); -} -/*}}}*/ -void Matbafl::GetViscosity(IssmDouble* pviscosity,IssmDouble eps_eff){/*{{{*/ - _error_("not implemented yet"); - /*From a string tensor and a material object, return viscosity, using Glen's flow law. - (1-D) B - viscosity= ------------------------- - 2 eps_eff ^[(n-1)/n] - - where viscosity is the viscotiy, B the flow law parameter , eps_eff is the effective strain rate - and n the flow law exponent. - - If eps_eff = 0 , it means this is the first time SystemMatrices is being run, and we - return 10^14, initial viscosity. - */ - - /*output: */ - IssmDouble viscosity; - - /*Intermediary: */ - IssmDouble B,D=0.,n; - - /*Get B and n*/ - B=GetB(); _assert_(B>0.); - n=GetN(); _assert_(n>0.); - - if (n==1.){ - /*Linear Viscous behavior (Newtonian fluid) viscosity=B/2: */ - viscosity=(1.-D)*B/2.; - } - else{ - - /*if no strain rate, return maximum viscosity*/ - if(eps_eff==0.){ - viscosity = 1.e+14/2.; - //viscosity = B; - //viscosity=2.5*pow(10.,17); - } - - else{ - viscosity=(1.-D)*B/(2.*pow(eps_eff,(n-1.)/n)); - } - } - - /*Checks in debugging mode*/ - if(viscosity<=0) _error_("Negative viscosity"); - - /*Return: */ - *pviscosity=viscosity; -} -/*}}}*/ -void Matbafl::GetViscosity_B(IssmDouble* pdmudB,IssmDouble eps_eff){/*{{{*/ - _error_("not implemented yet"); -} -/*}}}*/ -void Matbafl::GetViscosity_D(IssmDouble* pdmudD,IssmDouble eps_eff){/*{{{*/ - _error_("not implemented yet"); -} -/*}}}*/ -void Matbafl::GetViscosityBar(IssmDouble* pviscosity,IssmDouble eps_eff){/*{{{*/ - _error_("not implemented yet"); -} -/*}}}*/ -void Matbafl::GetViscosityComplement(IssmDouble* pviscosity_complement, IssmDouble* epsilon){/*{{{*/ - _error_("not implemented yet"); -} -/*}}}*/ -void Matbafl::GetViscosityDComplement(IssmDouble* pviscosity_complement, IssmDouble* epsilon){/*{{{*/ - _error_("not implemented yet"); -} -/*}}}*/ -void Matbafl::GetViscosityDerivativeEpsSquare(IssmDouble* pmu_prime, IssmDouble* epsilon){/*{{{*/ - _error_("not implemented yet"); -} -/*}}}*/ -void Matbafl::GetViscosity2dDerivativeEpsSquare(IssmDouble* pmu_prime, IssmDouble* epsilon){/*{{{*/ - _error_("not implemented yet"); -} -/*}}}*/ -void Matbafl::InputUpdateFromVector(IssmDouble* vector, int name, int type){/*{{{*/ - -} -/*}}}*/ -void Matbafl::InputUpdateFromVectorDakota(IssmDouble* vector, int name, int type){/*{{{*/ - -} -/*}}}*/ -void Matbafl::InputUpdateFromMatrixDakota(IssmDouble* matrix, int nrows, int ncols,int name, int type){/*{{{*/ - /*Nothing updated yet*/ -} -/*}}}*/ -void Matbafl::InputUpdateFromConstant(IssmDouble constant, int name){/*{{{*/ - /*Nothing updated yet*/ -} -/*}}}*/ -void Matbafl::InputUpdateFromConstant(int constant, int name){/*{{{*/ - /*Nothing updated yet*/ -} -/*}}}*/ -void Matbafl::InputUpdateFromConstant(bool constant, int name){/*{{{*/ - /*Nothing updated yet*/ -} -/*}}}*/ -void Matbafl::ViscosityFS(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input){/*{{{*/ - - /*Intermediaries*/ - IssmDouble vx,vy,vz; - IssmDouble dvx[3],dvy[3],dvz[3]; - IssmDouble ko,Ec,Es; - - /*Get velocity derivatives in all directions*/ - _assert_(dim>1); - _assert_(vx_input); - vx_input->GetInputValue(&vx,gauss); - vx_input->GetInputDerivativeValue(&dvx[0],xyz_list,gauss); - _assert_(vy_input); - vy_input->GetInputValue(&vy,gauss); - vy_input->GetInputDerivativeValue(&dvy[0],xyz_list,gauss); - if(dim==3){ - _assert_(vz_input); - vz_input->GetInputValue(&vz,gauss); - vz_input->GetInputDerivativeValue(&dvz[0],xyz_list,gauss); - } - else{ - vz = 0.; - dvz[0] = 0.; dvz[1] = 0.; dvz[2] = 0.; - } - - /*Get enhancement factors and ko*/ - Input* ec_input = element->inputs->GetInput(MaterialsRheologyEcEnum); _assert_(ec_input); - Input* es_input = element->inputs->GetInput(MaterialsRheologyEsEnum); _assert_(es_input); - Input* ko_input = element->inputs->GetInput(MaterialsRheologyKoEnum); _assert_(ko_input); - ec_input->GetInputValue(&Ec,gauss); - es_input->GetInputValue(&Es,gauss); - ko_input->GetInputValue(&ko,gauss); - - /*Compute viscosity*/ - *pviscosity=GetViscosityGeneral(ko,Ec,Es,vx,vy,vz,&dvx[0],&dvy[0],&dvz[0]); -} -/*}}}*/ -void Matbafl::ViscosityFSDerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon){/*{{{*/ - this->GetViscosityDerivativeEpsSquare(pmu_prime,epsilon); -}/*}}}*/ -void Matbafl::ViscosityHO(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input){/*{{{*/ - - /*Intermediaries*/ - IssmDouble vx,vy,vz; - IssmDouble dvx[3],dvy[3],dvz[3]; - IssmDouble ko,Ec,Es; - - /*Get velocity derivatives in all directions*/ - _assert_(dim==2 || dim==3); - _assert_(vx_input); - vx_input->GetInputValue(&vx,gauss); - vx_input->GetInputDerivativeValue(&dvx[0],xyz_list,gauss); - if(dim==3){ - _assert_(vy_input); - vy_input->GetInputValue(&vy,gauss); - vy_input->GetInputDerivativeValue(&dvy[0],xyz_list,gauss); - } - else{ - dvx[2] = 0.; - vy = 0.; - dvy[0] = 0.; dvy[1] = 0.; dvy[2] = 0.; - } - vz = 0.; - dvz[0] = 0.; dvz[1] = 0.; dvz[2] = -dvx[0]-dvy[1]; - - /*Get enhancement factors and ko*/ - Input* ec_input = element->inputs->GetInput(MaterialsRheologyEcEnum); _assert_(ec_input); - Input* es_input = element->inputs->GetInput(MaterialsRheologyEsEnum); _assert_(es_input); - Input* ko_input = element->inputs->GetInput(MaterialsRheologyKoEnum); _assert_(ko_input); - ec_input->GetInputValue(&Ec,gauss); - es_input->GetInputValue(&Es,gauss); - ko_input->GetInputValue(&ko,gauss); - - /*Compute viscosity*/ - *pviscosity=GetViscosityGeneral(ko,Ec,Es,vx,vy,vz,&dvx[0],&dvy[0],&dvz[0]); -}/*}}}*/ -void Matbafl::ViscosityHODerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon){/*{{{*/ - _error_("not implemented yet"); -}/*}}}*/ -void Matbafl::ViscosityL1L2(IssmDouble* pviscosity,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* surface_input){/*{{{*/ - _error_("not implemented yet"); -}/*}}}*/ -void Matbafl::ViscositySSA(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input){/*{{{*/ - /*Intermediaries*/ - IssmDouble vx,vy,vz; - IssmDouble dvx[3],dvy[3],dvz[3]; - IssmDouble ko,Ec,Es; - - /*Get velocity derivatives in all directions*/ - _assert_(dim==1 || dim==2); - _assert_(vx_input); - vx_input->GetInputValue(&vx,gauss); - vx_input->GetInputDerivativeValue(&dvx[0],xyz_list,gauss); - if(dim==2){ - _assert_(vy_input); - vy_input->GetInputValue(&vy,gauss); - vy_input->GetInputDerivativeValue(&dvy[0],xyz_list,gauss); - } - else{ - dvx[1] = 0.; - dvx[2] = 0.; - vy = 0.; - dvy[0] = 0.; dvy[1] = 0.; dvy[2] = 0.; - } - vz = 0.; - dvz[0] = 0.; dvz[1] = 0.; dvz[2] = -dvx[0]-dvy[1]; - - /*Get enhancement factors and ko*/ - Input* ec_input = element->inputs->GetInput(MaterialsRheologyEcbarEnum); _assert_(ec_input); - Input* es_input = element->inputs->GetInput(MaterialsRheologyEsbarEnum); _assert_(es_input); - Input* ko_input = element->inputs->GetInput(MaterialsRheologyKobarEnum); _assert_(ko_input); - ec_input->GetInputValue(&Ec,gauss); - es_input->GetInputValue(&Es,gauss); - ko_input->GetInputValue(&ko,gauss); - - /*Compute viscosity*/ - *pviscosity=GetViscosityGeneral(ko,Ec,Es,vx,vy,vz,&dvx[0],&dvy[0],&dvz[0]); -}/*}}}*/ -void Matbafl::ViscositySSADerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon){/*{{{*/ - _error_("not implemented yet"); -}/*}}}*/ -void Matbafl::ResetHooks(){/*{{{*/ - - this->element=NULL; - - /*Get Element type*/ - this->helement->reset(); - -} -/*}}}*/ -IssmDouble Matbafl::GetViscosityGeneral(IssmDouble ko,IssmDouble Ec, IssmDouble Es,IssmDouble vx,IssmDouble vy,IssmDouble vz,IssmDouble* dvx,IssmDouble* dvy,IssmDouble* dvz){/*{{{*/ - - /*Intermediaries*/ - IssmDouble viscosity; - IssmDouble vorticity[3],vorticity_norm; - IssmDouble nrsp[3],nrsp_norm; - IssmDouble eps[3][3],epso; - IssmDouble epsprime[3],epsprime_norm; - IssmDouble E,lambdas; - - /*Create vorticity vector*/ - _assert_(dvx && dvy && dvz); - vorticity[0] = dvz[1] - dvy[2]; - vorticity[1] = dvx[2] - dvz[0]; - vorticity[2] = dvy[0] - dvx[1]; - - /*Normalize*/ - vorticity_norm = sqrt(vorticity[0]*vorticity[0] + vorticity[1]*vorticity[1] + vorticity[2]*vorticity[2]); - if(vorticity_norm==0){ - vorticity[0] = 0.; - vorticity[1] = 0.; - vorticity[2] = 1.; - } - else{ - vorticity[0] =vorticity[0]/vorticity_norm; - vorticity[1] =vorticity[1]/vorticity_norm; - vorticity[2] =vorticity[2]/vorticity_norm; - } - - /*Non-rotating shear plane*/ - nrsp[0] = vy*vorticity[2] - vz*vorticity[1]; - nrsp[1] = vz*vorticity[0] - vx*vorticity[2]; - nrsp[2] = vx*vorticity[1] - vy*vorticity[0]; - - /*Normalize*/ - nrsp_norm = sqrt(nrsp[0]*nrsp[0] + nrsp[1]*nrsp[1] + nrsp[2]*nrsp[2]); - if(nrsp_norm==0){ - nrsp[0] = 0.; - nrsp[1] = 0.; - nrsp[2] = 1.; - } - else{ - nrsp[0] =nrsp[0]/nrsp_norm; - nrsp[1] =nrsp[1]/nrsp_norm; - nrsp[2] =nrsp[2]/nrsp_norm; - } - - /*Build strain rate tensor*/ - eps[0][0] = dvx[0]; eps[0][1] = .5*(dvx[1]+dvy[0]); eps[0][2] = .5*(dvx[2]+dvz[0]); - eps[1][0] = .5*(dvx[1]+dvy[0]); eps[1][1] = dvy[1]; eps[1][2] = .5*(dvy[2]+dvz[1]); - eps[2][0] = .5*(dvx[2]+dvz[0]); eps[2][1] = .5*(dvy[2]+dvz[1]); eps[2][2] = dvz[2]; - - /*octahedral strain rate*/ - epso = 0.; - for(int i=0;i<3;i++) for(int j=0;j<3;j++) epso += eps[i][j]*eps[i][j]; - if(epso==0.) epso=1.e-14; - epso=sqrt(epso)/sqrt(3.); - - /*Compute the shear strain rate on the non ratating shear plane*/ - epsprime[0]=0.; - epsprime[1]=0.; - epsprime[2]=0.; - /*term #1: eps'.n */ - for(int i=0;i<3;i++){ - for(int j=0;j<3;j++){ - epsprime[i] += eps[i][j]*nrsp[j]; - } - } - /*term #2: ((eps'.n).n)n */ - for(int i=0;i<3;i++){ - for(int j=0;j<3;j++){ - for(int k=0;k<3;k++){ - epsprime[j] += -nrsp[i]*eps[i][k]*nrsp[k]*nrsp[j]; - } - } - } - /*term #3: ((eps'.n).omega)omega */ - for(int i=0;i<3;i++){ - for(int j=0;j<3;j++){ - for(int k=0;k<3;k++){ - epsprime[j] += -nrsp[i]*eps[i][k]*vorticity[k]*vorticity[j]; - } - } - } - - /*Get norm of epsprime*/ - epsprime_norm = sqrt(epsprime[0]*epsprime[0] + epsprime[1]*epsprime[1] + epsprime[2]*epsprime[2]); - - /*Compute lambda_s*/ - _assert_(epso>0.); - lambdas = sqrt(2*epsprime_norm*epsprime_norm/(3*epso*epso)); - - /*Get total enhancement factor E(lambdas)*/ - E = Ec + (Es-Ec)*lambdas*lambdas; - - /*Compute viscosity*/ - _assert_(E>0.); - _assert_(ko>0.); - _assert_(epso>0.); - viscosity = 1./(2*pow(ko*E*epso*epso,1./3.)); - - /*Assign output pointer*/ - return viscosity; -} -/*}}}*/ Index: sm/trunk-jpl/src/c/classes/Materials/Matbafl.h =================================================================== --- /issm/trunk-jpl/src/c/classes/Materials/Matbafl.h (revision 20662) +++ (revision ) @@ -1,87 +1,0 @@ -/*!\file Matbafl.h - * \brief: header file for matice object - */ - -#ifndef MATBAFL_H_ -#define MATBAFL_H_ - -/*Headers:*/ -/*{{{*/ -#include "./Material.h" -#include "../Hook.h" -class IoModel; -class Elements; -class Element; -class Loads; -class Nodes; -class Vertices; -class Materials; -class Parameters; -class Gauss; -class Input; -/*}}}*/ - -class Matbafl: public Material{ - - private: - int mid; - Hook *helement; - Element *element; - - public: - /*Matbafl constructors, destructors: {{{*/ - Matbafl(); - Matbafl(int mid,int i, IoModel* iomodel); - ~Matbafl(); - /*}}}*/ - /*Object virtual functions definitions:{{{ */ - void Echo(); - void DeepEcho(); - int Id(); - int ObjectEnum(); - Object* copy(); - void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction); - /*}}}*/ - /*Update virtual funictions definitions: {{{*/ - void InputUpdateFromVector(IssmDouble* vector, int name, int type); - void InputUpdateFromMatrixDakota(IssmDouble* matrix, int nrow, int ncols, int name, int type); - void InputUpdateFromVectorDakota(IssmDouble* vector, int name, int type); - void InputUpdateFromConstant(IssmDouble constant, int name); - void InputUpdateFromConstant(int constant, int name); - void InputUpdateFromConstant(bool constant, int name); - void InputUpdateFromIoModel(int index, IoModel* iomodel){_error_("not implemented");}; - /*}}}*/ - /*Material virtual functions resolution: {{{*/ - void Configure(Elements* elements); - Material* copy2(Element* element); - void SetCurrentConfiguration(Elements* elements,Loads* loads,Nodes* nodes,Vertices* vertices,Materials* materials,Parameters* parameters); - void GetViscosity(IssmDouble* pviscosity, IssmDouble eps_eff); - void GetViscosity_B(IssmDouble* pviscosity, IssmDouble eps_eff); - void GetViscosity_D(IssmDouble* pviscosity, IssmDouble eps_eff); - void GetViscosityBar(IssmDouble* pviscosity, IssmDouble eps_eff); - void GetViscosityComplement(IssmDouble* pviscosity_complement, IssmDouble* pepsilon); - void GetViscosityDComplement(IssmDouble*, IssmDouble*); - void GetViscosityDerivativeEpsSquare(IssmDouble* pmu_prime, IssmDouble* pepsilon); - void GetViscosity2dDerivativeEpsSquare(IssmDouble* pmu_prime, IssmDouble* pepsilon); - IssmDouble GetA(); - IssmDouble GetAbar(); - IssmDouble GetB(); - IssmDouble GetBbar(); - IssmDouble GetD(); - IssmDouble GetDbar(); - IssmDouble GetN(); - bool IsDamage(); - void ResetHooks(); - - void ViscosityFS(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input); - void ViscosityFSDerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon); - void ViscosityHO(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input); - void ViscosityHODerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon); - 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 ViscositySSADerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon); - /*}}}*/ - IssmDouble GetViscosityGeneral(IssmDouble ko,IssmDouble Ec, IssmDouble Es,IssmDouble vx,IssmDouble vy,IssmDouble vz,IssmDouble* dvx,IssmDouble* dvy,IssmDouble* dvz); -}; - -#endif /* _MATBAFL_H_ */ Index: /issm/trunk-jpl/src/c/classes/Materials/Matearl.cpp =================================================================== --- /issm/trunk-jpl/src/c/classes/Materials/Matearl.cpp (revision 20663) +++ /issm/trunk-jpl/src/c/classes/Materials/Matearl.cpp (revision 20663) @@ -0,0 +1,509 @@ +/*!\file Matearl.c + * \brief: implementation of the Matearl object + */ + +#ifdef HAVE_CONFIG_H + #include +#else +#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!" +#endif + +#include "./Matearl.h" +#include "./Materials.h" +#include "../Inputs/Input.h" +#include "../Inputs/Inputs.h" +#include "../Inputs/TriaInput.h" +#include "../Inputs/PentaInput.h" +#include "../Inputs/ControlInput.h" +#include "../Elements/Element.h" +#include "../Elements/Tria.h" +#include "../Elements/Penta.h" +#include "../Params/Parameters.h" +#include "../Vertex.h" +#include "../Hook.h" +#include "../Node.h" +#include "../IoModel.h" +#include "../../shared/shared.h" + +/*Matearl constructors and destructor*/ +Matearl::Matearl(){/*{{{*/ + this->helement=NULL; + this->element=NULL; + return; +} +/*}}}*/ +Matearl::Matearl(int matearl_mid,int index, IoModel* iomodel){/*{{{*/ + + /*Intermediaries:*/ + int matearl_eid; + + /*Initialize id*/ + this->mid=matearl_mid; + + /*Hooks: */ + matearl_eid=index+1; + this->helement=new Hook(&matearl_eid,1); + this->element=NULL; + + return; +} +/*}}}*/ +Matearl::~Matearl(){/*{{{*/ + delete helement; + return; +} +/*}}}*/ + +/*Object virtual functions definitions:*/ +Object* Matearl::copy() {/*{{{*/ + + /*Output*/ + Matearl* matearl=NULL; + + /*Initialize output*/ + matearl=new Matearl(); + + /*copy fields: */ + matearl->mid=this->mid; + matearl->helement=(Hook*)this->helement->copy(); + matearl->element =(Element*)this->helement->delivers(); + + return matearl; +} +/*}}}*/ +Material* Matearl::copy2(Element* element_in) {/*{{{*/ + + /*Output*/ + Matearl* matearl=NULL; + + /*Initialize output*/ + matearl=new Matearl(); + + /*copy fields: */ + matearl->mid=this->mid; + matearl->helement=(Hook*)this->helement->copy(); + matearl->element =element_in; + + return matearl; +} +/*}}}*/ +void Matearl::DeepEcho(void){/*{{{*/ + + _printf_("Matearl:\n"); + _printf_(" mid: " << mid << "\n"); + _printf_(" element:\n"); + helement->Echo(); +} +/*}}}*/ +void Matearl::Echo(void){/*{{{*/ + + _printf_("Matearl:\n"); + _printf_(" mid: " << mid << "\n"); + _printf_(" element:\n"); + helement->Echo(); +} +/*}}}*/ +int Matearl::Id(void){ return mid; }/*{{{*/ +/*}}}*/ +int Matearl::ObjectEnum(void){/*{{{*/ + + return MatearlEnum; + +} +/*}}}*/ +void Matearl::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/ + + if(marshall_direction==MARSHALLING_BACKWARD)helement=new Hook(); + + MARSHALLING_ENUM(MatearlEnum); + MARSHALLING(mid); + this->helement->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction); + this->element=(Element*)this->helement->delivers(); + +} +/*}}}*/ + +/*Matearl management*/ +void Matearl::Configure(Elements* elementsin){/*{{{*/ + + /*Take care of hooking up all objects for this element, ie links the objects in the hooks to their respective + * datasets, using internal ids and offsets hidden in hooks: */ + helement->configure((DataSet*)elementsin); + this->element = (Element*)helement->delivers(); +} +/*}}}*/ +void Matearl::SetCurrentConfiguration(Elements* elementsin,Loads* loadsin,Nodes* nodesin,Vertices* verticesin,Materials* materialsin,Parameters* parametersin){/*{{{*/ + +} +/*}}}*/ +IssmDouble Matearl::GetA(){/*{{{*/ + _error_("not implemented yet"); +} +/*}}}*/ +IssmDouble Matearl::GetAbar(){/*{{{*/ + _error_("not implemented yet"); +} +/*}}}*/ +IssmDouble Matearl::GetB(){/*{{{*/ + _error_("not implemented yet"); +} +/*}}}*/ +IssmDouble Matearl::GetBbar(){/*{{{*/ + + _error_("not implemented yet"); +} +/*}}}*/ +IssmDouble Matearl::GetN(){/*{{{*/ + _error_("not implemented yet"); +} +/*}}}*/ +IssmDouble Matearl::GetD(){/*{{{*/ + _error_("not implemented yet"); +} +/*}}}*/ +IssmDouble Matearl::GetDbar(){/*{{{*/ + + _error_("not implemented yet"); +} +/*}}}*/ +bool Matearl::IsDamage(){/*{{{*/ + + _error_("not implemented yet"); +} +/*}}}*/ +void Matearl::GetViscosity(IssmDouble* pviscosity,IssmDouble eps_eff){/*{{{*/ + _error_("not implemented yet"); + /*From a string tensor and a material object, return viscosity, using Glen's flow law. + (1-D) B + viscosity= ------------------------- + 2 eps_eff ^[(n-1)/n] + + where viscosity is the viscotiy, B the flow law parameter , eps_eff is the effective strain rate + and n the flow law exponent. + + If eps_eff = 0 , it means this is the first time SystemMatrices is being run, and we + return 10^14, initial viscosity. + */ + + /*output: */ + IssmDouble viscosity; + + /*Intermediary: */ + IssmDouble B,D=0.,n; + + /*Get B and n*/ + B=GetB(); _assert_(B>0.); + n=GetN(); _assert_(n>0.); + + if (n==1.){ + /*Linear Viscous behavior (Newtonian fluid) viscosity=B/2: */ + viscosity=(1.-D)*B/2.; + } + else{ + + /*if no strain rate, return maximum viscosity*/ + if(eps_eff==0.){ + viscosity = 1.e+14/2.; + //viscosity = B; + //viscosity=2.5*pow(10.,17); + } + + else{ + viscosity=(1.-D)*B/(2.*pow(eps_eff,(n-1.)/n)); + } + } + + /*Checks in debugging mode*/ + if(viscosity<=0) _error_("Negative viscosity"); + + /*Return: */ + *pviscosity=viscosity; +} +/*}}}*/ +void Matearl::GetViscosity_B(IssmDouble* pdmudB,IssmDouble eps_eff){/*{{{*/ + _error_("not implemented yet"); +} +/*}}}*/ +void Matearl::GetViscosity_D(IssmDouble* pdmudD,IssmDouble eps_eff){/*{{{*/ + _error_("not implemented yet"); +} +/*}}}*/ +void Matearl::GetViscosityBar(IssmDouble* pviscosity,IssmDouble eps_eff){/*{{{*/ + _error_("not implemented yet"); +} +/*}}}*/ +void Matearl::GetViscosityComplement(IssmDouble* pviscosity_complement, IssmDouble* epsilon){/*{{{*/ + _error_("not implemented yet"); +} +/*}}}*/ +void Matearl::GetViscosityDComplement(IssmDouble* pviscosity_complement, IssmDouble* epsilon){/*{{{*/ + _error_("not implemented yet"); +} +/*}}}*/ +void Matearl::GetViscosityDerivativeEpsSquare(IssmDouble* pmu_prime, IssmDouble* epsilon){/*{{{*/ + _error_("not implemented yet"); +} +/*}}}*/ +void Matearl::GetViscosity2dDerivativeEpsSquare(IssmDouble* pmu_prime, IssmDouble* epsilon){/*{{{*/ + _error_("not implemented yet"); +} +/*}}}*/ +void Matearl::InputUpdateFromVector(IssmDouble* vector, int name, int type){/*{{{*/ + +} +/*}}}*/ +void Matearl::InputUpdateFromVectorDakota(IssmDouble* vector, int name, int type){/*{{{*/ + +} +/*}}}*/ +void Matearl::InputUpdateFromMatrixDakota(IssmDouble* matrix, int nrows, int ncols,int name, int type){/*{{{*/ + /*Nothing updated yet*/ +} +/*}}}*/ +void Matearl::InputUpdateFromConstant(IssmDouble constant, int name){/*{{{*/ + /*Nothing updated yet*/ +} +/*}}}*/ +void Matearl::InputUpdateFromConstant(int constant, int name){/*{{{*/ + /*Nothing updated yet*/ +} +/*}}}*/ +void Matearl::InputUpdateFromConstant(bool constant, int name){/*{{{*/ + /*Nothing updated yet*/ +} +/*}}}*/ +void Matearl::ViscosityFS(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input){/*{{{*/ + + /*Intermediaries*/ + IssmDouble vx,vy,vz; + IssmDouble dvx[3],dvy[3],dvz[3]; + IssmDouble ko,Ec,Es; + + /*Get velocity derivatives in all directions*/ + _assert_(dim>1); + _assert_(vx_input); + vx_input->GetInputValue(&vx,gauss); + vx_input->GetInputDerivativeValue(&dvx[0],xyz_list,gauss); + _assert_(vy_input); + vy_input->GetInputValue(&vy,gauss); + vy_input->GetInputDerivativeValue(&dvy[0],xyz_list,gauss); + if(dim==3){ + _assert_(vz_input); + vz_input->GetInputValue(&vz,gauss); + vz_input->GetInputDerivativeValue(&dvz[0],xyz_list,gauss); + } + else{ + vz = 0.; + dvz[0] = 0.; dvz[1] = 0.; dvz[2] = 0.; + } + + /*Get enhancement factors and ko*/ + Input* ec_input = element->inputs->GetInput(MaterialsRheologyEcEnum); _assert_(ec_input); + Input* es_input = element->inputs->GetInput(MaterialsRheologyEsEnum); _assert_(es_input); + Input* ko_input = element->inputs->GetInput(MaterialsRheologyKoEnum); _assert_(ko_input); + ec_input->GetInputValue(&Ec,gauss); + es_input->GetInputValue(&Es,gauss); + ko_input->GetInputValue(&ko,gauss); + + /*Compute viscosity*/ + *pviscosity=GetViscosityGeneral(ko,Ec,Es,vx,vy,vz,&dvx[0],&dvy[0],&dvz[0]); +} +/*}}}*/ +void Matearl::ViscosityFSDerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon){/*{{{*/ + this->GetViscosityDerivativeEpsSquare(pmu_prime,epsilon); +}/*}}}*/ +void Matearl::ViscosityHO(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input){/*{{{*/ + + /*Intermediaries*/ + IssmDouble vx,vy,vz; + IssmDouble dvx[3],dvy[3],dvz[3]; + IssmDouble ko,Ec,Es; + + /*Get velocity derivatives in all directions*/ + _assert_(dim==2 || dim==3); + _assert_(vx_input); + vx_input->GetInputValue(&vx,gauss); + vx_input->GetInputDerivativeValue(&dvx[0],xyz_list,gauss); + if(dim==3){ + _assert_(vy_input); + vy_input->GetInputValue(&vy,gauss); + vy_input->GetInputDerivativeValue(&dvy[0],xyz_list,gauss); + } + else{ + dvx[2] = 0.; + vy = 0.; + dvy[0] = 0.; dvy[1] = 0.; dvy[2] = 0.; + } + vz = 0.; + dvz[0] = 0.; dvz[1] = 0.; dvz[2] = -dvx[0]-dvy[1]; + + /*Get enhancement factors and ko*/ + Input* ec_input = element->inputs->GetInput(MaterialsRheologyEcEnum); _assert_(ec_input); + Input* es_input = element->inputs->GetInput(MaterialsRheologyEsEnum); _assert_(es_input); + Input* ko_input = element->inputs->GetInput(MaterialsRheologyKoEnum); _assert_(ko_input); + ec_input->GetInputValue(&Ec,gauss); + es_input->GetInputValue(&Es,gauss); + ko_input->GetInputValue(&ko,gauss); + + /*Compute viscosity*/ + *pviscosity=GetViscosityGeneral(ko,Ec,Es,vx,vy,vz,&dvx[0],&dvy[0],&dvz[0]); +}/*}}}*/ +void Matearl::ViscosityHODerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon){/*{{{*/ + _error_("not implemented yet"); +}/*}}}*/ +void Matearl::ViscosityL1L2(IssmDouble* pviscosity,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* surface_input){/*{{{*/ + _error_("not implemented yet"); +}/*}}}*/ +void Matearl::ViscositySSA(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input){/*{{{*/ + /*Intermediaries*/ + IssmDouble vx,vy,vz; + IssmDouble dvx[3],dvy[3],dvz[3]; + IssmDouble ko,Ec,Es; + + /*Get velocity derivatives in all directions*/ + _assert_(dim==1 || dim==2); + _assert_(vx_input); + vx_input->GetInputValue(&vx,gauss); + vx_input->GetInputDerivativeValue(&dvx[0],xyz_list,gauss); + if(dim==2){ + _assert_(vy_input); + vy_input->GetInputValue(&vy,gauss); + vy_input->GetInputDerivativeValue(&dvy[0],xyz_list,gauss); + } + else{ + dvx[1] = 0.; + dvx[2] = 0.; + vy = 0.; + dvy[0] = 0.; dvy[1] = 0.; dvy[2] = 0.; + } + vz = 0.; + dvz[0] = 0.; dvz[1] = 0.; dvz[2] = -dvx[0]-dvy[1]; + + /*Get enhancement factors and ko*/ + Input* ec_input = element->inputs->GetInput(MaterialsRheologyEcbarEnum); _assert_(ec_input); + Input* es_input = element->inputs->GetInput(MaterialsRheologyEsbarEnum); _assert_(es_input); + Input* ko_input = element->inputs->GetInput(MaterialsRheologyKobarEnum); _assert_(ko_input); + ec_input->GetInputValue(&Ec,gauss); + es_input->GetInputValue(&Es,gauss); + ko_input->GetInputValue(&ko,gauss); + + /*Compute viscosity*/ + *pviscosity=GetViscosityGeneral(ko,Ec,Es,vx,vy,vz,&dvx[0],&dvy[0],&dvz[0]); +}/*}}}*/ +void Matearl::ViscositySSADerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon){/*{{{*/ + _error_("not implemented yet"); +}/*}}}*/ +void Matearl::ResetHooks(){/*{{{*/ + + this->element=NULL; + + /*Get Element type*/ + this->helement->reset(); + +} +/*}}}*/ +IssmDouble Matearl::GetViscosityGeneral(IssmDouble ko,IssmDouble Ec, IssmDouble Es,IssmDouble vx,IssmDouble vy,IssmDouble vz,IssmDouble* dvx,IssmDouble* dvy,IssmDouble* dvz){/*{{{*/ + + /*Intermediaries*/ + IssmDouble viscosity; + IssmDouble vorticity[3],vorticity_norm; + IssmDouble nrsp[3],nrsp_norm; + IssmDouble eps[3][3],epso; + IssmDouble epsprime[3],epsprime_norm; + IssmDouble E,lambdas; + + /*Create vorticity vector*/ + _assert_(dvx && dvy && dvz); + vorticity[0] = dvz[1] - dvy[2]; + vorticity[1] = dvx[2] - dvz[0]; + vorticity[2] = dvy[0] - dvx[1]; + + /*Normalize*/ + vorticity_norm = sqrt(vorticity[0]*vorticity[0] + vorticity[1]*vorticity[1] + vorticity[2]*vorticity[2]); + if(vorticity_norm==0){ + vorticity[0] = 0.; + vorticity[1] = 0.; + vorticity[2] = 1.; + } + else{ + vorticity[0] =vorticity[0]/vorticity_norm; + vorticity[1] =vorticity[1]/vorticity_norm; + vorticity[2] =vorticity[2]/vorticity_norm; + } + + /*Non-rotating shear plane*/ + nrsp[0] = vy*vorticity[2] - vz*vorticity[1]; + nrsp[1] = vz*vorticity[0] - vx*vorticity[2]; + nrsp[2] = vx*vorticity[1] - vy*vorticity[0]; + + /*Normalize*/ + nrsp_norm = sqrt(nrsp[0]*nrsp[0] + nrsp[1]*nrsp[1] + nrsp[2]*nrsp[2]); + if(nrsp_norm==0){ + nrsp[0] = 0.; + nrsp[1] = 0.; + nrsp[2] = 1.; + } + else{ + nrsp[0] =nrsp[0]/nrsp_norm; + nrsp[1] =nrsp[1]/nrsp_norm; + nrsp[2] =nrsp[2]/nrsp_norm; + } + + /*Build strain rate tensor*/ + eps[0][0] = dvx[0]; eps[0][1] = .5*(dvx[1]+dvy[0]); eps[0][2] = .5*(dvx[2]+dvz[0]); + eps[1][0] = .5*(dvx[1]+dvy[0]); eps[1][1] = dvy[1]; eps[1][2] = .5*(dvy[2]+dvz[1]); + eps[2][0] = .5*(dvx[2]+dvz[0]); eps[2][1] = .5*(dvy[2]+dvz[1]); eps[2][2] = dvz[2]; + + /*octahedral strain rate*/ + epso = 0.; + for(int i=0;i<3;i++) for(int j=0;j<3;j++) epso += eps[i][j]*eps[i][j]; + if(epso==0.) epso=1.e-14; + epso=sqrt(epso)/sqrt(3.); + + /*Compute the shear strain rate on the non ratating shear plane*/ + epsprime[0]=0.; + epsprime[1]=0.; + epsprime[2]=0.; + /*term #1: eps'.n */ + for(int i=0;i<3;i++){ + for(int j=0;j<3;j++){ + epsprime[i] += eps[i][j]*nrsp[j]; + } + } + /*term #2: ((eps'.n).n)n */ + for(int i=0;i<3;i++){ + for(int j=0;j<3;j++){ + for(int k=0;k<3;k++){ + epsprime[j] += -nrsp[i]*eps[i][k]*nrsp[k]*nrsp[j]; + } + } + } + /*term #3: ((eps'.n).omega)omega */ + for(int i=0;i<3;i++){ + for(int j=0;j<3;j++){ + for(int k=0;k<3;k++){ + epsprime[j] += -nrsp[i]*eps[i][k]*vorticity[k]*vorticity[j]; + } + } + } + + /*Get norm of epsprime*/ + epsprime_norm = sqrt(epsprime[0]*epsprime[0] + epsprime[1]*epsprime[1] + epsprime[2]*epsprime[2]); + + /*Compute lambda_s*/ + _assert_(epso>0.); + lambdas = sqrt(2*epsprime_norm*epsprime_norm/(3*epso*epso)); + + /*Get total enhancement factor E(lambdas)*/ + E = Ec + (Es-Ec)*lambdas*lambdas; + + /*Compute viscosity*/ + _assert_(E>0.); + _assert_(ko>0.); + _assert_(epso>0.); + viscosity = 1./(2*pow(ko*E*epso*epso,1./3.)); + + /*Assign output pointer*/ + return viscosity; +} +/*}}}*/ Index: /issm/trunk-jpl/src/c/classes/Materials/Matearl.h =================================================================== --- /issm/trunk-jpl/src/c/classes/Materials/Matearl.h (revision 20663) +++ /issm/trunk-jpl/src/c/classes/Materials/Matearl.h (revision 20663) @@ -0,0 +1,87 @@ +/*!\file Matearl.h + * \brief: header file for matice object + */ + +#ifndef MATEARL_H_ +#define MATEARL_H_ + +/*Headers:*/ +/*{{{*/ +#include "./Material.h" +#include "../Hook.h" +class IoModel; +class Elements; +class Element; +class Loads; +class Nodes; +class Vertices; +class Materials; +class Parameters; +class Gauss; +class Input; +/*}}}*/ + +class Matearl: public Material{ + + private: + int mid; + Hook *helement; + Element *element; + + public: + /*Matearl constructors, destructors: {{{*/ + Matearl(); + Matearl(int mid,int i, IoModel* iomodel); + ~Matearl(); + /*}}}*/ + /*Object virtual functions definitions:{{{ */ + void Echo(); + void DeepEcho(); + int Id(); + int ObjectEnum(); + Object* copy(); + void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction); + /*}}}*/ + /*Update virtual funictions definitions: {{{*/ + void InputUpdateFromVector(IssmDouble* vector, int name, int type); + void InputUpdateFromMatrixDakota(IssmDouble* matrix, int nrow, int ncols, int name, int type); + void InputUpdateFromVectorDakota(IssmDouble* vector, int name, int type); + void InputUpdateFromConstant(IssmDouble constant, int name); + void InputUpdateFromConstant(int constant, int name); + void InputUpdateFromConstant(bool constant, int name); + void InputUpdateFromIoModel(int index, IoModel* iomodel){_error_("not implemented");}; + /*}}}*/ + /*Material virtual functions resolution: {{{*/ + void Configure(Elements* elements); + Material* copy2(Element* element); + void SetCurrentConfiguration(Elements* elements,Loads* loads,Nodes* nodes,Vertices* vertices,Materials* materials,Parameters* parameters); + void GetViscosity(IssmDouble* pviscosity, IssmDouble eps_eff); + void GetViscosity_B(IssmDouble* pviscosity, IssmDouble eps_eff); + void GetViscosity_D(IssmDouble* pviscosity, IssmDouble eps_eff); + void GetViscosityBar(IssmDouble* pviscosity, IssmDouble eps_eff); + void GetViscosityComplement(IssmDouble* pviscosity_complement, IssmDouble* pepsilon); + void GetViscosityDComplement(IssmDouble*, IssmDouble*); + void GetViscosityDerivativeEpsSquare(IssmDouble* pmu_prime, IssmDouble* pepsilon); + void GetViscosity2dDerivativeEpsSquare(IssmDouble* pmu_prime, IssmDouble* pepsilon); + IssmDouble GetA(); + IssmDouble GetAbar(); + IssmDouble GetB(); + IssmDouble GetBbar(); + IssmDouble GetD(); + IssmDouble GetDbar(); + IssmDouble GetN(); + bool IsDamage(); + void ResetHooks(); + + void ViscosityFS(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input); + void ViscosityFSDerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon); + void ViscosityHO(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input); + void ViscosityHODerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon); + 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 ViscositySSADerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon); + /*}}}*/ + IssmDouble GetViscosityGeneral(IssmDouble ko,IssmDouble Ec, IssmDouble Es,IssmDouble vx,IssmDouble vy,IssmDouble vz,IssmDouble* dvx,IssmDouble* dvy,IssmDouble* dvz); +}; + +#endif /* _MATEARL_H_ */ Index: /issm/trunk-jpl/src/c/classes/Materials/Matpar.cpp =================================================================== --- /issm/trunk-jpl/src/c/classes/Materials/Matpar.cpp (revision 20662) +++ /issm/trunk-jpl/src/c/classes/Materials/Matpar.cpp (revision 20663) @@ -82,5 +82,5 @@ case MaticeEnum: case MatdamageiceEnum: - case MatbaflEnum: + case MatearlEnum: iomodel->FindConstant(&this->rho_ice,MaterialsRhoIceEnum); iomodel->FindConstant(&this->rho_water,MaterialsRhoSeawaterEnum); Index: /issm/trunk-jpl/src/c/classes/classes.h =================================================================== --- /issm/trunk-jpl/src/c/classes/classes.h (revision 20662) +++ /issm/trunk-jpl/src/c/classes/classes.h (revision 20663) @@ -83,5 +83,5 @@ #include "./Materials/Material.h" #include "./Materials/Matice.h" -#include "./Materials/Matbafl.h" +#include "./Materials/Matearl.h" #include "./Materials/Matpar.h" Index: /issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateElementsVerticesAndMaterials.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateElementsVerticesAndMaterials.cpp (revision 20662) +++ /issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateElementsVerticesAndMaterials.cpp (revision 20663) @@ -79,9 +79,9 @@ } break; - case MatbaflEnum: + case MatearlEnum: iomodel->FetchDataToInput(elements,MaterialsRheologyKoEnum); iomodel->FetchDataToInput(elements,MaterialsRheologyEcEnum); iomodel->FetchDataToInput(elements,MaterialsRheologyEsEnum); - for(i=0;inumberofelements;i++) if(iomodel->my_elements[i]) materials->AddObject(new Matbafl(i+1,i,iomodel)); + for(i=0;inumberofelements;i++) if(iomodel->my_elements[i]) materials->AddObject(new Matearl(i+1,i,iomodel)); switch(iomodel->domaindim){ case 2: Index: /issm/trunk-jpl/src/c/shared/Enum/EnumDefinitions.h =================================================================== --- /issm/trunk-jpl/src/c/shared/Enum/EnumDefinitions.h (revision 20662) +++ /issm/trunk-jpl/src/c/shared/Enum/EnumDefinitions.h (revision 20663) @@ -611,5 +611,5 @@ MaticeEnum, MatdamageiceEnum, - MatbaflEnum, + MatearlEnum, MatparEnum, NodeEnum, Index: /issm/trunk-jpl/src/c/shared/Enum/EnumToStringx.cpp =================================================================== --- /issm/trunk-jpl/src/c/shared/Enum/EnumToStringx.cpp (revision 20662) +++ /issm/trunk-jpl/src/c/shared/Enum/EnumToStringx.cpp (revision 20663) @@ -601,5 +601,5 @@ case MaticeEnum : return "Matice"; case MatdamageiceEnum : return "Matdamageice"; - case MatbaflEnum : return "Matbafl"; + case MatearlEnum : return "Matearl"; case MatparEnum : return "Matpar"; case NodeEnum : return "Node"; Index: /issm/trunk-jpl/src/c/shared/Enum/StringToEnumx.cpp =================================================================== --- /issm/trunk-jpl/src/c/shared/Enum/StringToEnumx.cpp (revision 20662) +++ /issm/trunk-jpl/src/c/shared/Enum/StringToEnumx.cpp (revision 20663) @@ -613,5 +613,5 @@ else if (strcmp(name,"Matice")==0) return MaticeEnum; else if (strcmp(name,"Matdamageice")==0) return MatdamageiceEnum; - else if (strcmp(name,"Matbafl")==0) return MatbaflEnum; + else if (strcmp(name,"Matearl")==0) return MatearlEnum; else if (strcmp(name,"Matpar")==0) return MatparEnum; else if (strcmp(name,"Node")==0) return NodeEnum; Index: /issm/trunk-jpl/src/c/shared/FSanalyticals/fsanalyticals.cpp =================================================================== --- /issm/trunk-jpl/src/c/shared/FSanalyticals/fsanalyticals.cpp (revision 20662) +++ /issm/trunk-jpl/src/c/shared/FSanalyticals/fsanalyticals.cpp (revision 20663) @@ -9,5 +9,5 @@ * case 6: 3d test with sinusoidal functions, non homogeneous Dirichlet conditions * - * case 201: 3d test quadratic functions, BAFL flow law + * case 201: 3d test quadratic functions, EARL flow law */ Index: sm/trunk-jpl/src/m/classes/matbafl.m =================================================================== --- /issm/trunk-jpl/src/m/classes/matbafl.m (revision 20662) +++ (revision ) @@ -1,209 +1,0 @@ -%MATICE class definition -% -% Usage: -% matbafl=matbafl(); - -classdef matbafl - properties (SetAccess=public) - rho_ice = 0.; - rho_water = 0.; - rho_freshwater = 0.; - mu_water = 0.; - heatcapacity = 0.; - latentheat = 0.; - thermalconductivity = 0.; - temperateiceconductivity = 0.; - meltingpoint = 0.; - beta = 0.; - mixed_layer_capacity = 0.; - thermal_exchange_velocity = 0.; - rheology_ko = NaN; - rheology_Ec = NaN; - rheology_Es = NaN; - rheology_law = ''; - - %gia: - lithosphere_shear_modulus = 0.; - lithosphere_density = 0.; - mantle_shear_modulus = 0.; - mantle_density = 0.; - - %slr - earth_density = 0; - - end - methods - function self = extrude(self,md) % {{{ - self.rheology_ko=project3d(md,'vector',self.rheology_ko,'type','node'); - self.rheology_Ec=project3d(md,'vector',self.rheology_Ec,'type','node'); - self.rheology_Es=project3d(md,'vector',self.rheology_Es,'type','node'); - end % }}} - function self = matbafl(varargin) % {{{ - switch nargin - case 0 - self=setdefaultparameters(self); - case 1 - inputstruct=varargin{1}; - list1 = properties('matbafl'); - list2 = fieldnames(inputstruct); - for i=1:length(list1) - fieldname = list1{i}; - if ismember(fieldname,list2), - self.(fieldname) = inputstruct.(fieldname); - end - end - otherwise - error('constructor not supported'); - end - end % }}} - function self = setdefaultparameters(self) % {{{ - - %ice density (kg/m^3) - self.rho_ice=917.; - - %ocean water density (kg/m^3) - self.rho_water=1023.; - - %fresh water density (kg/m^3) - self.rho_freshwater=1000.; - - %water viscosity (N.s/m^2) - self.mu_water=0.001787; - - %ice heat capacity cp (J/kg/K) - self.heatcapacity=2093.; - - %ice latent heat of fusion L (J/kg) - self.latentheat=3.34*10^5; - - %ice thermal conductivity (W/m/K) - self.thermalconductivity=2.4; - - %wet ice thermal conductivity (W/m/K) - self.temperateiceconductivity=.24; - - %the melting point of ice at 1 atmosphere of pressure in K - self.meltingpoint=273.15; - - %rate of change of melting point with pressure (K/Pa) - self.beta=9.8*10^-8; - - %mixed layer (ice-water interface) heat capacity (J/kg/K) - self.mixed_layer_capacity=3974.; - - %thermal exchange velocity (ice-water interface) (m/s) - self.thermal_exchange_velocity=1.00*10^-4; - - %Rheology law: what is the temperature dependence of B with T - %available: none, paterson and arrhenius - self.rheology_law='Paterson'; - - % GIA: - self.lithosphere_shear_modulus = 6.7*10^10; % (Pa) - self.lithosphere_density = 3.32; % (g/cm^-3) - self.mantle_shear_modulus = 1.45*10^11; % (Pa) - self.mantle_density = 3.34; % (g/cm^-3) - - %SLR - self.earth_density= 5512; % average density of the Earth, (kg/m^3) - - end % }}} - function md = checkconsistency(self,md,solution,analyses) % {{{ - md = checkfield(md,'fieldname','materials.rho_ice','>',0); - md = checkfield(md,'fieldname','materials.rho_water','>',0); - md = checkfield(md,'fieldname','materials.rho_freshwater','>',0); - md = checkfield(md,'fieldname','materials.mu_water','>',0); - md = checkfield(md,'fieldname','materials.rheology_ko','>',0,'size',[md.mesh.numberofvertices 1],'NaN',1,'Inf',1); - md = checkfield(md,'fieldname','materials.rheology_Ec','>',0,'size',[md.mesh.numberofvertices 1],'NaN',1,'Inf',1); - md = checkfield(md,'fieldname','materials.rheology_Es','>',0,'size',[md.mesh.numberofvertices 1],'NaN',1,'Inf',1); - md = checkfield(md,'fieldname','materials.rheology_law','values',{'None' 'Cuffey' 'CuffeyTemperate' 'Paterson' 'Arrhenius' 'LliboutryDuval'}); - - if ismember(GiaAnalysisEnum(),analyses), - md = checkfield(md,'fieldname','materials.lithosphere_shear_modulus','>',0,'numel',1); - md = checkfield(md,'fieldname','materials.lithosphere_density','>',0,'numel',1); - md = checkfield(md,'fieldname','materials.mantle_shear_modulus','>',0,'numel',1); - md = checkfield(md,'fieldname','materials.mantle_density','>',0,'numel',1); - end - if ismember(SealevelriseAnalysisEnum(),analyses), - md = checkfield(md,'fieldname','materials.earth_density','>',0,'numel',1); - end - - end % }}} - function disp(self) % {{{ - disp(sprintf(' Materials:')); - - fielddisplay(self,'rho_ice','ice density [kg/m^3]'); - fielddisplay(self,'rho_water','ocean water density [kg/m^3]'); - fielddisplay(self,'rho_freshwater','fresh water density [kg/m^3]'); - fielddisplay(self,'mu_water','water viscosity [N s/m^2]'); - fielddisplay(self,'heatcapacity','heat capacity [J/kg/K]'); - fielddisplay(self,'thermalconductivity',['ice thermal conductivity [W/m/K]']); - fielddisplay(self,'temperateiceconductivity','temperate ice thermal conductivity [W/m/K]'); - fielddisplay(self,'meltingpoint','melting point of ice at 1atm in K'); - fielddisplay(self,'latentheat','latent heat of fusion [J/kg]'); - fielddisplay(self,'beta','rate of change of melting point with pressure [K/Pa]'); - fielddisplay(self,'mixed_layer_capacity','mixed layer capacity [W/kg/K]'); - fielddisplay(self,'thermal_exchange_velocity','thermal exchange velocity [m/s]'); - fielddisplay(self,'rheology_ko','octahedral flow law parameter [s^-1 Pa^-2]'); - fielddisplay(self,'rheology_Ec','compressive enhancement factor'); - fielddisplay(self,'rheology_Es','shear enhancement factor'); - fielddisplay(self,'rheology_law',['law for the temperature dependance of the rheology: ''None'', ''Cuffey'', ''CuffeyTemperate'', ''Paterson'', ''Arrhenius'' or ''LliboutryDuval''']); - fielddisplay(self,'lithosphere_shear_modulus','Lithosphere shear modulus [Pa]'); - fielddisplay(self,'lithosphere_density','Lithosphere density [g/cm^-3]'); - fielddisplay(self,'mantle_shear_modulus','Mantle shear modulus [Pa]'); - fielddisplay(self,'mantle_density','Mantle density [g/cm^-3]'); - fielddisplay(self,'earth_density','Mantle density [kg/m^-3]'); - end % }}} - function marshall(self,md,fid) % {{{ - WriteData(fid,'enum',MaterialsEnum(),'data',MatbaflEnum(),'format','Integer'); - WriteData(fid,'object',self,'class','materials','fieldname','rho_ice','format','Double'); - WriteData(fid,'object',self,'class','materials','fieldname','rho_water','enum',MaterialsRhoSeawaterEnum(),'format','Double'); - WriteData(fid,'object',self,'class','materials','fieldname','rho_freshwater','format','Double'); - WriteData(fid,'object',self,'class','materials','fieldname','mu_water','format','Double'); - WriteData(fid,'object',self,'class','materials','fieldname','heatcapacity','format','Double'); - WriteData(fid,'object',self,'class','materials','fieldname','latentheat','format','Double'); - WriteData(fid,'object',self,'class','materials','fieldname','thermalconductivity','format','Double'); - WriteData(fid,'object',self,'class','materials','fieldname','temperateiceconductivity','format','Double'); - WriteData(fid,'object',self,'class','materials','fieldname','meltingpoint','format','Double'); - WriteData(fid,'object',self,'class','materials','fieldname','beta','format','Double'); - WriteData(fid,'object',self,'class','materials','fieldname','mixed_layer_capacity','format','Double'); - WriteData(fid,'object',self,'class','materials','fieldname','thermal_exchange_velocity','format','Double'); - WriteData(fid,'object',self,'class','materials','fieldname','rheology_ko','format','DoubleMat','mattype',1); - WriteData(fid,'object',self,'class','materials','fieldname','rheology_Ec','format','DoubleMat','mattype',1); - WriteData(fid,'object',self,'class','materials','fieldname','rheology_Es','format','DoubleMat','mattype',1); - WriteData(fid,'data',StringToEnum(self.rheology_law),'enum',MaterialsRheologyLawEnum(),'format','Integer'); - - WriteData(fid,'object',self,'class','materials','fieldname','lithosphere_shear_modulus','format','Double'); - WriteData(fid,'object',self,'class','materials','fieldname','lithosphere_density','format','Double','scale',10^3); - WriteData(fid,'object',self,'class','materials','fieldname','mantle_shear_modulus','format','Double'); - WriteData(fid,'object',self,'class','materials','fieldname','mantle_density','format','Double','scale',10^3); - WriteData(fid,'object',self,'class','materials','fieldname','earth_density','format','Double'); - end % }}} - function savemodeljs(self,fid,modelname) % {{{ - - writejsdouble(fid,[modelname '.materials.rho_ice'],self.rho_ice); - writejsdouble(fid,[modelname '.materials.rho_water'],self.rho_water); - writejsdouble(fid,[modelname '.materials.rho_freshwater'],self.rho_freshwater); - writejsdouble(fid,[modelname '.materials.mu_water'],self.mu_water); - writejsdouble(fid,[modelname '.materials.heatcapacity'],self.heatcapacity); - writejsdouble(fid,[modelname '.materials.latentheat'],self.latentheat); - writejsdouble(fid,[modelname '.materials.thermalconductivity'],self.thermalconductivity); - writejsdouble(fid,[modelname '.materials.temperateiceconductivity'],self.temperateiceconductivity); - writejsdouble(fid,[modelname '.materials.meltingpoint'],self.meltingpoint); - writejsdouble(fid,[modelname '.materials.beta'],self.beta); - writejsdouble(fid,[modelname '.materials.mixed_layer_capacity'],self.mixed_layer_capacity); - writejsdouble(fid,[modelname '.materials.thermal_exchange_velocity'],self.thermal_exchange_velocity); - writejsdouble(fid,[modelname '.materials.mixed_layer_capacity'],self.mixed_layer_capacity); - writejs1Darray(fid,[modelname '.materials.rheology_ko'],self.rheology_ko); - writejs1Darray(fid,[modelname '.materials.rheology_Ec'],self.rheology_Ec); - writejs1Darray(fid,[modelname '.materials.rheology_Es'],self.rheology_Es); - writejsstring(fid,[modelname '.materials.rheology_law'],self.rheology_law); - writejsdouble(fid,[modelname '.materials.lithosphere_shear_modulus'],self.lithosphere_shear_modulus); - writejsdouble(fid,[modelname '.materials.lithosphere_density'],self.lithosphere_density); - writejsdouble(fid,[modelname '.materials.mantle_shear_modulus'],self.mantle_shear_modulus); - writejsdouble(fid,[modelname '.materials.mantle_density'],self.mantle_density); - writejsdouble(fid,[modelname '.materials.earth_density'],self.earth_density); - - end % }}} - end -end Index: /issm/trunk-jpl/src/m/classes/matearl.m =================================================================== --- /issm/trunk-jpl/src/m/classes/matearl.m (revision 20663) +++ /issm/trunk-jpl/src/m/classes/matearl.m (revision 20663) @@ -0,0 +1,209 @@ +%MATICE class definition +% +% Usage: +% matearl=matearl(); + +classdef matearl + properties (SetAccess=public) + rho_ice = 0.; + rho_water = 0.; + rho_freshwater = 0.; + mu_water = 0.; + heatcapacity = 0.; + latentheat = 0.; + thermalconductivity = 0.; + temperateiceconductivity = 0.; + meltingpoint = 0.; + beta = 0.; + mixed_layer_capacity = 0.; + thermal_exchange_velocity = 0.; + rheology_ko = NaN; + rheology_Ec = NaN; + rheology_Es = NaN; + rheology_law = ''; + + %gia: + lithosphere_shear_modulus = 0.; + lithosphere_density = 0.; + mantle_shear_modulus = 0.; + mantle_density = 0.; + + %slr + earth_density = 0; + + end + methods + function self = extrude(self,md) % {{{ + self.rheology_ko=project3d(md,'vector',self.rheology_ko,'type','node'); + self.rheology_Ec=project3d(md,'vector',self.rheology_Ec,'type','node'); + self.rheology_Es=project3d(md,'vector',self.rheology_Es,'type','node'); + end % }}} + function self = matearl(varargin) % {{{ + switch nargin + case 0 + self=setdefaultparameters(self); + case 1 + inputstruct=varargin{1}; + list1 = properties('matearl'); + list2 = fieldnames(inputstruct); + for i=1:length(list1) + fieldname = list1{i}; + if ismember(fieldname,list2), + self.(fieldname) = inputstruct.(fieldname); + end + end + otherwise + error('constructor not supported'); + end + end % }}} + function self = setdefaultparameters(self) % {{{ + + %ice density (kg/m^3) + self.rho_ice=917.; + + %ocean water density (kg/m^3) + self.rho_water=1023.; + + %fresh water density (kg/m^3) + self.rho_freshwater=1000.; + + %water viscosity (N.s/m^2) + self.mu_water=0.001787; + + %ice heat capacity cp (J/kg/K) + self.heatcapacity=2093.; + + %ice latent heat of fusion L (J/kg) + self.latentheat=3.34*10^5; + + %ice thermal conductivity (W/m/K) + self.thermalconductivity=2.4; + + %wet ice thermal conductivity (W/m/K) + self.temperateiceconductivity=.24; + + %the melting point of ice at 1 atmosphere of pressure in K + self.meltingpoint=273.15; + + %rate of change of melting point with pressure (K/Pa) + self.beta=9.8*10^-8; + + %mixed layer (ice-water interface) heat capacity (J/kg/K) + self.mixed_layer_capacity=3974.; + + %thermal exchange velocity (ice-water interface) (m/s) + self.thermal_exchange_velocity=1.00*10^-4; + + %Rheology law: what is the temperature dependence of B with T + %available: none, paterson and arrhenius + self.rheology_law='Paterson'; + + % GIA: + self.lithosphere_shear_modulus = 6.7*10^10; % (Pa) + self.lithosphere_density = 3.32; % (g/cm^-3) + self.mantle_shear_modulus = 1.45*10^11; % (Pa) + self.mantle_density = 3.34; % (g/cm^-3) + + %SLR + self.earth_density= 5512; % average density of the Earth, (kg/m^3) + + end % }}} + function md = checkconsistency(self,md,solution,analyses) % {{{ + md = checkfield(md,'fieldname','materials.rho_ice','>',0); + md = checkfield(md,'fieldname','materials.rho_water','>',0); + md = checkfield(md,'fieldname','materials.rho_freshwater','>',0); + md = checkfield(md,'fieldname','materials.mu_water','>',0); + md = checkfield(md,'fieldname','materials.rheology_ko','>',0,'size',[md.mesh.numberofvertices 1],'NaN',1,'Inf',1); + md = checkfield(md,'fieldname','materials.rheology_Ec','>',0,'size',[md.mesh.numberofvertices 1],'NaN',1,'Inf',1); + md = checkfield(md,'fieldname','materials.rheology_Es','>',0,'size',[md.mesh.numberofvertices 1],'NaN',1,'Inf',1); + md = checkfield(md,'fieldname','materials.rheology_law','values',{'None' 'Cuffey' 'CuffeyTemperate' 'Paterson' 'Arrhenius' 'LliboutryDuval'}); + + if ismember(GiaAnalysisEnum(),analyses), + md = checkfield(md,'fieldname','materials.lithosphere_shear_modulus','>',0,'numel',1); + md = checkfield(md,'fieldname','materials.lithosphere_density','>',0,'numel',1); + md = checkfield(md,'fieldname','materials.mantle_shear_modulus','>',0,'numel',1); + md = checkfield(md,'fieldname','materials.mantle_density','>',0,'numel',1); + end + if ismember(SealevelriseAnalysisEnum(),analyses), + md = checkfield(md,'fieldname','materials.earth_density','>',0,'numel',1); + end + + end % }}} + function disp(self) % {{{ + disp(sprintf(' Materials:')); + + fielddisplay(self,'rho_ice','ice density [kg/m^3]'); + fielddisplay(self,'rho_water','ocean water density [kg/m^3]'); + fielddisplay(self,'rho_freshwater','fresh water density [kg/m^3]'); + fielddisplay(self,'mu_water','water viscosity [N s/m^2]'); + fielddisplay(self,'heatcapacity','heat capacity [J/kg/K]'); + fielddisplay(self,'thermalconductivity',['ice thermal conductivity [W/m/K]']); + fielddisplay(self,'temperateiceconductivity','temperate ice thermal conductivity [W/m/K]'); + fielddisplay(self,'meltingpoint','melting point of ice at 1atm in K'); + fielddisplay(self,'latentheat','latent heat of fusion [J/kg]'); + fielddisplay(self,'beta','rate of change of melting point with pressure [K/Pa]'); + fielddisplay(self,'mixed_layer_capacity','mixed layer capacity [W/kg/K]'); + fielddisplay(self,'thermal_exchange_velocity','thermal exchange velocity [m/s]'); + fielddisplay(self,'rheology_ko','octahedral flow law parameter [s^-1 Pa^-2]'); + fielddisplay(self,'rheology_Ec','compressive enhancement factor'); + fielddisplay(self,'rheology_Es','shear enhancement factor'); + fielddisplay(self,'rheology_law',['law for the temperature dependance of the rheology: ''None'', ''Cuffey'', ''CuffeyTemperate'', ''Paterson'', ''Arrhenius'' or ''LliboutryDuval''']); + fielddisplay(self,'lithosphere_shear_modulus','Lithosphere shear modulus [Pa]'); + fielddisplay(self,'lithosphere_density','Lithosphere density [g/cm^-3]'); + fielddisplay(self,'mantle_shear_modulus','Mantle shear modulus [Pa]'); + fielddisplay(self,'mantle_density','Mantle density [g/cm^-3]'); + fielddisplay(self,'earth_density','Mantle density [kg/m^-3]'); + end % }}} + function marshall(self,md,fid) % {{{ + WriteData(fid,'enum',MaterialsEnum(),'data',MatearlEnum(),'format','Integer'); + WriteData(fid,'object',self,'class','materials','fieldname','rho_ice','format','Double'); + WriteData(fid,'object',self,'class','materials','fieldname','rho_water','enum',MaterialsRhoSeawaterEnum(),'format','Double'); + WriteData(fid,'object',self,'class','materials','fieldname','rho_freshwater','format','Double'); + WriteData(fid,'object',self,'class','materials','fieldname','mu_water','format','Double'); + WriteData(fid,'object',self,'class','materials','fieldname','heatcapacity','format','Double'); + WriteData(fid,'object',self,'class','materials','fieldname','latentheat','format','Double'); + WriteData(fid,'object',self,'class','materials','fieldname','thermalconductivity','format','Double'); + WriteData(fid,'object',self,'class','materials','fieldname','temperateiceconductivity','format','Double'); + WriteData(fid,'object',self,'class','materials','fieldname','meltingpoint','format','Double'); + WriteData(fid,'object',self,'class','materials','fieldname','beta','format','Double'); + WriteData(fid,'object',self,'class','materials','fieldname','mixed_layer_capacity','format','Double'); + WriteData(fid,'object',self,'class','materials','fieldname','thermal_exchange_velocity','format','Double'); + WriteData(fid,'object',self,'class','materials','fieldname','rheology_ko','format','DoubleMat','mattype',1); + WriteData(fid,'object',self,'class','materials','fieldname','rheology_Ec','format','DoubleMat','mattype',1); + WriteData(fid,'object',self,'class','materials','fieldname','rheology_Es','format','DoubleMat','mattype',1); + WriteData(fid,'data',StringToEnum(self.rheology_law),'enum',MaterialsRheologyLawEnum(),'format','Integer'); + + WriteData(fid,'object',self,'class','materials','fieldname','lithosphere_shear_modulus','format','Double'); + WriteData(fid,'object',self,'class','materials','fieldname','lithosphere_density','format','Double','scale',10^3); + WriteData(fid,'object',self,'class','materials','fieldname','mantle_shear_modulus','format','Double'); + WriteData(fid,'object',self,'class','materials','fieldname','mantle_density','format','Double','scale',10^3); + WriteData(fid,'object',self,'class','materials','fieldname','earth_density','format','Double'); + end % }}} + function savemodeljs(self,fid,modelname) % {{{ + + writejsdouble(fid,[modelname '.materials.rho_ice'],self.rho_ice); + writejsdouble(fid,[modelname '.materials.rho_water'],self.rho_water); + writejsdouble(fid,[modelname '.materials.rho_freshwater'],self.rho_freshwater); + writejsdouble(fid,[modelname '.materials.mu_water'],self.mu_water); + writejsdouble(fid,[modelname '.materials.heatcapacity'],self.heatcapacity); + writejsdouble(fid,[modelname '.materials.latentheat'],self.latentheat); + writejsdouble(fid,[modelname '.materials.thermalconductivity'],self.thermalconductivity); + writejsdouble(fid,[modelname '.materials.temperateiceconductivity'],self.temperateiceconductivity); + writejsdouble(fid,[modelname '.materials.meltingpoint'],self.meltingpoint); + writejsdouble(fid,[modelname '.materials.beta'],self.beta); + writejsdouble(fid,[modelname '.materials.mixed_layer_capacity'],self.mixed_layer_capacity); + writejsdouble(fid,[modelname '.materials.thermal_exchange_velocity'],self.thermal_exchange_velocity); + writejsdouble(fid,[modelname '.materials.mixed_layer_capacity'],self.mixed_layer_capacity); + writejs1Darray(fid,[modelname '.materials.rheology_ko'],self.rheology_ko); + writejs1Darray(fid,[modelname '.materials.rheology_Ec'],self.rheology_Ec); + writejs1Darray(fid,[modelname '.materials.rheology_Es'],self.rheology_Es); + writejsstring(fid,[modelname '.materials.rheology_law'],self.rheology_law); + writejsdouble(fid,[modelname '.materials.lithosphere_shear_modulus'],self.lithosphere_shear_modulus); + writejsdouble(fid,[modelname '.materials.lithosphere_density'],self.lithosphere_density); + writejsdouble(fid,[modelname '.materials.mantle_shear_modulus'],self.mantle_shear_modulus); + writejsdouble(fid,[modelname '.materials.mantle_density'],self.mantle_density); + writejsdouble(fid,[modelname '.materials.earth_density'],self.earth_density); + + end % }}} + end +end Index: /issm/trunk-jpl/src/m/enum/EnumDefinitions.js =================================================================== --- /issm/trunk-jpl/src/m/enum/EnumDefinitions.js (revision 20662) +++ /issm/trunk-jpl/src/m/enum/EnumDefinitions.js (revision 20663) @@ -178,840 +178,842 @@ function HydrologySpcheadEnum(){ return 174;} function HydrologyConductivityEnum(){ return 175;} -function IndependentObjectEnum(){ return 176;} -function InversionControlParametersEnum(){ return 177;} -function InversionControlScalingFactorsEnum(){ return 178;} -function InversionCostFunctionThresholdEnum(){ return 179;} -function InversionCostFunctionsCoefficientsEnum(){ return 180;} -function InversionCostFunctionsEnum(){ return 181;} -function InversionGradientScalingEnum(){ return 182;} -function InversionIscontrolEnum(){ return 183;} -function InversionTypeEnum(){ return 184;} -function InversionIncompleteAdjointEnum(){ return 185;} -function InversionMaxParametersEnum(){ return 186;} -function InversionMaxiterPerStepEnum(){ return 187;} -function InversionMaxiterEnum(){ return 188;} -function InversionMaxstepsEnum(){ return 189;} -function InversionFatolEnum(){ return 190;} -function InversionFrtolEnum(){ return 191;} -function InversionGatolEnum(){ return 192;} -function InversionGrtolEnum(){ return 193;} -function InversionGttolEnum(){ return 194;} -function InversionAlgorithmEnum(){ return 195;} -function InversionMinParametersEnum(){ return 196;} -function InversionNstepsEnum(){ return 197;} -function InversionDxminEnum(){ return 198;} -function InversionNumControlParametersEnum(){ return 199;} -function InversionNumCostFunctionsEnum(){ return 200;} -function InversionStepThresholdEnum(){ return 201;} -function InversionThicknessObsEnum(){ return 202;} -function InversionSurfaceObsEnum(){ return 203;} -function InversionVxObsEnum(){ return 204;} -function InversionVyObsEnum(){ return 205;} -function InversionVzObsEnum(){ return 206;} -function MaskIceLevelsetEnum(){ return 207;} -function MaskOceanLevelsetEnum(){ return 208;} -function MaskLandLevelsetEnum(){ return 209;} -function MaterialsBetaEnum(){ return 210;} -function MaterialsHeatcapacityEnum(){ return 211;} -function MaterialsLatentheatEnum(){ return 212;} -function MaterialsMeltingpointEnum(){ return 213;} -function MaterialsMixedLayerCapacityEnum(){ return 214;} -function MaterialsRheologyBEnum(){ return 215;} -function MaterialsRheologyBbarEnum(){ return 216;} -function MaterialsRheologyLawEnum(){ return 217;} -function MaterialsRheologyNEnum(){ return 218;} -function MaterialsRheologyKoEnum(){ return 219;} +function InversionControlParametersEnum(){ return 176;} +function InversionControlScalingFactorsEnum(){ return 177;} +function InversionCostFunctionThresholdEnum(){ return 178;} +function InversionCostFunctionsCoefficientsEnum(){ return 179;} +function InversionCostFunctionsEnum(){ return 180;} +function InversionGradientScalingEnum(){ return 181;} +function InversionIscontrolEnum(){ return 182;} +function InversionTypeEnum(){ return 183;} +function InversionIncompleteAdjointEnum(){ return 184;} +function InversionMaxParametersEnum(){ return 185;} +function InversionMaxiterPerStepEnum(){ return 186;} +function InversionMaxiterEnum(){ return 187;} +function InversionMaxstepsEnum(){ return 188;} +function InversionFatolEnum(){ return 189;} +function InversionFrtolEnum(){ return 190;} +function InversionGatolEnum(){ return 191;} +function InversionGrtolEnum(){ return 192;} +function InversionGttolEnum(){ return 193;} +function InversionAlgorithmEnum(){ return 194;} +function InversionMinParametersEnum(){ return 195;} +function InversionNstepsEnum(){ return 196;} +function InversionDxminEnum(){ return 197;} +function InversionNumControlParametersEnum(){ return 198;} +function InversionNumCostFunctionsEnum(){ return 199;} +function InversionStepThresholdEnum(){ return 200;} +function InversionThicknessObsEnum(){ return 201;} +function InversionSurfaceObsEnum(){ return 202;} +function InversionVxObsEnum(){ return 203;} +function InversionVyObsEnum(){ return 204;} +function InversionVzObsEnum(){ return 205;} +function MaskIceLevelsetEnum(){ return 206;} +function MaskOceanLevelsetEnum(){ return 207;} +function MaskLandLevelsetEnum(){ return 208;} +function MaterialsBetaEnum(){ return 209;} +function MaterialsHeatcapacityEnum(){ return 210;} +function MaterialsLatentheatEnum(){ return 211;} +function MaterialsMeltingpointEnum(){ return 212;} +function MaterialsMixedLayerCapacityEnum(){ return 213;} +function MaterialsRheologyBEnum(){ return 214;} +function MaterialsRheologyBbarEnum(){ return 215;} +function MaterialsRheologyLawEnum(){ return 216;} +function MaterialsRheologyNEnum(){ return 217;} +function MaterialsRheologyKoEnum(){ return 218;} +function MaterialsRheologyKobarEnum(){ return 219;} function MaterialsRheologyEcEnum(){ return 220;} -function MaterialsRheologyEsEnum(){ return 221;} -function DamageIsdamageEnum(){ return 222;} -function DamageDEnum(){ return 223;} -function DamageFEnum(){ return 224;} -function DamageDbarEnum(){ return 225;} -function DamageLawEnum(){ return 226;} -function DamageC1Enum(){ return 227;} -function DamageC2Enum(){ return 228;} -function DamageC3Enum(){ return 229;} -function DamageC4Enum(){ return 230;} -function DamageElementinterpEnum(){ return 231;} -function DamageHealingEnum(){ return 232;} -function DamageStressThresholdEnum(){ return 233;} -function DamageKappaEnum(){ return 234;} -function DamageStabilizationEnum(){ return 235;} -function DamageMaxiterEnum(){ return 236;} -function DamageSpcdamageEnum(){ return 237;} -function DamageMaxDamageEnum(){ return 238;} -function DamageEquivStressEnum(){ return 239;} -function DamageEvolutionNumRequestedOutputsEnum(){ return 240;} -function DamageEvolutionRequestedOutputsEnum(){ return 241;} -function DamageEnum(){ return 242;} -function NewDamageEnum(){ return 243;} -function StressIntensityFactorEnum(){ return 244;} -function CalvingLawEnum(){ return 245;} -function CalvingCalvingrateEnum(){ return 246;} -function CalvingMeltingrateEnum(){ return 247;} -function CalvingLevermannEnum(){ return 248;} -function CalvingDevEnum(){ return 249;} -function DefaultCalvingEnum(){ return 250;} -function CalvingRequestedOutputsEnum(){ return 251;} -function CalvinglevermannCoeffEnum(){ return 252;} -function CalvinglevermannMeltingrateEnum(){ return 253;} -function CalvingdevCoeffEnum(){ return 254;} -function CalvingratexEnum(){ return 255;} -function CalvingrateyEnum(){ return 256;} -function CalvingratexAverageEnum(){ return 257;} -function CalvingrateyAverageEnum(){ return 258;} -function StrainRateparallelEnum(){ return 259;} -function StrainRateperpendicularEnum(){ return 260;} -function StrainRateeffectiveEnum(){ return 261;} -function MaterialsRhoIceEnum(){ return 262;} -function MaterialsRhoSeawaterEnum(){ return 263;} -function MaterialsRhoFreshwaterEnum(){ return 264;} -function MaterialsMuWaterEnum(){ return 265;} -function MaterialsThermalExchangeVelocityEnum(){ return 266;} -function MaterialsThermalconductivityEnum(){ return 267;} -function MaterialsTemperateiceconductivityEnum(){ return 268;} -function MaterialsLithosphereShearModulusEnum(){ return 269;} -function MaterialsLithosphereDensityEnum(){ return 270;} -function MaterialsMantleShearModulusEnum(){ return 271;} -function MaterialsMantleDensityEnum(){ return 272;} -function MaterialsEarthDensityEnum(){ return 273;} -function MeshAverageVertexConnectivityEnum(){ return 274;} -function MeshElements2dEnum(){ return 275;} -function MeshElementsEnum(){ return 276;} -function MeshLowerelementsEnum(){ return 277;} -function MeshNumberofelements2dEnum(){ return 278;} -function MeshNumberofelementsEnum(){ return 279;} -function MeshNumberoflayersEnum(){ return 280;} -function MeshNumberofvertices2dEnum(){ return 281;} -function MeshNumberofverticesEnum(){ return 282;} -function MeshUpperelementsEnum(){ return 283;} -function MeshVertexonbaseEnum(){ return 284;} -function MeshVertexonsurfaceEnum(){ return 285;} -function MeshVertexonboundaryEnum(){ return 286;} -function MeshXEnum(){ return 287;} -function MeshYEnum(){ return 288;} -function MeshZEnum(){ return 289;} -function MeshLatEnum(){ return 290;} -function MeshLongEnum(){ return 291;} -function MeshREnum(){ return 292;} -function MeshElementtypeEnum(){ return 293;} -function MeshSegmentsEnum(){ return 294;} -function DomainTypeEnum(){ return 295;} -function DomainDimensionEnum(){ return 296;} -function Domain2DhorizontalEnum(){ return 297;} -function Domain2DverticalEnum(){ return 298;} -function Domain3DEnum(){ return 299;} -function Domain3DsurfaceEnum(){ return 300;} -function MiscellaneousNameEnum(){ return 301;} -function MasstransportHydrostaticAdjustmentEnum(){ return 302;} -function MasstransportIsfreesurfaceEnum(){ return 303;} -function MasstransportMinThicknessEnum(){ return 304;} -function MasstransportPenaltyFactorEnum(){ return 305;} -function MasstransportSpcthicknessEnum(){ return 306;} -function MasstransportStabilizationEnum(){ return 307;} -function MasstransportVertexPairingEnum(){ return 308;} -function MasstransportNumRequestedOutputsEnum(){ return 309;} -function MasstransportRequestedOutputsEnum(){ return 310;} -function QmuIsdakotaEnum(){ return 311;} -function MassFluxSegmentsEnum(){ return 312;} -function MassFluxSegmentsPresentEnum(){ return 313;} -function QmuMassFluxSegmentsPresentEnum(){ return 314;} -function QmuNumberofpartitionsEnum(){ return 315;} -function QmuNumberofresponsesEnum(){ return 316;} -function QmuPartitionEnum(){ return 317;} -function QmuResponsedescriptorsEnum(){ return 318;} -function QmuVariabledescriptorsEnum(){ return 319;} -function RiftsNumriftsEnum(){ return 320;} -function RiftsRiftstructEnum(){ return 321;} -function SettingsResultsOnNodesEnum(){ return 322;} -function SettingsIoGatherEnum(){ return 323;} -function SettingsLowmemEnum(){ return 324;} -function SettingsOutputFrequencyEnum(){ return 325;} -function SettingsRecordingFrequencyEnum(){ return 326;} -function SettingsWaitonlockEnum(){ return 327;} -function DebugProfilingEnum(){ return 328;} -function ProfilingCurrentMemEnum(){ return 329;} -function ProfilingCurrentFlopsEnum(){ return 330;} -function ProfilingSolutionTimeEnum(){ return 331;} -function SteadystateMaxiterEnum(){ return 332;} -function SteadystateNumRequestedOutputsEnum(){ return 333;} -function SteadystateReltolEnum(){ return 334;} -function SteadystateRequestedOutputsEnum(){ return 335;} -function SurfaceEnum(){ return 336;} -function ThermalIsenthalpyEnum(){ return 337;} -function ThermalIsdynamicbasalspcEnum(){ return 338;} -function ThermalReltolEnum(){ return 339;} -function ThermalMaxiterEnum(){ return 340;} -function ThermalPenaltyFactorEnum(){ return 341;} -function ThermalPenaltyLockEnum(){ return 342;} -function ThermalPenaltyThresholdEnum(){ return 343;} -function ThermalSpctemperatureEnum(){ return 344;} -function ThermalStabilizationEnum(){ return 345;} -function ThermalNumRequestedOutputsEnum(){ return 346;} -function ThermalRequestedOutputsEnum(){ return 347;} -function GiaMantleViscosityEnum(){ return 348;} -function GiaLithosphereThicknessEnum(){ return 349;} -function ThicknessEnum(){ return 350;} -function TimesteppingStartTimeEnum(){ return 351;} -function TimesteppingFinalTimeEnum(){ return 352;} -function TimesteppingCflCoefficientEnum(){ return 353;} -function TimesteppingTimeAdaptEnum(){ return 354;} -function TimesteppingTimeStepEnum(){ return 355;} -function TimesteppingInterpForcingsEnum(){ return 356;} -function TransientIssmbEnum(){ return 357;} -function TransientIscouplerEnum(){ return 358;} -function TransientIsstressbalanceEnum(){ return 359;} -function TransientIsgroundinglineEnum(){ return 360;} -function TransientIsmasstransportEnum(){ return 361;} -function TransientIsthermalEnum(){ return 362;} -function TransientIsgiaEnum(){ return 363;} -function TransientIsdamageevolutionEnum(){ return 364;} -function TransientIshydrologyEnum(){ return 365;} -function TransientIsmovingfrontEnum(){ return 366;} -function TransientIsslrEnum(){ return 367;} -function TransientNumRequestedOutputsEnum(){ return 368;} -function TransientRequestedOutputsEnum(){ return 369;} -function PotentialEnum(){ return 370;} -function BalancethicknessSpcpotentialEnum(){ return 371;} -function BalancethicknessApparentMassbalanceEnum(){ return 372;} -function Balancethickness2MisfitEnum(){ return 373;} -function BalancethicknessDiffusionCoefficientEnum(){ return 374;} -function BalancethicknessCmuEnum(){ return 375;} -function BalancethicknessOmegaEnum(){ return 376;} -function BalancethicknessD0Enum(){ return 377;} -function SmbEnum(){ return 378;} -function SmbAnalysisEnum(){ return 379;} -function SmbSolutionEnum(){ return 380;} -function SmbNumRequestedOutputsEnum(){ return 381;} -function SmbRequestedOutputsEnum(){ return 382;} -function SmbIsInitializedEnum(){ return 383;} -function SMBforcingEnum(){ return 384;} -function SmbMassBalanceEnum(){ return 385;} -function SMBgembEnum(){ return 386;} -function SmbInitDensityScalingEnum(){ return 387;} -function SmbTaEnum(){ return 388;} -function SmbVEnum(){ return 389;} -function SmbDswrfEnum(){ return 390;} -function SmbDlwrfEnum(){ return 391;} -function SmbPEnum(){ return 392;} -function SmbSwfEnum(){ return 393;} -function SmbEAirEnum(){ return 394;} -function SmbPAirEnum(){ return 395;} -function SmbTmeanEnum(){ return 396;} -function SmbCEnum(){ return 397;} -function SmbTzEnum(){ return 398;} -function SmbVzEnum(){ return 399;} -function SmbDtEnum(){ return 400;} -function SmbDzEnum(){ return 401;} -function SmbAIdxEnum(){ return 402;} -function SmbSwIdxEnum(){ return 403;} -function SmbDenIdxEnum(){ return 404;} -function SmbZTopEnum(){ return 405;} -function SmbDzTopEnum(){ return 406;} -function SmbDzMinEnum(){ return 407;} -function SmbZYEnum(){ return 408;} -function SmbZMaxEnum(){ return 409;} -function SmbZMinEnum(){ return 410;} -function SmbOutputFreqEnum(){ return 411;} -function SmbASnowEnum(){ return 412;} -function SmbAIceEnum(){ return 413;} -function SmbCldFracEnum(){ return 414;} -function SmbT0wetEnum(){ return 415;} -function SmbT0dryEnum(){ return 416;} -function SmbKEnum(){ return 417;} -function SmbDEnum(){ return 418;} -function SmbReEnum(){ return 419;} -function SmbGdnEnum(){ return 420;} -function SmbGspEnum(){ return 421;} -function SmbECEnum(){ return 422;} -function SmbCondensationEnum(){ return 423;} -function SmbWEnum(){ return 424;} -function SmbAEnum(){ return 425;} -function SmbTEnum(){ return 426;} -function SmbIsgraingrowthEnum(){ return 427;} -function SmbIsalbedoEnum(){ return 428;} -function SmbIsshortwaveEnum(){ return 429;} -function SmbIsthermalEnum(){ return 430;} -function SmbIsaccumulationEnum(){ return 431;} -function SmbIsmeltEnum(){ return 432;} -function SmbIsdensificationEnum(){ return 433;} -function SmbIsturbulentfluxEnum(){ return 434;} -function SMBpddEnum(){ return 435;} -function SmbDelta18oEnum(){ return 436;} -function SmbDelta18oSurfaceEnum(){ return 437;} -function SmbIsdelta18oEnum(){ return 438;} -function SmbIsmungsmEnum(){ return 439;} -function SmbIsd18opdEnum(){ return 440;} -function SmbPrecipitationsPresentdayEnum(){ return 441;} -function SmbPrecipitationsLgmEnum(){ return 442;} -function SmbTemperaturesPresentdayEnum(){ return 443;} -function SmbTemperaturesLgmEnum(){ return 444;} -function SmbPrecipitationEnum(){ return 445;} -function SmbDesfacEnum(){ return 446;} -function SmbS0pEnum(){ return 447;} -function SmbS0tEnum(){ return 448;} -function SmbRlapsEnum(){ return 449;} -function SmbRlapslgmEnum(){ return 450;} -function SmbPfacEnum(){ return 451;} -function SmbTdiffEnum(){ return 452;} -function SmbSealevEnum(){ return 453;} -function SMBd18opddEnum(){ return 454;} -function SmbDpermilEnum(){ return 455;} -function SMBgradientsEnum(){ return 456;} -function SmbMonthlytemperaturesEnum(){ return 457;} -function SmbHrefEnum(){ return 458;} -function SmbSmbrefEnum(){ return 459;} -function SmbBPosEnum(){ return 460;} -function SmbBNegEnum(){ return 461;} -function SMBhenningEnum(){ return 462;} -function SMBcomponentsEnum(){ return 463;} -function SmbAccumulationEnum(){ return 464;} -function SmbEvaporationEnum(){ return 465;} -function SmbRunoffEnum(){ return 466;} -function SMBmeltcomponentsEnum(){ return 467;} -function SmbMeltEnum(){ return 468;} -function SmbRefreezeEnum(){ return 469;} -function SMBgcmEnum(){ return 470;} -function SmbIspddEnum(){ return 471;} -function SmbIssmbgradientsEnum(){ return 472;} -function SolutionTypeEnum(){ return 473;} -function AnalysisTypeEnum(){ return 474;} -function ConfigurationTypeEnum(){ return 475;} -function AdjointBalancethicknessAnalysisEnum(){ return 476;} -function AdjointBalancethickness2AnalysisEnum(){ return 477;} -function AdjointHorizAnalysisEnum(){ return 478;} -function AnalysisCounterEnum(){ return 479;} -function DefaultAnalysisEnum(){ return 480;} -function BalancethicknessAnalysisEnum(){ return 481;} -function BalancethicknessSolutionEnum(){ return 482;} -function Balancethickness2AnalysisEnum(){ return 483;} -function Balancethickness2SolutionEnum(){ return 484;} -function BalancethicknessSoftAnalysisEnum(){ return 485;} -function BalancethicknessSoftSolutionEnum(){ return 486;} -function BalancevelocityAnalysisEnum(){ return 487;} -function BalancevelocitySolutionEnum(){ return 488;} -function L2ProjectionEPLAnalysisEnum(){ return 489;} -function L2ProjectionBaseAnalysisEnum(){ return 490;} -function BedSlopeSolutionEnum(){ return 491;} -function DamageEvolutionSolutionEnum(){ return 492;} -function DamageEvolutionAnalysisEnum(){ return 493;} -function StressbalanceAnalysisEnum(){ return 494;} -function StressbalanceSIAAnalysisEnum(){ return 495;} -function StressbalanceSolutionEnum(){ return 496;} -function StressbalanceVerticalAnalysisEnum(){ return 497;} -function EnthalpyAnalysisEnum(){ return 498;} -function FlaimAnalysisEnum(){ return 499;} -function FlaimSolutionEnum(){ return 500;} -function HydrologyShreveAnalysisEnum(){ return 501;} -function HydrologyDCInefficientAnalysisEnum(){ return 502;} -function HydrologyDCEfficientAnalysisEnum(){ return 503;} -function HydrologySommersAnalysisEnum(){ return 504;} -function HydrologySolutionEnum(){ return 505;} -function MeltingAnalysisEnum(){ return 506;} -function MasstransportAnalysisEnum(){ return 507;} -function MasstransportSolutionEnum(){ return 508;} -function FreeSurfaceBaseAnalysisEnum(){ return 509;} -function FreeSurfaceTopAnalysisEnum(){ return 510;} -function SurfaceNormalVelocityEnum(){ return 511;} -function ExtrudeFromBaseAnalysisEnum(){ return 512;} -function ExtrudeFromTopAnalysisEnum(){ return 513;} -function DepthAverageAnalysisEnum(){ return 514;} -function SteadystateSolutionEnum(){ return 515;} -function SurfaceSlopeSolutionEnum(){ return 516;} -function SmoothAnalysisEnum(){ return 517;} -function ThermalAnalysisEnum(){ return 518;} -function ThermalSolutionEnum(){ return 519;} -function TransientSolutionEnum(){ return 520;} -function UzawaPressureAnalysisEnum(){ return 521;} -function GiaSolutionEnum(){ return 522;} -function GiaAnalysisEnum(){ return 523;} -function MeshdeformationSolutionEnum(){ return 524;} -function MeshdeformationAnalysisEnum(){ return 525;} -function LevelsetAnalysisEnum(){ return 526;} -function LevelsetStabilizationEnum(){ return 527;} -function ExtrapolationAnalysisEnum(){ return 528;} -function LsfReinitializationAnalysisEnum(){ return 529;} -function ApproximationEnum(){ return 530;} -function NoneApproximationEnum(){ return 531;} -function SIAApproximationEnum(){ return 532;} -function SSAApproximationEnum(){ return 533;} -function SSAHOApproximationEnum(){ return 534;} -function SSAFSApproximationEnum(){ return 535;} -function L1L2ApproximationEnum(){ return 536;} -function HOApproximationEnum(){ return 537;} -function HOFSApproximationEnum(){ return 538;} -function FSApproximationEnum(){ return 539;} -function FSvelocityEnum(){ return 540;} -function FSpressureEnum(){ return 541;} -function DataSetEnum(){ return 542;} -function ConstraintsEnum(){ return 543;} -function LoadsEnum(){ return 544;} -function MaterialsEnum(){ return 545;} -function NodesEnum(){ return 546;} -function ContoursEnum(){ return 547;} -function ParametersEnum(){ return 548;} -function VerticesEnum(){ return 549;} -function ResultsEnum(){ return 550;} -function GenericParamEnum(){ return 551;} -function AdolcParamEnum(){ return 552;} -function BoolInputEnum(){ return 553;} -function BoolParamEnum(){ return 554;} -function ContourEnum(){ return 555;} -function ControlInputEnum(){ return 556;} -function DatasetInputEnum(){ return 557;} -function DoubleInputEnum(){ return 558;} -function DoubleArrayInputEnum(){ return 559;} -function DataSetParamEnum(){ return 560;} -function DoubleMatArrayParamEnum(){ return 561;} -function DoubleMatParamEnum(){ return 562;} -function DoubleParamEnum(){ return 563;} -function DoubleVecParamEnum(){ return 564;} -function ElementEnum(){ return 565;} -function ElementHookEnum(){ return 566;} -function HookEnum(){ return 567;} -function ExternalResultEnum(){ return 568;} -function FileParamEnum(){ return 569;} -function InputEnum(){ return 570;} -function IntInputEnum(){ return 571;} -function InputToExtrudeEnum(){ return 572;} -function InputToL2ProjectEnum(){ return 573;} -function InputToDepthaverageEnum(){ return 574;} -function InputToSmoothEnum(){ return 575;} -function SmoothThicknessMultiplierEnum(){ return 576;} -function IntParamEnum(){ return 577;} -function IntVecParamEnum(){ return 578;} -function TransientParamEnum(){ return 579;} -function MaticeEnum(){ return 580;} -function MatdamageiceEnum(){ return 581;} -function MatbaflEnum(){ return 582;} -function MatparEnum(){ return 583;} -function NodeEnum(){ return 584;} -function NumericalfluxEnum(){ return 585;} -function NumericalfluxTypeEnum(){ return 586;} -function NeumannfluxEnum(){ return 587;} -function ParamEnum(){ return 588;} -function MoulinEnum(){ return 589;} -function PengridEnum(){ return 590;} -function PenpairEnum(){ return 591;} -function ProfilerEnum(){ return 592;} -function MatrixParamEnum(){ return 593;} -function MassconEnum(){ return 594;} -function MassconNameEnum(){ return 595;} -function MassconDefinitionenumEnum(){ return 596;} -function MassconLevelsetEnum(){ return 597;} -function MassconaxpbyEnum(){ return 598;} -function MassconaxpbyNameEnum(){ return 599;} -function MassconaxpbyDefinitionenumEnum(){ return 600;} -function MassconaxpbyNamexEnum(){ return 601;} -function MassconaxpbyNameyEnum(){ return 602;} -function MassconaxpbyAlphaEnum(){ return 603;} -function MassconaxpbyBetaEnum(){ return 604;} -function NodeSIdEnum(){ return 605;} -function VectorParamEnum(){ return 606;} -function RiftfrontEnum(){ return 607;} -function RiftfrontTypeEnum(){ return 608;} -function SegmentEnum(){ return 609;} -function SegmentRiftfrontEnum(){ return 610;} -function SpcDynamicEnum(){ return 611;} -function SpcStaticEnum(){ return 612;} -function SpcTransientEnum(){ return 613;} -function StringArrayParamEnum(){ return 614;} -function StringParamEnum(){ return 615;} -function SegEnum(){ return 616;} -function SegInputEnum(){ return 617;} -function TriaEnum(){ return 618;} -function TriaInputEnum(){ return 619;} -function TetraEnum(){ return 620;} -function TetraInputEnum(){ return 621;} -function PentaEnum(){ return 622;} -function PentaInputEnum(){ return 623;} -function VertexEnum(){ return 624;} -function VertexPIdEnum(){ return 625;} -function VertexSIdEnum(){ return 626;} -function AirEnum(){ return 627;} -function IceEnum(){ return 628;} -function MelangeEnum(){ return 629;} -function WaterEnum(){ return 630;} -function ClosedEnum(){ return 631;} -function FreeEnum(){ return 632;} -function OpenEnum(){ return 633;} -function AdjointpEnum(){ return 634;} -function AdjointxEnum(){ return 635;} -function AdjointyEnum(){ return 636;} -function AdjointzEnum(){ return 637;} -function BalancethicknessMisfitEnum(){ return 638;} -function BedSlopeXEnum(){ return 639;} -function BedSlopeYEnum(){ return 640;} -function BoundaryEnum(){ return 641;} -function ConvergedEnum(){ return 642;} -function FillEnum(){ return 643;} -function FractionIncrementEnum(){ return 644;} -function FrictionEnum(){ return 645;} -function InternalEnum(){ return 646;} -function MassFluxEnum(){ return 647;} -function MeltingOffsetEnum(){ return 648;} -function MisfitEnum(){ return 649;} -function PressureEnum(){ return 650;} -function PressurePicardEnum(){ return 651;} -function AndroidFrictionCoefficientEnum(){ return 652;} -function ResetPenaltiesEnum(){ return 653;} -function SegmentOnIceShelfEnum(){ return 654;} -function SurfaceAbsVelMisfitEnum(){ return 655;} -function SurfaceAreaEnum(){ return 656;} -function SurfaceAverageVelMisfitEnum(){ return 657;} -function SurfaceLogVelMisfitEnum(){ return 658;} -function SurfaceLogVxVyMisfitEnum(){ return 659;} -function SurfaceRelVelMisfitEnum(){ return 660;} -function SurfaceSlopeXEnum(){ return 661;} -function SurfaceSlopeYEnum(){ return 662;} -function TemperatureEnum(){ return 663;} -function TemperaturePicardEnum(){ return 664;} -function TemperaturePDDEnum(){ return 665;} -function ThicknessAbsMisfitEnum(){ return 666;} -function SurfaceAbsMisfitEnum(){ return 667;} -function VelEnum(){ return 668;} -function VelocityEnum(){ return 669;} -function VxAverageEnum(){ return 670;} -function VxEnum(){ return 671;} -function VxPicardEnum(){ return 672;} -function VyAverageEnum(){ return 673;} -function VyEnum(){ return 674;} -function VyPicardEnum(){ return 675;} -function VzEnum(){ return 676;} -function VzSSAEnum(){ return 677;} -function VzHOEnum(){ return 678;} -function VzPicardEnum(){ return 679;} -function VzFSEnum(){ return 680;} -function VxMeshEnum(){ return 681;} -function VyMeshEnum(){ return 682;} -function VzMeshEnum(){ return 683;} -function EnthalpyEnum(){ return 684;} -function EnthalpyPicardEnum(){ return 685;} -function ThicknessAbsGradientEnum(){ return 686;} -function ThicknessAlongGradientEnum(){ return 687;} -function ThicknessAcrossGradientEnum(){ return 688;} -function ThicknessPositiveEnum(){ return 689;} -function IntMatParamEnum(){ return 690;} -function RheologyBbarAbsGradientEnum(){ return 691;} -function RheologyBAbsGradientEnum(){ return 692;} -function DragCoefficientAbsGradientEnum(){ return 693;} -function TransientInputEnum(){ return 694;} -function WaterfractionEnum(){ return 695;} -function WatercolumnEnum(){ return 696;} -function BasalFrictionEnum(){ return 697;} -function ViscousHeatingEnum(){ return 698;} -function HydrologyWaterVxEnum(){ return 699;} -function HydrologyWaterVyEnum(){ return 700;} -function DrivingStressXEnum(){ return 701;} -function DrivingStressYEnum(){ return 702;} -function SigmaNNEnum(){ return 703;} -function StressTensorEnum(){ return 704;} -function StressTensorxxEnum(){ return 705;} -function StressTensorxyEnum(){ return 706;} -function StressTensorxzEnum(){ return 707;} -function StressTensoryyEnum(){ return 708;} -function StressTensoryzEnum(){ return 709;} -function StressTensorzzEnum(){ return 710;} -function StressMaxPrincipalEnum(){ return 711;} -function DeviatoricStressEnum(){ return 712;} -function DeviatoricStressxxEnum(){ return 713;} -function DeviatoricStressxyEnum(){ return 714;} -function DeviatoricStressxzEnum(){ return 715;} -function DeviatoricStressyyEnum(){ return 716;} -function DeviatoricStressyzEnum(){ return 717;} -function DeviatoricStresszzEnum(){ return 718;} -function DeviatoricStresseffectiveEnum(){ return 719;} -function StrainRateEnum(){ return 720;} -function StrainRatexxEnum(){ return 721;} -function StrainRatexyEnum(){ return 722;} -function StrainRatexzEnum(){ return 723;} -function StrainRateyyEnum(){ return 724;} -function StrainRateyzEnum(){ return 725;} -function StrainRatezzEnum(){ return 726;} -function DivergenceEnum(){ return 727;} -function MaxDivergenceEnum(){ return 728;} -function GiaCrossSectionShapeEnum(){ return 729;} -function GiadWdtEnum(){ return 730;} -function GiaWEnum(){ return 731;} -function P0Enum(){ return 732;} -function P0ArrayEnum(){ return 733;} -function P1Enum(){ return 734;} -function P1DGEnum(){ return 735;} -function P1bubbleEnum(){ return 736;} -function P1bubblecondensedEnum(){ return 737;} -function P2Enum(){ return 738;} -function P2bubbleEnum(){ return 739;} -function P2bubblecondensedEnum(){ return 740;} -function P2xP1Enum(){ return 741;} -function P1xP2Enum(){ return 742;} -function P1xP3Enum(){ return 743;} -function P2xP4Enum(){ return 744;} -function P1P1Enum(){ return 745;} -function P1P1GLSEnum(){ return 746;} -function MINIEnum(){ return 747;} -function MINIcondensedEnum(){ return 748;} -function TaylorHoodEnum(){ return 749;} -function LATaylorHoodEnum(){ return 750;} -function XTaylorHoodEnum(){ return 751;} -function OneLayerP4zEnum(){ return 752;} -function CrouzeixRaviartEnum(){ return 753;} -function LACrouzeixRaviartEnum(){ return 754;} -function SaveResultsEnum(){ return 755;} -function BoolExternalResultEnum(){ return 756;} -function DoubleExternalResultEnum(){ return 757;} -function DoubleMatExternalResultEnum(){ return 758;} -function IntExternalResultEnum(){ return 759;} -function JEnum(){ return 760;} -function StringExternalResultEnum(){ return 761;} -function StepEnum(){ return 762;} -function TimeEnum(){ return 763;} -function WaterColumnOldEnum(){ return 764;} -function OutputdefinitionEnum(){ return 765;} -function Outputdefinition1Enum(){ return 766;} -function Outputdefinition2Enum(){ return 767;} -function Outputdefinition3Enum(){ return 768;} -function Outputdefinition4Enum(){ return 769;} -function Outputdefinition5Enum(){ return 770;} -function Outputdefinition6Enum(){ return 771;} -function Outputdefinition7Enum(){ return 772;} -function Outputdefinition8Enum(){ return 773;} -function Outputdefinition9Enum(){ return 774;} -function Outputdefinition10Enum(){ return 775;} -function Outputdefinition11Enum(){ return 776;} -function Outputdefinition12Enum(){ return 777;} -function Outputdefinition13Enum(){ return 778;} -function Outputdefinition14Enum(){ return 779;} -function Outputdefinition15Enum(){ return 780;} -function Outputdefinition16Enum(){ return 781;} -function Outputdefinition17Enum(){ return 782;} -function Outputdefinition18Enum(){ return 783;} -function Outputdefinition19Enum(){ return 784;} -function Outputdefinition20Enum(){ return 785;} -function Outputdefinition21Enum(){ return 786;} -function Outputdefinition22Enum(){ return 787;} -function Outputdefinition23Enum(){ return 788;} -function Outputdefinition24Enum(){ return 789;} -function Outputdefinition25Enum(){ return 790;} -function Outputdefinition26Enum(){ return 791;} -function Outputdefinition27Enum(){ return 792;} -function Outputdefinition28Enum(){ return 793;} -function Outputdefinition29Enum(){ return 794;} -function Outputdefinition30Enum(){ return 795;} -function Outputdefinition31Enum(){ return 796;} -function Outputdefinition32Enum(){ return 797;} -function Outputdefinition33Enum(){ return 798;} -function Outputdefinition34Enum(){ return 799;} -function Outputdefinition35Enum(){ return 800;} -function Outputdefinition36Enum(){ return 801;} -function Outputdefinition37Enum(){ return 802;} -function Outputdefinition38Enum(){ return 803;} -function Outputdefinition39Enum(){ return 804;} -function Outputdefinition40Enum(){ return 805;} -function Outputdefinition41Enum(){ return 806;} -function Outputdefinition42Enum(){ return 807;} -function Outputdefinition43Enum(){ return 808;} -function Outputdefinition44Enum(){ return 809;} -function Outputdefinition45Enum(){ return 810;} -function Outputdefinition46Enum(){ return 811;} -function Outputdefinition47Enum(){ return 812;} -function Outputdefinition48Enum(){ return 813;} -function Outputdefinition49Enum(){ return 814;} -function Outputdefinition50Enum(){ return 815;} -function Outputdefinition51Enum(){ return 816;} -function Outputdefinition52Enum(){ return 817;} -function Outputdefinition53Enum(){ return 818;} -function Outputdefinition54Enum(){ return 819;} -function Outputdefinition55Enum(){ return 820;} -function Outputdefinition56Enum(){ return 821;} -function Outputdefinition57Enum(){ return 822;} -function Outputdefinition58Enum(){ return 823;} -function Outputdefinition59Enum(){ return 824;} -function Outputdefinition60Enum(){ return 825;} -function Outputdefinition61Enum(){ return 826;} -function Outputdefinition62Enum(){ return 827;} -function Outputdefinition63Enum(){ return 828;} -function Outputdefinition64Enum(){ return 829;} -function Outputdefinition65Enum(){ return 830;} -function Outputdefinition66Enum(){ return 831;} -function Outputdefinition67Enum(){ return 832;} -function Outputdefinition68Enum(){ return 833;} -function Outputdefinition69Enum(){ return 834;} -function Outputdefinition70Enum(){ return 835;} -function Outputdefinition71Enum(){ return 836;} -function Outputdefinition72Enum(){ return 837;} -function Outputdefinition73Enum(){ return 838;} -function Outputdefinition74Enum(){ return 839;} -function Outputdefinition75Enum(){ return 840;} -function Outputdefinition76Enum(){ return 841;} -function Outputdefinition77Enum(){ return 842;} -function Outputdefinition78Enum(){ return 843;} -function Outputdefinition79Enum(){ return 844;} -function Outputdefinition80Enum(){ return 845;} -function Outputdefinition81Enum(){ return 846;} -function Outputdefinition82Enum(){ return 847;} -function Outputdefinition83Enum(){ return 848;} -function Outputdefinition84Enum(){ return 849;} -function Outputdefinition85Enum(){ return 850;} -function Outputdefinition86Enum(){ return 851;} -function Outputdefinition87Enum(){ return 852;} -function Outputdefinition88Enum(){ return 853;} -function Outputdefinition89Enum(){ return 854;} -function Outputdefinition90Enum(){ return 855;} -function Outputdefinition91Enum(){ return 856;} -function Outputdefinition92Enum(){ return 857;} -function Outputdefinition93Enum(){ return 858;} -function Outputdefinition94Enum(){ return 859;} -function Outputdefinition95Enum(){ return 860;} -function Outputdefinition96Enum(){ return 861;} -function Outputdefinition97Enum(){ return 862;} -function Outputdefinition98Enum(){ return 863;} -function Outputdefinition99Enum(){ return 864;} -function Outputdefinition100Enum(){ return 865;} -function OutputdefinitionListEnum(){ return 866;} -function MassfluxatgateEnum(){ return 867;} -function MassfluxatgateNameEnum(){ return 868;} -function MassfluxatgateDefinitionenumEnum(){ return 869;} -function MassfluxatgateSegmentsEnum(){ return 870;} -function NodalvalueEnum(){ return 871;} -function NodalvalueNameEnum(){ return 872;} -function NodalvalueDefinitionenumEnum(){ return 873;} -function NodalvalueModelEnum(){ return 874;} -function NodalvalueNodeEnum(){ return 875;} -function MisfitNameEnum(){ return 876;} -function MisfitDefinitionenumEnum(){ return 877;} -function MisfitModelEnum(){ return 878;} -function MisfitObservationEnum(){ return 879;} -function MisfitObservationEnum(){ return 880;} -function MisfitLocalEnum(){ return 881;} -function MisfitTimeinterpolationEnum(){ return 882;} -function MisfitWeightsEnum(){ return 883;} -function MisfitWeightsEnum(){ return 884;} -function SurfaceObservationEnum(){ return 885;} -function WeightsSurfaceObservationEnum(){ return 886;} -function VxObsEnum(){ return 887;} -function WeightsVxObsEnum(){ return 888;} -function VyObsEnum(){ return 889;} -function WeightsVyObsEnum(){ return 890;} -function MinVelEnum(){ return 891;} -function MaxVelEnum(){ return 892;} -function MinVxEnum(){ return 893;} -function MaxVxEnum(){ return 894;} -function MaxAbsVxEnum(){ return 895;} -function MinVyEnum(){ return 896;} -function MaxVyEnum(){ return 897;} -function MaxAbsVyEnum(){ return 898;} -function MinVzEnum(){ return 899;} -function MaxVzEnum(){ return 900;} -function MaxAbsVzEnum(){ return 901;} -function FloatingAreaEnum(){ return 902;} -function GroundedAreaEnum(){ return 903;} -function IceMassEnum(){ return 904;} -function IceVolumeEnum(){ return 905;} -function IceVolumeAboveFloatationEnum(){ return 906;} -function TotalFloatingBmbEnum(){ return 907;} -function TotalGroundedBmbEnum(){ return 908;} -function TotalSmbEnum(){ return 909;} -function AbsoluteEnum(){ return 910;} -function IncrementalEnum(){ return 911;} -function AugmentedLagrangianREnum(){ return 912;} -function AugmentedLagrangianRhopEnum(){ return 913;} -function AugmentedLagrangianRlambdaEnum(){ return 914;} -function AugmentedLagrangianRholambdaEnum(){ return 915;} -function AugmentedLagrangianThetaEnum(){ return 916;} -function NoneEnum(){ return 917;} -function AggressiveMigrationEnum(){ return 918;} -function SoftMigrationEnum(){ return 919;} -function SubelementMigrationEnum(){ return 920;} -function SubelementMigration2Enum(){ return 921;} -function ContactEnum(){ return 922;} -function GroundingOnlyEnum(){ return 923;} -function MaskGroundediceLevelsetEnum(){ return 924;} -function GaussSegEnum(){ return 925;} -function GaussTriaEnum(){ return 926;} -function GaussTetraEnum(){ return 927;} -function GaussPentaEnum(){ return 928;} -function FSSolverEnum(){ return 929;} -function AdjointEnum(){ return 930;} -function ColinearEnum(){ return 931;} -function ControlSteadyEnum(){ return 932;} -function FsetEnum(){ return 933;} -function Gradient1Enum(){ return 934;} -function Gradient2Enum(){ return 935;} -function Gradient3Enum(){ return 936;} -function GradientEnum(){ return 937;} -function GroundinglineMigrationEnum(){ return 938;} -function GsetEnum(){ return 939;} -function IndexEnum(){ return 940;} -function IndexedEnum(){ return 941;} -function IntersectEnum(){ return 942;} -function NodalEnum(){ return 943;} -function OldGradientEnum(){ return 944;} -function OutputBufferPointerEnum(){ return 945;} -function OutputBufferSizePointerEnum(){ return 946;} -function OutputFilePointerEnum(){ return 947;} -function ToolkitsFileNameEnum(){ return 948;} -function RootPathEnum(){ return 949;} -function OutputFileNameEnum(){ return 950;} -function InputFileNameEnum(){ return 951;} -function LockFileNameEnum(){ return 952;} -function RestartFileNameEnum(){ return 953;} -function ToolkitsOptionsAnalysesEnum(){ return 954;} -function ToolkitsOptionsStringsEnum(){ return 955;} -function QmuErrNameEnum(){ return 956;} -function QmuInNameEnum(){ return 957;} -function QmuOutNameEnum(){ return 958;} -function RegularEnum(){ return 959;} -function ScaledEnum(){ return 960;} -function SeparateEnum(){ return 961;} -function SsetEnum(){ return 962;} -function VerboseEnum(){ return 963;} -function TriangleInterpEnum(){ return 964;} -function BilinearInterpEnum(){ return 965;} -function NearestInterpEnum(){ return 966;} -function XYEnum(){ return 967;} -function XYZEnum(){ return 968;} -function DenseEnum(){ return 969;} -function MpiDenseEnum(){ return 970;} -function MpiSparseEnum(){ return 971;} -function SeqEnum(){ return 972;} -function MpiEnum(){ return 973;} -function MumpsEnum(){ return 974;} -function GslEnum(){ return 975;} -function OptionEnum(){ return 976;} -function GenericOptionEnum(){ return 977;} -function OptionCellEnum(){ return 978;} -function OptionStructEnum(){ return 979;} -function CuffeyEnum(){ return 980;} -function CuffeyTemperateEnum(){ return 981;} -function PatersonEnum(){ return 982;} -function ArrheniusEnum(){ return 983;} -function LliboutryDuvalEnum(){ return 984;} -function SpclevelsetEnum(){ return 985;} -function ExtrapolationVariableEnum(){ return 986;} -function IceMaskNodeActivationEnum(){ return 987;} -function LevelsetfunctionSlopeXEnum(){ return 988;} -function LevelsetfunctionSlopeYEnum(){ return 989;} -function LevelsetfunctionPicardEnum(){ return 990;} -function LevelsetReinitFrequencyEnum(){ return 991;} -function SealevelriseSolutionEnum(){ return 992;} -function SealevelriseAnalysisEnum(){ return 993;} -function SealevelEnum(){ return 994;} -function SealevelEustaticEnum(){ return 995;} -function SealevelriseDeltathicknessEnum(){ return 996;} -function SealevelriseMaxiterEnum(){ return 997;} -function SealevelriseReltolEnum(){ return 998;} -function SealevelriseAbstolEnum(){ return 999;} -function SealevelriseLoveHEnum(){ return 1000;} -function SealevelriseLoveKEnum(){ return 1001;} -function SealevelriseTideLoveHEnum(){ return 1002;} -function SealevelriseTideLoveKEnum(){ return 1003;} -function SealevelriseRigidEnum(){ return 1004;} -function SealevelriseElasticEnum(){ return 1005;} -function SealevelriseRotationEnum(){ return 1006;} -function SealevelriseGElasticEnum(){ return 1007;} -function SealevelriseDegaccEnum(){ return 1008;} -function SealevelriseTransitionsEnum(){ return 1009;} -function SealevelriseRequestedOutputsEnum(){ return 1010;} -function SealevelriseNumRequestedOutputsEnum(){ return 1011;} -function ParametersENDEnum(){ return 1012;} -function MaximumNumberOfDefinitionsEnum(){ return 1013;} +function MaterialsRheologyEcbarEnum(){ return 221;} +function MaterialsRheologyEsEnum(){ return 222;} +function MaterialsRheologyEsbarEnum(){ return 223;} +function DamageIsdamageEnum(){ return 224;} +function DamageDEnum(){ return 225;} +function DamageFEnum(){ return 226;} +function DamageDbarEnum(){ return 227;} +function DamageLawEnum(){ return 228;} +function DamageC1Enum(){ return 229;} +function DamageC2Enum(){ return 230;} +function DamageC3Enum(){ return 231;} +function DamageC4Enum(){ return 232;} +function DamageElementinterpEnum(){ return 233;} +function DamageHealingEnum(){ return 234;} +function DamageStressThresholdEnum(){ return 235;} +function DamageKappaEnum(){ return 236;} +function DamageStabilizationEnum(){ return 237;} +function DamageMaxiterEnum(){ return 238;} +function DamageSpcdamageEnum(){ return 239;} +function DamageMaxDamageEnum(){ return 240;} +function DamageEquivStressEnum(){ return 241;} +function DamageEvolutionNumRequestedOutputsEnum(){ return 242;} +function DamageEvolutionRequestedOutputsEnum(){ return 243;} +function DamageEnum(){ return 244;} +function NewDamageEnum(){ return 245;} +function StressIntensityFactorEnum(){ return 246;} +function CalvingLawEnum(){ return 247;} +function CalvingCalvingrateEnum(){ return 248;} +function CalvingMeltingrateEnum(){ return 249;} +function CalvingLevermannEnum(){ return 250;} +function CalvingDevEnum(){ return 251;} +function DefaultCalvingEnum(){ return 252;} +function CalvingRequestedOutputsEnum(){ return 253;} +function CalvinglevermannCoeffEnum(){ return 254;} +function CalvinglevermannMeltingrateEnum(){ return 255;} +function CalvingdevCoeffEnum(){ return 256;} +function CalvingratexEnum(){ return 257;} +function CalvingrateyEnum(){ return 258;} +function CalvingratexAverageEnum(){ return 259;} +function CalvingrateyAverageEnum(){ return 260;} +function StrainRateparallelEnum(){ return 261;} +function StrainRateperpendicularEnum(){ return 262;} +function StrainRateeffectiveEnum(){ return 263;} +function MaterialsRhoIceEnum(){ return 264;} +function MaterialsRhoSeawaterEnum(){ return 265;} +function MaterialsRhoFreshwaterEnum(){ return 266;} +function MaterialsMuWaterEnum(){ return 267;} +function MaterialsThermalExchangeVelocityEnum(){ return 268;} +function MaterialsThermalconductivityEnum(){ return 269;} +function MaterialsTemperateiceconductivityEnum(){ return 270;} +function MaterialsLithosphereShearModulusEnum(){ return 271;} +function MaterialsLithosphereDensityEnum(){ return 272;} +function MaterialsMantleShearModulusEnum(){ return 273;} +function MaterialsMantleDensityEnum(){ return 274;} +function MaterialsEarthDensityEnum(){ return 275;} +function MeshAverageVertexConnectivityEnum(){ return 276;} +function MeshElements2dEnum(){ return 277;} +function MeshElementsEnum(){ return 278;} +function MeshLowerelementsEnum(){ return 279;} +function MeshNumberofelements2dEnum(){ return 280;} +function MeshNumberofelementsEnum(){ return 281;} +function MeshNumberoflayersEnum(){ return 282;} +function MeshNumberofvertices2dEnum(){ return 283;} +function MeshNumberofverticesEnum(){ return 284;} +function MeshUpperelementsEnum(){ return 285;} +function MeshVertexonbaseEnum(){ return 286;} +function MeshVertexonsurfaceEnum(){ return 287;} +function MeshVertexonboundaryEnum(){ return 288;} +function MeshXEnum(){ return 289;} +function MeshYEnum(){ return 290;} +function MeshZEnum(){ return 291;} +function MeshLatEnum(){ return 292;} +function MeshLongEnum(){ return 293;} +function MeshREnum(){ return 294;} +function MeshElementtypeEnum(){ return 295;} +function MeshSegmentsEnum(){ return 296;} +function DomainTypeEnum(){ return 297;} +function DomainDimensionEnum(){ return 298;} +function Domain2DhorizontalEnum(){ return 299;} +function Domain2DverticalEnum(){ return 300;} +function Domain3DEnum(){ return 301;} +function Domain3DsurfaceEnum(){ return 302;} +function MiscellaneousNameEnum(){ return 303;} +function MasstransportHydrostaticAdjustmentEnum(){ return 304;} +function MasstransportIsfreesurfaceEnum(){ return 305;} +function MasstransportMinThicknessEnum(){ return 306;} +function MasstransportPenaltyFactorEnum(){ return 307;} +function MasstransportSpcthicknessEnum(){ return 308;} +function MasstransportStabilizationEnum(){ return 309;} +function MasstransportVertexPairingEnum(){ return 310;} +function MasstransportNumRequestedOutputsEnum(){ return 311;} +function MasstransportRequestedOutputsEnum(){ return 312;} +function QmuIsdakotaEnum(){ return 313;} +function MassFluxSegmentsEnum(){ return 314;} +function MassFluxSegmentsPresentEnum(){ return 315;} +function QmuMassFluxSegmentsPresentEnum(){ return 316;} +function QmuNumberofpartitionsEnum(){ return 317;} +function QmuNumberofresponsesEnum(){ return 318;} +function QmuPartitionEnum(){ return 319;} +function QmuResponsedescriptorsEnum(){ return 320;} +function QmuVariabledescriptorsEnum(){ return 321;} +function RiftsNumriftsEnum(){ return 322;} +function RiftsRiftstructEnum(){ return 323;} +function SettingsResultsOnNodesEnum(){ return 324;} +function SettingsIoGatherEnum(){ return 325;} +function SettingsLowmemEnum(){ return 326;} +function SettingsOutputFrequencyEnum(){ return 327;} +function SettingsRecordingFrequencyEnum(){ return 328;} +function SettingsWaitonlockEnum(){ return 329;} +function DebugProfilingEnum(){ return 330;} +function ProfilingCurrentMemEnum(){ return 331;} +function ProfilingCurrentFlopsEnum(){ return 332;} +function ProfilingSolutionTimeEnum(){ return 333;} +function SteadystateMaxiterEnum(){ return 334;} +function SteadystateNumRequestedOutputsEnum(){ return 335;} +function SteadystateReltolEnum(){ return 336;} +function SteadystateRequestedOutputsEnum(){ return 337;} +function SurfaceEnum(){ return 338;} +function ThermalIsenthalpyEnum(){ return 339;} +function ThermalIsdynamicbasalspcEnum(){ return 340;} +function ThermalReltolEnum(){ return 341;} +function ThermalMaxiterEnum(){ return 342;} +function ThermalPenaltyFactorEnum(){ return 343;} +function ThermalPenaltyLockEnum(){ return 344;} +function ThermalPenaltyThresholdEnum(){ return 345;} +function ThermalSpctemperatureEnum(){ return 346;} +function ThermalStabilizationEnum(){ return 347;} +function ThermalNumRequestedOutputsEnum(){ return 348;} +function ThermalRequestedOutputsEnum(){ return 349;} +function GiaMantleViscosityEnum(){ return 350;} +function GiaLithosphereThicknessEnum(){ return 351;} +function ThicknessEnum(){ return 352;} +function TimesteppingStartTimeEnum(){ return 353;} +function TimesteppingFinalTimeEnum(){ return 354;} +function TimesteppingCflCoefficientEnum(){ return 355;} +function TimesteppingTimeAdaptEnum(){ return 356;} +function TimesteppingTimeStepEnum(){ return 357;} +function TimesteppingInterpForcingsEnum(){ return 358;} +function TransientIssmbEnum(){ return 359;} +function TransientIscouplerEnum(){ return 360;} +function TransientIsstressbalanceEnum(){ return 361;} +function TransientIsgroundinglineEnum(){ return 362;} +function TransientIsmasstransportEnum(){ return 363;} +function TransientIsthermalEnum(){ return 364;} +function TransientIsgiaEnum(){ return 365;} +function TransientIsdamageevolutionEnum(){ return 366;} +function TransientIshydrologyEnum(){ return 367;} +function TransientIsmovingfrontEnum(){ return 368;} +function TransientIsslrEnum(){ return 369;} +function TransientNumRequestedOutputsEnum(){ return 370;} +function TransientRequestedOutputsEnum(){ return 371;} +function PotentialEnum(){ return 372;} +function BalancethicknessSpcpotentialEnum(){ return 373;} +function BalancethicknessApparentMassbalanceEnum(){ return 374;} +function Balancethickness2MisfitEnum(){ return 375;} +function BalancethicknessDiffusionCoefficientEnum(){ return 376;} +function BalancethicknessCmuEnum(){ return 377;} +function BalancethicknessOmegaEnum(){ return 378;} +function BalancethicknessD0Enum(){ return 379;} +function SmbEnum(){ return 380;} +function SmbAnalysisEnum(){ return 381;} +function SmbSolutionEnum(){ return 382;} +function SmbNumRequestedOutputsEnum(){ return 383;} +function SmbRequestedOutputsEnum(){ return 384;} +function SmbIsInitializedEnum(){ return 385;} +function SMBforcingEnum(){ return 386;} +function SmbMassBalanceEnum(){ return 387;} +function SMBgembEnum(){ return 388;} +function SmbInitDensityScalingEnum(){ return 389;} +function SmbTaEnum(){ return 390;} +function SmbVEnum(){ return 391;} +function SmbDswrfEnum(){ return 392;} +function SmbDlwrfEnum(){ return 393;} +function SmbPEnum(){ return 394;} +function SmbSwfEnum(){ return 395;} +function SmbEAirEnum(){ return 396;} +function SmbPAirEnum(){ return 397;} +function SmbTmeanEnum(){ return 398;} +function SmbCEnum(){ return 399;} +function SmbTzEnum(){ return 400;} +function SmbVzEnum(){ return 401;} +function SmbDtEnum(){ return 402;} +function SmbDzEnum(){ return 403;} +function SmbAIdxEnum(){ return 404;} +function SmbSwIdxEnum(){ return 405;} +function SmbDenIdxEnum(){ return 406;} +function SmbZTopEnum(){ return 407;} +function SmbDzTopEnum(){ return 408;} +function SmbDzMinEnum(){ return 409;} +function SmbZYEnum(){ return 410;} +function SmbZMaxEnum(){ return 411;} +function SmbZMinEnum(){ return 412;} +function SmbOutputFreqEnum(){ return 413;} +function SmbASnowEnum(){ return 414;} +function SmbAIceEnum(){ return 415;} +function SmbCldFracEnum(){ return 416;} +function SmbT0wetEnum(){ return 417;} +function SmbT0dryEnum(){ return 418;} +function SmbKEnum(){ return 419;} +function SmbDEnum(){ return 420;} +function SmbReEnum(){ return 421;} +function SmbGdnEnum(){ return 422;} +function SmbGspEnum(){ return 423;} +function SmbECEnum(){ return 424;} +function SmbCondensationEnum(){ return 425;} +function SmbWEnum(){ return 426;} +function SmbAEnum(){ return 427;} +function SmbTEnum(){ return 428;} +function SmbIsgraingrowthEnum(){ return 429;} +function SmbIsalbedoEnum(){ return 430;} +function SmbIsshortwaveEnum(){ return 431;} +function SmbIsthermalEnum(){ return 432;} +function SmbIsaccumulationEnum(){ return 433;} +function SmbIsmeltEnum(){ return 434;} +function SmbIsdensificationEnum(){ return 435;} +function SmbIsturbulentfluxEnum(){ return 436;} +function SMBpddEnum(){ return 437;} +function SmbDelta18oEnum(){ return 438;} +function SmbDelta18oSurfaceEnum(){ return 439;} +function SmbIsdelta18oEnum(){ return 440;} +function SmbIsmungsmEnum(){ return 441;} +function SmbIsd18opdEnum(){ return 442;} +function SmbPrecipitationsPresentdayEnum(){ return 443;} +function SmbPrecipitationsLgmEnum(){ return 444;} +function SmbTemperaturesPresentdayEnum(){ return 445;} +function SmbTemperaturesLgmEnum(){ return 446;} +function SmbPrecipitationEnum(){ return 447;} +function SmbDesfacEnum(){ return 448;} +function SmbS0pEnum(){ return 449;} +function SmbS0tEnum(){ return 450;} +function SmbRlapsEnum(){ return 451;} +function SmbRlapslgmEnum(){ return 452;} +function SmbPfacEnum(){ return 453;} +function SmbTdiffEnum(){ return 454;} +function SmbSealevEnum(){ return 455;} +function SMBd18opddEnum(){ return 456;} +function SmbDpermilEnum(){ return 457;} +function SMBgradientsEnum(){ return 458;} +function SmbMonthlytemperaturesEnum(){ return 459;} +function SmbHrefEnum(){ return 460;} +function SmbSmbrefEnum(){ return 461;} +function SmbBPosEnum(){ return 462;} +function SmbBNegEnum(){ return 463;} +function SMBhenningEnum(){ return 464;} +function SMBcomponentsEnum(){ return 465;} +function SmbAccumulationEnum(){ return 466;} +function SmbEvaporationEnum(){ return 467;} +function SmbRunoffEnum(){ return 468;} +function SMBmeltcomponentsEnum(){ return 469;} +function SmbMeltEnum(){ return 470;} +function SmbRefreezeEnum(){ return 471;} +function SMBgcmEnum(){ return 472;} +function SmbIspddEnum(){ return 473;} +function SmbIssmbgradientsEnum(){ return 474;} +function SolutionTypeEnum(){ return 475;} +function AnalysisTypeEnum(){ return 476;} +function ConfigurationTypeEnum(){ return 477;} +function AdjointBalancethicknessAnalysisEnum(){ return 478;} +function AdjointBalancethickness2AnalysisEnum(){ return 479;} +function AdjointHorizAnalysisEnum(){ return 480;} +function AnalysisCounterEnum(){ return 481;} +function DefaultAnalysisEnum(){ return 482;} +function BalancethicknessAnalysisEnum(){ return 483;} +function BalancethicknessSolutionEnum(){ return 484;} +function Balancethickness2AnalysisEnum(){ return 485;} +function Balancethickness2SolutionEnum(){ return 486;} +function BalancethicknessSoftAnalysisEnum(){ return 487;} +function BalancethicknessSoftSolutionEnum(){ return 488;} +function BalancevelocityAnalysisEnum(){ return 489;} +function BalancevelocitySolutionEnum(){ return 490;} +function L2ProjectionEPLAnalysisEnum(){ return 491;} +function L2ProjectionBaseAnalysisEnum(){ return 492;} +function BedSlopeSolutionEnum(){ return 493;} +function DamageEvolutionSolutionEnum(){ return 494;} +function DamageEvolutionAnalysisEnum(){ return 495;} +function StressbalanceAnalysisEnum(){ return 496;} +function StressbalanceSIAAnalysisEnum(){ return 497;} +function StressbalanceSolutionEnum(){ return 498;} +function StressbalanceVerticalAnalysisEnum(){ return 499;} +function EnthalpyAnalysisEnum(){ return 500;} +function FlaimAnalysisEnum(){ return 501;} +function FlaimSolutionEnum(){ return 502;} +function HydrologyShreveAnalysisEnum(){ return 503;} +function HydrologyDCInefficientAnalysisEnum(){ return 504;} +function HydrologyDCEfficientAnalysisEnum(){ return 505;} +function HydrologySommersAnalysisEnum(){ return 506;} +function HydrologySolutionEnum(){ return 507;} +function MeltingAnalysisEnum(){ return 508;} +function MasstransportAnalysisEnum(){ return 509;} +function MasstransportSolutionEnum(){ return 510;} +function FreeSurfaceBaseAnalysisEnum(){ return 511;} +function FreeSurfaceTopAnalysisEnum(){ return 512;} +function SurfaceNormalVelocityEnum(){ return 513;} +function ExtrudeFromBaseAnalysisEnum(){ return 514;} +function ExtrudeFromTopAnalysisEnum(){ return 515;} +function DepthAverageAnalysisEnum(){ return 516;} +function SteadystateSolutionEnum(){ return 517;} +function SurfaceSlopeSolutionEnum(){ return 518;} +function SmoothAnalysisEnum(){ return 519;} +function ThermalAnalysisEnum(){ return 520;} +function ThermalSolutionEnum(){ return 521;} +function TransientSolutionEnum(){ return 522;} +function UzawaPressureAnalysisEnum(){ return 523;} +function GiaSolutionEnum(){ return 524;} +function GiaAnalysisEnum(){ return 525;} +function MeshdeformationSolutionEnum(){ return 526;} +function MeshdeformationAnalysisEnum(){ return 527;} +function LevelsetAnalysisEnum(){ return 528;} +function LevelsetStabilizationEnum(){ return 529;} +function ExtrapolationAnalysisEnum(){ return 530;} +function LsfReinitializationAnalysisEnum(){ return 531;} +function ApproximationEnum(){ return 532;} +function NoneApproximationEnum(){ return 533;} +function SIAApproximationEnum(){ return 534;} +function SSAApproximationEnum(){ return 535;} +function SSAHOApproximationEnum(){ return 536;} +function SSAFSApproximationEnum(){ return 537;} +function L1L2ApproximationEnum(){ return 538;} +function HOApproximationEnum(){ return 539;} +function HOFSApproximationEnum(){ return 540;} +function FSApproximationEnum(){ return 541;} +function FSvelocityEnum(){ return 542;} +function FSpressureEnum(){ return 543;} +function DataSetEnum(){ return 544;} +function ConstraintsEnum(){ return 545;} +function LoadsEnum(){ return 546;} +function MaterialsEnum(){ return 547;} +function NodesEnum(){ return 548;} +function ContoursEnum(){ return 549;} +function ParametersEnum(){ return 550;} +function VerticesEnum(){ return 551;} +function ResultsEnum(){ return 552;} +function GenericParamEnum(){ return 553;} +function AdolcParamEnum(){ return 554;} +function BoolInputEnum(){ return 555;} +function BoolParamEnum(){ return 556;} +function ContourEnum(){ return 557;} +function ControlInputEnum(){ return 558;} +function DatasetInputEnum(){ return 559;} +function DoubleInputEnum(){ return 560;} +function DoubleArrayInputEnum(){ return 561;} +function DataSetParamEnum(){ return 562;} +function DoubleMatArrayParamEnum(){ return 563;} +function DoubleMatParamEnum(){ return 564;} +function DoubleParamEnum(){ return 565;} +function DoubleVecParamEnum(){ return 566;} +function ElementEnum(){ return 567;} +function ElementHookEnum(){ return 568;} +function HookEnum(){ return 569;} +function ExternalResultEnum(){ return 570;} +function FileParamEnum(){ return 571;} +function InputEnum(){ return 572;} +function IntInputEnum(){ return 573;} +function InputToExtrudeEnum(){ return 574;} +function InputToL2ProjectEnum(){ return 575;} +function InputToDepthaverageEnum(){ return 576;} +function InputToSmoothEnum(){ return 577;} +function SmoothThicknessMultiplierEnum(){ return 578;} +function IntParamEnum(){ return 579;} +function IntVecParamEnum(){ return 580;} +function TransientParamEnum(){ return 581;} +function MaticeEnum(){ return 582;} +function MatdamageiceEnum(){ return 583;} +function MatearlEnum(){ return 584;} +function MatparEnum(){ return 585;} +function NodeEnum(){ return 586;} +function NumericalfluxEnum(){ return 587;} +function NumericalfluxTypeEnum(){ return 588;} +function NeumannfluxEnum(){ return 589;} +function ParamEnum(){ return 590;} +function MoulinEnum(){ return 591;} +function PengridEnum(){ return 592;} +function PenpairEnum(){ return 593;} +function ProfilerEnum(){ return 594;} +function MatrixParamEnum(){ return 595;} +function MassconEnum(){ return 596;} +function MassconNameEnum(){ return 597;} +function MassconDefinitionenumEnum(){ return 598;} +function MassconLevelsetEnum(){ return 599;} +function MassconaxpbyEnum(){ return 600;} +function MassconaxpbyNameEnum(){ return 601;} +function MassconaxpbyDefinitionenumEnum(){ return 602;} +function MassconaxpbyNamexEnum(){ return 603;} +function MassconaxpbyNameyEnum(){ return 604;} +function MassconaxpbyAlphaEnum(){ return 605;} +function MassconaxpbyBetaEnum(){ return 606;} +function NodeSIdEnum(){ return 607;} +function VectorParamEnum(){ return 608;} +function RiftfrontEnum(){ return 609;} +function RiftfrontTypeEnum(){ return 610;} +function SegmentEnum(){ return 611;} +function SegmentRiftfrontEnum(){ return 612;} +function SpcDynamicEnum(){ return 613;} +function SpcStaticEnum(){ return 614;} +function SpcTransientEnum(){ return 615;} +function StringArrayParamEnum(){ return 616;} +function StringParamEnum(){ return 617;} +function SegEnum(){ return 618;} +function SegInputEnum(){ return 619;} +function TriaEnum(){ return 620;} +function TriaInputEnum(){ return 621;} +function TetraEnum(){ return 622;} +function TetraInputEnum(){ return 623;} +function PentaEnum(){ return 624;} +function PentaInputEnum(){ return 625;} +function VertexEnum(){ return 626;} +function VertexPIdEnum(){ return 627;} +function VertexSIdEnum(){ return 628;} +function AirEnum(){ return 629;} +function IceEnum(){ return 630;} +function MelangeEnum(){ return 631;} +function WaterEnum(){ return 632;} +function ClosedEnum(){ return 633;} +function FreeEnum(){ return 634;} +function OpenEnum(){ return 635;} +function AdjointpEnum(){ return 636;} +function AdjointxEnum(){ return 637;} +function AdjointyEnum(){ return 638;} +function AdjointzEnum(){ return 639;} +function BalancethicknessMisfitEnum(){ return 640;} +function BedSlopeXEnum(){ return 641;} +function BedSlopeYEnum(){ return 642;} +function BoundaryEnum(){ return 643;} +function ConvergedEnum(){ return 644;} +function FillEnum(){ return 645;} +function FractionIncrementEnum(){ return 646;} +function FrictionEnum(){ return 647;} +function InternalEnum(){ return 648;} +function MassFluxEnum(){ return 649;} +function MeltingOffsetEnum(){ return 650;} +function MisfitEnum(){ return 651;} +function PressureEnum(){ return 652;} +function PressurePicardEnum(){ return 653;} +function AndroidFrictionCoefficientEnum(){ return 654;} +function ResetPenaltiesEnum(){ return 655;} +function SegmentOnIceShelfEnum(){ return 656;} +function SurfaceAbsVelMisfitEnum(){ return 657;} +function SurfaceAreaEnum(){ return 658;} +function SurfaceAverageVelMisfitEnum(){ return 659;} +function SurfaceLogVelMisfitEnum(){ return 660;} +function SurfaceLogVxVyMisfitEnum(){ return 661;} +function SurfaceRelVelMisfitEnum(){ return 662;} +function SurfaceSlopeXEnum(){ return 663;} +function SurfaceSlopeYEnum(){ return 664;} +function TemperatureEnum(){ return 665;} +function TemperaturePicardEnum(){ return 666;} +function TemperaturePDDEnum(){ return 667;} +function ThicknessAbsMisfitEnum(){ return 668;} +function SurfaceAbsMisfitEnum(){ return 669;} +function VelEnum(){ return 670;} +function VelocityEnum(){ return 671;} +function VxAverageEnum(){ return 672;} +function VxEnum(){ return 673;} +function VxPicardEnum(){ return 674;} +function VyAverageEnum(){ return 675;} +function VyEnum(){ return 676;} +function VyPicardEnum(){ return 677;} +function VzEnum(){ return 678;} +function VzSSAEnum(){ return 679;} +function VzHOEnum(){ return 680;} +function VzPicardEnum(){ return 681;} +function VzFSEnum(){ return 682;} +function VxMeshEnum(){ return 683;} +function VyMeshEnum(){ return 684;} +function VzMeshEnum(){ return 685;} +function EnthalpyEnum(){ return 686;} +function EnthalpyPicardEnum(){ return 687;} +function ThicknessAbsGradientEnum(){ return 688;} +function ThicknessAlongGradientEnum(){ return 689;} +function ThicknessAcrossGradientEnum(){ return 690;} +function ThicknessPositiveEnum(){ return 691;} +function IntMatParamEnum(){ return 692;} +function RheologyBbarAbsGradientEnum(){ return 693;} +function RheologyBAbsGradientEnum(){ return 694;} +function DragCoefficientAbsGradientEnum(){ return 695;} +function TransientInputEnum(){ return 696;} +function WaterfractionEnum(){ return 697;} +function WatercolumnEnum(){ return 698;} +function BasalFrictionEnum(){ return 699;} +function ViscousHeatingEnum(){ return 700;} +function HydrologyWaterVxEnum(){ return 701;} +function HydrologyWaterVyEnum(){ return 702;} +function DrivingStressXEnum(){ return 703;} +function DrivingStressYEnum(){ return 704;} +function SigmaNNEnum(){ return 705;} +function StressTensorEnum(){ return 706;} +function StressTensorxxEnum(){ return 707;} +function StressTensorxyEnum(){ return 708;} +function StressTensorxzEnum(){ return 709;} +function StressTensoryyEnum(){ return 710;} +function StressTensoryzEnum(){ return 711;} +function StressTensorzzEnum(){ return 712;} +function StressMaxPrincipalEnum(){ return 713;} +function DeviatoricStressEnum(){ return 714;} +function DeviatoricStressxxEnum(){ return 715;} +function DeviatoricStressxyEnum(){ return 716;} +function DeviatoricStressxzEnum(){ return 717;} +function DeviatoricStressyyEnum(){ return 718;} +function DeviatoricStressyzEnum(){ return 719;} +function DeviatoricStresszzEnum(){ return 720;} +function DeviatoricStresseffectiveEnum(){ return 721;} +function StrainRateEnum(){ return 722;} +function StrainRatexxEnum(){ return 723;} +function StrainRatexyEnum(){ return 724;} +function StrainRatexzEnum(){ return 725;} +function StrainRateyyEnum(){ return 726;} +function StrainRateyzEnum(){ return 727;} +function StrainRatezzEnum(){ return 728;} +function DivergenceEnum(){ return 729;} +function MaxDivergenceEnum(){ return 730;} +function GiaCrossSectionShapeEnum(){ return 731;} +function GiadWdtEnum(){ return 732;} +function GiaWEnum(){ return 733;} +function P0Enum(){ return 734;} +function P0ArrayEnum(){ return 735;} +function P1Enum(){ return 736;} +function P1DGEnum(){ return 737;} +function P1bubbleEnum(){ return 738;} +function P1bubblecondensedEnum(){ return 739;} +function P2Enum(){ return 740;} +function P2bubbleEnum(){ return 741;} +function P2bubblecondensedEnum(){ return 742;} +function P2xP1Enum(){ return 743;} +function P1xP2Enum(){ return 744;} +function P1xP3Enum(){ return 745;} +function P2xP4Enum(){ return 746;} +function P1P1Enum(){ return 747;} +function P1P1GLSEnum(){ return 748;} +function MINIEnum(){ return 749;} +function MINIcondensedEnum(){ return 750;} +function TaylorHoodEnum(){ return 751;} +function LATaylorHoodEnum(){ return 752;} +function XTaylorHoodEnum(){ return 753;} +function OneLayerP4zEnum(){ return 754;} +function CrouzeixRaviartEnum(){ return 755;} +function LACrouzeixRaviartEnum(){ return 756;} +function SaveResultsEnum(){ return 757;} +function BoolExternalResultEnum(){ return 758;} +function DoubleExternalResultEnum(){ return 759;} +function DoubleMatExternalResultEnum(){ return 760;} +function IntExternalResultEnum(){ return 761;} +function JEnum(){ return 762;} +function StringExternalResultEnum(){ return 763;} +function StepEnum(){ return 764;} +function TimeEnum(){ return 765;} +function WaterColumnOldEnum(){ return 766;} +function OutputdefinitionEnum(){ return 767;} +function Outputdefinition1Enum(){ return 768;} +function Outputdefinition2Enum(){ return 769;} +function Outputdefinition3Enum(){ return 770;} +function Outputdefinition4Enum(){ return 771;} +function Outputdefinition5Enum(){ return 772;} +function Outputdefinition6Enum(){ return 773;} +function Outputdefinition7Enum(){ return 774;} +function Outputdefinition8Enum(){ return 775;} +function Outputdefinition9Enum(){ return 776;} +function Outputdefinition10Enum(){ return 777;} +function Outputdefinition11Enum(){ return 778;} +function Outputdefinition12Enum(){ return 779;} +function Outputdefinition13Enum(){ return 780;} +function Outputdefinition14Enum(){ return 781;} +function Outputdefinition15Enum(){ return 782;} +function Outputdefinition16Enum(){ return 783;} +function Outputdefinition17Enum(){ return 784;} +function Outputdefinition18Enum(){ return 785;} +function Outputdefinition19Enum(){ return 786;} +function Outputdefinition20Enum(){ return 787;} +function Outputdefinition21Enum(){ return 788;} +function Outputdefinition22Enum(){ return 789;} +function Outputdefinition23Enum(){ return 790;} +function Outputdefinition24Enum(){ return 791;} +function Outputdefinition25Enum(){ return 792;} +function Outputdefinition26Enum(){ return 793;} +function Outputdefinition27Enum(){ return 794;} +function Outputdefinition28Enum(){ return 795;} +function Outputdefinition29Enum(){ return 796;} +function Outputdefinition30Enum(){ return 797;} +function Outputdefinition31Enum(){ return 798;} +function Outputdefinition32Enum(){ return 799;} +function Outputdefinition33Enum(){ return 800;} +function Outputdefinition34Enum(){ return 801;} +function Outputdefinition35Enum(){ return 802;} +function Outputdefinition36Enum(){ return 803;} +function Outputdefinition37Enum(){ return 804;} +function Outputdefinition38Enum(){ return 805;} +function Outputdefinition39Enum(){ return 806;} +function Outputdefinition40Enum(){ return 807;} +function Outputdefinition41Enum(){ return 808;} +function Outputdefinition42Enum(){ return 809;} +function Outputdefinition43Enum(){ return 810;} +function Outputdefinition44Enum(){ return 811;} +function Outputdefinition45Enum(){ return 812;} +function Outputdefinition46Enum(){ return 813;} +function Outputdefinition47Enum(){ return 814;} +function Outputdefinition48Enum(){ return 815;} +function Outputdefinition49Enum(){ return 816;} +function Outputdefinition50Enum(){ return 817;} +function Outputdefinition51Enum(){ return 818;} +function Outputdefinition52Enum(){ return 819;} +function Outputdefinition53Enum(){ return 820;} +function Outputdefinition54Enum(){ return 821;} +function Outputdefinition55Enum(){ return 822;} +function Outputdefinition56Enum(){ return 823;} +function Outputdefinition57Enum(){ return 824;} +function Outputdefinition58Enum(){ return 825;} +function Outputdefinition59Enum(){ return 826;} +function Outputdefinition60Enum(){ return 827;} +function Outputdefinition61Enum(){ return 828;} +function Outputdefinition62Enum(){ return 829;} +function Outputdefinition63Enum(){ return 830;} +function Outputdefinition64Enum(){ return 831;} +function Outputdefinition65Enum(){ return 832;} +function Outputdefinition66Enum(){ return 833;} +function Outputdefinition67Enum(){ return 834;} +function Outputdefinition68Enum(){ return 835;} +function Outputdefinition69Enum(){ return 836;} +function Outputdefinition70Enum(){ return 837;} +function Outputdefinition71Enum(){ return 838;} +function Outputdefinition72Enum(){ return 839;} +function Outputdefinition73Enum(){ return 840;} +function Outputdefinition74Enum(){ return 841;} +function Outputdefinition75Enum(){ return 842;} +function Outputdefinition76Enum(){ return 843;} +function Outputdefinition77Enum(){ return 844;} +function Outputdefinition78Enum(){ return 845;} +function Outputdefinition79Enum(){ return 846;} +function Outputdefinition80Enum(){ return 847;} +function Outputdefinition81Enum(){ return 848;} +function Outputdefinition82Enum(){ return 849;} +function Outputdefinition83Enum(){ return 850;} +function Outputdefinition84Enum(){ return 851;} +function Outputdefinition85Enum(){ return 852;} +function Outputdefinition86Enum(){ return 853;} +function Outputdefinition87Enum(){ return 854;} +function Outputdefinition88Enum(){ return 855;} +function Outputdefinition89Enum(){ return 856;} +function Outputdefinition90Enum(){ return 857;} +function Outputdefinition91Enum(){ return 858;} +function Outputdefinition92Enum(){ return 859;} +function Outputdefinition93Enum(){ return 860;} +function Outputdefinition94Enum(){ return 861;} +function Outputdefinition95Enum(){ return 862;} +function Outputdefinition96Enum(){ return 863;} +function Outputdefinition97Enum(){ return 864;} +function Outputdefinition98Enum(){ return 865;} +function Outputdefinition99Enum(){ return 866;} +function Outputdefinition100Enum(){ return 867;} +function OutputdefinitionListEnum(){ return 868;} +function MassfluxatgateEnum(){ return 869;} +function MassfluxatgateNameEnum(){ return 870;} +function MassfluxatgateDefinitionenumEnum(){ return 871;} +function MassfluxatgateSegmentsEnum(){ return 872;} +function NodalvalueEnum(){ return 873;} +function NodalvalueNameEnum(){ return 874;} +function NodalvalueDefinitionenumEnum(){ return 875;} +function NodalvalueModelEnum(){ return 876;} +function NodalvalueNodeEnum(){ return 877;} +function MisfitNameEnum(){ return 878;} +function MisfitDefinitionenumEnum(){ return 879;} +function MisfitModelEnum(){ return 880;} +function MisfitObservationEnum(){ return 881;} +function MisfitObservationEnum(){ return 882;} +function MisfitLocalEnum(){ return 883;} +function MisfitTimeinterpolationEnum(){ return 884;} +function MisfitWeightsEnum(){ return 885;} +function MisfitWeightsEnum(){ return 886;} +function SurfaceObservationEnum(){ return 887;} +function WeightsSurfaceObservationEnum(){ return 888;} +function VxObsEnum(){ return 889;} +function WeightsVxObsEnum(){ return 890;} +function VyObsEnum(){ return 891;} +function WeightsVyObsEnum(){ return 892;} +function MinVelEnum(){ return 893;} +function MaxVelEnum(){ return 894;} +function MinVxEnum(){ return 895;} +function MaxVxEnum(){ return 896;} +function MaxAbsVxEnum(){ return 897;} +function MinVyEnum(){ return 898;} +function MaxVyEnum(){ return 899;} +function MaxAbsVyEnum(){ return 900;} +function MinVzEnum(){ return 901;} +function MaxVzEnum(){ return 902;} +function MaxAbsVzEnum(){ return 903;} +function FloatingAreaEnum(){ return 904;} +function GroundedAreaEnum(){ return 905;} +function IceMassEnum(){ return 906;} +function IceVolumeEnum(){ return 907;} +function IceVolumeAboveFloatationEnum(){ return 908;} +function TotalFloatingBmbEnum(){ return 909;} +function TotalGroundedBmbEnum(){ return 910;} +function TotalSmbEnum(){ return 911;} +function AbsoluteEnum(){ return 912;} +function IncrementalEnum(){ return 913;} +function AugmentedLagrangianREnum(){ return 914;} +function AugmentedLagrangianRhopEnum(){ return 915;} +function AugmentedLagrangianRlambdaEnum(){ return 916;} +function AugmentedLagrangianRholambdaEnum(){ return 917;} +function AugmentedLagrangianThetaEnum(){ return 918;} +function NoneEnum(){ return 919;} +function AggressiveMigrationEnum(){ return 920;} +function SoftMigrationEnum(){ return 921;} +function SubelementMigrationEnum(){ return 922;} +function SubelementMigration2Enum(){ return 923;} +function ContactEnum(){ return 924;} +function GroundingOnlyEnum(){ return 925;} +function MaskGroundediceLevelsetEnum(){ return 926;} +function GaussSegEnum(){ return 927;} +function GaussTriaEnum(){ return 928;} +function GaussTetraEnum(){ return 929;} +function GaussPentaEnum(){ return 930;} +function FSSolverEnum(){ return 931;} +function AdjointEnum(){ return 932;} +function ColinearEnum(){ return 933;} +function ControlSteadyEnum(){ return 934;} +function FsetEnum(){ return 935;} +function Gradient1Enum(){ return 936;} +function Gradient2Enum(){ return 937;} +function Gradient3Enum(){ return 938;} +function GradientEnum(){ return 939;} +function GroundinglineMigrationEnum(){ return 940;} +function GsetEnum(){ return 941;} +function IndexEnum(){ return 942;} +function IndexedEnum(){ return 943;} +function IntersectEnum(){ return 944;} +function NodalEnum(){ return 945;} +function OldGradientEnum(){ return 946;} +function OutputBufferPointerEnum(){ return 947;} +function OutputBufferSizePointerEnum(){ return 948;} +function OutputFilePointerEnum(){ return 949;} +function ToolkitsFileNameEnum(){ return 950;} +function RootPathEnum(){ return 951;} +function OutputFileNameEnum(){ return 952;} +function InputFileNameEnum(){ return 953;} +function LockFileNameEnum(){ return 954;} +function RestartFileNameEnum(){ return 955;} +function ToolkitsOptionsAnalysesEnum(){ return 956;} +function ToolkitsOptionsStringsEnum(){ return 957;} +function QmuErrNameEnum(){ return 958;} +function QmuInNameEnum(){ return 959;} +function QmuOutNameEnum(){ return 960;} +function RegularEnum(){ return 961;} +function ScaledEnum(){ return 962;} +function SeparateEnum(){ return 963;} +function SsetEnum(){ return 964;} +function VerboseEnum(){ return 965;} +function TriangleInterpEnum(){ return 966;} +function BilinearInterpEnum(){ return 967;} +function NearestInterpEnum(){ return 968;} +function XYEnum(){ return 969;} +function XYZEnum(){ return 970;} +function DenseEnum(){ return 971;} +function MpiDenseEnum(){ return 972;} +function MpiSparseEnum(){ return 973;} +function SeqEnum(){ return 974;} +function MpiEnum(){ return 975;} +function MumpsEnum(){ return 976;} +function GslEnum(){ return 977;} +function OptionEnum(){ return 978;} +function GenericOptionEnum(){ return 979;} +function OptionCellEnum(){ return 980;} +function OptionStructEnum(){ return 981;} +function CuffeyEnum(){ return 982;} +function CuffeyTemperateEnum(){ return 983;} +function PatersonEnum(){ return 984;} +function ArrheniusEnum(){ return 985;} +function LliboutryDuvalEnum(){ return 986;} +function SpclevelsetEnum(){ return 987;} +function ExtrapolationVariableEnum(){ return 988;} +function IceMaskNodeActivationEnum(){ return 989;} +function LevelsetfunctionSlopeXEnum(){ return 990;} +function LevelsetfunctionSlopeYEnum(){ return 991;} +function LevelsetfunctionPicardEnum(){ return 992;} +function LevelsetReinitFrequencyEnum(){ return 993;} +function SealevelriseSolutionEnum(){ return 994;} +function SealevelriseAnalysisEnum(){ return 995;} +function SealevelEnum(){ return 996;} +function SealevelEustaticEnum(){ return 997;} +function SealevelriseDeltathicknessEnum(){ return 998;} +function SealevelriseMaxiterEnum(){ return 999;} +function SealevelriseReltolEnum(){ return 1000;} +function SealevelriseAbstolEnum(){ return 1001;} +function SealevelriseLoveHEnum(){ return 1002;} +function SealevelriseLoveKEnum(){ return 1003;} +function SealevelriseTideLoveHEnum(){ return 1004;} +function SealevelriseTideLoveKEnum(){ return 1005;} +function SealevelriseRigidEnum(){ return 1006;} +function SealevelriseElasticEnum(){ return 1007;} +function SealevelriseRotationEnum(){ return 1008;} +function SealevelriseGElasticEnum(){ return 1009;} +function SealevelriseDegaccEnum(){ return 1010;} +function SealevelriseTransitionsEnum(){ return 1011;} +function SealevelriseRequestedOutputsEnum(){ return 1012;} +function SealevelriseNumRequestedOutputsEnum(){ return 1013;} +function ParametersENDEnum(){ return 1014;} +function MaximumNumberOfDefinitionsEnum(){ return 1015;} Index: /issm/trunk-jpl/src/m/enum/EnumDefinitions.py =================================================================== --- /issm/trunk-jpl/src/m/enum/EnumDefinitions.py (revision 20662) +++ /issm/trunk-jpl/src/m/enum/EnumDefinitions.py (revision 20663) @@ -185,5 +185,4 @@ def HydrologySpcheadEnum(): return StringToEnum("HydrologySpchead")[0] def HydrologyConductivityEnum(): return StringToEnum("HydrologyConductivity")[0] -def IndependentObjectEnum(): return StringToEnum("IndependentObject")[0] def InversionControlParametersEnum(): return StringToEnum("InversionControlParameters")[0] def InversionControlScalingFactorsEnum(): return StringToEnum("InversionControlScalingFactors")[0] @@ -229,6 +228,9 @@ def MaterialsRheologyNEnum(): return StringToEnum("MaterialsRheologyN")[0] def MaterialsRheologyKoEnum(): return StringToEnum("MaterialsRheologyKo")[0] +def MaterialsRheologyKobarEnum(): return StringToEnum("MaterialsRheologyKobar")[0] def MaterialsRheologyEcEnum(): return StringToEnum("MaterialsRheologyEc")[0] +def MaterialsRheologyEcbarEnum(): return StringToEnum("MaterialsRheologyEcbar")[0] def MaterialsRheologyEsEnum(): return StringToEnum("MaterialsRheologyEs")[0] +def MaterialsRheologyEsbarEnum(): return StringToEnum("MaterialsRheologyEsbar")[0] def DamageIsdamageEnum(): return StringToEnum("DamageIsdamage")[0] def DamageDEnum(): return StringToEnum("DamageD")[0] @@ -591,5 +593,5 @@ def MaticeEnum(): return StringToEnum("Matice")[0] def MatdamageiceEnum(): return StringToEnum("Matdamageice")[0] -def MatbaflEnum(): return StringToEnum("Matbafl")[0] +def MatearlEnum(): return StringToEnum("Matearl")[0] def MatparEnum(): return StringToEnum("Matpar")[0] def NodeEnum(): return StringToEnum("Node")[0] Index: sm/trunk-jpl/src/m/enum/IndependentObjectEnum.m =================================================================== --- /issm/trunk-jpl/src/m/enum/IndependentObjectEnum.m (revision 20662) +++ (revision ) @@ -1,11 +1,0 @@ -function macro=IndependentObjectEnum() -%INDEPENDENTOBJECTENUM - Enum of IndependentObject -% -% WARNING: DO NOT MODIFY THIS FILE -% this file has been automatically generated by src/c/shared/Enum/Synchronize.sh -% Please read src/c/shared/Enum/README for more information -% -% Usage: -% macro=IndependentObjectEnum() - -macro=StringToEnum('IndependentObject'); Index: sm/trunk-jpl/src/m/enum/MatbaflEnum.m =================================================================== --- /issm/trunk-jpl/src/m/enum/MatbaflEnum.m (revision 20662) +++ (revision ) @@ -1,11 +1,0 @@ -function macro=MatbaflEnum() -%MATBAFLENUM - Enum of Matbafl -% -% WARNING: DO NOT MODIFY THIS FILE -% this file has been automatically generated by src/c/shared/Enum/Synchronize.sh -% Please read src/c/shared/Enum/README for more information -% -% Usage: -% macro=MatbaflEnum() - -macro=StringToEnum('Matbafl'); Index: /issm/trunk-jpl/src/m/enum/MatearlEnum.m =================================================================== --- /issm/trunk-jpl/src/m/enum/MatearlEnum.m (revision 20663) +++ /issm/trunk-jpl/src/m/enum/MatearlEnum.m (revision 20663) @@ -0,0 +1,11 @@ +function macro=MatearlEnum() +%MATEARLENUM - Enum of Matearl +% +% WARNING: DO NOT MODIFY THIS FILE +% this file has been automatically generated by src/c/shared/Enum/Synchronize.sh +% Please read src/c/shared/Enum/README for more information +% +% Usage: +% macro=MatearlEnum() + +macro=StringToEnum('Matearl'); Index: /issm/trunk-jpl/src/m/enum/MaterialsRheologyEcbarEnum.m =================================================================== --- /issm/trunk-jpl/src/m/enum/MaterialsRheologyEcbarEnum.m (revision 20663) +++ /issm/trunk-jpl/src/m/enum/MaterialsRheologyEcbarEnum.m (revision 20663) @@ -0,0 +1,11 @@ +function macro=MaterialsRheologyEcbarEnum() +%MATERIALSRHEOLOGYECBARENUM - Enum of MaterialsRheologyEcbar +% +% WARNING: DO NOT MODIFY THIS FILE +% this file has been automatically generated by src/c/shared/Enum/Synchronize.sh +% Please read src/c/shared/Enum/README for more information +% +% Usage: +% macro=MaterialsRheologyEcbarEnum() + +macro=StringToEnum('MaterialsRheologyEcbar'); Index: /issm/trunk-jpl/src/m/enum/MaterialsRheologyEsbarEnum.m =================================================================== --- /issm/trunk-jpl/src/m/enum/MaterialsRheologyEsbarEnum.m (revision 20663) +++ /issm/trunk-jpl/src/m/enum/MaterialsRheologyEsbarEnum.m (revision 20663) @@ -0,0 +1,11 @@ +function macro=MaterialsRheologyEsbarEnum() +%MATERIALSRHEOLOGYESBARENUM - Enum of MaterialsRheologyEsbar +% +% WARNING: DO NOT MODIFY THIS FILE +% this file has been automatically generated by src/c/shared/Enum/Synchronize.sh +% Please read src/c/shared/Enum/README for more information +% +% Usage: +% macro=MaterialsRheologyEsbarEnum() + +macro=StringToEnum('MaterialsRheologyEsbar'); Index: /issm/trunk-jpl/src/m/enum/MaterialsRheologyKobarEnum.m =================================================================== --- /issm/trunk-jpl/src/m/enum/MaterialsRheologyKobarEnum.m (revision 20663) +++ /issm/trunk-jpl/src/m/enum/MaterialsRheologyKobarEnum.m (revision 20663) @@ -0,0 +1,11 @@ +function macro=MaterialsRheologyKobarEnum() +%MATERIALSRHEOLOGYKOBARENUM - Enum of MaterialsRheologyKobar +% +% WARNING: DO NOT MODIFY THIS FILE +% this file has been automatically generated by src/c/shared/Enum/Synchronize.sh +% Please read src/c/shared/Enum/README for more information +% +% Usage: +% macro=MaterialsRheologyKobarEnum() + +macro=StringToEnum('MaterialsRheologyKobar'); Index: /issm/trunk-jpl/src/m/exp/exptool.m =================================================================== --- /issm/trunk-jpl/src/m/exp/exptool.m (revision 20662) +++ /issm/trunk-jpl/src/m/exp/exptool.m (revision 20663) @@ -158,5 +158,9 @@ undoplots(prevplot); if numprofiles - prevplot2=1; + if ~nofigurecopy, + prevplot2=1; + else + prevplot2=L; + end for i=1:numprofiles if length(A(i).x)==1,