Changeset 21049


Ignore:
Timestamp:
08/02/16 17:06:46 (9 years ago)
Author:
agscott1
Message:

CHG: Replaced Enums with Strings in matlab and python. Updated corresponding cpp code.

Location:
issm/trunk-jpl
Files:
617 edited

Legend:

Unmodified
Added
Removed

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

    r20993 r21049  
    14891489        if(control_analysis && iomodel->Data("md.inversion.cost_functions_coefficients")) {
    14901490
     1491                /*Generate cost functions associated with the iomodel*/
     1492                char**  cost_functions                  = NULL;
     1493                int*            cost_functions_enums = NULL;
     1494                int             num_cost_functions;
     1495
     1496                iomodel->FindConstant(&num_cost_functions,"md.inversion.num_cost_functions");
     1497                iomodel->FindConstant(&cost_functions,&num_cost_functions,"md.inversion.cost_functions");
     1498                if(num_cost_functions<1) _error_("No cost functions found");
     1499                cost_functions_enums=xNew<int>(num_cost_functions);
     1500                for(int j=0;j<num_cost_functions;j++){ cost_functions_enums[j]=StringToEnumx(cost_functions[j]); }
     1501
    14911502                /*Create inputs and add to DataSetInput*/
    14921503                DatasetInput* datasetinput=new DatasetInput(InversionCostFunctionsCoefficientsEnum);
    14931504                for(i=0;i<num_responses;i++){
    14941505                        for(j=0;j<NUMVERTICES;j++)nodeinputs[j]=iomodel->Data("md.inversion.cost_functions_coefficients")[(penta_vertex_ids[j]-1)*num_responses+i];
    1495                         datasetinput->AddInput(new PentaInput(InversionCostFunctionsCoefficientsEnum,nodeinputs,P1Enum),reCast<int>(iomodel->Data("md.inversion.cost_functions")[i]));
     1506                        datasetinput->AddInput(new PentaInput(InversionCostFunctionsCoefficientsEnum,nodeinputs,P1Enum),cost_functions_enums[i]);
    14961507                }
    14971508
    14981509                /*Add datasetinput to element inputs*/
    14991510                this->inputs->AddInput(datasetinput);
     1511
     1512                /*Free resources*/
     1513                for(int j=0;j<num_cost_functions;j++) xDelete<char>(cost_functions[j]);
     1514                xDelete<char*>(cost_functions);
     1515                xDelete<int>(cost_functions_enums);
    15001516        }
    15011517}

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

    r20993 r21049  
    453453        if (control_analysis && iomodel->Data("md.inversion.cost_functions_coefficients")) {
    454454
     455                /*Generate cost functions associated with the iomodel*/
     456                char**  cost_functions                  = NULL;
     457                int*            cost_functions_enums = NULL;
     458                int             num_cost_functions;
     459
     460                iomodel->FindConstant(&num_cost_functions,"md.inversion.num_cost_functions");
     461                iomodel->FindConstant(&cost_functions,&num_cost_functions,"md.inversion.cost_functions");
     462                if(num_cost_functions<1) _error_("No cost functions found");
     463                cost_functions_enums=xNew<int>(num_cost_functions);
     464                for(int j=0;j<num_cost_functions;j++){ cost_functions_enums[j]=StringToEnumx(cost_functions[j]); }
     465
    455466                /*Create inputs and add to DataSetInput*/
    456467                DatasetInput* datasetinput=new DatasetInput(InversionCostFunctionsCoefficientsEnum);
    457468                for(i=0;i<num_responses;i++){
    458469                        for(j=0;j<NUMVERTICES;j++)nodeinputs[j]=iomodel->Data("md.inversion.cost_functions_coefficients")[(tetra_vertex_ids[j]-1)*num_responses+i];
    459                         datasetinput->AddInput(new TetraInput(InversionCostFunctionsCoefficientsEnum,nodeinputs,P1Enum),reCast<int>(iomodel->Data("md.inversion.cost_functions")[i]));
     470                        datasetinput->AddInput(new TetraInput(InversionCostFunctionsCoefficientsEnum,nodeinputs,P1Enum),cost_functions_enums[i]);
    460471                }
    461472
    462473                /*Add datasetinput to element inputs*/
    463474                this->inputs->AddInput(datasetinput);
     475
     476                /*Clean up cost functions*/
     477                xDelete<int>(cost_functions_enums);
     478                for(int j=0;j<num_cost_functions;j++) xDelete<char>(cost_functions[j]);
     479                xDelete<char*>(cost_functions);
    464480        }
    465481}

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

    r21031 r21049  
    18231823        /*DatasetInputs*/
    18241824        if (control_analysis && iomodel->Data("md.inversion.cost_functions_coefficients")){
     1825       
     1826                /*Generate cost functions associated with the iomodel*/
     1827                char**  cost_functions                  = NULL;
     1828                int*            cost_functions_enums = NULL;
     1829                int             num_cost_functions;
     1830
     1831                iomodel->FindConstant(&num_cost_functions,"md.inversion.num_cost_functions");
     1832                iomodel->FindConstant(&cost_functions,&num_cost_functions,"md.inversion.cost_functions");
     1833                if(num_cost_functions<1) _error_("No cost functions found");
     1834                cost_functions_enums=xNew<int>(num_cost_functions);
     1835                for(int j=0;j<num_cost_functions;j++){ cost_functions_enums[j]=StringToEnumx(cost_functions[j]); }
    18251836
    18261837                /*Create inputs and add to DataSetInput*/
    … …  
    18281839                for(i=0;i<num_responses;i++){
    18291840                        for(j=0;j<3;j++)nodeinputs[j]=iomodel->Data("md.inversion.cost_functions_coefficients")[(tria_vertex_ids[j]-1)*num_responses+i];
    1830                         datasetinput->AddInput(new TriaInput(InversionCostFunctionsCoefficientsEnum,nodeinputs,P1Enum),reCast<int>(iomodel->Data("md.inversion.cost_functions")[i]));
     1841                        datasetinput->AddInput(new TriaInput(InversionCostFunctionsCoefficientsEnum,nodeinputs,P1Enum),cost_functions_enums[i]);
    18311842                }
    18321843
    18331844                /*Add datasetinput to element inputs*/
    18341845                this->inputs->AddInput(datasetinput);
     1846
     1847                /*Clean up cost functions*/
     1848                xDelete<int>(cost_functions_enums);
     1849                for(int j=0;j<num_cost_functions;j++) xDelete<char>(cost_functions[j]);
     1850                xDelete<char*>(cost_functions);
    18351851        }
    18361852}

  • issm/trunk-jpl/src/c/classes/Loads/Riftfront.cpp

    r20827 r21049  
    8686        //intialize properties
    8787        this->type=SegmentRiftfrontEnum;
    88         this->fill = reCast<int,IssmDouble>(*(iomodel->Data("md.rifts.riftstruct")+RIFTINFOSIZE*i+7));
     88        this->fill = IoRiftfillToEnum(reCast<int,IssmDouble>(*(iomodel->Data("md.rifts.riftstruct")+RIFTINFOSIZE*i+7)));
    8989        this->friction=*(iomodel->Data("md.rifts.riftstruct")+RIFTINFOSIZE*i+8);
    9090        this->fractionincrement=*(iomodel->Data("md.rifts.riftstruct")+RIFTINFOSIZE*i+10);

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

    r20810 r21049  
    5353
    5454                        this->definitionenum=in_definitionenum;
    55                         this->name   = xNew<char>(strlen(in_name)+1);
     55                       
     56                        this->name              = xNew<char>(strlen(in_name)+1);
    5657                        xMemCpy<char>(this->name,in_name,strlen(in_name)+1);
    5758
    58                         this->timeinterpolation   = xNew<char>(strlen(in_timeinterpolation)+1);
     59                        this->timeinterpolation = xNew<char>(strlen(in_timeinterpolation)+1);
    5960                        xMemCpy<char>(this->timeinterpolation,in_timeinterpolation,strlen(in_timeinterpolation)+1);
    60 
     61                                               
    6162                        this->model_enum=in_model_enum;
    6263                        this->observation_enum=in_observation_enum;
    … …  
    110111                /*Definition virtual function resolutoin: */
    111112                int DefinitionEnum(){/*{{{*/
    112 
    113113                        return this->definitionenum;
    114114                }
    115115                /*}}}*/
    116116                char* Name(){/*{{{*/
    117 
    118117                        char* name2=xNew<char>(strlen(this->name)+1);
    119118                        xMemCpy(name2,this->name,strlen(this->name)+1);

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

    r20690 r21049  
    88#include "../ModelProcessorx.h"
    99
    10 void CreateParametersControl(Parameters* parameters,IoModel* iomodel,int solution_type){
     10void CreateParametersControl(Parameters* parameters,IoModel* iomodel,int solution_type){/*{{{*/
    1111
    1212        bool        control_analysis;
    … …  
    1717        char**      controls      = NULL;
    1818        int        *maxiter       = NULL;
    19         int        *cm_responses  = NULL;
     19        char**      cm_responses  = NULL;
    2020        IssmDouble *cm_jump       = NULL;
    2121        IssmDouble *optscal       = NULL;
    … …  
    5151                parameters->AddObject(new IntVecParam(InversionControlParametersEnum,control_enums,num_controls));
    5252
    53                 iomodel->FetchData(&cm_responses,NULL,&num_costfunc,"md.inversion.cost_functions");
    54                 parameters->AddObject(new IntVecParam(InversionCostFunctionsEnum,cm_responses,num_costfunc));
     53                iomodel->FindConstant(&cm_responses,&num_costfunc,"md.inversion.cost_functions");
     54                if(num_costfunc<1) _error_ ("no cost functions found");
     55                int* costfunc_enums=xNew<int>(num_costfunc);
     56                for(int i=0;i<num_costfunc;i++){
     57                        costfunc_enums[i]=StringToEnumx(cm_responses[i]);
     58                        xDelete<char>(cm_responses[i]);
     59                }
     60                xDelete<char*>(cm_responses);
     61                parameters->AddObject(new IntVecParam(InversionCostFunctionsEnum,costfunc_enums,num_costfunc));
     62               
    5563                xDelete<int>(control_enums);
     64                xDelete<int>(costfunc_enums);
    5665
    5766                /*Inversion type specifics*/
    … …  
    103112                        default:
    104113                                _error_("not supported");
    105 
    106114                }
    107115
    108116                xDelete<int>(control_enums);
    109                 xDelete<int>(cm_responses);
    110117                xDelete<int>(maxiter);
    111118                xDelete<IssmDouble>(control_scaling_factors);
    … …  
    113120                iomodel->DeleteData(optscal,"md.inversion.gradient_scaling");
    114121        }
    115 }
     122}/*}}}*/

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

    r20690 r21049  
    1212
    1313        /*Intermediary*/
    14         int       control,cost_function,domaintype;
    15         Element  *element = NULL;
    16         Material *material = NULL;
    17         int       num_controls,num_cost_functions;
    18         int*      control_enums = NULL;
    19         char**    controls;
    20         bool      control_analysis;
     14        bool       control_analysis;
     15        int        control,cost_function,domaintype;
     16        int        num_controls,num_cost_functions;
     17        Element   *element          = NULL;
     18        Material  *material         = NULL;
     19        int       *control_enums    = NULL;
     20        char     **controls         = NULL;
     21        char     **cost_functions   = NULL;
    2122
    2223        /*Fetch parameters: */
    … …  
    3536        }
    3637
    37         iomodel->FetchData(4,"md.inversion.cost_functions","md.inversion.cost_functions_coefficients","md.inversion.min_parameters","md.inversion.max_parameters");
     38        /*Process cost functions and convert from string to enums*/
     39        iomodel->FindConstant(&num_cost_functions,"md.inversion.num_cost_functions");
     40        iomodel->FindConstant(&cost_functions,&num_cost_functions,"md.inversion.cost_functions");
     41        if(num_cost_functions<1) _error_("No cost functions found");
     42        int* cost_function_enums=xNew<int>(num_cost_functions);
     43        for(int i=0;i<num_cost_functions;++i){
     44                cost_function_enums[i]=StringToEnumx(cost_functions[i]);
     45        }
    3846
     47        iomodel->FetchData(3,"md.inversion.cost_functions_coefficients","md.inversion.min_parameters","md.inversion.max_parameters");
     48       
    3949        /*Fetch Observations */
    40         iomodel->FindConstant(&num_cost_functions,"md.inversion.num_cost_functions");
    4150        iomodel->FindConstant(&domaintype,"md.mesh.domain_type");
    4251        for(int i=0;i<num_cost_functions;i++){
    43                 cost_function= reCast<int,IssmDouble>(iomodel->Data("md.inversion.cost_functions")[i]);
    44                 //iomodel->FetchDataToInput(elements,"md.inversion.thickness_obs",InversionThicknessObsEnum);
     52                cost_function=cost_function_enums[i];
    4553                if(     cost_function==ThicknessAbsMisfitEnum) iomodel->FetchDataToInput(elements,"md.inversion.thickness_obs",InversionThicknessObsEnum);
    4654                else if(cost_function==SurfaceAbsMisfitEnum)   iomodel->FetchDataToInput(elements,"md.inversion.surface_obs",InversionSurfaceObsEnum);
    … …  
    106114                }
    107115        }
    108         iomodel->DeleteData(4,"md.inversion.cost_functions","md.inversion.cost_functions_coefficients","md.inversion.min_parameters","md.inversion.max_parameters");
     116
     117        iomodel->DeleteData(3,"md.inversion.cost_functions_coefficients","md.inversion.min_parameters","md.inversion.max_parameters");
    109118        xDelete<int>(control_enums);
     119        xDelete<int>(cost_function_enums);
     120        for(int i=0;i<num_cost_functions;i++) xDelete<char>(cost_functions[i]);
     121        xDelete<char*>(cost_functions);
    110122        for(int i=0;i<num_controls;i++) xDelete<char>(controls[i]);
    111123        xDelete<char*>(controls);
    112 
    113 
    114 
    115124}

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

    r20690 r21049  
    1818        /*Create output_definitions dataset: */
    1919        output_definitions=new DataSet();
    20        
    21         iomodel->FetchData(&output_definition_enums,&num_output_definitions,NULL,"md.outputdefinition.list");
     20
     21        char** out_strings = NULL;
     22        iomodel->FetchData(&out_strings,&num_output_definitions,"md.outputdefinition.list");
     23        if(num_output_definitions>0){
     24                output_definition_enums=xNew<int>(num_output_definitions);
     25                for(int i=0;i<num_output_definitions;i++){
     26                        output_definition_enums[i]=StringToEnumx(out_strings[i]);
     27                }
     28        }
     29        // free data
     30        for(int i=0;i<num_output_definitions;i++) xDelete<char>(out_strings[i]);
     31        xDelete<char*>(out_strings);
     32
    2233        if(num_output_definitions){
    2334                for (i=0;i<num_output_definitions;i++){
    … …  
    2839                                int          temp,numgates;
    2940                                char       **gatenames           = NULL;
    30                                 int         *gatedefinitionenums = NULL;
     41                                char              **gatedefinitionstrings = NULL;
    3142                                IssmDouble **gatesegments        = NULL;
    3243                                int         *gatesegments_M      = NULL;
    … …  
    3445                                /*Fetch segments and names: */
    3546                                iomodel->FetchMultipleData(&gatenames,&numgates,                     "md.massfluxatgate.name");
    36                                 iomodel->FetchMultipleData(&gatedefinitionenums,&temp,               "md.massfluxatgate.definitionenum"); _assert_(temp==numgates);
     47                                iomodel->FetchMultipleData(&gatedefinitionstrings,&temp,             "md.massfluxatgate.definitionstring"); _assert_(temp==numgates);
    3748                                iomodel->FetchMultipleData(&gatesegments,&gatesegments_M,NULL,&temp, "md.massfluxatgate.segments");       _assert_(temp==numgates);
    3849
    3950                                for(j=0;j<numgates;j++){
    40                                         output_definitions->AddObject(new Massfluxatgate<IssmDouble>(gatenames[j],gatedefinitionenums[j],gatesegments_M[j],gatesegments[j]));
     51                                        output_definitions->AddObject(new Massfluxatgate<IssmDouble>(gatenames[j],StringToEnumx(gatedefinitionstrings[j]),gatesegments_M[j],gatesegments[j]));
    4152                                }
    4253                                /*Free ressources:*/
    … …  
    4859                                xDelete<IssmDouble*>(gatesegments);
    4960                                xDelete<int>(gatesegments_M);
    50                                 xDelete<int>(gatedefinitionenums);
     61                                xDelete<char*>(gatedefinitionstrings);
    5162                                /*}}}*/
    5263                        }
    … …  
    5667                                /*misfit variables: */
    5768                                int          nummisfits;
    58                                 char**       misfit_name_s             = NULL;   
    59                                 int*         misfit_definitionenums_s             = NULL;   
    60                                 int*         misfit_model_enum_s        = NULL;
    61                                 IssmDouble** misfit_observation_s      = NULL;
    62                                 int*         misfit_observation_enum_s  = NULL;
    63                                 int*         misfit_observation_M_s    = NULL;
    64                                 int*         misfit_observation_N_s    = NULL;
    65                                 int*         misfit_local_s = NULL;
    66                                 char**       misfit_timeinterpolation_s = NULL;
    67                                 IssmDouble** misfit_weights_s           = NULL;
    68                                 int*         misfit_weights_M_s    = NULL;
    69                                 int*         misfit_weights_N_s    = NULL;
    70                                 int*         misfit_weights_enum_s= NULL;
    71 
    72                                 /*Fetch name, model_enum, observation, observation_enum, etc ... (see src/m/classes/misfit.m): */
     69                                char**       misfit_name_s                                              = NULL;   
     70                                char**           misfit_definitionstring_s              = NULL;   
     71                                char**       misfit_model_string_s                      = NULL;
     72                                IssmDouble** misfit_observation_s                       = NULL;
     73                                char**           misfit_observation_string_s    = NULL;
     74                                int*         misfit_observation_M_s                     = NULL;
     75                                int*         misfit_observation_N_s                     = NULL;
     76                                int*         misfit_local_s                                     = NULL;
     77                                char**       misfit_timeinterpolation_s = NULL;
     78                                IssmDouble** misfit_weights_s                                   = NULL;
     79                                int*         misfit_weights_M_s                         = NULL;
     80                                int*         misfit_weights_N_s                         = NULL;
     81                                char**       misfit_weights_string_s            = NULL;
     82
     83                                /*Fetch name, model_string, observation, observation_string, etc ... (see src/m/classes/misfit.m): */
    7384                                iomodel->FetchMultipleData(&misfit_name_s,&nummisfits,                                                        "md.misfit.name");
    74                                 iomodel->FetchMultipleData(&misfit_definitionenums_s,&nummisfits,                                             "md.misfit.definitionenum");
    75                                 iomodel->FetchMultipleData(&misfit_model_enum_s,&nummisfits,                                                  "md.misfit.model_enum");
     85                                iomodel->FetchMultipleData(&misfit_definitionstring_s,&nummisfits,                                            "md.misfit.definitionstring");
     86                                iomodel->FetchMultipleData(&misfit_model_string_s,&nummisfits,                                                "md.misfit.model_string");
    7687                                iomodel->FetchMultipleData(&misfit_observation_s,&misfit_observation_M_s,&misfit_observation_N_s,&nummisfits, "md.misfit.observation");
    77                                 iomodel->FetchMultipleData(&misfit_observation_enum_s,&nummisfits,                                            "md.misfit.observation_enum");
     88                                iomodel->FetchMultipleData(&misfit_observation_string_s,&nummisfits,                                          "md.misfit.observation_string");
    7889                                iomodel->FetchMultipleData(&misfit_timeinterpolation_s,&nummisfits,                                           "md.misfit.timeinterpolation");
    7990                                iomodel->FetchMultipleData(&misfit_local_s,&nummisfits,                                                       "md.misfit.local");
    8091                                iomodel->FetchMultipleData(&misfit_weights_s,&misfit_weights_M_s,&misfit_weights_N_s,&nummisfits,             "md.misfit.weights");
    81                                 iomodel->FetchMultipleData(&misfit_weights_enum_s,&nummisfits,                                                "md.misfit.weights_enum");
     92                                iomodel->FetchMultipleData(&misfit_weights_string_s,&nummisfits,                                              "md.misfit.weights_string");
    8293
    8394                                for(j=0;j<nummisfits;j++){
    8495
    85                                         /*First create a misfit object for that specific enum (misfit_model_enum_s[j]):*/
    86                                         output_definitions->AddObject(new Misfit(misfit_name_s[j],misfit_definitionenums_s[j],misfit_model_enum_s[j],misfit_observation_enum_s[j],misfit_timeinterpolation_s[j],(bool)misfit_local_s[j],misfit_weights_enum_s[j]));
     96                                        /*First create a misfit object for that specific string (misfit_model_string_s[j]):*/
     97                                        output_definitions->AddObject(new Misfit(misfit_name_s[j],StringToEnumx(misfit_definitionstring_s[j]),StringToEnumx(misfit_model_string_s[j]),StringToEnumx(misfit_observation_string_s[j]),misfit_timeinterpolation_s[j],(bool)misfit_local_s[j],StringToEnumx(misfit_weights_string_s[j])));
    8798
    8899                                        /*Now, for this particular misfit object, make sure we plug into the elements: the observation, and the weights.*/
    89100                                        for(int k=0;k<elements->Size();k++){
    90101                                                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(k));
    91                                                 element->InputCreate(misfit_observation_s[j], iomodel,misfit_observation_M_s[j],misfit_observation_N_s[j],1,misfit_observation_enum_s[j],7);
    92                                                 element->InputCreate(misfit_weights_s[j], iomodel,misfit_weights_M_s[j],misfit_weights_N_s[j],1,misfit_weights_enum_s[j],7);
     102                                                element->InputCreate(misfit_observation_s[j], iomodel,misfit_observation_M_s[j],misfit_observation_N_s[j],1,StringToEnumx(misfit_observation_string_s[j]),7);
     103                                                element->InputCreate(misfit_weights_s[j], iomodel,misfit_weights_M_s[j],misfit_weights_N_s[j],1,StringToEnumx(misfit_weights_string_s[j]),7);
    93104                                        }
    94105
    … …  
    100111                                        IssmDouble* matrix = NULL;
    101112
     113                                        string = misfit_definitionstring_s[j];          xDelete<char>(string);
     114                                        string = misfit_observation_string_s[j];        xDelete<char>(string);
     115                                        string = misfit_model_string_s[j];                      xDelete<char>(string);
     116                                        string = misfit_weights_string_s[j];            xDelete<char>(string);
    102117                                        string = misfit_name_s[j];    xDelete<char>(string);
    103118                                        string = misfit_timeinterpolation_s[j];    xDelete<char>(string);
    … …  
    106121                                }
    107122                                xDelete<char*>(misfit_name_s);
    108                                 xDelete<int>(misfit_model_enum_s);
    109                                 xDelete<int>(misfit_definitionenums_s);
     123                                xDelete<char*>(misfit_model_string_s);
     124                                xDelete<char*>(misfit_definitionstring_s);
    110125                                xDelete<IssmDouble*>(misfit_observation_s);
    111                                 xDelete<int>(misfit_observation_enum_s);
     126                                xDelete<char*>(misfit_observation_string_s);
    112127                                xDelete<int>(misfit_observation_M_s);
    113128                                xDelete<int>(misfit_observation_N_s);
    … …  
    117132                                xDelete<int>(misfit_weights_M_s);
    118133                                xDelete<int>(misfit_weights_N_s);
    119                                 xDelete<int>(misfit_weights_enum_s);
     134                                xDelete<char*>(misfit_weights_string_s);
    120135                                /*}}}*/
    121136                        }
    … …  
    156171                        else if (output_definition_enums[i]==MassconEnum){
    157172                                /*Deal with masscons: {{{*/
    158                                
     173
    159174                                /*masscon variables: */
    160175                                int          nummasscons;
    161                                 char**       masscon_name_s             = NULL;   
    162                                 int*         masscon_definitionenum_s   = NULL;   
     176                                char**       masscon_name_s                                     = NULL;   
     177                                int*         masscon_definitionenum_s           = NULL;   
    163178                                IssmDouble** masscon_levelset_s           = NULL;
    164                                 int*         masscon_levelset_M_s    = NULL;
    165                                 int*         masscon_levelset_N_s    = NULL;
     179                                int*         masscon_levelset_M_s                       = NULL;
     180                                int*         masscon_levelset_N_s                       = NULL;
    166181
    167182                                /*Fetch name and levelset, etc ... (see src/m/classes/masscon.m): */
    … …  
    232247                                /*}}}*/
    233248                        }
    234                         else _error_("output definition enum " << output_definition_enums[i] << "not supported yet!");
     249                        else _error_("output definition enum " << output_definition_enums[i] << " not supported yet!");
    235250                }
    236251        }

  • issm/trunk-jpl/src/c/modules/OutputDefinitionsResponsex/OutputDefinitionsResponsex.cpp

    r18877 r21049  
    1515        /*Now, go through the output definitions, and retrieve the object which corresponds to our requested response, output_string: */
    1616        for(int i=0;i<output_definitions->Size();i++){
    17                
    18                 //Definition* definition=xDynamicCast<Definition*>(output_definitions->GetObjectByOffset(i));
    1917                Definition* definition=dynamic_cast<Definition*>(output_definitions->GetObjectByOffset(i));
    2018

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

    r20993 r21049  
    119119
    120120}/*}}}*/
     121
     122int IoRiftfillToEnum(int enum_in){/*{{{*/
     123        switch(enum_in){
     124                case 0: return AirEnum;
     125                case 1: return IceEnum;
     126                case 2: return MelangeEnum;
     127                case 3: return WaterEnum;
     128                default: _error_("Marshalled Riftfill enum \""<<enum_in<<"\" not supported yet.");
     129        }
     130}/*}}}*/

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

    r20993 r21049  
    1212int IoCodeToEnumVertexEquation(int enum_in);
    1313int IoCodeToEnumElementEquation(int enum_in);
     14
     15int IoRiftfillToEnum(int enum_in);
     16
    1417#endif 

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

    r20902 r21049  
    4949                function md = checkconsistency(self,md,solution,analyses) % {{{
    5050
    51                         if ismember(MasstransportAnalysisEnum(),analyses),
     51                        if ismember('MasstransportAnalysis',analyses),
    5252                                md = checkfield(md,'fieldname','smb.accumulation','timeseries',1,'NaN',1,'Inf',1);
    5353                        end
    54                         if ismember(BalancethicknessAnalysisEnum(),analyses),
     54                        if ismember('BalancethicknessAnalysis',analyses),
    5555                                md = checkfield(md,'fieldname','smb.accumulation','size',[md.mesh.numberofvertices 1],'NaN',1,'Inf',1);
    5656                        end
    57                         if ismember(MasstransportAnalysisEnum(),analyses),
     57                        if ismember('MasstransportAnalysis',analyses),
    5858                                md = checkfield(md,'fieldname','smb.runoff','timeseries',1,'NaN',1,'Inf',1);
    5959                        end
    60                         if ismember(BalancethicknessAnalysisEnum(),analyses),
     60                        if ismember('BalancethicknessAnalysis',analyses),
    6161                                md = checkfield(md,'fieldname','smb.runoff','size',[md.mesh.numberofvertices 1],'NaN',1,'Inf',1);
    6262                        end
    63                         if ismember(MasstransportAnalysisEnum(),analyses),
     63                        if ismember('MasstransportAnalysis',analyses),
    6464                                md = checkfield(md,'fieldname','smb.evaporation','timeseries',1,'NaN',1,'Inf',1);
    6565                        end
    66                         if ismember(BalancethicknessAnalysisEnum(),analyses),
     66                        if ismember('BalancethicknessAnalysis',analyses),
    6767                                md = checkfield(md,'fieldname','smb.evaporation','size',[md.mesh.numberofvertices 1],'NaN',1,'Inf',1);
    6868                        end

  • issm/trunk-jpl/src/m/classes/SMBcomponents.py

    r20902 r21049  
    11from fielddisplay import fielddisplay
    2 from EnumDefinitions import *
    32from checkfield import *
    43from project3d import *
    … …  
    5554        def checkconsistency(self,md,solution,analyses):    # {{{
    5655
    57                 if MasstransportAnalysisEnum() in analyses:
     56                if 'MasstransportAnalysis' in analyses:
    5857                        md = checkfield(md,'fieldname','smb.accumulation','timeseries',1,'NaN',1,'Inf',1)
    5958
    60                 if BalancethicknessAnalysisEnum() in analyses:
     59                if 'BalancethicknessAnalysis' in analyses:
    6160                        md = checkfield(md,'fieldname','smb.accumulation','size',[md.mesh.numberofvertices],'NaN',1,'Inf',1)
    6261
    63                 if MasstransportAnalysisEnum() in analyses:
     62                if 'MasstransportAnalysis' in analyses:
    6463                        md = checkfield(md,'fieldname','smb.runoff','timeseries',1,'NaN',1,'Inf',1)
    6564
    66                 if BalancethicknessAnalysisEnum() in analyses:
     65                if 'BalancethicknessAnalysis' in analyses:
    6766                        md = checkfield(md,'fieldname','smb.runoff','size',[md.mesh.numberofvertices],'NaN',1,'Inf',1)
    6867
    69                 if MasstransportAnalysisEnum() in analyses:
     68                if 'MasstransportAnalysis' in analyses:
    7069                        md = checkfield(md,'fieldname','smb.evaporation','timeseries',1,'NaN',1,'Inf',1)
    7170
    72                 if BalancethicknessAnalysisEnum() in analyses:
     71                if 'BalancethicknessAnalysis' in analyses:
    7372                        md = checkfield(md,'fieldname','smb.evaporation','size',[md.mesh.numberofvertices],'NaN',1,'Inf',1)
    7473               

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

    r20902 r21049  
    6767                function md = checkconsistency(self,md,solution,analyses) % {{{
    6868
    69                         if ismember(MasstransportAnalysisEnum(),analyses),
     69                        if ismember('MasstransportAnalysis',analyses),
    7070                                md = checkfield(md,'fieldname','smb.desfac','<=',1,'numel',1);
    7171                                md = checkfield(md,'fieldname','smb.s0p','>=',0,'NaN',1,'Inf',1,'size',[md.mesh.numberofvertices 1]);

  • issm/trunk-jpl/src/m/classes/SMBd18opdd.py

    r20902 r21049  
    11import numpy
    22from fielddisplay import fielddisplay
    3 from EnumDefinitions import *
    43from checkfield import checkfield
    54from WriteData import WriteData
    … …  
    8988        def checkconsistency(self,md,solution,analyses):    # {{{
    9089
    91                 if MasstransportAnalysisEnum() in analyses:
     90                if 'MasstransportAnalysis' in analyses:
    9291                        md = checkfield(md,'fieldname','smb.desfac','<=',1,'numel',[1])
    9392                        md = checkfield(md,'fieldname','smb.s0p','>=',0,'NaN',1,'Inf',1,'size',[md.mesh.numberofvertices,1])

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

    r20902 r21049  
    4848                function md = checkconsistency(self,md,solution,analyses) % {{{
    4949
    50                         if (solution==TransientSolutionEnum & md.transient.issmb == 0), return; end
     50                        if (strcmp(solution,'TransientSolution') & md.transient.issmb == 0), return; end
    5151                       
    52                         if ismember(MasstransportAnalysisEnum(),analyses),
     52                        if ismember('MasstransportAnalysis',analyses),
    5353                                md = checkfield(md,'fieldname','smb.mass_balance','timeseries',1,'NaN',1,'Inf',1);
    5454                        end
    55                         if ismember(BalancethicknessAnalysisEnum(),analyses),
     55                        if ismember('BalancethicknessAnalysis',analyses),
    5656                                md = checkfield(md,'fieldname','smb.mass_balance','size',[md.mesh.numberofvertices 1],'NaN',1,'Inf',1);
    5757                        end

  • issm/trunk-jpl/src/m/classes/SMBforcing.py

    r20902 r21049  
    11import numpy
    22from fielddisplay import fielddisplay
    3 from EnumDefinitions import *
    43from checkfield import checkfield
    54from WriteData import WriteData
    … …  
    4241        def checkconsistency(self,md,solution,analyses):    # {{{
    4342
    44                 if MasstransportAnalysisEnum() in analyses:
     43                if 'MasstransportAnalysis' in analyses:
    4544                        md = checkfield(md,'fieldname','smb.mass_balance','timeseries',1,'NaN',1,'Inf',1)
    4645
    47                 if BalancethicknessAnalysisEnum() in analyses:
     46                if 'BalancethicknessAnalysis' in analyses:
    4847                        md = checkfield(md,'fieldname','smb.mass_balance','size',[md.mesh.numberofvertices],'NaN',1,'Inf',1)
    4948

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

    r20902 r21049  
    4141                function md = checkconsistency(self,md,solution,analyses) % {{{
    4242
    43                         if ismember(MasstransportAnalysisEnum(),analyses),
     43                        if ismember('MasstransportAnalysis',analyses),
    4444                                md = checkfield(md,'fieldname','smb.href','timeseries',1,'NaN',1,'Inf',1);
    4545                                md = checkfield(md,'fieldname','smb.smbref','timeseries',1,'NaN',1,'Inf',1);

  • issm/trunk-jpl/src/m/classes/SMBgradients.py

    r20902 r21049  
    11from fielddisplay import fielddisplay
    2 from EnumDefinitions import *
    32from checkfield import checkfield
    43from WriteData import WriteData
    … …  
    4847        def checkconsistency(self,md,solution,analyses):    # {{{
    4948
    50                 if MasstransportAnalysisEnum() in analyses:
     49                if 'MasstransportAnalysis' in analyses:
    5150                        md = checkfield(md,'fieldname','smb.href','timeseries',1,'NaN',1,'Inf',1)
    5251                        md = checkfield(md,'fieldname','smb.smbref','timeseries',1,'NaN',1,'Inf',1)

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

    r20902 r21049  
    3535                function md = checkconsistency(self,md,solution,analyses) % {{{
    3636
    37                         if ismember(MasstransportAnalysisEnum(),analyses),
     37                        if ismember('MasstransportAnalysis',analyses),
    3838                                md = checkfield(md,'fieldname','smb.smbref','timeseries',1,'NaN',1,'Inf',1);
    3939                        end
    40                         if ismember(BalancethicknessAnalysisEnum(),analyses),
     40                        if ismember('BalancethicknessAnalysis',analyses),
    4141                                md = checkfield(md,'fieldname','smb.smbref','size',[md.mesh.numberofvertices 1],'NaN',1,'Inf',1);
    4242                        end

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

    r20902 r21049  
    5353                function md = checkconsistency(self,md,solution,analyses) % {{{
    5454
    55                         if ismember(MasstransportAnalysisEnum(),analyses),
     55                        if ismember('MasstransportAnalysis',analyses),
    5656                                md = checkfield(md,'fieldname','smb.accumulation','timeseries',1,'NaN',1,'Inf',1);
    5757                        end
    58                         if ismember(BalancethicknessAnalysisEnum(),analyses),
     58                        if ismember('BalancethicknessAnalysis',analyses),
    5959                                md = checkfield(md,'fieldname','smb.accumulation','size',[md.mesh.numberofvertices 1],'NaN',1,'Inf',1);
    6060                        end
    61                         if ismember(MasstransportAnalysisEnum(),analyses),
     61                        if ismember('MasstransportAnalysis',analyses),
    6262                                md = checkfield(md,'fieldname','smb.evaporation','timeseries',1,'NaN',1,'Inf',1);
    6363                        end
    64                         if ismember(BalancethicknessAnalysisEnum(),analyses),
     64                        if ismember('BalancethicknessAnalysis',analyses),
    6565                                md = checkfield(md,'fieldname','smb.evaporation','size',[md.mesh.numberofvertices 1],'NaN',1,'Inf',1);
    6666                        end
    67                         if ismember(MasstransportAnalysisEnum(),analyses),
     67                        if ismember('MasstransportAnalysis',analyses),
    6868                                md = checkfield(md,'fieldname','smb.refreeze','timeseries',1,'NaN',1,'Inf',1);
    6969                        end
    70                         if ismember(BalancethicknessAnalysisEnum(),analyses),
     70                        if ismember('BalancethicknessAnalysis',analyses),
    7171                                md = checkfield(md,'fieldname','smb.refreeze','size',[md.mesh.numberofvertices 1],'NaN',1,'Inf',1);
    7272                        end
    73                         if ismember(MasstransportAnalysisEnum(),analyses),
     73                        if ismember('MasstransportAnalysis',analyses),
    7474                                md = checkfield(md,'fieldname','smb.melt','timeseries',1,'NaN',1,'Inf',1);
    7575                        end
    76                         if ismember(BalancethicknessAnalysisEnum(),analyses),
     76                        if ismember('BalancethicknessAnalysis',analyses),
    7777                                md = checkfield(md,'fieldname','smb.melt','size',[md.mesh.numberofvertices 1],'NaN',1,'Inf',1);
    7878                        end

  • issm/trunk-jpl/src/m/classes/SMBmeltcomponents.py

    r20902 r21049  
    11from fielddisplay import fielddisplay
    2 from EnumDefinitions import *
    32from checkfield import *
    43from project3d import *
    … …  
    6160        def checkconsistency(self,md,solution,analyses):    # {{{
    6261
    63                 if MasstransportAnalysisEnum() in analyses:
     62                if 'MasstransportAnalysis' in analyses:
    6463                        md = checkfield(md,'fieldname','smb.accumulation','timeseries',1,'NaN',1,'Inf',1)
    6564
    66                 if BalancethicknessAnalysisEnum() in analyses:
     65                if 'BalancethicknessAnalysis' in analyses:
    6766                        md = checkfield(md,'fieldname','smb.accumulation','size',[md.mesh.numberofvertices],'NaN',1,'Inf',1)
    6867
    69                 if MasstransportAnalysisEnum() in analyses:
     68                if 'MasstransportAnalysis' in analyses:
    7069                        md = checkfield(md,'fieldname','smb.melt','timeseries',1,'NaN',1,'Inf',1)
    7170
    72                 if BalancethicknessAnalysisEnum() in analyses:
     71                if 'BalancethicknessAnalysis' in analyses:
    7372                        md = checkfield(md,'fieldname','smb.melt','size',[md.mesh.numberofvertices],'NaN',1,'Inf',1)
    7473
    75                 if MasstransportAnalysisEnum() in analyses:
     74                if 'MasstransportAnalysis' in analyses:
    7675                        md = checkfield(md,'fieldname','smb.refreeze','timeseries',1,'NaN',1,'Inf',1)
    7776
    78                 if BalancethicknessAnalysisEnum() in analyses:
     77                if 'BalancethicknessAnalysis' in analyses:
    7978                        md = checkfield(md,'fieldname','smb.refreeze','size',[md.mesh.numberofvertices],'NaN',1,'Inf',1)
    8079
    81                 if MasstransportAnalysisEnum() in analyses:
     80                if 'MasstransportAnalysis' in analyses:
    8281                        md = checkfield(md,'fieldname','smb.evaporation','timeseries',1,'NaN',1,'Inf',1)
    8382
    84                 if BalancethicknessAnalysisEnum() in analyses:
     83                if 'BalancethicknessAnalysis' in analyses:
    8584                        md = checkfield(md,'fieldname','smb.evaporation','size',[md.mesh.numberofvertices],'NaN',1,'Inf',1)
    8685

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

    r20902 r21049  
    7676                function md = checkconsistency(self,md,solution,analyses) % {{{
    7777
    78                         if ismember(MasstransportAnalysisEnum(),analyses),
     78                        if ismember('MasstransportAnalysis',analyses),
    7979                                md = checkfield(md,'fieldname','smb.desfac','<=',1,'numel',1);
    8080                                md = checkfield(md,'fieldname','smb.s0p','>=',0,'NaN',1,'Inf',1,'size',[md.mesh.numberofvertices 1]);

  • issm/trunk-jpl/src/m/classes/SMBpdd.py

    r20902 r21049  
    11import numpy
    22from fielddisplay import fielddisplay
    3 from EnumDefinitions import *
    43from checkfield import checkfield
    54from WriteData import WriteData
    … …  
    118117        def checkconsistency(self,md,solution,analyses):    # {{{
    119118
    120                 if MasstransportAnalysisEnum() in analyses:
     119                if 'MasstransportAnalysis' in analyses:
    121120                        md = checkfield(md,'fieldname','smb.desfac','<=',1,'numel',[1])
    122121                        md = checkfield(md,'fieldname','smb.s0p','>=',0,'NaN',1,'Inf',1,'size',[md.mesh.numberofvertices,1])

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

    r20896 r21049  
    8383                        md = checkfield(md,'fieldname','inversion.max_parameters','size',[md.mesh.numberofvertices num_controls]);
    8484
    85                         if solution==BalancethicknessSolutionEnum()
     85                        if strcmp(solution,'BalancethicknessSolution')
    8686                                md = checkfield(md,'fieldname','inversion.thickness_obs','size',[md.mesh.numberofvertices 1],'NaN',1,'Inf',1);
    8787                                md = checkfield(md,'fieldname','inversion.surface_obs','size',[md.mesh.numberofvertices 1],'NaN',1,'Inf',1);
    88                         elseif solution==BalancethicknessSoftSolutionEnum()
     88                        elseif strcmp(solution,'BalancethicknessSoftSolution')
    8989                                md = checkfield(md,'fieldname','inversion.thickness_obs','size',[md.mesh.numberofvertices 1],'NaN',1,'Inf',1);
    9090                        else
    … …  
    159159                        num_cost_functions=size(self.cost_functions,2);
    160160                        data=self.cost_functions;
    161                         pos=find(self.cost_functions==101); data(pos)=SurfaceAbsVelMisfitEnum();
    162                         pos=find(self.cost_functions==102); data(pos)=SurfaceRelVelMisfitEnum();
    163                         pos=find(self.cost_functions==103); data(pos)=SurfaceLogVelMisfitEnum();
    164                         pos=find(self.cost_functions==104); data(pos)=SurfaceLogVxVyMisfitEnum();
    165                         pos=find(self.cost_functions==105); data(pos)=SurfaceAverageVelMisfitEnum();
    166                         pos=find(self.cost_functions==201); data(pos)=ThicknessAbsMisfitEnum();
    167                         pos=find(self.cost_functions==501); data(pos)=DragCoefficientAbsGradientEnum();
    168                         pos=find(self.cost_functions==502); data(pos)=RheologyBbarAbsGradientEnum();
    169                         pos=find(self.cost_functions==503); data(pos)=ThicknessAbsGradientEnum();
    170                         pos=find(self.cost_functions==504); data(pos)=ThicknessAlongGradientEnum();
    171                         pos=find(self.cost_functions==505); data(pos)=ThicknessAcrossGradientEnum();
    172                         pos=find(self.cost_functions==506); data(pos)=BalancethicknessMisfitEnum();
    173                         pos=find(self.cost_functions==601); data(pos)=SurfaceAbsMisfitEnum();
    174                         pos=find(self.cost_functions==1001); data(pos)=Outputdefinition1Enum();
    175                         pos=find(self.cost_functions==1002); data(pos)=Outputdefinition2Enum();
    176                         pos=find(self.cost_functions==1003); data(pos)=Outputdefinition3Enum();
    177                         pos=find(self.cost_functions==1004); data(pos)=Outputdefinition4Enum();
    178                         pos=find(self.cost_functions==1005); data(pos)=Outputdefinition5Enum();
    179                         pos=find(self.cost_functions==1006); data(pos)=Outputdefinition6Enum();
    180                         pos=find(self.cost_functions==1007); data(pos)=Outputdefinition7Enum();
    181                         pos=find(self.cost_functions==1008); data(pos)=Outputdefinition8Enum();
    182                         pos=find(self.cost_functions==1009); data(pos)=Outputdefinition8Enum();
    183                         pos=find(self.cost_functions==1010); data(pos)=Outputdefinition10Enum();
    184                         WriteData(fid,prefix,'data',data,'name','md.inversion.cost_functions','format','DoubleMat','mattype',3);
     161                        pos=find(self.cost_functions==101); data(pos)={'SurfaceAbsVelMisfit'};
     162                        pos=find(self.cost_functions==102); data(pos)={'SurfaceRelVelMisfit'};
     163                        pos=find(self.cost_functions==103); data(pos)={'SurfaceLogVelMisfit'};
     164                        pos=find(self.cost_functions==104); data(pos)={'SurfaceLogVxVyMisfit'};
     165                        pos=find(self.cost_functions==105); data(pos)={'SurfaceAverageVelMisfit'};
     166                        pos=find(self.cost_functions==201); data(pos)={'ThicknessAbsMisfit'};
     167                        pos=find(self.cost_functions==501); data(pos)={'DragCoefficientAbsGradient'};
     168                        pos=find(self.cost_functions==502); data(pos)={'RheologyBbarAbsGradient'};
     169                        pos=find(self.cost_functions==503); data(pos)={'ThicknessAbsGradient'};
     170                        pos=find(self.cost_functions==504); data(pos)={'ThicknessAlongGradient'};
     171                        pos=find(self.cost_functions==505); data(pos)={'ThicknessAcrossGradient'};
     172                        pos=find(self.cost_functions==506); data(pos)={'BalancethicknessMisfit'};
     173                        pos=find(self.cost_functions==601); data(pos)={'SurfaceAbsMisfit'};
     174                        pos=find(self.cost_functions==1001); data(pos)={'Outputdefinition1'};
     175                        pos=find(self.cost_functions==1002); data(pos)={'Outputdefinition2'};
     176                        pos=find(self.cost_functions==1003); data(pos)={'Outputdefinition3'};
     177                        pos=find(self.cost_functions==1004); data(pos)={'Outputdefinition4'};
     178                        pos=find(self.cost_functions==1005); data(pos)={'Outputdefinition5'};
     179                        pos=find(self.cost_functions==1006); data(pos)={'Outputdefinition6'};
     180                        pos=find(self.cost_functions==1007); data(pos)={'Outputdefinition7'};
     181                        pos=find(self.cost_functions==1008); data(pos)={'Outputdefinition8'};
     182                        pos=find(self.cost_functions==1009); data(pos)={'Outputdefinition8'};
     183                        pos=find(self.cost_functions==1010); data(pos)={'Outputdefinition10'};
     184                        WriteData(fid,prefix,'data',data,'name','md.inversion.cost_functions','format','StringArray');
    185185                        WriteData(fid,prefix,'data',num_cost_functions,'name','md.inversion.num_cost_functions','format','Integer');
    186186                end % }}}

  • issm/trunk-jpl/src/m/classes/adinversion.py

    r20910 r21049  
    1212
    1313from MatlabFuncs import *
    14 
    15 from EnumDefinitions import *
    1614from numpy import *
    1715
    … …  
    9694
    9795
    98                 if solution==BalancethicknessSolutionEnum():
     96                if solution=='BalancethicknessSolution':
    9997                        md = checkfield(md,'fieldname','inversion.thickness_obs','size',[md.mesh.numberofvertices, 1],float('Nan'),1)
    10098                        md = checkfield(md,'fieldname','inversion.surface_obs','size',[md.mesh.numberofvertices, 1], float('Nan'),1)
    101                 elif solution==BalancethicknessSoftSolutionEnum():
     99                elif solution=='BalancethicknessSoftSolution':
    102100                        md = checkfield(md,'fieldname','inversion.thickness_obs','size',[md.mesh.numberofvertices, 1],float('Nan'),1)
    103101                else:
    … …  
    173171                num_cost_functions=numpy.size(self.cost_functions,2);
    174172                data=copy.deepcopy(self.cost_functions)
    175                 data[numpy.nonzero(self.cost_functions==101)] =SurfaceAbsVelMisfitEnum();
    176                 data[numpy.nonzero(self.cost_functions==102)]=SurfaceRelVelMisfitEnum();
    177                 data[numpy.nonzero(self.cost_functions==103)]=SurfaceLogVelMisfitEnum();
    178                 data[numpy.nonzero(self.cost_functions==104)]=SurfaceLogVxVyMisfitEnum();
    179                 data[numpy.nonzero(self.cost_functions==105)]=SurfaceAverageVelMisfitEnum();
    180                 data[numpy.nonzero(self.cost_functions==201)]=ThicknessAbsMisfitEnum();
    181                 data[numpy.nonzero(self.cost_functions==501)]=DragCoefficientAbsGradientEnum();
    182                 data[numpy.nonzero(self.cost_functions==502)]=RheologyBbarAbsGradientEnum();
    183                 data[numpy.nonzero(self.cost_functions==503)]=ThicknessAbsGradientEnum();
    184                 data[numpy.nonzero(self.cost_functions==504)]=ThicknessAlongGradientEnum();
    185                 data[numpy.nonzero(self.cost_functions==505)]=ThicknessAcrossGradientEnum();
    186                 data[numpy.nonzero(self.cost_functions==506)]=BalancethicknessMisfitEnum();
    187                 data[numpy.nonzero(self.cost_functions==601)]=SurfaceAbsMisfitEnum();
    188                 data[numpy.nonzero(self.cost_functions==1001)]=Outputdefinition1Enum();
    189                 data[numpy.nonzero(self.cost_functions==1002)]=Outputdefinition2Enum();
    190                 data[numpy.nonzero(self.cost_functions==1003)]=Outputdefinition3Enum();
    191                 data[numpy.nonzero(self.cost_functions==1004)]=Outputdefinition4Enum();
    192                 data[numpy.nonzero(self.cost_functions==1005)]=Outputdefinition5Enum();
    193                 data[numpy.nonzero(self.cost_functions==1006)]=Outputdefinition6Enum();
    194                 data[numpy.nonzero(self.cost_functions==1007)]=Outputdefinition7Enum();
    195                 data[numpy.nonzero(self.cost_functions==1008)]=Outputdefinition8Enum();
    196                 data[numpy.nonzero(self.cost_functions==1009)]=Outputdefinition8Enum();
    197                 data[numpy.nonzero(self.cost_functions==1010)]=Outputdefinition10Enum();
    198                 WriteData(fid,prefix,'data',data,'name','md.inversion.cost_functions','format','DoubleMat','mattype',3);
     173                data[numpy.nonzero(self.cost_functions==101)] =['SurfaceAbsVelMisfit'];
     174                data[numpy.nonzero(self.cost_functions==102)]=['SurfaceRelVelMisfit'];
     175                data[numpy.nonzero(self.cost_functions==103)]=['SurfaceLogVelMisfit'];
     176                data[numpy.nonzero(self.cost_functions==104)]=['SurfaceLogVxVyMisfit'];
     177                data[numpy.nonzero(self.cost_functions==105)]=['SurfaceAverageVelMisfit'];
     178                data[numpy.nonzero(self.cost_functions==201)]=['ThicknessAbsMisfit'];
     179                data[numpy.nonzero(self.cost_functions==501)]=['DragCoefficientAbsGradient'];
     180                data[numpy.nonzero(self.cost_functions==502)]=['RheologyBbarAbsGradient'];
     181                data[numpy.nonzero(self.cost_functions==503)]=['ThicknessAbsGradient'];
     182                data[numpy.nonzero(self.cost_functions==504)]=['ThicknessAlongGradient'];
     183                data[numpy.nonzero(self.cost_functions==505)]=['ThicknessAcrossGradient'];
     184                data[numpy.nonzero(self.cost_functions==506)]=['BalancethicknessMisfit'];
     185                data[numpy.nonzero(self.cost_functions==601)]=['SurfaceAbsMisfit'];
     186                data[numpy.nonzero(self.cost_functions==1001)]=['Outputdefinition1'];
     187                data[numpy.nonzero(self.cost_functions==1002)]=['Outputdefinition2'];
     188                data[numpy.nonzero(self.cost_functions==1003)]=['Outputdefinition3'];
     189                data[numpy.nonzero(self.cost_functions==1004)]=['Outputdefinition4'];
     190                data[numpy.nonzero(self.cost_functions==1005)]=['Outputdefinition5'];
     191                data[numpy.nonzero(self.cost_functions==1006)]=['Outputdefinition6'];
     192                data[numpy.nonzero(self.cost_functions==1007)]=['Outputdefinition7'];
     193                data[numpy.nonzero(self.cost_functions==1008)]=['Outputdefinition8'];
     194                data[numpy.nonzero(self.cost_functions==1009)]=['Outputdefinition8'];
     195                data[numpy.nonzero(self.cost_functions==1010)]=['Outputdefinition10'];
     196                WriteData(fid,prefix,'data',data,'name','md.inversion.cost_functions','format','StringArray');
    199197                WriteData(fid,prefix,'data',num_cost_functions,'name','md.inversion.num_cost_functions','format','Integer');
    200198               

  • issm/trunk-jpl/src/m/classes/autodiff.py

    r20973 r21049  
    33from independent import independent
    44from fielddisplay import fielddisplay
    5 from EnumDefinitions import *
    65from checkfield import checkfield
    76from WriteData import WriteData

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

    r20896 r21049  
    2929                function md = checkconsistency(self,md,solution,analyses) % {{{
    3030                        %Early return
    31                         if solution~=BalancethicknessSolutionEnum(), return; end
     31                        if ~strcmp(solution,'BalancethicknessSolution'), return; end
    3232
    3333                        md = checkfield(md,'fieldname','balancethickness.spcthickness');

  • issm/trunk-jpl/src/m/classes/balancethickness.py

    r20896 r21049  
    11from fielddisplay import fielddisplay
    2 from EnumDefinitions import *
    32from checkfield import checkfield
    43from WriteData import WriteData
    … …  
    3938        def checkconsistency(self,md,solution,analyses):    # {{{
    4039                #Early return
    41                 if not solution==BalancethicknessSolutionEnum():
     40                if not solution=='BalancethicknessSolution':
    4241                        return md
    4342

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

    r20916 r21049  
    4242                function md = checkconsistency(self,md,solution,analyses) % {{{
    4343
    44                         if ismember(MasstransportAnalysisEnum(),analyses) & ~(solution==TransientSolutionEnum() & md.transient.ismasstransport==0),
     44                        if ismember('MasstransportAnalysis',analyses) & ~(strcmp(solution,'TransientSolution') & md.transient.ismasstransport==0),
    4545                                md = checkfield(md,'fieldname','basalforcings.groundedice_melting_rate','NaN',1,'Inf',1,'timeseries',1);
    4646                                md = checkfield(md,'fieldname','basalforcings.floatingice_melting_rate','NaN',1,'Inf',1,'timeseries',1);
    4747                        end
    48                         if ismember(BalancethicknessAnalysisEnum(),analyses),
     48                        if ismember('BalancethicknessAnalysis',analyses),
    4949                                md = checkfield(md,'fieldname','basalforcings.groundedice_melting_rate','NaN',1,'Inf',1,'size',[md.mesh.numberofvertices 1]);
    5050                                md = checkfield(md,'fieldname','basalforcings.floatingice_melting_rate','NaN',1,'Inf',1,'size',[md.mesh.numberofvertices 1]);
    5151                        end
    52                         if ismember(ThermalAnalysisEnum(),analyses) & ~(solution==TransientSolutionEnum() & md.transient.isthermal==0),
     52                        if ismember('ThermalAnalysis',analyses) & ~(strcmp(solution,'TransientSolution') & md.transient.isthermal==0),
    5353                                md = checkfield(md,'fieldname','basalforcings.groundedice_melting_rate','NaN',1,'Inf',1,'timeseries',1);
    5454                                md = checkfield(md,'fieldname','basalforcings.floatingice_melting_rate','NaN',1,'Inf',1,'timeseries',1);

  • issm/trunk-jpl/src/m/classes/basalforcings.py

    r20916 r21049  
    11from fielddisplay import fielddisplay
    22from project3d import project3d
    3 from EnumDefinitions import *
    43from checkfield import checkfield
    54from WriteData import WriteData
    … …  
    5453        def checkconsistency(self,md,solution,analyses):    # {{{
    5554
    56                 if MasstransportAnalysisEnum() in analyses and not (solution==TransientSolutionEnum() and not md.transient.ismasstransport):
     55                if 'MasstransportAnalysis' in analyses and not (solution=='TransientSolution' and not md.transient.ismasstransport):
    5756                        md = checkfield(md,'fieldname','basalforcings.groundedice_melting_rate','NaN',1,'Inf',1,'timeseries',1)
    5857                        md = checkfield(md,'fieldname','basalforcings.floatingice_melting_rate','NaN',1,'Inf',1,'timeseries',1)
    5958
    60                 if BalancethicknessAnalysisEnum() in analyses:
     59                if 'BalancethicknessAnalysis' in analyses:
    6160                        md = checkfield(md,'fieldname','basalforcings.groundedice_melting_rate','NaN',1,'Inf',1,'size',[md.mesh.numberofvertices])
    6261                        md = checkfield(md,'fieldname','basalforcings.floatingice_melting_rate','NaN',1,'Inf',1,'size',[md.mesh.numberofvertices])
    6362
    64                 if ThermalAnalysisEnum() in analyses and not (solution==TransientSolutionEnum() and not md.transient.isthermal):
     63                if 'ThermalAnalysis' in analyses and not (solution=='TransientSolution' and not md.transient.isthermal):
    6564                        md = checkfield(md,'fieldname','basalforcings.groundedice_melting_rate','NaN',1,'Inf',1,'timeseries',1)
    6665                        md = checkfield(md,'fieldname','basalforcings.floatingice_melting_rate','NaN',1,'Inf',1,'timeseries',1)

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

    r20916 r21049  
    3737                function md = checkconsistency(self,md,solution,analyses) % {{{
    3838                        %Early return
    39                         if (solution~=TransientSolutionEnum() | md.transient.ismovingfront==0), return; end
     39                        if (~strcmp(solution,'TransientSolution') | md.transient.ismovingfront==0), return; end
    4040
    4141                        md = checkfield(md,'fieldname','calving.calvingrate','>=',0,'timeseries',1,'NaN',1,'Inf',1);

  • issm/trunk-jpl/src/m/classes/calving.py

    r20916 r21049  
    11from fielddisplay import fielddisplay
    22from project3d import project3d
    3 from EnumDefinitions import *
    4 from StringToEnum import StringToEnum
    53from checkfield import checkfield
    64from WriteData import WriteData
    … …  
    4240
    4341                #Early return
    44                 if (solution!=TransientSolutionEnum()) or (not md.transient.ismovingfront):
     42                if (solution!='TransientSolution') or (not md.transient.ismovingfront):
    4543                        return md
    4644

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

    r20916 r21049  
    3939                function md = checkconsistency(self,md,solution,analyses) % {{{
    4040                        %Early return
    41                         if (solution~=TransientSolutionEnum() | md.transient.ismovingfront==0), return; end
     41                        if (~strcmp(solution,'TransientSolution') | md.transient.ismovingfront==0), return; end
    4242
    4343                        md = checkfield(md,'fieldname','calving.coeff','>',0,'size',[md.mesh.numberofvertices 1]);

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

    r20916 r21049  
    3939                function md = checkconsistency(self,md,solution,analyses) % {{{
    4040                        %Early return
    41                         if (solution~=TransientSolutionEnum() | md.transient.ismovingfront==0), return; end
     41                        if (~strcmp(solution,'TransientSolution') | md.transient.ismovingfront==0), return; end
    4242
    4343                        md = checkfield(md,'fieldname','calving.coeff','>',0,'size',[md.mesh.numberofvertices 1]);

  • issm/trunk-jpl/src/m/classes/calvinglevermann.py

    r20916 r21049  
    11from fielddisplay import fielddisplay
    2 from EnumDefinitions import *
    3 from StringToEnum import StringToEnum
    42from checkfield import checkfield
    53from WriteData import WriteData
    … …  
    4240
    4341                #Early return
    44                 if (solution!=TransientSolutionEnum()) or (not md.transient.ismovingfront):
     42                if (solution!='TransientSolution') or (not md.transient.ismovingfront):
    4543                        return md
    4644

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

    r20916 r21049  
    3838                function md = checkconsistency(self,md,solution,analyses) % {{{
    3939                        %Early return
    40                         if (solution~=TransientSolutionEnum() | md.transient.ismovingfront==0), return; end
     40                        if (~strcmp(solution,'TransientSolution') | md.transient.ismovingfront==0), return; end
    4141
    4242                        md = checkfield(md,'fieldname','calving.min_thickness','>',0,'NaN',1,'Inf',1);

  • issm/trunk-jpl/src/m/classes/constants.py

    r20896 r21049  
    11from fielddisplay import fielddisplay
    2 from EnumDefinitions import *
    32from checkfield import checkfield
    43from WriteData import WriteData

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

    r20969 r21049  
    105105                                md = checkfield(md,'fieldname','damage.requested_outputs','stringrow',1);
    106106                        elseif (self.law~=0),
    107                                 if (solution==DamageEvolutionSolutionEnum),
     107                                if (strcmp(solution,'DamageEvolutionSolution')),
    108108                                        error('Invalid evolution law (md.damage.law) for a damage solution');
    109109                                end

  • issm/trunk-jpl/src/m/classes/damage.py

    r20969 r21049  
    11from fielddisplay import fielddisplay
    22from project3d import project3d
    3 from EnumDefinitions import *
    4 from StringToEnum import StringToEnum
    53from checkfield import checkfield
    64from WriteData import WriteData
    … …  
    140138                        md = checkfield(md,'fieldname','damage.requested_outputs','stringrow',1)
    141139                elif self.law != 0:
    142                         if (solution==DamageEvolutionSolutionEnum):
     140                        if (solution=='DamageEvolutionSolution'):
    143141                                raise RuntimeError('Invalid evolution law (md.damage.law) for a damage solution')
    144142

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

    r19040 r21049  
    6464                        disp(sprintf('   dependent variable:'));
    6565
    66                         fielddisplay(self,'name','variable name (must match corresponding Enum)');
     66                        fielddisplay(self,'name','variable name (must match corresponding String)');
    6767                        fielddisplay(self,'type','type of variable (''vertex'' or ''scalar'')');
    6868

  • issm/trunk-jpl/src/m/classes/dependent.py

    r20910 r21049  
    44from fielddisplay import fielddisplay
    55from MatlabFuncs import *
    6 from EnumDefinitions import *
    76from MeshProfileIntersection import MeshProfileIntersection
    87
    … …  
    4948                s ="   dependent variable:\n"
    5049
    51                 s+="%s\n" % fielddisplay(self,'name',"variable name (must match corresponding Enum)")
     50                s+="%s\n" % fielddisplay(self,'name',"variable name (must match corresponding String)")
    5251                s+="%s\n" % fielddisplay(self,'type',"type of variable ('vertex' or 'scalar')")
    5352

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

    r19958 r21049  
    3535
    3636                        %Early return
    37                         if solution~=FlaimSolutionEnum(), return; end
     37                        if ~strcmp(solution,'FlaimSolution'), return; end
    3838
    3939                        md = checkfield(md,'fieldname','flaim.tracks','file',1);

  • issm/trunk-jpl/src/m/classes/flaim.py

    r17497 r21049  
    22from collections import OrderedDict
    33from fielddisplay import fielddisplay
    4 from EnumDefinitions import *
    54from checkfield import checkfield
    65from WriteData import WriteData
    … …  
    6059
    6160                #Early return
    62                 if not solution==FlaimSolutionEnum():
     61                if not solution=='FlaimSolution':
    6362                        return md
    6463

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

    r20993 r21049  
    9191
    9292                        %Early return
    93                         if (~ismember(StressbalanceAnalysisEnum(),analyses) & ~ismember(StressbalanceSIAAnalysisEnum(),analyses)) | (solution==TransientSolutionEnum() & md.transient.isstressbalance==0), return; end
     93                        if (~ismember('StressbalanceAnalysis',analyses) & ~ismember('StressbalanceSIAAnalysis',analyses)) | (strcmp(solution,'TransientSolution') & md.transient.isstressbalance==0), return; end
    9494
    9595                        md = checkfield(md,'fieldname','flowequation.isSIA','numel',[1],'values',[0 1]);
    … …  
    127127                                md = checkmessage(md,['no element types set for this model']);
    128128                        end
    129                         if ismember(StressbalanceSIAAnalysisEnum(),analyses),
     129                        if ismember('StressbalanceSIAAnalysis',analyses),
    130130                                if any(self.element_equation==1),
    131131                                        if(self.vertex_equation & md.mask.groundedice_levelset<0.),

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

    r20993 r21049  
    33from project3d import project3d
    44from fielddisplay import fielddisplay
    5 from EnumDefinitions import *
    65from checkfield import checkfield
    76from WriteData import WriteData
    … …  
    8382
    8483                #Early return
    85                 if (StressbalanceAnalysisEnum() not in analyses and StressbalanceSIAAnalysisEnum() not in analyses) or (solution==TransientSolutionEnum() and not md.transient.isstressbalance):
     84                if ('StressbalanceAnalysis' not in analyses and 'StressbalanceSIAAnalysis' not in analyses) or (solution=='TransientSolution' and not md.transient.isstressbalance):
    8685                        return md
    8786
    … …  
    113112                        md.checkmessage("no element types set for this model")
    114113
    115                 if StressbalanceSIAAnalysisEnum() in analyses:
     114                if 'StressbalanceSIAAnalysis' in analyses:
    116115                        if any(self.element_equation==1):
    117116                                if numpy.any(numpy.logical_and(self.vertex_equation,md.mask.groundedice_levelset)):

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

    r20902 r21049  
    3030
    3131                        %Early return
    32                         if ~ismember(StressbalanceAnalysisEnum(),analyses) & ~ismember(ThermalAnalysisEnum(),analyses), return; end
    33                         if (solution==TransientSolutionEnum() &  md.transient.isstressbalance ==0 & md.transient.isthermal == 0), return; end
     32                        if ~ismember('StressbalanceAnalysis',analyses) & ~ismember('ThermalAnalysis',analyses), return; end
     33                        if (strcmp(solution,'TransientSolution') &  md.transient.isstressbalance ==0 & md.transient.isthermal == 0), return; end
    3434
    3535                        md = checkfield(md,'fieldname','friction.coefficient','timeseries',1,'NaN',1,'Inf',1);

  • issm/trunk-jpl/src/m/classes/friction.py

    r20690 r21049  
    11from fielddisplay import fielddisplay
    22from project3d import project3d
    3 from EnumDefinitions import *
    43from checkfield import checkfield
    54from WriteData import WriteData
    … …  
    4241
    4342                #Early return
    44                 if StressbalanceAnalysisEnum() not in analyses and ThermalAnalysisEnum() not in analyses:
     43                if 'StressbalanceAnalysis' not in analyses and 'ThermalAnalysis' not in analyses:
    4544                        return md
    4645

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

    r20902 r21049  
    3232
    3333                        %Early return
    34                         if ~ismember(StressbalanceAnalysisEnum(),analyses) & ~ismember(ThermalAnalysisEnum(),analyses), return; end
     34                        if ~ismember('StressbalanceAnalysis',analyses) & ~ismember('ThermalAnalysis',analyses), return; end
    3535                        md = checkfield(md,'fieldname','friction.coefficient','timeseries',1,'NaN',1,'Inf',1);
    3636                        md = checkfield(md,'fieldname','friction.coefficientcoulomb','timeseries',1,'NaN',1,'Inf',1);

  • issm/trunk-jpl/src/m/classes/frictioncoulomb.py

    r20902 r21049  
    11from fielddisplay import fielddisplay
    22from project3d import project3d
    3 from EnumDefinitions import *
    43from checkfield import checkfield
    54from WriteData import WriteData
    … …  
    4544
    4645        #Early return
    47         if StressbalanceAnalysisEnum() not in analyses and ThermalAnalysisEnum() not in analyses:
     46        if 'StressbalanceAnalysis' not in analyses and 'ThermalAnalysis' not in analyses:
    4847            return md
    4948

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

    r20902 r21049  
    2727
    2828                        %Early return
    29                         if ~ismember(StressbalanceAnalysisEnum(),analyses) & ~ismember(ThermalAnalysisEnum(),analyses), return; end
     29                        if ~ismember('StressbalanceAnalysis',analyses) & ~ismember('ThermalAnalysis',analyses), return; end
    3030                        md = checkfield(md,'fieldname','friction.Coupling','numel',[1],'values',[0 1]);
    3131                        md = checkfield(md,'fieldname','friction.q','NaN',1,'Inf',1,'size',[md.mesh.numberofelements 1]);

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

    r20902 r21049  
    2828
    2929                        %Early return
    30                         if ~ismember(StressbalanceAnalysisEnum(),analyses) & ~ismember(ThermalAnalysisEnum(),analyses), return; end
     30                        if ~ismember('StressbalanceAnalysis',analyses) & ~ismember('ThermalAnalysis',analyses), return; end
    3131                        md = checkfield(md,'fieldname','friction.coefficient','timeseries',1,'NaN',1,'Inf',1);
    3232                end % }}}

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

    r20902 r21049  
    3737
    3838                        %Early return
    39                         if ~ismember(StressbalanceAnalysisEnum(),analyses) & ~ismember(ThermalAnalysisEnum(),analyses), return; end
     39                        if ~ismember('StressbalanceAnalysis',analyses) & ~ismember('ThermalAnalysis',analyses), return; end
    4040
    4141                        md = checkfield(md,'fieldname','friction.coefficient','timeseries',1,'NaN',1,'Inf',1);

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

    r20902 r21049  
    2929
    3030                        %Early return
    31                         if ~ismember(StressbalanceAnalysisEnum(),analyses) & ~ismember(ThermalAnalysisEnum(),analyses), return; end
     31                        if ~ismember('StressbalanceAnalysis',analyses) & ~ismember('ThermalAnalysis',analyses), return; end
    3232
    3333                        md = checkfield(md,'fieldname','friction.coefficient','timeseries',1,'NaN',1,'Inf',1);

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

    r20902 r21049  
    2828
    2929                        %Early return
    30                         if ~ismember(StressbalanceAnalysisEnum(),analyses) & ~ismember(ThermalAnalysisEnum(),analyses), return; end
     30                        if ~ismember('StressbalanceAnalysis',analyses) & ~ismember('ThermalAnalysis',analyses), return; end
    3131                        md = checkfield(md,'fieldname','friction.C','timeseries',1,'NaN',1,'Inf',1);
    3232                        md = checkfield(md,'fieldname','friction.m','NaN',1,'Inf',1,'size',[md.mesh.numberofelements 1]);

  • issm/trunk-jpl/src/m/classes/frictionweertman.py

    r20690 r21049  
    11from fielddisplay import fielddisplay
    22from project3d import project3d
    3 from EnumDefinitions import *
    43from checkfield import checkfield
    54from WriteData import WriteData
    … …  
    3433
    3534                #Early return
    36                 if StressbalanceAnalysisEnum() not in analyses and ThermalAnalysisEnum() not in analyses:
     35                if 'StressbalanceAnalysis' not in analyses and 'ThermalAnalysis' not in analyses:
    3736                        return md
    3837

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

    r20902 r21049  
    2525
    2626                        %Early return
    27                         if ~ismember(StressbalanceAnalysisEnum(),analyses) & ~ismember(ThermalAnalysisEnum(),analyses), return; end
     27                        if ~ismember('StressbalanceAnalysis',analyses) & ~ismember('ThermalAnalysis',analyses), return; end
    2828                        md = checkfield(md,'fieldname','friction.C','timeseries',1,'NaN',1,'Inf',1);
    2929                        md = checkfield(md,'fieldname','friction.m','NaN',1,'Inf',1,'size',[md.mesh.numberofelements 1]);

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

    r20902 r21049  
    5353                function md = checkconsistency(self,md,solution,analyses) % {{{
    5454
    55                         if (solution==TransientSolutionEnum() & md.transient.isgia) | (solution==GiaSolutionEnum()),
     55                        if (strcmp(solution,'TransientSolution') & md.transient.isgia) | strcmp(solution,'GiaSolution'),
    5656                                md = checkfield(md,'fieldname','geometry.thickness','timeseries',1,'NaN',1,'Inf',1,'>=',0);
    5757                        else
    … …  
    6262                                        md = checkmessage(md,['equality thickness=surface-base violated']);
    6363                                end
    64                                 if solution==TransientSolutionEnum() & md.transient.isgroundingline,
     64                                if strcmp(solution,'TransientSolution') & md.transient.isgroundingline,
    6565                                        md = checkfield(md,'fieldname','geometry.bed','NaN',1,'Inf',1,'size',[md.mesh.numberofvertices 1]);
    6666                                end

  • issm/trunk-jpl/src/m/classes/geometry.py

    r20902 r21049  
    11from project3d import project3d
    22from fielddisplay import fielddisplay
    3 from EnumDefinitions import *
    43from checkfield import checkfield
    54from WriteData import WriteData
    … …  
    4645        def checkconsistency(self,md,solution,analyses):    # {{{
    4746
    48                 if (solution==TransientSolutionEnum() and md.transient.isgia) or (solution==GiaSolutionEnum()):
     47                if (solution=='TransientSolution' and md.transient.isgia) or (solution=='GiaSolution'):
    4948                        md = checkfield(md,'fieldname','geometry.thickness','NaN',1,'Inf',1,'>=',0,'timeseries',1)
    5049                else:
    … …  
    5453                        if any(abs(self.thickness-self.surface+self.base)>10**-9):
    5554                                md.checkmessage("equality thickness=surface-base violated")
    56                         if solution==TransientSolutionEnum() and md.transient.isgroundingline:
     55                        if solution=='TransientSolution' and md.transient.isgroundingline:
    5756                                md = checkfield(md,'fieldname','geometry.bed','NaN',1,'Inf',1,'size',[md.mesh.numberofvertices])
    5857

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

    r20690 r21049  
    2828                function md = checkconsistency(self,md,solution,analyses) % {{{
    2929
    30                         if ~ismember(GiaAnalysisEnum(),analyses), return; end
     30                        if ~ismember('GiaAnalysis',analyses), return; end
    3131                        md = checkfield(md,'fieldname','gia.mantle_viscosity','NaN',1,'Inf',1,'size',[md.mesh.numberofvertices 1],'>',0);
    3232                        md = checkfield(md,'fieldname','gia.lithosphere_thickness','NaN',1,'Inf',1,'size',[md.mesh.numberofvertices 1],'>',0);
    … …  
    3535                        %be sure that if we are running a masstransport ice flow model coupled with gia, that thickness forcings
    3636                        %are not provided into the future.
    37                         if solution==TransientSolutionEnum() & md.transient.ismasstransport & md.transient.isgia,
     37                        if strcmp(solution,'TransientSolution') & md.transient.ismasstransport & md.transient.isgia,
    3838                                %figure out if thickness is a transient forcing:
    3939                                if size(md.geometry.thickness,1)==md.mesh.numberofvertices+1,

  • issm/trunk-jpl/src/m/classes/gia.py

    r20690 r21049  
    11from fielddisplay import fielddisplay
    22from project3d import project3d
    3 from EnumDefinitions import *
    43from checkfield import checkfield
    54from WriteData import WriteData
    … …  
    4544
    4645                # Early return
    47                 if (GiaAnalysisEnum() not in  analyses):
     46                if ('GiaAnalysis' not in  analyses):
    4847                        return md
    4948               

  • issm/trunk-jpl/src/m/classes/groundingline.py

    r20927 r21049  
    11import numpy
    22from fielddisplay import fielddisplay
    3 from EnumDefinitions import *
    4 from StringToEnum import StringToEnum
    53from checkfield import checkfield
    64from WriteData import WriteData

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

    r20917 r21049  
    9696                function md = checkconsistency(self,md,solution,analyses)
    9797                        %Early return
    98                         if ~ismember(HydrologyDCInefficientAnalysisEnum(),analyses) & ~ismember(HydrologyDCEfficientAnalysisEnum(),analyses),
     98                        if ~ismember('HydrologyDCInefficientAnalysis',analyses) & ~ismember('HydrologyDCEfficientAnalysis',analyses),
    9999                                return;
    100100                        end

  • issm/trunk-jpl/src/m/classes/hydrologydc.py

    r20917 r21049  
    22from project3d import project3d
    33from fielddisplay import fielddisplay
    4 from EnumDefinitions import *
    54from checkfield import checkfield
    65from WriteData import WriteData
    … …  
    145144
    146145                #Early return
    147                 if HydrologyDCInefficientAnalysisEnum() not in analyses and HydrologyDCEfficientAnalysisEnum() not in analyses:
     146                if 'HydrologyDCInefficientAnalysis' not in analyses and 'HydrologyDCEfficientAnalysis' not in analyses:
    148147                        return md
    149148

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

    r20917 r21049  
    3030
    3131                        %Early return
    32                         if ~ismember(HydrologyShreveAnalysisEnum(),analyses)
     32                        if ~ismember('HydrologyShreveAnalysis',analyses)
    3333                                return;
    3434                        end

  • issm/trunk-jpl/src/m/classes/hydrologyshreve.py

    r20917 r21049  
    11from fielddisplay import fielddisplay
    2 from EnumDefinitions import *
    32from checkfield import checkfield
    43from WriteData import WriteData
    … …  
    4039               
    4140                #Early return
    42                 if HydrologyShreveAnalysisEnum() not in analyses:
     41                if 'HydrologyShreveAnalysis' not in analyses:
    4342                        return md
    4443

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

    r20917 r21049  
    3434
    3535                        %Early return
    36                         if ~ismember(HydrologySommersAnalysisEnum(),analyses)
     36                        if ~ismember('HydrologySommersAnalysis',analyses)
    3737                                return;
    3838                        end

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

    r19068 r21049  
    5151                        disp(sprintf('   independent variable:'));
    5252
    53                         fielddisplay(self,'name','variable name (must match corresponding Enum)');
     53                        fielddisplay(self,'name','variable name (must match corresponding String)');
    5454                        fielddisplay(self,'type','type of variable (''vertex'' or ''scalar'')');
    5555                        fielddisplay(self,'nods','size of dependent variables');

  • issm/trunk-jpl/src/m/classes/independent.py

    r21016 r21049  
    44from checkfield import checkfield
    55from MatlabFuncs import *
    6 from EnumDefinitions import *
    76
    87class independent(object):
    … …  
    3332                s ="   independent variable:\n"
    3433
    35                 s+="%s\n" % fielddisplay(self,'name',"variable name (must match corresponding Enum)")
     34                s+="%s\n" % fielddisplay(self,'name',"variable name (must match corresponding String)")
    3635                s+="%s\n" % fielddisplay(self,'type',"type of variable ('vertex' or 'scalar')")
    3736                if not numpy.isnan(self.fos_forward_index):

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

    r20896 r21049  
    4646                end % }}}
    4747                function md = checkconsistency(self,md,solution,analyses) % {{{
    48                         if ismember(StressbalanceAnalysisEnum(),analyses) & ~(solution==TransientSolutionEnum() & md.transient.isstressbalance == 0),
     48                        if ismember('StressbalanceAnalysis',analyses) & ~(strcmp(solution,'TransientSolution') & md.transient.isstressbalance == 0),
    4949                                if ~(isnan(md.initialization.vx) | isnan(md.initialization.vy)),
    5050                                        md = checkfield(md,'fieldname','initialization.vx','NaN',1,'Inf',1,'size',[md.mesh.numberofvertices 1]);
    … …  
    5252                                end
    5353                        end
    54                         if ismember(MasstransportAnalysisEnum(),analyses) & ~(solution==TransientSolutionEnum() & md.transient.ismasstransport == 0),
     54                        if ismember('MasstransportAnalysis',analyses) & ~(strcmp(solution,'TransientSolution') & md.transient.ismasstransport == 0),
    5555                                md = checkfield(md,'fieldname','initialization.vx','NaN',1,'Inf',1,'size',[md.mesh.numberofvertices 1]);
    5656                                md = checkfield(md,'fieldname','initialization.vy','NaN',1,'Inf',1,'size',[md.mesh.numberofvertices 1]);
    5757                        end
    58                         if ismember(BalancethicknessAnalysisEnum(),analyses) & solution==BalancethicknessSolutionEnum,
     58                        if ismember('BalancethicknessAnalysis',analyses) & strcmp(solution,'BalancethicknessSolution'),
    5959                                md = checkfield(md,'fieldname','initialization.vx','NaN',1,'Inf',1,'size',[md.mesh.numberofvertices 1]);
    6060                                md = checkfield(md,'fieldname','initialization.vy','NaN',1,'Inf',1,'size',[md.mesh.numberofvertices 1]);
    … …  
    6464                                end
    6565                        end
    66                         if ismember(ThermalAnalysisEnum(),analyses) & ~(solution==TransientSolutionEnum() & md.transient.isthermal == 0),
     66                        if ismember('ThermalAnalysis',analyses) & ~(strcmp(solution,'TransientSolution') & md.transient.isthermal == 0),
    6767                                md = checkfield(md,'fieldname','initialization.vx','NaN',1,'Inf',1,'size',[md.mesh.numberofvertices 1]);
    6868                                md = checkfield(md,'fieldname','initialization.vy','NaN',1,'Inf',1,'size',[md.mesh.numberofvertices 1]);
    … …  
    7373                                md = checkfield(md,'fieldname','initialization.temperature','NaN',1,'Inf',1,'size',[md.mesh.numberofvertices 1]);
    7474                        end
    75                         if (ismember(EnthalpyAnalysisEnum(),analyses) & md.thermal.isenthalpy)
     75                        if (ismember('EnthalpyAnalysis',analyses) & md.thermal.isenthalpy)
    7676                                md = checkfield(md,'fieldname','initialization.waterfraction','>=',0,'size',[md.mesh.numberofvertices 1]);
    7777                                md = checkfield(md,'fieldname','initialization.watercolumn'  ,'>=',0,'size',[md.mesh.numberofvertices 1]);
    7878                        end
    79                         if ismember(HydrologyShreveAnalysisEnum(),analyses),
     79                        if ismember('HydrologyShreveAnalysis',analyses),
    8080                                if isa(md.hydrology,'hydrologyshreve'),
    8181                                        md = checkfield(md,'fieldname','initialization.watercolumn','NaN',1,'Inf',1,'size',[md.mesh.numberofvertices 1]);
    8282                                end
    8383                        end
    84                         if ismember(HydrologyDCInefficientAnalysisEnum(),analyses),
     84                        if ismember('HydrologyDCInefficientAnalysis',analyses),
    8585                                if isa(md.hydrology,'hydrologydc'),
    8686                                        md = checkfield(md,'fieldname','initialization.sediment_head','NaN',1,'Inf',1,'size',[md.mesh.numberofvertices 1]);
    8787                                end
    8888                        end
    89                         if ismember(HydrologyDCEfficientAnalysisEnum(),analyses),
     89                        if ismember('HydrologyDCEfficientAnalysis',analyses),
    9090                                if isa(md.hydrology,'hydrologydc'),
    9191                                        if md.hydrology.isefficientlayer==1,

  • issm/trunk-jpl/src/m/classes/initialization.py

    r20991 r21049  
    22from project3d import project3d
    33from fielddisplay import fielddisplay
    4 from EnumDefinitions import *
    54from checkfield import checkfield
    65from WriteData import WriteData
    … …  
    7069        #}}}
    7170        def checkconsistency(self,md,solution,analyses):    # {{{
    72                 if StressbalanceAnalysisEnum() in analyses:
     71                if 'StressbalanceAnalysis' in analyses:
    7372                        if not numpy.any(numpy.logical_or(numpy.isnan(md.initialization.vx),numpy.isnan(md.initialization.vy))):
    7473                                md = checkfield(md,'fieldname','initialization.vx','NaN',1,'Inf',1,'size',[md.mesh.numberofvertices])
    7574                                md = checkfield(md,'fieldname','initialization.vy','NaN',1,'Inf',1,'size',[md.mesh.numberofvertices])
    76                 if MasstransportAnalysisEnum() in analyses:
     75                if 'MasstransportAnalysis' in analyses:
    7776                        md = checkfield(md,'fieldname','initialization.vx','NaN',1,'Inf',1,'size',[md.mesh.numberofvertices])
    7877                        md = checkfield(md,'fieldname','initialization.vy','NaN',1,'Inf',1,'size',[md.mesh.numberofvertices])
    79                 if BalancethicknessAnalysisEnum() in analyses:
     78                if 'BalancethicknessAnalysis' in analyses:
    8079                        md = checkfield(md,'fieldname','initialization.vx','NaN',1,'Inf',1,'size',[md.mesh.numberofvertices])
    8180                        md = checkfield(md,'fieldname','initialization.vy','NaN',1,'Inf',1,'size',[md.mesh.numberofvertices])
    … …  
    8483                                                       numpy.sum(numpy.abs(md.initialization.vy[md.mesh.elements-1]),axis=1)==0)):
    8584                                md.checkmessage("at least one triangle has all its vertices with a zero velocity")
    86                 if ThermalAnalysisEnum() in analyses:
     85                if 'ThermalAnalysis' in analyses:
    8786                        md = checkfield(md,'fieldname','initialization.vx','NaN',1,'Inf',1,'size',[md.mesh.numberofvertices])
    8887                        md = checkfield(md,'fieldname','initialization.vy','NaN',1,'Inf',1,'size',[md.mesh.numberofvertices])
    … …  
    9190                                md = checkfield(md,'fieldname','initialization.vz','NaN',1,'Inf',1,'size',[md.mesh.numberofvertices])
    9291                        md = checkfield(md,'fieldname','initialization.pressure','NaN',1,'Inf',1,'size',[md.mesh.numberofvertices])
    93                         if (EnthalpyAnalysisEnum() in analyses and md.thermal.isenthalpy):
     92                        if ('EnthalpyAnalysis' in analyses and md.thermal.isenthalpy):
    9493                                md = checkfield(md,'fieldname','initialization.waterfraction','>=',0,'size',[md.mesh.numberofvertices])
    9594                                md = checkfield(md,'fieldname','initialization.watercolumn'  ,'>=',0,'size',[md.mesh.numberofvertices])
    96                 if HydrologyShreveAnalysisEnum() in analyses:
     95                if 'HydrologyShreveAnalysis' in analyses:
    9796                        if hasattr(md.hydrology,'hydrologyshreve'):
    9897                                md = checkfield(md,'fieldname','initialization.watercolumn','NaN',1,'Inf',1,'size',[md.mesh.numberofvertices])
    99                 if HydrologyDCInefficientAnalysisEnum() in analyses:
     98                if 'HydrologyDCInefficientAnalysis' in analyses:
    10099                        if hasattr(md.hydrology,'hydrologydc'):
    101100                                md = checkfield(md,'fieldname','initialization.sediment_head','NaN',1,'Inf',1,'size',[md.mesh.numberofvertices,1])
    102                 if HydrologyDCEfficientAnalysisEnum() in analyses:
     101                if 'HydrologyDCEfficientAnalysis' in analyses:
    103102                        if hasattr(md.hydrology,'hydrologydc'):
    104103                                if md.hydrology.isefficientlayer==1:

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

    r20896 r21049  
    103103
    104104                        %Only SSA, HO and FS are supported right now
    105                         if solution==StressbalanceSolutionEnum()
     105                        if strcmp(solution,'StressbalanceSolution')
    106106                                if ~(md.flowequation.isSSA || md.flowequation.isHO || md.flowequation.isFS || md.flowequation.isL1L2),
    107107                                        md = checkmessage(md,['inversion can only be performed for SSA, HO or FS ice flow models']);
    … …  
    109109                        end
    110110
    111                         if solution==BalancethicknessSolutionEnum()
     111                        if strcmp(solution,'BalancethicknessSolution')
    112112                                md = checkfield(md,'fieldname','inversion.thickness_obs','size',[md.mesh.numberofvertices 1],'NaN',1,'Inf',1);
    113                         elseif solution==BalancethicknessSoftSolutionEnum()
     113                        elseif strcmp(solution,'BalancethicknessSoftSolution')
    114114                                md = checkfield(md,'fieldname','inversion.thickness_obs','size',[md.mesh.numberofvertices 1],'NaN',1,'Inf',1);
    115115                        else
    … …  
    182182                        num_cost_functions=size(self.cost_functions,2);
    183183                        data=marshallcostfunctions(self.cost_functions);
    184                         WriteData(fid,prefix,'data',data,'name','md.inversion.cost_functions','format','DoubleMat','mattype',3);
     184                        WriteData(fid,prefix,'data',data,'name','md.inversion.cost_functions','format','StringArray');
    185185                        WriteData(fid,prefix,'data',num_cost_functions,'name','md.inversion.num_cost_functions','format','Integer');
    186186                end % }}}

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

    r20896 r21049  
    22from project3d import project3d
    33from fielddisplay import fielddisplay
    4 from EnumDefinitions import *
    5 from StringToEnum import StringToEnum
    64from checkfield import checkfield
    75from WriteData import WriteData
    … …  
    2422                self.nsteps                      = 0
    2523                self.maxiter_per_step            = float('NaN')
    26                 self.cost_functions              = float('NaN')
     24                self.cost_functions              = ''
    2725                self.cost_functions_coefficients = float('NaN')
    2826                self.gradient_scaling            = float('NaN')
    … …  
    146144
    147145                #Only SSA, HO and FS are supported right now
    148                 if solution==StressbalanceSolutionEnum():
     146                if solution=='StressbalanceSolution':
    149147                        if not (md.flowequation.isSSA or md.flowequation.isHO or md.flowequation.isFS or md.flowequation.isL1L2):
    150148                                md.checkmessage("'inversion can only be performed for SSA, HO or FS ice flow models");
    151149
    152                 if solution==BalancethicknessSolutionEnum():
     150                if solution=='BalancethicknessSolution':
    153151                        md = checkfield(md,'fieldname','inversion.thickness_obs','size',[md.mesh.numberofvertices],'NaN',1,'Inf',1)
    154152                else:
    … …  
    189187                num_cost_functions=numpy.size(self.cost_functions)
    190188                data=marshallcostfunctions(self.cost_functions)
    191                 WriteData(fid,prefix,'data',numpy.array(data).reshape(1,-1),'name','md.inversion.cost_functions','format','DoubleMat','mattype',3)
     189                WriteData(fid,prefix,'data',data,'name','md.inversion.cost_functions','format','StringArray')
    192190                WriteData(fid,prefix,'data',num_cost_functions,'name','md.inversion.num_cost_functions','format','Integer')
    193191        # }}}

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

    r20896 r21049  
    7373                        md = checkfield(md,'fieldname','inversion.max_parameters','size',[md.mesh.numberofvertices num_controls]);
    7474
    75                         if solution==BalancethicknessSolutionEnum()
     75                        if strcmp(solution,'BalancethicknessSolution')
    7676                                md = checkfield(md,'fieldname','inversion.thickness_obs','size',[md.mesh.numberofvertices 1],'NaN',1,'Inf',1);
    77                         elseif solution==BalancethicknessSoftSolutionEnum()
     77                        elseif strcmp(solution,'BalancethicknessSoftSolution')
    7878                                md = checkfield(md,'fieldname','inversion.thickness_obs','size',[md.mesh.numberofvertices 1],'NaN',1,'Inf',1);
    7979                        else
    … …  
    141141                        num_cost_functions=size(self.cost_functions,2);
    142142                        data=marshallcostfunctions(self.cost_functions);
    143                         WriteData(fid,prefix,'data',data,'name','md.inversion.cost_functions','format','DoubleMat','mattype',3);
     143                        WriteData(fid,prefix,'data',data,'name','md.inversion.cost_functions','format','StringArray');
    144144                        WriteData(fid,prefix,'data',num_cost_functions,'name','md.inversion.num_cost_functions','format','Integer');
    145145                end % }}}

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

    r20902 r21049  
    4242                function md = checkconsistency(self,md,solution,analyses) % {{{
    4343                        %Early return
    44                         if (solution~=TransientSolutionEnum() | md.transient.ismovingfront==0), return; end
     44                        if (~strcmp(solution,'TransientSolution') | md.transient.ismovingfront==0), return; end
    4545
    4646                        md = checkfield(md,'fieldname','levelset.spclevelset','Inf',1,'timeseries',1);

  • issm/trunk-jpl/src/m/classes/levelset.py

    r20902 r21049  
    11from fielddisplay import fielddisplay
    22from project3d import project3d
    3 from EnumDefinitions import *
    4 from StringToEnum import StringToEnum
    53from checkfield import checkfield
    64from WriteData import WriteData
    … …  
    4745
    4846                #Early return
    49                 if (solution!=TransientSolutionEnum()) or (not md.transient.ismovingfront):
     47                if (solution!='TransientSolution') or (not md.transient.ismovingfront):
    5048                        return md
    5149

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

    r20916 r21049  
    4141                function md = checkconsistency(self,md,solution,analyses) % {{{
    4242
    43                         if ismember(MasstransportAnalysisEnum(),analyses) & ~(solution==TransientSolutionEnum() & md.transient.ismasstransport==0),
     43                        if ismember('MasstransportAnalysis',analyses) & ~(strcmp(solution,'TransientSolution') & md.transient.ismasstransport==0),
    4444                                md = checkfield(md,'fieldname','basalforcings.groundedice_melting_rate','NaN',1,'Inf',1,'timeseries',1);
    4545                                md = checkfield(md,'fieldname','basalforcings.deepwater_melting_rate','>=',0,'numel',1);
    … …  
    4747                                md = checkfield(md,'fieldname','basalforcings.upperwater_elevation','<',0,'numel',1);
    4848                        end
    49                         if ismember(BalancethicknessAnalysisEnum(),analyses),
     49                        if ismember('BalancethicknessAnalysis',analyses),
    5050                                md = checkfield(md,'fieldname','basalforcings.groundedice_melting_rate','NaN',1,'Inf',1,'size',[md.mesh.numberofvertices 1]);
    5151                                md = checkfield(md,'fieldname','basalforcings.deepwater_melting_rate','>=',0,'numel',1);
    … …  
    5353                                md = checkfield(md,'fieldname','basalforcings.upperwater_elevation','<',0,'numel',1);
    5454                        end
    55                         if ismember(ThermalAnalysisEnum(),analyses) & ~(solution==TransientSolutionEnum() & md.transient.isthermal==0),
     55                        if ismember('ThermalAnalysis',analyses) & ~(strcmp(solution,'TransientSolution') & md.transient.isthermal==0),
    5656                                md = checkfield(md,'fieldname','basalforcings.groundedice_melting_rate','NaN',1,'Inf',1,'timeseries',1);
    5757                                md = checkfield(md,'fieldname','basalforcings.deepwater_melting_rate','>=',0,'numel',1);

  • issm/trunk-jpl/src/m/classes/linearbasalforcings.py

    r20916 r21049  
    11from fielddisplay import fielddisplay
    2 from EnumDefinitions import *
    32from checkfield import checkfield
    43from WriteData import WriteData
    … …  
    6867        def checkconsistency(self,md,solution,analyses):    # {{{
    6968
    70                 if MasstransportAnalysisEnum() in analyses and not (solution==TransientSolutionEnum() and not md.transient.ismasstransport):
     69                if 'MasstransportAnalysis' in analyses and not (solution=='TransientSolution' and not md.transient.ismasstransport):
    7170                        md = checkfield(md,'fieldname','basalforcings.groundedice_melting_rate','NaN',1,'Inf',1,'timeseries',1)
    7271                        md = checkfield(md,'fieldname','basalforcings.deepwater_melting_rate','>=',0);
    … …  
    7473                        md = checkfield(md,'fieldname','basalforcings.upperwater_elevation','<',0);
    7574
    76                 if BalancethicknessAnalysisEnum() in analyses:
     75                if 'BalancethicknessAnalysis' in analyses:
    7776                        md = checkfield(md,'fieldname','basalforcings.groundedice_melting_rate','NaN',1,'Inf',1,'size',[md.mesh.numberofvertices])
    7877                        md = checkfield(md,'fieldname','basalforcings.deepwater_melting_rate','>=',0);
    … …  
    8079                        md = checkfield(md,'fieldname','basalforcings.upperwater_elevation','<',0);
    8180
    82                 if ThermalAnalysisEnum() in analyses and not (solution==TransientSolutionEnum() and not md.transient.isthermal):
     81                if 'ThermalAnalysis' in analyses and not (solution=='TransientSolution' and not md.transient.isthermal):
    8382                        md = checkfield(md,'fieldname','basalforcings.groundedice_melting_rate','NaN',1,'Inf',1,'timeseries',1)
    8483                        md = checkfield(md,'fieldname','basalforcings.deepwater_melting_rate','>=',0);

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

    r20896 r21049  
    9494                        md = checkfield(md,'fieldname','inversion.max_parameters','size',[md.mesh.numberofvertices num_controls]);
    9595
    96                         if solution==BalancethicknessSolutionEnum()
     96                        if strcmp(solution,'BalancethicknessSolution')
    9797                                md = checkfield(md,'fieldname','inversion.thickness_obs','size',[md.mesh.numberofvertices 1],'NaN',1,'Inf',1);
    9898                                md = checkfield(md,'fieldname','inversion.surface_obs','size',[md.mesh.numberofvertices 1],'NaN',1,'Inf',1);
    99                         elseif solution==BalancethicknessSoftSolutionEnum()
     99                        elseif strcmp(solution,'BalancethicknessSoftSolution')
    100100                                md = checkfield(md,'fieldname','inversion.thickness_obs','size',[md.mesh.numberofvertices 1],'NaN',1,'Inf',1);
    101101                        else
    … …  
    171171                        num_cost_functions=size(self.cost_functions,2);
    172172                        data=marshallcostfunctions(self.cost_functions);
    173                         WriteData(fid,prefix,'data',data,'name','md.inversion.cost_functions','format','DoubleMat','mattype',3);
     173                        WriteData(fid,prefix,'data',data,'name','md.inversion.cost_functions','format','StringArray');
    174174                        WriteData(fid,prefix,'data',num_cost_functions,'name','md.inversion.num_cost_functions','format','Integer');
    175175                end % }}}

  • issm/trunk-jpl/src/m/classes/m1qn3inversion.py

    r20896 r21049  
    22from project3d import project3d
    33from fielddisplay import fielddisplay
    4 from EnumDefinitions import *
    5 from StringToEnum import StringToEnum
    64from checkfield import checkfield
    75from WriteData import WriteData
    … …  
    155153                md = checkfield(md,'fieldname','inversion.max_parameters','size',[md.mesh.numberofvertices,num_controls])
    156154
    157                 if solution==BalancethicknessSolutionEnum():
     155                if solution=='BalancethicknessSolution':
    158156                        md = checkfield(md,'fieldname','inversion.thickness_obs','size',[md.mesh.numberofvertices],'NaN',1,'Inf',1)
    159157                else:
    … …  
    193191                num_cost_functions=numpy.size(self.cost_functions)
    194192                data=marshallcostfunctions(self.cost_functions)
    195                 WriteData(fid,prefix,'data',numpy.array(data).reshape(1,-1),'name','md.inversion.cost_functions','format','DoubleMat','mattype',3)
     193                WriteData(fid,prefix,'data',data,'name','md.inversion.cost_functions','format','StringArray')
    196194                WriteData(fid,prefix,'data',num_cost_functions,'name','md.inversion.num_cost_functions','format','Integer')
    197195        # }}}

  • issm/trunk-jpl/src/m/classes/mask.py

    r20690 r21049  
    22from fielddisplay import fielddisplay
    33from project3d import project3d
    4 from EnumDefinitions import *
    54from checkfield import checkfield
    65from WriteData import WriteData

  • issm/trunk-jpl/src/m/classes/maskpsl.py

    r20690 r21049  
    22import MatlabFuncs as m
    33from model import *
    4 from EnumDefinitions import *
    54from fielddisplay import fielddisplay
    65from checkfield import checkfield

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

    r20690 r21049  
    1414                %masscon
    1515                name              = '';
    16                 definitionenum   = NaN; %enum that identifies this output definition uniquely, from Outputdefinition[1-10]Enum
     16                definitionstring   = ''; %string that identifies this output definition uniquely, from 'Outputdefinition[1-10]'
    1717                levelset          = NaN; %levelset vectorial field which identifies the boundaries of the masscon
    1818        end
    … …  
    2929                                self.name=getfieldvalue(options,'name','');
    3030                                self.levelset=getfieldvalue(options,'levelset');
    31                                 self.definitionenum=getfieldvalue(options,'definitionenum');
     31                                self.definitionstring=getfieldvalue(options,'definitionstring');
    3232
    3333                        end
    … …  
    4141                        end
    4242                       
    43                         md = checkfield(md,'fieldname','self.definitionenum','field',self.definitionenum,'values',[Outputdefinition1Enum:Outputdefinition100Enum]);
     43                        OutputdefinitionStringArray={};
     44                        for i=1:100
     45                                OutputdefinitionStringArray{i}=strcat('Outputdefinition',num2str(i));
     46                        end
    4447
     48                        md = checkfield(md,'fieldname','self.definitionstring','field',self.definitionstring,'values','Outputdefinition');
    4549                        md = checkfield(md,'fieldname','self.levelset','field',self.levelset,'timeseries',1,'NaN',1,'Inf',1);
    4650
    … …  
    5155
    5256                        fielddisplay(self,'name','identifier for this masscon response');
    53                         fielddisplay(self,'definitionenum','enum that identifies this output definition uniquely, from Outputdefinition[1-10]Enum');
     57                        fielddisplay(self,'definitionstring','string that identifies this output definition uniquely, from ''Outputdefinition[1-10]''');
    5458                        fielddisplay(self,'levelset','levelset vectorial field which identifies the boundaries of the masscon');
    5559
    … …  
    5862
    5963                WriteData(fid,prefix,'object',self,'fieldname','name','format','String');
    60                 WriteData(fid,prefix,'object',self,'fieldname','definitionenum','format','Integer');
     64                WriteData(fid,prefix,'object',self,'fieldname','definitionstring','format','String');
    6165                WriteData(fid,prefix,'object',self,'fieldname','levelset','format','DoubleMat','mattype',1);
    6266

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

    r20690 r21049  
    1515                %masscon axpby
    1616                name              = '';
    17                 definitionenum   = NaN; %enum that identifies this output definition uniquely, from Outputdefinition[1-10]Enum
     17                definitionstring   = ''; %String that identifies this output definition uniquely, from 'Outputdefinition[1-10]'
    1818                namex              = '';
    1919                namey              = '';
    … …  
    3232                                %get names
    3333                                self.name=getfieldvalue(options,'name','');
    34                                 self.definitionenum=getfieldvalue(options,'definitionenum');
     34                                self.definitionstring=getfieldvalue(options,'definitionstring');
    3535                                self.namex=getfieldvalue(options,'namex');
    3636                                self.namey=getfieldvalue(options,'namey');
    … …  
    5050                        if ~ischar(self.namex), error('masscon error message: ''namex'' field should be a string!'); end
    5151                        if ~ischar(self.namey), error('masscon error message: ''namey'' field should be a string!'); end
    52                        
    53                         md = checkfield(md,'fieldname','self.definitionenum','field',self.definitionenum,'values',[Outputdefinition1Enum:Outputdefinition100Enum]);
     52               
     53                        % Create output definition cell array for check
     54                        OutputdefinitionStringArray={};
     55                        for i=1:100
     56                                OutputdefinitionStringArray{i}=strcat('Outputdefinition',num2str(i));
     57                        end
     58
     59                        md = checkfield(md,'fieldname','self.definitionstring','field',self.definitionstring,'values',OutputdefinitionStringArray);
    5460
    5561                        md = checkfield(md,'fieldname','self.alpha','field',self.alpha,'NaN',1,'Inf',1,'size',[1 1]);
    … …  
    6268
    6369                        fielddisplay(self,'name','name');
    64                         fielddisplay(self,'definitionenum','enum that identifies this output definition uniquely, from Outputdefinition[1-10]Enum');
     70                        fielddisplay(self,'definitionstring','string that identifies this output definition uniquely, from Outputdefinition[1-10]');
    6571                        fielddisplay(self,'namex','identifier for the first masscon');
    6672                        fielddisplay(self,'alpha','first masscon multiplicator');
    … …  
    7278
    7379                WriteData(fid,prefix,'object',self,'fieldname','name','format','String');
    74                 WriteData(fid,prefix,'object',self,'fieldname','definitionenum','format','Integer');
     80                WriteData(fid,prefix,'object',self,'fieldname','definitionstring','format','Integer');
    7581                WriteData(fid,prefix,'object',self,'fieldname','namex','format','String');
    7682                WriteData(fid,prefix,'object',self,'fieldname','namey','format','String');

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

    r20690 r21049  
    33%   Usage:
    44%      massfluxatgate=massfluxatgate();
    5 %      massfluxatgate=massfluxatgate('name','GateName','definitionname',Outputdefinition1Enum,'profilename','PathToExpFile');
     5%      massfluxatgate=massfluxatgate('name','GateName','definitionname','Outputdefinition1','profilename','PathToExpFile');
    66
    77classdef massfluxatgate
    … …  
    99                %massfluxatgate
    1010                name            = '';
    11                 definitionenum  = 0;
     11                definitionstring  = '';
    1212                profilename     = '';
    1313        end
    … …  
    2525                                %get name
    2626                                self.name=getfieldvalue(options,'name','');
    27                                 self.definitionenum=getfieldvalue(options,'definitionenum');
     27                                self.definitionstring=getfieldvalue(options,'definitionstring');
    2828                                self.profilename=getfieldvalue(options,'profilename');
    2929                        end
    … …  
    3939                                error('massfluxatgate error message: ''profilename'' field should be a string!');
    4040                        end
    41                        
    42                         md = checkfield(md,'field',self.definitionenum,'values',[Outputdefinition1Enum():Outputdefinition100Enum()]);
     41               
     42                        OutputdefinitionStringArray={};
     43                        for i=1:100
     44                                OutputdefinitionStringArray{i}=strcat('Outputdefinition',num2str(i));
     45                        end
     46                        md = checkfield(md,'field',self.definitionstring,'values',OutputdefinitionStringArray);
    4347
    4448                        %check the profilename points to a file!:
    … …  
    5256                        fielddisplay(self,'name','identifier for this massfluxatgate response');
    5357                        fielddisplay(self,'profilename','name of file (shapefile or argus file) defining a profile (or gate)');
    54                         fielddisplay(self,'definitionenum','enum that identifies this output definition uniquely, from Outputdefinition[1-10]Enum');
     58                        fielddisplay(self,'definitionstring','string that identifies this output definition uniquely, from ''Outputdefinition[1-10]''');
    5559                       
    5660                end % }}}
    … …  
    6266                %ok, marshall name and segments:
    6367                WriteData(fid,prefix,'data',self.name,'name','md.massfluxatgate.name','format','String');
    64                 WriteData(fid,prefix,'data',self.definitionenum,'name','md.massfluxatgate.definitionenum','format','Integer');
     68                WriteData(fid,prefix,'data',self.definitionstring,'name','md.massfluxatgate.definitionstring','format','String');
    6569                WriteData(fid,prefix,'data',self.segments,'name','md.massfluxatgate.segments','format','DoubleMat','mattype',1);
    6670

  • issm/trunk-jpl/src/m/classes/massfluxatgate.py

    r20911 r21049  
    11from fielddisplay import fielddisplay
    2 from EnumDefinitions import *
    32from pairoptions import pairoptions
    43from checkfield import checkfield
    … …  
    1817
    1918                self.name            = ''
    20                 self.definitionenum  = 0
     19                self.definitionstring  = ''
    2120                self.profilename     = ''
    2221                self.segments        = float('NaN')
    … …  
    3635                string="   Massfluxatgate:"
    3736                string="%s\n%s"%(string,fielddisplay(self,'name','identifier for this massfluxatgate response'))
    38                 string="%s\n%s"%(string,fielddisplay(self,'definitionenum','enum that identifies this output definition uniquely, from Outputdefinition[1-10]Enum'))
     37                string="%s\n%s"%(string,fielddisplay(self,'definitionstring','string that identifies this output definition uniquely, from Outputdefinition[1-10]'))
    3938                string="%s\n%s"%(string,fielddisplay(self,'profilename','name of file (shapefile or argus file) defining a profile (or gate)'))
    4039                return string
    … …  
    5150                        raise RuntimeError("massfluxatgate error message: 'profilename' field should be a string!")
    5251
    53                         md = checkfield(md,'field',self.definitionenum,'values',[Outputdefinition1Enum(),Outputdefinition2Enum(),Outputdefinition3Enum(),Outputdefinition4Enum(),Outputdefinition5Enum(),Outputdefinition6Enum(),Outputdefinition7Enum(),Outputdefinition8Enum(),Outputdefinition9Enum(),Outputdefinition10Enum()])
     52                        md = checkfield(md,'field',self.definitionstring,'values',['Outputdefinition1','Outputdefinition2','Outputdefinition3','Outputdefinition4','Outputdefinition5','Outputdefinition6','Outputdefinition7','Outputdefinition8','Outputdefinition9','Outputdefinition10'])
    5453               
    5554                #check the profilename points to a file!:
    … …  
    6665                #ok, marshall name and segments:
    6766                WriteData(fid,prefix,'data',self.name,'name','md.massfluxatgate.name','format','String');
    68                 WriteData(fid,prefix,'data',self.definitionenum,'name','md.massfluxatgate.definitionenum','format','Integer');
     67                WriteData(fid,prefix,'data',self.definitionstring,'name','md.massfluxatgate.definitionstring','format','String');
    6968                WriteData(fid,prefix,'data',self.segments,'name','md.massfluxatgate.segments','format','DoubleMat','mattype',1);
    7069

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

    r20940 r21049  
    8787
    8888                        %Early return
    89                         if ~ismember(MasstransportAnalysisEnum(),analyses) |  (solution==TransientSolutionEnum() & md.transient.ismasstransport==0), return; end
     89                        if ~ismember('MasstransportAnalysis',analyses) |  (strcmp(solution,'TransientSolution') & md.transient.ismasstransport==0), return; end
    9090
    9191                        md = checkfield(md,'fieldname','masstransport.spcthickness','Inf',1,'timeseries',1);

  • issm/trunk-jpl/src/m/classes/masstransport.py

    r20940 r21049  
    11from fielddisplay import fielddisplay
    22from project3d import project3d
    3 from EnumDefinitions import *
    4 from StringToEnum import StringToEnum
    53from checkfield import checkfield
    64from WriteData import WriteData
    … …  
    6967
    7068                #Early return
    71                 if (MasstransportAnalysisEnum() not in analyses) or (solution==TransientSolutionEnum() and not md.transient.ismasstransport):
     69                if ('MasstransportAnalysis' not in analyses) or (solution=='TransientSolution' and not md.transient.ismasstransport):
    7270                        return md
    7371

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

    r20947 r21049  
    116116                        md = checkfield(md,'fieldname','materials.rheology_law','values',{'None' 'Cuffey' 'CuffeyTemperate' 'Paterson' 'Arrhenius' 'LliboutryDuval'});
    117117
    118                         if ismember(GiaAnalysisEnum(),analyses),
     118                        if ismember('GiaAnalysis',analyses),
    119119                                md = checkfield(md,'fieldname','materials.lithosphere_shear_modulus','>',0,'numel',1);
    120120                                md = checkfield(md,'fieldname','materials.lithosphere_density','>',0,'numel',1);
    … …  
    122122                                md = checkfield(md,'fieldname','materials.mantle_density','>',0,'numel',1);
    123123                        end
    124                         if ismember(SealevelriseAnalysisEnum(),analyses),
     124                        if ismember('SealevelriseAnalysis',analyses),
    125125                                md = checkfield(md,'fieldname','materials.earth_density','>',0,'numel',1);
    126126                        end

  • issm/trunk-jpl/src/m/classes/matdamageice.py

    r20947 r21049  
    11from fielddisplay import fielddisplay
    22from project3d import project3d
    3 from EnumDefinitions import MaterialsEnum, MatdamageiceEnum, MaterialsRheologyLawEnum, MaterialsRhoSeawaterEnum
    4 from StringToEnum import StringToEnum
    53from checkfield import checkfield
    64from WriteData import WriteData

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

    r20967 r21049  
    126126                        md = checkfield(md,'fieldname','materials.rheology_law','values',{'None' 'Cuffey' 'CuffeyTemperate' 'Paterson' 'Arrhenius' 'LliboutryDuval'});
    127127
    128                         if ismember(GiaAnalysisEnum(),analyses),
     128                        if ismember('GiaAnalysis',analyses),
    129129                                md = checkfield(md,'fieldname','materials.lithosphere_shear_modulus','>',0,'numel',1);
    130130                                md = checkfield(md,'fieldname','materials.lithosphere_density','>',0,'numel',1);
    … …  
    132132                                md = checkfield(md,'fieldname','materials.mantle_density','>',0,'numel',1);
    133133                        end
    134                         if ismember(SealevelriseAnalysisEnum(),analyses),
     134                        if ismember('SealevelriseAnalysis',analyses),
    135135                                md = checkfield(md,'fieldname','materials.earth_density','>',0,'numel',1);
    136136                        end

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

    r20947 r21049  
    116116                        md = checkfield(md,'fieldname','materials.rheology_law','values',{'None' 'Cuffey' 'CuffeyTemperate' 'Paterson' 'Arrhenius' 'LliboutryDuval'});
    117117
    118                         if ismember(GiaAnalysisEnum(),analyses),
     118                        if ismember('GiaAnalysis',analyses),
    119119                                md = checkfield(md,'fieldname','materials.lithosphere_shear_modulus','>',0,'numel',1);
    120120                                md = checkfield(md,'fieldname','materials.lithosphere_density','>',0,'numel',1);
    … …  
    122122                                md = checkfield(md,'fieldname','materials.mantle_density','>',0,'numel',1);
    123123                        end
    124                         if ismember(SealevelriseAnalysisEnum(),analyses),
     124                        if ismember('SealevelriseAnalysis',analyses),
    125125                                md = checkfield(md,'fieldname','materials.earth_density','>',0,'numel',1);
    126126                        end

  • issm/trunk-jpl/src/m/classes/matice.py

    r20947 r21049  
    11from fielddisplay import fielddisplay
    22from project3d import project3d
    3 from EnumDefinitions import *
    4 from StringToEnum import StringToEnum
    53from checkfield import checkfield
    64from WriteData import WriteData

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

    r20969 r21049  
    9393                        md = checkfield(md,'fieldname','mesh.segments','NaN',1,'Inf',1,'>',0,'size',[NaN 3]);
    9494
    95                         switch(solution),
    96                                 case ThermalSolutionEnum(),
     95                        if strcmp(solution,'ThermalSolution')
    9796                                        md = checkmessage(md,'thermal not supported for 2d mesh');
    9897                        end

  • issm/trunk-jpl/src/m/classes/mesh2d.py

    r20969 r21049  
    11import numpy
    22from fielddisplay import fielddisplay
    3 from EnumDefinitions import *
    43from checkfield import checkfield
    54import MatlabFuncs as m
    … …  
    9392                md = checkfield(md,'fieldname','mesh.numberofvertices','>',0)
    9493                md = checkfield(md,'fieldname','mesh.average_vertex_connectivity','>=',9,'message',"'mesh.average_vertex_connectivity' should be at least 9 in 2d")
    95                 if solution==ThermalSolutionEnum():
     94                if solution=='ThermalSolution':
    9695                        md.checkmessage("thermal not supported for 2d mesh")
    9796

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

    r20970 r21049  
    9393                        md = checkfield(md,'fieldname','mesh.average_vertex_connectivity','>=',9,'message','''mesh.average_vertex_connectivity'' should be at least 9 in 2d');
    9494
    95                         switch(solution),
    96                                 case ThermalSolutionEnum(),
    97                                         md = checkmessage(md,'thermal not supported for 2d mesh');
     95                        if strcmp(solution,'ThermalSolution')
     96                                md = checkmessage(md,'thermal not supported for 2d mesh');
    9897                        end
    9998                end % }}}

  • issm/trunk-jpl/src/m/classes/mesh3dprisms.py

    r20970 r21049  
    11import numpy
    22from fielddisplay import fielddisplay
    3 from EnumDefinitions import *
    43from checkfield import *
    54import MatlabFuncs as m

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

    r20970 r21049  
    9696                        md = checkfield(md,'fieldname','mesh.average_vertex_connectivity','>=',9,'message','''mesh.average_vertex_connectivity'' should be at least 9 in 2d');
    9797
    98                         switch(solution),
    99                                 case ThermalSolutionEnum(),
    100                                         md = checkmessage(md,'thermal not supported for 2d mesh');
     98                        if strcmp(solution,'ThermalSolution')
     99                                md = checkmessage(md,'thermal not supported for 2d mesh');
    101100                        end
    102101                end % }}}

  • issm/trunk-jpl/src/m/classes/mesh3dsurface.py

    r20970 r21049  
    11from MatlabFuncs import *
    22from model import *
    3 from EnumDefinitions import *
    43from numpy import *
    54from fielddisplay import fielddisplay
    … …  
    125124                md = checkfield(md,'fieldname','mesh.average_vertex_connectivity','>=',9,'message','"mesh.average_vertex_connectivity" should be at least 9 in 2d')
    126125
    127                 if (solution==ThermalSolutionEnum()):
     126                if (solution=='ThermalSolution'):
    128127                        md = checkmessage(md,'thermal not supported for 2d mesh');
    129128                       

  • issm/trunk-jpl/src/m/classes/miscellaneous.py

    r20690 r21049  
    11from collections import OrderedDict
    22from fielddisplay import fielddisplay
    3 from EnumDefinitions import *
    43from checkfield import checkfield
    54from WriteData import WriteData

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

    r20902 r21049  
    44%      misfit=misfit();
    55%      misfit=misfit('name','SurfaceAltimetry',...
    6 %                    'definitionenum',Outputdefinition1Enum, 'model_enum',SurfaceEnum,...
    7 %                    'observation_enum',SurfaceObservationsEnum,...
     6%                    'definitionstring','Outputdefinition1',...
     7%                                                       'model_string','Surface',...
     8%                    'observation_string','SurfaceObservations',...
    89%                    'observation',md.geometry.surface,...
    910%                    'timeinterpolation','nearestneighbor',...
    1011%                    'local',1,...
    1112%                    'weights',ones(md.mesh.numberofvertices,1),...
    12 %                    'weights_enum',WeightsSurfaceObservationsEnum);
     13%                    'weights_string','WeightsSurfaceObservations');
    1314%
    1415%
    … …  
    1718        properties (SetAccess=public)
    1819                %misfit
    19                 name              = '';
    20                 definitionenum   = NaN; %enum that identifies this output definition uniquely, from Outputdefinition[1-10]Enum
    21                 model_enum        = NaN; %enum for field that is modeled
    22                 observation       = NaN; %observed field that we compare the model against
    23                 observation_enum  = NaN; %enum for observed field.
    24                 timeinterpolation = '';
    25                 local             = 1;
    26                 weights           = NaN; %weight coefficients for every vertex
    27                 weights_enum      = NaN; %enum to identify this particular set of weights
    28                 cumulated         = NaN; %do we cumulate misfit through time?
     20                name                                            = '';
     21                definitionstring                = ''; %string that identifies this output definition uniquely, from 'Outputdefinition[1-10]'
     22                model_string                    = ''; %string for field that is modeled
     23                observation                             = NaN; %observed field that we compare the model against
     24                observation_string      = ''; %string for observed field.
     25                timeinterpolation               = '';
     26                local                                           = 1;
     27                weights                                 = NaN; %weight coefficients for every vertex
     28                weights_string                  = ''; %string to identify this particular set of weights
     29                cumulated                               = NaN; %do we cumulate misfit through time?
    2930        end
    3031       
    … …  
    3940                                %get name
    4041                                self.name=getfieldvalue(options,'name','');
    41                                 self.definitionenum=getfieldvalue(options,'definitionenum');
    42                                 self.model_enum=getfieldvalue(options,'model_enum');
     42                                self.definitionstring=getfieldvalue(options,'definitionstring');
     43                                self.model_string=getfieldvalue(options,'model_string');
    4344                                self.observation=getfieldvalue(options,'observation',NaN);
    44                                 self.observation_enum=getfieldvalue(options,'observation_enum');
     45                                self.observation_string=getfieldvalue(options,'observation_string');
    4546                                self.local=getfieldvalue(options,'local',1);
    4647                                self.timeinterpolation=getfieldvalue(options,'timeinterpolation','nearestneighbor');
    4748                                self.weights=getfieldvalue(options,'weights',NaN);
    48                                 self.weights_enum=getfieldvalue(options,'weights_enum',NaN);
     49                                self.weights_string=getfieldvalue(options,'weights_string','');
    4950
    5051                        end
    … …  
    5960                                error('misfit error message: ''name'' field should be a string!');
    6061                        end
    61                         md = checkfield(md,'fieldname','self.definitionenum','field',self.definitionenum,'values',[Outputdefinition1Enum:Outputdefinition100Enum]);
     62                        OutputdefinitionStringArray={};
     63                        for i=1:100
     64                                OutputdefinitionStringArray{i}=strcat('Outputdefinition',num2str(i));
     65                        end
     66                        md = checkfield(md,'fieldname','self.definitionstring','field',self.definitionstring,'values',OutputdefinitionStringArray);
    6267
    6368                        if ~ischar(self.timeinterpolation),
    … …  
    7479
    7580                        fielddisplay(self,'name','identifier for this misfit response');
    76                         fielddisplay(self,'definitionenum','enum that identifies this output definition uniquely, from Outputdefinition[1-10]Enum');
    77                         fielddisplay(self,'model_enum','enum for field that is modeled');
     81                        fielddisplay(self,'definitionstring','string that identifies this output definition uniquely, from ''Outputdefinition[1-10]''');
     82                        fielddisplay(self,'model_string','string for field that is modeled');
    7883                        fielddisplay(self,'observation','observed field that we compare the model against');
    79                         fielddisplay(self,'observation_enum','observation enum');
     84                        fielddisplay(self,'observation_string','observation string');
    8085                        fielddisplay(self,'local','is the response local to the elements, or global? (default is 1)''');
    8186                        fielddisplay(self,'timeinterpolation','interpolation routine used to interpolate misfit between two time steps (default is ''nearestneighbor''');
    8287                        fielddisplay(self,'weights','weights (at vertices) to apply to the misfit');
    83                         fielddisplay(self,'weights_enum','enum for weights for identification purposes');
     88                        fielddisplay(self,'weights_string','string for weights for identification purposes');
    8489
    8590                end % }}}
    … …  
    8792
    8893                WriteData(fid,prefix,'data',self.name,'name','md.misfit.name','format','String');
    89                 WriteData(fid,prefix,'data',self.definitionenum,'name','md.misfit.definitionenum','format','Integer');
    90                 WriteData(fid,prefix,'data',self.model_enum,'name','md.misfit.model_enum','format','Integer');
     94                WriteData(fid,prefix,'data',self.definitionstring,'name','md.misfit.definitionstring','format','String');
     95                WriteData(fid,prefix,'data',self.model_string,'name','md.misfit.model_string','format','String');
    9196                WriteData(fid,prefix,'data',self.observation,'name','md.misfit.observation','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1,'yts',md.constants.yts);
    92                 WriteData(fid,prefix,'data',self.observation_enum,'name','md.misfit.observation_enum','format','Integer');
     97                WriteData(fid,prefix,'data',self.observation_string,'name','md.misfit.observation_string','format','String');
    9398                WriteData(fid,prefix,'data',self.local,'name','md.misfit.local','format','Integer');
    9499                WriteData(fid,prefix,'data',self.timeinterpolation,'name','md.misfit.timeinterpolation','format','String');
    95100                WriteData(fid,prefix,'data',self.weights,'name','md.misfit.weights','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1,'yts',md.constants.yts);
    96                 WriteData(fid,prefix,'data',self.weights_enum,'name','md.misfit.weights_enum','format','Integer');
     101                WriteData(fid,prefix,'data',self.weights_string,'name','md.misfit.weights_string','format','String');
    97102
    98103                end % }}}

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

    r20916 r21049  
    4545                function md = checkconsistency(self,md,solution,analyses) % {{{
    4646
    47                         if ismember(MasstransportAnalysisEnum(),analyses) & ~(solution==TransientSolutionEnum() & md.transient.ismasstransport==0),
     47                        if ismember('MasstransportAnalysis',analyses) & ~(strcmp(solution,'TransientSolution') & md.transient.ismasstransport==0),
    4848                                md = checkfield(md,'fieldname','basalforcings.groundedice_melting_rate','NaN',1,'Inf',1,'timeseries',1);
    4949                                md = checkfield(md,'fieldname','basalforcings.meltrate_factor','>=',0,'numel',1);
    … …  
    5151                                md = checkfield(md,'fieldname','basalforcings.upperdepth_melt','<=',0,'numel',1);
    5252                        end
    53                         if ismember(BalancethicknessAnalysisEnum(),analyses),
     53                        if ismember('BalancethicknessAnalysis',analyses),
    5454                                md = checkfield(md,'fieldname','basalforcings.groundedice_melting_rate','NaN',1,'Inf',1,'size',[md.mesh.numberofvertices 1]);
    5555                                md = checkfield(md,'fieldname','basalforcings.meltrate_factor','>=',0,'numel',1);
    … …  
    5757                                md = checkfield(md,'fieldname','basalforcings.upperdepth_melt','<=',0,'numel',1);
    5858                        end
    59                         if ismember(ThermalAnalysisEnum(),analyses) & ~(solution==TransientSolutionEnum() & md.transient.isthermal==0),
     59                        if ismember('ThermalAnalysis',analyses) & ~(strcmp(solution,'TransientSolution') & md.transient.isthermal==0),
    6060                                md = checkfield(md,'fieldname','basalforcings.groundedice_melting_rate','NaN',1,'Inf',1,'timeseries',1);
    6161                                md = checkfield(md,'fieldname','basalforcings.meltrate_factor','>=',0,'numel',1);

  • issm/trunk-jpl/src/m/classes/mismipbasalforcings.py

    r20916 r21049  
    11from fielddisplay import fielddisplay
    2 from EnumDefinitions import *
    32from checkfield import checkfield
    43from WriteData import WriteData
    … …  
    5554
    5655        #Early return
    57         if MasstransportAnalysisEnum() in analyses and not (solution==TransientSolutionEnum() and md.transient.ismasstransport==0):
     56        if 'MasstransportAnalysis' in analyses and not (solution=='TransientSolution' and md.transient.ismasstransport==0):
    5857
    5958            md = checkfield(md,'fieldname','basalforcings.groundedice_melting_rate','NaN',1,'Inf',1,'timeseries',1)
    … …  
    6261            md = checkfield(md,'fieldname','basalforcings.upperdepth_melt','<=',0,'numel',[1])
    6362
    64         if BalancethicknessAnalysisEnum() in analyses:
     63        if 'BalancethicknessAnalysis' in analyses:
    6564
    6665            md = checkfield(md,'fieldname','basalforcings.groundedice_melting_rate','NaN',1,'Inf',1,'size',[md.mesh.numberofvertices])
    … …  
    6968            md = checkfield(md,'fieldname','basalforcings.upperdepth_melt','<=',0,'numel',[1])
    7069
    71         if ThermalAnalysisEnum() in analyses and not (solution==TransientSolutionEnum() and md.transient.isthermal==0):
     70        if 'ThermalAnalysis' in analyses and not (solution=='TransientSolution' and md.transient.isthermal==0):
    7271
    7372            md = checkfield(md,'fieldname','basalforcings.groundedice_melting_rate','NaN',1,'Inf',1,'timeseries',1)

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

    r20690 r21049  
    44%      nodalvalue=nodalvalue();
    55%      nodalvalue=nodalvalue('name','SealevelriseSNodalValue',...
    6 %                    'definitionenum',Outputdefinition1Enum,
    7 %                    'model_enum',SealevelriseSEnum,...
     6%                    'definitionstring','Outputdefinition1',
     7%                    'model_string','SealevelriseS',
    88%                    'node',1);
    99
    … …  
    1212                %nodalvalue
    1313                name              = '';
    14                 definitionenum   = NaN; %enum that identifies this output definition uniquely, from Outputdefinition[1-10]Enum
    15                 model_enum       = NaN; %enum for field that is being retrieved
     14                definitionstring   = ''; %string that identifies this output definition uniquely, from 'Outputdefinition[1-10]'
     15                model_string      = ''; %string for field that is being retrieved
    1616                node             = NaN; %for which node are we retrieving the value?
    1717        end
    … …  
    2727                                %get name
    2828                                self.name=getfieldvalue(options,'name','');
    29                                 self.definitionenum=getfieldvalue(options,'definitionenum');
    30                                 self.model_enum=getfieldvalue(options,'model_enum');
     29                                self.definitionstring=getfieldvalue(options,'definitionstring');
     30                                self.model_string=getfieldvalue(options,'model_string');
    3131                                self.node=getfieldvalue(options,'node',NaN);
    3232
    … …  
    4040                                error('nodalvalue error message: ''name'' field should be a string!');
    4141                        end
    42                         md = checkfield(md,'fieldname','self.definitionenum','field',self.definitionenum,'values',[Outputdefinition1Enum:Outputdefinition100Enum]);
    43 
     42                        OutputdefinitionStringArray={};
     43                        for i=1:100
     44                                OutputdefinitionStringArray{i}=strcat('Outputdefinition',num2str(i));
     45                        end
     46                        md = checkfield(md,'fieldname','self.definitionstring','field',self.definitionstring,'values',OutputdefinitionStringArray);
    4447                        md = checkfield(md,'fieldname','self.node','field',self.node,'values',[1:md.mesh.numberofvertices]);
    4548
    … …  
    5053
    5154                        fielddisplay(self,'name','identifier for this nodalvalue response');
    52                         fielddisplay(self,'definitionenum','enum that identifies this output definition uniquely, from Outputdefinition[1-10]Enum');
    53                         fielddisplay(self,'model_enum','enum for field that is being retrieved');
     55                        fielddisplay(self,'definitionstring','string that identifies this output definition uniquely, from ''Outputdefinition[1-10]''');
     56                        fielddisplay(self,'model_string','string for field that is being retrieved');
    5457                        fielddisplay(self,'node','vertex index at which we retrieve the value');
    5558
    … …  
    5861
    5962                WriteData(fid,prefix,'object',self,'fieldname','name','format','String');
    60                 WriteData(fid,prefix,'object',self,'fieldname','definitionenum','format','Integer');
    61                 WriteData(fid,prefix,'object',self,'fieldname','model_enum','format','Integer');
     63                WriteData(fid,prefix,'object',self,'fieldname','definitionstring','format','String');
     64                WriteData(fid,prefix,'object',self,'fieldname','model_string','format','String');
    6265                WriteData(fid,prefix,'object',self,'fieldname','node','format','Integer');
    6366

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

    r20690 r21049  
    3737                end % }}}
    3838                function marshall(self,prefix,md,fid) % {{{
    39 
     39                %{
    4040                enums=zeros(length(self.definitions),1);
    4141                for i=1:length(self.definitions),
    … …  
    4545                        enums(i)=StringToEnum(classdefinition);
    4646                end
    47                 enums=unique(enums);
    48                
    4947                WriteData(fid,prefix,'data',enums,'name','md.outputdefinition.list','format','DoubleMat','mattype',1);
     48                %}
     49                data={};
     50                for i=1:length(self.definitions)
     51                        self.definitions{i}.marshall(prefix,md,fid);
     52                        classdefinition=class(self.definitions{i});
     53                        classdefinition(1)=upper(classdefinition(1));
     54                        data{i}=classdefinition;
     55                end
     56                data_unique=unique(data);
     57                WriteData(fid,prefix,'data',data_unique,'name','md.outputdefinition.list','format','StringArray');
    5058                end % }}}
    5159                function savemodeljs(self,fid,modelname) % {{{

  • issm/trunk-jpl/src/m/classes/outputdefinition.py

    r20690 r21049  
    11from fielddisplay import fielddisplay
    2 from EnumDefinitions import *
    3 from StringToEnum import StringToEnum
    42from checkfield import checkfield
    53from WriteData import WriteData
    … …  
    3533        # }}}
    3634        def marshall(self,prefix,md,fid):    # {{{
    37                
    38                 enums=npy.zeros(len(self.definitions),)
    39                
     35                data=[];
    4036                for i in range(len(self.definitions)):
    4137                        self.definitions[i].marshall(prefix,md,fid);
    42                         classdefinition=self.definitions[i].__class__.__name__
     38                        classdefinition=self.definitions[i].__class__.__name__;
    4339                        classdefinition=classdefinition[0].upper()+classdefinition[1:]
    44                         enums[i]=StringToEnum(classdefinition)[0]
    45                
    46                 enums=npy.unique(enums);
    47                
    48                 WriteData(fid,prefix,'data',enums,'name','md.outputdefinition.list','format','DoubleMat','mattype',1);
     40                        data.append(classdefinition)
     41
     42                data=npy.unique(data);
     43                WriteData(fid,prefix,'data',data,'name','md.outputdefinition.list','format','StringArray');
    4944        # }}}

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

    r20916 r21049  
    6666                function md = checkconsistency(self,md,solution,analyses) % {{{
    6767
    68                         if ismember(MasstransportAnalysisEnum(),analyses) & ~(solution==TransientSolutionEnum() & md.transient.ismasstransport==0),
     68                        if ismember('MasstransportAnalysis',analyses) & ~(strcmp(solution,'TransientSolution') & md.transient.ismasstransport==0),
    6969                                md = checkfield(md,'fieldname','basalforcings.groundedice_melting_rate','NaN',1,'timeseries',1);
    7070                                md = checkfield(md,'fieldname','basalforcings.floatingice_melting_rate','NaN',1,'timeseries',1);
    7171                        end
    72                         if ismember(BalancethicknessAnalysisEnum(),analyses),
     72                        if ismember('BalancethicknessAnalysis',analyses),
    7373                                md = checkfield(md,'fieldname','basalforcings.groundedice_melting_rate','NaN',1,'size',[md.mesh.numberofvertices 1]);
    7474                                md = checkfield(md,'fieldname','basalforcings.floatingice_melting_rate','NaN',1,'size',[md.mesh.numberofvertices 1]);
    7575                        end
    76                         if ismember(ThermalAnalysisEnum(),analyses) & ~(solution==TransientSolutionEnum() & md.transient.isthermal==0),
     76                        if ismember('ThermalAnalysis',analyses) & ~(strcmp(solution,'TransientSolution') & md.transient.isthermal==0),
    7777                                md = checkfield(md,'fieldname','basalforcings.groundedice_melting_rate','NaN',1,'timeseries',1);
    7878                                md = checkfield(md,'fieldname','basalforcings.floatingice_melting_rate','NaN',1,'timeseries',1);

  • issm/trunk-jpl/src/m/classes/private.py

    r17497 r21049  
    11from collections import OrderedDict
    22from fielddisplay import fielddisplay
    3 from EnumDefinitions import *
    43from checkfield import checkfield
    54

  • issm/trunk-jpl/src/m/classes/qmu.py

    r20690 r21049  
    33from collections import OrderedDict
    44from fielddisplay import fielddisplay
    5 from EnumDefinitions import *
    65from checkfield import checkfield
    76from WriteData import WriteData

  • issm/trunk-jpl/src/m/classes/results.py

    r20690 r21049  
    33from fielddisplay import fielddisplay
    44import MatlabFuncs as m
    5 from EnumDefinitions import *
    65
    76class results(object):

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

    r20690 r21049  
    3939                                end
    4040                                for i=1:numrifts,
    41                                         md = checkfield(md,'fieldname',sprintf('rifts.riftstruct(%d).fill',i),'values',[WaterEnum() AirEnum() IceEnum() MelangeEnum()]);
     41                                        md = checkfield(md,'fieldname',sprintf('rifts.riftstruct(%d).fill',i),'values',{'Air','Ice','Melange','Water'});
    4242                                end
    4343                        else
    … …  
    6262                                numrifts=numel(self.riftstruct);
    6363                        end
     64
    6465                        numpairs=0;
    6566                        for i=1:numrifts,
    6667                                numpairs=numpairs+size(self.riftstruct(i).penaltypairs,1);
     68                        end
     69                       
     70                        for i=1:numrifts
     71                                if (strcmpi(self.riftstruct(i).fill,'Air'))
     72                                        self.riftstruct(i).fill = 0;
     73                                elseif (strcmpi(self.riftstruct(i).fill,'Ice'))
     74                                        self.riftstruct(i).fill = 1;
     75                                elseif (strcmpi(self.riftstruct(i).fill,'Melange'))
     76                                        self.riftstruct(i).fill = 2;
     77                                elseif (strcmpi(self.riftstruct(i).fill,'Water'))
     78                                        self.riftstruct(i).fill = 3;
     79                                else
     80                                        error(['Could not convert string in riftstruct to integer for marshalling']);   
     81                                end
    6782                        end
    6883

  • issm/trunk-jpl/src/m/classes/rifts.py

    r20690 r21049  
    11import numpy
    22from fielddisplay import fielddisplay
    3 from EnumDefinitions import *
    43from checkfield import checkfield
    54from WriteData import WriteData
    … …  
    4847                                md.checkmessage("model should be processed for rifts (run meshprocessrifts)!")
    4948                        for i,rift in enumerate(self.riftstruct):
    50                                 md = checkfield(md,'fieldname',"rifts.riftstruct[%d]['fill']" % i,'values',[WaterEnum(),AirEnum(),IceEnum(),MelangeEnum()])
     49                                md = checkfield(md,'fieldname',"rifts.riftstruct[%d]['fill']" % i,'values',['Water','Air','Ice','Melange'])
    5150                else:
    5251                        if self.riftstruct and numpy.any(numpy.logical_not(isnans(self.riftstruct))):
    … …  
    6766                        numpairs+=numpy.size(rift['penaltypairs'],axis=0)
    6867
     68                # Convert strings in riftstruct to hard coded numbers
     69                for i,rift in enumerate(self.riftstruct):
     70                        if rift['fill'] == 'Air':
     71                                rift['fill'] = 0;
     72                        elif rift['fill'] == 'Ice':
     73                                rift['fill'] = 1;
     74                        elif rift['fill'] == 'Melange':
     75                                rift['fill'] = 2;
     76                        elif rift['fill'] == 'Water':
     77                                rift['fill'] = 3;
     78                        else:
     79                                error('Could not convert strings in riftstruct to integers for marshalling')
     80
    6981                # 2 for nodes + 2 for elements+ 2 for  normals + 1 for length + 1 for fill + 1 for friction + 1 for fraction + 1 for fractionincrement + 1 for state.
    7082                data=numpy.zeros((numpairs,12))

  • issm/trunk-jpl/src/m/classes/settings.py

    r20690 r21049  
    11from fielddisplay import fielddisplay
    2 from EnumDefinitions import *
    32from checkfield import checkfield
    43from WriteData import WriteData

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

    r21000 r21049  
    6262                function md = checkconsistency(self,md,solution,analyses) % {{{
    6363
    64                         if ~ismember(SealevelriseAnalysisEnum(),analyses), return; end
     64                        if ~ismember('SealevelriseAnalysis',analyses), return; end
    6565                        md = checkfield(md,'fieldname','slr.deltathickness','NaN',1,'Inf',1,'size',[md.mesh.numberofelements 1]);
    6666                        md = checkfield(md,'fieldname','slr.sealevel','NaN',1,'Inf',1,'size',[md.mesh.numberofvertices 1]);

  • issm/trunk-jpl/src/m/classes/slr.py

    r21000 r21049  
    22from MatlabFuncs import *
    33from model import *
    4 from EnumDefinitions import *
    54from numpy import *
    65from checkfield import checkfield
    … …  
    9089
    9190                #Early return
    92                 if (solution!=SealevelriseAnalysisEnum()):
     91                if (solution!='SealevelriseAnalysis'):
    9392                        return md
    9493

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

    r20690 r21049  
    3737
    3838                        %Early return
    39                         if solution~=SteadystateSolutionEnum(), return; end;
     39                        if ~strcmp(solution,'SteadystateSolution'), return; end;
    4040
    4141                        if md.timestepping.time_step~=0,

  • issm/trunk-jpl/src/m/classes/steadystate.py

    r20690 r21049  
    11import numpy
    22from fielddisplay import fielddisplay
    3 from EnumDefinitions import *
    43from checkfield import checkfield
    54from WriteData import WriteData
    … …  
    4948
    5049                #Early return
    51                 if not solution==SteadystateSolutionEnum():
     50                if not solution=='SteadystateSolution':
    5251                        return md
    5352

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

    r20902 r21049  
    8888
    8989                        %Early return
    90                         if ~ismember(StressbalanceAnalysisEnum(),analyses), return; end
    91                         if (solution==TransientSolutionEnum & md.transient.isstressbalance == 0), return; end
     90                        if ~ismember('StressbalanceAnalysis',analyses), return; end
     91                        if (strcmp(solution,'TransientSolution') & md.transient.isstressbalance == 0), return; end
    9292
    9393                        md = checkfield(md,'fieldname','stressbalance.spcvx','Inf',1,'timeseries',1);

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

    r20902 r21049  
    44from project3d import project3d
    55from fielddisplay import fielddisplay
    6 from EnumDefinitions import *
    76from checkfield import checkfield
    87from WriteData import WriteData
    … …  
    130129
    131130                #Early return
    132                 if StressbalanceAnalysisEnum() not in analyses:
     131                if 'StressbalanceAnalysis' not in analyses:
    133132                        return md
    134133

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

    r20896 r21049  
    117117                        md = checkfield(md,'fieldname','inversion.max_parameters','size',[md.mesh.numberofvertices num_controls]);
    118118
    119                         if solution==BalancethicknessSolutionEnum()
     119                        if strcmp(solution,'BalancethicknessSolution')
    120120                                md = checkfield(md,'fieldname','inversion.thickness_obs','size',[md.mesh.numberofvertices 1],'NaN',1,'Inf',1);
    121                         elseif solution==BalancethicknessSoftSolutionEnum()
     121                        elseif strcmp(solution,'BalancethicknessSoftSolution')
    122122                                md = checkfield(md,'fieldname','inversion.thickness_obs','size',[md.mesh.numberofvertices 1],'NaN',1,'Inf',1);
    123123                        else
    … …  
    192192                        num_cost_functions=size(self.cost_functions,2);
    193193                        data=marshallcostfunctions(self.cost_functions);
    194                         WriteData(fid,prefix,'data',data,'name','md.inversion.cost_functions','format','DoubleMat','mattype',3);
     194                        WriteData(fid,prefix,'data',data,'name','md.inversion.cost_functions','format','StringArray');
    195195                        WriteData(fid,prefix,'data',num_cost_functions,'name','md.inversion.num_cost_functions','format','Integer');
    196196                end % }}}

  • issm/trunk-jpl/src/m/classes/taoinversion.py

    r20910 r21049  
    55from fielddisplay import fielddisplay
    66from IssmConfig import IssmConfig
    7 from EnumDefinitions import *
    87from marshallcostfunctions import marshallcostfunctions
    98
    … …  
    155154
    156155
    157                 if solution==BalancethicknessSolutionEnum():
     156                if solution=='BalancethicknessSolution':
    158157                        md = checkfield(md,'fieldname','inversion.thickness_obs','size',[md.mesh.numberofvertices, 1],'NaN',1,'Inf',1)
    159                 elif solution==BalancethicknessSoftSolutionEnum():
     158                elif solution=='BalancethicknessSoftSolution':
    160159                        md = checkfield(md,'fieldname','inversion.thickness_obs','size',[md.mesh.numberofvertices, 1],'NaN',1,'Inf',1)
    161160                else:
    … …  
    196195                        num_cost_functions = numpy.size(self.cost_functions,2)
    197196                        data= marshallcostfunctions(self.cost_functions)
    198                         WriteData(fid,prefix,'data',data,'name','md.inversion.cost_functions','format','DoubleMat','mattype',3)
     197                        WriteData(fid,prefix,'data',data,'name','md.inversion.cost_functions','format','StringArray')
    199198                        WriteData(fid,prefix,'data',num_cost_functions,'name','md.inversion.num_cost_functions','format','Integer')

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

    r20902 r21049  
    7272
    7373                        %Early return
    74                         if (~ismember(ThermalAnalysisEnum(),analyses) & ~ismember(EnthalpyAnalysisEnum(),analyses)) | (solution==TransientSolutionEnum() & md.transient.isthermal==0), return; end
     74                        if (~ismember('ThermalAnalysis',analyses) & ~ismember('EnthalpyAnalysis',analyses)) | (strcmp(solution,'TransientSolution') & md.transient.isthermal==0), return; end
    7575
    7676                        md = checkfield(md,'fieldname','thermal.stabilization','numel',[1],'values',[0 1 2]);
    7777                        md = checkfield(md,'fieldname','thermal.spctemperature','Inf',1,'timeseries',1,'>=',0);
    78                         if (ismember(EnthalpyAnalysisEnum(),analyses) & md.thermal.isenthalpy & dimension(md.mesh)==3),
     78                        if (ismember('EnthalpyAnalysis',analyses) & md.thermal.isenthalpy & dimension(md.mesh)==3),
    7979
    8080                                %Make sure the spc are less than melting point

  • issm/trunk-jpl/src/m/classes/thermal.py

    r20991 r21049  
    22from project3d import project3d
    33from fielddisplay import fielddisplay
    4 from EnumDefinitions import *
    54from checkfield import checkfield
    65from WriteData import WriteData
    … …  
    9190
    9291                #Early return
    93                 if (ThermalAnalysisEnum() not in analyses and EnthalpyAnalysisEnum() not in analyses) or (solution==TransientSolutionEnum() and not md.transient.isthermal):
     92                if ('ThermalAnalysis' not in analyses and 'EnthalpyAnalysis' not in analyses) or (solution=='TransientSolution' and not md.transient.isthermal):
    9493                        return md
    9594
    9695                md = checkfield(md,'fieldname','thermal.stabilization','numel',[1],'values',[0,1,2])
    9796                md = checkfield(md,'fieldname','thermal.spctemperature','Inf',1,'timeseries',1)
    98                 if EnthalpyAnalysisEnum() in analyses and md.thermal.isenthalpy and md.mesh.dimension()==3:
     97                if 'EnthalpyAnalysis' in analyses and md.thermal.isenthalpy and md.mesh.dimension()==3:
    9998                        pos=numpy.nonzero(numpy.logical_not(numpy.isnan(md.thermal.spctemperature[0:md.mesh.numberofvertices])))
    10099                        replicate=numpy.tile(md.geometry.surface-md.mesh.z,(1,numpy.size(md.thermal.spctemperature,axis=1)))

  • issm/trunk-jpl/src/m/classes/timestepping.py

    r20896 r21049  
    11from fielddisplay import fielddisplay
    2 from EnumDefinitions import *
    32from checkfield import checkfield
    43from WriteData import WriteData

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

    r19879 r21049  
    2222                 function self = addoptions(self,analysis,varargin) % {{{
    2323                 % Usage example:
    24                  %    md.toolkits=addoptions(md.toolkits,StressbalanceAnalysisEnum(),FSoptions());
    25                  %    md.toolkits=addoptions(md.toolkits,StressbalanceAnalysisEnum());
    26 
    27                          %Convert analysis from enum to string
    28                          analysis=EnumToString(analysis);
     24                 %    md.toolkits=addoptions(md.toolkits,'StressbalanceAnalysis',FSoptions());
     25                 %    md.toolkits=addoptions(md.toolkits,'StressbalanceAnalysis');
    2926
    3027                         %Create dynamic property if property does not exist yet

  • issm/trunk-jpl/src/m/classes/toolkits.py

    r20913 r21049  
    22from mumpsoptions import mumpsoptions
    33from iluasmoptions import iluasmoptions
    4 from EnumToString import EnumToString
    54from fielddisplay import fielddisplay
    6 from EnumDefinitions import *
    75from checkfield import checkfield
    86from issmgslsolver import issmgslsolver
    … …  
    4442        def addoptions(self,analysis,*args):    # {{{
    4543                # Usage example:
    46                 #    md.toolkits=addoptions(md.toolkits,StressbalanceAnalysisEnum(),FSoptions());
    47                 #    md.toolkits=addoptions(md.toolkits,StressbalanceAnalysisEnum());
    48 
    49                 #Convert analysis from enum to string
    50                 analysis=EnumToString(analysis)[0]
     44                #    md.toolkits=addoptions(md.toolkits,'StressbalanceAnalysis',FSoptions());
     45                #    md.toolkits=addoptions(md.toolkits,'StressbalanceAnalysis');
    5146
    5247                #Create dynamic property if property does not exist yet

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

    r20690 r21049  
    7474
    7575                        %Early return
    76                         if solution~=TransientSolutionEnum(), return; end
     76                        if ~strcmp(solution,'TransientSolution'), return; end
    7777
    7878                        md = checkfield(md,'fieldname','transient.issmb','numel',[1],'values',[0 1]);

  • issm/trunk-jpl/src/m/classes/transient.py

    r20690 r21049  
    11from fielddisplay import fielddisplay
    2 from EnumDefinitions import *
    32from checkfield import checkfield
    43from WriteData import WriteData
    … …  
    9594
    9695                #Early return
    97                 if not solution==TransientSolutionEnum():
     96                if not solution=='TransientSolution':
    9897                        return md
    9998

  • issm/trunk-jpl/src/m/classes/verbose.py

    r20690 r21049  
    11from pairoptions import pairoptions
    22import MatlabFuncs as m
    3 from EnumDefinitions import *
    43from WriteData import WriteData
    54

  • issm/trunk-jpl/src/m/consistency/ismodelselfconsistent.m

    r20381 r21049  
    4444%      [analyses]=AnalysisConfiguration(solutiontype);
    4545
    46 switch solutiontype,
    47 
    48         case StressbalanceSolutionEnum(),
    49                 analyses=[StressbalanceAnalysisEnum();StressbalanceVerticalAnalysisEnum();StressbalanceSIAAnalysisEnum();L2ProjectionBaseAnalysisEnum()];
    50 
    51         case SteadystateSolutionEnum(),
    52                 analyses=[StressbalanceAnalysisEnum();StressbalanceVerticalAnalysisEnum();StressbalanceSIAAnalysisEnum();L2ProjectionBaseAnalysisEnum();ThermalAnalysisEnum();MeltingAnalysisEnum();EnthalpyAnalysisEnum()];
    53 
    54         case ThermalSolutionEnum(),
    55                 analyses=[EnthalpyAnalysisEnum;ThermalAnalysisEnum();MeltingAnalysisEnum()];
    56 
    57         case MasstransportSolutionEnum(),
    58                 analyses=[MasstransportAnalysisEnum()];
    59 
    60         case BalancethicknessSolutionEnum(),
    61                 analyses=[BalancethicknessAnalysisEnum()];
    62 
    63         case Balancethickness2SolutionEnum(),
    64                 analyses=[Balancethickness2AnalysisEnum()];
    65 
    66         case BalancethicknessSoftSolutionEnum(),
    67                 analyses=[BalancethicknessAnalysisEnum()];
    68 
    69         case BalancevelocitySolutionEnum(),
    70                 analyses=[BalancevelocityAnalysisEnum()];
    71 
    72         case SurfaceSlopeSolutionEnum(),
    73                 analyses=[L2ProjectionBaseAnalysisEnum()];
    74 
    75         case BedSlopeSolutionEnum(),
    76                 analyses=[L2ProjectionBaseAnalysisEnum()];
    77 
    78         case GiaSolutionEnum(),
    79                 analyses=[GiaAnalysisEnum()];
    80 
    81         case TransientSolutionEnum(),
    82                 analyses=[StressbalanceAnalysisEnum();StressbalanceVerticalAnalysisEnum();StressbalanceSIAAnalysisEnum();L2ProjectionBaseAnalysisEnum();ThermalAnalysisEnum();MeltingAnalysisEnum();EnthalpyAnalysisEnum();MasstransportAnalysisEnum();HydrologySommersAnalysisEnum];
    83 
    84         case FlaimSolutionEnum(),
    85                 analyses=[FlaimAnalysisEnum()];
    86 
    87         case SealevelriseSolutionEnum(),
    88                 analyses=[SealevelriseAnalysisEnum()];
    89 
    90         case HydrologySolutionEnum(),
    91                 analyses=[L2ProjectionBaseAnalysisEnum();HydrologyShreveAnalysisEnum();HydrologyDCInefficientAnalysisEnum();HydrologyDCEfficientAnalysisEnum()];
    92        
    93         case DamageEvolutionSolutionEnum(),
    94                 analyses=[DamageEvolutionAnalysisEnum()];
    95 
    96         otherwise
    97                 error('%s%s%s',' solution type: ',EnumToString(solutiontype),' not supported yet!');
    98 
     46        if strcmp(solutiontype,'StressbalanceSolution')
     47                analyses={'StressbalanceAnalysis','StressbalanceVerticalAnalysis','StressbalanceSIAAnalysis','L2ProjectionBaseAnalysis'};
     48        elseif strcmp(solutiontype,'SteadystateSolution')
     49                analyses={'StressbalanceAnalysis','StressbalanceVerticalAnalysis','StressbalanceSIAAnalysis','L2ProjectionBaseAnalysis','ThermalAnalysis','MeltingAnalysis','EnthalpyAnalysis'};
     50        elseif strcmp(solutiontype,'ThermalSolution')
     51                analyses={'EnthalpyAnalysis','ThermalAnalysis','MeltingAnalysis'};
     52        elseif strcmp(solutiontype,'MasstransportSolution')
     53                analyses={'MasstransportAnalysis'};
     54        elseif strcmp(solutiontype,'BalancethicknessSolution')
     55                analyses={'BalancethicknessAnalysis'};
     56        elseif strcmp(solutiontype,'Balancethickness2Solution')
     57                analyses={'Balancethickness2Analysis'};
     58        elseif strcmp(solutiontype,'BalancethicknessSoftSolution')
     59                analyses={'BalancethicknessAnalysis'};
     60        elseif strcmp(solutiontype,'BalancevelocitySolution')
     61                analyses={'BalancevelocityAnalysis'};
     62        elseif strcmp(solutiontype,'SurfaceSlopeSolution')
     63                analyses={'L2ProjectionBaseAnalysis'};
     64        elseif strcmp(solutiontype,'BedSlopeSolution')
     65                analyses={'L2ProjectionBaseAnalysis'};
     66        elseif strcmp(solutiontype,'GiaSolution')
     67                analyses={'GiaAnalysis'};
     68        elseif strcmp(solutiontype,'TransientSolution')
     69                analyses={'StressbalanceAnalysis','StressbalanceVerticalAnalysis','StressbalanceSIAAnalysis','L2ProjectionBaseAnalysis','ThermalAnalysis','MeltingAnalysis','EnthalpyAnalysis','MasstransportAnalysis','HydrologySommersAnalysis'};
     70        elseif strcmp(solutiontype,'FlaimSolution')
     71                analyses={'FlaimAnalysis'};
     72        elseif strcmp(solutiontype,'SealevelriseSolution')
     73                analyses={'SealevelriseAnalysis'};
     74        elseif strcmp(solutiontype,'HydrologySolution')
     75                analyses={'L2ProjectionBaseAnalysis','HydrologyShreveAnalysis','HydrologyDCInefficientAnalysis','HydrologyDCEfficientAnalysis'};
     76        elseif strcmp(solutiontype,'DamageEvolutionSolution')
     77                analyses={'DamageEvolutionAnalysis'};
     78        else
     79                error(' solution type: %s' , solutiontype, ' not supported yet!');
    9980        end
    10081end % }}}

  • issm/trunk-jpl/src/m/consistency/ismodelselfconsistent.py

    r20913 r21049  
    1010        """
    1111
    12         if   solutiontype == StressbalanceSolutionEnum():
    13                 analyses=[StressbalanceAnalysisEnum(),StressbalanceVerticalAnalysisEnum(),StressbalanceSIAAnalysisEnum(),L2ProjectionBaseAnalysisEnum()]
     12        if   solutiontype == 'StressbalanceSolution':
     13                analyses=['StressbalanceAnalysis','StressbalanceVerticalAnalysis','StressbalanceSIAAnalysis','L2ProjectionBaseAnalysis']
    1414
    15         elif solutiontype == SteadystateSolutionEnum():
    16                 analyses=[StressbalanceAnalysisEnum(),StressbalanceVerticalAnalysisEnum(),StressbalanceSIAAnalysisEnum(),L2ProjectionBaseAnalysisEnum(),ThermalAnalysisEnum(),MeltingAnalysisEnum(),EnthalpyAnalysisEnum()]
     15        elif solutiontype == 'SteadystateSolution':
     16                analyses=['StressbalanceAnalysis','StressbalanceVerticalAnalysis','StressbalanceSIAAnalysis','L2ProjectionBaseAnalysis','ThermalAnalysis','MeltingAnalysis','EnthalpyAnalysis']
    1717
    18         elif solutiontype == ThermalSolutionEnum():
    19                 analyses=[EnthalpyAnalysisEnum(),ThermalAnalysisEnum(),MeltingAnalysisEnum()]
     18        elif solutiontype == 'ThermalSolution':
     19                analyses=['EnthalpyAnalysis','ThermalAnalysis','MeltingAnalysis']
    2020
    21         elif solutiontype == MasstransportSolutionEnum():
    22                 analyses=[MasstransportAnalysisEnum()]
     21        elif solutiontype == 'MasstransportSolution':
     22                analyses=['MasstransportAnalysis']
    2323
    24         elif solutiontype == BalancethicknessSolutionEnum():
    25                 analyses=[BalancethicknessAnalysisEnum()]
     24        elif solutiontype == 'BalancethicknessSolution':
     25                analyses=['BalancethicknessAnalysis']
    2626
    27         elif solutiontype == SurfaceSlopeSolutionEnum():
    28                 analyses=[L2ProjectionBaseAnalysisEnum()]
     27        elif solutiontype == 'SurfaceSlopeSolution':
     28                analyses=['L2ProjectionBaseAnalysis']
    2929
    30         elif solutiontype == BalancevelocitySolutionEnum():
    31                 analyses=[BalancevelocityAnalysisEnum()]
     30        elif solutiontype == 'BalancevelocitySolution':
     31                analyses=['BalancevelocityAnalysis']
    3232
    33         elif solutiontype == BedSlopeSolutionEnum():
    34                 analyses=[L2ProjectionBaseAnalysisEnum()]
     33        elif solutiontype == 'BedSlopeSolution':
     34                analyses=['L2ProjectionBaseAnalysis']
    3535
    36         elif solutiontype == GiaSolutionEnum():
    37                 analyses=[GiaAnalysisEnum()]
     36        elif solutiontype == 'GiaSolution':
     37                analyses=['GiaAnalysis']
    3838
    39         elif solutiontype == TransientSolutionEnum():
    40                 analyses=[StressbalanceAnalysisEnum(),StressbalanceVerticalAnalysisEnum(),StressbalanceSIAAnalysisEnum(),L2ProjectionBaseAnalysisEnum(),ThermalAnalysisEnum(),MeltingAnalysisEnum(),EnthalpyAnalysisEnum(),MasstransportAnalysisEnum()]
     39        elif solutiontype == 'TransientSolution':
     40                analyses=['StressbalanceAnalysis','StressbalanceVerticalAnalysis','StressbalanceSIAAnalysis','L2ProjectionBaseAnalysis','ThermalAnalysis','MeltingAnalysis','EnthalpyAnalysis','MasstransportAnalysis']
    4141
    42         elif solutiontype == FlaimSolutionEnum():
    43                 analyses=[FlaimAnalysisEnum()]
     42        elif solutiontype == 'FlaimSolution':
     43                analyses=['FlaimAnalysis']
    4444
    45         elif solutiontype == HydrologySolutionEnum():
    46                 analyses=[L2ProjectionBaseAnalysisEnum(),HydrologyShreveAnalysisEnum(),HydrologyDCInefficientAnalysisEnum(),HydrologyDCEfficientAnalysisEnum()]
     45        elif solutiontype == 'HydrologySolution':
     46                analyses=['L2ProjectionBaseAnalysis','HydrologyShreveAnalysis','HydrologyDCInefficientAnalysis','HydrologyDCEfficientAnalysis']
    4747
    48         elif DamageEvolutionSolutionEnum():
    49                 analyses=[DamageEvolutionAnalysisEnum()]
     48        elif 'DamageEvolutionSolution':
     49                analyses=['DamageEvolutionAnalysis']
    5050
    5151        else:
    52                 raise TypeError("solution type: '%s' not supported yet!" % EnumToString(solutiontype)[0])
     52                raise TypeError("solution type: '%s' not supported yet!" % solutiontype)
    5353
    5454        return analyses

  • issm/trunk-jpl/src/m/inversions/marshallcostfunctions.m

    r20016 r21049  
    11function data = marshallcostfunctions(cost_functions)
    2         pos=find(cost_functions==101); data(pos)=SurfaceAbsVelMisfitEnum();
    3         pos=find(cost_functions==102); data(pos)=SurfaceRelVelMisfitEnum();
    4         pos=find(cost_functions==103); data(pos)=SurfaceLogVelMisfitEnum();
    5         pos=find(cost_functions==104); data(pos)=SurfaceLogVxVyMisfitEnum();
    6         pos=find(cost_functions==105); data(pos)=SurfaceAverageVelMisfitEnum();
    7         pos=find(cost_functions==201); data(pos)=ThicknessAbsMisfitEnum();
    8         pos=find(cost_functions==501); data(pos)=DragCoefficientAbsGradientEnum();
    9         pos=find(cost_functions==502); data(pos)=RheologyBbarAbsGradientEnum();
    10         pos=find(cost_functions==503); data(pos)=ThicknessAbsGradientEnum();
    11         pos=find(cost_functions==504); data(pos)=ThicknessAlongGradientEnum();
    12         pos=find(cost_functions==505); data(pos)=ThicknessAcrossGradientEnum();
    13         pos=find(cost_functions==506); data(pos)=BalancethicknessMisfitEnum();
    14         pos=find(cost_functions==507); data(pos)=RheologyBAbsGradientEnum();
    15         pos=find(cost_functions==510); data(pos)=ThicknessPositiveEnum();
    16         pos=find(cost_functions==601); data(pos)=SurfaceAbsMisfitEnum();
     2        pos=find(cost_functions==101); data(pos) = {'SurfaceAbsVelMisfit'};
     3        pos=find(cost_functions==102); data(pos) = {'SurfaceRelVelMisfit'};
     4        pos=find(cost_functions==103); data(pos) = {'SurfaceLogVelMisfit'};
     5        pos=find(cost_functions==104); data(pos) = {'SurfaceLogVxVyMisfit'};
     6        pos=find(cost_functions==105); data(pos) = {'SurfaceAverageVelMisfit'};
     7        pos=find(cost_functions==201); data(pos) = {'ThicknessAbsMisfit'};
     8        pos=find(cost_functions==501); data(pos) = {'DragCoefficientAbsGradient'};
     9        pos=find(cost_functions==502); data(pos) = {'RheologyBbarAbsGradient'};
     10        pos=find(cost_functions==503); data(pos) = {'ThicknessAbsGradient'};
     11        pos=find(cost_functions==504); data(pos) = {'ThicknessAlongGradient'};
     12        pos=find(cost_functions==505); data(pos) = {'ThicknessAcrossGradient'};
     13        pos=find(cost_functions==506); data(pos) = {'BalancethicknessMisfit'};
     14        pos=find(cost_functions==507); data(pos) = {'RheologyBAbsGradient'};
     15        pos=find(cost_functions==510); data(pos) = {'ThicknessPositive'};
     16        pos=find(cost_functions==601); data(pos) = {'SurfaceAbsMisfit'};

  • issm/trunk-jpl/src/m/inversions/marshallcostfunctions.py

    r18994 r21049  
    11import copy
    2 from EnumDefinitions import *
    32
    43def marshallcostfunctions(cost_functions):
    … …  
    76        data=copy.deepcopy(cost_functions)
    87
    9         #convert to  Enums
     8        #convert to strings
    109        pos=[i for i,x in enumerate(cost_functions) if x==101];
    11         for i in pos: data[i]=SurfaceAbsVelMisfitEnum()       
     10        for i in pos: data[i]='SurfaceAbsVelMisfit'       
    1211        pos=[i for i,x in enumerate(cost_functions) if x==102];
    13         for i in pos: data[i]=SurfaceRelVelMisfitEnum()       
     12        for i in pos: data[i]='SurfaceRelVelMisfit'       
    1413        pos=[i for i,x in enumerate(cost_functions) if x==103];
    15         for i in pos: data[i]=SurfaceLogVelMisfitEnum()       
     14        for i in pos: data[i]='SurfaceLogVelMisfit'       
    1615        pos=[i for i,x in enumerate(cost_functions) if x==104];
    17         for i in pos: data[i]=SurfaceLogVxVyMisfitEnum()       
     16        for i in pos: data[i]='SurfaceLogVxVyMisfit'       
    1817        pos=[i for i,x in enumerate(cost_functions) if x==105];
    19         for i in pos: data[i]=SurfaceAverageVelMisfitEnum()   
     18        for i in pos: data[i]='SurfaceAverageVelMisfit'   
    2019        pos=[i for i,x in enumerate(cost_functions) if x==201];
    21         for i in pos: data[i]=ThicknessAbsMisfitEnum()         
     20        for i in pos: data[i]='ThicknessAbsMisfit'         
    2221        pos=[i for i,x in enumerate(cost_functions) if x==501];
    23         for i in pos: data[i]=DragCoefficientAbsGradientEnum()
     22        for i in pos: data[i]='DragCoefficientAbsGradient'
    2423        pos=[i for i,x in enumerate(cost_functions) if x==502];
    25         for i in pos: data[i]=RheologyBbarAbsGradientEnum()   
     24        for i in pos: data[i]='RheologyBbarAbsGradient'   
    2625        pos=[i for i,x in enumerate(cost_functions) if x==503];
    27         for i in pos: data[i]=ThicknessAbsGradientEnum()       
     26        for i in pos: data[i]='ThicknessAbsGradient'       
    2827        pos=[i for i,x in enumerate(cost_functions) if x==504];
    29         for i in pos: data[i]=ThicknessAlongGradientEnum()     
     28        for i in pos: data[i]='ThicknessAlongGradient'     
    3029        pos=[i for i,x in enumerate(cost_functions) if x==505];
    31         for i in pos: data[i]=ThicknessAcrossGradientEnum()   
     30        for i in pos: data[i]='ThicknessAcrossGradient'   
    3231
    3332        return data

  • issm/trunk-jpl/src/m/solve/WriteData.py

    r20898 r21049  
    205205                recordlength=4+4+8*s[0]*s[1]+4+4; #2 integers (32 bits) + the double matrix + code + matrix type
    206206                if recordlength > 2**31 :
    207                         raise ValueError('field %s cannot be marshalled because it is larger than 4^31 bytes!' % EnumToString(enum)[0])
     207                        raise ValueError('field %s cannot be marshalled because it is larger than 4^31 bytes!' % enum)
    208208
    209209                fid.write(struct.pack('i',recordlength))  #2 integers (32 bits) + the double matrix + code + matrix type
    … …  
    288288
    289289        else:    # {{{
    290                 raise TypeError('WriteData error message: data type: %d not supported yet! (%s)' % (format,EnumToString(enum)[0]))
     290                raise TypeError('WriteData error message: data type: %d not supported yet! (%s)' % (format,enum))
    291291        # }}}
    292292

  • issm/trunk-jpl/src/m/solve/solve.m

    r20120 r21049  
    1 function md=solve(md,solutionenum,varargin)
     1function md=solve(md,solutionstring,varargin)
    22%SOLVE - apply solution sequence for this model
    33%
    44%   Usage:
    5 %      md=solve(md,solutionenum,varargin)
     5%      md=solve(md,solutionstring,varargin)
    66%      where varargin is a lit of paired arguments of string OR enums
    77%
    88%   solution types available comprise:
    9 %                - StressbalanceSolutionEnum
    10 %                - MasstransportSolutionEnum
    11 %                - ThermalSolutionEnum
    12 %                - SteadystateSolutionEnum
    13 %                - TransientSolutionEnum
    14 %                - BalancethicknessSolutionEnum
    15 %                - BedSlopeSolutionEnum
    16 %                - SurfaceSlopeSolutionEnum
    17 %                - HydrologySolutionEnum
    18 %                - FlaimSolutionEnum
     9%                - 'StressbalanceSolution'              or 'sb'
     10%                - 'MasstransportSolution'              or 'mt'
     11%                - 'ThermalSolution'                            or 'th'
     12%                - 'SteadystateSolution'                or 'st'
     13%                - 'TransientSolution'                  or 'tr'
     14%                - 'BalancethicknessSolution' or 'mc'
     15%      - 'BalancevelocitySolution'      or 'bv'
     16%                - 'BedSlopeSolution'                   or 'bs'
     17%                - 'SurfaceSlopeSolution'               or 'ss'
     18%                - 'HydrologySolution'                  or 'hy'
     19%      - 'DamageEvolutionSolution'      or 'da'
    1920%
    2021%  extra options:
    … …  
    2526%
    2627%   Examples:
    27 %      md=solve(md,StressbalanceSolutionEnum);
     28%      md=solve(md,'StressbalanceSolution');
     29%                md=solve(md,'sb');
     30
     31if ~ischar(solutionstring)
     32        error('ISSM''s solve function only accepts strings for solution sequences. Type help solve to get a list of supported solutions');
     33end
    2834
    2935%recover and process solve options
    30 if ~strncmp(fliplr(EnumToString(solutionenum)),fliplr('Solution'),8),
    31         error(['solutionenum ' EnumToString(solutionenum) ' not supported!']);
     36if strcmpi(solutionstring,'sb') || strcmpi(solutionstring,'Stressbalance') || strcmpi(solutionstring, 'StressbalanceSolution')
     37        solutionstring = 'StressbalanceSolution';
     38elseif strcmpi(solutionstring,'mt') || strcmpi(solutionstring,'Masstransport') || strcmpi(solutionstring,'MasstransportSolution')
     39        solutionstring = 'MasstransportSolution';
     40elseif strcmpi(solutionstring,'th') || strcmpi(solutionstring,'Thermal') || strcmpi(solutionstring,'ThermalSolution')
     41        solutionstring = 'ThermalSolution';
     42elseif strcmpi(solutionstring,'st') || strcmpi(solutionstring,'Steadystate') || strcmpi(solutionstring,'SteadystateSolution')
     43        solutionstring = 'SteadystateSolution';
     44elseif strcmpi(solutionstring,'tr') || strcmpi(solutionstring,'Transient') || strcmpi(solutionstring,'TransientSolution')
     45        solutionstring = 'TransientSolution';
     46elseif strcmpi(solutionstring,'mc') || strcmpi(solutionstring,'Balancethickness') || strcmpi(solutionstring,'BalancethicknessSolution')
     47        solutionstring = 'BalancethicknessSolution';
     48elseif strcmpi(solutionstring,'bv') || strcmpi(solutionstring,'Balancevelocity') || strcmpi(solutionstring,'BalancevelocitySolution')
     49        solutionstring = 'BalancevelocitySolution';
     50elseif strcmpi(solutionstring,'bs') || strcmpi(solutionstring,'BedSlope') || strcmpi(solutionstring,'BedSlopeSolution')
     51        solutionstring = 'BedSlopeSolution';
     52elseif strcmpi(solutionstring,'ss') || strcmpi(solutionstring,'SurfaceSlope') || strcmpi(solutionstring,'SurfaceSlopeSolution')
     53        solutionstring = 'SurfaceSlopeSolution';
     54elseif strcmpi(solutionstring,'hy') || strcmpi(solutionstring,'Hydrology') || strcmpi(solutionstring,'HydrologySolution')
     55        solutionstring = 'HydrologySolution';
     56elseif strcmpi(solutionstring,'da') || strcmpi(solutionstring,'DamageEvolution') || strcmpi(solutionstring,'DamageEvolutionSolution')
     57        solutionstring = 'DamageEvolutionSolution';
     58else
     59        error(['solutionstring ' solutionstring ' not supported!']);
    3260end
    33 options=pairoptions(varargin{:},'solutionenum',solutionenum);
     61options=pairoptions(varargin{:},'solutionstring',solutionstring);
    3462
    3563%recover some fields
    36 md.private.solution=solutionenum;
     64md.private.solution=solutionstring;
    3765cluster=md.cluster;
    3866if strcmpi(getfieldvalue(options,'batch','no'),'yes') batch=1; else batch=0; end
    … …  
    4371                disp('checking model consistency');
    4472        end
    45         if (solutionenum == FlaimSolutionEnum())
     73        if (strcmp(solutionstring,'FlaimSolution'))
    4674                md.private.isconsistent=true;
    47                 md=checkconsistency(md.mesh,md,solutionenum);
    48                 md=checkconsistency(md.flaim,md,solutionenum);
     75                md=checkconsistency(md.mesh,md,solutionstring);
     76                md=checkconsistency(md.flaim,md,solutionstring);
    4977                if md.private.isconsistent==false,
    5078                        error('Model not consistent, see messages above');
    … …  
    78106
    79107%flaim analysis (To be removed?)
    80 if (solutionenum == FlaimSolutionEnum())
     108if (strcmp(solutionstring,'FlaimSolution'))
    81109        %fmdir     = getfieldvalue(options,'fmdir',['fm' num2str(feature('GetPid'))]);
    82110        %overwrite = getfieldvalue(options,'overwrite','n');
    … …  
    85113        %cmap      = getfieldvalue(options,'cmap',[]);
    86114        md=flaim_sol(md,options);
    87         md.private.solution=EnumToString(solutionenum);
     115        md.private.solution=solutionstring;
    88116        return;
    89117end

  • issm/trunk-jpl/src/m/solve/solve.py

    r20910 r21049  
    1111import MatlabFuncs as m
    1212
    13 def solve(md,solutionenum,*args):
     13def solve(md,solutionstring,*args):
    1414        """
    1515        SOLVE - apply solution sequence for this model
    1616 
    1717           Usage:
    18               md=solve(md,solutionenum,varargin)
     18              md=solve(md,solutionstring,varargin)
    1919              where varargin is a list of paired arguments of string OR enums
    2020 
    21            solution types available comprise:
    22               - StressbalanceSolutionEnum
    23               - MasstransportSolutionEnum
    24               - ThermalSolutionEnum
    25               - SteadystateSolutionEnum
    26               - TransientSolutionEnum
    27               - BalancethicknessSolutionEnum
    28               - BedSlopeSolutionEnum
    29               - SurfaceSlopeSolutionEnum
    30               - HydrologySolutionEnum
    31               - FlaimSolutionEnum
     21                solution types available comprise:
     22                 - 'StressbalanceSolution'              or 'sb'
     23                 - 'MasstransportSolution'              or 'mt'
     24                 - 'ThermalSolution'                            or 'th'
     25                 - 'SteadystateSolution'                or 'st'
     26                 - 'TransientSolution'                  or 'tr'
     27                 - 'BalancethicknessSolution' or 'mc'
     28                 - 'BalancevelocitySolution'    or 'bv'
     29                 - 'BedSlopeSolution'                   or 'bs'
     30                 - 'SurfaceSlopeSolution'               or 'ss'
     31                 - 'HydrologySolution'                  or 'hy'
     32                 - 'DamageEvolutionSolution'    or 'da'
     33
    3234 
    3335           extra options:
    … …  
    3739 
    3840           Examples:
    39               md=solve(md,StressbalanceSolutionEnum);
     41              md=solve(md,'StressbalanceSolution');
     42                        md=solve(md,'sb');
    4043        """
    4144
    4245        #recover and process solve options
    43         if EnumToString(solutionenum)[0][-8:] != 'Solution':
    44                 raise ValueError("solutionenum '%s' not supported!" % EnumToString(solutionenum)[0])
    45         options=pairoptions('solutionenum',solutionenum,*args)
     46        if solutionstring.lower() == 'sb' or solutionstring.lower() == 'stressbalance' or solutionstring.lower() == 'stressbalancesolution':
     47                solutionstring = 'StressbalanceSolution';
     48        elif solutionstring.lower() == 'mt' or solutionstring.lower() == 'masstransport' or solutionstring.lower() == 'masstransportsolution':
     49                solutionstring = 'MasstransportSolution';       
     50        elif solutionstring.lower() == 'th' or solutionstring.lower() == 'thermal' or solutionstring.lower() == 'thermalsolution':
     51                solutionstring = 'ThermalSolution';
     52        elif solutionstring.lower() == 'st' or solutionstring.lower() == 'steadystate' or solutionstring.lower() == 'steadystatesolution':
     53                solutionstring = 'SteadystateSolution';
     54        elif solutionstring.lower() == 'tr' or solutionstring.lower() == 'transient' or solutionstring.lower() == 'transientsolution':
     55                solutionstring = 'TransientSolution';
     56        elif solutionstring.lower() == 'mc' or solutionstring.lower() == 'balancethickness' or solutionstring.lower() == 'balancethicknesssolution':
     57                solutionstring = 'BalancethicknessSolution';
     58        elif solutionstring.lower() == 'bv' or solutionstring.lower() == 'balancevelocity' or solutionstring.lower() == 'balancevelocitysolution':
     59                solutionstring = 'BalancevelocitySolution';
     60        elif solutionstring.lower() == 'bs' or solutionstring.lower() == 'bedslope' or solutionstring.lower() == 'bedslopesolution':
     61                solutionstring = 'BedSlopeSolution';
     62        elif solutionstring.lower() == 'ss' or solutionstring.lower() == 'surfaceslope' or solutionstring.lower() == 'surfaceslopesolution':
     63                solutionstring = 'SurfaceSlopeSolution';
     64        elif solutionstring.lower() == 'hy' or solutionstring.lower() == 'hydrology' or solutionstring.lower() == 'hydrologysolution':
     65                solutioneum = 'HydrologySolution';
     66        elif solutionstring.lower() == 'da' or solutionstring.lower() == 'damageevolution' or solutionstring.lower() == 'damageevolutionsolution':
     67                solutionstring = 'DamageEvolutionSolution';
     68        else:   
     69                raise ValueError("solutionstring '%s' not supported!" % solutionstring)
     70        options=pairoptions('solutionstring',solutionstring,*args)
    4671
    4772        #recover some fields
    48         md.private.solution=solutionenum
     73        md.private.solution=solutionstring
    4974        cluster=md.cluster
    5075        if m.strcmpi(options.getfieldvalue('batch','no'),'yes'):
    … …  
    5681        if m.strcmpi(options.getfieldvalue('checkconsistency','yes'),'yes'):
    5782                print "checking model consistency"
    58                 if solutionenum == FlaimSolutionEnum():
     83                if solutionstring.lower() == 'flaimsolution':
    5984                        md.private.isconsistent=True
    60                         md.mesh.checkconsistency(md,solutionenum)
    61                         md.flaim.checkconsistency(md,solutionenum)
     85                        md.mesh.checkconsistency(md,solutionstring)
     86                        md.flaim.checkconsistency(md,solutionstring)
    6287                        if not md.private.isconsistent:
    6388                                raise RuntimeError("Model not consistent, see messages above.")
    … …  
    85110
    86111        #flaim analysis
    87         if solutionenum == FlaimSolutionEnum():
     112        if solutionstring.lower() == 'flaimSolution':
     113                solutionstring='FlaimSolution'
    88114                md=flaim_sol(md,options)
    89                 md.private.solution=EnumToString(solutionenum)[0]
     115                md.private.solution=solutionstring
    90116                return md
    91117

  • issm/trunk-jpl/src/wrappers/matlab/io/WriteMatlabData.cpp

    r18618 r21049  
    351351                SetStructureFieldi(dataref,i,"tips"             ,1                                  ,2,&riftstruct->riftstips[2*i]);
    352352                SetStructureFieldi(dataref,i,"penaltypairs"     ,riftstruct->riftsnumpenaltypairs[i],7,riftstruct->riftspenaltypairs[i]);
    353                 SetStructureFieldi(dataref,i,"fill"             ,IceEnum);
     353                SetStructureFieldi(dataref,i,"fill"             ,"Ice");
    354354                SetStructureFieldi(dataref,i,"friction"         ,0);
    355355                SetStructureFieldi(dataref,i,"fraction"         ,0.);

  • issm/trunk-jpl/src/wrappers/python/io/WritePythonData.cpp

    r19896 r21049  
    227227                PyDict_SetItemString(dict,"penaltypairs"     ,PyArrayFromCopiedData(riftstruct->riftsnumpenaltypairs[i],7,riftstruct->riftspenaltypairs[i]));
    228228                #if _PYTHON_MAJOR_ >= 3
    229                 PyDict_SetItemString(dict,"fill"             ,PyLong_FromSsize_t((Py_ssize_t)IceEnum));
     229                PyDict_SetItemString(dict,"fill"             ,PyString_FromString("Ice"));
    230230                PyDict_SetItemString(dict,"friction"         ,PyLong_FromSsize_t((Py_ssize_t)0));
    231231                #else
    232                 PyDict_SetItemString(dict,"fill"             ,PyInt_FromSsize_t((Py_ssize_t)IceEnum));
     232                PyDict_SetItemString(dict,"fill"             ,PyString_FromString("Ice"));
    233233                PyDict_SetItemString(dict,"friction"         ,PyInt_FromSsize_t((Py_ssize_t)0));
    234234                #endif

  • issm/trunk-jpl/test/NightlyRun/test101.m

    r20952 r21049  
    99md.stressbalance.requested_outputs={'default','DeviatoricStressxx','DeviatoricStressyy','DeviatoricStressxy','MassFlux1','MassFlux2','MassFlux3','MassFlux4','MassFlux5','MassFlux6'};
    1010md.outputdefinition.definitions={...
    11         massfluxatgate('name','MassFlux1','profilename',['../Exp/MassFlux1.exp'],'definitionenum',Outputdefinition1Enum()),...
    12         massfluxatgate('name','MassFlux2','profilename',['../Exp/MassFlux2.exp'],'definitionenum',Outputdefinition2Enum()),...
    13         massfluxatgate('name','MassFlux3','profilename',['../Exp/MassFlux3.exp'],'definitionenum',Outputdefinition3Enum()),...
    14         massfluxatgate('name','MassFlux4','profilename',['../Exp/MassFlux4.exp'],'definitionenum',Outputdefinition4Enum()),...
    15         massfluxatgate('name','MassFlux5','profilename',['../Exp/MassFlux5.exp'],'definitionenum',Outputdefinition5Enum()),...
    16         massfluxatgate('name','MassFlux6','profilename',['../Exp/MassFlux6.exp'],'definitionenum',Outputdefinition6Enum())...
     11        massfluxatgate('name','MassFlux1','profilename',['../Exp/MassFlux1.exp'],'definitionstring','Outputdefinition1'),...
     12        massfluxatgate('name','MassFlux2','profilename',['../Exp/MassFlux2.exp'],'definitionstring','Outputdefinition2'),...
     13        massfluxatgate('name','MassFlux3','profilename',['../Exp/MassFlux3.exp'],'definitionstring','Outputdefinition3'),...
     14        massfluxatgate('name','MassFlux4','profilename',['../Exp/MassFlux4.exp'],'definitionstring','Outputdefinition4'),...
     15        massfluxatgate('name','MassFlux5','profilename',['../Exp/MassFlux5.exp'],'definitionstring','Outputdefinition5'),...
     16        massfluxatgate('name','MassFlux6','profilename',['../Exp/MassFlux6.exp'],'definitionstring','Outputdefinition6')...
    1717        };
    1818
    19 md=solve(md,StressbalanceSolutionEnum());
     19md=solve(md,'StressbalanceSolution');
    2020
    2121%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test101.py

    r19049 r21049  
    2020md.stressbalance.requested_outputs=['default','DeviatoricStressxx','DeviatoricStressyy','DeviatoricStressxy','MassFlux1','MassFlux2','MassFlux3','MassFlux4','MassFlux5','MassFlux6']
    2121md.outputdefinition.definitions=[
    22                 massfluxatgate('name','MassFlux1','profilename','../Exp/MassFlux1.exp','definitionenum',Outputdefinition1Enum()),
    23                 massfluxatgate('name','MassFlux2','profilename','../Exp/MassFlux2.exp','definitionenum',Outputdefinition2Enum()),
    24                 massfluxatgate('name','MassFlux3','profilename','../Exp/MassFlux3.exp','definitionenum',Outputdefinition3Enum()),
    25                 massfluxatgate('name','MassFlux4','profilename','../Exp/MassFlux4.exp','definitionenum',Outputdefinition4Enum()),
    26                 massfluxatgate('name','MassFlux5','profilename','../Exp/MassFlux5.exp','definitionenum',Outputdefinition5Enum()),
    27                 massfluxatgate('name','MassFlux6','profilename','../Exp/MassFlux6.exp','definitionenum',Outputdefinition6Enum())
     22                massfluxatgate('name','MassFlux1','profilename','../Exp/MassFlux1.exp','definitionstring','Outputdefinition1'),
     23                massfluxatgate('name','MassFlux2','profilename','../Exp/MassFlux2.exp','definitionstring','Outputdefinition2'),
     24                massfluxatgate('name','MassFlux3','profilename','../Exp/MassFlux3.exp','definitionstring','Outputdefinition3'),
     25                massfluxatgate('name','MassFlux4','profilename','../Exp/MassFlux4.exp','definitionstring','Outputdefinition4'),
     26                massfluxatgate('name','MassFlux5','profilename','../Exp/MassFlux5.exp','definitionstring','Outputdefinition5'),
     27                massfluxatgate('name','MassFlux6','profilename','../Exp/MassFlux6.exp','definitionstring','Outputdefinition6')
    2828                ]
    2929
    30 md=solve(md,StressbalanceSolutionEnum())
     30md=solve(md,'StressbalanceSolution')
    3131
    3232#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test102.m

    r20952 r21049  
    66md=setflowequation(md,'SSA','all');
    77md.cluster=generic('name',oshostname(),'np',3);
    8 md=solve(md,StressbalanceSolutionEnum());
     8md=solve(md,'StressbalanceSolution');
    99
    1010%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test102.py

    r19049 r21049  
    1515md=setflowequation(md,'SSA','all')
    1616md.cluster=generic('name',oshostname(),'np',3)
    17 md=solve(md,StressbalanceSolutionEnum())
     17md=solve(md,'StressbalanceSolution')
    1818
    1919#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test103.m

    r19049 r21049  
    77md.cluster=generic('name',oshostname(),'np',3);
    88md.stressbalance.requested_outputs={'default','StressTensorxx','StressTensoryy','StressTensorzz','StressTensorxy','StressTensorxz','StressTensoryz'};
    9 md=solve(md,StressbalanceSolutionEnum());
     9md=solve(md,'sb');
    1010
    1111%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test103.py

    r19049 r21049  
    1616md.cluster=generic('name',oshostname(),'np',3)
    1717md.stressbalance.requested_outputs=['default','StressTensorxx','StressTensoryy','StressTensorzz','StressTensorxy','StressTensorxz','StressTensoryz']
    18 md=solve(md,StressbalanceSolutionEnum())
     18md=solve(md,'StressbalanceSolution')
    1919
    2020#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test104.m

    r19049 r21049  
    66md=setflowequation(md,'FS','all');
    77md.cluster=generic('name',oshostname(),'np',3);
    8 md=solve(md,StressbalanceSolutionEnum());
     8md=solve(md,'StressbalanceSolution');
    99
    1010%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test104.py

    r19049 r21049  
    1515md=setflowequation(md,'FS','all')
    1616md.cluster=generic('name',oshostname(),'np',3)
    17 md=solve(md,StressbalanceSolutionEnum())
     17md=solve(md,'StressbalanceSolution')
    1818
    1919#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test105.m

    r20140 r21049  
    55md=setflowequation(md,'SSA','all');
    66md.cluster=generic('name',oshostname(),'np',3);
    7 md=solve(md,MasstransportSolutionEnum());
     7md=solve(md,'MasstransportSolution');
    88
    99%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test105.py

    r19049 r21049  
    1414md=setflowequation(md,'SSA','all')
    1515md.cluster=generic('name',oshostname(),'np',3)
    16 md=solve(md,MasstransportSolutionEnum())
     16md=solve(md,'MasstransportSolution')
    1717
    1818#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test106.m

    r19049 r21049  
    88md.masstransport.stabilization=3;
    99md.masstransport.spcthickness=md.geometry.thickness;
    10 md=solve(md,MasstransportSolutionEnum());
     10md=solve(md,'MasstransportSolution');
    1111
    1212%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test106.py

    r19049 r21049  
    1818md.masstransport.stabilization=3
    1919md.masstransport.spcthickness=md.geometry.thickness
    20 md=solve(md,MasstransportSolutionEnum())
     20md=solve(md,'MasstransportSolution')
    2121
    2222#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test107.m

    r19049 r21049  
    66md=extrude(md,5,3.);
    77md.cluster=generic('name',oshostname(),'np',3);
    8 md=solve(md,MasstransportSolutionEnum());
     8md=solve(md,'MasstransportSolution');
    99
    1010%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test107.py

    r19049 r21049  
    1515md.extrude(5,3.)
    1616md.cluster=generic('name',oshostname(),'np',3)
    17 md=solve(md,MasstransportSolutionEnum())
     17md=solve(md,'MasstransportSolution')
    1818
    1919#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test108.m

    r19049 r21049  
    77md.timestepping.time_step=0;
    88md.cluster=generic('name',oshostname(),'np',3);
    9 md=solve(md,ThermalSolutionEnum());
     9md=solve(md,'ThermalSolution');
    1010
    1111%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test108.py

    r19049 r21049  
    1616md.timestepping.time_step=0
    1717md.cluster=generic('name',oshostname(),'np',3)
    18 md=solve(md,ThermalSolutionEnum())
     18md=solve(md,'ThermalSolution')
    1919
    2020#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test109.m

    r20140 r21049  
    1111md.transient.isthermal=1;
    1212md.transient.isgroundingline=0;
    13 md=solve(md,TransientSolutionEnum());
     13md=solve(md,'TransientSolution');
    1414
    1515%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test109.py

    r19528 r21049  
    2020md.transient.isthermal=True
    2121md.transient.isgroundingline=False
    22 md=solve(md,TransientSolutionEnum())
     22md=solve(md,'TransientSolution')
    2323
    2424#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test110.m

    r19049 r21049  
    77md.transient.requested_outputs={'IceVolume'};
    88
    9 md=solve(md,TransientSolutionEnum());
     9md=solve(md,'TransientSolution');
    1010
    1111%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test110.py

    r19049 r21049  
    1616md.transient.requested_outputs=['IceVolume']
    1717
    18 md=solve(md,TransientSolutionEnum())
     18md=solve(md,'TransientSolution')
    1919
    2020#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test1101.m

    r19049 r21049  
    4242        %Compute the stressbalance
    4343        md.cluster=generic('name',oshostname(),'np',8);
    44         md=solve(md,StressbalanceSolutionEnum());
     44        md=solve(md,'StressbalanceSolution');
    4545
    4646        %Plot the results and save them

  • issm/trunk-jpl/test/NightlyRun/test1101.py

    r19049 r21049  
    5555        #Compute the stressbalance
    5656        md.cluster=generic('name',oshostname(),'np',8)
    57         md=solve(md,StressbalanceSolutionEnum())
     57        md=solve(md,'StressbalanceSolution')
    5858
    5959        #Plot the results and save them

  • issm/trunk-jpl/test/NightlyRun/test1102.m

    r19049 r21049  
    5151        md.stressbalance.restol=1.;
    5252        md.cluster=generic('name',oshostname(),'np',8);
    53         md=solve(md,StressbalanceSolutionEnum());
     53        md=solve(md,'StressbalanceSolution');
    5454
    5555        %Plot the results and save them

  • issm/trunk-jpl/test/NightlyRun/test1102.py

    r19049 r21049  
    6464        md.stressbalance.restol=1.
    6565        md.cluster=generic('name',oshostname(),'np',8)
    66         md=solve(md,StressbalanceSolutionEnum())
     66        md=solve(md,'StressbalanceSolution')
    6767
    6868        #Plot the results and save them

  • issm/trunk-jpl/test/NightlyRun/test1103.m

    r19049 r21049  
    4141        %Compute the stressbalance
    4242        md.cluster=generic('name',oshostname(),'np',8);
    43         md=solve(md,StressbalanceSolutionEnum());
     43        md=solve(md,'StressbalanceSolution');
    4444
    4545        %Plot the results and save them

  • issm/trunk-jpl/test/NightlyRun/test1103.py

    r19049 r21049  
    5454        #Compute the stressbalance
    5555        md.cluster=generic('name',oshostname(),'np',8)
    56         md=solve(md,StressbalanceSolutionEnum())
     56        md=solve(md,'StressbalanceSolution')
    5757
    5858        #Plot the results and save them

  • issm/trunk-jpl/test/NightlyRun/test1104.m

    r19049 r21049  
    3939        md.stressbalance.abstol=NaN;
    4040        md.cluster=generic('name',oshostname(),'np',8);
    41         md=solve(md,StressbalanceSolutionEnum());
     41        md=solve(md,'StressbalanceSolution');
    4242        pos=find(md.mesh.x==0. | md.mesh.y==0. | md.mesh.x==max(md.mesh.x) | md.mesh.y==max(md.mesh.y));
    4343        md.stressbalance.spcvx(pos)=md.results.StressbalanceSolution.Vx(pos);
    … …  
    4545        md.stressbalance.vertex_pairing=[];
    4646        md=setflowequation(md,'FS','all');
    47         md=solve(md,StressbalanceSolutionEnum());
     47        md=solve(md,'StressbalanceSolution');
    4848
    4949        %Plot the results and save them

  • issm/trunk-jpl/test/NightlyRun/test1104.py

    r19049 r21049  
    5050        md.stressbalance.abstol=float('NaN')
    5151        md.cluster=generic('name',oshostname(),'np',8)
    52         md=solve(md,StressbalanceSolutionEnum())
     52        md=solve(md,'StressbalanceSolution')
    5353        pos=numpy.nonzero(logical_or_n(md.mesh.x==0.,md.mesh.y==0.,md.mesh.x==numpy.max(md.mesh.x),md.mesh.y==numpy.max(md.mesh.y)))
    5454        md.stressbalance.spcvx[pos]=md.results.StressbalanceSolution.Vx[pos]
    … …  
    5656        md.stressbalance.vertex_pairing=numpy.empty((0,2),int)
    5757        md=setflowequation(md,'FS','all')
    58         md=solve(md,StressbalanceSolutionEnum())
     58        md=solve(md,'StressbalanceSolution')
    5959
    6060        #Plot the results and save them

  • issm/trunk-jpl/test/NightlyRun/test1105.m

    r19049 r21049  
    6565        %Compute the stressbalance
    6666        md.cluster=generic('name',oshostname(),'np',8);
    67         md=solve(md,StressbalanceSolutionEnum());
     67        md=solve(md,'StressbalanceSolution');
    6868
    6969        %Plot the results and save them

  • issm/trunk-jpl/test/NightlyRun/test1105.py

    r19049 r21049  
    7777        #Compute the stressbalance
    7878        md.cluster=generic('name',oshostname(),'np',8)
    79         md=solve(md,StressbalanceSolutionEnum())
     79        md=solve(md,'StressbalanceSolution')
    8080
    8181        #Plot the results and save them

  • issm/trunk-jpl/test/NightlyRun/test1106.m

    r19049 r21049  
    4343        %Compute the stressbalance
    4444        md.cluster=generic('name',oshostname(),'np',8);
    45         md=solve(md,StressbalanceSolutionEnum());
     45        md=solve(md,'StressbalanceSolution');
    4646
    4747        %Plot the results and save them

  • issm/trunk-jpl/test/NightlyRun/test1106.py

    r19049 r21049  
    5353        #Compute the stressbalance
    5454        md.cluster=generic('name',oshostname(),'np',8)
    55         md=solve(md,StressbalanceSolutionEnum())
     55        md=solve(md,'StressbalanceSolution')
    5656
    5757        #Plot the results and save them

  • issm/trunk-jpl/test/NightlyRun/test1107.m

    r19049 r21049  
    6060        %Compute the stressbalance
    6161        md.cluster=generic('name',oshostname(),'np',8);
    62         md=solve(md,StressbalanceSolutionEnum());
     62        md=solve(md,'StressbalanceSolution');
    6363
    6464        %Plot the results and save them

  • issm/trunk-jpl/test/NightlyRun/test1107.py

    r19049 r21049  
    7474        #Compute the stressbalance
    7575        md.cluster=generic('name',oshostname(),'np',8)
    76         md=solve(md,StressbalanceSolutionEnum())
     76        md=solve(md,'StressbalanceSolution')
    7777
    7878        #Plot the results and save them

  • issm/trunk-jpl/test/NightlyRun/test1108.m

    r19049 r21049  
    4040        %Compute the stressbalance
    4141        md.cluster=generic('name',oshostname(),'np',8);
    42         md=solve(md,StressbalanceSolutionEnum());
     42        md=solve(md,'StressbalanceSolution');
    4343        md.stressbalance.reltol=NaN;
    4444        md.stressbalance.abstol=NaN;
    … …  
    5252        md.stressbalance.spcvy(pos)=md.results.StressbalanceSolution.Vy(pos);
    5353        md=setflowequation(md,'FS','all');
    54         md=solve(md,StressbalanceSolutionEnum());
     54        md=solve(md,'StressbalanceSolution');
    5555
    5656        %Plot the results and save them

  • issm/trunk-jpl/test/NightlyRun/test1108.py

    r19049 r21049  
    5252        md.cluster=generic('name',oshostname(),'np',8)
    5353        md.verbose=verbose('convergence',True)
    54         md=solve(md,StressbalanceSolutionEnum())
     54        md=solve(md,'StressbalanceSolution')
    5555        md.stressbalance.reltol=float('NaN')
    5656        md.stressbalance.abstol=float('NaN')
    … …  
    6464        md.stressbalance.spcvy[pos]=md.results.StressbalanceSolution.Vy[pos]
    6565        md=setflowequation(md,'FS','all')
    66         md=solve(md,StressbalanceSolutionEnum())
     66        md=solve(md,'StressbalanceSolution')
    6767
    6868        #Plot the results and save them

  • issm/trunk-jpl/test/NightlyRun/test1109.m

    r19049 r21049  
    5050        %Compute the stressbalance
    5151        md.cluster=generic('name',oshostname(),'np',8);
    52         md=solve(md,StressbalanceSolutionEnum());
     52        md=solve(md,'StressbalanceSolution');
    5353
    5454        vx=(md.results.StressbalanceSolution.Vx);

  • issm/trunk-jpl/test/NightlyRun/test111.m

    r19049 r21049  
    77md.cluster=generic('name',oshostname(),'np',3);
    88md.transient.requested_outputs={'IceVolume'};
    9 md=solve(md,TransientSolutionEnum());
     9md=solve(md,'TransientSolution');
    1010
    1111%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test111.py

    r19049 r21049  
    1616md.cluster=generic('name',oshostname(),'np',3)
    1717md.transient.requested_outputs=['IceVolume']
    18 md=solve(md,TransientSolutionEnum())
     18md=solve(md,'TransientSolution')
    1919
    2020#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test1110.m

    r19049 r21049  
    5959        md.cluster=generic('name',oshostname(),'np',8);
    6060        md.verbose=verbose('convergence',true,'solution',true);
    61         md=solve(md,TransientSolutionEnum());
     61        md=solve(md,'TransientSolution');
    6262
    6363        %save the results

  • issm/trunk-jpl/test/NightlyRun/test112.m

    r19049 r21049  
    55md=setflowequation(md,'SSA','all');
    66md.cluster=generic('name',oshostname(),'np',3);
    7 md=solve(md,SurfaceSlopeSolutionEnum());
     7md=solve(md,'SurfaceSlopeSolution');
    88
    99%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test112.py

    r19049 r21049  
    1414md=setflowequation(md,'SSA','all')
    1515md.cluster=generic('name',oshostname(),'np',3)
    16 md=solve(md,SurfaceSlopeSolutionEnum())
     16md=solve(md,'SurfaceSlopeSolution')
    1717
    1818#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test113.m

    r19049 r21049  
    66md=setflowequation(md,'SSA','all');
    77md.cluster=generic('name',oshostname(),'np',3);
    8 md=solve(md,SurfaceSlopeSolutionEnum());
     8md=solve(md,'SurfaceSlopeSolution');
    99
    1010%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test113.py

    r19049 r21049  
    1515md=setflowequation(md,'SSA','all')
    1616md.cluster=generic('name',oshostname(),'np',3)
    17 md=solve(md,SurfaceSlopeSolutionEnum())
     17md=solve(md,'SurfaceSlopeSolution')
    1818
    1919#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test114.m

    r19049 r21049  
    55md=setflowequation(md,'SSA','all');
    66md.cluster=generic('name',oshostname(),'np',3);
    7 md=solve(md,BedSlopeSolutionEnum());
     7md=solve(md,'BedSlopeSolution');
    88
    99%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test114.py

    r19049 r21049  
    1414md=setflowequation(md,'SSA','all')
    1515md.cluster=generic('name',oshostname(),'np',3)
    16 md=solve(md,BedSlopeSolutionEnum())
     16md=solve(md,'BedSlopeSolution')
    1717
    1818#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test115.m

    r19049 r21049  
    66md=setflowequation(md,'SSA','all');
    77md.cluster=generic('name',oshostname(),'np',3);
    8 md=solve(md,BedSlopeSolutionEnum());
     8md=solve(md,'BedSlopeSolution');
    99
    1010%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test115.py

    r19049 r21049  
    1515md=setflowequation(md,'SSA','all')
    1616md.cluster=generic('name',oshostname(),'np',3)
    17 md=solve(md,BedSlopeSolutionEnum())
     17md=solve(md,'BedSlopeSolution')
    1818
    1919#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test116.m

    r19049 r21049  
    88md=setflowequation(md,'SSA','all');
    99md.cluster=generic('name',oshostname(),'np',3);
    10 md=solve(md,BalancethicknessSolutionEnum());
     10md=solve(md,'BalancethicknessSolution');
    1111
    1212%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test116.py

    r19049 r21049  
    1818md=setflowequation(md,'SSA','all')
    1919md.cluster=generic('name',oshostname(),'np',3)
    20 md=solve(md,BalancethicknessSolutionEnum())
     20md=solve(md,'BalancethicknessSolution')
    2121
    2222#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test120.m

    r19663 r21049  
    1212
    1313md.cluster=generic('name',oshostname(),'np',3);
    14 md=solve(md,ThermalSolutionEnum());
     14md=solve(md,'ThermalSolution');
    1515
    1616%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test120.py

    r19049 r21049  
    2222
    2323md.cluster=generic('name',oshostname(),'np',3)
    24 md=solve(md,ThermalSolutionEnum())
     24md=solve(md,'ThermalSolution')
    2525
    2626#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test1201.m

    r19527 r21049  
    3939        md.settings.output_frequency=500; %keep only last step
    4040        md.verbose=verbose();
    41         md=solve(md,TransientSolutionEnum());
     41        md=solve(md,'TransientSolution');
    4242        results{stabilization}=(md.results.TransientSolution(end).Thickness);
    4343end

  • issm/trunk-jpl/test/NightlyRun/test1201.py

    r19527 r21049  
    5151        md.settings.output_frequency=500    #keep only last step
    5252        md.verbose=verbose()
    53         md=solve(md,TransientSolutionEnum())
     53        md=solve(md,'TransientSolution')
    5454        results.append(md.results.TransientSolution[-1].Thickness)
    5555

  • issm/trunk-jpl/test/NightlyRun/test1202.m

    r19049 r21049  
    1212%Compute solution for SSA's model
    1313md.cluster=generic('name',oshostname(),'np',8);
    14 md=solve(md,StressbalanceSolutionEnum());
     14md=solve(md,'StressbalanceSolution');
    1515
    1616%plot results

  • issm/trunk-jpl/test/NightlyRun/test1202.py

    r19049 r21049  
    2525#Compute solution for SSA's model
    2626md.cluster=generic('name',oshostname(),'np',8)
    27 md=solve(md,StressbalanceSolutionEnum())
     27md=solve(md,'StressbalanceSolution')
    2828
    2929#plot results

  • issm/trunk-jpl/test/NightlyRun/test1203.m

    r19049 r21049  
    1616%Compute solution for SSA's model
    1717md.cluster=generic('name',oshostname(),'np',8);
    18 md=solve(md,StressbalanceSolutionEnum());
     18md=solve(md,'StressbalanceSolution');
    1919
    2020vx=(md.results.StressbalanceSolution.Vx);

  • issm/trunk-jpl/test/NightlyRun/test1203.py

    r19049 r21049  
    3030#Compute solution for SSA's model
    3131md.cluster=generic('name',oshostname(),'np',8)
    32 md=solve(md,StressbalanceSolutionEnum())
     32md=solve(md,'StressbalanceSolution')
    3333
    3434vx=md.results.StressbalanceSolution.Vx

  • issm/trunk-jpl/test/NightlyRun/test1204.m

    r19049 r21049  
    1616%Compute solution for SSA's model
    1717md.cluster=generic('name',oshostname(),'np',8);
    18 md=solve(md,StressbalanceSolutionEnum());
     18md=solve(md,'StressbalanceSolution');
    1919
    2020%plot results
    … …  
    2525md.timestepping.final_time=5000.;
    2626md.masstransport.stabilization=1;
    27 md=solve(md,TransientSolutionEnum());
     27md=solve(md,'TransientSolution');
    2828
    2929plotmodel(md,'data',(md.results.TransientSolution(end).Vx))

  • issm/trunk-jpl/test/NightlyRun/test1204.py

    r19049 r21049  
    3030#Compute solution for SSA's model
    3131md.cluster=generic('name',oshostname(),'np',8)
    32 md=solve(md,StressbalanceSolutionEnum())
     32md=solve(md,'StressbalanceSolution')
    3333
    3434#plot results
    … …  
    3939md.timestepping.final_time=5000.
    4040md.masstransport.stabilization=1
    41 md=solve(md,TransientSolutionEnum())
     41md=solve(md,'TransientSolution')
    4242
    4343#plotmodel(md,'data',(md.results.TransientSolution(end).Vx))

  • issm/trunk-jpl/test/NightlyRun/test1205.m

    r19049 r21049  
    3030%Now we can solve the problem
    3131md.cluster=generic('name',oshostname(),'np',8);
    32 md=solve(md,StressbalanceSolutionEnum());
     32md=solve(md,'StressbalanceSolution');
    3333
    3434%Calculate the depth averaged velocity field (2d):

  • issm/trunk-jpl/test/NightlyRun/test1205.py

    r19049 r21049  
    4343#Now we can solve the problem
    4444md.cluster=generic('name',oshostname(),'np',8)
    45 md=solve(md,StressbalanceSolutionEnum())
     45md=solve(md,'StressbalanceSolution')
    4646
    4747#Calculate the depth averaged velocity field (2d):

  • issm/trunk-jpl/test/NightlyRun/test1206.m

    r19049 r21049  
    3030%Now we can solve the problem
    3131md.cluster=generic('name',oshostname(),'np',8);
    32 md=solve(md,StressbalanceSolutionEnum());
     32md=solve(md,'StressbalanceSolution');
    3333
    3434%Calculate the depth averaged velocity field (2d):

  • issm/trunk-jpl/test/NightlyRun/test1206.py

    r19049 r21049  
    4343#Now we can solve the problem
    4444md.cluster=generic('name',oshostname(),'np',8)
    45 md=solve(md,StressbalanceSolutionEnum())
     45md=solve(md,'StressbalanceSolution')
    4646
    4747#Calculate the depth averaged velocity field (2d):

  • issm/trunk-jpl/test/NightlyRun/test1207.m

    r19049 r21049  
    3030%Now we can solve the problem
    3131md.cluster=generic('name',oshostname(),'np',8);
    32 md=solve(md,StressbalanceSolutionEnum());
     32md=solve(md,'StressbalanceSolution');
    3333
    3434%Calculate the depth averaged velocity field (2d):

  • issm/trunk-jpl/test/NightlyRun/test1207.py

    r19049 r21049  
    4343#Now we can solve the problem
    4444md.cluster=generic('name',oshostname(),'np',8)
    45 md=solve(md,StressbalanceSolutionEnum())
     45md=solve(md,'StressbalanceSolution')
    4646
    4747#Calculate the depth averaged velocity field (2d):

  • issm/trunk-jpl/test/NightlyRun/test1208.m

    r19049 r21049  
    2828%Now we can solve the problem
    2929md.cluster=generic('name',oshostname(),'np',8);
    30 md=solve(md,TransientSolutionEnum());
     30md=solve(md,'TransientSolution');
    3131
    3232%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test1208.py

    r19049 r21049  
    4141#Now we can solve the problem
    4242md.cluster=generic('name',oshostname(),'np',8)
    43 md=solve(md,TransientSolutionEnum())
     43md=solve(md,'TransientSolution')
    4444
    4545#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test121.m

    r19528 r21049  
    1515md.thermal.isenthalpy=1;
    1616md.thermal.isdynamicbasalspc=1;
    17 md=solve(md,TransientSolutionEnum());
     17md=solve(md,'TransientSolution');
    1818
    1919%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test121.py

    r19528 r21049  
    2424md.thermal.isenthalpy=1
    2525md.thermal.isdynamicbasalspc=1
    26 md=solve(md,TransientSolutionEnum())
     26md=solve(md,'TransientSolution')
    2727
    2828#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test122.m

    r19049 r21049  
    1111md.thermal.stabilization=2;
    1212md.cluster=generic('name',oshostname(),'np',3);
    13 md=solve(md,TransientSolutionEnum());
     13md=solve(md,'TransientSolution');
    1414
    1515%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test122.py

    r19049 r21049  
    2020md.thermal.stabilization=2
    2121md.cluster=generic('name',oshostname(),'np',3)
    22 md=solve(md,TransientSolutionEnum())
     22md=solve(md,'TransientSolution')
    2323
    2424#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test123.m

    r19049 r21049  
    55md=setflowequation(md,'SSA','all');
    66md.cluster=generic('name',oshostname(),'np',3);
     7%md.debug.valgrind=1;
    78
    89fake_surface=[[md.geometry.surface+100;1.1],...
    … …  
    1112
    1213md.transient.requested_outputs={'default','SurfaceMisfit'};
    13 md.outputdefinition.definitions={misfit('name','SurfaceMisfit', 'definitionenum',Outputdefinition1Enum,'model_enum',SurfaceEnum,'observation_enum',SurfaceObservationEnum,'observation',fake_surface,'timeinterpolation','nearestneighbor','weights',ones(md.mesh.numberofvertices,1),'weights_enum',WeightsSurfaceObservationEnum)};
     14md.outputdefinition.definitions={misfit('name','SurfaceMisfit', 'definitionstring','Outputdefinition1','model_string','Surface','observation_string','SurfaceObservation','observation',fake_surface,'timeinterpolation','nearestneighbor','weights',ones(md.mesh.numberofvertices,1),'weights_string','WeightsSurfaceObservation')};
    1415
    15 md=solve(md,TransientSolutionEnum());
     16md=solve(md,'TransientSolution');
    1617
    1718%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test124.m

    r20550 r21049  
    1313%Go solve
    1414md.cluster=generic('name',oshostname(),'np',3);
    15 md=solve(md,TransientSolutionEnum());
     15md=solve(md,'TransientSolution');
    1616
    1717%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test125.m

    r20956 r21049  
    1313md.timestepping.final_time=8;
    1414
    15 md=solve(md,TransientSolutionEnum());
    16 md2=solve(md,TransientSolutionEnum(),'restart',1);
     15md=solve(md,'TransientSolution');
     16md2=solve(md,'TransientSolution','restart',1);
    1717
    1818%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test125.py

    r20960 r21049  
    2525md.timestepping.final_time=8
    2626
    27 md=solve(md,TransientSolutionEnum())
     27md=solve(md,'TransientSolution')
    2828md2=copy.deepcopy(md)
    29 md=solve(md,TransientSolutionEnum(),'restart',1)
     29md=solve(md,'TransientSolution','restart',1)
    3030
    3131#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test126.m

    r20957 r21049  
    1414md.timestepping.final_time=8;
    1515
    16 md=solve(md,TransientSolutionEnum());
    17 md2=solve(md,TransientSolutionEnum(),'restart',1);
     16md=solve(md,'TransientSolution');
     17md2=solve(md,'TransientSolution','restart',1);
    1818
    1919%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test126.py

    r20960 r21049  
    2626md.timestepping.final_time=8
    2727
    28 md=solve(md,TransientSolutionEnum())
     28md=solve(md,'TransientSolution')
    2929md2=copy.deepcopy(md)
    30 md=solve(md,TransientSolutionEnum(),'restart',1)
     30md=solve(md,'TransientSolution','restart',1)
    3131
    3232#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test1301.m

    r19049 r21049  
    2727%modeled results
    2828md.cluster=generic('name',oshostname(),'np',2);
    29 md=solve(md,ThermalSolutionEnum());
     29md=solve(md,'ThermalSolution');
    3030
    3131%plot results

  • issm/trunk-jpl/test/NightlyRun/test1301.py

    r19049 r21049  
    4141#modeled results
    4242md.cluster=generic('name',oshostname(),'np',2)
    43 md=solve(md,ThermalSolutionEnum())
     43md=solve(md,'ThermalSolution')
    4444
    4545#plot results

  • issm/trunk-jpl/test/NightlyRun/test1302.m

    r19049 r21049  
    2929%modeled results
    3030md.cluster=generic('name',oshostname(),'np',2);
    31 md=solve(md,ThermalSolutionEnum());
     31md=solve(md,'ThermalSolution');
    3232
    3333%plot results

  • issm/trunk-jpl/test/NightlyRun/test1302.py

    r19049 r21049  
    4545#modeled results
    4646md.cluster=generic('name',oshostname(),'np',2)
    47 md=solve(md,ThermalSolutionEnum())
     47md=solve(md,'ThermalSolution')
    4848
    4949#plot results

  • issm/trunk-jpl/test/NightlyRun/test1303.m

    r19049 r21049  
    2424%modeled results
    2525md.cluster=generic('name',oshostname(),'np',2);
    26 md=solve(md,ThermalSolutionEnum());
     26md=solve(md,'ThermalSolution');
    2727
    2828%plot results

  • issm/trunk-jpl/test/NightlyRun/test1303.py

    r19049 r21049  
    4040#modeled results
    4141md.cluster=generic('name',oshostname(),'np',2)
    42 md=solve(md,ThermalSolutionEnum())
     42md=solve(md,'ThermalSolution')
    4343
    4444#plot results

  • issm/trunk-jpl/test/NightlyRun/test1304.m

    r19049 r21049  
    2424%modeled results
    2525md.cluster=generic('name',oshostname(),'np',2);
    26 md=solve(md,ThermalSolutionEnum());
     26md=solve(md,'ThermalSolution');
    2727
    2828%plot results

  • issm/trunk-jpl/test/NightlyRun/test1304.py

    r19049 r21049  
    3939#modeled results
    4040md.cluster=generic('name',oshostname(),'np',2)
    41 md=solve(md,ThermalSolutionEnum())
     41md=solve(md,'ThermalSolution')
    4242
    4343#plot results

  • issm/trunk-jpl/test/NightlyRun/test1501.m

    r19527 r21049  
    1818md.basalforcings.groundedice_melting_rate= smb;
    1919
    20 md=solve(md,MasstransportSolutionEnum());
     20md=solve(md,'MasstransportSolution');
    2121
    2222for i=1:10
    23          md=solve(md,MasstransportSolutionEnum());
     23         md=solve(md,'MasstransportSolution');
    2424         md.smb.mass_balance= md.smb.mass_balance - ((md.results.MasstransportSolution.Thickness)-md.geometry.thickness);
    2525end
    … …  
    3434md.smb.mass_balance(end+1,:)=[1.:2000.];
    3535
    36 md=solve(md,TransientSolutionEnum());
     36md=solve(md,'TransientSolution');
    3737
    3838%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test1501.py

    r19527 r21049  
    2929md.basalforcings.groundedice_melting_rate= smb
    3030
    31 md=solve(md,MasstransportSolutionEnum())
     31md=solve(md,'MasstransportSolution')
    3232
    3333for i in xrange(1,11):
    34          md=solve(md,MasstransportSolutionEnum())
     34         md=solve(md,'MasstransportSolution')
    3535         md.smb.mass_balance= md.smb.mass_balance - ((md.results.MasstransportSolution.Thickness)-md.geometry.thickness)
    3636
    … …  
    4747md.smb.mass_balance=numpy.vstack((smb,numpy.arange(1,2001)))
    4848
    49 md=solve(md,TransientSolutionEnum())
     49md=solve(md,'TransientSolution')
    5050
    5151#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test1502.m

    r19527 r21049  
    1919md.basalforcings.groundedice_melting_rate= smb;
    2020
    21 md=solve(md,MasstransportSolutionEnum());
     21md=solve(md,'MasstransportSolution');
    2222
    2323for i=1:10
    24          md=solve(md,MasstransportSolutionEnum());
     24         md=solve(md,'MasstransportSolution');
    2525         md.smb.mass_balance= md.smb.mass_balance - ((md.results.MasstransportSolution.Thickness)-md.geometry.thickness);
    2626end
    … …  
    3535md.smb.mass_balance(end+1,:)=[1.:2000.];
    3636
    37 md=solve(md,TransientSolutionEnum());
     37md=solve(md,'TransientSolution');
    3838
    3939%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test1502.py

    r19527 r21049  
    3030md.basalforcings.groundedice_melting_rate= smb
    3131
    32 md=solve(md,MasstransportSolutionEnum())
     32md=solve(md,'MasstransportSolution')
    3333
    3434for i in xrange(1,11):
    35          md=solve(md,MasstransportSolutionEnum())
     35         md=solve(md,'MasstransportSolution')
    3636         md.smb.mass_balance= md.smb.mass_balance - ((md.results.MasstransportSolution.Thickness)-md.geometry.thickness)
    3737
    … …  
    4848md.smb.mass_balance=numpy.vstack((smb,numpy.arange(1,2001)))
    4949
    50 md=solve(md,TransientSolutionEnum())
     50md=solve(md,'TransientSolution')
    5151
    5252#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test1601.m

    r19049 r21049  
    1010
    1111md.cluster=generic('name',oshostname(),'np',2);
    12 md=solve(md,StressbalanceSolutionEnum());
     12md=solve(md,'StressbalanceSolution');
    1313vel0=md.results.StressbalanceSolution.Vel;
    1414
    … …  
    2121md.stressbalance.referential(:,1:3)=repmat([cos(theta),sin(theta),0],md.mesh.numberofvertices,1);
    2222md.stressbalance.referential(:,4:6)=repmat([0,0,1],md.mesh.numberofvertices,1);
    23 md=solve(md,StressbalanceSolutionEnum());
     23md=solve(md,'StressbalanceSolution');
    2424vel1=md.results.StressbalanceSolution.Vel;
    2525
    … …  
    3232md.stressbalance.referential(pos,1:3)=repmat([cos(theta),sin(theta),0],size(pos,1),1);
    3333md.stressbalance.referential(pos,4:6)=repmat([0,0,1],size(pos,1),1);
    34 md=solve(md,StressbalanceSolutionEnum());
     34md=solve(md,'StressbalanceSolution');
    3535vel2=md.results.StressbalanceSolution.Vel;
    3636

  • issm/trunk-jpl/test/NightlyRun/test1601.py

    r19049 r21049  
    2121
    2222md.cluster=generic('name',oshostname(),'np',2)
    23 md=solve(md,StressbalanceSolutionEnum())
     23md=solve(md,'StressbalanceSolution')
    2424vel0=md.results.StressbalanceSolution.Vel
    2525
    … …  
    3232md.stressbalance.referential[:,0:3]=numpy.tile([numpy.cos(theta),numpy.sin(theta),0],(md.mesh.numberofvertices,1))
    3333md.stressbalance.referential[:,3: ]=numpy.tile([0,0,1],(md.mesh.numberofvertices,1))
    34 md=solve(md,StressbalanceSolutionEnum())
     34md=solve(md,'StressbalanceSolution')
    3535vel1=md.results.StressbalanceSolution.Vel
    3636
    … …  
    4343md.stressbalance.referential[pos,0:3]=numpy.tile([numpy.cos(theta),numpy.sin(theta),0],(len(pos),1))
    4444md.stressbalance.referential[pos,3: ]=numpy.tile([0,0,1],(len(pos),1))
    45 md=solve(md,StressbalanceSolutionEnum())
     45md=solve(md,'StressbalanceSolution')
    4646vel2=md.results.StressbalanceSolution.Vel
    4747

  • issm/trunk-jpl/test/NightlyRun/test1602.m

    r19049 r21049  
    1111
    1212md.cluster=generic('name',oshostname(),'np',3);
    13 md=solve(md,StressbalanceSolutionEnum());
     13md=solve(md,'StressbalanceSolution');
    1414vel0=md.results.StressbalanceSolution.Vel;
    1515
    … …  
    2222md.stressbalance.referential(:,1:3)=repmat([cos(theta),sin(theta),0],md.mesh.numberofvertices,1);
    2323md.stressbalance.referential(:,4:6)=repmat([0,0,1],md.mesh.numberofvertices,1);
    24 md=solve(md,StressbalanceSolutionEnum());
     24md=solve(md,'StressbalanceSolution');
    2525vel1=md.results.StressbalanceSolution.Vel;
    2626

  • issm/trunk-jpl/test/NightlyRun/test1602.py

    r19049 r21049  
    2222
    2323md.cluster=generic('name',oshostname(),'np',3)
    24 md=solve(md,StressbalanceSolutionEnum())
     24md=solve(md,'StressbalanceSolution')
    2525vel0=md.results.StressbalanceSolution.Vel
    2626
    … …  
    3333md.stressbalance.referential[:,0:3]=numpy.tile([numpy.cos(theta),numpy.sin(theta),0],(md.mesh.numberofvertices,1))
    3434md.stressbalance.referential[:,3: ]=numpy.tile([0,0,1],(md.mesh.numberofvertices,1))
    35 md=solve(md,StressbalanceSolutionEnum())
     35md=solve(md,'StressbalanceSolution')
    3636vel1=md.results.StressbalanceSolution.Vel
    3737

  • issm/trunk-jpl/test/NightlyRun/test2001.m

    r19049 r21049  
    2020md.cluster=generic('name',oshostname(),'np',3);
    2121md.verbose=verbose('1111111');
    22 md=solve(md,GiaSolutionEnum());
     22md=solve(md,'GiaSolution');
    2323
    2424%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test2001.py

    r20416 r21049  
    3333#Solve for GIA deflection
    3434md.cluster=generic('name',oshostname(),'np',3)
    35 md=solve(md,GiaSolutionEnum())
     35md=solve(md,'GiaSolution')
    3636
    3737#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test2002.py

    r21048 r21049  
    7979md.slr.rigid=0
    8080md.slr.elastic=0
    81 md=solve(md,SealevelriseSolutionEnum())
     81md=solve(md,'SealevelriseSolution')
    8282Seustatic=md.results.SealevelriseSolution.Sealevel;
    8383
    … …  
    8585md.slr.rigid=1
    8686md.slr.elastic=0
    87 md=solve(md,SealevelriseSolutionEnum())
     87md=solve(md,'SealevelriseSolution')
    8888Srigid=md.results.SealevelriseSolution.Sealevel;
    8989
    … …  
    9191md.slr.rigid=1
    9292md.slr.elastic=1
    93 md=solve(md,SealevelriseSolutionEnum())
     93md=solve(md,'SealevelriseSolution')
    9494Selastic=md.results.SealevelriseSolution.Sealevel;
    9595

  • issm/trunk-jpl/test/NightlyRun/test201.m

    r19049 r21049  
    55md=setflowequation(md,'SSA','all');
    66md.cluster=generic('name',oshostname(),'np',3);
    7 md=solve(md,StressbalanceSolutionEnum());
     7md=solve(md,'StressbalanceSolution');
    88
    99%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test201.py

    r19049 r21049  
    1515md=setflowequation(md,'SSA','all')
    1616md.cluster=generic('name',oshostname(),'np',3)
    17 md=solve(md,StressbalanceSolutionEnum())
     17md=solve(md,'StressbalanceSolution')
    1818
    1919#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test202.m

    r19049 r21049  
    66md=setflowequation(md,'SSA','all');
    77md.cluster=generic('name',oshostname(),'np',3);
    8 md=solve(md,StressbalanceSolutionEnum());
     8md=solve(md,'StressbalanceSolution');
    99
    1010%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test202.py

    r19049 r21049  
    1717md=setflowequation(md,'SSA','all')
    1818md.cluster=generic('name',oshostname(),'np',3)
    19 md=solve(md,StressbalanceSolutionEnum())
     19md=solve(md,'StressbalanceSolution')
    2020
    2121

  • issm/trunk-jpl/test/NightlyRun/test203.m

    r19049 r21049  
    66md=setflowequation(md,'HO','all');
    77md.cluster=generic('name',oshostname(),'np',3);
    8 md=solve(md,StressbalanceSolutionEnum());
     8md=solve(md,'StressbalanceSolution');
    99
    1010%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test203.py

    r19049 r21049  
    1717md=setflowequation(md,'HO','all')
    1818md.cluster=generic('name',oshostname(),'np',3)
    19 md=solve(md,StressbalanceSolutionEnum())
     19md=solve(md,'StressbalanceSolution')
    2020
    2121

  • issm/trunk-jpl/test/NightlyRun/test204.m

    r19049 r21049  
    88md.stressbalance.shelf_dampening=1;
    99md.timestepping.time_step=0;
    10 md1=solve(md,StressbalanceSolutionEnum());
     10md1=solve(md,'StressbalanceSolution');
    1111md.stressbalance.shelf_dampening=0;
    12 md=solve(md,StressbalanceSolutionEnum());
     12md=solve(md,'StressbalanceSolution');
    1313
    1414%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test204.py

    r19049 r21049  
    1919md.stressbalance.shelf_dampening=1;
    2020md.timestepping.time_step=0;
    21 md1=solve(md,StressbalanceSolutionEnum())
     21md1=solve(md,'StressbalanceSolution')
    2222md.stressbalance.shelf_dampening=0;
    23 md=solve(md,StressbalanceSolutionEnum())
     23md=solve(md,'StressbalanceSolution')
    2424
    2525

  • issm/trunk-jpl/test/NightlyRun/test205.m

    r20567 r21049  
    66md=setflowequation(md,'HO','../Exp/SquareHalfRight.exp','fill','SSA','coupling','penalties');
    77md.cluster=generic('name',oshostname(),'np',3);
    8 md=solve(md,StressbalanceSolutionEnum());
     8md=solve(md,'StressbalanceSolution');
    99
    1010%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test205.py

    r20567 r21049  
    1717md=setflowequation(md,'HO','../Exp/SquareHalfRight.exp','fill','SSA','coupling','penalties')
    1818md.cluster=generic('name',oshostname(),'np',3)
    19 md=solve(md,StressbalanceSolutionEnum())
     19md=solve(md,'StressbalanceSolution')
    2020
    2121

  • issm/trunk-jpl/test/NightlyRun/test2051.m

    r19049 r21049  
    2222md.cluster=generic('name',oshostname(),'np',3);
    2323md.verbose=verbose('1111111');
    24 md=solve(md,GiaSolutionEnum());
     24md=solve(md,'GiaSolution');
    2525
    2626%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test2052.m

    r19049 r21049  
    2222md.cluster=generic('name',oshostname(),'np',3);
    2323md.verbose=verbose('1111111');
    24 md=solve(md,GiaSolutionEnum());
     24md=solve(md,'GiaSolution');
    2525
    2626%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test2053.m

    r19049 r21049  
    2222md.cluster=generic('name',oshostname(),'np',3);
    2323md.verbose=verbose('1111111');
    24 md=solve(md,GiaSolutionEnum());
     24md=solve(md,'GiaSolution');
    2525
    2626%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test206.m

    r19049 r21049  
    77md.timestepping.time_step=0;
    88md.cluster=generic('name',oshostname(),'np',3);
    9 md=solve(md,ThermalSolutionEnum());
     9md=solve(md,'ThermalSolution');
    1010
    1111%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test206.py

    r19049 r21049  
    1818md.timestepping.time_step=0
    1919md.cluster=generic('name',oshostname(),'np',3)
    20 md=solve(md,ThermalSolutionEnum())
     20md=solve(md,'ThermalSolution')
    2121
    2222

  • issm/trunk-jpl/test/NightlyRun/test207.m

    r19528 r21049  
    1111md.transient.isthermal=1;
    1212md.transient.isgroundingline=0;
    13 md=solve(md,TransientSolutionEnum());
     13md=solve(md,'TransientSolution');
    1414
    1515%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test207.py

    r19528 r21049  
    2222md.transient.isthermal=True
    2323md.transient.isgroundingline=False
    24 md=solve(md,TransientSolutionEnum())
     24md=solve(md,'TransientSolution')
    2525
    2626# Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test2071.m

    r19049 r21049  
    2121md.cluster=generic('name',oshostname(),'np',3);
    2222md.verbose=verbose('1111111');
    23 md=solve(md,GiaSolutionEnum());
     23md=solve(md,'GiaSolution');
    2424
    2525%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test2072.m

    r19049 r21049  
    2121md.cluster=generic('name',oshostname(),'np',3);
    2222md.verbose=verbose('1111111');
    23 md=solve(md,GiaSolutionEnum());
     23md=solve(md,'GiaSolution');
    2424
    2525%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test2073.m

    r19049 r21049  
    2121md.cluster=generic('name',oshostname(),'np',3);
    2222md.verbose=verbose('1111111');
    23 md=solve(md,GiaSolutionEnum());
     23md=solve(md,'GiaSolution');
    2424
    2525%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test208.m

    r20212 r21049  
    77md.transient.requested_outputs={'default','FloatingArea','GroundedArea','TotalGroundedBmb','TotalFloatingBmb'};
    88md.basalforcings.floatingice_melting_rate(:)=1;
    9 md=solve(md,TransientSolutionEnum());
     9md=solve(md,'TransientSolution');
    1010
    1111%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test208.py

    r20215 r21049  
    1818md.cluster=generic('name',oshostname(),'np',3)
    1919md.transient.requested_outputs=['default','FloatingArea','GroundedArea','TotalFloatingBmb','TotalGroundedBmb']
    20 md=solve(md,TransientSolutionEnum())
     20md=solve(md,'TransientSolution')
    2121
    2222

  • issm/trunk-jpl/test/NightlyRun/test2081.m

    r19049 r21049  
    2121md.cluster=generic('name',oshostname(),'np',3);
    2222md.verbose=verbose('1111111');
    23 md=solve(md,GiaSolutionEnum());
     23md=solve(md,'GiaSolution');
    2424
    2525%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test2082.m

    r19049 r21049  
    2121md.cluster=generic('name',oshostname(),'np',3);
    2222md.verbose=verbose('1111111');
    23 md=solve(md,GiaSolutionEnum());
     23md=solve(md,'GiaSolution');
    2424
    2525%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test2083.m

    r19049 r21049  
    2121md.cluster=generic('name',oshostname(),'np',3);
    2222md.verbose=verbose('1111111');
    23 md=solve(md,GiaSolutionEnum());
     23md=solve(md,'GiaSolution');
    2424
    2525%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test209.m

    r19049 r21049  
    66md=setflowequation(md,'SSA','all');
    77md.cluster=generic('name',oshostname(),'np',3);
    8 md=solve(md,TransientSolutionEnum());
     8md=solve(md,'TransientSolution');
    99
    1010%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test209.py

    r19049 r21049  
    1717md=setflowequation(md,'SSA','all')
    1818md.cluster=generic('name',oshostname(),'np',3)
    19 md=solve(md,TransientSolutionEnum())
     19md=solve(md,'TransientSolution')
    2020
    2121

  • issm/trunk-jpl/test/NightlyRun/test210.m

    r19769 r21049  
    77md.cluster=generic('name',oshostname(),'np',3);
    88md.transient.requested_outputs={'default','GroundedArea'};
    9 md=solve(md,TransientSolutionEnum());
     9md=solve(md,'TransientSolution');
    1010
    1111%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test210.py

    r19049 r21049  
    1717md=setflowequation(md,'HO','all')
    1818md.cluster=generic('name',oshostname(),'np',3)
    19 md=solve(md,TransientSolutionEnum())
     19md=solve(md,'TransientSolution')
    2020
    2121

  • issm/trunk-jpl/test/NightlyRun/test211.m

    r20570 r21049  
    77md.stressbalance.reltol=NaN;
    88md.cluster=generic('name',oshostname(),'np',3);
    9 md=solve(md,TransientSolutionEnum());
     9md=solve(md,'TransientSolution');
    1010
    1111%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test211.py

    r20570 r21049  
    1818md.stressbalance.reltol=NaN
    1919md.cluster=generic('name',oshostname(),'np',3)
    20 md=solve(md,TransientSolutionEnum())
     20md=solve(md,'TransientSolution')
    2121
    2222

  • issm/trunk-jpl/test/NightlyRun/test212.m

    r19049 r21049  
    2020
    2121md.cluster=generic('name',oshostname(),'np',3);
    22 md=solve(md,StressbalanceSolutionEnum());
     22md=solve(md,'StressbalanceSolution');
    2323
    2424%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test212.py

    r19049 r21049  
    3434
    3535md.cluster=generic('name',oshostname(),'np',3)
    36 md=solve(md,StressbalanceSolutionEnum())
     36md=solve(md,'StressbalanceSolution')
    3737
    3838

  • issm/trunk-jpl/test/NightlyRun/test213.m

    r19049 r21049  
    2222md.verbose.solution=true;
    2323
    24 md.cluster=generic('name',oshostname(),'np',1);
    25 md=solve(md,StressbalanceSolutionEnum());
     24md.cluster=generic('name',oshostname(),'np',3);
     25md=solve(md,'StressbalanceSolution');
    2626
    2727%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test213.py

    r19049 r21049  
    3535
    3636md.cluster=generic('name',oshostname(),'np',3)
    37 md=solve(md,StressbalanceSolutionEnum())
     37md=solve(md,'StressbalanceSolution')
    3838
    3939

  • issm/trunk-jpl/test/NightlyRun/test214.m

    r19049 r21049  
    2020
    2121md.cluster=generic('name',oshostname(),'np',3);
    22 md=solve(md,StressbalanceSolutionEnum());
     22md=solve(md,'StressbalanceSolution');
    2323
    2424%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test214.py

    r19049 r21049  
    3535
    3636md.cluster=generic('name',oshostname(),'np',3)
    37 md=solve(md,StressbalanceSolutionEnum())
     37md=solve(md,'StressbalanceSolution')
    3838
    3939

  • issm/trunk-jpl/test/NightlyRun/test215.m

    r19337 r21049  
    2020
    2121md.cluster=generic('name',oshostname(),'np',3);
    22 md=solve(md,StressbalanceSolutionEnum());
     22md=solve(md,'StressbalanceSolution');
    2323
    2424%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test215.py

    r19337 r21049  
    3535
    3636md.cluster=generic('name',oshostname(),'np',3)
    37 md=solve(md,StressbalanceSolutionEnum())
     37md=solve(md,'StressbalanceSolution')
    3838
    3939

  • issm/trunk-jpl/test/NightlyRun/test216.m

    r19049 r21049  
    88
    99%rift settings
    10 md.rifts.riftstruct.fill=MelangeEnum();
     10md.rifts.riftstruct.fill='Melange';
    1111md.rifts.riftstruct.fraction=0;
    1212md.stressbalance.rift_penalty_lock=2;
    1313md.stressbalance.rift_penalty_threshold=0;
    1414md.rifts.riftstruct.fractionincrement=.1;
    15 md=solve(md,StressbalanceSolutionEnum());
     15md=solve(md,'StressbalanceSolution');
    1616
    1717%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test216.py

    r19049 r21049  
    2121# rift settings
    2222
    23 md.rifts.riftstruct[0]['fill']=MelangeEnum()
     23md.rifts.riftstruct[0]['fill']='Melange'
    2424md.rifts.riftstruct[0]['fraction']=0
    2525md.stressbalance.rift_penalty_lock=2
    2626md.stressbalance.rift_penalty_threshold=0
    2727md.rifts.riftstruct[0]['fractionincrement']=0.1
    28 md=solve(md,StressbalanceSolutionEnum())
     28md=solve(md,'StressbalanceSolution')
    2929
    3030# Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test217.m

    r19049 r21049  
    5757md.mask.ice_levelset=-1+nodeonicefront;
    5858
    59 md=solve(md,StressbalanceSolutionEnum());
     59md=solve(md,'StressbalanceSolution');
    6060
    6161%create analytical solution: strain rate is constant = ((rho_ice*g*h)/4B)^3 (Paterson, 4th Edition, page 292.

  • issm/trunk-jpl/test/NightlyRun/test217.py

    r19049 r21049  
    7070md.mask.ice_levelset=-1+nodeonicefront
    7171
    72 md=solve(md,StressbalanceSolutionEnum())
     72md=solve(md,'StressbalanceSolution')
    7373
    7474# create analytical solution: strain rate is constant = ((rho_ice*g*h)/4B)^3 (Paterson, 4th Edition, page 292.

  • issm/trunk-jpl/test/NightlyRun/test218.m

    r19658 r21049  
    8686
    8787%solve
    88 md=solve(md,StressbalanceSolutionEnum(),'overwrite','y');
     88md=solve(md,'StressbalanceSolution','overwrite','y');
    8989
    9090%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test219.m

    r19049 r21049  
    66md=setflowequation(md,'HO','../Exp/SquareHalfRight.exp','fill','SSA');
    77md.cluster=generic('name',oshostname(),'np',3);
    8 md=solve(md,StressbalanceSolutionEnum());
     8md=solve(md,'StressbalanceSolution');
    99
    1010%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test219.py

    r19049 r21049  
    1717md=setflowequation(md,'HO','../Exp/SquareHalfRight.exp','fill','SSA')
    1818md.cluster=generic('name',oshostname(),'np',3)
    19 md=solve(md,StressbalanceSolutionEnum())
     19md=solve(md,'StressbalanceSolution')
    2020
    2121# Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test220.m

    r19049 r21049  
    66md=setflowequation(md,'FS','../Exp/SquareHalfRight.exp','fill','HO');
    77md.cluster=generic('name',oshostname(),'np',3);
    8 md=solve(md,StressbalanceSolutionEnum());
     8md.verbose=verbose('all');
     9md=solve(md,'StressbalanceSolution');
    910
    1011%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test220.py

    r19049 r21049  
    1717md=setflowequation(md,'FS','../Exp/SquareHalfRight.exp','fill','HO')
    1818md.cluster=generic('name',oshostname(),'np',3)
    19 md=solve(md,StressbalanceSolutionEnum())
     19md=solve(md,'StressbalanceSolution')
    2020
    2121# Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test221.m

    r19049 r21049  
    77md.cluster=generic('name',oshostname(),'np',3);
    88md.stressbalance.viscosity_overshoot=0;
    9 md=solve(md,StressbalanceSolutionEnum());
     9md=solve(md,'StressbalanceSolution');
    1010
    1111%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test221.py

    r19049 r21049  
    1616md.cluster=generic('name',oshostname(),'np',3)
    1717md.stressbalance.viscosity_overshoot=0
    18 md=solve(md,StressbalanceSolutionEnum())
     18md=solve(md,'StressbalanceSolution')
    1919
    2020#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test222.m

    r19049 r21049  
    66md.cluster=generic('name',oshostname(),'np',3);
    77md.masstransport.hydrostatic_adjustment='Incremental';
    8 md=solve(md,TransientSolutionEnum());
     8md=solve(md,'TransientSolution');
    99
    1010%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test222.py

    r19049 r21049  
    1515md.cluster=generic('name',oshostname(),'np',3)
    1616md.masstransport.hydrostatic_adjustment='Incremental'
    17 md=solve(md,TransientSolutionEnum())
     17md=solve(md,'TransientSolution')
    1818
    1919#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test223.m

    r19049 r21049  
    77md.cluster=generic('name',oshostname(),'np',1);
    88md.masstransport.hydrostatic_adjustment='Incremental';
    9 md=solve(md,TransientSolutionEnum());
     9md=solve(md,'TransientSolution');
    1010
    1111%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test223.py

    r19049 r21049  
    1717md.cluster=generic('name',oshostname(),'np',1)
    1818md.masstransport.hydrostatic_adjustment='Incremental'
    19 md=solve(md,TransientSolutionEnum())
     19md=solve(md,'TransientSolution')
    2020
    2121#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test224.m

    r21029 r21049  
    77md.cluster=generic('name',oshostname(),'np',3);
    88md.masstransport.hydrostatic_adjustment='Incremental';
    9 md=solve(md,TransientSolutionEnum());
     9md=solve(md,'TransientSolution');
    1010
    1111%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test224.py

    r21029 r21049  
    1616md.cluster=generic('name',oshostname(),'np',3)
    1717md.masstransport.hydrostatic_adjustment='Incremental'
    18 md=solve(md,TransientSolutionEnum())
     18md=solve(md,'TransientSolution')
    1919
    2020#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test225.m

    r19049 r21049  
    88md.cluster=generic('name',oshostname(),'np',3);
    99md.masstransport.hydrostatic_adjustment='Incremental';
    10 md=solve(md,TransientSolutionEnum());
     10md=solve(md,'TransientSolution');
    1111
    1212%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test225.py

    r19049 r21049  
    1818md.cluster=generic('name',oshostname(),'np',3)
    1919md.masstransport.hydrostatic_adjustment='Incremental'
    20 md=solve(md,TransientSolutionEnum())
     20md=solve(md,'TransientSolution')
    2121
    2222#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test226.m

    r19315 r21049  
    77md.timestepping.time_adapt=1.;
    88md.timestepping.final_time=15.;
    9 md=solve(md,TransientSolutionEnum());
     9md=solve(md,'TransientSolution');
    1010
    1111%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test226.py

    r19315 r21049  
    1616md.timestepping.time_adapt=1.
    1717md.timestepping.final_time=15.
    18 md=solve(md,TransientSolutionEnum())
     18md=solve(md,'TransientSolution')
    1919
    2020#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test227.m

    r20422 r21049  
    88md.timestepping.time_adapt=1.;
    99md.timestepping.final_time=20.;
    10 md=solve(md,TransientSolutionEnum());
     10md=solve(md,'TransientSolution');
    1111
    1212%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test227.py

    r20422 r21049  
    1717md.timestepping.time_adapt=1.
    1818md.timestepping.final_time=20.
    19 md=solve(md,TransientSolutionEnum())
     19md=solve(md,'TransientSolution')
    2020
    2121#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test228.m

    r19527 r21049  
    1818md.transient.isthermal=0;
    1919
    20 md=solve(md,TransientSolutionEnum());
     20md=solve(md,'TransientSolution');
    2121
    2222%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test228.py

    r19527 r21049  
    2727md.transient.isthermal=False
    2828
    29 md=solve(md,TransientSolutionEnum())
     29md=solve(md,'TransientSolution')
    3030
    3131#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test229.m

    r19527 r21049  
    1818md.transient.isthermal=0;
    1919
    20 md=solve(md,TransientSolutionEnum());
     20md=solve(md,'TransientSolution');
    2121
    2222%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test229.py

    r19527 r21049  
    2727md.transient.isthermal=False
    2828
    29 md=solve(md,TransientSolutionEnum())
     29md=solve(md,'TransientSolution')
    3030
    3131#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test230.m

    r19527 r21049  
    1919md.transient.isthermal=0;
    2020
    21 md=solve(md,TransientSolutionEnum());
     21md=solve(md,'TransientSolution');
    2222
    2323%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test230.py

    r19527 r21049  
    2828md.transient.isthermal=False
    2929
    30 md=solve(md,TransientSolutionEnum())
     30md=solve(md,'TransientSolution')
    3131
    3232#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test231.m

    r19527 r21049  
    1919md.transient.isthermal=0;
    2020
    21 md=solve(md,TransientSolutionEnum());
     21md=solve(md,'TransientSolution');
    2222
    2323%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test231.py

    r19527 r21049  
    2828md.transient.isthermal=False
    2929
    30 md=solve(md,TransientSolutionEnum())
     30md=solve(md,'TransientSolution')
    3131
    3232#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test232.m

    r19528 r21049  
    1414md.transient.isthermal=1;
    1515md.transient.isgroundingline=0;
    16 md=solve(md,TransientSolutionEnum());
     16md=solve(md,'TransientSolution');
    1717
    1818%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test232.py

    r19528 r21049  
    2424md.transient.isthermal=True
    2525md.transient.isgroundingline=False
    26 md=solve(md,TransientSolutionEnum())
     26md=solve(md,'TransientSolution')
    2727
    2828#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test233.m

    r20019 r21049  
    99md.timestepping.time_step=0.5;
    1010md.timestepping.final_time=2.;
    11 md=solve(md,TransientSolutionEnum());
     11md=solve(md,'TransientSolution');
    1212
    1313%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test233.py

    r20019 r21049  
    1919md.timestepping.time_step=0.5
    2020md.timestepping.final_time=2.
    21 md=solve(md,TransientSolutionEnum())
     21md=solve(md,'TransientSolution')
    2222
    2323#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test234.m

    r21037 r21049  
    7272
    7373%solve
    74 md=solve(md,TransientSolutionEnum(),'overwrite','y');
     74md=solve(md,'TransientSolution','overwrite','y');
    7575md.qmu.results=md.results.dakota;
    7676

  • issm/trunk-jpl/test/NightlyRun/test235.m

    r21037 r21049  
    6767
    6868%solve
    69 md=solve(md,TransientSolutionEnum(),'overwrite','y');
     69md=solve(md,'TransientSolution','overwrite','y');
    7070md.qmu.results=md.results.dakota;
    7171

  • issm/trunk-jpl/test/NightlyRun/test236.m

    r19527 r21049  
    6868md=setflowequation(md,'SSA','all');
    6969md.cluster=generic('name',oshostname(),'np',1); % 3 for the cluster
    70 md=solve(md,TransientSolutionEnum());
     70md=solve(md,'TransientSolution');
    7171
    7272%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test236.py

    r19527 r21049  
    7373md=setflowequation(md,'SSA','all')
    7474md.cluster=generic('name',oshostname(),'np',3)
    75 md=solve(md,TransientSolutionEnum())
     75md=solve(md,'TransientSolution')
    7676
    7777#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test237.m

    r20366 r21049  
    6161md=setflowequation(md,'SSA','all');
    6262md.cluster=generic('name',oshostname(),'np',1); % 3 for the cluster
    63 md=solve(md,TransientSolutionEnum);
     63md=solve(md,'TransientSolution');
    6464
    6565%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test237.py

    r20366 r21049  
    7474md=setflowequation(md,'SSA','all')
    7575md.cluster=generic('name',oshostname(),'np',1)
    76 md=solve(md,TransientSolutionEnum())
     76md=solve(md,'TransientSolution')
    7777
    7878#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test238.m

    r19527 r21049  
    4848md=setflowequation(md,'SSA','all');
    4949md.cluster=generic('name',oshostname(),'np',1); % 3 for the cluster
    50 md=solve(md,TransientSolutionEnum());
     50md=solve(md,'TransientSolution');
    5151
    5252%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test238.py

    r19527 r21049  
    5353md=setflowequation(md,'SSA','all')
    5454md.cluster=generic('name',oshostname(),'np',3)
    55 md=solve(md,TransientSolutionEnum())
     55md=solve(md,'TransientSolution')
    5656
    5757#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test239.m

    r19527 r21049  
    4949md=setflowequation(md,'SSA','all');
    5050md.cluster=generic('name',oshostname(),'np',1); % 3 for the cluster
    51 md=solve(md,TransientSolutionEnum());
     51md=solve(md,'TransientSolution');
    5252
    5353%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test239.py

    r19527 r21049  
    5353md=setflowequation(md,'SSA','all')
    5454md.cluster=generic('name',oshostname(),'np',3)
    55 md=solve(md,TransientSolutionEnum())
     55md=solve(md,'TransientSolution')
    5656
    5757#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test240.m

    r19527 r21049  
    4949md=setflowequation(md,'SSA','all');
    5050md.cluster=generic('name',oshostname(),'np',1); % 3 for the cluster
    51 md=solve(md,TransientSolutionEnum());
     51md=solve(md,'TransientSolution');
    5252
    5353%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test240.py

    r19527 r21049  
    5454md=setflowequation(md,'SSA','all')
    5555md.cluster=generic('name',oshostname(),'np',3)
    56 md=solve(md,TransientSolutionEnum())
     56md=solve(md,'TransientSolution')
    5757
    5858#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test241.m

    r19527 r21049  
    1919md.transient.isthermal=0;
    2020
    21 md=solve(md,TransientSolutionEnum());
     21md=solve(md,'TransientSolution');
    2222
    2323%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test241.py

    r19527 r21049  
    2828md.transient.isthermal=False
    2929
    30 md=solve(md,TransientSolutionEnum())
     30md=solve(md,'TransientSolution')
    3131
    3232#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test242.m

    r19527 r21049  
    2020md.transient.isthermal=0;
    2121
    22 md=solve(md,TransientSolutionEnum());
     22md=solve(md,'TransientSolution');
    2323
    2424%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test242.py

    r19527 r21049  
    2929md.transient.isthermal=False
    3030
    31 md=solve(md,TransientSolutionEnum())
     31md=solve(md,'TransientSolution')
    3232
    3333#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test2424.m

    r20188 r21049  
    2323
    2424md.cluster=generic('name',oshostname(),'np',3);
    25 md=solve(md,TransientSolutionEnum());
     25md=solve(md,'TransientSolution');
    2626
    2727%we are checking that the grounding line position is near the theorical one, which is the 0 contour level

  • issm/trunk-jpl/test/NightlyRun/test2425.m

    r20185 r21049  
    1818
    1919md.cluster=generic('name',oshostname(),'np',3);
    20 md=solve(md,TransientSolutionEnum());
     20md=solve(md,'TransientSolution');
    2121vel1=md.results.TransientSolution(end).Vel;
    2222
    … …  
    3333md.slr.sealevel=1000*ones(md.mesh.numberofvertices,1);
    3434
    35 md=solve(md,TransientSolutionEnum(),'checkconsistency','no');
     35md=solve(md,'TransientSolution','checkconsistency','no');
    3636vel2=md.results.TransientSolution(end).Vel;
    3737

  • issm/trunk-jpl/test/NightlyRun/test243.m

    r20952 r21049  
    4141
    4242%Run transient
    43 md=solve(md,TransientSolutionEnum());
     43md=solve(md,'TransientSolution');
    4444
    4545%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test270.m

    r19049 r21049  
    99md=setflowequation(md,'SSA','all');
    1010md.cluster=generic('name',oshostname(),'np',3);
    11 md=solve(md,StressbalanceSolutionEnum());
     11md=solve(md,'StressbalanceSolution');
    1212
    1313%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test270.py

    r19049 r21049  
    2121md=setflowequation(md,'SSA','all')
    2222md.cluster=generic('name',oshostname(),'np',3)
    23 md=solve(md,StressbalanceSolutionEnum())
     23md=solve(md,'StressbalanceSolution')
    2424
    2525#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test272.m

    r19393 r21049  
    2525
    2626md.cluster=generic('name',oshostname(),'np',3);
    27 md=solve(md,StressbalanceSolutionEnum());
     27md=solve(md,'StressbalanceSolution');
    2828
    2929%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test272.py

    r19393 r21049  
    3636
    3737md.cluster=generic('name',oshostname(),'np',3)
    38 md=solve(md,StressbalanceSolutionEnum())
     38md=solve(md,'StressbalanceSolution')
    3939
    4040#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test273.m

    r20308 r21049  
    1414md.damage.kappa=2.8;
    1515
    16 md=solve(md,StressbalanceSolutionEnum());
     16md=solve(md,'StressbalanceSolution');
    1717
    1818%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test273.py

    r19382 r21049  
    2626md.damage.kappa=2.8
    2727
    28 md=solve(md,StressbalanceSolutionEnum())
     28md=solve(md,'StressbalanceSolution')
    2929
    3030#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test274.m

    r19049 r21049  
    1111
    1212md.cluster=generic('name',oshostname(),'np',3);
    13 md=solve(md,StressbalanceSolutionEnum());
     13md=solve(md,'StressbalanceSolution');
    1414
    1515%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test274.py

    r19049 r21049  
    2424
    2525md.cluster=generic('name',oshostname(),'np',3)
    26 md=solve(md,StressbalanceSolutionEnum())
     26print md.rifts.riftstruct[0]['fill']
     27md=solve(md,'StressbalanceSolution')
    2728
    2829#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test275.m

    r19383 r21049  
    2020md=setflowequation(md,'SSA','all');
    2121md.cluster=generic('name',oshostname(),'np',3);
    22 md=solve(md,DamageEvolutionSolutionEnum());
     22md=solve(md,'DamageEvolutionSolution');
    2323
    2424field_names={'D','F'};

  • issm/trunk-jpl/test/NightlyRun/test275.py

    r19383 r21049  
    3333md=setflowequation(md,'SSA','all')
    3434md.cluster=generic('name',oshostname(),'np',3)
    35 md=solve(md,DamageEvolutionSolutionEnum())
     35md=solve(md,'DamageEvolutionSolution')
    3636
    3737field_names=['D','F']

  • issm/trunk-jpl/test/NightlyRun/test280.m

    r19049 r21049  
    1111for i={'P1bubble','P1bubblecondensed','P2'}
    1212        md.flowequation.fe_SSA=i{1};
    13         md=solve(md,StressbalanceSolutionEnum());
     13        md=solve(md,'StressbalanceSolution');
    1414        field_names     ={field_names{:},['Vx' i{1}],['Vy' i{1}],['Vel' i{1}],['Pressure' i{1}]};
    1515        field_tolerances={field_tolerances{:},1e-12,1e-13,1e-13,1e-13};

  • issm/trunk-jpl/test/NightlyRun/test280.py

    r19049 r21049  
    2121for i in ['P1bubble','P1bubblecondensed','P2']:
    2222        md.flowequation.fe_SSA=i
    23         md=solve(md,StressbalanceSolutionEnum())
     23        md=solve(md,'StressbalanceSolution')
    2424        field_names     =field_names+['Vx'+i,'Vy'+i,'Vel'+i,'Pressure'+i]
    2525        field_tolerances=field_tolerances+[1e-12,1e-13,1e-13,1e-13]

  • issm/trunk-jpl/test/NightlyRun/test285.m

    r20816 r21049  
    1212for i={'P1bubble','P1bubblecondensed','P1xP2','P2xP1','P2','P1xP3','P2xP4'}
    1313        md.flowequation.fe_HO=i{1};
    14         md=solve(md,StressbalanceSolutionEnum());
     14        md=solve(md,'StressbalanceSolution');
    1515        field_names     ={field_names{:},['Vx' i{1}],['Vy' i{1}],['Vz' i{1}],['Vel' i{1}],['Pressure' i{1}]};
    1616        field_tolerances={field_tolerances{:},6.5e-08,5e-08,2e-08,5e-08,1e-13};

  • issm/trunk-jpl/test/NightlyRun/test285.py

    r20816 r21049  
    2222for i in ['P1bubble','P1bubblecondensed','P1xP2','P2xP1','P2','P1xP3','P2xP4']:
    2323        md.flowequation.fe_HO=i
    24         md=solve(md,StressbalanceSolutionEnum())
     24        md=solve(md,'StressbalanceSolution')
    2525        field_names     =field_names+['Vx'+i,'Vy'+i,'Vz'+i,'Vel'+i,'Pressure'+i]
    2626        field_tolerances=field_tolerances+[6.5e-08,5e-08,2e-08,5e-08,1e-13]

  • issm/trunk-jpl/test/NightlyRun/test290.m

    r19049 r21049  
    77md.flowequation.fe_FS='TaylorHood';
    88md.cluster=generic('name',oshostname(),'np',3);
    9 md=solve(md,StressbalanceSolutionEnum());
     9md=solve(md,'StressbalanceSolution');
    1010
    1111%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test290.py

    r19049 r21049  
    1717md.flowequation.fe_FS='TaylorHood';
    1818md.cluster=generic('name',oshostname(),'np',3);
    19 md=solve(md,StressbalanceSolutionEnum());
     19md=solve(md,'StressbalanceSolution');
    2020
    2121#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test291.m

    r19049 r21049  
    77md.flowequation.fe_FS='OneLayerP4z';
    88md.cluster=generic('name',oshostname(),'np',1);
    9 md=solve(md,StressbalanceSolutionEnum());
     9md=solve(md,'StressbalanceSolution');
    1010
    1111%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test291.py

    r19049 r21049  
    1717md.flowequation.fe_FS='OneLayerP4z'
    1818md.cluster=generic('name',oshostname(),'np',1)
    19 md=solve(md,StressbalanceSolutionEnum())
     19md=solve(md,'StressbalanceSolution')
    2020
    2121#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test292.m

    r19049 r21049  
    66md.cluster=generic('name',oshostname(),'np',3);
    77md.basalforcings=linearbasalforcings(md.basalforcings);
    8 md=solve(md,TransientSolutionEnum());
     8md=solve(md,'TransientSolution');
    99
    1010%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test292.py

    r19049 r21049  
    1818md.cluster=generic('name',oshostname(),'np',3)
    1919md.basalforcings=linearbasalforcings(md.basalforcings)
    20 md=solve(md,TransientSolutionEnum())
     20md=solve(md,'TransientSolution')
    2121
    2222# Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test293.m

    r20897 r21049  
    1010md.geometry.bed=min(md.geometry.base)*ones(md.mesh.numberofvertices,1);
    1111md.transient.requested_outputs={'default','BasalforcingsFloatingiceMeltingRate'};
    12 md=solve(md,TransientSolutionEnum());
     12md=solve(md,'TransientSolution');
    1313
    1414%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test3001.m

    r19049 r21049  
    99md.toolkits.DefaultAnalysis=issmgslsolver();
    1010
    11 md=solve(md,StressbalanceSolutionEnum());
     11md=solve(md,'StressbalanceSolution');
    1212
    1313%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test3001.py

    r19966 r21049  
    1616md.stressbalance.requested_outputs=['default','DeviatoricStressxx','DeviatoricStressyy','DeviatoricStressxy']
    1717md.autodiff.isautodiff=True
    18 md=solve(md,StressbalanceSolutionEnum())
     18md=solve(md,'StressbalanceSolution')
    1919
    2020#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test3002.m

    r19049 r21049  
    99md.toolkits.DefaultAnalysis=issmgslsolver();
    1010md.verbose=verbose('autodiff',true);
    11 md=solve(md,StressbalanceSolutionEnum());
     11md=solve(md,'StressbalanceSolution');
    1212
    1313%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test3002.py

    r19966 r21049  
    1616md.cluster=generic('name',oshostname(),'np',1)
    1717md.autodiff.isautodiff=True
    18 md=solve(md,StressbalanceSolutionEnum())
     18md=solve(md,'StressbalanceSolution')
    1919
    2020#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test3003.m

    r19049 r21049  
    1010md.toolkits.DefaultAnalysis=issmgslsolver();
    1111md.verbose=verbose('autodiff',true);
    12 md=solve(md,StressbalanceSolutionEnum());
     12md=solve(md,'StressbalanceSolution');
    1313
    1414%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test3003.py

    r19966 r21049  
    1717md.stressbalance.requested_outputs=['default','StressTensorxx','StressTensoryy','StressTensorzz','StressTensorxy','StressTensorxz','StressTensoryz']
    1818md.autodiff.isautodiff=True
    19 md=solve(md,StressbalanceSolutionEnum())
     19md=solve(md,'StressbalanceSolution')
    2020
    2121#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test3004.m

    r19049 r21049  
    99md.toolkits.DefaultAnalysis=issmgslsolver();
    1010md.verbose=verbose('autodiff',true);
    11 md=solve(md,StressbalanceSolutionEnum());
     11md=solve(md,'StressbalanceSolution');
    1212
    1313%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test3004.py

    r19966 r21049  
    1616md.cluster=generic('name',oshostname(),'np',1)
    1717md.autodiff.isautodiff=True
    18 md=solve(md,StressbalanceSolutionEnum())
     18md=solve(md,'StressbalanceSolution')
    1919
    2020#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test3005.m

    r19049 r21049  
    88md.toolkits.DefaultAnalysis=issmgslsolver();
    99md.verbose=verbose('autodiff',true);
    10 md=solve(md,MasstransportSolutionEnum());
     10md=solve(md,'MasstransportSolution');
    1111
    1212%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test3005.py

    r19966 r21049  
    1515md.cluster=generic('name',oshostname(),'np',1)
    1616md.autodiff.isautodiff=True
    17 md=solve(md,MasstransportSolutionEnum())
     17md=solve(md,'MasstransportSolution')
    1818
    1919#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test3006.m

    r19049 r21049  
    1111md.toolkits.DefaultAnalysis=issmgslsolver();
    1212md.verbose=verbose('autodiff',true);
    13 md=solve(md,MasstransportSolutionEnum());
     13md=solve(md,'MasstransportSolution');
    1414
    1515%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test3006.py

    r19966 r21049  
    1919md.masstransport.spcthickness=md.geometry.thickness
    2020md.autodiff.isautodiff=True
    21 md=solve(md,MasstransportSolutionEnum())
     21md=solve(md,'MasstransportSolution')
    2222
    2323#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test3007.m

    r19049 r21049  
    99md.verbose=verbose('autodiff',true);
    1010md.toolkits.DefaultAnalysis=issmgslsolver();
    11 md=solve(md,MasstransportSolutionEnum());
     11md=solve(md,'MasstransportSolution');
    1212
    1313%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test3007.py

    r19966 r21049  
    1616md.cluster=generic('name',oshostname(),'np',1)
    1717md.autodiff.isautodiff=True
    18 md=solve(md,MasstransportSolutionEnum())
     18md=solve(md,'MasstransportSolution')
    1919
    2020#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test3008.m

    r20986 r21049  
    1010md.verbose=verbose('autodiff',true);
    1111md.toolkits.DefaultAnalysis=issmgslsolver();
    12 md=solve(md,ThermalSolutionEnum());
     12md=solve(md,'ThermalSolution');
    1313
    1414%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test3008.py

    r20986 r21049  
    1717md.cluster=generic('name',oshostname(),'np',1)
    1818md.autodiff.isautodiff=True
    19 md=solve(md,ThermalSolutionEnum())
     19md=solve(md,'ThermalSolution')
    2020
    2121#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test3009.m

    r19528 r21049  
    1414md.verbose=verbose('autodiff',true);
    1515md.toolkits.DefaultAnalysis=issmgslsolver();
    16 md=solve(md,TransientSolutionEnum());
     16md=solve(md,'TransientSolution');
    1717
    1818%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test3009.py

    r19966 r21049  
    2121md.transient.isgroundingline=False
    2222md.autodiff.isautodiff=True
    23 md=solve(md,TransientSolutionEnum())
     23md=solve(md,'TransientSolution')
    2424
    2525#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test301.m

    r19049 r21049  
    55md=setflowequation(md,'SSA','all');
    66md.cluster=generic('name',oshostname(),'np',3);
    7 md=solve(md,StressbalanceSolutionEnum());
     7md=solve(md,'StressbalanceSolution');
    88
    99%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test301.py

    r19049 r21049  
    1414md=setflowequation(md,'SSA','all')
    1515md.cluster=generic('name',oshostname(),'np',3)
    16 md=solve(md,StressbalanceSolutionEnum())
     16md=solve(md,'StressbalanceSolution')
    1717
    1818#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test3010.m

    r19049 r21049  
    1010md.verbose=verbose('autodiff',true);
    1111md.toolkits.DefaultAnalysis=issmgslsolver();
    12 md=solve(md,TransientSolutionEnum());
     12md=solve(md,'TransientSolution');
    1313
    1414%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test3010.py

    r19966 r21049  
    1717
    1818md.autodiff.isautodiff=True
    19 md=solve(md,TransientSolutionEnum())
     19md=solve(md,'TransientSolution')
    2020
    2121#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test3015.m

    r20981 r21049  
    4343md=SetIceShelfBC(md);
    4444
    45 md=solve(md,MasstransportSolutionEnum());
     45md=solve(md,'MasstransportSolution');
    4646V0=md.results.MasstransportSolution.IceVolume;
    4747
    … …  
    5454md=SetIceShelfBC(md);
    5555
    56 md=solve(md,MasstransportSolutionEnum());
     56md=solve(md,'MasstransportSolution');
    5757V2=md.results.MasstransportSolution.IceVolume;
    5858
    … …  
    6868md=SetIceShelfBC(md);
    6969
    70 md=solve(md,MasstransportSolutionEnum());
     70md=solve(md,'MasstransportSolution');
    7171%retrieve directly
    7272dVdh_ad=md.results.MasstransportSolution.AutodiffJacobian;

  • issm/trunk-jpl/test/NightlyRun/test3015.py

    r20981 r21049  
    5959md=SetIceShelfBC(md)
    6060
    61 md=solve(md,MasstransportSolutionEnum())
     61md=solve(md,'MasstransportSolution')
    6262V0=md.results.MasstransportSolution.IceVolume
    6363
    … …  
    7070md=SetIceShelfBC(md)
    7171
    72 md=solve(md,MasstransportSolutionEnum())
     72md=solve(md,'MasstransportSolution')
    7373V2=md.results.MasstransportSolution.IceVolume
    7474
    … …  
    8484md=SetIceShelfBC(md)
    8585
    86 md=solve(md,MasstransportSolutionEnum())
     86md=solve(md,'MasstransportSolution')
    8787#retrieve directly
    8888dVdh_ad=md.results.MasstransportSolution.AutodiffJacobian

  • issm/trunk-jpl/test/NightlyRun/test3019.m

    r20981 r21049  
    1616md.autodiff.driver='fos_reverse';
    1717
    18 md=solve(md,TransientSolutionEnum());
     18md=solve(md,'TransientSolution');
    1919
    2020%recover jacobian:
    … …  
    2626md.autodiff.driver='fov_forward';
    2727
    28 md=solve(md,TransientSolutionEnum());
     28md=solve(md,'TransientSolution');
    2929
    3030%recover jacobian:

  • issm/trunk-jpl/test/NightlyRun/test3019.py

    r21023 r21049  
    2828md.autodiff.driver='fos_reverse'
    2929
    30 md=solve(md,TransientSolutionEnum())
     30md=solve(md,'TransientSolution')
    3131
    3232#recover jacobian:
    … …  
    3838md.autodiff.driver='fov_forward'
    3939
    40 md=solve(md,TransientSolutionEnum())
     40md=solve(md,'TransientSolution')
    4141
    4242#recover jacobian:

  • issm/trunk-jpl/test/NightlyRun/test302.m

    r19049 r21049  
    55md=setflowequation(md,'SIA','all');
    66md.cluster=generic('name',oshostname(),'np',3);
    7 md=solve(md,StressbalanceSolutionEnum());
     7md=solve(md,'StressbalanceSolution');
    88
    99%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test302.py

    r19049 r21049  
    1414md=setflowequation(md,'SIA','all')
    1515md.cluster=generic('name',oshostname(),'np',3)
    16 md=solve(md,StressbalanceSolutionEnum())
     16md=solve(md,'StressbalanceSolution')
    1717
    1818#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test3020.m

    r20981 r21049  
    4545md=SetIceShelfBC(md);
    4646
    47 md=solve(md,TransientSolutionEnum());
     47md=solve(md,'TransientSolution');
    4848V0=md.results.TransientSolution(end).IceVolume;
    4949MaxV0=md.results.TransientSolution(end).MaxVel;
    … …  
    5757md=SetIceShelfBC(md);
    5858
    59 md=solve(md,TransientSolutionEnum());
     59md=solve(md,'TransientSolution');
    6060V2=md.results.TransientSolution(end).IceVolume;
    6161MaxV2=md.results.TransientSolution(end).MaxVel;
    … …  
    7373md=SetIceShelfBC(md);
    7474
    75 md=solve(md,TransientSolutionEnum());
     75md=solve(md,'TransientSolution');
    7676%retrieve directly
    7777dVdh_ad=md.results.TransientSolution(1).AutodiffJacobian(1);

  • issm/trunk-jpl/test/NightlyRun/test3020.py

    r20981 r21049  
    6161md=SetIceShelfBC(md)
    6262
    63 md=solve(md,TransientSolutionEnum())
     63md=solve(md,'TransientSolution')
    6464V0=md.results.TransientSolution[-1].IceVolume
    6565MaxV0=md.results.TransientSolution[-1].MaxVel
    … …  
    7373md=SetIceShelfBC(md)
    7474
    75 md=solve(md,TransientSolutionEnum())
     75md=solve(md,'TransientSolution')
    7676V2=md.results.TransientSolution[-1].IceVolume
    7777MaxV2=md.results.TransientSolution[-1].MaxVel
    … …  
    8989md=SetIceShelfBC(md)
    9090
    91 md=solve(md,TransientSolutionEnum())
     91md=solve(md,'TransientSolution')
    9292#retrieve directly
    9393dVdh_ad=md.results.TransientSolution[0].AutodiffJacobian[0]

  • issm/trunk-jpl/test/NightlyRun/test3021.m

    r16462 r21049  
    88md.toolkits.DefaultAnalysis=issmsolver();
    99md.verbose=verbose('all');
    10 md=solve(md,StressbalanceSolutionEnum());
     10md=solve(md,'StressbalanceSolution');
    1111
    1212%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test303.m

    r19049 r21049  
    55md=setflowequation(md,'SIA','../Exp/SquareHalfRight.exp','fill','SSA');
    66md.cluster=generic('name',oshostname(),'np',3);
    7 md=solve(md,StressbalanceSolutionEnum());
     7md=solve(md,'StressbalanceSolution');
    88
    99%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test303.py

    r19049 r21049  
    1414md=setflowequation(md,'SIA','../Exp/SquareHalfRight.exp','fill','SSA')
    1515md.cluster=generic('name',oshostname(),'np',3)
    16 md=solve(md,StressbalanceSolutionEnum())
     16md=solve(md,'StressbalanceSolution')
    1717
    1818#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test304.m

    r19049 r21049  
    66md=setflowequation(md,'SSA','all');
    77md.cluster=generic('name',oshostname(),'np',3);
    8 md=solve(md,StressbalanceSolutionEnum());
     8md=solve(md,'StressbalanceSolution');
    99
    1010%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test304.py

    r19049 r21049  
    1515md=setflowequation(md,'SSA','all')
    1616md.cluster=generic('name',oshostname(),'np',3)
    17 md=solve(md,StressbalanceSolutionEnum())
     17md=solve(md,'StressbalanceSolution')
    1818
    1919#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test305.m

    r19049 r21049  
    66md=setflowequation(md,'SIA','all');
    77md.cluster=generic('name',oshostname(),'np',3);
    8 md=solve(md,StressbalanceSolutionEnum());
     8md=solve(md,'StressbalanceSolution');
    99
    1010%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test305.py

    r19049 r21049  
    1515md=setflowequation(md,'SIA','all')
    1616md.cluster=generic('name',oshostname(),'np',3)
    17 md=solve(md,StressbalanceSolutionEnum())
     17md=solve(md,'StressbalanceSolution')
    1818
    1919#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test306.m

    r19049 r21049  
    66md=setflowequation(md,'SIA','../Exp/SquareHalfRight.exp','fill','SSA');
    77md.cluster=generic('name',oshostname(),'np',3);
    8 md=solve(md,StressbalanceSolutionEnum());
     8md=solve(md,'StressbalanceSolution');
    99
    1010%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test306.py

    r19049 r21049  
    1515md=setflowequation(md,'SIA','../Exp/SquareHalfRight.exp','fill','SSA')
    1616md.cluster=generic('name',oshostname(),'np',3)
    17 md=solve(md,StressbalanceSolutionEnum())
     17md=solve(md,'StressbalanceSolution')
    1818
    1919#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test307.m

    r19049 r21049  
    66md=setflowequation(md,'HO','all');
    77md.cluster=generic('name',oshostname(),'np',3);
    8 md=solve(md,StressbalanceSolutionEnum());
     8md=solve(md,'StressbalanceSolution');
    99
    1010%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test307.py

    r19049 r21049  
    1515md=setflowequation(md,'HO','all')
    1616md.cluster=generic('name',oshostname(),'np',3)
    17 md=solve(md,StressbalanceSolutionEnum())
     17md=solve(md,'StressbalanceSolution')
    1818
    1919#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test308.m

    r19049 r21049  
    66md=setflowequation(md,'FS','all');
    77md.cluster=generic('name',oshostname(),'np',3);
    8 md=solve(md,StressbalanceSolutionEnum());
     8md=solve(md,'StressbalanceSolution');
    99
    1010%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test308.py

    r19049 r21049  
    1515md=setflowequation(md,'FS','all')
    1616md.cluster=generic('name',oshostname(),'np',3)
    17 md=solve(md,StressbalanceSolutionEnum())
     17md=solve(md,'StressbalanceSolution')
    1818
    1919#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test309.m

    r19049 r21049  
    55md=setflowequation(md,'SSA','all');
    66md.cluster=generic('name',oshostname(),'np',3);
    7 md=solve(md,MasstransportSolutionEnum());
     7md=solve(md,'MasstransportSolution');
    88
    99%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test309.py

    r19049 r21049  
    1414md=setflowequation(md,'SSA','all')
    1515md.cluster=generic('name',oshostname(),'np',3)
    16 md=solve(md,MasstransportSolutionEnum())
     16md=solve(md,'MasstransportSolution')
    1717
    1818#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test310.m

    r19051 r21049  
    88md.masstransport.spcthickness=md.geometry.thickness;
    99md.cluster=generic('name',oshostname(),'np',3);
    10 md=solve(md,MasstransportSolutionEnum());
     10md=solve(md,'MasstransportSolution');
    1111
    1212%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test310.py

    r19051 r21049  
    1818md.masstransport.spcthickness=md.geometry.thickness
    1919md.cluster=generic('name',oshostname(),'np',3)
    20 md=solve(md,MasstransportSolutionEnum())
     20md=solve(md,'MasstransportSolution')
    2121
    2222#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test3101.m

    r20986 r21049  
    99md.toolkits.DefaultAnalysis=issmmumpssolver();
    1010
    11 md=solve(md,StressbalanceSolutionEnum());
     11md=solve(md,'StressbalanceSolution');
    1212
    1313%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test3101.py

    r20986 r21049  
    1717
    1818md.autodiff.isautodiff=True
    19 md=solve(md,StressbalanceSolutionEnum())
     19md=solve(md,'StressbalanceSolution')
    2020
    2121#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test3102.m

    r19049 r21049  
    99md.toolkits.DefaultAnalysis=issmmumpssolver();
    1010md.verbose=verbose('autodiff',true);
    11 md=solve(md,StressbalanceSolutionEnum());
     11md=solve(md,'StressbalanceSolution');
    1212
    1313%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test3102.py

    r20001 r21049  
    1717md.autodiff.isautodiff=True
    1818
    19 md=solve(md,StressbalanceSolutionEnum())
     19md=solve(md,'StressbalanceSolution')
    2020
    2121#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test3103.m

    r19049 r21049  
    1010md.toolkits.DefaultAnalysis=issmmumpssolver();
    1111md.verbose=verbose('autodiff',true);
    12 md=solve(md,StressbalanceSolutionEnum());
     12md=solve(md,'StressbalanceSolution');
    1313
    1414%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test3103.py

    r20001 r21049  
    1818
    1919md.autodiff.isautodiff=True
    20 md=solve(md,StressbalanceSolutionEnum())
     20md=solve(md,'StressbalanceSolution')
    2121
    2222#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test3104.m

    r19049 r21049  
    99md.toolkits.DefaultAnalysis=issmmumpssolver();
    1010md.verbose=verbose('autodiff',true);
    11 md=solve(md,StressbalanceSolutionEnum());
     11md=solve(md,'StressbalanceSolution');
    1212
    1313%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test3104.py

    r20001 r21049  
    1717
    1818md.autodiff.isautodiff=True
    19 md=solve(md,StressbalanceSolutionEnum())
     19md=solve(md,'StressbalanceSolution')
    2020
    2121#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test3105.m

    r19049 r21049  
    88md.toolkits.DefaultAnalysis=issmmumpssolver();
    99md.verbose=verbose('autodiff',true);
    10 md=solve(md,MasstransportSolutionEnum());
     10md=solve(md,'MasstransportSolution');
    1111
    1212%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test3105.py

    r20001 r21049  
    1616
    1717md.autodiff.isautodiff=True
    18 md=solve(md,MasstransportSolutionEnum())
     18md=solve(md,'MasstransportSolution')
    1919
    2020#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test3106.m

    r19049 r21049  
    1111md.toolkits.DefaultAnalysis=issmmumpssolver();
    1212md.verbose=verbose('autodiff',true);
    13 md=solve(md,MasstransportSolutionEnum());
     13md=solve(md,'MasstransportSolution');
    1414
    1515%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test3106.py

    r20001 r21049  
    2020
    2121md.autodiff.isautodiff=True
    22 md=solve(md,MasstransportSolutionEnum())
     22md=solve(md,'MasstransportSolution')
    2323
    2424#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test3107.m

    r19049 r21049  
    99md.verbose=verbose('autodiff',true);
    1010md.toolkits.DefaultAnalysis=issmmumpssolver();
    11 md=solve(md,MasstransportSolutionEnum());
     11md=solve(md,'MasstransportSolution');
    1212
    1313%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test3107.py

    r20001 r21049  
    1717
    1818md.autodiff.isautodiff=True
    19 md=solve(md,MasstransportSolutionEnum())
     19md=solve(md,'MasstransportSolution')
    2020
    2121#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test3108.m

    r20986 r21049  
    1010md.verbose=verbose('autodiff',true);
    1111md.toolkits.DefaultAnalysis=issmmumpssolver();
    12 md=solve(md,ThermalSolutionEnum());
     12md=solve(md,'ThermalSolution');
    1313
    1414%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test3108.py

    r20986 r21049  
    1818
    1919md.autodiff.isautodiff=True
    20 md=solve(md,ThermalSolutionEnum())
     20md=solve(md,'ThermalSolution')
    2121
    2222#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test3109.m

    r19528 r21049  
    1414md.verbose=verbose('autodiff',true);
    1515md.toolkits.DefaultAnalysis=issmmumpssolver();
    16 md=solve(md,TransientSolutionEnum());
     16md=solve(md,'TransientSolution');
    1717
    1818%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test3109.py

    r20001 r21049  
    2222
    2323md.autodiff.isautodiff=True
    24 md=solve(md,TransientSolutionEnum())
     24md=solve(md,'TransientSolution')
    2525
    2626#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test311.m

    r19049 r21049  
    66md=extrude(md,5,0.5);
    77md.cluster=generic('name',oshostname(),'np',3);
    8 md=solve(md,MasstransportSolutionEnum());
     8md=solve(md,'MasstransportSolution');
    99
    1010%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test311.py

    r19049 r21049  
    1515md.extrude(5,0.5)
    1616md.cluster=generic('name',oshostname(),'np',3)
    17 md=solve(md,MasstransportSolutionEnum())
     17md=solve(md,'MasstransportSolution')
    1818
    1919#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test3110.m

    r19049 r21049  
    1010md.verbose=verbose('autodiff',true);
    1111md.toolkits.DefaultAnalysis=issmmumpssolver();
    12 md=solve(md,TransientSolutionEnum());
     12md=solve(md,'TransientSolution');
    1313
    1414%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test3110.py

    r20001 r21049  
    1818
    1919md.autodiff.isautodiff=True
    20 md=solve(md,TransientSolutionEnum())
     20md=solve(md,'TransientSolution')
    2121
    2222#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test3119.m

    r20974 r21049  
    1616md.autodiff.driver='fos_reverse';
    1717
    18 md=solve(md,TransientSolutionEnum());
     18md=solve(md,'TransientSolution');
    1919
    2020%recover jacobian:

  • issm/trunk-jpl/test/NightlyRun/test3119.py

    r20974 r21049  
    2626md.autodiff.driver='fos_reverse'
    2727
    28 md=solve(md,TransientSolutionEnum())
     28md=solve(md,'TransientSolution')
    2929
    3030#recover jacobian:

  • issm/trunk-jpl/test/NightlyRun/test312.m

    r19049 r21049  
    77md.timestepping.time_step=0.;
    88md.cluster=generic('name',oshostname(),'np',3);
    9 md=solve(md,ThermalSolutionEnum());
     9md=solve(md,'ThermalSolution');
    1010
    1111%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test312.py

    r19049 r21049  
    1616md.timestepping.time_step=0.
    1717md.cluster=generic('name',oshostname(),'np',3)
    18 md=solve(md,ThermalSolutionEnum())
     18md=solve(md,'ThermalSolution')
    1919
    2020#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test313.m

    r19528 r21049  
    1212md.transient.isthermal=1;
    1313md.transient.isgroundingline=0;
    14 md=solve(md,TransientSolutionEnum());
     14md=solve(md,'TransientSolution');
    1515
    1616%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test313.py

    r19528 r21049  
    2121md.transient.isthermal=True
    2222md.transient.isgroundingline=False
    23 md=solve(md,TransientSolutionEnum())
     23md=solve(md,'TransientSolution')
    2424
    2525#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test314.m

    r19764 r21049  
    66md.cluster=generic('name',oshostname(),'np',3);
    77md.transient.requested_outputs={'default','GroundedArea','FloatingArea','IceVolume'};
    8 md=solve(md,TransientSolutionEnum());
     8md=solve(md,'TransientSolution');
    99
    1010%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test314.py

    r19764 r21049  
    1515md.cluster=generic('name',oshostname(),'np',3)
    1616md.transient.requested_outputs=['default','GroundedArea','FloatingArea','IceVolume']
    17 md=solve(md,TransientSolutionEnum())
     17md=solve(md,'TransientSolution')
    1818
    1919#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test315.m

    r20366 r21049  
    66md=setflowequation(md,'SIA','all');
    77md.cluster=generic('name',oshostname(),'np',3);
    8 md=solve(md,TransientSolutionEnum());
     8md=solve(md,'TransientSolution');
    99
    1010%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test315.py

    r20366 r21049  
    1515md=setflowequation(md,'SIA','all')
    1616md.cluster=generic('name',oshostname(),'np',3)
    17 md=solve(md,TransientSolutionEnum())
     17md=solve(md,'TransientSolution')
    1818
    1919#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test316.m

    r19049 r21049  
    55md=setflowequation(md,'SSA','all');
    66md.cluster=generic('name',oshostname(),'np',3);
    7 md=solve(md,TransientSolutionEnum());
     7md=solve(md,'TransientSolution');
    88
    99%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test316.py

    r19049 r21049  
    1414md=setflowequation(md,'SSA','all')
    1515md.cluster=generic('name',oshostname(),'np',3)
    16 md=solve(md,TransientSolutionEnum())
     16md=solve(md,'TransientSolution')
    1717
    1818#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test317.m

    r20215 r21049  
    88md.cluster=generic('name',oshostname(),'np',3);
    99md.transient.requested_outputs={'default','GroundedArea','FloatingArea','TotalFloatingBmb','TotalGroundedBmb'};
    10 md=solve(md,TransientSolutionEnum());
     10md=solve(md,'TransientSolution');
    1111
    1212%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test317.py

    r20220 r21049  
    1717md.cluster=generic('name',oshostname(),'np',3)
    1818md.transient.requested_outputs=['default','GroundedArea','FloatingArea','TotalFloatingBmb','TotalGroundedBmb']
    19 md=solve(md,TransientSolutionEnum())
     19md=solve(md,'TransientSolution')
    2020
    2121#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test318.m

    r19186 r21049  
    77md.cluster=generic('name',oshostname(),'np',3);
    88md.timestepping.time_step=0;
    9 md=solve(md,SteadystateSolutionEnum());
     9md=solve(md,'SteadystateSolution');
    1010
    1111%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test318.py

    r19187 r21049  
    1616md.cluster=generic('name',oshostname(),'np',3)
    1717md.timestepping.time_step=0
    18 md=solve(md,SteadystateSolutionEnum())
     18md=solve(md,'SteadystateSolution')
    1919
    2020#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test319.m

    r19049 r21049  
    1919
    2020md.cluster=generic('name',oshostname(),'np',3);
    21 md=solve(md,StressbalanceSolutionEnum());
     21md=solve(md,'StressbalanceSolution');
    2222
    2323%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test319.py

    r19049 r21049  
    3131
    3232md.cluster=generic('name',oshostname(),'np',3)
    33 md=solve(md,StressbalanceSolutionEnum())
     33md=solve(md,'StressbalanceSolution')
    3434
    3535#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test320.m

    r19053 r21049  
    2020
    2121md.cluster=generic('name',oshostname(),'np',3);
    22 md=solve(md,StressbalanceSolutionEnum());
     22md=solve(md,'StressbalanceSolution');
    2323
    2424%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test320.py

    r19051 r21049  
    3232
    3333md.cluster=generic('name',oshostname(),'np',3)
    34 md=solve(md,StressbalanceSolutionEnum())
     34md=solve(md,'StressbalanceSolution')
    3535
    3636#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test321.m

    r19049 r21049  
    2020
    2121md.cluster=generic('name',oshostname(),'np',3);
    22 md=solve(md,StressbalanceSolutionEnum());
     22md=solve(md,'StressbalanceSolution');
    2323
    2424%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test321.py

    r19049 r21049  
    3232
    3333md.cluster=generic('name',oshostname(),'np',3)
    34 md=solve(md,StressbalanceSolutionEnum())
     34md=solve(md,'StressbalanceSolution')
    3535
    3636#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test322.m

    r21005 r21049  
    2020
    2121md.cluster=generic('name',oshostname(),'np',3);
    22 md=solve(md,StressbalanceSolutionEnum());
     22md=solve(md,'StressbalanceSolution');
    2323
    2424%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test322.py

    r21005 r21049  
    3232
    3333md.cluster=generic('name',oshostname(),'np',3)
    34 md=solve(md,StressbalanceSolutionEnum())
     34md=solve(md,'StressbalanceSolution')
    3535
    3636#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test323.m

    r19315 r21049  
    77md.timestepping.time_adapt=1;
    88md.timestepping.final_time=1120.;
    9 md=solve(md,TransientSolutionEnum());
     9md=solve(md,'TransientSolution');
    1010
    1111%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test323.py

    r19315 r21049  
    1717md.timestepping.time_adapt=1
    1818md.timestepping.final_time=1120.
    19 md=solve(md,TransientSolutionEnum())
     19md=solve(md,'TransientSolution')
    2020
    2121#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test324.m

    r20368 r21049  
    88md.timestepping.time_adapt=1;
    99md.timestepping.final_time=16000.;
    10 md=solve(md,TransientSolutionEnum());
     10md=solve(md,'TransientSolution');
    1111
    1212%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test324.py

    r20368 r21049  
    1818md.timestepping.time_adapt=1
    1919md.timestepping.final_time=16000.
    20 md=solve(md,TransientSolutionEnum())
     20md=solve(md,'TransientSolution')
    2121
    2222#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test325.m

    r19049 r21049  
    1212
    1313md.cluster=generic('name',oshostname(),'np',3);
    14 md=solve(md,ThermalSolutionEnum());
     14md=solve(md,'ThermalSolution');
    1515
    1616%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test325.py

    r19049 r21049  
    2222
    2323md.cluster=generic('name',oshostname(),'np',3)
    24 md=solve(md,ThermalSolutionEnum())
     24md=solve(md,'ThermalSolution')
    2525
    2626#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test326.m

    r19528 r21049  
    1515md.thermal.isenthalpy=1;
    1616md.thermal.isdynamicbasalspc=1;
    17 md=solve(md,TransientSolutionEnum());
     17md=solve(md,'TransientSolution');
    1818
    1919%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test326.py

    r19528 r21049  
    2525md.thermal.isenthalpy=1
    2626md.thermal.isdynamicbasalspc=1
    27 md=solve(md,TransientSolutionEnum())
     27md=solve(md,'TransientSolution')
    2828
    2929#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test327.m

    r19049 r21049  
    1313md.thermal.isdynamicbasalspc=1;
    1414md.basalforcings.geothermalflux(:)=5.;
    15 md=solve(md,TransientSolutionEnum());
     15md=solve(md,'TransientSolution');
    1616
    1717%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test327.py

    r19049 r21049  
    2323md.thermal.isdynamicbasalspc=1
    2424md.basalforcings.geothermalflux[:]=5.
    25 md=solve(md,TransientSolutionEnum())
     25md=solve(md,'TransientSolution')
    2626
    2727#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test328.m

    r19527 r21049  
    1111md.transient.requested_outputs={'default','TotalSmb'};
    1212md.cluster=generic('name',oshostname(),'np',3);
    13 md=solve(md,TransientSolutionEnum());
     13md=solve(md,'TransientSolution');
    1414
    1515%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test328.py

    r19527 r21049  
    2222md.smb.smbref= 1000. - 0.001*md.mesh.x - 0.005*md.mesh.y;
    2323md.cluster=generic('name',oshostname(),'np',3)
    24 md=solve(md,TransientSolutionEnum())
     24md=solve(md,'TransientSolution')
    2525
    2626#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test329.m

    r19527 r21049  
    1212md.transient.requested_outputs={'default','TotalSmb'};
    1313md.cluster=generic('name',oshostname(),'np',3);
    14 md=solve(md,TransientSolutionEnum());
     14md=solve(md,'TransientSolution');
    1515
    1616%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test329.py

    r19527 r21049  
    2323md.transient.requested_outputs=['default','TotalSmb']
    2424md.cluster=generic('name',oshostname(),'np',3)
    25 md=solve(md,TransientSolutionEnum())
     25md=solve(md,'TransientSolution')
    2626
    2727#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test3300.m

    r19031 r21049  
    4949md.timestepping.final_time=8.0;
    5050
    51 md=solve(md,TransientSolutionEnum());
     51md=solve(md,'TransientSolution');
    5252
    5353field_names     ={'SedimentWaterHead5','EplWaterHead5','SedimentWaterHead40','EplWaterHead40'};

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

    r19049 r21049  
    2121md.timestepping.time_step=0;
    2222md.timestepping.final_time=1.0;
    23 md=solve(md,HydrologySolutionEnum());
     23md=solve(md,'HydrologySolution');
    2424
    2525%Fields and tolerances to track changes

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

    r19049 r21049  
    3737md.timestepping.time_step=0
    3838md.timestepping.final_time=1.0
    39 md=solve(md,HydrologySolutionEnum())
     39md=solve(md,'HydrologySolution')
    4040
    4141#Fields and tolerances to track changes

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

    r20475 r21049  
    3333%md.verbose.solution=1;
    3434
    35 md=solve(md,TransientSolutionEnum());
     35md=solve(md,'TransientSolution');
    3636
    3737%store=md.constants.g*md.hydrology.sediment_porosity*md.materials.rho_freshwater*((md.hydrology.sediment_compressibility/md.hydrology.sediment_porosity)+md.hydrology.water_compressibility);

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

    r20475 r21049  
    4646md.timestepping.final_time=2.0
    4747
    48 md=solve(md,TransientSolutionEnum())
     48md=solve(md,'TransientSolution')
    4949
    5050field_names     =['SedimentWaterHead1','EplWaterHead1','SedimentHeadResidual1', \

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

    r20140 r21049  
    2222md.timestepping.final_time=1.0;
    2323md=extrude(md,3,1.1);
    24 md=solve(md,HydrologySolutionEnum());
     24md=solve(md,'HydrologySolution');
    2525
    2626%Fields and tolerances to track changes

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

    r20662 r21049  
    3333%md.verbose.solution=1;
    3434md=extrude(md,3,1.1);
    35 md=solve(md,TransientSolutionEnum());
     35md=solve(md,'TransientSolution');
    3636
    3737%store=md.constants.g*md.hydrology.sediment_porosity* ...

  • issm/trunk-jpl/test/NightlyRun/test336.m

    r19527 r21049  
    2020md.transient.isthermal=0;
    2121
    22 md=solve(md,TransientSolutionEnum());
     22md=solve(md,'TransientSolution');
    2323
    2424%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test336.py

    r19527 r21049  
    3030md.transient.isthermal=False
    3131
    32 md=solve(md,TransientSolutionEnum())
     32md=solve(md,'TransientSolution')
    3333
    3434#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test337.m

    r19527 r21049  
    2121md.transient.isthermal=0;
    2222
    23 md=solve(md,TransientSolutionEnum());
     23md=solve(md,'TransientSolution');
    2424
    2525%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test337.py

    r19527 r21049  
    3131md.transient.isthermal=False
    3232
    33 md=solve(md,TransientSolutionEnum())
     33md=solve(md,'TransientSolution')
    3434
    3535#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test338.m

    r19527 r21049  
    2121md.transient.isthermal=0;
    2222
    23 md=solve(md,TransientSolutionEnum());
     23md=solve(md,'TransientSolution');
    2424
    2525%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test338.py

    r19527 r21049  
    3131md.transient.isthermal=False
    3232
    33 md=solve(md,TransientSolutionEnum())
     33md=solve(md,'TransientSolution')
    3434
    3535#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test339.m

    r19527 r21049  
    2222md.transient.isthermal=0;
    2323
    24 md=solve(md,TransientSolutionEnum());
     24md=solve(md,'TransientSolution');
    2525
    2626%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test339.py

    r19527 r21049  
    3232md.transient.isthermal=False
    3333
    34 md=solve(md,TransientSolutionEnum())
     34md=solve(md,'TransientSolution')
    3535
    3636#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test340.m

    r19049 r21049  
    1919
    2020md.cluster=generic('name',oshostname(),'np',3);
    21 md=solve(md,StressbalanceSolutionEnum());
     21md=solve(md,'StressbalanceSolution');
    2222
    2323%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test341.m

    r19835 r21049  
    1919
    2020md.cluster=generic('name',oshostname(),'np',3);
    21 md=solve(md,StressbalanceSolutionEnum());
     21md=solve(md,'StressbalanceSolution');
    2222
    2323%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test341.py

    r20335 r21049  
    3232
    3333md.cluster=generic('name',oshostname(),'np',3);
    34 md=solve(md,StressbalanceSolutionEnum());
     34md=solve(md,'StressbalanceSolution');
    3535
    3636#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test342.m

    r20082 r21049  
    1313md.thermal.requested_outputs={'default','BasalforcingsGeothermalflux'};
    1414md.cluster=generic('name',oshostname(),'np',3);
    15 md=solve(md,ThermalSolutionEnum());
     15md=solve(md,'ThermalSolution');
    1616
    1717%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test350.m

    r20244 r21049  
    5353md.hydrology.neumannflux(pos,:)=repmat(0.05*(1-sin(2*pi/(1/365)*time)),numel(pos),1);
    5454
    55 md=solve(md,TransientSolutionEnum());
     55md=solve(md,'TransientSolution');
    5656
    5757%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test401.m

    r19049 r21049  
    55md=setflowequation(md,'SSA','all');
    66md.cluster=generic('name',oshostname(),'np',3);
    7 md=solve(md,StressbalanceSolutionEnum());
     7md=solve(md,'StressbalanceSolution');
    88
    99%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test401.py

    r19049 r21049  
    1515md=setflowequation(md,'SSA','all')
    1616md.cluster=generic('name',oshostname(),'np',3)
    17 md=solve(md,StressbalanceSolutionEnum())
     17md=solve(md,'StressbalanceSolution')
    1818
    1919#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test402.m

    r19049 r21049  
    66md=setflowequation(md,'SSA','all');
    77md.cluster=generic('name',oshostname(),'np',3);
    8 md=solve(md,StressbalanceSolutionEnum());
     8md=solve(md,'StressbalanceSolution');
    99
    1010%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test402.py

    r19049 r21049  
    1616md=setflowequation(md,'SSA','all')
    1717md.cluster=generic('name',oshostname(),'np',3)
    18 md=solve(md,StressbalanceSolutionEnum())
     18md=solve(md,'StressbalanceSolution')
    1919
    2020#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test403.m

    r20488 r21049  
    66md=setflowequation(md,'HO','all');
    77md.cluster=generic('name',oshostname(),'np',3);
    8 md=solve(md,StressbalanceSolutionEnum());
     8md=solve(md,'StressbalanceSolution');
    99
    1010%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test403.py

    r20488 r21049  
    1616md=setflowequation(md,'HO','all')
    1717md.cluster=generic('name',oshostname(),'np',3)
    18 md=solve(md,StressbalanceSolutionEnum())
     18md=solve(md,'StressbalanceSolution')
    1919
    2020#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test404.m

    r20525 r21049  
    66md=setflowequation(md,'FS','all');
    77md.cluster=generic('name',oshostname(),'np',3);
    8 md=solve(md,StressbalanceSolutionEnum());
     8md=solve(md,'StressbalanceSolution');
    99
    1010%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test404.py

    r20525 r21049  
    1616md=setflowequation(md,'FS','all')
    1717md.cluster=generic('name',oshostname(),'np',3)
    18 md=solve(md,StressbalanceSolutionEnum())
     18md=solve(md,'StressbalanceSolution')
    1919
    2020#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test405.m

    r19049 r21049  
    66md=setflowequation(md,'SSA','../Exp/SquareHalfRight.exp','fill','HO','coupling','penalties');
    77md.cluster=generic('name',oshostname(),'np',3);
    8 md=solve(md,StressbalanceSolutionEnum());
     8md=solve(md,'StressbalanceSolution');
    99
    1010%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test405.py

    r19049 r21049  
    1616md=setflowequation(md,'SSA','../Exp/SquareHalfRight.exp','fill','HO','coupling','penalties')
    1717md.cluster=generic('name',oshostname(),'np',3)
    18 md=solve(md,StressbalanceSolutionEnum())
     18md=solve(md,'StressbalanceSolution')
    1919
    2020#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test406.m

    r19049 r21049  
    77md.cluster=generic('name',oshostname(),'np',3);
    88md.timestepping.time_step=0.;
    9 md=solve(md,ThermalSolutionEnum());
     9md=solve(md,'ThermalSolution');
    1010
    1111%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test406.py

    r19049 r21049  
    1717md.cluster=generic('name',oshostname(),'np',3)
    1818md.timestepping.time_step=0.
    19 md=solve(md,ThermalSolutionEnum())
     19md=solve(md,'ThermalSolution')
    2020
    2121#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test407.m

    r19528 r21049  
    1111md.transient.isthermal=1;
    1212md.transient.isgroundingline=0;
    13 md=solve(md,TransientSolutionEnum());
     13md=solve(md,'TransientSolution');
    1414
    1515%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test407.py

    r19528 r21049  
    2121md.transient.isthermal=True
    2222md.transient.isgroundingline=False
    23 md=solve(md,TransientSolutionEnum())
     23md=solve(md,'TransientSolution')
    2424
    2525#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test408.m

    r20215 r21049  
    88md.cluster=generic('name',oshostname(),'np',3);
    99md.transient.requested_outputs={'default','GroundedArea','FloatingArea','TotalFloatingBmb','TotalGroundedBmb','TotalSmb'};
    10 md=solve(md,TransientSolutionEnum());
     10md=solve(md,'TransientSolution');
    1111
    1212%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test408.py

    r20221 r21049  
    1818md.cluster=generic('name',oshostname(),'np',3)
    1919md.transient.requested_outputs=['default','GroundedArea','FloatingArea','TotalFloatingBmb','TotalGroundedBmb','TotalSmb']
    20 md=solve(md,TransientSolutionEnum())
     20md=solve(md,'TransientSolution')
    2121
    2222#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test409.m

    r19523 r21049  
    77md.cluster=generic('name',oshostname(),'np',1);
    88md.transient.requested_outputs={'default','GroundedArea'};
    9 md=solve(md,TransientSolutionEnum());
     9md=solve(md,'TransientSolution');
    1010
    1111%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test409.py

    r19523 r21049  
    1717md.cluster=generic('name',oshostname(),'np',3)
    1818md.transient.requested_outputs=['default','GroundedArea'];
    19 md=solve(md,TransientSolutionEnum())
     19md=solve(md,'TransientSolution')
    2020
    2121#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test410.m

    r20094 r21049  
    77md.cluster=generic('name',oshostname(),'np',3);
    88md.timestepping.time_step=0;
    9 md=solve(md,SteadystateSolutionEnum());
     9md=solve(md,'SteadystateSolution');
    1010
    1111%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test410.py

    r20096 r21049  
    1717md.cluster=generic('name',oshostname(),'np',3)
    1818md.timestepping.time_step=0
    19 md=solve(md,SteadystateSolutionEnum())
     19md=solve(md,'SteadystateSolution')
    2020
    2121#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test411.m

    r19049 r21049  
    77md.cluster=generic('name',oshostname(),'np',3);
    88md.timestepping.time_step=0;
    9 md=solve(md,SteadystateSolutionEnum());
     9md=solve(md,'SteadystateSolution');
    1010
    1111%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test411.py

    r19049 r21049  
    1717md.cluster=generic('name',oshostname(),'np',3)
    1818md.timestepping.time_step=0.
    19 md=solve(md,SteadystateSolutionEnum())
     19md=solve(md,'SteadystateSolution')
    2020
    2121#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test412.m

    r19658 r21049  
    4646
    4747%solve
    48 md=solve(md,StressbalanceSolutionEnum(),'overwrite','y');
     48md=solve(md,'StressbalanceSolution','overwrite','y');
    4949
    5050%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test413.m

    r19658 r21049  
    4444
    4545%solve
    46 md=solve(md,StressbalanceSolutionEnum(),'overwrite','y');
     46md=solve(md,'StressbalanceSolution','overwrite','y');
    4747
    4848%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test414.m

    r19658 r21049  
    6161
    6262%solve
    63 md=solve(md,StressbalanceSolutionEnum(),'overwrite','y');
     63md=solve(md,'StressbalanceSolution','overwrite','y');
    6464md.qmu.results=md.results.dakota;
    6565

  • issm/trunk-jpl/test/NightlyRun/test415.m

    r19049 r21049  
    2121
    2222md.cluster=generic('name',oshostname(),'np',3);
    23 md=solve(md,SteadystateSolutionEnum());
     23md=solve(md,'SteadystateSolution');
    2424
    2525%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test415.py

    r19049 r21049  
    3333
    3434md.cluster=generic('name',oshostname(),'np',3)
    35 md=solve(md,SteadystateSolutionEnum())
     35md=solve(md,'SteadystateSolution')
    3636
    3737#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test416.m

    r19049 r21049  
    2121
    2222md.cluster=generic('name',oshostname(),'np',3);
    23 md=solve(md,SteadystateSolutionEnum());
     23md=solve(md,'SteadystateSolution');
    2424
    2525%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test416.py

    r19049 r21049  
    3333
    3434md.cluster=generic('name',oshostname(),'np',3)
    35 md=solve(md,SteadystateSolutionEnum())
     35md=solve(md,'SteadystateSolution')
    3636
    3737#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test417.m

    r19658 r21049  
    6666md.stressbalance.reltol=10^-5; %tighten for qmu analyses
    6767
    68 md=solve(md,StressbalanceSolutionEnum(),'overwrite','y');
     68md=solve(md,'StressbalanceSolution','overwrite','y');
    6969
    7070%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test419.m

    r19049 r21049  
    66md=setflowequation(md,'SSA','../Exp/SquareHalfRight.exp','fill','HO');
    77md.cluster=generic('name',oshostname(),'np',3);
    8 md=solve(md,StressbalanceSolutionEnum());
     8md=solve(md,'StressbalanceSolution');
    99
    1010%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test419.py

    r19049 r21049  
    1616md=setflowequation(md,'SSA','../Exp/SquareHalfRight.exp','fill','HO')
    1717md.cluster=generic('name',oshostname(),'np',3)
    18 md=solve(md,StressbalanceSolutionEnum())
     18md=solve(md,'StressbalanceSolution')
    1919
    2020#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test420.m

    r19658 r21049  
    4545
    4646%solve
    47 md=solve(md,StressbalanceSolutionEnum(),'overwrite','y');
     47md=solve(md,'StressbalanceSolution','overwrite','y');
    4848md.qmu.results=md.results.dakota;
    4949

  • issm/trunk-jpl/test/NightlyRun/test421.m

    r19049 r21049  
    66md=setflowequation(md,'FS','../Exp/SquareHalfRight.exp','fill','HO');
    77md.cluster=generic('name',oshostname(),'np',3);
    8 md=solve(md,StressbalanceSolutionEnum());
     8md=solve(md,'StressbalanceSolution');
    99
    1010%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test421.py

    r19049 r21049  
    1616md=setflowequation(md,'FS','../Exp/SquareHalfRight.exp','fill','HO')
    1717md.cluster=generic('name',oshostname(),'np',3)
    18 md=solve(md,StressbalanceSolutionEnum())
     18md=solve(md,'StressbalanceSolution')
    1919
    2020#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test422.m

    r20504 r21049  
    77md.cluster=generic('name',oshostname(),'np',3);
    88md.stressbalance.reltol=0.4;
    9 md=solve(md,StressbalanceSolutionEnum());
     9md=solve(md,'StressbalanceSolution');
    1010
    1111%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test422.py

    r20504 r21049  
    1717md.cluster=generic('name',oshostname(),'np',3)
    1818md.stressbalance.reltol=0.4
    19 md=solve(md,StressbalanceSolutionEnum())
     19md=solve(md,'StressbalanceSolution')
    2020
    2121#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test423.m

    r19529 r21049  
    2727%test different grounding line dynamics.
    2828md.groundingline.migration='AggressiveMigration';
    29 md=solve(md,TransientSolutionEnum());
     29md=solve(md,'TransientSolution');
    3030element_on_iceshelf_agressive=(md.results.TransientSolution.MaskGroundediceLevelset);
    3131vel_agressive=(md.results.TransientSolution.Vel);
    3232
    3333md.groundingline.migration='SoftMigration';
    34 md=solve(md,TransientSolutionEnum());
     34md=solve(md,'TransientSolution');
    3535element_on_iceshelf_soft=(md.results.TransientSolution.MaskGroundediceLevelset);
    3636vel_soft=(md.results.TransientSolution.Vel);
    … …  
    3838md.mask.groundedice_levelset=md.geometry.thickness + md.materials.rho_water/md.materials.rho_ice*md.geometry.bed;
    3939md.groundingline.migration='SubelementMigration';
    40 md=solve(md,TransientSolutionEnum());
     40md=solve(md,'TransientSolution');
    4141element_on_iceshelf_subelement=(md.results.TransientSolution.MaskGroundediceLevelset);
    4242vel_subelement=(md.results.TransientSolution.Vel);
    4343
    4444md.groundingline.migration='SubelementMigration2';
    45 md=solve(md,TransientSolutionEnum());
     45md=solve(md,'TransientSolution');
    4646element_on_iceshelf_subelement2=(md.results.TransientSolution.MaskGroundediceLevelset);
    4747vel_subelement2=(md.results.TransientSolution.Vel);

  • issm/trunk-jpl/test/NightlyRun/test423.py

    r19529 r21049  
    3838#test different grounding line dynamics.
    3939md.groundingline.migration='AggressiveMigration'
    40 md=solve(md,TransientSolutionEnum())
     40md=solve(md,'TransientSolution')
    4141element_on_iceshelf_agressive=md.results.TransientSolution[0].MaskGroundediceLevelset
    4242vel_agressive=md.results.TransientSolution[0].Vel
    4343
    4444md.groundingline.migration='SoftMigration'
    45 md=solve(md,TransientSolutionEnum())
     45md=solve(md,'TransientSolution')
    4646element_on_iceshelf_soft=md.results.TransientSolution[0].MaskGroundediceLevelset
    4747vel_soft=md.results.TransientSolution[0].Vel
    … …  
    4949md.mask.groundedice_levelset=md.geometry.thickness + md.materials.rho_water/md.materials.rho_ice*md.geometry.bed
    5050md.groundingline.migration='SubelementMigration'
    51 md=solve(md,TransientSolutionEnum())
     51md=solve(md,'TransientSolution')
    5252element_on_iceshelf_subelement=md.results.TransientSolution[0].MaskGroundediceLevelset
    5353vel_subelement=md.results.TransientSolution[0].Vel
    5454
    5555md.groundingline.migration='SubelementMigration2'
    56 md=solve(md,TransientSolutionEnum())
     56md=solve(md,'TransientSolution')
    5757element_on_iceshelf_subelement2=md.results.TransientSolution[0].MaskGroundediceLevelset
    5858vel_subelement2=md.results.TransientSolution[0].Vel

  • issm/trunk-jpl/test/NightlyRun/test424.m

    r19527 r21049  
    1717
    1818md.cluster=generic('name',oshostname(),'np',3);
    19 md=solve(md,TransientSolutionEnum());
     19md=solve(md,'TransientSolution');
    2020
    2121%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test424.py

    r19527 r21049  
    2727
    2828md.cluster=generic('name',oshostname(),'np',3)
    29 md=solve(md,TransientSolutionEnum())
     29md=solve(md,'TransientSolution')
    3030
    3131#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test425.m

    r19527 r21049  
    1616
    1717md.cluster=generic('name',oshostname(),'np',3);
    18 md=solve(md,TransientSolutionEnum());
     18md=solve(md,'TransientSolution');
    1919
    2020%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test425.py

    r19527 r21049  
    2626
    2727md.cluster=generic('name',oshostname(),'np',3)
    28 md=solve(md,TransientSolutionEnum())
     28md=solve(md,'TransientSolution')
    2929
    3030#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test426.m

    r19527 r21049  
    1818md.cluster=generic('name',oshostname(),'np',3);
    1919
    20 md=solve(md,TransientSolutionEnum());
     20md=solve(md,'TransientSolution');
    2121
    2222%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test426.py

    r19527 r21049  
    2828md.cluster=generic('name',oshostname(),'np',3)
    2929
    30 md=solve(md,TransientSolutionEnum())
     30md=solve(md,'TransientSolution')
    3131
    3232#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test427.m

    r19527 r21049  
    1717md.groundingline.migration='SoftMigration';
    1818md.cluster=generic('name',oshostname(),'np',3);
    19 md=solve(md,TransientSolutionEnum());
     19md=solve(md,'TransientSolution');
    2020
    2121%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test427.py

    r19527 r21049  
    2727md.groundingline.migration='SoftMigration'
    2828md.cluster=generic('name',oshostname(),'np',3)
    29 md=solve(md,TransientSolutionEnum())
     29md=solve(md,'TransientSolution')
    3030
    3131#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test428.m

    r19049 r21049  
    77md.stressbalance.restol=0.0001;
    88md.cluster=generic('name',oshostname(),'np',3);
    9 md=solve(md,StressbalanceSolutionEnum());
     9md=solve(md,'StressbalanceSolution');
    1010
    1111%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test428.py

    r19049 r21049  
    1717md.stressbalance.restol=0.0001
    1818md.cluster=generic('name',oshostname(),'np',3)
    19 md=solve(md,StressbalanceSolutionEnum())
     19md=solve(md,'StressbalanceSolution')
    2020
    2121#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test429.m

    r19049 r21049  
    88md.stressbalance.restol=0.0001;
    99md.cluster=generic('name',oshostname(),'np',3);
    10 md=solve(md,StressbalanceSolutionEnum());
     10md=solve(md,'StressbalanceSolution');
    1111
    1212%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test429.py

    r19049 r21049  
    1818md.stressbalance.restol=0.0001
    1919md.cluster=generic('name',oshostname(),'np',3)
    20 md=solve(md,StressbalanceSolutionEnum())
     20md=solve(md,'StressbalanceSolution')
    2121
    2222#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test431.m

    r19648 r21049  
    1111md.initialization.waterfraction=zeros(md.mesh.numberofvertices,1);
    1212md.initialization.watercolumn=zeros(md.mesh.numberofvertices,1);
    13 md=solve(md,SteadystateSolutionEnum());
     13md=solve(md,'SteadystateSolution');
    1414
    1515%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test431.py

    r19648 r21049  
    2121md.initialization.waterfraction=numpy.zeros((md.mesh.numberofvertices,1))
    2222md.initialization.watercolumn=numpy.zeros((md.mesh.numberofvertices,1))
    23 md=solve(md,SteadystateSolutionEnum())
     23md=solve(md,'SteadystateSolution')
    2424
    2525#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test432.m

    r19868 r21049  
    1010md.initialization.waterfraction=zeros(md.mesh.numberofvertices,1);
    1111md.initialization.watercolumn=zeros(md.mesh.numberofvertices,1);
    12 md=solve(md,SteadystateSolutionEnum());
     12md=solve(md,'SteadystateSolution');
    1313
    1414%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test432.py

    r19868 r21049  
    2020md.initialization.waterfraction=numpy.zeros((md.mesh.numberofvertices,1))
    2121md.initialization.watercolumn=numpy.zeros((md.mesh.numberofvertices,1))
    22 md=solve(md,SteadystateSolutionEnum())
     22md=solve(md,'SteadystateSolution')
    2323
    2424#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test433.m

    r20215 r21049  
    2828%test different grounding line dynamics.
    2929md.groundingline.migration='AggressiveMigration';
    30 md=solve(md,TransientSolutionEnum());
     30md=solve(md,'TransientSolution');
    3131element_on_iceshelf_agressive=(md.results.TransientSolution.MaskGroundediceLevelset);
    3232
    3333md.groundingline.migration='SoftMigration';
    34 md=solve(md,TransientSolutionEnum());
     34md=solve(md,'TransientSolution');
    3535element_on_iceshelf_soft=(md.results.TransientSolution.MaskGroundediceLevelset);
    3636
    3737md.groundingline.migration='SubelementMigration';
    38 md=solve(md,TransientSolutionEnum());
     38md=solve(md,'TransientSolution');
    3939element_on_iceshelf_subelement=(md.results.TransientSolution.MaskGroundediceLevelset);
    4040
    … …  
    4242md.transient.isstressbalance=1;
    4343md=setflowequation(md,'SSA','all');
    44 md=solve(md,TransientSolutionEnum());
     44md=solve(md,'TransientSolution');
    4545element_on_iceshelf_subelement2=(md.results.TransientSolution.MaskGroundediceLevelset);
    4646

  • issm/trunk-jpl/test/NightlyRun/test433.py

    r19529 r21049  
    3939#test different grounding line dynamics.
    4040md.groundingline.migration='AggressiveMigration'
    41 md=solve(md,TransientSolutionEnum())
     41md=solve(md,'TransientSolution')
    4242element_on_iceshelf_agressive=md.results.TransientSolution[0].MaskGroundediceLevelset
    4343
    4444md.groundingline.migration='SoftMigration'
    45 md=solve(md,TransientSolutionEnum())
     45md=solve(md,'TransientSolution')
    4646element_on_iceshelf_soft=md.results.TransientSolution[0].MaskGroundediceLevelset
    4747
    4848md.groundingline.migration='SubelementMigration'
    49 md=solve(md,TransientSolutionEnum())
     49md=solve(md,'TransientSolution')
    5050element_on_iceshelf_subelement=md.results.TransientSolution[0].MaskGroundediceLevelset
    5151

  • issm/trunk-jpl/test/NightlyRun/test434.m

    r19049 r21049  
    66md=setflowequation(md,'L1L2','all');
    77md.cluster=generic('name',oshostname(),'np',3);
    8 md=solve(md,StressbalanceSolutionEnum());
     8md=solve(md,'StressbalanceSolution');
    99
    1010%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test434.py

    r19049 r21049  
    1616md=setflowequation(md,'L1L2','all')
    1717md.cluster=generic('name',oshostname(),'np',3)
    18 md=solve(md,StressbalanceSolutionEnum())
     18md=solve(md,'StressbalanceSolution')
    1919
    2020#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test435.m

    r19527 r21049  
    4444
    4545md.cluster=generic('name',oshostname(),'np',3);
    46 md=solve(md,TransientSolutionEnum());
     46md=solve(md,'TransientSolution');
    4747
    4848%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test436.m

    r20629 r21049  
    2020
    2121        md.materials.rheology_law=i{1};
    22         md=solve(md,SteadystateSolutionEnum());
     22        md=solve(md,'SteadystateSolution');
    2323        field_names     ={field_names{:},['Vx' i{1}],['Vy' i{1}],['Vz' i{1}],['Vel' i{1}],['Pressure' i{1}],...
    2424                ['Temperature' i{1}],['Waterfraction' i{1}],['Enthalpy' i{1}]};

  • issm/trunk-jpl/test/NightlyRun/test437.m

    r19528 r21049  
    4545md.verbose=verbose(0);
    4646md.cluster=generic('name',oshostname(),'np',3);
    47 md=solve(md, TransientSolutionEnum());
     47md=solve(md,'TransientSolution');
    4848
    4949%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test438.m

    r19373 r21049  
    1010md.friction.f=0.8;
    1111md.cluster=generic('name',oshostname(),'np',3);
    12 md=solve(md,TransientSolutionEnum());
     12md=solve(md,'TransientSolution');
    1313
    1414%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test439.m

    r19373 r21049  
    1111md.friction.f=0.8;
    1212md.cluster=generic('name',oshostname(),'np',3);
    13 md=solve(md,TransientSolutionEnum());
     13md=solve(md,'TransientSolution');
    1414
    1515%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test450.m

    r19049 r21049  
    1111for i={'P1bubble','P1bubblecondensed','P2'}
    1212        md.flowequation.fe_SSA=i{1};
    13         md=solve(md,StressbalanceSolutionEnum());
     13        md=solve(md,'StressbalanceSolution');
    1414        field_names     ={field_names{:},['Vx' i{1}],['Vy' i{1}],['Vel' i{1}],['Pressure' i{1}]};
    1515        field_tolerances={field_tolerances{:},1e-12,1e-13,1e-13,1e-13};

  • issm/trunk-jpl/test/NightlyRun/test450.py

    r19049 r21049  
    2121for i in ['P1bubble','P1bubblecondensed','P2']:
    2222        md.flowequation.fe_SSA=i
    23         md=solve(md,StressbalanceSolutionEnum())
     23        md=solve(md,'StressbalanceSolution')
    2424        field_names     =field_names+['Vx'+i,'Vy'+i,'Vel'+i,'Pressure'+i]
    2525        field_tolerances=field_tolerances+[1e-12,1e-13,1e-13,1e-13]

  • issm/trunk-jpl/test/NightlyRun/test455.m

    r20816 r21049  
    1212for i={'P1bubble','P1bubblecondensed','P1xP2','P2xP1','P2','P1xP3','P2xP4'}
    1313        md.flowequation.fe_HO=i{1};
    14         md=solve(md,StressbalanceSolutionEnum());
     14        md=solve(md,'StressbalanceSolution');
    1515        field_names     ={field_names{:},['Vx' i{1}],['Vy' i{1}],['Vz' i{1}],['Vel' i{1}],['Pressure' i{1}]};
    1616        field_tolerances={field_tolerances{:},6e-08,6e-08,6e-08,6e-08,3e-13};

  • issm/trunk-jpl/test/NightlyRun/test455.py

    r20816 r21049  
    2222for i in ['P1bubble','P1bubblecondensed','P1xP2','P2xP1','P2','P1xP3','P2xP4']:
    2323        md.flowequation.fe_HO=i
    24         md=solve(md,StressbalanceSolutionEnum())
     24        md=solve(md,'StressbalanceSolution')
    2525        field_names     =field_names+['Vx'+i,'Vy'+i,'Vz'+i,'Vel'+i,'Pressure'+i]
    2626        field_tolerances=field_tolerances+[6e-08,6e-08,6e-08,6e-08,3e-13]

  • issm/trunk-jpl/test/NightlyRun/test460.m

    r20946 r21049  
    1919        disp(['====== Testing Estar with ' i{1} ' =====']);
    2020        md=setflowequation(md,i{1},'all');
    21         md=solve(md,StressbalanceSolutionEnum());
     21        md=solve(md,'StressbalanceSolution');
    2222        field_names     ={field_names{:},['Vx' i{1}],['Vy' i{1}],['Vz' i{1}],['Vel' i{1}],['Pressure' i{1}]};
    2323        field_tolerances={field_tolerances{:},6e-07,6e-07,2e-06,1e-06,5e-07};

  • issm/trunk-jpl/test/NightlyRun/test501.m

    r19049 r21049  
    55md=setflowequation(md,'SSA','all');
    66md.cluster=generic('name',oshostname(),'np',3);
    7 md=solve(md,StressbalanceSolutionEnum());
     7md=solve(md,'StressbalanceSolution');
    88
    99%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test501.py

    r19049 r21049  
    1414md=setflowequation(md,'SSA','all')
    1515md.cluster=generic('name',oshostname(),'np',3)
    16 md=solve(md,StressbalanceSolutionEnum())
     16md=solve(md,'StressbalanceSolution')
    1717
    1818# Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test502.m

    r19049 r21049  
    66md=setflowequation(md,'HO','all');
    77md.cluster=generic('name',oshostname(),'np',3);
    8 md=solve(md,StressbalanceSolutionEnum());
     8md=solve(md,'StressbalanceSolution');
    99
    1010%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test502.py

    r19049 r21049  
    1515md=setflowequation(md,'HO','all')
    1616md.cluster=generic('name',oshostname(),'np',3)
    17 md=solve(md,StressbalanceSolutionEnum())
     17md=solve(md,'StressbalanceSolution')
    1818
    1919# Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test503.m

    r19049 r21049  
    66md=setflowequation(md,'FS','all');
    77md.cluster=generic('name',oshostname(),'np',3);
    8 md=solve(md,StressbalanceSolutionEnum());
     8md=solve(md,'StressbalanceSolution');
    99
    1010%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test503.py

    r19049 r21049  
    1515md=setflowequation(md,'FS','all')
    1616md.cluster=generic('name',oshostname(),'np',3)
    17 md=solve(md,StressbalanceSolutionEnum())
     17md=solve(md,'StressbalanceSolution')
    1818
    1919# Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test504.m

    r19049 r21049  
    55md=setflowequation(md,'SSA','all');
    66md.cluster=generic('name',oshostname(),'np',3);
    7 md=solve(md,TransientSolutionEnum());
     7md=solve(md,'TransientSolution');
    88
    99%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test504.py

    r19049 r21049  
    1414md=setflowequation(md,'SSA','all')
    1515md.cluster=generic('name',oshostname(),'np',3)
    16 md=solve(md,TransientSolutionEnum())
     16md=solve(md,'TransientSolution')
    1717
    1818# Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test505.m

    r19049 r21049  
    66md=setflowequation(md,'SSA','all');
    77md.cluster=generic('name',oshostname(),'np',3);
    8 md=solve(md,TransientSolutionEnum());
     8md=solve(md,'TransientSolution');
    99
    1010%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test505.py

    r19777 r21049  
    1515md=setflowequation(md,'SSA','all')
    1616md.cluster=generic('name',oshostname(),'np',3)
    17 md=solve(md,TransientSolutionEnum())
     17md=solve(md,'TransientSolution')
    1818
    1919# Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test506.m

    r19049 r21049  
    66md=setflowequation(md,'HO','all');
    77md.cluster=generic('name',oshostname(),'np',3);
    8 md=solve(md,TransientSolutionEnum());
     8md=solve(md,'TransientSolution');
    99
    1010%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test506.py

    r19049 r21049  
    1515md=setflowequation(md,'HO','all')
    1616md.cluster=generic('name',oshostname(),'np',3)
    17 md=solve(md,TransientSolutionEnum())
     17md=solve(md,'TransientSolution')
    1818
    1919# Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test507.m

    r19049 r21049  
    66md=setflowequation(md,'FS','all');
    77md.cluster=generic('name',oshostname(),'np',3);
    8 md=solve(md,TransientSolutionEnum());
     8md=solve(md,'TransientSolution');
    99
    1010%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test507.py

    r19049 r21049  
    1515md=setflowequation(md,'FS','all')
    1616md.cluster=generic('name',oshostname(),'np',3)
    17 md=solve(md,TransientSolutionEnum())
     17md=solve(md,'TransientSolution')
    1818
    1919# Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test508.m

    r19049 r21049  
    77md.cluster=generic('name',oshostname(),'np',3);
    88md.timestepping.time_step=0.;
    9 md=solve(md,SteadystateSolutionEnum());
     9md=solve(md,'SteadystateSolution');
    1010
    1111%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test508.py

    r19049 r21049  
    1616md.cluster=generic('name',oshostname(),'np',3)
    1717md.timestepping.time_step=0.
    18 md=solve(md,SteadystateSolutionEnum())
     18md=solve(md,'SteadystateSolution')
    1919
    2020# Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test509.m

    r19049 r21049  
    88md.timestepping.time_step=0.;
    99md.thermal.penalty_threshold=7;
    10 md=solve(md,SteadystateSolutionEnum());
     10md=solve(md,'SteadystateSolution');
    1111
    1212%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test509.py

    r19049 r21049  
    1717md.timestepping.time_step=0.
    1818md.thermal.penalty_threshold=7
    19 md=solve(md,SteadystateSolutionEnum())
     19md=solve(md,'SteadystateSolution')
    2020
    2121# Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test510.m

    r19049 r21049  
    77md.cluster=generic('name',oshostname(),'np',3);
    88md.timestepping.time_step=0.;
    9 md=solve(md,SteadystateSolutionEnum());
     9md=solve(md,'SteadystateSolution');
    1010
    1111%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test510.py

    r19049 r21049  
    1616md.cluster=generic('name',oshostname(),'np',3)
    1717md.timestepping.time_step=0.
    18 md=solve(md,SteadystateSolutionEnum())
     18md=solve(md,'SteadystateSolution')
    1919
    2020# Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test511.m

    r19049 r21049  
    2525
    2626md.cluster=generic('name',oshostname(),'np',1);
    27 md=solve(md,StressbalanceSolutionEnum());
     27md=solve(md,'StressbalanceSolution');
    2828
    2929%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test511.py

    r19049 r21049  
    3636
    3737md.cluster=generic('name',oshostname(),'np',1)
    38 md=solve(md,StressbalanceSolutionEnum())
     38md=solve(md,'StressbalanceSolution')
    3939
    4040#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test512.m

    r19049 r21049  
    2020
    2121md.cluster=generic('name',oshostname(),'np',3);
    22 md=solve(md,StressbalanceSolutionEnum());
     22md=solve(md,'StressbalanceSolution');
    2323
    2424%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test512.py

    r19049 r21049  
    3232
    3333md.cluster=generic('name',oshostname(),'np',3)
    34 md=solve(md,StressbalanceSolutionEnum())
     34md=solve(md,'StressbalanceSolution')
    3535
    3636# Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test513.m

    r19994 r21049  
    2222md.thermal.penalty_lock=5;
    2323md.cluster=generic('name',oshostname(),'np',3);
    24 md=solve(md,SteadystateSolutionEnum());
     24md=solve(md,'SteadystateSolution');
    2525
    2626%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test513.py

    r19797 r21049  
    3333md.thermal.penalty_lock=5
    3434md.cluster=generic('name',oshostname(),'np',3)
    35 md=solve(md,SteadystateSolutionEnum())
     35md=solve(md,'SteadystateSolution')
    3636
    3737# Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test515.m

    r19528 r21049  
    1212md.transient.isthermal=1;
    1313md.transient.isgroundingline=0;
    14 md=solve(md,TransientSolutionEnum());
     14md=solve(md,'TransientSolution');
    1515
    1616%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test515.py

    r19528 r21049  
    2121md.transient.isthermal=True
    2222md.transient.isgroundingline=False
    23 md=solve(md,TransientSolutionEnum())
     23md=solve(md,'TransientSolution')
    2424
    2525# Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test516.m

    r19049 r21049  
    99md.timestepping.time_step=0;
    1010md.thermal.penalty_threshold=40;
    11 md=solve(md,ThermalSolutionEnum());
     11md=solve(md,'ThermalSolution');
    1212
    1313%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test516.py

    r19049 r21049  
    1919md.timestepping.time_step=0
    2020md.thermal.penalty_threshold=40
    21 md=solve(md,ThermalSolutionEnum())
     21md=solve(md,'ThermalSolution')
    2222
    2323#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test530.m

    r19049 r21049  
    55md=setflowequation(md,'SSA','all');
    66md.cluster=generic('name',oshostname(),'np',3);
    7 md=solve(md,BalancevelocitySolutionEnum());
     7md=solve(md,'BalancevelocitySolution');
    88
    99%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test530.py

    r19049 r21049  
    1414md=setflowequation(md,'SSA','all')
    1515md.cluster=generic('name',oshostname(),'np',3)
    16 md=solve(md,BalancevelocitySolutionEnum())
     16md=solve(md,'BalancevelocitySolution')
    1717
    1818# Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test531.m

    r19049 r21049  
    77md=setflowequation(md,'SSA','all');
    88md.cluster=generic('name',oshostname(),'np',3);
    9 md=solve(md,BalancevelocitySolutionEnum());
     9md=solve(md,'BalancevelocitySolution');
    1010
    1111%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test531.py

    r19049 r21049  
    1616md=setflowequation(md,'SSA','all')
    1717md.cluster=generic('name',oshostname(),'np',3)
    18 md=solve(md,BalancevelocitySolutionEnum())
     18md=solve(md,'BalancevelocitySolution')
    1919
    2020# Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test601.m

    r19049 r21049  
    55md=setflowequation(md,'SSA','all');
    66md.cluster=generic('name',oshostname(),'np',3);
    7 md=solve(md,MasstransportSolutionEnum());
     7md=solve(md,'MasstransportSolution');
    88
    99%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test601.py

    r19049 r21049  
    1414md=setflowequation(md,'SSA','all')
    1515md.cluster=generic('name',oshostname(),'np',3)
    16 md=solve(md,MasstransportSolutionEnum())
     16md=solve(md,'MasstransportSolution')
    1717
    1818#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test602.m

    r19049 r21049  
    88md.masstransport.spcthickness=md.geometry.thickness;
    99md.cluster=generic('name',oshostname(),'np',3);
    10 md=solve(md,MasstransportSolutionEnum());
     10md=solve(md,'MasstransportSolution');
    1111
    1212%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test602.py

    r19049 r21049  
    1919md.masstransport.spcthickness=md.geometry.thickness
    2020md.cluster=generic('name',oshostname(),'np',3)
    21 md=solve(md,MasstransportSolutionEnum())
     21md=solve(md,'MasstransportSolution')
    2222
    2323#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test603.m

    r19049 r21049  
    66md=setflowequation(md,'SSA','all');
    77md.cluster=generic('name',oshostname(),'np',3);
    8 md=solve(md,MasstransportSolutionEnum());
     8md=solve(md,'MasstransportSolution');
    99
    1010%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test603.py

    r19049 r21049  
    1616md=setflowequation(md,'SSA','all')
    1717md.cluster=generic('name',oshostname(),'np',3)
    18 md=solve(md,MasstransportSolutionEnum())
     18md=solve(md,'MasstransportSolution')
    1919
    2020#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test604.m

    r19049 r21049  
    55md=setflowequation(md,'SSA','all');
    66md.cluster=generic('name',oshostname(),'np',3);
    7 md=solve(md,SurfaceSlopeSolutionEnum());
     7md=solve(md,'SurfaceSlopeSolution');
    88
    99%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test604.py

    r19049 r21049  
    1515md=setflowequation(md,'SSA','all')
    1616md.cluster=generic('name',oshostname(),'np',3)
    17 md=solve(md,SurfaceSlopeSolutionEnum())
     17md=solve(md,'SurfaceSlopeSolution')
    1818
    1919#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test605.m

    r19049 r21049  
    66md=setflowequation(md,'HO','all');
    77md.cluster=generic('name',oshostname(),'np',3);
    8 md=solve(md,SurfaceSlopeSolutionEnum());
     8md=solve(md,'SurfaceSlopeSolution');
    99
    1010%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test605.py

    r19049 r21049  
    1616md=setflowequation(md,'HO','all')
    1717md.cluster=generic('name',oshostname(),'np',3)
    18 md=solve(md,SurfaceSlopeSolutionEnum())
     18md=solve(md,'SurfaceSlopeSolution')
    1919
    2020#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test606.m

    r19049 r21049  
    55md=setflowequation(md,'SSA','all');
    66md.cluster=generic('name',oshostname(),'np',3);
    7 md=solve(md,BedSlopeSolutionEnum());
     7md=solve(md,'BedSlopeSolution');
    88
    99%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test606.py

    r19049 r21049  
    1515md=setflowequation(md,'SSA','all')
    1616md.cluster=generic('name',oshostname(),'np',3)
    17 md=solve(md,BedSlopeSolutionEnum())
     17md=solve(md,'BedSlopeSolution')
    1818
    1919#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test607.m

    r19049 r21049  
    66md=setflowequation(md,'SSA','all');
    77md.cluster=generic('name',oshostname(),'np',3);
    8 md=solve(md,BedSlopeSolutionEnum());
     8md=solve(md,'BedSlopeSolution');
    99
    1010%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test607.py

    r19049 r21049  
    1616md=setflowequation(md,'SSA','all')
    1717md.cluster=generic('name',oshostname(),'np',3)
    18 md=solve(md,BedSlopeSolutionEnum())
     18md=solve(md,'BedSlopeSolution')
    1919
    2020#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test608.m

    r19049 r21049  
    55md=setflowequation(md,'SSA','all');
    66md.cluster=generic('name',oshostname(),'np',3);
    7 md=solve(md,BalancethicknessSolutionEnum());
     7md=solve(md,'BalancethicknessSolution');
    88
    99%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test608.py

    r19049 r21049  
    1515md=setflowequation(md,'SSA','all')
    1616md.cluster=generic('name',oshostname(),'np',3)
    17 md=solve(md,BalancethicknessSolutionEnum())
     17md=solve(md,'BalancethicknessSolution')
    1818
    1919#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test611.m

    r19049 r21049  
    2020
    2121md.cluster=generic('name',oshostname(),'np',3);
    22 md=solve(md,BalancethicknessSolutionEnum());
     22md=solve(md,'BalancethicknessSolution');
    2323
    2424%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test611.py

    r19049 r21049  
    3030
    3131md.cluster=generic('name',oshostname(),'np',3)
    32 md=solve(md,BalancethicknessSolutionEnum())
     32md=solve(md,'BalancethicknessSolution')
    3333
    3434#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test613.m

    r19049 r21049  
    2727md.verbose.control=1;
    2828md.cluster=generic('name',oshostname(),'np',3);
    29 md=solve(md,BalancethicknessSolutionEnum());
     29md=solve(md,'BalancethicknessSolution');
    3030
    3131%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test613.py

    r19049 r21049  
    3939md.verbose.control=1
    4040md.cluster=generic('name',oshostname(),'np',3)
    41 md=solve(md,BalancethicknessSolutionEnum())
     41md=solve(md,'BalancethicknessSolution')
    4242
    4343#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test701.m

    r19648 r21049  
    5656        disp(['====== Testing ' i{1} ' Full-Stokes Finite element =====']);
    5757        md.flowequation.fe_FS=i{1};
    58         md=solve(md,StressbalanceSolutionEnum());
     58        md=solve(md,'StressbalanceSolution');
    5959        field_names     ={field_names{:},['Vx' i{1}],['Vy' i{1}],['Vel' i{1}],['Pressure' i{1}]};
    6060        field_tolerances={field_tolerances{:},9e-5,9e-5,9e-5,1e-10};

  • issm/trunk-jpl/test/NightlyRun/test702.m

    r19049 r21049  
    5454        disp(['====== Testing ' i{1} ' Full-Stokes Finite element =====']);
    5555        md.flowequation.fe_FS=i{1};
    56         md=solve(md,StressbalanceSolutionEnum());
     56        md=solve(md,'StressbalanceSolution');
    5757        field_names     ={field_names{:},['Vx' i{1}],['Vy' i{1}],['Vel' i{1}],['Pressure' i{1}]};
    5858        field_tolerances={field_tolerances{:},8e-5,8e-5,8e-5,1e-08};

  • issm/trunk-jpl/test/NightlyRun/test703.m

    r19527 r21049  
    6161md.cluster=generic('np',3);
    6262md.stressbalance.shelf_dampening=1;
    63 md1=solve(md,TransientSolutionEnum());
     63md1=solve(md,'TransientSolution');
    6464
    6565md.stressbalance.shelf_dampening=0;
    66 md=solve(md,TransientSolutionEnum());
     66md=solve(md,'TransientSolution');
    6767
    6868%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test801.m

    r20459 r21049  
    1515md.transient.isgia=0;
    1616
    17 md=solve(md,TransientSolutionEnum());
     17md=solve(md,'TransientSolution');
    1818
    1919%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test801.py

    r20459 r21049  
    2525md.transient.isgia=False
    2626
    27 md=solve(md,TransientSolutionEnum())
     27md=solve(md,'TransientSolution')
    2828
    2929#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test802.m

    r20459 r21049  
    2020md.transient.isgia=0;
    2121
    22 md=solve(md,TransientSolutionEnum());
     22md=solve(md,'TransientSolution');
    2323
    2424%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test802.py

    r20459 r21049  
    3030md.transient.isgia=False
    3131
    32 md=solve(md,TransientSolutionEnum())
     32md=solve(md,'TransientSolution')
    3333
    3434#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test803.m

    r20459 r21049  
    2222md.transient.isgia=0;
    2323
    24 md=solve(md,TransientSolutionEnum());
     24md=solve(md,'TransientSolution');
    2525
    2626%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test803.py

    r20459 r21049  
    3232md.transient.isgia=False
    3333
    34 md=solve(md,TransientSolutionEnum())
     34md=solve(md,'TransientSolution')
    3535
    3636#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test804.m

    r20459 r21049  
    1818md.calving.meltingrate=zeros(md.mesh.numberofvertices,1);
    1919
    20 md=solve(md,TransientSolutionEnum());
     20md=solve(md,'TransientSolution');
    2121
    2222%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test804.py

    r20459 r21049  
    2828md.calving.meltingrate=numpy.zeros((md.mesh.numberofvertices,1))
    2929
    30 md=solve(md,TransientSolutionEnum())
     30md=solve(md,'TransientSolution')
    3131
    3232#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test805.m

    r20459 r21049  
    2525md.calving.meltingrate=zeros(md.mesh.numberofvertices,1);
    2626
    27 md=solve(md,TransientSolutionEnum());
     27md=solve(md,'TransientSolution');
    2828
    2929%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test805.py

    r20459 r21049  
    3535md.calving.meltingrate=numpy.zeros((md.mesh.numberofvertices,1))
    3636
    37 md=solve(md,TransientSolutionEnum())
     37md=solve(md,'TransientSolution')
    3838
    3939#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test806.m

    r20468 r21049  
    3232md.transient.requested_outputs={'default','StrainRateparallel','StrainRateperpendicular','Calvingratex','Calvingratey','CalvingCalvingrate'};
    3333
    34 md=solve(md,TransientSolutionEnum());
     34md=solve(md,'TransientSolution');
    3535
    3636%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test806.py

    r20468 r21049  
    4343md.transient.requested_outputs=['default','StrainRateparallel','StrainRateperpendicular','Calvingratex','Calvingratey','CalvingCalvingrate']
    4444
    45 md=solve(md,TransientSolutionEnum())
     45md=solve(md,'TransientSolution')
    4646
    4747#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test807.m

    r20468 r21049  
    2929md.levelset.spclevelset=NaN(md.mesh.numberofvertices,1);
    3030
    31 md=solve(md,TransientSolutionEnum());
     31md=solve(md,'TransientSolution');
    3232
    3333%Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test807.py

    r20468 r21049  
    4040md.levelset.spclevelset=numpy.float('NaN')*numpy.ones((md.mesh.numberofvertices,1))
    4141
    42 md=solve(md,TransientSolutionEnum())
     42md=solve(md,'TransientSolution')
    4343
    4444#Fields and tolerances to track changes

  • issm/trunk-jpl/test/NightlyRun/test808.m

    r21043 r21049  
    3131md.levelset.reinit_frequency=1;
    3232
    33 md=solve(md,TransientSolutionEnum());
     33md=solve(md,'TransientSolution');
    3434
    3535%Fields and tolerances to track changes
Note: See TracChangeset for help on using the changeset viewer.