Changeset 20663


Ignore:
Timestamp:
05/29/16 15:10:24 (9 years ago)
Author:
Mathieu Morlighem
Message:

CHG: renaming Bafl flow law -> Earl (empirical Anasotropic Rheology Law)

Location:
issm/trunk-jpl/src
Files:
4 added
2 deleted
12 edited
3 moved

Legend:

Unmodified
Added
Removed

  • issm/trunk-jpl/src/c/Makefile.am

    r20653 r20663  
    6161                                        ./classes/Materials/Materials.cpp\
    6262                                        ./classes/Materials/Matice.cpp\
    63                                         ./classes/Materials/Matbafl.cpp\
     63                                        ./classes/Materials/Matearl.cpp\
    6464                                        ./classes/Materials/Matpar.cpp\
    6565                                        ./classes/Constraints/Constraints.cpp\

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

    r20656 r20663  
    22572257                        if(this->material->IsDamage())this->InputDepthAverageAtBase(DamageDEnum,DamageDbarEnum);
    22582258                        break;
    2259                 case MatbaflEnum:
     2259                case MatearlEnum:
    22602260                        this->InputDepthAverageAtBase(MaterialsRheologyKoEnum,MaterialsRheologyKobarEnum);
    22612261                        this->InputDepthAverageAtBase(MaterialsRheologyEcEnum,MaterialsRheologyEcbarEnum);
    … …  
    22752275                        this->inputs->DeleteInput(DamageDbarEnum);
    22762276                        break;
    2277                 case MatbaflEnum:
     2277                case MatearlEnum:
    22782278                        break;
    22792279                default:

  • issm/trunk-jpl/src/c/classes/Materials/Matearl.cpp

    r20656 r20663  
    1 /*!\file Matbafl.c
    2  * \brief: implementation of the Matbafl object
     1/*!\file Matearl.c
     2 * \brief: implementation of the Matearl object
    33 */
    44
    … …  
    99#endif
    1010
    11 #include "./Matbafl.h"
     11#include "./Matearl.h"
    1212#include "./Materials.h"
    1313#include "../Inputs/Input.h"
    … …  
    2626#include "../../shared/shared.h"
    2727
    28 /*Matbafl constructors and destructor*/
    29 Matbafl::Matbafl(){/*{{{*/
     28/*Matearl constructors and destructor*/
     29Matearl::Matearl(){/*{{{*/
    3030        this->helement=NULL;
    3131        this->element=NULL;
    … …  
    3333}
    3434/*}}}*/
    35 Matbafl::Matbafl(int matbafl_mid,int index, IoModel* iomodel){/*{{{*/
     35Matearl::Matearl(int matearl_mid,int index, IoModel* iomodel){/*{{{*/
    3636
    3737        /*Intermediaries:*/
    38         int    matbafl_eid;
     38        int    matearl_eid;
    3939
    4040        /*Initialize id*/
    41         this->mid=matbafl_mid;
     41        this->mid=matearl_mid;
    4242
    4343        /*Hooks: */
    44         matbafl_eid=index+1;
    45         this->helement=new Hook(&matbafl_eid,1);
     44        matearl_eid=index+1;
     45        this->helement=new Hook(&matearl_eid,1);
    4646        this->element=NULL;
    4747
    … …  
    4949}
    5050/*}}}*/
    51 Matbafl::~Matbafl(){/*{{{*/
     51Matearl::~Matearl(){/*{{{*/
    5252        delete helement;
    5353        return;
    … …  
    5656
    5757/*Object virtual functions definitions:*/
    58 Object*   Matbafl::copy() {/*{{{*/
     58Object*   Matearl::copy() {/*{{{*/
    5959
    6060        /*Output*/
    61         Matbafl* matbafl=NULL;
     61        Matearl* matearl=NULL;
    6262
    6363        /*Initialize output*/
    64         matbafl=new Matbafl();
     64        matearl=new Matearl();
    6565
    6666        /*copy fields: */
    67         matbafl->mid=this->mid;
    68         matbafl->helement=(Hook*)this->helement->copy();
    69         matbafl->element =(Element*)this->helement->delivers();
    70 
    71         return matbafl;
    72 }
    73 /*}}}*/
    74 Material* Matbafl::copy2(Element* element_in) {/*{{{*/
     67        matearl->mid=this->mid;
     68        matearl->helement=(Hook*)this->helement->copy();
     69        matearl->element =(Element*)this->helement->delivers();
     70
     71        return matearl;
     72}
     73/*}}}*/
     74Material* Matearl::copy2(Element* element_in) {/*{{{*/
    7575
    7676        /*Output*/
    77         Matbafl* matbafl=NULL;
     77        Matearl* matearl=NULL;
    7878
    7979        /*Initialize output*/
    80         matbafl=new Matbafl();
     80        matearl=new Matearl();
    8181
    8282        /*copy fields: */
    83         matbafl->mid=this->mid;
    84         matbafl->helement=(Hook*)this->helement->copy();
    85         matbafl->element =element_in;
    86 
    87         return matbafl;
    88 }
    89 /*}}}*/
    90 void      Matbafl::DeepEcho(void){/*{{{*/
    91 
    92         _printf_("Matbafl:\n");
     83        matearl->mid=this->mid;
     84        matearl->helement=(Hook*)this->helement->copy();
     85        matearl->element =element_in;
     86
     87        return matearl;
     88}
     89/*}}}*/
     90void      Matearl::DeepEcho(void){/*{{{*/
     91
     92        _printf_("Matearl:\n");
    9393        _printf_("   mid: " << mid << "\n");
    9494        _printf_("   element:\n");
    … …  
    9696}               
    9797/*}}}*/
    98 void      Matbafl::Echo(void){/*{{{*/
    99 
    100         _printf_("Matbafl:\n");
     98void      Matearl::Echo(void){/*{{{*/
     99
     100        _printf_("Matearl:\n");
    101101        _printf_("   mid: " << mid << "\n");
    102102        _printf_("   element:\n");
    … …  
    104104}
    105105/*}}}*/
    106 int       Matbafl::Id(void){ return mid; }/*{{{*/
    107 /*}}}*/
    108 int       Matbafl::ObjectEnum(void){/*{{{*/
    109 
    110         return MatbaflEnum;
    111 
    112 }
    113 /*}}}*/
    114 void      Matbafl::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
     106int       Matearl::Id(void){ return mid; }/*{{{*/
     107/*}}}*/
     108int       Matearl::ObjectEnum(void){/*{{{*/
     109
     110        return MatearlEnum;
     111
     112}
     113/*}}}*/
     114void      Matearl::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
    115115
    116116        if(marshall_direction==MARSHALLING_BACKWARD)helement=new Hook();
    117117       
    118         MARSHALLING_ENUM(MatbaflEnum);
     118        MARSHALLING_ENUM(MatearlEnum);
    119119        MARSHALLING(mid);
    120120        this->helement->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    … …  
    124124/*}}}*/
    125125
    126 /*Matbafl management*/
    127 void  Matbafl::Configure(Elements* elementsin){/*{{{*/
     126/*Matearl management*/
     127void  Matearl::Configure(Elements* elementsin){/*{{{*/
    128128
    129129        /*Take care of hooking up all objects for this element, ie links the objects in the hooks to their respective
    … …  
    133133}
    134134/*}}}*/
    135 void  Matbafl::SetCurrentConfiguration(Elements* elementsin,Loads* loadsin,Nodes* nodesin,Vertices* verticesin,Materials* materialsin,Parameters* parametersin){/*{{{*/
    136 
    137 }
    138 /*}}}*/
    139 IssmDouble Matbafl::GetA(){/*{{{*/
    140         _error_("not implemented yet");
    141 }
    142 /*}}}*/
    143 IssmDouble Matbafl::GetAbar(){/*{{{*/
    144         _error_("not implemented yet");
    145 }
    146 /*}}}*/
    147 IssmDouble Matbafl::GetB(){/*{{{*/
    148         _error_("not implemented yet");
    149 }
    150 /*}}}*/
    151 IssmDouble Matbafl::GetBbar(){/*{{{*/
    152 
    153         _error_("not implemented yet");
    154 }
    155 /*}}}*/
    156 IssmDouble Matbafl::GetN(){/*{{{*/
    157         _error_("not implemented yet");
    158 }
    159 /*}}}*/
    160 IssmDouble Matbafl::GetD(){/*{{{*/
    161         _error_("not implemented yet");
    162 }
    163 /*}}}*/
    164 IssmDouble Matbafl::GetDbar(){/*{{{*/
    165 
    166         _error_("not implemented yet");
    167 }
    168 /*}}}*/
    169 bool Matbafl::IsDamage(){/*{{{*/
    170 
    171         _error_("not implemented yet");
    172 }
    173 /*}}}*/
    174 void  Matbafl::GetViscosity(IssmDouble* pviscosity,IssmDouble eps_eff){/*{{{*/
     135void  Matearl::SetCurrentConfiguration(Elements* elementsin,Loads* loadsin,Nodes* nodesin,Vertices* verticesin,Materials* materialsin,Parameters* parametersin){/*{{{*/
     136
     137}
     138/*}}}*/
     139IssmDouble Matearl::GetA(){/*{{{*/
     140        _error_("not implemented yet");
     141}
     142/*}}}*/
     143IssmDouble Matearl::GetAbar(){/*{{{*/
     144        _error_("not implemented yet");
     145}
     146/*}}}*/
     147IssmDouble Matearl::GetB(){/*{{{*/
     148        _error_("not implemented yet");
     149}
     150/*}}}*/
     151IssmDouble Matearl::GetBbar(){/*{{{*/
     152
     153        _error_("not implemented yet");
     154}
     155/*}}}*/
     156IssmDouble Matearl::GetN(){/*{{{*/
     157        _error_("not implemented yet");
     158}
     159/*}}}*/
     160IssmDouble Matearl::GetD(){/*{{{*/
     161        _error_("not implemented yet");
     162}
     163/*}}}*/
     164IssmDouble Matearl::GetDbar(){/*{{{*/
     165
     166        _error_("not implemented yet");
     167}
     168/*}}}*/
     169bool Matearl::IsDamage(){/*{{{*/
     170
     171        _error_("not implemented yet");
     172}
     173/*}}}*/
     174void  Matearl::GetViscosity(IssmDouble* pviscosity,IssmDouble eps_eff){/*{{{*/
    175175        _error_("not implemented yet");
    176176        /*From a string tensor and a material object, return viscosity, using Glen's flow law.
    … …  
    221221}
    222222/*}}}*/
    223 void  Matbafl::GetViscosity_B(IssmDouble* pdmudB,IssmDouble eps_eff){/*{{{*/
    224         _error_("not implemented yet");
    225 }
    226 /*}}}*/
    227 void  Matbafl::GetViscosity_D(IssmDouble* pdmudD,IssmDouble eps_eff){/*{{{*/
     223void  Matearl::GetViscosity_B(IssmDouble* pdmudB,IssmDouble eps_eff){/*{{{*/
     224        _error_("not implemented yet");
     225}
     226/*}}}*/
     227void  Matearl::GetViscosity_D(IssmDouble* pdmudD,IssmDouble eps_eff){/*{{{*/
    228228         _error_("not implemented yet");
    229229}
    230230/*}}}*/
    231 void  Matbafl::GetViscosityBar(IssmDouble* pviscosity,IssmDouble eps_eff){/*{{{*/
    232         _error_("not implemented yet");
    233 }
    234 /*}}}*/
    235 void  Matbafl::GetViscosityComplement(IssmDouble* pviscosity_complement, IssmDouble* epsilon){/*{{{*/
    236         _error_("not implemented yet");
    237 }
    238 /*}}}*/
    239 void  Matbafl::GetViscosityDComplement(IssmDouble* pviscosity_complement, IssmDouble* epsilon){/*{{{*/
    240         _error_("not implemented yet");
    241 }
    242 /*}}}*/
    243 void  Matbafl::GetViscosityDerivativeEpsSquare(IssmDouble* pmu_prime, IssmDouble* epsilon){/*{{{*/
    244         _error_("not implemented yet");
    245 }
    246 /*}}}*/
    247 void  Matbafl::GetViscosity2dDerivativeEpsSquare(IssmDouble* pmu_prime, IssmDouble* epsilon){/*{{{*/
    248         _error_("not implemented yet");
    249 }
    250 /*}}}*/
    251 void  Matbafl::InputUpdateFromVector(IssmDouble* vector, int name, int type){/*{{{*/
    252 
    253 }
    254 /*}}}*/
    255 void  Matbafl::InputUpdateFromVectorDakota(IssmDouble* vector, int name, int type){/*{{{*/
    256 
    257 }
    258 /*}}}*/
    259 void  Matbafl::InputUpdateFromMatrixDakota(IssmDouble* matrix, int nrows, int ncols,int name, int type){/*{{{*/
     231void  Matearl::GetViscosityBar(IssmDouble* pviscosity,IssmDouble eps_eff){/*{{{*/
     232        _error_("not implemented yet");
     233}
     234/*}}}*/
     235void  Matearl::GetViscosityComplement(IssmDouble* pviscosity_complement, IssmDouble* epsilon){/*{{{*/
     236        _error_("not implemented yet");
     237}
     238/*}}}*/
     239void  Matearl::GetViscosityDComplement(IssmDouble* pviscosity_complement, IssmDouble* epsilon){/*{{{*/
     240        _error_("not implemented yet");
     241}
     242/*}}}*/
     243void  Matearl::GetViscosityDerivativeEpsSquare(IssmDouble* pmu_prime, IssmDouble* epsilon){/*{{{*/
     244        _error_("not implemented yet");
     245}
     246/*}}}*/
     247void  Matearl::GetViscosity2dDerivativeEpsSquare(IssmDouble* pmu_prime, IssmDouble* epsilon){/*{{{*/
     248        _error_("not implemented yet");
     249}
     250/*}}}*/
     251void  Matearl::InputUpdateFromVector(IssmDouble* vector, int name, int type){/*{{{*/
     252
     253}
     254/*}}}*/
     255void  Matearl::InputUpdateFromVectorDakota(IssmDouble* vector, int name, int type){/*{{{*/
     256
     257}
     258/*}}}*/
     259void  Matearl::InputUpdateFromMatrixDakota(IssmDouble* matrix, int nrows, int ncols,int name, int type){/*{{{*/
    260260        /*Nothing updated yet*/
    261261}
    262262/*}}}*/
    263 void  Matbafl::InputUpdateFromConstant(IssmDouble constant, int name){/*{{{*/
     263void  Matearl::InputUpdateFromConstant(IssmDouble constant, int name){/*{{{*/
    264264        /*Nothing updated yet*/
    265265}
    266266/*}}}*/
    267 void  Matbafl::InputUpdateFromConstant(int constant, int name){/*{{{*/
     267void  Matearl::InputUpdateFromConstant(int constant, int name){/*{{{*/
    268268        /*Nothing updated yet*/
    269269}
    270270/*}}}*/
    271 void  Matbafl::InputUpdateFromConstant(bool constant, int name){/*{{{*/
     271void  Matearl::InputUpdateFromConstant(bool constant, int name){/*{{{*/
    272272        /*Nothing updated yet*/
    273273}
    274274/*}}}*/
    275 void  Matbafl::ViscosityFS(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input){/*{{{*/
     275void  Matearl::ViscosityFS(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input){/*{{{*/
    276276
    277277        /*Intermediaries*/
    … …  
    310310}
    311311/*}}}*/
    312 void  Matbafl::ViscosityFSDerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon){/*{{{*/
     312void  Matearl::ViscosityFSDerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon){/*{{{*/
    313313        this->GetViscosityDerivativeEpsSquare(pmu_prime,epsilon);
    314314}/*}}}*/
    315 void  Matbafl::ViscosityHO(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input){/*{{{*/
     315void  Matearl::ViscosityHO(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input){/*{{{*/
    316316
    317317        /*Intermediaries*/
    … …  
    349349        *pviscosity=GetViscosityGeneral(ko,Ec,Es,vx,vy,vz,&dvx[0],&dvy[0],&dvz[0]);
    350350}/*}}}*/
    351 void  Matbafl::ViscosityHODerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon){/*{{{*/
     351void  Matearl::ViscosityHODerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon){/*{{{*/
    352352        _error_("not implemented yet");
    353353}/*}}}*/
    354 void  Matbafl::ViscosityL1L2(IssmDouble* pviscosity,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* surface_input){/*{{{*/
     354void  Matearl::ViscosityL1L2(IssmDouble* pviscosity,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* surface_input){/*{{{*/
    355355        _error_("not implemented yet");
    356356}/*}}}*/
    357 void  Matbafl::ViscositySSA(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input){/*{{{*/
     357void  Matearl::ViscositySSA(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input){/*{{{*/
    358358        /*Intermediaries*/
    359359        IssmDouble vx,vy,vz;
    … …  
    391391        *pviscosity=GetViscosityGeneral(ko,Ec,Es,vx,vy,vz,&dvx[0],&dvy[0],&dvz[0]);
    392392}/*}}}*/
    393 void  Matbafl::ViscositySSADerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon){/*{{{*/
     393void  Matearl::ViscositySSADerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon){/*{{{*/
    394394        _error_("not implemented yet");
    395395}/*}}}*/
    396 void  Matbafl::ResetHooks(){/*{{{*/
     396void  Matearl::ResetHooks(){/*{{{*/
    397397
    398398        this->element=NULL;
    … …  
    403403}
    404404/*}}}*/
    405 IssmDouble Matbafl::GetViscosityGeneral(IssmDouble ko,IssmDouble Ec, IssmDouble Es,IssmDouble vx,IssmDouble vy,IssmDouble vz,IssmDouble* dvx,IssmDouble* dvy,IssmDouble* dvz){/*{{{*/
     405IssmDouble Matearl::GetViscosityGeneral(IssmDouble ko,IssmDouble Ec, IssmDouble Es,IssmDouble vx,IssmDouble vy,IssmDouble vz,IssmDouble* dvx,IssmDouble* dvy,IssmDouble* dvz){/*{{{*/
    406406
    407407        /*Intermediaries*/

  • issm/trunk-jpl/src/c/classes/Materials/Matearl.h

    r20656 r20663  
    1 /*!\file Matbafl.h
     1/*!\file Matearl.h
    22 * \brief: header file for matice object
    33 */
    44
    5 #ifndef MATBAFL_H_
    6 #define MATBAFL_H_
     5#ifndef MATEARL_H_
     6#define MATEARL_H_
    77
    88/*Headers:*/
    … …  
    2222/*}}}*/
    2323
    24 class Matbafl: public Material{
     24class Matearl: public Material{
    2525
    2626        private:
    … …  
    3030
    3131        public:
    32                 /*Matbafl constructors, destructors: {{{*/
    33                 Matbafl();
    34                 Matbafl(int mid,int i, IoModel* iomodel);
    35                 ~Matbafl();
     32                /*Matearl constructors, destructors: {{{*/
     33                Matearl();
     34                Matearl(int mid,int i, IoModel* iomodel);
     35                ~Matearl();
    3636                /*}}}*/
    3737                /*Object virtual functions definitions:{{{ */
    … …  
    8585};
    8686
    87 #endif  /* _MATBAFL_H_ */
     87#endif  /* _MATEARL_H_ */

  • issm/trunk-jpl/src/c/classes/Materials/Matpar.cpp

    r20645 r20663  
    8282                case MaticeEnum:
    8383                case MatdamageiceEnum:
    84                 case MatbaflEnum:
     84                case MatearlEnum:
    8585                        iomodel->FindConstant(&this->rho_ice,MaterialsRhoIceEnum);
    8686                        iomodel->FindConstant(&this->rho_water,MaterialsRhoSeawaterEnum);

  • issm/trunk-jpl/src/c/classes/classes.h

    r20654 r20663  
    8383#include "./Materials/Material.h"
    8484#include "./Materials/Matice.h"
    85 #include "./Materials/Matbafl.h"
     85#include "./Materials/Matearl.h"
    8686#include "./Materials/Matpar.h"
    8787

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateElementsVerticesAndMaterials.cpp

    r20649 r20663  
    7979                        }
    8080                        break;
    81                 case MatbaflEnum:
     81                case MatearlEnum:
    8282                        iomodel->FetchDataToInput(elements,MaterialsRheologyKoEnum);
    8383                        iomodel->FetchDataToInput(elements,MaterialsRheologyEcEnum);
    8484                        iomodel->FetchDataToInput(elements,MaterialsRheologyEsEnum);
    85                         for(i=0;i<iomodel->numberofelements;i++) if(iomodel->my_elements[i]) materials->AddObject(new Matbafl(i+1,i,iomodel));
     85                        for(i=0;i<iomodel->numberofelements;i++) if(iomodel->my_elements[i]) materials->AddObject(new Matearl(i+1,i,iomodel));
    8686                        switch(iomodel->domaindim){
    8787                                case 2:

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

    r20654 r20663  
    611611        MaticeEnum,
    612612        MatdamageiceEnum,
    613         MatbaflEnum,
     613        MatearlEnum,
    614614        MatparEnum,
    615615        NodeEnum,

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

    r20654 r20663  
    601601                case MaticeEnum : return "Matice";
    602602                case MatdamageiceEnum : return "Matdamageice";
    603                 case MatbaflEnum : return "Matbafl";
     603                case MatearlEnum : return "Matearl";
    604604                case MatparEnum : return "Matpar";
    605605                case NodeEnum : return "Node";

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

    r20654 r20663  
    613613              else if (strcmp(name,"Matice")==0) return MaticeEnum;
    614614              else if (strcmp(name,"Matdamageice")==0) return MatdamageiceEnum;
    615               else if (strcmp(name,"Matbafl")==0) return MatbaflEnum;
     615              else if (strcmp(name,"Matearl")==0) return MatearlEnum;
    616616              else if (strcmp(name,"Matpar")==0) return MatparEnum;
    617617              else if (strcmp(name,"Node")==0) return NodeEnum;

  • issm/trunk-jpl/src/c/shared/FSanalyticals/fsanalyticals.cpp

    r20649 r20663  
    99 * case 6: 3d test with sinusoidal functions, non homogeneous Dirichlet conditions
    1010 *
    11  * case 201: 3d test quadratic functions, BAFL flow law
     11 * case 201: 3d test quadratic functions, EARL flow law
    1212 */
    1313

  • issm/trunk-jpl/src/m/classes/matearl.m

    r20656 r20663  
    22%
    33%   Usage:
    4 %      matbafl=matbafl();
    5 
    6 classdef matbafl
     4%      matearl=matearl();
     5
     6classdef matearl
    77        properties (SetAccess=public)
    88                rho_ice                    = 0.;
    … …  
    3939                        self.rheology_Es=project3d(md,'vector',self.rheology_Es,'type','node');
    4040                end % }}}
    41                 function self = matbafl(varargin) % {{{
     41                function self = matearl(varargin) % {{{
    4242                        switch nargin
    4343                                case 0
    … …  
    4545                                case 1
    4646                                        inputstruct=varargin{1};
    47                                         list1 = properties('matbafl');
     47                                        list1 = properties('matearl');
    4848                                        list2 = fieldnames(inputstruct);
    4949                                        for i=1:length(list1)
    … …  
    156156                end % }}}
    157157                function marshall(self,md,fid) % {{{
    158                         WriteData(fid,'enum',MaterialsEnum(),'data',MatbaflEnum(),'format','Integer');
     158                        WriteData(fid,'enum',MaterialsEnum(),'data',MatearlEnum(),'format','Integer');
    159159                        WriteData(fid,'object',self,'class','materials','fieldname','rho_ice','format','Double');
    160160                        WriteData(fid,'object',self,'class','materials','fieldname','rho_water','enum',MaterialsRhoSeawaterEnum(),'format','Double');

  • issm/trunk-jpl/src/m/enum/EnumDefinitions.js

    r20644 r20663  
    178178function HydrologySpcheadEnum(){ return 174;}
    179179function HydrologyConductivityEnum(){ return 175;}
    180 function IndependentObjectEnum(){ return 176;}
    181 function InversionControlParametersEnum(){ return 177;}
    182 function InversionControlScalingFactorsEnum(){ return 178;}
    183 function InversionCostFunctionThresholdEnum(){ return 179;}
    184 function InversionCostFunctionsCoefficientsEnum(){ return 180;}
    185 function InversionCostFunctionsEnum(){ return 181;}
    186 function InversionGradientScalingEnum(){ return 182;}
    187 function InversionIscontrolEnum(){ return 183;}
    188 function InversionTypeEnum(){ return 184;}
    189 function InversionIncompleteAdjointEnum(){ return 185;}
    190 function InversionMaxParametersEnum(){ return 186;}
    191 function InversionMaxiterPerStepEnum(){ return 187;}
    192 function InversionMaxiterEnum(){ return 188;}
    193 function InversionMaxstepsEnum(){ return 189;}
    194 function InversionFatolEnum(){ return 190;}
    195 function InversionFrtolEnum(){ return 191;}
    196 function InversionGatolEnum(){ return 192;}
    197 function InversionGrtolEnum(){ return 193;}
    198 function InversionGttolEnum(){ return 194;}
    199 function InversionAlgorithmEnum(){ return 195;}
    200 function InversionMinParametersEnum(){ return 196;}
    201 function InversionNstepsEnum(){ return 197;}
    202 function InversionDxminEnum(){ return 198;}
    203 function InversionNumControlParametersEnum(){ return 199;}
    204 function InversionNumCostFunctionsEnum(){ return 200;}
    205 function InversionStepThresholdEnum(){ return 201;}
    206 function InversionThicknessObsEnum(){ return 202;}
    207 function InversionSurfaceObsEnum(){ return 203;}
    208 function InversionVxObsEnum(){ return 204;}
    209 function InversionVyObsEnum(){ return 205;}
    210 function InversionVzObsEnum(){ return 206;}
    211 function MaskIceLevelsetEnum(){ return 207;}
    212 function MaskOceanLevelsetEnum(){ return 208;}
    213 function MaskLandLevelsetEnum(){ return 209;}
    214 function MaterialsBetaEnum(){ return 210;}
    215 function MaterialsHeatcapacityEnum(){ return 211;}
    216 function MaterialsLatentheatEnum(){ return 212;}
    217 function MaterialsMeltingpointEnum(){ return 213;}
    218 function MaterialsMixedLayerCapacityEnum(){ return 214;}
    219 function MaterialsRheologyBEnum(){ return 215;}
    220 function MaterialsRheologyBbarEnum(){ return 216;}
    221 function MaterialsRheologyLawEnum(){ return 217;}
    222 function MaterialsRheologyNEnum(){ return 218;}
    223 function MaterialsRheologyKoEnum(){ return 219;}
     180function InversionControlParametersEnum(){ return 176;}
     181function InversionControlScalingFactorsEnum(){ return 177;}
     182function InversionCostFunctionThresholdEnum(){ return 178;}
     183function InversionCostFunctionsCoefficientsEnum(){ return 179;}
     184function InversionCostFunctionsEnum(){ return 180;}
     185function InversionGradientScalingEnum(){ return 181;}
     186function InversionIscontrolEnum(){ return 182;}
     187function InversionTypeEnum(){ return 183;}
     188function InversionIncompleteAdjointEnum(){ return 184;}
     189function InversionMaxParametersEnum(){ return 185;}
     190function InversionMaxiterPerStepEnum(){ return 186;}
     191function InversionMaxiterEnum(){ return 187;}
     192function InversionMaxstepsEnum(){ return 188;}
     193function InversionFatolEnum(){ return 189;}
     194function InversionFrtolEnum(){ return 190;}
     195function InversionGatolEnum(){ return 191;}
     196function InversionGrtolEnum(){ return 192;}
     197function InversionGttolEnum(){ return 193;}
     198function InversionAlgorithmEnum(){ return 194;}
     199function InversionMinParametersEnum(){ return 195;}
     200function InversionNstepsEnum(){ return 196;}
     201function InversionDxminEnum(){ return 197;}
     202function InversionNumControlParametersEnum(){ return 198;}
     203function InversionNumCostFunctionsEnum(){ return 199;}
     204function InversionStepThresholdEnum(){ return 200;}
     205function InversionThicknessObsEnum(){ return 201;}
     206function InversionSurfaceObsEnum(){ return 202;}
     207function InversionVxObsEnum(){ return 203;}
     208function InversionVyObsEnum(){ return 204;}
     209function InversionVzObsEnum(){ return 205;}
     210function MaskIceLevelsetEnum(){ return 206;}
     211function MaskOceanLevelsetEnum(){ return 207;}
     212function MaskLandLevelsetEnum(){ return 208;}
     213function MaterialsBetaEnum(){ return 209;}
     214function MaterialsHeatcapacityEnum(){ return 210;}
     215function MaterialsLatentheatEnum(){ return 211;}
     216function MaterialsMeltingpointEnum(){ return 212;}
     217function MaterialsMixedLayerCapacityEnum(){ return 213;}
     218function MaterialsRheologyBEnum(){ return 214;}
     219function MaterialsRheologyBbarEnum(){ return 215;}
     220function MaterialsRheologyLawEnum(){ return 216;}
     221function MaterialsRheologyNEnum(){ return 217;}
     222function MaterialsRheologyKoEnum(){ return 218;}
     223function MaterialsRheologyKobarEnum(){ return 219;}
    224224function MaterialsRheologyEcEnum(){ return 220;}
    225 function MaterialsRheologyEsEnum(){ return 221;}
    226 function DamageIsdamageEnum(){ return 222;}
    227 function DamageDEnum(){ return 223;}
    228 function DamageFEnum(){ return 224;}
    229 function DamageDbarEnum(){ return 225;}
    230 function DamageLawEnum(){ return 226;}
    231 function DamageC1Enum(){ return 227;}
    232 function DamageC2Enum(){ return 228;}
    233 function DamageC3Enum(){ return 229;}
    234 function DamageC4Enum(){ return 230;}
    235 function DamageElementinterpEnum(){ return 231;}
    236 function DamageHealingEnum(){ return 232;}
    237 function DamageStressThresholdEnum(){ return 233;}
    238 function DamageKappaEnum(){ return 234;}
    239 function DamageStabilizationEnum(){ return 235;}
    240 function DamageMaxiterEnum(){ return 236;}
    241 function DamageSpcdamageEnum(){ return 237;}
    242 function DamageMaxDamageEnum(){ return 238;}
    243 function DamageEquivStressEnum(){ return 239;}
    244 function DamageEvolutionNumRequestedOutputsEnum(){ return 240;}
    245 function DamageEvolutionRequestedOutputsEnum(){ return 241;}
    246 function DamageEnum(){ return 242;}
    247 function NewDamageEnum(){ return 243;}
    248 function StressIntensityFactorEnum(){ return 244;}
    249 function CalvingLawEnum(){ return 245;}
    250 function CalvingCalvingrateEnum(){ return 246;}
    251 function CalvingMeltingrateEnum(){ return 247;}
    252 function CalvingLevermannEnum(){ return 248;}
    253 function CalvingDevEnum(){ return 249;}
    254 function DefaultCalvingEnum(){ return 250;}
    255 function CalvingRequestedOutputsEnum(){ return 251;}
    256 function CalvinglevermannCoeffEnum(){ return 252;}
    257 function CalvinglevermannMeltingrateEnum(){ return 253;}
    258 function CalvingdevCoeffEnum(){ return 254;}
    259 function CalvingratexEnum(){ return 255;}
    260 function CalvingrateyEnum(){ return 256;}
    261 function CalvingratexAverageEnum(){ return 257;}
    262 function CalvingrateyAverageEnum(){ return 258;}
    263 function StrainRateparallelEnum(){ return 259;}
    264 function StrainRateperpendicularEnum(){ return 260;}
    265 function StrainRateeffectiveEnum(){ return 261;}
    266 function MaterialsRhoIceEnum(){ return 262;}
    267 function MaterialsRhoSeawaterEnum(){ return 263;}
    268 function MaterialsRhoFreshwaterEnum(){ return 264;}
    269 function MaterialsMuWaterEnum(){ return 265;}
    270 function MaterialsThermalExchangeVelocityEnum(){ return 266;}
    271 function MaterialsThermalconductivityEnum(){ return 267;}
    272 function MaterialsTemperateiceconductivityEnum(){ return 268;}
    273 function MaterialsLithosphereShearModulusEnum(){ return 269;}
    274 function MaterialsLithosphereDensityEnum(){ return 270;}
    275 function MaterialsMantleShearModulusEnum(){ return 271;}
    276 function MaterialsMantleDensityEnum(){ return 272;}
    277 function MaterialsEarthDensityEnum(){ return 273;}
    278 function MeshAverageVertexConnectivityEnum(){ return 274;}
    279 function MeshElements2dEnum(){ return 275;}
    280 function MeshElementsEnum(){ return 276;}
    281 function MeshLowerelementsEnum(){ return 277;}
    282 function MeshNumberofelements2dEnum(){ return 278;}
    283 function MeshNumberofelementsEnum(){ return 279;}
    284 function MeshNumberoflayersEnum(){ return 280;}
    285 function MeshNumberofvertices2dEnum(){ return 281;}
    286 function MeshNumberofverticesEnum(){ return 282;}
    287 function MeshUpperelementsEnum(){ return 283;}
    288 function MeshVertexonbaseEnum(){ return 284;}
    289 function MeshVertexonsurfaceEnum(){ return 285;}
    290 function MeshVertexonboundaryEnum(){ return 286;}
    291 function MeshXEnum(){ return 287;}
    292 function MeshYEnum(){ return 288;}
    293 function MeshZEnum(){ return 289;}
    294 function MeshLatEnum(){ return 290;}
    295 function MeshLongEnum(){ return 291;}
    296 function MeshREnum(){ return 292;}
    297 function MeshElementtypeEnum(){ return 293;}
    298 function MeshSegmentsEnum(){ return 294;}
    299 function DomainTypeEnum(){ return 295;}
    300 function DomainDimensionEnum(){ return 296;}
    301 function Domain2DhorizontalEnum(){ return 297;}
    302 function Domain2DverticalEnum(){ return 298;}
    303 function Domain3DEnum(){ return 299;}
    304 function Domain3DsurfaceEnum(){ return 300;}
    305 function MiscellaneousNameEnum(){ return 301;}
    306 function MasstransportHydrostaticAdjustmentEnum(){ return 302;}
    307 function MasstransportIsfreesurfaceEnum(){ return 303;}
    308 function MasstransportMinThicknessEnum(){ return 304;}
    309 function MasstransportPenaltyFactorEnum(){ return 305;}
    310 function MasstransportSpcthicknessEnum(){ return 306;}
    311 function MasstransportStabilizationEnum(){ return 307;}
    312 function MasstransportVertexPairingEnum(){ return 308;}
    313 function MasstransportNumRequestedOutputsEnum(){ return 309;}
    314 function MasstransportRequestedOutputsEnum(){ return 310;}
    315 function QmuIsdakotaEnum(){ return 311;}
    316 function MassFluxSegmentsEnum(){ return 312;}
    317 function MassFluxSegmentsPresentEnum(){ return 313;}
    318 function QmuMassFluxSegmentsPresentEnum(){ return 314;}
    319 function QmuNumberofpartitionsEnum(){ return 315;}
    320 function QmuNumberofresponsesEnum(){ return 316;}
    321 function QmuPartitionEnum(){ return 317;}
    322 function QmuResponsedescriptorsEnum(){ return 318;}
    323 function QmuVariabledescriptorsEnum(){ return 319;}
    324 function RiftsNumriftsEnum(){ return 320;}
    325 function RiftsRiftstructEnum(){ return 321;}
    326 function SettingsResultsOnNodesEnum(){ return 322;}
    327 function SettingsIoGatherEnum(){ return 323;}
    328 function SettingsLowmemEnum(){ return 324;}
    329 function SettingsOutputFrequencyEnum(){ return 325;}
    330 function SettingsRecordingFrequencyEnum(){ return 326;}
    331 function SettingsWaitonlockEnum(){ return 327;}
    332 function DebugProfilingEnum(){ return 328;}
    333 function ProfilingCurrentMemEnum(){ return 329;}
    334 function ProfilingCurrentFlopsEnum(){ return 330;}
    335 function ProfilingSolutionTimeEnum(){ return 331;}
    336 function SteadystateMaxiterEnum(){ return 332;}
    337 function SteadystateNumRequestedOutputsEnum(){ return 333;}
    338 function SteadystateReltolEnum(){ return 334;}
    339 function SteadystateRequestedOutputsEnum(){ return 335;}
    340 function SurfaceEnum(){ return 336;}
    341 function ThermalIsenthalpyEnum(){ return 337;}
    342 function ThermalIsdynamicbasalspcEnum(){ return 338;}
    343 function ThermalReltolEnum(){ return 339;}
    344 function ThermalMaxiterEnum(){ return 340;}
    345 function ThermalPenaltyFactorEnum(){ return 341;}
    346 function ThermalPenaltyLockEnum(){ return 342;}
    347 function ThermalPenaltyThresholdEnum(){ return 343;}
    348 function ThermalSpctemperatureEnum(){ return 344;}
    349 function ThermalStabilizationEnum(){ return 345;}
    350 function ThermalNumRequestedOutputsEnum(){ return 346;}
    351 function ThermalRequestedOutputsEnum(){ return 347;}
    352 function GiaMantleViscosityEnum(){ return 348;}
    353 function GiaLithosphereThicknessEnum(){ return 349;}
    354 function ThicknessEnum(){ return 350;}
    355 function TimesteppingStartTimeEnum(){ return 351;}
    356 function TimesteppingFinalTimeEnum(){ return 352;}
    357 function TimesteppingCflCoefficientEnum(){ return 353;}
    358 function TimesteppingTimeAdaptEnum(){ return 354;}
    359 function TimesteppingTimeStepEnum(){ return 355;}
    360 function TimesteppingInterpForcingsEnum(){ return 356;}
    361 function TransientIssmbEnum(){ return 357;}
    362 function TransientIscouplerEnum(){ return 358;}
    363 function TransientIsstressbalanceEnum(){ return 359;}
    364 function TransientIsgroundinglineEnum(){ return 360;}
    365 function TransientIsmasstransportEnum(){ return 361;}
    366 function TransientIsthermalEnum(){ return 362;}
    367 function TransientIsgiaEnum(){ return 363;}
    368 function TransientIsdamageevolutionEnum(){ return 364;}
    369 function TransientIshydrologyEnum(){ return 365;}
    370 function TransientIsmovingfrontEnum(){ return 366;}
    371 function TransientIsslrEnum(){ return 367;}
    372 function TransientNumRequestedOutputsEnum(){ return 368;}
    373 function TransientRequestedOutputsEnum(){ return 369;}
    374 function PotentialEnum(){ return 370;}
    375 function BalancethicknessSpcpotentialEnum(){ return 371;}
    376 function BalancethicknessApparentMassbalanceEnum(){ return 372;}
    377 function Balancethickness2MisfitEnum(){ return 373;}
    378 function BalancethicknessDiffusionCoefficientEnum(){ return 374;}
    379 function BalancethicknessCmuEnum(){ return 375;}
    380 function BalancethicknessOmegaEnum(){ return 376;}
    381 function BalancethicknessD0Enum(){ return 377;}
    382 function SmbEnum(){ return 378;}
    383 function SmbAnalysisEnum(){ return 379;}
    384 function SmbSolutionEnum(){ return 380;}
    385 function SmbNumRequestedOutputsEnum(){ return 381;}
    386 function SmbRequestedOutputsEnum(){ return 382;}
    387 function SmbIsInitializedEnum(){ return 383;}
    388 function SMBforcingEnum(){ return 384;}
    389 function SmbMassBalanceEnum(){ return 385;}
    390 function SMBgembEnum(){ return 386;}
    391 function SmbInitDensityScalingEnum(){ return 387;}
    392 function SmbTaEnum(){ return 388;}
    393 function SmbVEnum(){ return 389;}
    394 function SmbDswrfEnum(){ return 390;}
    395 function SmbDlwrfEnum(){ return 391;}
    396 function SmbPEnum(){ return 392;}
    397 function SmbSwfEnum(){ return 393;}
    398 function SmbEAirEnum(){ return 394;}
    399 function SmbPAirEnum(){ return 395;}
    400 function SmbTmeanEnum(){ return 396;}
    401 function SmbCEnum(){ return 397;}
    402 function SmbTzEnum(){ return 398;}
    403 function SmbVzEnum(){ return 399;}
    404 function SmbDtEnum(){ return 400;}
    405 function SmbDzEnum(){ return 401;}
    406 function SmbAIdxEnum(){ return 402;}
    407 function SmbSwIdxEnum(){ return 403;}
    408 function SmbDenIdxEnum(){ return 404;}
    409 function SmbZTopEnum(){ return 405;}
    410 function SmbDzTopEnum(){ return 406;}
    411 function SmbDzMinEnum(){ return 407;}
    412 function SmbZYEnum(){ return 408;}
    413 function SmbZMaxEnum(){ return 409;}
    414 function SmbZMinEnum(){ return 410;}
    415 function SmbOutputFreqEnum(){ return 411;}
    416 function SmbASnowEnum(){ return 412;}
    417 function SmbAIceEnum(){ return 413;}
    418 function SmbCldFracEnum(){ return 414;}
    419 function SmbT0wetEnum(){ return 415;}
    420 function SmbT0dryEnum(){ return 416;}
    421 function SmbKEnum(){ return 417;}
    422 function SmbDEnum(){ return 418;}
    423 function SmbReEnum(){ return 419;}
    424 function SmbGdnEnum(){ return 420;}
    425 function SmbGspEnum(){ return 421;}
    426 function SmbECEnum(){ return 422;}
    427 function SmbCondensationEnum(){ return 423;}
    428 function SmbWEnum(){ return 424;}
    429 function SmbAEnum(){ return 425;}
    430 function SmbTEnum(){ return 426;}
    431 function SmbIsgraingrowthEnum(){ return 427;}
    432 function SmbIsalbedoEnum(){ return 428;}
    433 function SmbIsshortwaveEnum(){ return 429;}
    434 function SmbIsthermalEnum(){ return 430;}
    435 function SmbIsaccumulationEnum(){ return 431;}
    436 function SmbIsmeltEnum(){ return 432;}
    437 function SmbIsdensificationEnum(){ return 433;}
    438 function SmbIsturbulentfluxEnum(){ return 434;}
    439 function SMBpddEnum(){ return 435;}
    440 function SmbDelta18oEnum(){ return 436;}
    441 function SmbDelta18oSurfaceEnum(){ return 437;}
    442 function SmbIsdelta18oEnum(){ return 438;}
    443 function SmbIsmungsmEnum(){ return 439;}
    444 function SmbIsd18opdEnum(){ return 440;}
    445 function SmbPrecipitationsPresentdayEnum(){ return 441;}
    446 function SmbPrecipitationsLgmEnum(){ return 442;}
    447 function SmbTemperaturesPresentdayEnum(){ return 443;}
    448 function SmbTemperaturesLgmEnum(){ return 444;}
    449 function SmbPrecipitationEnum(){ return 445;}
    450 function SmbDesfacEnum(){ return 446;}
    451 function SmbS0pEnum(){ return 447;}
    452 function SmbS0tEnum(){ return 448;}
    453 function SmbRlapsEnum(){ return 449;}
    454 function SmbRlapslgmEnum(){ return 450;}
    455 function SmbPfacEnum(){ return 451;}
    456 function SmbTdiffEnum(){ return 452;}
    457 function SmbSealevEnum(){ return 453;}
    458 function SMBd18opddEnum(){ return 454;}
    459 function SmbDpermilEnum(){ return 455;}
    460 function SMBgradientsEnum(){ return 456;}
    461 function SmbMonthlytemperaturesEnum(){ return 457;}
    462 function SmbHrefEnum(){ return 458;}
    463 function SmbSmbrefEnum(){ return 459;}
    464 function SmbBPosEnum(){ return 460;}
    465 function SmbBNegEnum(){ return 461;}
    466 function SMBhenningEnum(){ return 462;}
    467 function SMBcomponentsEnum(){ return 463;}
    468 function SmbAccumulationEnum(){ return 464;}
    469 function SmbEvaporationEnum(){ return 465;}
    470 function SmbRunoffEnum(){ return 466;}
    471 function SMBmeltcomponentsEnum(){ return 467;}
    472 function SmbMeltEnum(){ return 468;}
    473 function SmbRefreezeEnum(){ return 469;}
    474 function SMBgcmEnum(){ return 470;}
    475 function SmbIspddEnum(){ return 471;}
    476 function SmbIssmbgradientsEnum(){ return 472;}
    477 function SolutionTypeEnum(){ return 473;}
    478 function AnalysisTypeEnum(){ return 474;}
    479 function ConfigurationTypeEnum(){ return 475;}
    480 function AdjointBalancethicknessAnalysisEnum(){ return 476;}
    481 function AdjointBalancethickness2AnalysisEnum(){ return 477;}
    482 function AdjointHorizAnalysisEnum(){ return 478;}
    483 function AnalysisCounterEnum(){ return 479;}
    484 function DefaultAnalysisEnum(){ return 480;}
    485 function BalancethicknessAnalysisEnum(){ return 481;}
    486 function BalancethicknessSolutionEnum(){ return 482;}
    487 function Balancethickness2AnalysisEnum(){ return 483;}
    488 function Balancethickness2SolutionEnum(){ return 484;}
    489 function BalancethicknessSoftAnalysisEnum(){ return 485;}
    490 function BalancethicknessSoftSolutionEnum(){ return 486;}
    491 function BalancevelocityAnalysisEnum(){ return 487;}
    492 function BalancevelocitySolutionEnum(){ return 488;}
    493 function L2ProjectionEPLAnalysisEnum(){ return 489;}
    494 function L2ProjectionBaseAnalysisEnum(){ return 490;}
    495 function BedSlopeSolutionEnum(){ return 491;}
    496 function DamageEvolutionSolutionEnum(){ return 492;}
    497 function DamageEvolutionAnalysisEnum(){ return 493;}
    498 function StressbalanceAnalysisEnum(){ return 494;}
    499 function StressbalanceSIAAnalysisEnum(){ return 495;}
    500 function StressbalanceSolutionEnum(){ return 496;}
    501 function StressbalanceVerticalAnalysisEnum(){ return 497;}
    502 function EnthalpyAnalysisEnum(){ return 498;}
    503 function FlaimAnalysisEnum(){ return 499;}
    504 function FlaimSolutionEnum(){ return 500;}
    505 function HydrologyShreveAnalysisEnum(){ return 501;}
    506 function HydrologyDCInefficientAnalysisEnum(){ return 502;}
    507 function HydrologyDCEfficientAnalysisEnum(){ return 503;}
    508 function HydrologySommersAnalysisEnum(){ return 504;}
    509 function HydrologySolutionEnum(){ return 505;}
    510 function MeltingAnalysisEnum(){ return 506;}
    511 function MasstransportAnalysisEnum(){ return 507;}
    512 function MasstransportSolutionEnum(){ return 508;}
    513 function FreeSurfaceBaseAnalysisEnum(){ return 509;}
    514 function FreeSurfaceTopAnalysisEnum(){ return 510;}
    515 function SurfaceNormalVelocityEnum(){ return 511;}
    516 function ExtrudeFromBaseAnalysisEnum(){ return 512;}
    517 function ExtrudeFromTopAnalysisEnum(){ return 513;}
    518 function DepthAverageAnalysisEnum(){ return 514;}
    519 function SteadystateSolutionEnum(){ return 515;}
    520 function SurfaceSlopeSolutionEnum(){ return 516;}
    521 function SmoothAnalysisEnum(){ return 517;}
    522 function ThermalAnalysisEnum(){ return 518;}
    523 function ThermalSolutionEnum(){ return 519;}
    524 function TransientSolutionEnum(){ return 520;}
    525 function UzawaPressureAnalysisEnum(){ return 521;}
    526 function GiaSolutionEnum(){ return 522;}
    527 function GiaAnalysisEnum(){ return 523;}
    528 function MeshdeformationSolutionEnum(){ return 524;}
    529 function MeshdeformationAnalysisEnum(){ return 525;}
    530 function LevelsetAnalysisEnum(){ return 526;}
    531 function LevelsetStabilizationEnum(){ return 527;}
    532 function ExtrapolationAnalysisEnum(){ return 528;}
    533 function LsfReinitializationAnalysisEnum(){ return 529;}
    534 function ApproximationEnum(){ return 530;}
    535 function NoneApproximationEnum(){ return 531;}
    536 function SIAApproximationEnum(){ return 532;}
    537 function SSAApproximationEnum(){ return 533;}
    538 function SSAHOApproximationEnum(){ return 534;}
    539 function SSAFSApproximationEnum(){ return 535;}
    540 function L1L2ApproximationEnum(){ return 536;}
    541 function HOApproximationEnum(){ return 537;}
    542 function HOFSApproximationEnum(){ return 538;}
    543 function FSApproximationEnum(){ return 539;}
    544 function FSvelocityEnum(){ return 540;}
    545 function FSpressureEnum(){ return 541;}
    546 function DataSetEnum(){ return 542;}
    547 function ConstraintsEnum(){ return 543;}
    548 function LoadsEnum(){ return 544;}
    549 function MaterialsEnum(){ return 545;}
    550 function NodesEnum(){ return 546;}
    551 function ContoursEnum(){ return 547;}
    552 function ParametersEnum(){ return 548;}
    553 function VerticesEnum(){ return 549;}
    554 function ResultsEnum(){ return 550;}
    555 function GenericParamEnum(){ return 551;}
    556 function AdolcParamEnum(){ return 552;}
    557 function BoolInputEnum(){ return 553;}
    558 function BoolParamEnum(){ return 554;}
    559 function ContourEnum(){ return 555;}
    560 function ControlInputEnum(){ return 556;}
    561 function DatasetInputEnum(){ return 557;}
    562 function DoubleInputEnum(){ return 558;}
    563 function DoubleArrayInputEnum(){ return 559;}
    564 function DataSetParamEnum(){ return 560;}
    565 function DoubleMatArrayParamEnum(){ return 561;}
    566 function DoubleMatParamEnum(){ return 562;}
    567 function DoubleParamEnum(){ return 563;}
    568 function DoubleVecParamEnum(){ return 564;}
    569 function ElementEnum(){ return 565;}
    570 function ElementHookEnum(){ return 566;}
    571 function HookEnum(){ return 567;}
    572 function ExternalResultEnum(){ return 568;}
    573 function FileParamEnum(){ return 569;}
    574 function InputEnum(){ return 570;}
    575 function IntInputEnum(){ return 571;}
    576 function InputToExtrudeEnum(){ return 572;}
    577 function InputToL2ProjectEnum(){ return 573;}
    578 function InputToDepthaverageEnum(){ return 574;}
    579 function InputToSmoothEnum(){ return 575;}
    580 function SmoothThicknessMultiplierEnum(){ return 576;}
    581 function IntParamEnum(){ return 577;}
    582 function IntVecParamEnum(){ return 578;}
    583 function TransientParamEnum(){ return 579;}
    584 function MaticeEnum(){ return 580;}
    585 function MatdamageiceEnum(){ return 581;}
    586 function MatbaflEnum(){ return 582;}
    587 function MatparEnum(){ return 583;}
    588 function NodeEnum(){ return 584;}
    589 function NumericalfluxEnum(){ return 585;}
    590 function NumericalfluxTypeEnum(){ return 586;}
    591 function NeumannfluxEnum(){ return 587;}
    592 function ParamEnum(){ return 588;}
    593 function MoulinEnum(){ return 589;}
    594 function PengridEnum(){ return 590;}
    595 function PenpairEnum(){ return 591;}
    596 function ProfilerEnum(){ return 592;}
    597 function MatrixParamEnum(){ return 593;}
    598 function MassconEnum(){ return 594;}
    599 function MassconNameEnum(){ return 595;}
    600 function MassconDefinitionenumEnum(){ return 596;}
    601 function MassconLevelsetEnum(){ return 597;}
    602 function MassconaxpbyEnum(){ return 598;}
    603 function MassconaxpbyNameEnum(){ return 599;}
    604 function MassconaxpbyDefinitionenumEnum(){ return 600;}
    605 function MassconaxpbyNamexEnum(){ return 601;}
    606 function MassconaxpbyNameyEnum(){ return 602;}
    607 function MassconaxpbyAlphaEnum(){ return 603;}
    608 function MassconaxpbyBetaEnum(){ return 604;}
    609 function NodeSIdEnum(){ return 605;}
    610 function VectorParamEnum(){ return 606;}
    611 function RiftfrontEnum(){ return 607;}
    612 function RiftfrontTypeEnum(){ return 608;}
    613 function SegmentEnum(){ return 609;}
    614 function SegmentRiftfrontEnum(){ return 610;}
    615 function SpcDynamicEnum(){ return 611;}
    616 function SpcStaticEnum(){ return 612;}
    617 function SpcTransientEnum(){ return 613;}
    618 function StringArrayParamEnum(){ return 614;}
    619 function StringParamEnum(){ return 615;}
    620 function SegEnum(){ return 616;}
    621 function SegInputEnum(){ return 617;}
    622 function TriaEnum(){ return 618;}
    623 function TriaInputEnum(){ return 619;}
    624 function TetraEnum(){ return 620;}
    625 function TetraInputEnum(){ return 621;}
    626 function PentaEnum(){ return 622;}
    627 function PentaInputEnum(){ return 623;}
    628 function VertexEnum(){ return 624;}
    629 function VertexPIdEnum(){ return 625;}
    630 function VertexSIdEnum(){ return 626;}
    631 function AirEnum(){ return 627;}
    632 function IceEnum(){ return 628;}
    633 function MelangeEnum(){ return 629;}
    634 function WaterEnum(){ return 630;}
    635 function ClosedEnum(){ return 631;}
    636 function FreeEnum(){ return 632;}
    637 function OpenEnum(){ return 633;}
    638 function AdjointpEnum(){ return 634;}
    639 function AdjointxEnum(){ return 635;}
    640 function AdjointyEnum(){ return 636;}
    641 function AdjointzEnum(){ return 637;}
    642 function BalancethicknessMisfitEnum(){ return 638;}
    643 function BedSlopeXEnum(){ return 639;}
    644 function BedSlopeYEnum(){ return 640;}
    645 function BoundaryEnum(){ return 641;}
    646 function ConvergedEnum(){ return 642;}
    647 function FillEnum(){ return 643;}
    648 function FractionIncrementEnum(){ return 644;}
    649 function FrictionEnum(){ return 645;}
    650 function InternalEnum(){ return 646;}
    651 function MassFluxEnum(){ return 647;}
    652 function MeltingOffsetEnum(){ return 648;}
    653 function MisfitEnum(){ return 649;}
    654 function PressureEnum(){ return 650;}
    655 function PressurePicardEnum(){ return 651;}
    656 function AndroidFrictionCoefficientEnum(){ return 652;}
    657 function ResetPenaltiesEnum(){ return 653;}
    658 function SegmentOnIceShelfEnum(){ return 654;}
    659 function SurfaceAbsVelMisfitEnum(){ return 655;}
    660 function SurfaceAreaEnum(){ return 656;}
    661 function SurfaceAverageVelMisfitEnum(){ return 657;}
    662 function SurfaceLogVelMisfitEnum(){ return 658;}
    663 function SurfaceLogVxVyMisfitEnum(){ return 659;}
    664 function SurfaceRelVelMisfitEnum(){ return 660;}
    665 function SurfaceSlopeXEnum(){ return 661;}
    666 function SurfaceSlopeYEnum(){ return 662;}
    667 function TemperatureEnum(){ return 663;}
    668 function TemperaturePicardEnum(){ return 664;}
    669 function TemperaturePDDEnum(){ return 665;}
    670 function ThicknessAbsMisfitEnum(){ return 666;}
    671 function SurfaceAbsMisfitEnum(){ return 667;}
    672 function VelEnum(){ return 668;}
    673 function VelocityEnum(){ return 669;}
    674 function VxAverageEnum(){ return 670;}
    675 function VxEnum(){ return 671;}
    676 function VxPicardEnum(){ return 672;}
    677 function VyAverageEnum(){ return 673;}
    678 function VyEnum(){ return 674;}
    679 function VyPicardEnum(){ return 675;}
    680 function VzEnum(){ return 676;}
    681 function VzSSAEnum(){ return 677;}
    682 function VzHOEnum(){ return 678;}
    683 function VzPicardEnum(){ return 679;}
    684 function VzFSEnum(){ return 680;}
    685 function VxMeshEnum(){ return 681;}
    686 function VyMeshEnum(){ return 682;}
    687 function VzMeshEnum(){ return 683;}
    688 function EnthalpyEnum(){ return 684;}
    689 function EnthalpyPicardEnum(){ return 685;}
    690 function ThicknessAbsGradientEnum(){ return 686;}
    691 function ThicknessAlongGradientEnum(){ return 687;}
    692 function ThicknessAcrossGradientEnum(){ return 688;}
    693 function ThicknessPositiveEnum(){ return 689;}
    694 function IntMatParamEnum(){ return 690;}
    695 function RheologyBbarAbsGradientEnum(){ return 691;}
    696 function RheologyBAbsGradientEnum(){ return 692;}
    697 function DragCoefficientAbsGradientEnum(){ return 693;}
    698 function TransientInputEnum(){ return 694;}
    699 function WaterfractionEnum(){ return 695;}
    700 function WatercolumnEnum(){ return 696;}
    701 function BasalFrictionEnum(){ return 697;}
    702 function ViscousHeatingEnum(){ return 698;}
    703 function HydrologyWaterVxEnum(){ return 699;}
    704 function HydrologyWaterVyEnum(){ return 700;}
    705 function DrivingStressXEnum(){ return 701;}
    706 function DrivingStressYEnum(){ return 702;}
    707 function SigmaNNEnum(){ return 703;}
    708 function StressTensorEnum(){ return 704;}
    709 function StressTensorxxEnum(){ return 705;}
    710 function StressTensorxyEnum(){ return 706;}
    711 function StressTensorxzEnum(){ return 707;}
    712 function StressTensoryyEnum(){ return 708;}
    713 function StressTensoryzEnum(){ return 709;}
    714 function StressTensorzzEnum(){ return 710;}
    715 function StressMaxPrincipalEnum(){ return 711;}
    716 function DeviatoricStressEnum(){ return 712;}
    717 function DeviatoricStressxxEnum(){ return 713;}
    718 function DeviatoricStressxyEnum(){ return 714;}
    719 function DeviatoricStressxzEnum(){ return 715;}
    720 function DeviatoricStressyyEnum(){ return 716;}
    721 function DeviatoricStressyzEnum(){ return 717;}
    722 function DeviatoricStresszzEnum(){ return 718;}
    723 function DeviatoricStresseffectiveEnum(){ return 719;}
    724 function StrainRateEnum(){ return 720;}
    725 function StrainRatexxEnum(){ return 721;}
    726 function StrainRatexyEnum(){ return 722;}
    727 function StrainRatexzEnum(){ return 723;}
    728 function StrainRateyyEnum(){ return 724;}
    729 function StrainRateyzEnum(){ return 725;}
    730 function StrainRatezzEnum(){ return 726;}
    731 function DivergenceEnum(){ return 727;}
    732 function MaxDivergenceEnum(){ return 728;}
    733 function GiaCrossSectionShapeEnum(){ return 729;}
    734 function GiadWdtEnum(){ return 730;}
    735 function GiaWEnum(){ return 731;}
    736 function P0Enum(){ return 732;}
    737 function P0ArrayEnum(){ return 733;}
    738 function P1Enum(){ return 734;}
    739 function P1DGEnum(){ return 735;}
    740 function P1bubbleEnum(){ return 736;}
    741 function P1bubblecondensedEnum(){ return 737;}
    742 function P2Enum(){ return 738;}
    743 function P2bubbleEnum(){ return 739;}
    744 function P2bubblecondensedEnum(){ return 740;}
    745 function P2xP1Enum(){ return 741;}
    746 function P1xP2Enum(){ return 742;}
    747 function P1xP3Enum(){ return 743;}
    748 function P2xP4Enum(){ return 744;}
    749 function P1P1Enum(){ return 745;}
    750 function P1P1GLSEnum(){ return 746;}
    751 function MINIEnum(){ return 747;}
    752 function MINIcondensedEnum(){ return 748;}
    753 function TaylorHoodEnum(){ return 749;}
    754 function LATaylorHoodEnum(){ return 750;}
    755 function XTaylorHoodEnum(){ return 751;}
    756 function OneLayerP4zEnum(){ return 752;}
    757 function CrouzeixRaviartEnum(){ return 753;}
    758 function LACrouzeixRaviartEnum(){ return 754;}
    759 function SaveResultsEnum(){ return 755;}
    760 function BoolExternalResultEnum(){ return 756;}
    761 function DoubleExternalResultEnum(){ return 757;}
    762 function DoubleMatExternalResultEnum(){ return 758;}
    763 function IntExternalResultEnum(){ return 759;}
    764 function JEnum(){ return 760;}
    765 function StringExternalResultEnum(){ return 761;}
    766 function StepEnum(){ return 762;}
    767 function TimeEnum(){ return 763;}
    768 function WaterColumnOldEnum(){ return 764;}
    769 function OutputdefinitionEnum(){ return 765;}
    770 function Outputdefinition1Enum(){ return 766;}
    771 function Outputdefinition2Enum(){ return 767;}
    772 function Outputdefinition3Enum(){ return 768;}
    773 function Outputdefinition4Enum(){ return 769;}
    774 function Outputdefinition5Enum(){ return 770;}
    775 function Outputdefinition6Enum(){ return 771;}
    776 function Outputdefinition7Enum(){ return 772;}
    777 function Outputdefinition8Enum(){ return 773;}
    778 function Outputdefinition9Enum(){ return 774;}
    779 function Outputdefinition10Enum(){ return 775;}
    780 function Outputdefinition11Enum(){ return 776;}
    781 function Outputdefinition12Enum(){ return 777;}
    782 function Outputdefinition13Enum(){ return 778;}
    783 function Outputdefinition14Enum(){ return 779;}
    784 function Outputdefinition15Enum(){ return 780;}
    785 function Outputdefinition16Enum(){ return 781;}
    786 function Outputdefinition17Enum(){ return 782;}
    787 function Outputdefinition18Enum(){ return 783;}
    788 function Outputdefinition19Enum(){ return 784;}
    789 function Outputdefinition20Enum(){ return 785;}
    790 function Outputdefinition21Enum(){ return 786;}
    791 function Outputdefinition22Enum(){ return 787;}
    792 function Outputdefinition23Enum(){ return 788;}
    793 function Outputdefinition24Enum(){ return 789;}
    794 function Outputdefinition25Enum(){ return 790;}
    795 function Outputdefinition26Enum(){ return 791;}
    796 function Outputdefinition27Enum(){ return 792;}
    797 function Outputdefinition28Enum(){ return 793;}
    798 function Outputdefinition29Enum(){ return 794;}
    799 function Outputdefinition30Enum(){ return 795;}
    800 function Outputdefinition31Enum(){ return 796;}
    801 function Outputdefinition32Enum(){ return 797;}
    802 function Outputdefinition33Enum(){ return 798;}
    803 function Outputdefinition34Enum(){ return 799;}
    804 function Outputdefinition35Enum(){ return 800;}
    805 function Outputdefinition36Enum(){ return 801;}
    806 function Outputdefinition37Enum(){ return 802;}
    807 function Outputdefinition38Enum(){ return 803;}
    808 function Outputdefinition39Enum(){ return 804;}
    809 function Outputdefinition40Enum(){ return 805;}
    810 function Outputdefinition41Enum(){ return 806;}
    811 function Outputdefinition42Enum(){ return 807;}
    812 function Outputdefinition43Enum(){ return 808;}
    813 function Outputdefinition44Enum(){ return 809;}
    814 function Outputdefinition45Enum(){ return 810;}
    815 function Outputdefinition46Enum(){ return 811;}
    816 function Outputdefinition47Enum(){ return 812;}
    817 function Outputdefinition48Enum(){ return 813;}
    818 function Outputdefinition49Enum(){ return 814;}
    819 function Outputdefinition50Enum(){ return 815;}
    820 function Outputdefinition51Enum(){ return 816;}
    821 function Outputdefinition52Enum(){ return 817;}
    822 function Outputdefinition53Enum(){ return 818;}
    823 function Outputdefinition54Enum(){ return 819;}
    824 function Outputdefinition55Enum(){ return 820;}
    825 function Outputdefinition56Enum(){ return 821;}
    826 function Outputdefinition57Enum(){ return 822;}
    827 function Outputdefinition58Enum(){ return 823;}
    828 function Outputdefinition59Enum(){ return 824;}
    829 function Outputdefinition60Enum(){ return 825;}
    830 function Outputdefinition61Enum(){ return 826;}
    831 function Outputdefinition62Enum(){ return 827;}
    832 function Outputdefinition63Enum(){ return 828;}
    833 function Outputdefinition64Enum(){ return 829;}
    834 function Outputdefinition65Enum(){ return 830;}
    835 function Outputdefinition66Enum(){ return 831;}
    836 function Outputdefinition67Enum(){ return 832;}
    837 function Outputdefinition68Enum(){ return 833;}
    838 function Outputdefinition69Enum(){ return 834;}
    839 function Outputdefinition70Enum(){ return 835;}
    840 function Outputdefinition71Enum(){ return 836;}
    841 function Outputdefinition72Enum(){ return 837;}
    842 function Outputdefinition73Enum(){ return 838;}
    843 function Outputdefinition74Enum(){ return 839;}
    844 function Outputdefinition75Enum(){ return 840;}
    845 function Outputdefinition76Enum(){ return 841;}
    846 function Outputdefinition77Enum(){ return 842;}
    847 function Outputdefinition78Enum(){ return 843;}
    848 function Outputdefinition79Enum(){ return 844;}
    849 function Outputdefinition80Enum(){ return 845;}
    850 function Outputdefinition81Enum(){ return 846;}
    851 function Outputdefinition82Enum(){ return 847;}
    852 function Outputdefinition83Enum(){ return 848;}
    853 function Outputdefinition84Enum(){ return 849;}
    854 function Outputdefinition85Enum(){ return 850;}
    855 function Outputdefinition86Enum(){ return 851;}
    856 function Outputdefinition87Enum(){ return 852;}
    857 function Outputdefinition88Enum(){ return 853;}
    858 function Outputdefinition89Enum(){ return 854;}
    859 function Outputdefinition90Enum(){ return 855;}
    860 function Outputdefinition91Enum(){ return 856;}
    861 function Outputdefinition92Enum(){ return 857;}
    862 function Outputdefinition93Enum(){ return 858;}
    863 function Outputdefinition94Enum(){ return 859;}
    864 function Outputdefinition95Enum(){ return 860;}
    865 function Outputdefinition96Enum(){ return 861;}
    866 function Outputdefinition97Enum(){ return 862;}
    867 function Outputdefinition98Enum(){ return 863;}
    868 function Outputdefinition99Enum(){ return 864;}
    869 function Outputdefinition100Enum(){ return 865;}
    870 function OutputdefinitionListEnum(){ return 866;}
    871 function MassfluxatgateEnum(){ return 867;}
    872 function MassfluxatgateNameEnum(){ return 868;}
    873 function MassfluxatgateDefinitionenumEnum(){ return 869;}
    874 function MassfluxatgateSegmentsEnum(){ return 870;}
    875 function NodalvalueEnum(){ return 871;}
    876 function NodalvalueNameEnum(){ return 872;}
    877 function NodalvalueDefinitionenumEnum(){ return 873;}
    878 function NodalvalueModelEnum(){ return 874;}
    879 function NodalvalueNodeEnum(){ return 875;}
    880 function MisfitNameEnum(){ return 876;}
    881 function MisfitDefinitionenumEnum(){ return 877;}
    882 function MisfitModelEnum(){ return 878;}
    883 function MisfitObservationEnum(){ return 879;}
    884 function MisfitObservationEnum(){ return 880;}
    885 function MisfitLocalEnum(){ return 881;}
    886 function MisfitTimeinterpolationEnum(){ return 882;}
    887 function MisfitWeightsEnum(){ return 883;}
    888 function MisfitWeightsEnum(){ return 884;}
    889 function SurfaceObservationEnum(){ return 885;}
    890 function WeightsSurfaceObservationEnum(){ return 886;}
    891 function VxObsEnum(){ return 887;}
    892 function WeightsVxObsEnum(){ return 888;}
    893 function VyObsEnum(){ return 889;}
    894 function WeightsVyObsEnum(){ return 890;}
    895 function MinVelEnum(){ return 891;}
    896 function MaxVelEnum(){ return 892;}
    897 function MinVxEnum(){ return 893;}
    898 function MaxVxEnum(){ return 894;}
    899 function MaxAbsVxEnum(){ return 895;}
    900 function MinVyEnum(){ return 896;}
    901 function MaxVyEnum(){ return 897;}
    902 function MaxAbsVyEnum(){ return 898;}
    903 function MinVzEnum(){ return 899;}
    904 function MaxVzEnum(){ return 900;}
    905 function MaxAbsVzEnum(){ return 901;}
    906 function FloatingAreaEnum(){ return 902;}
    907 function GroundedAreaEnum(){ return 903;}
    908 function IceMassEnum(){ return 904;}
    909 function IceVolumeEnum(){ return 905;}
    910 function IceVolumeAboveFloatationEnum(){ return 906;}
    911 function TotalFloatingBmbEnum(){ return 907;}
    912 function TotalGroundedBmbEnum(){ return 908;}
    913 function TotalSmbEnum(){ return 909;}
    914 function AbsoluteEnum(){ return 910;}
    915 function IncrementalEnum(){ return 911;}
    916 function AugmentedLagrangianREnum(){ return 912;}
    917 function AugmentedLagrangianRhopEnum(){ return 913;}
    918 function AugmentedLagrangianRlambdaEnum(){ return 914;}
    919 function AugmentedLagrangianRholambdaEnum(){ return 915;}
    920 function AugmentedLagrangianThetaEnum(){ return 916;}
    921 function NoneEnum(){ return 917;}
    922 function AggressiveMigrationEnum(){ return 918;}
    923 function SoftMigrationEnum(){ return 919;}
    924 function SubelementMigrationEnum(){ return 920;}
    925 function SubelementMigration2Enum(){ return 921;}
    926 function ContactEnum(){ return 922;}
    927 function GroundingOnlyEnum(){ return 923;}
    928 function MaskGroundediceLevelsetEnum(){ return 924;}
    929 function GaussSegEnum(){ return 925;}
    930 function GaussTriaEnum(){ return 926;}
    931 function GaussTetraEnum(){ return 927;}
    932 function GaussPentaEnum(){ return 928;}
    933 function FSSolverEnum(){ return 929;}
    934 function AdjointEnum(){ return 930;}
    935 function ColinearEnum(){ return 931;}
    936 function ControlSteadyEnum(){ return 932;}
    937 function FsetEnum(){ return 933;}
    938 function Gradient1Enum(){ return 934;}
    939 function Gradient2Enum(){ return 935;}
    940 function Gradient3Enum(){ return 936;}
    941 function GradientEnum(){ return 937;}
    942 function GroundinglineMigrationEnum(){ return 938;}
    943 function GsetEnum(){ return 939;}
    944 function IndexEnum(){ return 940;}
    945 function IndexedEnum(){ return 941;}
    946 function IntersectEnum(){ return 942;}
    947 function NodalEnum(){ return 943;}
    948 function OldGradientEnum(){ return 944;}
    949 function OutputBufferPointerEnum(){ return 945;}
    950 function OutputBufferSizePointerEnum(){ return 946;}
    951 function OutputFilePointerEnum(){ return 947;}
    952 function ToolkitsFileNameEnum(){ return 948;}
    953 function RootPathEnum(){ return 949;}
    954 function OutputFileNameEnum(){ return 950;}
    955 function InputFileNameEnum(){ return 951;}
    956 function LockFileNameEnum(){ return 952;}
    957 function RestartFileNameEnum(){ return 953;}
    958 function ToolkitsOptionsAnalysesEnum(){ return 954;}
    959 function ToolkitsOptionsStringsEnum(){ return 955;}
    960 function QmuErrNameEnum(){ return 956;}
    961 function QmuInNameEnum(){ return 957;}
    962 function QmuOutNameEnum(){ return 958;}
    963 function RegularEnum(){ return 959;}
    964 function ScaledEnum(){ return 960;}
    965 function SeparateEnum(){ return 961;}
    966 function SsetEnum(){ return 962;}
    967 function VerboseEnum(){ return 963;}
    968 function TriangleInterpEnum(){ return 964;}
    969 function BilinearInterpEnum(){ return 965;}
    970 function NearestInterpEnum(){ return 966;}
    971 function XYEnum(){ return 967;}
    972 function XYZEnum(){ return 968;}
    973 function DenseEnum(){ return 969;}
    974 function MpiDenseEnum(){ return 970;}
    975 function MpiSparseEnum(){ return 971;}
    976 function SeqEnum(){ return 972;}
    977 function MpiEnum(){ return 973;}
    978 function MumpsEnum(){ return 974;}
    979 function GslEnum(){ return 975;}
    980 function OptionEnum(){ return 976;}
    981 function GenericOptionEnum(){ return 977;}
    982 function OptionCellEnum(){ return 978;}
    983 function OptionStructEnum(){ return 979;}
    984 function CuffeyEnum(){ return 980;}
    985 function CuffeyTemperateEnum(){ return 981;}
    986 function PatersonEnum(){ return 982;}
    987 function ArrheniusEnum(){ return 983;}
    988 function LliboutryDuvalEnum(){ return 984;}
    989 function SpclevelsetEnum(){ return 985;}
    990 function ExtrapolationVariableEnum(){ return 986;}
    991 function IceMaskNodeActivationEnum(){ return 987;}
    992 function LevelsetfunctionSlopeXEnum(){ return 988;}
    993 function LevelsetfunctionSlopeYEnum(){ return 989;}
    994 function LevelsetfunctionPicardEnum(){ return 990;}
    995 function LevelsetReinitFrequencyEnum(){ return 991;}
    996 function SealevelriseSolutionEnum(){ return 992;}
    997 function SealevelriseAnalysisEnum(){ return 993;}
    998 function SealevelEnum(){ return 994;}
    999 function SealevelEustaticEnum(){ return 995;}
    1000 function SealevelriseDeltathicknessEnum(){ return 996;}
    1001 function SealevelriseMaxiterEnum(){ return 997;}
    1002 function SealevelriseReltolEnum(){ return 998;}
    1003 function SealevelriseAbstolEnum(){ return 999;}
    1004 function SealevelriseLoveHEnum(){ return 1000;}
    1005 function SealevelriseLoveKEnum(){ return 1001;}
    1006 function SealevelriseTideLoveHEnum(){ return 1002;}
    1007 function SealevelriseTideLoveKEnum(){ return 1003;}
    1008 function SealevelriseRigidEnum(){ return 1004;}
    1009 function SealevelriseElasticEnum(){ return 1005;}
    1010 function SealevelriseRotationEnum(){ return 1006;}
    1011 function SealevelriseGElasticEnum(){ return 1007;}
    1012 function SealevelriseDegaccEnum(){ return 1008;}
    1013 function SealevelriseTransitionsEnum(){ return 1009;}
    1014 function SealevelriseRequestedOutputsEnum(){ return 1010;}
    1015 function SealevelriseNumRequestedOutputsEnum(){ return 1011;}
    1016 function ParametersENDEnum(){ return 1012;}
    1017 function MaximumNumberOfDefinitionsEnum(){ return 1013;}
     225function MaterialsRheologyEcbarEnum(){ return 221;}
     226function MaterialsRheologyEsEnum(){ return 222;}
     227function MaterialsRheologyEsbarEnum(){ return 223;}
     228function DamageIsdamageEnum(){ return 224;}
     229function DamageDEnum(){ return 225;}
     230function DamageFEnum(){ return 226;}
     231function DamageDbarEnum(){ return 227;}
     232function DamageLawEnum(){ return 228;}
     233function DamageC1Enum(){ return 229;}
     234function DamageC2Enum(){ return 230;}
     235function DamageC3Enum(){ return 231;}
     236function DamageC4Enum(){ return 232;}
     237function DamageElementinterpEnum(){ return 233;}
     238function DamageHealingEnum(){ return 234;}
     239function DamageStressThresholdEnum(){ return 235;}
     240function DamageKappaEnum(){ return 236;}
     241function DamageStabilizationEnum(){ return 237;}
     242function DamageMaxiterEnum(){ return 238;}
     243function DamageSpcdamageEnum(){ return 239;}
     244function DamageMaxDamageEnum(){ return 240;}
     245function DamageEquivStressEnum(){ return 241;}
     246function DamageEvolutionNumRequestedOutputsEnum(){ return 242;}
     247function DamageEvolutionRequestedOutputsEnum(){ return 243;}
     248function DamageEnum(){ return 244;}
     249function NewDamageEnum(){ return 245;}
     250function StressIntensityFactorEnum(){ return 246;}
     251function CalvingLawEnum(){ return 247;}
     252function CalvingCalvingrateEnum(){ return 248;}
     253function CalvingMeltingrateEnum(){ return 249;}
     254function CalvingLevermannEnum(){ return 250;}
     255function CalvingDevEnum(){ return 251;}
     256function DefaultCalvingEnum(){ return 252;}
     257function CalvingRequestedOutputsEnum(){ return 253;}
     258function CalvinglevermannCoeffEnum(){ return 254;}
     259function CalvinglevermannMeltingrateEnum(){ return 255;}
     260function CalvingdevCoeffEnum(){ return 256;}
     261function CalvingratexEnum(){ return 257;}
     262function CalvingrateyEnum(){ return 258;}
     263function CalvingratexAverageEnum(){ return 259;}
     264function CalvingrateyAverageEnum(){ return 260;}
     265function StrainRateparallelEnum(){ return 261;}
     266function StrainRateperpendicularEnum(){ return 262;}
     267function StrainRateeffectiveEnum(){ return 263;}
     268function MaterialsRhoIceEnum(){ return 264;}
     269function MaterialsRhoSeawaterEnum(){ return 265;}
     270function MaterialsRhoFreshwaterEnum(){ return 266;}
     271function MaterialsMuWaterEnum(){ return 267;}
     272function MaterialsThermalExchangeVelocityEnum(){ return 268;}
     273function MaterialsThermalconductivityEnum(){ return 269;}
     274function MaterialsTemperateiceconductivityEnum(){ return 270;}
     275function MaterialsLithosphereShearModulusEnum(){ return 271;}
     276function MaterialsLithosphereDensityEnum(){ return 272;}
     277function MaterialsMantleShearModulusEnum(){ return 273;}
     278function MaterialsMantleDensityEnum(){ return 274;}
     279function MaterialsEarthDensityEnum(){ return 275;}
     280function MeshAverageVertexConnectivityEnum(){ return 276;}
     281function MeshElements2dEnum(){ return 277;}
     282function MeshElementsEnum(){ return 278;}
     283function MeshLowerelementsEnum(){ return 279;}
     284function MeshNumberofelements2dEnum(){ return 280;}
     285function MeshNumberofelementsEnum(){ return 281;}
     286function MeshNumberoflayersEnum(){ return 282;}
     287function MeshNumberofvertices2dEnum(){ return 283;}
     288function MeshNumberofverticesEnum(){ return 284;}
     289function MeshUpperelementsEnum(){ return 285;}
     290function MeshVertexonbaseEnum(){ return 286;}
     291function MeshVertexonsurfaceEnum(){ return 287;}
     292function MeshVertexonboundaryEnum(){ return 288;}
     293function MeshXEnum(){ return 289;}
     294function MeshYEnum(){ return 290;}
     295function MeshZEnum(){ return 291;}
     296function MeshLatEnum(){ return 292;}
     297function MeshLongEnum(){ return 293;}
     298function MeshREnum(){ return 294;}
     299function MeshElementtypeEnum(){ return 295;}
     300function MeshSegmentsEnum(){ return 296;}
     301function DomainTypeEnum(){ return 297;}
     302function DomainDimensionEnum(){ return 298;}
     303function Domain2DhorizontalEnum(){ return 299;}
     304function Domain2DverticalEnum(){ return 300;}
     305function Domain3DEnum(){ return 301;}
     306function Domain3DsurfaceEnum(){ return 302;}
     307function MiscellaneousNameEnum(){ return 303;}
     308function MasstransportHydrostaticAdjustmentEnum(){ return 304;}
     309function MasstransportIsfreesurfaceEnum(){ return 305;}
     310function MasstransportMinThicknessEnum(){ return 306;}
     311function MasstransportPenaltyFactorEnum(){ return 307;}
     312function MasstransportSpcthicknessEnum(){ return 308;}
     313function MasstransportStabilizationEnum(){ return 309;}
     314function MasstransportVertexPairingEnum(){ return 310;}
     315function MasstransportNumRequestedOutputsEnum(){ return 311;}
     316function MasstransportRequestedOutputsEnum(){ return 312;}
     317function QmuIsdakotaEnum(){ return 313;}
     318function MassFluxSegmentsEnum(){ return 314;}
     319function MassFluxSegmentsPresentEnum(){ return 315;}
     320function QmuMassFluxSegmentsPresentEnum(){ return 316;}
     321function QmuNumberofpartitionsEnum(){ return 317;}
     322function QmuNumberofresponsesEnum(){ return 318;}
     323function QmuPartitionEnum(){ return 319;}
     324function QmuResponsedescriptorsEnum(){ return 320;}
     325function QmuVariabledescriptorsEnum(){ return 321;}
     326function RiftsNumriftsEnum(){ return 322;}
     327function RiftsRiftstructEnum(){ return 323;}
     328function SettingsResultsOnNodesEnum(){ return 324;}
     329function SettingsIoGatherEnum(){ return 325;}
     330function SettingsLowmemEnum(){ return 326;}
     331function SettingsOutputFrequencyEnum(){ return 327;}
     332function SettingsRecordingFrequencyEnum(){ return 328;}
     333function SettingsWaitonlockEnum(){ return 329;}
     334function DebugProfilingEnum(){ return 330;}
     335function ProfilingCurrentMemEnum(){ return 331;}
     336function ProfilingCurrentFlopsEnum(){ return 332;}
     337function ProfilingSolutionTimeEnum(){ return 333;}
     338function SteadystateMaxiterEnum(){ return 334;}
     339function SteadystateNumRequestedOutputsEnum(){ return 335;}
     340function SteadystateReltolEnum(){ return 336;}
     341function SteadystateRequestedOutputsEnum(){ return 337;}
     342function SurfaceEnum(){ return 338;}
     343function ThermalIsenthalpyEnum(){ return 339;}
     344function ThermalIsdynamicbasalspcEnum(){ return 340;}
     345function ThermalReltolEnum(){ return 341;}
     346function ThermalMaxiterEnum(){ return 342;}
     347function ThermalPenaltyFactorEnum(){ return 343;}
     348function ThermalPenaltyLockEnum(){ return 344;}
     349function ThermalPenaltyThresholdEnum(){ return 345;}
     350function ThermalSpctemperatureEnum(){ return 346;}
     351function ThermalStabilizationEnum(){ return 347;}
     352function ThermalNumRequestedOutputsEnum(){ return 348;}
     353function ThermalRequestedOutputsEnum(){ return 349;}
     354function GiaMantleViscosityEnum(){ return 350;}
     355function GiaLithosphereThicknessEnum(){ return 351;}
     356function ThicknessEnum(){ return 352;}
     357function TimesteppingStartTimeEnum(){ return 353;}
     358function TimesteppingFinalTimeEnum(){ return 354;}
     359function TimesteppingCflCoefficientEnum(){ return 355;}
     360function TimesteppingTimeAdaptEnum(){ return 356;}
     361function TimesteppingTimeStepEnum(){ return 357;}
     362function TimesteppingInterpForcingsEnum(){ return 358;}
     363function TransientIssmbEnum(){ return 359;}
     364function TransientIscouplerEnum(){ return 360;}
     365function TransientIsstressbalanceEnum(){ return 361;}
     366function TransientIsgroundinglineEnum(){ return 362;}
     367function TransientIsmasstransportEnum(){ return 363;}
     368function TransientIsthermalEnum(){ return 364;}
     369function TransientIsgiaEnum(){ return 365;}
     370function TransientIsdamageevolutionEnum(){ return 366;}
     371function TransientIshydrologyEnum(){ return 367;}
     372function TransientIsmovingfrontEnum(){ return 368;}
     373function TransientIsslrEnum(){ return 369;}
     374function TransientNumRequestedOutputsEnum(){ return 370;}
     375function TransientRequestedOutputsEnum(){ return 371;}
     376function PotentialEnum(){ return 372;}
     377function BalancethicknessSpcpotentialEnum(){ return 373;}
     378function BalancethicknessApparentMassbalanceEnum(){ return 374;}
     379function Balancethickness2MisfitEnum(){ return 375;}
     380function BalancethicknessDiffusionCoefficientEnum(){ return 376;}
     381function BalancethicknessCmuEnum(){ return 377;}
     382function BalancethicknessOmegaEnum(){ return 378;}
     383function BalancethicknessD0Enum(){ return 379;}
     384function SmbEnum(){ return 380;}
     385function SmbAnalysisEnum(){ return 381;}
     386function SmbSolutionEnum(){ return 382;}
     387function SmbNumRequestedOutputsEnum(){ return 383;}
     388function SmbRequestedOutputsEnum(){ return 384;}
     389function SmbIsInitializedEnum(){ return 385;}
     390function SMBforcingEnum(){ return 386;}
     391function SmbMassBalanceEnum(){ return 387;}
     392function SMBgembEnum(){ return 388;}
     393function SmbInitDensityScalingEnum(){ return 389;}
     394function SmbTaEnum(){ return 390;}
     395function SmbVEnum(){ return 391;}
     396function SmbDswrfEnum(){ return 392;}
     397function SmbDlwrfEnum(){ return 393;}
     398function SmbPEnum(){ return 394;}
     399function SmbSwfEnum(){ return 395;}
     400function SmbEAirEnum(){ return 396;}
     401function SmbPAirEnum(){ return 397;}
     402function SmbTmeanEnum(){ return 398;}
     403function SmbCEnum(){ return 399;}
     404function SmbTzEnum(){ return 400;}
     405function SmbVzEnum(){ return 401;}
     406function SmbDtEnum(){ return 402;}
     407function SmbDzEnum(){ return 403;}
     408function SmbAIdxEnum(){ return 404;}
     409function SmbSwIdxEnum(){ return 405;}
     410function SmbDenIdxEnum(){ return 406;}
     411function SmbZTopEnum(){ return 407;}
     412function SmbDzTopEnum(){ return 408;}
     413function SmbDzMinEnum(){ return 409;}
     414function SmbZYEnum(){ return 410;}
     415function SmbZMaxEnum(){ return 411;}
     416function SmbZMinEnum(){ return 412;}
     417function SmbOutputFreqEnum(){ return 413;}
     418function SmbASnowEnum(){ return 414;}
     419function SmbAIceEnum(){ return 415;}
     420function SmbCldFracEnum(){ return 416;}
     421function SmbT0wetEnum(){ return 417;}
     422function SmbT0dryEnum(){ return 418;}
     423function SmbKEnum(){ return 419;}
     424function SmbDEnum(){ return 420;}
     425function SmbReEnum(){ return 421;}
     426function SmbGdnEnum(){ return 422;}
     427function SmbGspEnum(){ return 423;}
     428function SmbECEnum(){ return 424;}
     429function SmbCondensationEnum(){ return 425;}
     430function SmbWEnum(){ return 426;}
     431function SmbAEnum(){ return 427;}
     432function SmbTEnum(){ return 428;}
     433function SmbIsgraingrowthEnum(){ return 429;}
     434function SmbIsalbedoEnum(){ return 430;}
     435function SmbIsshortwaveEnum(){ return 431;}
     436function SmbIsthermalEnum(){ return 432;}
     437function SmbIsaccumulationEnum(){ return 433;}
     438function SmbIsmeltEnum(){ return 434;}
     439function SmbIsdensificationEnum(){ return 435;}
     440function SmbIsturbulentfluxEnum(){ return 436;}
     441function SMBpddEnum(){ return 437;}
     442function SmbDelta18oEnum(){ return 438;}
     443function SmbDelta18oSurfaceEnum(){ return 439;}
     444function SmbIsdelta18oEnum(){ return 440;}
     445function SmbIsmungsmEnum(){ return 441;}
     446function SmbIsd18opdEnum(){ return 442;}
     447function SmbPrecipitationsPresentdayEnum(){ return 443;}
     448function SmbPrecipitationsLgmEnum(){ return 444;}
     449function SmbTemperaturesPresentdayEnum(){ return 445;}
     450function SmbTemperaturesLgmEnum(){ return 446;}
     451function SmbPrecipitationEnum(){ return 447;}
     452function SmbDesfacEnum(){ return 448;}
     453function SmbS0pEnum(){ return 449;}
     454function SmbS0tEnum(){ return 450;}
     455function SmbRlapsEnum(){ return 451;}
     456function SmbRlapslgmEnum(){ return 452;}
     457function SmbPfacEnum(){ return 453;}
     458function SmbTdiffEnum(){ return 454;}
     459function SmbSealevEnum(){ return 455;}
     460function SMBd18opddEnum(){ return 456;}
     461function SmbDpermilEnum(){ return 457;}
     462function SMBgradientsEnum(){ return 458;}
     463function SmbMonthlytemperaturesEnum(){ return 459;}
     464function SmbHrefEnum(){ return 460;}
     465function SmbSmbrefEnum(){ return 461;}
     466function SmbBPosEnum(){ return 462;}
     467function SmbBNegEnum(){ return 463;}
     468function SMBhenningEnum(){ return 464;}
     469function SMBcomponentsEnum(){ return 465;}
     470function SmbAccumulationEnum(){ return 466;}
     471function SmbEvaporationEnum(){ return 467;}
     472function SmbRunoffEnum(){ return 468;}
     473function SMBmeltcomponentsEnum(){ return 469;}
     474function SmbMeltEnum(){ return 470;}
     475function SmbRefreezeEnum(){ return 471;}
     476function SMBgcmEnum(){ return 472;}
     477function SmbIspddEnum(){ return 473;}
     478function SmbIssmbgradientsEnum(){ return 474;}
     479function SolutionTypeEnum(){ return 475;}
     480function AnalysisTypeEnum(){ return 476;}
     481function ConfigurationTypeEnum(){ return 477;}
     482function AdjointBalancethicknessAnalysisEnum(){ return 478;}
     483function AdjointBalancethickness2AnalysisEnum(){ return 479;}
     484function AdjointHorizAnalysisEnum(){ return 480;}
     485function AnalysisCounterEnum(){ return 481;}
     486function DefaultAnalysisEnum(){ return 482;}
     487function BalancethicknessAnalysisEnum(){ return 483;}
     488function BalancethicknessSolutionEnum(){ return 484;}
     489function Balancethickness2AnalysisEnum(){ return 485;}
     490function Balancethickness2SolutionEnum(){ return 486;}
     491function BalancethicknessSoftAnalysisEnum(){ return 487;}
     492function BalancethicknessSoftSolutionEnum(){ return 488;}
     493function BalancevelocityAnalysisEnum(){ return 489;}
     494function BalancevelocitySolutionEnum(){ return 490;}
     495function L2ProjectionEPLAnalysisEnum(){ return 491;}
     496function L2ProjectionBaseAnalysisEnum(){ return 492;}
     497function BedSlopeSolutionEnum(){ return 493;}
     498function DamageEvolutionSolutionEnum(){ return 494;}
     499function DamageEvolutionAnalysisEnum(){ return 495;}
     500function StressbalanceAnalysisEnum(){ return 496;}
     501function StressbalanceSIAAnalysisEnum(){ return 497;}
     502function StressbalanceSolutionEnum(){ return 498;}
     503function StressbalanceVerticalAnalysisEnum(){ return 499;}
     504function EnthalpyAnalysisEnum(){ return 500;}
     505function FlaimAnalysisEnum(){ return 501;}
     506function FlaimSolutionEnum(){ return 502;}
     507function HydrologyShreveAnalysisEnum(){ return 503;}
     508function HydrologyDCInefficientAnalysisEnum(){ return 504;}
     509function HydrologyDCEfficientAnalysisEnum(){ return 505;}
     510function HydrologySommersAnalysisEnum(){ return 506;}
     511function HydrologySolutionEnum(){ return 507;}
     512function MeltingAnalysisEnum(){ return 508;}
     513function MasstransportAnalysisEnum(){ return 509;}
     514function MasstransportSolutionEnum(){ return 510;}
     515function FreeSurfaceBaseAnalysisEnum(){ return 511;}
     516function FreeSurfaceTopAnalysisEnum(){ return 512;}
     517function SurfaceNormalVelocityEnum(){ return 513;}
     518function ExtrudeFromBaseAnalysisEnum(){ return 514;}
     519function ExtrudeFromTopAnalysisEnum(){ return 515;}
     520function DepthAverageAnalysisEnum(){ return 516;}
     521function SteadystateSolutionEnum(){ return 517;}
     522function SurfaceSlopeSolutionEnum(){ return 518;}
     523function SmoothAnalysisEnum(){ return 519;}
     524function ThermalAnalysisEnum(){ return 520;}
     525function ThermalSolutionEnum(){ return 521;}
     526function TransientSolutionEnum(){ return 522;}
     527function UzawaPressureAnalysisEnum(){ return 523;}
     528function GiaSolutionEnum(){ return 524;}
     529function GiaAnalysisEnum(){ return 525;}
     530function MeshdeformationSolutionEnum(){ return 526;}
     531function MeshdeformationAnalysisEnum(){ return 527;}
     532function LevelsetAnalysisEnum(){ return 528;}
     533function LevelsetStabilizationEnum(){ return 529;}
     534function ExtrapolationAnalysisEnum(){ return 530;}
     535function LsfReinitializationAnalysisEnum(){ return 531;}
     536function ApproximationEnum(){ return 532;}
     537function NoneApproximationEnum(){ return 533;}
     538function SIAApproximationEnum(){ return 534;}
     539function SSAApproximationEnum(){ return 535;}
     540function SSAHOApproximationEnum(){ return 536;}
     541function SSAFSApproximationEnum(){ return 537;}
     542function L1L2ApproximationEnum(){ return 538;}
     543function HOApproximationEnum(){ return 539;}
     544function HOFSApproximationEnum(){ return 540;}
     545function FSApproximationEnum(){ return 541;}
     546function FSvelocityEnum(){ return 542;}
     547function FSpressureEnum(){ return 543;}
     548function DataSetEnum(){ return 544;}
     549function ConstraintsEnum(){ return 545;}
     550function LoadsEnum(){ return 546;}
     551function MaterialsEnum(){ return 547;}
     552function NodesEnum(){ return 548;}
     553function ContoursEnum(){ return 549;}
     554function ParametersEnum(){ return 550;}
     555function VerticesEnum(){ return 551;}
     556function ResultsEnum(){ return 552;}
     557function GenericParamEnum(){ return 553;}
     558function AdolcParamEnum(){ return 554;}
     559function BoolInputEnum(){ return 555;}
     560function BoolParamEnum(){ return 556;}
     561function ContourEnum(){ return 557;}
     562function ControlInputEnum(){ return 558;}
     563function DatasetInputEnum(){ return 559;}
     564function DoubleInputEnum(){ return 560;}
     565function DoubleArrayInputEnum(){ return 561;}
     566function DataSetParamEnum(){ return 562;}
     567function DoubleMatArrayParamEnum(){ return 563;}
     568function DoubleMatParamEnum(){ return 564;}
     569function DoubleParamEnum(){ return 565;}
     570function DoubleVecParamEnum(){ return 566;}
     571function ElementEnum(){ return 567;}
     572function ElementHookEnum(){ return 568;}
     573function HookEnum(){ return 569;}
     574function ExternalResultEnum(){ return 570;}
     575function FileParamEnum(){ return 571;}
     576function InputEnum(){ return 572;}
     577function IntInputEnum(){ return 573;}
     578function InputToExtrudeEnum(){ return 574;}
     579function InputToL2ProjectEnum(){ return 575;}
     580function InputToDepthaverageEnum(){ return 576;}
     581function InputToSmoothEnum(){ return 577;}
     582function SmoothThicknessMultiplierEnum(){ return 578;}
     583function IntParamEnum(){ return 579;}
     584function IntVecParamEnum(){ return 580;}
     585function TransientParamEnum(){ return 581;}
     586function MaticeEnum(){ return 582;}
     587function MatdamageiceEnum(){ return 583;}
     588function MatearlEnum(){ return 584;}
     589function MatparEnum(){ return 585;}
     590function NodeEnum(){ return 586;}
     591function NumericalfluxEnum(){ return 587;}
     592function NumericalfluxTypeEnum(){ return 588;}
     593function NeumannfluxEnum(){ return 589;}
     594function ParamEnum(){ return 590;}
     595function MoulinEnum(){ return 591;}
     596function PengridEnum(){ return 592;}
     597function PenpairEnum(){ return 593;}
     598function ProfilerEnum(){ return 594;}
     599function MatrixParamEnum(){ return 595;}
     600function MassconEnum(){ return 596;}
     601function MassconNameEnum(){ return 597;}
     602function MassconDefinitionenumEnum(){ return 598;}
     603function MassconLevelsetEnum(){ return 599;}
     604function MassconaxpbyEnum(){ return 600;}
     605function MassconaxpbyNameEnum(){ return 601;}
     606function MassconaxpbyDefinitionenumEnum(){ return 602;}
     607function MassconaxpbyNamexEnum(){ return 603;}
     608function MassconaxpbyNameyEnum(){ return 604;}
     609function MassconaxpbyAlphaEnum(){ return 605;}
     610function MassconaxpbyBetaEnum(){ return 606;}
     611function NodeSIdEnum(){ return 607;}
     612function VectorParamEnum(){ return 608;}
     613function RiftfrontEnum(){ return 609;}
     614function RiftfrontTypeEnum(){ return 610;}
     615function SegmentEnum(){ return 611;}
     616function SegmentRiftfrontEnum(){ return 612;}
     617function SpcDynamicEnum(){ return 613;}
     618function SpcStaticEnum(){ return 614;}
     619function SpcTransientEnum(){ return 615;}
     620function StringArrayParamEnum(){ return 616;}
     621function StringParamEnum(){ return 617;}
     622function SegEnum(){ return 618;}
     623function SegInputEnum(){ return 619;}
     624function TriaEnum(){ return 620;}
     625function TriaInputEnum(){ return 621;}
     626function TetraEnum(){ return 622;}
     627function TetraInputEnum(){ return 623;}
     628function PentaEnum(){ return 624;}
     629function PentaInputEnum(){ return 625;}
     630function VertexEnum(){ return 626;}
     631function VertexPIdEnum(){ return 627;}
     632function VertexSIdEnum(){ return 628;}
     633function AirEnum(){ return 629;}
     634function IceEnum(){ return 630;}
     635function MelangeEnum(){ return 631;}
     636function WaterEnum(){ return 632;}
     637function ClosedEnum(){ return 633;}
     638function FreeEnum(){ return 634;}
     639function OpenEnum(){ return 635;}
     640function AdjointpEnum(){ return 636;}
     641function AdjointxEnum(){ return 637;}
     642function AdjointyEnum(){ return 638;}
     643function AdjointzEnum(){ return 639;}
     644function BalancethicknessMisfitEnum(){ return 640;}
     645function BedSlopeXEnum(){ return 641;}
     646function BedSlopeYEnum(){ return 642;}
     647function BoundaryEnum(){ return 643;}
     648function ConvergedEnum(){ return 644;}
     649function FillEnum(){ return 645;}
     650function FractionIncrementEnum(){ return 646;}
     651function FrictionEnum(){ return 647;}
     652function InternalEnum(){ return 648;}
     653function MassFluxEnum(){ return 649;}
     654function MeltingOffsetEnum(){ return 650;}
     655function MisfitEnum(){ return 651;}
     656function PressureEnum(){ return 652;}
     657function PressurePicardEnum(){ return 653;}
     658function AndroidFrictionCoefficientEnum(){ return 654;}
     659function ResetPenaltiesEnum(){ return 655;}
     660function SegmentOnIceShelfEnum(){ return 656;}
     661function SurfaceAbsVelMisfitEnum(){ return 657;}
     662function SurfaceAreaEnum(){ return 658;}
     663function SurfaceAverageVelMisfitEnum(){ return 659;}
     664function SurfaceLogVelMisfitEnum(){ return 660;}
     665function SurfaceLogVxVyMisfitEnum(){ return 661;}
     666function SurfaceRelVelMisfitEnum(){ return 662;}
     667function SurfaceSlopeXEnum(){ return 663;}
     668function SurfaceSlopeYEnum(){ return 664;}
     669function TemperatureEnum(){ return 665;}
     670function TemperaturePicardEnum(){ return 666;}
     671function TemperaturePDDEnum(){ return 667;}
     672function ThicknessAbsMisfitEnum(){ return 668;}
     673function SurfaceAbsMisfitEnum(){ return 669;}
     674function VelEnum(){ return 670;}
     675function VelocityEnum(){ return 671;}
     676function VxAverageEnum(){ return 672;}
     677function VxEnum(){ return 673;}
     678function VxPicardEnum(){ return 674;}
     679function VyAverageEnum(){ return 675;}
     680function VyEnum(){ return 676;}
     681function VyPicardEnum(){ return 677;}
     682function VzEnum(){ return 678;}
     683function VzSSAEnum(){ return 679;}
     684function VzHOEnum(){ return 680;}
     685function VzPicardEnum(){ return 681;}
     686function VzFSEnum(){ return 682;}
     687function VxMeshEnum(){ return 683;}
     688function VyMeshEnum(){ return 684;}
     689function VzMeshEnum(){ return 685;}
     690function EnthalpyEnum(){ return 686;}
     691function EnthalpyPicardEnum(){ return 687;}
     692function ThicknessAbsGradientEnum(){ return 688;}
     693function ThicknessAlongGradientEnum(){ return 689;}
     694function ThicknessAcrossGradientEnum(){ return 690;}
     695function ThicknessPositiveEnum(){ return 691;}
     696function IntMatParamEnum(){ return 692;}
     697function RheologyBbarAbsGradientEnum(){ return 693;}
     698function RheologyBAbsGradientEnum(){ return 694;}
     699function DragCoefficientAbsGradientEnum(){ return 695;}
     700function TransientInputEnum(){ return 696;}
     701function WaterfractionEnum(){ return 697;}
     702function WatercolumnEnum(){ return 698;}
     703function BasalFrictionEnum(){ return 699;}
     704function ViscousHeatingEnum(){ return 700;}
     705function HydrologyWaterVxEnum(){ return 701;}
     706function HydrologyWaterVyEnum(){ return 702;}
     707function DrivingStressXEnum(){ return 703;}
     708function DrivingStressYEnum(){ return 704;}
     709function SigmaNNEnum(){ return 705;}
     710function StressTensorEnum(){ return 706;}
     711function StressTensorxxEnum(){ return 707;}
     712function StressTensorxyEnum(){ return 708;}
     713function StressTensorxzEnum(){ return 709;}
     714function StressTensoryyEnum(){ return 710;}
     715function StressTensoryzEnum(){ return 711;}
     716function StressTensorzzEnum(){ return 712;}
     717function StressMaxPrincipalEnum(){ return 713;}
     718function DeviatoricStressEnum(){ return 714;}
     719function DeviatoricStressxxEnum(){ return 715;}
     720function DeviatoricStressxyEnum(){ return 716;}
     721function DeviatoricStressxzEnum(){ return 717;}
     722function DeviatoricStressyyEnum(){ return 718;}
     723function DeviatoricStressyzEnum(){ return 719;}
     724function DeviatoricStresszzEnum(){ return 720;}
     725function DeviatoricStresseffectiveEnum(){ return 721;}
     726function StrainRateEnum(){ return 722;}
     727function StrainRatexxEnum(){ return 723;}
     728function StrainRatexyEnum(){ return 724;}
     729function StrainRatexzEnum(){ return 725;}
     730function StrainRateyyEnum(){ return 726;}
     731function StrainRateyzEnum(){ return 727;}
     732function StrainRatezzEnum(){ return 728;}
     733function DivergenceEnum(){ return 729;}
     734function MaxDivergenceEnum(){ return 730;}
     735function GiaCrossSectionShapeEnum(){ return 731;}
     736function GiadWdtEnum(){ return 732;}
     737function GiaWEnum(){ return 733;}
     738function P0Enum(){ return 734;}
     739function P0ArrayEnum(){ return 735;}
     740function P1Enum(){ return 736;}
     741function P1DGEnum(){ return 737;}
     742function P1bubbleEnum(){ return 738;}
     743function P1bubblecondensedEnum(){ return 739;}
     744function P2Enum(){ return 740;}
     745function P2bubbleEnum(){ return 741;}
     746function P2bubblecondensedEnum(){ return 742;}
     747function P2xP1Enum(){ return 743;}
     748function P1xP2Enum(){ return 744;}
     749function P1xP3Enum(){ return 745;}
     750function P2xP4Enum(){ return 746;}
     751function P1P1Enum(){ return 747;}
     752function P1P1GLSEnum(){ return 748;}
     753function MINIEnum(){ return 749;}
     754function MINIcondensedEnum(){ return 750;}
     755function TaylorHoodEnum(){ return 751;}
     756function LATaylorHoodEnum(){ return 752;}
     757function XTaylorHoodEnum(){ return 753;}
     758function OneLayerP4zEnum(){ return 754;}
     759function CrouzeixRaviartEnum(){ return 755;}
     760function LACrouzeixRaviartEnum(){ return 756;}
     761function SaveResultsEnum(){ return 757;}
     762function BoolExternalResultEnum(){ return 758;}
     763function DoubleExternalResultEnum(){ return 759;}
     764function DoubleMatExternalResultEnum(){ return 760;}
     765function IntExternalResultEnum(){ return 761;}
     766function JEnum(){ return 762;}
     767function StringExternalResultEnum(){ return 763;}
     768function StepEnum(){ return 764;}
     769function TimeEnum(){ return 765;}
     770function WaterColumnOldEnum(){ return 766;}
     771function OutputdefinitionEnum(){ return 767;}
     772function Outputdefinition1Enum(){ return 768;}
     773function Outputdefinition2Enum(){ return 769;}
     774function Outputdefinition3Enum(){ return 770;}
     775function Outputdefinition4Enum(){ return 771;}
     776function Outputdefinition5Enum(){ return 772;}
     777function Outputdefinition6Enum(){ return 773;}
     778function Outputdefinition7Enum(){ return 774;}
     779function Outputdefinition8Enum(){ return 775;}
     780function Outputdefinition9Enum(){ return 776;}
     781function Outputdefinition10Enum(){ return 777;}
     782function Outputdefinition11Enum(){ return 778;}
     783function Outputdefinition12Enum(){ return 779;}
     784function Outputdefinition13Enum(){ return 780;}
     785function Outputdefinition14Enum(){ return 781;}
     786function Outputdefinition15Enum(){ return 782;}
     787function Outputdefinition16Enum(){ return 783;}
     788function Outputdefinition17Enum(){ return 784;}
     789function Outputdefinition18Enum(){ return 785;}
     790function Outputdefinition19Enum(){ return 786;}
     791function Outputdefinition20Enum(){ return 787;}
     792function Outputdefinition21Enum(){ return 788;}
     793function Outputdefinition22Enum(){ return 789;}
     794function Outputdefinition23Enum(){ return 790;}
     795function Outputdefinition24Enum(){ return 791;}
     796function Outputdefinition25Enum(){ return 792;}
     797function Outputdefinition26Enum(){ return 793;}
     798function Outputdefinition27Enum(){ return 794;}
     799function Outputdefinition28Enum(){ return 795;}
     800function Outputdefinition29Enum(){ return 796;}
     801function Outputdefinition30Enum(){ return 797;}
     802function Outputdefinition31Enum(){ return 798;}
     803function Outputdefinition32Enum(){ return 799;}
     804function Outputdefinition33Enum(){ return 800;}
     805function Outputdefinition34Enum(){ return 801;}
     806function Outputdefinition35Enum(){ return 802;}
     807function Outputdefinition36Enum(){ return 803;}
     808function Outputdefinition37Enum(){ return 804;}
     809function Outputdefinition38Enum(){ return 805;}
     810function Outputdefinition39Enum(){ return 806;}
     811function Outputdefinition40Enum(){ return 807;}
     812function Outputdefinition41Enum(){ return 808;}
     813function Outputdefinition42Enum(){ return 809;}
     814function Outputdefinition43Enum(){ return 810;}
     815function Outputdefinition44Enum(){ return 811;}
     816function Outputdefinition45Enum(){ return 812;}
     817function Outputdefinition46Enum(){ return 813;}
     818function Outputdefinition47Enum(){ return 814;}
     819function Outputdefinition48Enum(){ return 815;}
     820function Outputdefinition49Enum(){ return 816;}
     821function Outputdefinition50Enum(){ return 817;}
     822function Outputdefinition51Enum(){ return 818;}
     823function Outputdefinition52Enum(){ return 819;}
     824function Outputdefinition53Enum(){ return 820;}
     825function Outputdefinition54Enum(){ return 821;}
     826function Outputdefinition55Enum(){ return 822;}
     827function Outputdefinition56Enum(){ return 823;}
     828function Outputdefinition57Enum(){ return 824;}
     829function Outputdefinition58Enum(){ return 825;}
     830function Outputdefinition59Enum(){ return 826;}
     831function Outputdefinition60Enum(){ return 827;}
     832function Outputdefinition61Enum(){ return 828;}
     833function Outputdefinition62Enum(){ return 829;}
     834function Outputdefinition63Enum(){ return 830;}
     835function Outputdefinition64Enum(){ return 831;}
     836function Outputdefinition65Enum(){ return 832;}
     837function Outputdefinition66Enum(){ return 833;}
     838function Outputdefinition67Enum(){ return 834;}
     839function Outputdefinition68Enum(){ return 835;}
     840function Outputdefinition69Enum(){ return 836;}
     841function Outputdefinition70Enum(){ return 837;}
     842function Outputdefinition71Enum(){ return 838;}
     843function Outputdefinition72Enum(){ return 839;}
     844function Outputdefinition73Enum(){ return 840;}
     845function Outputdefinition74Enum(){ return 841;}
     846function Outputdefinition75Enum(){ return 842;}
     847function Outputdefinition76Enum(){ return 843;}
     848function Outputdefinition77Enum(){ return 844;}
     849function Outputdefinition78Enum(){ return 845;}
     850function Outputdefinition79Enum(){ return 846;}
     851function Outputdefinition80Enum(){ return 847;}
     852function Outputdefinition81Enum(){ return 848;}
     853function Outputdefinition82Enum(){ return 849;}
     854function Outputdefinition83Enum(){ return 850;}
     855function Outputdefinition84Enum(){ return 851;}
     856function Outputdefinition85Enum(){ return 852;}
     857function Outputdefinition86Enum(){ return 853;}
     858function Outputdefinition87Enum(){ return 854;}
     859function Outputdefinition88Enum(){ return 855;}
     860function Outputdefinition89Enum(){ return 856;}
     861function Outputdefinition90Enum(){ return 857;}
     862function Outputdefinition91Enum(){ return 858;}
     863function Outputdefinition92Enum(){ return 859;}
     864function Outputdefinition93Enum(){ return 860;}
     865function Outputdefinition94Enum(){ return 861;}
     866function Outputdefinition95Enum(){ return 862;}
     867function Outputdefinition96Enum(){ return 863;}
     868function Outputdefinition97Enum(){ return 864;}
     869function Outputdefinition98Enum(){ return 865;}
     870function Outputdefinition99Enum(){ return 866;}
     871function Outputdefinition100Enum(){ return 867;}
     872function OutputdefinitionListEnum(){ return 868;}
     873function MassfluxatgateEnum(){ return 869;}
     874function MassfluxatgateNameEnum(){ return 870;}
     875function MassfluxatgateDefinitionenumEnum(){ return 871;}
     876function MassfluxatgateSegmentsEnum(){ return 872;}
     877function NodalvalueEnum(){ return 873;}
     878function NodalvalueNameEnum(){ return 874;}
     879function NodalvalueDefinitionenumEnum(){ return 875;}
     880function NodalvalueModelEnum(){ return 876;}
     881function NodalvalueNodeEnum(){ return 877;}
     882function MisfitNameEnum(){ return 878;}
     883function MisfitDefinitionenumEnum(){ return 879;}
     884function MisfitModelEnum(){ return 880;}
     885function MisfitObservationEnum(){ return 881;}
     886function MisfitObservationEnum(){ return 882;}
     887function MisfitLocalEnum(){ return 883;}
     888function MisfitTimeinterpolationEnum(){ return 884;}
     889function MisfitWeightsEnum(){ return 885;}
     890function MisfitWeightsEnum(){ return 886;}
     891function SurfaceObservationEnum(){ return 887;}
     892function WeightsSurfaceObservationEnum(){ return 888;}
     893function VxObsEnum(){ return 889;}
     894function WeightsVxObsEnum(){ return 890;}
     895function VyObsEnum(){ return 891;}
     896function WeightsVyObsEnum(){ return 892;}
     897function MinVelEnum(){ return 893;}
     898function MaxVelEnum(){ return 894;}
     899function MinVxEnum(){ return 895;}
     900function MaxVxEnum(){ return 896;}
     901function MaxAbsVxEnum(){ return 897;}
     902function MinVyEnum(){ return 898;}
     903function MaxVyEnum(){ return 899;}
     904function MaxAbsVyEnum(){ return 900;}
     905function MinVzEnum(){ return 901;}
     906function MaxVzEnum(){ return 902;}
     907function MaxAbsVzEnum(){ return 903;}
     908function FloatingAreaEnum(){ return 904;}
     909function GroundedAreaEnum(){ return 905;}
     910function IceMassEnum(){ return 906;}
     911function IceVolumeEnum(){ return 907;}
     912function IceVolumeAboveFloatationEnum(){ return 908;}
     913function TotalFloatingBmbEnum(){ return 909;}
     914function TotalGroundedBmbEnum(){ return 910;}
     915function TotalSmbEnum(){ return 911;}
     916function AbsoluteEnum(){ return 912;}
     917function IncrementalEnum(){ return 913;}
     918function AugmentedLagrangianREnum(){ return 914;}
     919function AugmentedLagrangianRhopEnum(){ return 915;}
     920function AugmentedLagrangianRlambdaEnum(){ return 916;}
     921function AugmentedLagrangianRholambdaEnum(){ return 917;}
     922function AugmentedLagrangianThetaEnum(){ return 918;}
     923function NoneEnum(){ return 919;}
     924function AggressiveMigrationEnum(){ return 920;}
     925function SoftMigrationEnum(){ return 921;}
     926function SubelementMigrationEnum(){ return 922;}
     927function SubelementMigration2Enum(){ return 923;}
     928function ContactEnum(){ return 924;}
     929function GroundingOnlyEnum(){ return 925;}
     930function MaskGroundediceLevelsetEnum(){ return 926;}
     931function GaussSegEnum(){ return 927;}
     932function GaussTriaEnum(){ return 928;}
     933function GaussTetraEnum(){ return 929;}
     934function GaussPentaEnum(){ return 930;}
     935function FSSolverEnum(){ return 931;}
     936function AdjointEnum(){ return 932;}
     937function ColinearEnum(){ return 933;}
     938function ControlSteadyEnum(){ return 934;}
     939function FsetEnum(){ return 935;}
     940function Gradient1Enum(){ return 936;}
     941function Gradient2Enum(){ return 937;}
     942function Gradient3Enum(){ return 938;}
     943function GradientEnum(){ return 939;}
     944function GroundinglineMigrationEnum(){ return 940;}
     945function GsetEnum(){ return 941;}
     946function IndexEnum(){ return 942;}
     947function IndexedEnum(){ return 943;}
     948function IntersectEnum(){ return 944;}
     949function NodalEnum(){ return 945;}
     950function OldGradientEnum(){ return 946;}
     951function OutputBufferPointerEnum(){ return 947;}
     952function OutputBufferSizePointerEnum(){ return 948;}
     953function OutputFilePointerEnum(){ return 949;}
     954function ToolkitsFileNameEnum(){ return 950;}
     955function RootPathEnum(){ return 951;}
     956function OutputFileNameEnum(){ return 952;}
     957function InputFileNameEnum(){ return 953;}
     958function LockFileNameEnum(){ return 954;}
     959function RestartFileNameEnum(){ return 955;}
     960function ToolkitsOptionsAnalysesEnum(){ return 956;}
     961function ToolkitsOptionsStringsEnum(){ return 957;}
     962function QmuErrNameEnum(){ return 958;}
     963function QmuInNameEnum(){ return 959;}
     964function QmuOutNameEnum(){ return 960;}
     965function RegularEnum(){ return 961;}
     966function ScaledEnum(){ return 962;}
     967function SeparateEnum(){ return 963;}
     968function SsetEnum(){ return 964;}
     969function VerboseEnum(){ return 965;}
     970function TriangleInterpEnum(){ return 966;}
     971function BilinearInterpEnum(){ return 967;}
     972function NearestInterpEnum(){ return 968;}
     973function XYEnum(){ return 969;}
     974function XYZEnum(){ return 970;}
     975function DenseEnum(){ return 971;}
     976function MpiDenseEnum(){ return 972;}
     977function MpiSparseEnum(){ return 973;}
     978function SeqEnum(){ return 974;}
     979function MpiEnum(){ return 975;}
     980function MumpsEnum(){ return 976;}
     981function GslEnum(){ return 977;}
     982function OptionEnum(){ return 978;}
     983function GenericOptionEnum(){ return 979;}
     984function OptionCellEnum(){ return 980;}
     985function OptionStructEnum(){ return 981;}
     986function CuffeyEnum(){ return 982;}
     987function CuffeyTemperateEnum(){ return 983;}
     988function PatersonEnum(){ return 984;}
     989function ArrheniusEnum(){ return 985;}
     990function LliboutryDuvalEnum(){ return 986;}
     991function SpclevelsetEnum(){ return 987;}
     992function ExtrapolationVariableEnum(){ return 988;}
     993function IceMaskNodeActivationEnum(){ return 989;}
     994function LevelsetfunctionSlopeXEnum(){ return 990;}
     995function LevelsetfunctionSlopeYEnum(){ return 991;}
     996function LevelsetfunctionPicardEnum(){ return 992;}
     997function LevelsetReinitFrequencyEnum(){ return 993;}
     998function SealevelriseSolutionEnum(){ return 994;}
     999function SealevelriseAnalysisEnum(){ return 995;}
     1000function SealevelEnum(){ return 996;}
     1001function SealevelEustaticEnum(){ return 997;}
     1002function SealevelriseDeltathicknessEnum(){ return 998;}
     1003function SealevelriseMaxiterEnum(){ return 999;}
     1004function SealevelriseReltolEnum(){ return 1000;}
     1005function SealevelriseAbstolEnum(){ return 1001;}
     1006function SealevelriseLoveHEnum(){ return 1002;}
     1007function SealevelriseLoveKEnum(){ return 1003;}
     1008function SealevelriseTideLoveHEnum(){ return 1004;}
     1009function SealevelriseTideLoveKEnum(){ return 1005;}
     1010function SealevelriseRigidEnum(){ return 1006;}
     1011function SealevelriseElasticEnum(){ return 1007;}
     1012function SealevelriseRotationEnum(){ return 1008;}
     1013function SealevelriseGElasticEnum(){ return 1009;}
     1014function SealevelriseDegaccEnum(){ return 1010;}
     1015function SealevelriseTransitionsEnum(){ return 1011;}
     1016function SealevelriseRequestedOutputsEnum(){ return 1012;}
     1017function SealevelriseNumRequestedOutputsEnum(){ return 1013;}
     1018function ParametersENDEnum(){ return 1014;}
     1019function MaximumNumberOfDefinitionsEnum(){ return 1015;}

  • issm/trunk-jpl/src/m/enum/EnumDefinitions.py

    r20644 r20663  
    185185def HydrologySpcheadEnum(): return StringToEnum("HydrologySpchead")[0]
    186186def HydrologyConductivityEnum(): return StringToEnum("HydrologyConductivity")[0]
    187 def IndependentObjectEnum(): return StringToEnum("IndependentObject")[0]
    188187def InversionControlParametersEnum(): return StringToEnum("InversionControlParameters")[0]
    189188def InversionControlScalingFactorsEnum(): return StringToEnum("InversionControlScalingFactors")[0]
    … …  
    229228def MaterialsRheologyNEnum(): return StringToEnum("MaterialsRheologyN")[0]
    230229def MaterialsRheologyKoEnum(): return StringToEnum("MaterialsRheologyKo")[0]
     230def MaterialsRheologyKobarEnum(): return StringToEnum("MaterialsRheologyKobar")[0]
    231231def MaterialsRheologyEcEnum(): return StringToEnum("MaterialsRheologyEc")[0]
     232def MaterialsRheologyEcbarEnum(): return StringToEnum("MaterialsRheologyEcbar")[0]
    232233def MaterialsRheologyEsEnum(): return StringToEnum("MaterialsRheologyEs")[0]
     234def MaterialsRheologyEsbarEnum(): return StringToEnum("MaterialsRheologyEsbar")[0]
    233235def DamageIsdamageEnum(): return StringToEnum("DamageIsdamage")[0]
    234236def DamageDEnum(): return StringToEnum("DamageD")[0]
    … …  
    591593def MaticeEnum(): return StringToEnum("Matice")[0]
    592594def MatdamageiceEnum(): return StringToEnum("Matdamageice")[0]
    593 def MatbaflEnum(): return StringToEnum("Matbafl")[0]
     595def MatearlEnum(): return StringToEnum("Matearl")[0]
    594596def MatparEnum(): return StringToEnum("Matpar")[0]
    595597def NodeEnum(): return StringToEnum("Node")[0]

  • issm/trunk-jpl/src/m/exp/exptool.m

    r19204 r20663  
    158158        undoplots(prevplot);
    159159        if numprofiles
    160                 prevplot2=1;
     160                if ~nofigurecopy,
     161                        prevplot2=1;
     162                else
     163                        prevplot2=L;
     164                end
    161165                for i=1:numprofiles
    162166                        if length(A(i).x)==1,
Note: See TracChangeset for help on using the changeset viewer.