Changeset 15771 for issm/trunk-jpl/src


Ignore:
Timestamp:
08/09/13 10:59:47 (12 years ago)
Author:
Mathieu Morlighem
Message:

CHG: Diagnostic is now Stressbalance

Location:
issm/trunk-jpl/src
Files:
91 edited
17 moved

Legend:

Unmodified
Added
Removed

  • issm/trunk-jpl/src/ad/validation/Update/SquareShelfConstrained.par

    r10330 r15771  
    3535
    3636%Numerical parameters
    37 md.diagnostic.viscosity_overshoot=0.0;
     37md.stressbalance.viscosity_overshoot=0.0;
    3838md.prognostic.stabilization=1;
    3939md.thermal.stabilization=1;
    4040md.verbose=verbose(0);
    4141md.settings.waitonlock=30;
    42 md.diagnostic.restol=0.05;
    43 md.diagnostic.reltol=0.05;
     42md.stressbalance.restol=0.05;
     43md.stressbalance.reltol=0.05;
    4444md.steadystate.reltol=0.05;
    45 md.diagnostic.abstol=NaN;
     45md.stressbalance.abstol=NaN;
    4646md.timestepping.time_step=1;
    4747md.timestepping.final_time=3;

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

    r15767 r15771  
    440440                                          ./analyses/objectivefunction.cpp\
    441441                                          ./analyses/gradient_core.cpp\
    442                                           ./analyses/adjointdiagnostic_core.cpp\
     442                                          ./analyses/adjointstressbalance_core.cpp\
    443443                                          ./analyses/adjointbalancethickness_core.cpp\
    444444                                          ./analyses/AdjointCorePointerFromSolutionEnum.cpp\
    … …  
    465465                                                        ./solutionsequences/solutionsequence_hydro_nonlinear.cpp
    466466#}}}
    467 #Diagnostic sources  {{{
    468 diagnostic_sources = ./modules/ModelProcessorx/DiagnosticHoriz/UpdateElementsDiagnosticHoriz.cpp\
    469                                               ./modules/ModelProcessorx/DiagnosticHoriz/CreateNodesDiagnosticHoriz.cpp \
    470                                               ./modules/ModelProcessorx/DiagnosticHoriz/CreateConstraintsDiagnosticHoriz.cpp \
    471                                               ./modules/ModelProcessorx/DiagnosticHoriz/CreateLoadsDiagnosticHoriz.cpp\
    472                                               ./modules/ModelProcessorx/DiagnosticVert/UpdateElementsDiagnosticVert.cpp\
    473                                               ./modules/ModelProcessorx/DiagnosticVert/CreateNodesDiagnosticVert.cpp \
    474                                               ./modules/ModelProcessorx/DiagnosticVert/CreateConstraintsDiagnosticVert.cpp \
    475                                               ./modules/ModelProcessorx/DiagnosticVert/CreateLoadsDiagnosticVert.cpp\
    476                                               ./modules/ModelProcessorx/DiagnosticHutter/UpdateElementsDiagnosticHutter.cpp\
    477                                               ./modules/ModelProcessorx/DiagnosticHutter/CreateNodesDiagnosticHutter.cpp \
    478                                               ./modules/ModelProcessorx/DiagnosticHutter/CreateConstraintsDiagnosticHutter.cpp \
    479                                                         ./modules/ModelProcessorx/DiagnosticHutter/CreateLoadsDiagnosticHutter.cpp \
    480                                                         ./analyses/diagnostic_core.cpp\
     467#Stressbalance sources  {{{
     468stressbalance_sources = ./modules/ModelProcessorx/Stressbalance/UpdateElementsStressbalance.cpp\
     469                                              ./modules/ModelProcessorx/Stressbalance/CreateNodesStressbalance.cpp \
     470                                              ./modules/ModelProcessorx/Stressbalance/CreateConstraintsStressbalance.cpp \
     471                                              ./modules/ModelProcessorx/Stressbalance/CreateLoadsStressbalance.cpp\
     472                                              ./modules/ModelProcessorx/StressbalanceVertical/UpdateElementsStressbalanceVertical.cpp\
     473                                              ./modules/ModelProcessorx/StressbalanceVertical/CreateNodesStressbalanceVertical.cpp \
     474                                              ./modules/ModelProcessorx/StressbalanceVertical/CreateConstraintsStressbalanceVertical.cpp \
     475                                              ./modules/ModelProcessorx/StressbalanceVertical/CreateLoadsStressbalanceVertical.cpp\
     476                                              ./modules/ModelProcessorx/StressbalanceSIA/UpdateElementsStressbalanceSIA.cpp\
     477                                              ./modules/ModelProcessorx/StressbalanceSIA/CreateNodesStressbalanceSIA.cpp \
     478                                              ./modules/ModelProcessorx/StressbalanceSIA/CreateConstraintsStressbalanceSIA.cpp \
     479                                                        ./modules/ModelProcessorx/StressbalanceSIA/CreateLoadsStressbalanceSIA.cpp \
     480                                                        ./analyses/stressbalance_core.cpp\
    481481                                                        ./solutionsequences/solutionsequence_stokescoupling_nonlinear.cpp
    482482#}}}
    … …  
    890890endif
    891891
    892 if DIAGNOSTIC
    893 issm_sources  +=  $(diagnostic_sources)
     892if STRESSBALANCE
     893issm_sources  +=  $(stressbalance_sources)
    894894endif
    895895

  • issm/trunk-jpl/src/c/analyses/AdjointCorePointerFromSolutionEnum.cpp

    r15339 r15771  
    2323        switch(solutiontype){
    2424
    25                 case DiagnosticSolutionEnum:
    26                         adjointcore=&adjointdiagnostic_core;
     25                case StressbalanceSolutionEnum:
     26                        adjointcore=&adjointstressbalance_core;
    2727                        break;
    2828                case SteadystateSolutionEnum:
    29                         adjointcore=&adjointdiagnostic_core;
     29                        adjointcore=&adjointstressbalance_core;
    3030                        break;
    3131                case BalancethicknessSolutionEnum:

  • issm/trunk-jpl/src/c/analyses/AnalysisConfiguration.cpp

    r15767 r15771  
    2525        switch(solutiontype){
    2626
    27                 case DiagnosticSolutionEnum:
     27                case StressbalanceSolutionEnum:
    2828                        numanalyses=5;
    2929                        analyses=xNew<int>(numanalyses);
    30                         analyses[0]=DiagnosticHorizAnalysisEnum;
    31                         analyses[1]=DiagnosticVertAnalysisEnum;
    32                         analyses[2]=DiagnosticSIAAnalysisEnum;
     30                        analyses[0]=StressbalanceAnalysisEnum;
     31                        analyses[1]=StressbalanceVerticalAnalysisEnum;
     32                        analyses[2]=StressbalanceSIAAnalysisEnum;
    3333                        analyses[3]=SurfaceSlopeAnalysisEnum;
    3434                        analyses[4]=BedSlopeAnalysisEnum;
    … …  
    3838                        numanalyses=8;
    3939                        analyses=xNew<int>(numanalyses);
    40                         analyses[0]=DiagnosticHorizAnalysisEnum;
    41                         analyses[1]=DiagnosticVertAnalysisEnum;
    42                         analyses[2]=DiagnosticSIAAnalysisEnum;
     40                        analyses[0]=StressbalanceAnalysisEnum;
     41                        analyses[1]=StressbalanceVerticalAnalysisEnum;
     42                        analyses[2]=StressbalanceSIAAnalysisEnum;
    4343                        analyses[3]=SurfaceSlopeAnalysisEnum;
    4444                        analyses[4]=BedSlopeAnalysisEnum;
    … …  
    110110                        numanalyses=10-1;
    111111                        analyses=xNew<int>(numanalyses);
    112                         analyses[0]=DiagnosticHorizAnalysisEnum;
    113                         analyses[1]=DiagnosticVertAnalysisEnum;
    114                         analyses[2]=DiagnosticSIAAnalysisEnum;
     112                        analyses[0]=StressbalanceAnalysisEnum;
     113                        analyses[1]=StressbalanceVerticalAnalysisEnum;
     114                        analyses[2]=StressbalanceSIAAnalysisEnum;
    115115                        analyses[3]=SurfaceSlopeAnalysisEnum;
    116116                        analyses[4]=BedSlopeAnalysisEnum;

  • issm/trunk-jpl/src/c/analyses/CorePointerFromSolutionEnum.cpp

    r15767 r15771  
    2323        switch(solutiontype){
    2424
    25                 case DiagnosticSolutionEnum:
    26                         #ifdef _HAVE_DIAGNOSTIC_
    27                         solutioncore=&diagnostic_core;
     25                case StressbalanceSolutionEnum:
     26                        #ifdef _HAVE_STRESSBALANCE_
     27                        solutioncore=&stressbalance_core;
    2828                        #else
    29                         _error_("ISSM was not compiled with diagnostic capabilities. Exiting");
     29                        _error_("ISSM was not compiled with stressbalance capabilities. Exiting");
    3030                        #endif
    3131                        break;

  • issm/trunk-jpl/src/c/analyses/adjointstressbalance_core.cpp

    r15769 r15771  
    1 /*!\file:  adjointdiagnostic_core.cpp
     1/*!\file:  adjointstressbalance_core.cpp
    22 * \brief compute inverse method adjoint state
    33 */
    … …  
    1010#include "../solutionsequences/solutionsequences.h"
    1111
    12 void adjointdiagnostic_core(FemModel* femmodel){
     12void adjointstressbalance_core(FemModel* femmodel){
    1313
    1414        /*parameters: */
    … …  
    2323        /*Compute velocities*/
    2424        if(VerboseSolution()) _printf0_("   computing velocities\n");
    25         femmodel->SetCurrentConfiguration(DiagnosticHorizAnalysisEnum);
     25        femmodel->SetCurrentConfiguration(StressbalanceAnalysisEnum);
    2626        solutionsequence_nonlinear(femmodel,conserve_loads);
    2727
    … …  
    3131        /*Compute adjoint*/
    3232        if(VerboseSolution()) _printf0_("   computing adjoint\n");
    33         femmodel->SetCurrentConfiguration(DiagnosticHorizAnalysisEnum,AdjointHorizAnalysisEnum);
     33        femmodel->SetCurrentConfiguration(StressbalanceAnalysisEnum,AdjointHorizAnalysisEnum);
    3434        solutionsequence_adjoint_linear(femmodel);
    3535

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

    r15767 r15771  
    1717
    1818/*cores: */
    19 void adjointdiagnostic_core(FemModel* femmodel);
     19void adjointstressbalance_core(FemModel* femmodel);
    2020void adjointbalancethickness_core(FemModel* femmodel);
    2121void gradient_core(FemModel* femmodel,int n=0,bool orthogonalize=false);
    22 void diagnostic_core(FemModel* femmodel);
     22void stressbalance_core(FemModel* femmodel);
    2323void hydrology_core(FemModel* femmodel);
    2424void thermal_core(FemModel* femmodel);

  • issm/trunk-jpl/src/c/analyses/control_core.cpp

    r15564 r15771  
    112112        solutioncore(femmodel);
    113113
    114         /*some results not computed by steadystate_core or diagnostic_core: */
     114        /*some results not computed by steadystate_core or stressbalance_core: */
    115115        if(!dakota_analysis){ //do not save this if we are running the control core from a qmu run!
    116116                for(i=0;i<num_controls;i++) InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,control_type[i]);

  • issm/trunk-jpl/src/c/analyses/dakota_core.cpp

    r15177 r15771  
    1414 *
    1515 * Now, how does CPU 0 drive all other CPUS to carry out sensitivity analysese? By synchronizing its call to
    16  * our ISSM cores (diagnostic_core, thermal_core, transient_core, etc ...) on CPU 0 with all other CPUS.
     16 * our ISSM cores (stressbalance_core, thermal_core, transient_core, etc ...) on CPU 0 with all other CPUS.
    1717 * This explains the structure of qmu.cpp, where cpu 0 runs Dakota, the Dakota pluggin fires up DakotaSpawnCore.cpp,
    1818 * while the other CPUS are waiting for a broadcast from CPU0, once they get it, they also fire up

  • issm/trunk-jpl/src/c/analyses/objectivefunction.cpp

    r15564 r15771  
    3737
    3838        /*set analysis type to compute velocity: */
    39         if (solution_type==SteadystateSolutionEnum || solution_type==DiagnosticSolutionEnum){
    40                 femmodel->SetCurrentConfiguration(DiagnosticHorizAnalysisEnum);
     39        if (solution_type==SteadystateSolutionEnum || solution_type==StressbalanceSolutionEnum){
     40                femmodel->SetCurrentConfiguration(StressbalanceAnalysisEnum);
    4141        }
    4242        else if (solution_type==BalancethicknessSolutionEnum){
    … …  
    5353        InputControlUpdatex(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,search_scalar,false);
    5454
    55         /*Run diagnostic with updated inputs: */
     55        /*Run stressbalance with updated inputs: */
    5656        if (solution_type==SteadystateSolutionEnum){
    57                 diagnostic_core(femmodel);      //We need a 3D velocity!! (vz is required for the next thermal run)
     57                stressbalance_core(femmodel);   //We need a 3D velocity!! (vz is required for the next thermal run)
    5858        }
    59         else if (solution_type==DiagnosticSolutionEnum){
     59        else if (solution_type==StressbalanceSolutionEnum){
    6060                solutionsequence_nonlinear(femmodel,conserve_loads);
    6161        }

  • issm/trunk-jpl/src/c/analyses/steadystate_core.cpp

    r15727 r15771  
    6464
    6565                if(VerboseSolution()) _printf0_("   computing new velocity\n");
    66                 diagnostic_core(femmodel);
     66                stressbalance_core(femmodel);
    6767                GetSolutionFromInputsx(&ug,femmodel->elements, femmodel->nodes, femmodel->vertices,femmodel->loads, femmodel->materials, femmodel->parameters);
    6868

  • issm/trunk-jpl/src/c/analyses/stressbalance_core.cpp

    r15769 r15771  
    1 /*!\file: diagnostic_core.cpp
    2  * \brief: core of the diagnostic solution
     1/*!\file: stressbalance_core.cpp
     2 * \brief: core of the stressbalance solution
    33 */
    44
    … …  
    1010#include "../solutionsequences/solutionsequences.h"
    1111
    12 void diagnostic_core(FemModel* femmodel){
     12void stressbalance_core(FemModel* femmodel){
    1313
    1414        /*parameters: */
    … …  
    3030        femmodel->parameters->FindParam(&isHO,FlowequationIsHOEnum);
    3131        femmodel->parameters->FindParam(&isFS,FlowequationIsFSEnum);
    32         femmodel->parameters->FindParam(&newton,DiagnosticIsnewtonEnum);
     32        femmodel->parameters->FindParam(&newton,StressbalanceIsnewtonEnum);
    3333        femmodel->parameters->FindParam(&dakota_analysis,QmuIsdakotaEnum);
    3434        femmodel->parameters->FindParam(&save_results,SaveResultsEnum);
    3535        femmodel->parameters->FindParam(&solution_type,SolutionTypeEnum);
    36         femmodel->parameters->FindParam(&numoutputs,DiagnosticNumRequestedOutputsEnum);
    37         if(numoutputs) femmodel->parameters->FindParam(&requested_outputs,&numoutputs,DiagnosticRequestedOutputsEnum);
     36        femmodel->parameters->FindParam(&numoutputs,StressbalanceNumRequestedOutputsEnum);
     37        if(numoutputs) femmodel->parameters->FindParam(&requested_outputs,&numoutputs,StressbalanceRequestedOutputsEnum);
    3838
    3939        /*for qmu analysis, reinitialize velocity so that fake sensitivities do not show up as a result of a different restart of the convergence at each trial.*/
    40         if(dakota_analysis && solution_type==DiagnosticSolutionEnum){
     40        if(dakota_analysis && solution_type==StressbalanceSolutionEnum){
    4141                InputDuplicatex(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,QmuVxEnum,VxEnum);
    4242                InputDuplicatex(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,QmuVyEnum,VyEnum);
    … …  
    4949        if(isFS){
    5050                bedslope_core(femmodel);
    51                 femmodel->SetCurrentConfiguration(DiagnosticHorizAnalysisEnum);
     51                femmodel->SetCurrentConfiguration(StressbalanceAnalysisEnum);
    5252                ResetCoordinateSystemx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters);
    5353        }
    … …  
    5757
    5858                /*Take the last velocity into account so that the velocity on the SSA domain is not zero*/
    59                 if(isSSA || isL1L2 || isHO ) ResetBoundaryConditions(femmodel,DiagnosticSIAAnalysisEnum);
    60                 femmodel->SetCurrentConfiguration(DiagnosticSIAAnalysisEnum);
     59                if(isSSA || isL1L2 || isHO ) ResetBoundaryConditions(femmodel,StressbalanceSIAAnalysisEnum);
     60                femmodel->SetCurrentConfiguration(StressbalanceSIAAnalysisEnum);
    6161                solutionsequence_linear(femmodel);
    62                 if(isSSA || isL1L2 || isHO) ResetBoundaryConditions(femmodel,DiagnosticHorizAnalysisEnum);
     62                if(isSSA || isL1L2 || isHO) ResetBoundaryConditions(femmodel,StressbalanceAnalysisEnum);
    6363        }
    6464
    … …  
    6666                if(VerboseSolution()) _printf0_("   computing velocities\n");
    6767
    68                 femmodel->SetCurrentConfiguration(DiagnosticHorizAnalysisEnum);
     68                femmodel->SetCurrentConfiguration(StressbalanceAnalysisEnum);
    6969                if(newton>0)
    7070                 solutionsequence_newton(femmodel);
    … …  
    8080        if (dim==3 & (isSIA || isSSA || isL1L2 || isHO)){
    8181                if(VerboseSolution()) _printf0_("   computing vertical velocities\n");
    82                 femmodel->SetCurrentConfiguration(DiagnosticVertAnalysisEnum);
     82                femmodel->SetCurrentConfiguration(StressbalanceVerticalAnalysisEnum);
    8383                solutionsequence_linear(femmodel);
    8484        }
    … …  
    9494        }
    9595
    96         if(solution_type==DiagnosticSolutionEnum)femmodel->RequestedDependentsx();
     96        if(solution_type==StressbalanceSolutionEnum)femmodel->RequestedDependentsx();
    9797
    9898        /*Free ressources:*/

  • issm/trunk-jpl/src/c/analyses/transient_core.cpp

    r15767 r15771  
    2121        /*parameters: */
    2222        IssmDouble starttime,finaltime,dt,yts;
    23         bool   isdiagnostic,ismasstransport,isthermal,isgroundingline,isenthalpy,isdelta18o,isgia;
     23        bool   isstressbalance,ismasstransport,isthermal,isgroundingline,isenthalpy,isdelta18o,isgia;
    2424        bool   save_results,dakota_analysis;
    2525        bool   time_adapt=false;
    … …  
    4242        femmodel->parameters->FindParam(&output_frequency,SettingsOutputFrequencyEnum);
    4343        femmodel->parameters->FindParam(&time_adapt,TimesteppingTimeAdaptEnum);
    44         femmodel->parameters->FindParam(&isdiagnostic,TransientIsdiagnosticEnum);
     44        femmodel->parameters->FindParam(&isstressbalance,TransientIsstressbalanceEnum);
    4545        femmodel->parameters->FindParam(&ismasstransport,TransientIsmasstransportEnum);
    4646        femmodel->parameters->FindParam(&isthermal,TransientIsthermalEnum);
    … …  
    117117                }
    118118
    119                 if(isdiagnostic){
     119                if(isstressbalance){
    120120                        if(VerboseSolution()) _printf0_("   computing new velocity\n");
    121                         #ifdef _HAVE_DIAGNOSTIC_
    122                         diagnostic_core(femmodel);
     121                        #ifdef _HAVE_STRESSBALANCE_
     122                        stressbalance_core(femmodel);
    123123                        #else
    124                         _error_("ISSM was not compiled with diagnostic capabilities. Exiting");
     124                        _error_("ISSM was not compiled with stressbalance capabilities. Exiting");
    125125                        #endif
    126126                }

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

    r15770 r15771  
    184184
    185185        /*Build friction element, needed later: */
    186         friction=new Friction("3d",inputs,matpar,DiagnosticHorizAnalysisEnum);
     186        friction=new Friction("3d",inputs,matpar,StressbalanceAnalysisEnum);
    187187
    188188        /* Start looping on the number of gauss 2d (nodes on the bedrock) */
    … …  
    233233
    234234        /*Check analysis_types*/
    235         if (analysis_type!=DiagnosticHorizAnalysisEnum) _error_("Not supported yet!");
     235        if (analysis_type!=StressbalanceAnalysisEnum) _error_("Not supported yet!");
    236236        if (approximation!=FSApproximationEnum) _error_("Not supported yet!");
    237237
    238238        /*retrieve some parameters: */
    239         this->parameters->FindParam(&FSreconditioning,DiagnosticFSreconditioningEnum);
     239        this->parameters->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum);
    240240
    241241        if(!IsOnBed()){
    … …  
    403403                int analysis_type;
    404404                parameters->FindParam(&analysis_type,AnalysisTypeEnum);
    405                 if(analysis_type==DiagnosticHorizAnalysisEnum){
     405                if(analysis_type==StressbalanceAnalysisEnum){
    406406                        int approximation;
    407407                        inputs->GetInputValue(&approximation,ApproximationEnum);
    … …  
    450450        /*Just branch to the correct element stiffness matrix generator, according to the type of analysis we are carrying out: */
    451451        switch(analysis_type){
    452                 #ifdef _HAVE_DIAGNOSTIC_
    453                 case DiagnosticHorizAnalysisEnum:
    454                         return CreateKMatrixDiagnosticHoriz();
     452                #ifdef _HAVE_STRESSBALANCE_
     453                case StressbalanceAnalysisEnum:
     454                        return CreateKMatrixStressbalanceHoriz();
    455455                        break;
    456456                case AdjointHorizAnalysisEnum:
    457457                        return CreateKMatrixAdjointHoriz();
    458458                        break;
    459                 case DiagnosticSIAAnalysisEnum:
    460                         return CreateKMatrixDiagnosticSIA();
     459                case StressbalanceSIAAnalysisEnum:
     460                        return CreateKMatrixStressbalanceSIA();
    461461                        break;
    462                 case DiagnosticVertAnalysisEnum:
    463                         return CreateKMatrixDiagnosticVert();
     462                case StressbalanceVerticalAnalysisEnum:
     463                        return CreateKMatrixStressbalanceVert();
    464464                        break;
    465465                #endif
    … …  
    550550
    551551        switch(analysis_type){
    552                 #ifdef _HAVE_DIAGNOSTIC_
    553                 case DiagnosticHorizAnalysisEnum:
    554                         De=CreateDVectorDiagnosticHoriz();
     552                #ifdef _HAVE_STRESSBALANCE_
     553                case StressbalanceAnalysisEnum:
     554                        De=CreateDVectorStressbalanceHoriz();
    555555                        break;
    556556                #endif
    … …  
    576576                int analysis_type;
    577577                parameters->FindParam(&analysis_type,AnalysisTypeEnum);
    578                 if(analysis_type==DiagnosticHorizAnalysisEnum){
     578                if(analysis_type==StressbalanceAnalysisEnum){
    579579                        /*StaticCondensation if requested*/
    580580                        if(this->element_type==MINIcondensedEnum){
    … …  
    588588
    589589                                        this->element_type=MINIEnum;
    590                                         ElementMatrix* Ke = CreateKMatrixDiagnosticFS();
     590                                        ElementMatrix* Ke = CreateKMatrixStressbalanceFS();
    591591                                        this->element_type=MINIcondensedEnum;
    592592
    … …  
    633633        /*Just branch to the correct element stiffness matrix generator, according to the type of analysis we are carrying out: */
    634634        switch(analysis_type){
    635                 #ifdef _HAVE_DIAGNOSTIC_
    636                 case DiagnosticHorizAnalysisEnum:
    637                         return CreatePVectorDiagnosticHoriz();
     635                #ifdef _HAVE_STRESSBALANCE_
     636                case StressbalanceAnalysisEnum:
     637                        return CreatePVectorStressbalanceHoriz();
    638638                        break;
    639                 case DiagnosticSIAAnalysisEnum:
    640                         return CreatePVectorDiagnosticSIA();
     639                case StressbalanceSIAAnalysisEnum:
     640                        return CreatePVectorStressbalanceSIA();
    641641                        break;
    642                 case DiagnosticVertAnalysisEnum:
    643                         return CreatePVectorDiagnosticVert();
     642                case StressbalanceVerticalAnalysisEnum:
     643                        return CreatePVectorStressbalanceVert();
    644644                        break;
    645645                #endif
    … …  
    740740        /*Just branch to the correct element stiffness matrix generator, according to the type of analysis we are carrying out: */
    741741        switch(analysis_type){
    742 #ifdef _HAVE_DIAGNOSTIC_
    743                 case DiagnosticHorizAnalysisEnum:
    744                         Ke=CreateJacobianDiagnosticHoriz();
     742#ifdef _HAVE_STRESSBALANCE_
     743                case StressbalanceAnalysisEnum:
     744                        Ke=CreateJacobianStressbalanceHoriz();
    745745                        break;
    746746#endif
    … …  
    13791379        /*Just branch to the correct InputUpdateFromSolution generator, according to the type of analysis we are carrying out: */
    13801380        switch(analysis_type){
    1381         #ifdef _HAVE_DIAGNOSTIC_
    1382         case DiagnosticHorizAnalysisEnum:
     1381        #ifdef _HAVE_STRESSBALANCE_
     1382        case StressbalanceAnalysisEnum:
    13831383                int approximation;
    13841384                inputs->GetInputValue(&approximation,ApproximationEnum);
    13851385                if(approximation==FSApproximationEnum || approximation==NoneApproximationEnum){
    1386                         GetSolutionFromInputsDiagnosticFS(solution);
     1386                        GetSolutionFromInputsStressbalanceFS(solution);
    13871387                }
    13881388                else if (approximation==SSAApproximationEnum || approximation==HOApproximationEnum || approximation==SIAApproximationEnum){
    1389                         GetSolutionFromInputsDiagnosticHoriz(solution);
     1389                        GetSolutionFromInputsStressbalanceHoriz(solution);
    13901390                }
    13911391                else if (approximation==SSAHOApproximationEnum || approximation==HOFSApproximationEnum || approximation==SSAFSApproximationEnum){
    … …  
    13931393                }
    13941394                break;
    1395         case DiagnosticSIAAnalysisEnum:
    1396                 GetSolutionFromInputsDiagnosticSIA(solution);
     1395        case StressbalanceSIAAnalysisEnum:
     1396                GetSolutionFromInputsStressbalanceSIA(solution);
    13971397                break;
    1398         case DiagnosticVertAnalysisEnum:
    1399                 //GetSolutionFromInputsDiagnosticVert(solution);
     1398        case StressbalanceVerticalAnalysisEnum:
     1399                //GetSolutionFromInputsStressbalanceVert(solution);
    14001400                GetSolutionFromInputsOneDof(solution, VzEnum);
    14011401                break;
    … …  
    22142214        /*Just branch to the correct InputUpdateFromSolution generator, according to the type of analysis we are carrying out: */
    22152215        switch(analysis_type){
    2216         #ifdef _HAVE_DIAGNOSTIC_
    2217         case DiagnosticHorizAnalysisEnum:
    2218                 InputUpdateFromSolutionDiagnosticHoriz( solution);
     2216        #ifdef _HAVE_STRESSBALANCE_
     2217        case StressbalanceAnalysisEnum:
     2218                InputUpdateFromSolutionStressbalanceHoriz( solution);
    22192219                break;
    2220         case DiagnosticSIAAnalysisEnum:
    2221                 InputUpdateFromSolutionDiagnosticSIA( solution);
     2220        case StressbalanceSIAAnalysisEnum:
     2221                InputUpdateFromSolutionStressbalanceSIA( solution);
    22222222                break;
    2223         case DiagnosticVertAnalysisEnum:
    2224                 InputUpdateFromSolutionDiagnosticVert( solution);
     2223        case StressbalanceVerticalAnalysisEnum:
     2224                InputUpdateFromSolutionStressbalanceVert( solution);
    22252225                break;
    22262226        #endif
    … …  
    30733073        int analysis_type,approximation,numlayers;
    30743074        parameters->FindParam(&analysis_type,AnalysisTypeEnum);
    3075         if(analysis_type==DiagnosticHorizAnalysisEnum){
     3075        if(analysis_type==StressbalanceAnalysisEnum){
    30763076                inputs->GetInputValue(&approximation,ApproximationEnum);
    30773077                if(approximation==SSAHOApproximationEnum || approximation==SSAFSApproximationEnum){
    … …  
    34503450        switch(analysis_type){
    34513451
    3452                 case DiagnosticHorizAnalysisEnum:
     3452                case StressbalanceAnalysisEnum:
    34533453
    34543454                        /*default vx,vy and vz: either observation or 0 */
    … …  
    51385138        /*Initialize Jacobian with regular HO (first part of the Gateau derivative)*/
    51395139        parameters->FindParam(&incomplete_adjoint,InversionIncompleteAdjointEnum);
    5140         ElementMatrix* Ke=CreateKMatrixDiagnosticHO();
     5140        ElementMatrix* Ke=CreateKMatrixStressbalanceHO();
    51415141        if(incomplete_adjoint) return Ke;
    51425142
    … …  
    52035203        /*Initialize Jacobian with regular FS (first part of the Gateau derivative)*/
    52045204        parameters->FindParam(&incomplete_adjoint,InversionIncompleteAdjointEnum);
    5205         ElementMatrix* Ke=CreateKMatrixDiagnosticFS();
     5205        ElementMatrix* Ke=CreateKMatrixStressbalanceFS();
    52065206        if(incomplete_adjoint) return Ke;
    52075207
    … …  
    61126112
    61136113        /*Recondition pressure and compute vel: */
    6114         this->parameters->FindParam(&FSreconditioning,DiagnosticFSreconditioningEnum);
     6114        this->parameters->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum);
    61156115        for(i=0;i<pnumnodes;i++) lambdap[i]=lambdap[i]*FSreconditioning;
    61166116
    … …  
    66226622#endif
    66236623
    6624 #ifdef _HAVE_DIAGNOSTIC_
    6625 /*FUNCTION Penta::CreateDVectorDiagnosticHoriz {{{*/
    6626 ElementVector* Penta::CreateDVectorDiagnosticHoriz(void){
     6624#ifdef _HAVE_STRESSBALANCE_
     6625/*FUNCTION Penta::CreateDVectorStressbalanceHoriz {{{*/
     6626ElementVector* Penta::CreateDVectorStressbalanceHoriz(void){
    66276627
    66286628        int approximation;
    … …  
    66316631        switch(approximation){
    66326632                case FSApproximationEnum:
    6633                         return CreateDVectorDiagnosticFS();
     6633                        return CreateDVectorStressbalanceFS();
    66346634                default:
    66356635                        return NULL; //no need for doftypes outside of FS approximation
    … …  
    66376637}
    66386638/*}}}*/
    6639 /*FUNCTION Penta::CreateDVectorDiagnosticFS{{{*/
    6640 ElementVector* Penta::CreateDVectorDiagnosticFS(void){
     6639/*FUNCTION Penta::CreateDVectorStressbalanceFS{{{*/
     6640ElementVector* Penta::CreateDVectorStressbalanceFS(void){
    66416641
    66426642        /*output: */
    … …  
    67266726        /* Get node coordinates and dof list: */
    67276727        GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
    6728         this->parameters->FindParam(&viscosity_overshoot,DiagnosticViscosityOvershootEnum);
     6728        this->parameters->FindParam(&viscosity_overshoot,StressbalanceViscosityOvershootEnum);
    67296729        Input* vx_input=inputs->GetInput(VxEnum);       _assert_(vx_input);
    67306730        Input* vy_input=inputs->GetInput(VyEnum);       _assert_(vy_input);
    … …  
    69336933        /* Get node coordinates and dof list: */
    69346934        GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
    6935         parameters->FindParam(&FSreconditioning,DiagnosticFSreconditioningEnum);
     6935        parameters->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum);
    69366936        Input* vx_input=inputs->GetInput(VxEnum);       _assert_(vx_input);
    69376937        Input* vy_input=inputs->GetInput(VyEnum);       _assert_(vy_input);
    … …  
    70437043        GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
    70447044        parameters->FindParam(&analysis_type,AnalysisTypeEnum);
    7045         parameters->FindParam(&FSreconditioning,DiagnosticFSreconditioningEnum);
     7045        parameters->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum);
    70467046        Input* vx_input=inputs->GetInput(VxEnum); _assert_(vx_input);
    70477047        Input* vy_input=inputs->GetInput(VyEnum); _assert_(vy_input);
    … …  
    71317131        /*Compute HO Matrix with P1 element type\n");*/
    71327132        this->element_type=P1Enum;
    7133         Ke1=CreateKMatrixDiagnosticHO();
     7133        Ke1=CreateKMatrixStressbalanceHO();
    71347134        this->element_type=init;
    71357135        /*Compute FS Matrix and condense it \n");*/
    7136         Ke2=CreateKMatrixDiagnosticFS();
     7136        Ke2=CreateKMatrixStressbalanceFS();
    71377137        int indices[3]={18,19,20};
    71387138        Ke2->StaticCondensation(3,&indices[0]);
    … …  
    71567156}
    71577157//*}}}*/
    7158 /*FUNCTION Penta::CreateKMatrixDiagnosticHoriz {{{*/
    7159 ElementMatrix* Penta::CreateKMatrixDiagnosticHoriz(void){
     7158/*FUNCTION Penta::CreateKMatrixStressbalanceHoriz {{{*/
     7159ElementMatrix* Penta::CreateKMatrixStressbalanceHoriz(void){
    71607160
    71617161        int approximation;
    … …  
    71637163        switch(approximation){
    71647164                case SSAApproximationEnum:
    7165                         return CreateKMatrixDiagnosticSSA2d();
     7165                        return CreateKMatrixStressbalanceSSA2d();
    71667166                case L1L2ApproximationEnum:
    7167                         return CreateKMatrixDiagnosticL1L2();
     7167                        return CreateKMatrixStressbalanceL1L2();
    71687168                case HOApproximationEnum:
    7169                         return CreateKMatrixDiagnosticHO();
     7169                        return CreateKMatrixStressbalanceHO();
    71707170                case FSApproximationEnum:
    7171                         return CreateKMatrixDiagnosticFS();
     7171                        return CreateKMatrixStressbalanceFS();
    71727172                case SIAApproximationEnum:
    71737173                        return NULL;
    … …  
    71757175                        return NULL;
    71767176                case SSAHOApproximationEnum:
    7177                         return CreateKMatrixDiagnosticSSAHO();
     7177                        return CreateKMatrixStressbalanceSSAHO();
    71787178                case SSAFSApproximationEnum:
    7179                         return CreateKMatrixDiagnosticSSAFS();
     7179                        return CreateKMatrixStressbalanceSSAFS();
    71807180                case HOFSApproximationEnum:
    7181                         return CreateKMatrixDiagnosticHOFS();
     7181                        return CreateKMatrixStressbalanceHOFS();
    71827182                default:
    71837183                        _error_("Approximation " << EnumToStringx(approximation) << " not supported yet");
    … …  
    71857185}
    71867186/*}}}*/
    7187 /*FUNCTION Penta::CreateKMatrixDiagnosticSIA{{{*/
    7188 ElementMatrix* Penta::CreateKMatrixDiagnosticSIA(void){
     7187/*FUNCTION Penta::CreateKMatrixStressbalanceSIA{{{*/
     7188ElementMatrix* Penta::CreateKMatrixStressbalanceSIA(void){
    71897189
    71907190        /*Intermediaries*/
    … …  
    72487248        return Ke;
    72497249}/*}}}*/
    7250 /*FUNCTION Penta::CreateKMatrixDiagnosticSSA2d{{{*/
    7251 ElementMatrix* Penta::CreateKMatrixDiagnosticSSA2d(void){
     7250/*FUNCTION Penta::CreateKMatrixStressbalanceSSA2d{{{*/
     7251ElementMatrix* Penta::CreateKMatrixStressbalanceSSA2d(void){
    72527252
    72537253        /*Figure out if this penta is collapsed. If so, then bailout, except if it is at the
    … …  
    72717271        /*Call Tria function*/
    72727272        Tria* tria=(Tria*)SpawnTria(0); //lower face is 0, upper face is 1.
    7273         ElementMatrix* Ke=tria->CreateKMatrixDiagnosticSSA();
     7273        ElementMatrix* Ke=tria->CreateKMatrixStressbalanceSSA();
    72747274        delete tria->material; delete tria;
    72757275
    … …  
    72827282}
    72837283/*}}}*/
    7284 /*FUNCTION Penta::CreateKMatrixDiagnosticSSA3d{{{*/
    7285 ElementMatrix* Penta::CreateKMatrixDiagnosticSSA3d(void){
     7284/*FUNCTION Penta::CreateKMatrixStressbalanceSSA3d{{{*/
     7285ElementMatrix* Penta::CreateKMatrixStressbalanceSSA3d(void){
    72867286
    72877287        /*compute all stiffness matrices for this element*/
    7288         ElementMatrix* Ke1=CreateKMatrixDiagnosticSSA3dViscous();
    7289         ElementMatrix* Ke2=CreateKMatrixDiagnosticSSA3dFriction();
     7288        ElementMatrix* Ke1=CreateKMatrixStressbalanceSSA3dViscous();
     7289        ElementMatrix* Ke2=CreateKMatrixStressbalanceSSA3dFriction();
    72907290        ElementMatrix* Ke =new ElementMatrix(Ke1,Ke2);
    72917291
    … …  
    72967296}
    72977297/*}}}*/
    7298 /*FUNCTION Penta::CreateKMatrixDiagnosticSSA3dViscous{{{*/
    7299 ElementMatrix* Penta::CreateKMatrixDiagnosticSSA3dViscous(void){
     7298/*FUNCTION Penta::CreateKMatrixStressbalanceSSA3dViscous{{{*/
     7299ElementMatrix* Penta::CreateKMatrixStressbalanceSSA3dViscous(void){
    73007300
    73017301        /*Constants*/
    … …  
    73297329        /*Retrieve all inputs and parameters*/
    73307330        GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
    7331         this->parameters->FindParam(&viscosity_overshoot,DiagnosticViscosityOvershootEnum);
     7331        this->parameters->FindParam(&viscosity_overshoot,StressbalanceViscosityOvershootEnum);
    73327332        Input* vx_input=inputs->GetInput(VxEnum);       _assert_(vx_input);
    73337333        Input* vy_input=inputs->GetInput(VyEnum);       _assert_(vy_input);
    … …  
    73847384}
    73857385/*}}}*/
    7386 /*FUNCTION Penta::CreateKMatrixDiagnosticSSA3dFriction{{{*/
    7387 ElementMatrix* Penta::CreateKMatrixDiagnosticSSA3dFriction(void){
     7386/*FUNCTION Penta::CreateKMatrixStressbalanceSSA3dFriction{{{*/
     7387ElementMatrix* Penta::CreateKMatrixStressbalanceSSA3dFriction(void){
    73887388
    73897389        /*Initialize Element matrix and return if necessary*/
    … …  
    73947394         * nodes: */
    73957395        Tria* tria=(Tria*)SpawnTria(0); //lower face is 0, upper face is 1.
    7396         ElementMatrix* Ke=tria->CreateKMatrixDiagnosticSSAFriction();
     7396        ElementMatrix* Ke=tria->CreateKMatrixStressbalanceSSAFriction();
    73977397        delete tria->material; delete tria;
    73987398
    … …  
    74017401}
    74027402/*}}}*/
    7403 /*FUNCTION Penta::CreateKMatrixDiagnosticSSAHO{{{*/
    7404 ElementMatrix* Penta::CreateKMatrixDiagnosticSSAHO(void){
     7403/*FUNCTION Penta::CreateKMatrixStressbalanceSSAHO{{{*/
     7404ElementMatrix* Penta::CreateKMatrixStressbalanceSSAHO(void){
    74057405
    74067406        /*compute all stiffness matrices for this element*/
    7407         ElementMatrix* Ke1=CreateKMatrixDiagnosticSSA3d();
    7408         ElementMatrix* Ke2=CreateKMatrixDiagnosticHO();
     7407        ElementMatrix* Ke1=CreateKMatrixStressbalanceSSA3d();
     7408        ElementMatrix* Ke2=CreateKMatrixStressbalanceHO();
    74097409        ElementMatrix* Ke3=CreateKMatrixCouplingSSAHO();
    74107410        ElementMatrix* Ke =new ElementMatrix(Ke1,Ke2,Ke3);
    … …  
    74177417}
    74187418/*}}}*/
    7419 /*FUNCTION Penta::CreateKMatrixDiagnosticSSAFS{{{*/
    7420 ElementMatrix* Penta::CreateKMatrixDiagnosticSSAFS(void){
     7419/*FUNCTION Penta::CreateKMatrixStressbalanceSSAFS{{{*/
     7420ElementMatrix* Penta::CreateKMatrixStressbalanceSSAFS(void){
    74217421
    74227422        /*compute all stiffness matrices for this element*/
    7423         ElementMatrix* Ke1=CreateKMatrixDiagnosticFS();
     7423        ElementMatrix* Ke1=CreateKMatrixStressbalanceFS();
    74247424        int indices[3]={18,19,20};
    74257425        Ke1->StaticCondensation(3,&indices[0]);
    74267426        int init = this->element_type;
    74277427        this->element_type=P1Enum; //P1 needed for HO
    7428         ElementMatrix* Ke2=CreateKMatrixDiagnosticSSA3d();
     7428        ElementMatrix* Ke2=CreateKMatrixStressbalanceSSA3d();
    74297429        this->element_type=init;
    74307430        ElementMatrix* Ke3=CreateKMatrixCouplingSSAFS();
    … …  
    74387438}
    74397439/*}}}*/
    7440 /*FUNCTION Penta::CreateKMatrixDiagnosticL1L2{{{*/
    7441 ElementMatrix* Penta::CreateKMatrixDiagnosticL1L2(void){
     7440/*FUNCTION Penta::CreateKMatrixStressbalanceL1L2{{{*/
     7441ElementMatrix* Penta::CreateKMatrixStressbalanceL1L2(void){
    74427442
    74437443        /*compute all stiffness matrices for this element*/
    7444         ElementMatrix* Ke1=CreateKMatrixDiagnosticL1L2Viscous();
    7445         ElementMatrix* Ke2=CreateKMatrixDiagnosticL1L2Friction();
     7444        ElementMatrix* Ke1=CreateKMatrixStressbalanceL1L2Viscous();
     7445        ElementMatrix* Ke2=CreateKMatrixStressbalanceL1L2Friction();
    74467446        ElementMatrix* Ke =new ElementMatrix(Ke1,Ke2);
    74477447
    … …  
    74527452}
    74537453/*}}}*/
    7454 /*FUNCTION Penta::CreateKMatrixDiagnosticL1L2Viscous{{{*/
    7455 ElementMatrix* Penta::CreateKMatrixDiagnosticL1L2Viscous(void){
     7454/*FUNCTION Penta::CreateKMatrixStressbalanceL1L2Viscous{{{*/
     7455ElementMatrix* Penta::CreateKMatrixStressbalanceL1L2Viscous(void){
    74567456
    74577457        /*Constants*/
    … …  
    75207520}
    75217521/*}}}*/
    7522 /*FUNCTION Penta::CreateKMatrixDiagnosticL1L2Friction{{{*/
    7523 ElementMatrix* Penta::CreateKMatrixDiagnosticL1L2Friction(void){
     7522/*FUNCTION Penta::CreateKMatrixStressbalanceL1L2Friction{{{*/
     7523ElementMatrix* Penta::CreateKMatrixStressbalanceL1L2Friction(void){
    75247524
    75257525        /*Initialize Element matrix and return if necessary*/
    … …  
    75307530         * nodes: */
    75317531        Tria* tria=(Tria*)SpawnTria(0); //lower face is 0, upper face is 1.
    7532         ElementMatrix* Ke=tria->CreateKMatrixDiagnosticSSAFriction();
     7532        ElementMatrix* Ke=tria->CreateKMatrixStressbalanceSSAFriction();
    75337533        delete tria->material; delete tria;
    75347534
    … …  
    75377537}
    75387538/*}}}*/
    7539 /*FUNCTION Penta::CreateKMatrixDiagnosticHO{{{*/
    7540 ElementMatrix* Penta::CreateKMatrixDiagnosticHO(void){
     7539/*FUNCTION Penta::CreateKMatrixStressbalanceHO{{{*/
     7540ElementMatrix* Penta::CreateKMatrixStressbalanceHO(void){
    75417541
    75427542        /*compute all stiffness matrices for this element*/
    7543         ElementMatrix* Ke1=CreateKMatrixDiagnosticHOViscous();
    7544         ElementMatrix* Ke2=CreateKMatrixDiagnosticHOFriction();
     7543        ElementMatrix* Ke1=CreateKMatrixStressbalanceHOViscous();
     7544        ElementMatrix* Ke2=CreateKMatrixStressbalanceHOFriction();
    75457545        ElementMatrix* Ke =new ElementMatrix(Ke1,Ke2);
    75467546
    … …  
    75527552}
    75537553/*}}}*/
    7554 /*FUNCTION Penta::CreateKMatrixDiagnosticHOViscous{{{*/
    7555 ElementMatrix* Penta::CreateKMatrixDiagnosticHOViscous(void){
     7554/*FUNCTION Penta::CreateKMatrixStressbalanceHOViscous{{{*/
     7555ElementMatrix* Penta::CreateKMatrixStressbalanceHOViscous(void){
    75567556
    75577557        /*Intermediaries */
    … …  
    75787578        inputs->GetInputValue(&approximation,ApproximationEnum);
    75797579        GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
    7580         this->parameters->FindParam(&viscosity_overshoot,DiagnosticViscosityOvershootEnum);
     7580        this->parameters->FindParam(&viscosity_overshoot,StressbalanceViscosityOvershootEnum);
    75817581        Input* vx_input=inputs->GetInput(VxEnum);       _assert_(vx_input);
    75827582        Input* vy_input=inputs->GetInput(VyEnum);       _assert_(vy_input);
    … …  
    76207620}
    76217621/*}}}*/
    7622 /*FUNCTION Penta::CreateKMatrixDiagnosticHOFriction{{{*/
    7623 ElementMatrix* Penta::CreateKMatrixDiagnosticHOFriction(void){
     7622/*FUNCTION Penta::CreateKMatrixStressbalanceHOFriction{{{*/
     7623ElementMatrix* Penta::CreateKMatrixStressbalanceHOFriction(void){
    76247624
    76257625        /*Intermediaries */
    … …  
    76947694}
    76957695/*}}}*/
    7696 /*FUNCTION Penta::CreateKMatrixDiagnosticHOFS{{{*/
    7697 ElementMatrix* Penta::CreateKMatrixDiagnosticHOFS(void){
     7696/*FUNCTION Penta::CreateKMatrixStressbalanceHOFS{{{*/
     7697ElementMatrix* Penta::CreateKMatrixStressbalanceHOFS(void){
    76987698
    76997699        /*compute all stiffness matrices for this element*/
    7700         ElementMatrix* Ke1=CreateKMatrixDiagnosticFS();
     7700        ElementMatrix* Ke1=CreateKMatrixStressbalanceFS();
    77017701        int indices[3]={18,19,20};
    77027702        Ke1->StaticCondensation(3,&indices[0]);
    77037703        int init = this->element_type;
    77047704        this->element_type=P1Enum; //P1 needed for HO
    7705         ElementMatrix* Ke2=CreateKMatrixDiagnosticHO();
     7705        ElementMatrix* Ke2=CreateKMatrixStressbalanceHO();
    77067706        this->element_type=init;
    77077707        ElementMatrix* Ke3=CreateKMatrixCouplingHOFS();
    … …  
    77157715}
    77167716/*}}}*/
    7717 /*FUNCTION Penta::CreateKMatrixDiagnosticFS{{{*/
    7718 ElementMatrix* Penta::CreateKMatrixDiagnosticFS(void){
     7717/*FUNCTION Penta::CreateKMatrixStressbalanceFS{{{*/
     7718ElementMatrix* Penta::CreateKMatrixStressbalanceFS(void){
    77197719
    77207720        ElementMatrix* Ke1 = NULL;
    … …  
    77237723
    77247724        /*compute all stiffness matrices for this element*/
    7725         Ke1=CreateKMatrixDiagnosticFSViscous();
    7726         Ke2=CreateKMatrixDiagnosticFSFriction();
     7725        Ke1=CreateKMatrixStressbalanceFSViscous();
     7726        Ke2=CreateKMatrixStressbalanceFSFriction();
    77277727        Ke =new ElementMatrix(Ke1,Ke2);
    77287728
    … …  
    77677767        /*Retrieve all inputs and parameters*/
    77687768        GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
    7769         parameters->FindParam(&FSreconditioning,DiagnosticFSreconditioningEnum);
     7769        parameters->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum);
    77707770        Input* vx_input=inputs->GetInput(VxEnum); _assert_(vx_input);
    77717771        Input* vy_input=inputs->GetInput(VyEnum); _assert_(vy_input);
    … …  
    78487848}
    78497849/*}}}*/
    7850 /*FUNCTION Penta::CreateKMatrixDiagnosticFSViscous {{{*/
    7851 ElementMatrix* Penta::CreateKMatrixDiagnosticFSViscous(void){
     7850/*FUNCTION Penta::CreateKMatrixStressbalanceFSViscous {{{*/
     7851ElementMatrix* Penta::CreateKMatrixStressbalanceFSViscous(void){
    78527852
    78537853        /*Intermediaries */
    … …  
    78807880        /*Retrieve all inputs and parameters*/
    78817881        GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
    7882         parameters->FindParam(&FSreconditioning,DiagnosticFSreconditioningEnum);
     7882        parameters->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum);
    78837883        Input* vx_input=inputs->GetInput(VxEnum); _assert_(vx_input);
    78847884        Input* vy_input=inputs->GetInput(VyEnum); _assert_(vy_input);
    … …  
    79207920}
    79217921/*}}}*/
    7922 /*FUNCTION Penta::CreateKMatrixDiagnosticFSFriction{{{*/
    7923 ElementMatrix* Penta::CreateKMatrixDiagnosticFSFriction(void){
     7922/*FUNCTION Penta::CreateKMatrixStressbalanceFSFriction{{{*/
     7923ElementMatrix* Penta::CreateKMatrixStressbalanceFSFriction(void){
    79247924
    79257925        /*Intermediaries */
    … …  
    79547954        GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
    79557955        parameters->FindParam(&analysis_type,AnalysisTypeEnum);
    7956         parameters->FindParam(&FSreconditioning,DiagnosticFSreconditioningEnum);
     7956        parameters->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum);
    79577957        Input* vx_input=inputs->GetInput(VxEnum); _assert_(vx_input);
    79587958        Input* vy_input=inputs->GetInput(VyEnum); _assert_(vy_input);
    … …  
    79977997}
    79987998/*}}}*/
    7999 /*FUNCTION Penta::CreateKMatrixDiagnosticVert {{{*/
    8000 ElementMatrix* Penta::CreateKMatrixDiagnosticVert(void){
     7999/*FUNCTION Penta::CreateKMatrixStressbalanceVert {{{*/
     8000ElementMatrix* Penta::CreateKMatrixStressbalanceVert(void){
    80018001
    80028002        /*compute all stiffness matrices for this element*/
    8003         ElementMatrix* Ke1=CreateKMatrixDiagnosticVertVolume();
    8004         ElementMatrix* Ke2=CreateKMatrixDiagnosticVertSurface();
     8003        ElementMatrix* Ke1=CreateKMatrixStressbalanceVertVolume();
     8004        ElementMatrix* Ke2=CreateKMatrixStressbalanceVertSurface();
    80058005        ElementMatrix* Ke =new ElementMatrix(Ke1,Ke2);
    80068006
    … …  
    80128012}
    80138013/*}}}*/
    8014 /*FUNCTION Penta::CreateKMatrixDiagnosticVertVolume {{{*/
    8015 ElementMatrix* Penta::CreateKMatrixDiagnosticVertVolume(void){
     8014/*FUNCTION Penta::CreateKMatrixStressbalanceVertVolume {{{*/
     8015ElementMatrix* Penta::CreateKMatrixStressbalanceVertVolume(void){
    80168016
    80178017        /*Intermediaries */
    … …  
    80528052}
    80538053/*}}}*/
    8054 /*FUNCTION Penta::CreateKMatrixDiagnosticVertSurface {{{*/
    8055 ElementMatrix* Penta::CreateKMatrixDiagnosticVertSurface(void){
     8054/*FUNCTION Penta::CreateKMatrixStressbalanceVertSurface {{{*/
     8055ElementMatrix* Penta::CreateKMatrixStressbalanceVertSurface(void){
    80568056
    80578057        if (!IsOnSurface()) return NULL;
    … …  
    81428142        /*Retrieve all inputs and parameters*/
    81438143        GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
    8144         this->parameters->FindParam(&FSreconditioning,DiagnosticFSreconditioningEnum);
     8144        this->parameters->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum);
    81458145        Input* vx_input=inputs->GetInput(VxEnum);               _assert_(vx_input);
    81468146        Input* vy_input=inputs->GetInput(VyEnum);               _assert_(vy_input);
    … …  
    82088208        GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
    82098209        parameters->FindParam(&analysis_type,AnalysisTypeEnum);
    8210         this->parameters->FindParam(&FSreconditioning,DiagnosticFSreconditioningEnum);
     8210        this->parameters->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum);
    82118211        Input* vx_input=inputs->GetInput(VxEnum);               _assert_(vx_input);
    82128212        Input* vy_input=inputs->GetInput(VyEnum);               _assert_(vy_input);
    … …  
    82978297        /*Retrieve all inputs and parameters*/
    82988298        GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
    8299         this->parameters->FindParam(&FSreconditioning,DiagnosticFSreconditioningEnum);
     8299        this->parameters->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum);
    83008300        Input* vx_input=inputs->GetInput(VxEnum);       _assert_(vx_input);
    83018301        Input* vy_input=inputs->GetInput(VyEnum);       _assert_(vy_input);
    … …  
    83738373        GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
    83748374        parameters->FindParam(&analysis_type,AnalysisTypeEnum);
    8375         this->parameters->FindParam(&FSreconditioning,DiagnosticFSreconditioningEnum);
     8375        this->parameters->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum);
    83768376        Input* vx_input=inputs->GetInput(VxEnum);               _assert_(vx_input);
    83778377        Input* vy_input=inputs->GetInput(VyEnum);               _assert_(vy_input);
    … …  
    84188418}
    84198419/*}}}*/
    8420 /*FUNCTION Penta::CreatePVectorDiagnosticHoriz{{{*/
    8421 ElementVector* Penta::CreatePVectorDiagnosticHoriz(void){
     8420/*FUNCTION Penta::CreatePVectorStressbalanceHoriz{{{*/
     8421ElementVector* Penta::CreatePVectorStressbalanceHoriz(void){
    84228422
    84238423        int approximation;
    … …  
    84268426        switch(approximation){
    84278427                case SSAApproximationEnum:
    8428                         return CreatePVectorDiagnosticSSA();
     8428                        return CreatePVectorStressbalanceSSA();
    84298429                case HOApproximationEnum:
    8430                         return CreatePVectorDiagnosticHO();
     8430                        return CreatePVectorStressbalanceHO();
    84318431                case L1L2ApproximationEnum:
    8432                         return CreatePVectorDiagnosticL1L2();
     8432                        return CreatePVectorStressbalanceL1L2();
    84338433                case SIAApproximationEnum:
    84348434                        return NULL;
    … …  
    84368436                        return NULL;
    84378437                case FSApproximationEnum:
    8438                         return CreatePVectorDiagnosticFS();
     8438                        return CreatePVectorStressbalanceFS();
    84398439                case SSAHOApproximationEnum:
    8440                         return CreatePVectorDiagnosticSSAHO();
     8440                        return CreatePVectorStressbalanceSSAHO();
    84418441                case SSAFSApproximationEnum:
    8442                         return CreatePVectorDiagnosticSSAFS();
     8442                        return CreatePVectorStressbalanceSSAFS();
    84438443                case HOFSApproximationEnum:
    8444                         return CreatePVectorDiagnosticHOFS();
     8444                        return CreatePVectorStressbalanceHOFS();
    84458445                default:
    84468446                        _error_("Approximation " << EnumToStringx(approximation) << " not supported yet");
    … …  
    84488448}
    84498449/*}}}*/
    8450 /*FUNCTION Penta::CreatePVectorDiagnosticSSAHO{{{*/
    8451 ElementVector* Penta::CreatePVectorDiagnosticSSAHO(void){
     8450/*FUNCTION Penta::CreatePVectorStressbalanceSSAHO{{{*/
     8451ElementVector* Penta::CreatePVectorStressbalanceSSAHO(void){
    84528452
    84538453        /*compute all load vectors for this element*/
    8454         ElementVector* pe1=CreatePVectorDiagnosticSSA();
    8455         ElementVector* pe2=CreatePVectorDiagnosticHO();
     8454        ElementVector* pe1=CreatePVectorStressbalanceSSA();
     8455        ElementVector* pe2=CreatePVectorStressbalanceHO();
    84568456        ElementVector* pe =new ElementVector(pe1,pe2);
    84578457
    … …  
    84628462}
    84638463/*}}}*/
    8464 /*FUNCTION Penta::CreatePVectorDiagnosticSSAFS{{{*/
    8465 ElementVector* Penta::CreatePVectorDiagnosticSSAFS(void){
     8464/*FUNCTION Penta::CreatePVectorStressbalanceSSAFS{{{*/
     8465ElementVector* Penta::CreatePVectorStressbalanceSSAFS(void){
    84668466
    84678467        /*compute all load vectors for this element*/
    84688468        int init = this->element_type;
    84698469        this->element_type=P1Enum;
    8470         ElementVector* pe1=CreatePVectorDiagnosticSSA();
     8470        ElementVector* pe1=CreatePVectorStressbalanceSSA();
    84718471        this->element_type=init;
    8472         ElementVector* pe2=CreatePVectorDiagnosticFS();
     8472        ElementVector* pe2=CreatePVectorStressbalanceFS();
    84738473        int indices[3]={18,19,20};
    84748474        this->element_type=MINIcondensedEnum;
    8475         ElementMatrix* Ke = CreateKMatrixDiagnosticFS();
     8475        ElementMatrix* Ke = CreateKMatrixStressbalanceFS();
    84768476        this->element_type=init;
    84778477        pe2->StaticCondensation(Ke,3,&indices[0]);
    … …  
    84878487}
    84888488/*}}}*/
    8489 /*FUNCTION Penta::CreatePVectorDiagnosticHOFS{{{*/
    8490 ElementVector* Penta::CreatePVectorDiagnosticHOFS(void){
     8489/*FUNCTION Penta::CreatePVectorStressbalanceHOFS{{{*/
     8490ElementVector* Penta::CreatePVectorStressbalanceHOFS(void){
    84918491
    84928492        /*compute all load vectors for this element*/
    84938493        int init = this->element_type;
    84948494        this->element_type=P1Enum;
    8495         ElementVector* pe1=CreatePVectorDiagnosticHO();
     8495        ElementVector* pe1=CreatePVectorStressbalanceHO();
    84968496        this->element_type=init;
    8497         ElementVector* pe2=CreatePVectorDiagnosticFS();
     8497        ElementVector* pe2=CreatePVectorStressbalanceFS();
    84988498        int indices[3]={18,19,20};
    84998499        this->element_type=MINIcondensedEnum;
    8500         ElementMatrix* Ke = CreateKMatrixDiagnosticFS();
     8500        ElementMatrix* Ke = CreateKMatrixStressbalanceFS();
    85018501        this->element_type=init;
    85028502        pe2->StaticCondensation(Ke,3,&indices[0]);
    … …  
    85128512}
    85138513/*}}}*/
    8514 /*FUNCTION Penta::CreatePVectorDiagnosticSIA{{{*/
    8515 ElementVector* Penta::CreatePVectorDiagnosticSIA(void){
     8514/*FUNCTION Penta::CreatePVectorStressbalanceSIA{{{*/
     8515ElementVector* Penta::CreatePVectorStressbalanceSIA(void){
    85168516
    85178517        /*Intermediaries*/
    … …  
    86028602}
    86038603/*}}}*/
    8604 /*FUNCTION Penta::CreatePVectorDiagnosticSSA{{{*/
    8605 ElementVector* Penta::CreatePVectorDiagnosticSSA(void){
     8604/*FUNCTION Penta::CreatePVectorStressbalanceSSA{{{*/
     8605ElementVector* Penta::CreatePVectorStressbalanceSSA(void){
    86068606
    86078607        if (!IsOnBed()) return NULL;
    … …  
    86098609        /*Call Tria function*/
    86108610        Tria* tria=(Tria*)SpawnTria(0); //lower face is 0, upper face is 1.
    8611         ElementVector* pe=tria->CreatePVectorDiagnosticSSA();
     8611        ElementVector* pe=tria->CreatePVectorStressbalanceSSA();
    86128612        delete tria->material; delete tria;
    86138613
    … …  
    86168616}
    86178617/*}}}*/
    8618 /*FUNCTION Penta::CreatePVectorDiagnosticL1L2{{{*/
    8619 ElementVector* Penta::CreatePVectorDiagnosticL1L2(void){
     8618/*FUNCTION Penta::CreatePVectorStressbalanceL1L2{{{*/
     8619ElementVector* Penta::CreatePVectorStressbalanceL1L2(void){
    86208620
    86218621        if (!IsOnBed()) return NULL;
    … …  
    86238623        /*Call Tria function*/
    86248624        Tria* tria=(Tria*)SpawnTria(0); //lower face is 0, upper face is 1.
    8625         ElementVector* pe=tria->CreatePVectorDiagnosticSSA();
     8625        ElementVector* pe=tria->CreatePVectorStressbalanceSSA();
    86268626        delete tria->material; delete tria;
    86278627
    … …  
    86308630}
    86318631/*}}}*/
    8632 /*FUNCTION Penta::CreatePVectorDiagnosticHO{{{*/
    8633 ElementVector* Penta::CreatePVectorDiagnosticHO(void){
     8632/*FUNCTION Penta::CreatePVectorStressbalanceHO{{{*/
     8633ElementVector* Penta::CreatePVectorStressbalanceHO(void){
    86348634
    86358635        /*compute all load vectors for this element*/
    8636         ElementVector* pe1=CreatePVectorDiagnosticHODrivingStress();
    8637         ElementVector* pe2=CreatePVectorDiagnosticHOFront();
     8636        ElementVector* pe1=CreatePVectorStressbalanceHODrivingStress();
     8637        ElementVector* pe2=CreatePVectorStressbalanceHOFront();
    86388638        ElementVector* pe =new ElementVector(pe1,pe2);
    86398639
    … …  
    86448644}
    86458645/*}}}*/
    8646 /*FUNCTION Penta::CreatePVectorDiagnosticHODrivingStress{{{*/
    8647 ElementVector* Penta::CreatePVectorDiagnosticHODrivingStress(void){
     8646/*FUNCTION Penta::CreatePVectorStressbalanceHODrivingStress{{{*/
     8647ElementVector* Penta::CreatePVectorStressbalanceHODrivingStress(void){
    86488648
    86498649        /*Intermediaries*/
    … …  
    86968696}
    86978697/*}}}*/
    8698 /*FUNCTION Penta::CreatePVectorDiagnosticHOFront{{{*/
    8699 ElementVector* Penta::CreatePVectorDiagnosticHOFront(void){
     8698/*FUNCTION Penta::CreatePVectorStressbalanceHOFront{{{*/
     8699ElementVector* Penta::CreatePVectorStressbalanceHOFront(void){
    87008700
    87018701        /*Intermediaries */
    … …  
    87798779}
    87808780/*}}}*/
    8781 /*FUNCTION Penta::CreatePVectorDiagnosticFS {{{*/
    8782 ElementVector* Penta::CreatePVectorDiagnosticFS(void){
     8781/*FUNCTION Penta::CreatePVectorStressbalanceFS {{{*/
     8782ElementVector* Penta::CreatePVectorStressbalanceFS(void){
    87838783
    87848784        ElementVector* pe1;
    … …  
    87888788
    87898789        /*compute all stiffness matrices for this element*/
    8790         pe1=CreatePVectorDiagnosticFSViscous();
    8791         pe2=CreatePVectorDiagnosticFSShelf();
    8792         pe3=CreatePVectorDiagnosticFSFront();
     8790        pe1=CreatePVectorStressbalanceFSViscous();
     8791        pe2=CreatePVectorStressbalanceFSShelf();
     8792        pe3=CreatePVectorStressbalanceFSFront();
    87938793        pe =new ElementVector(pe1,pe2,pe3);
    87948794
    … …  
    88008800}
    88018801/*}}}*/
    8802 /*FUNCTION Penta::CreatePVectorDiagnosticFSFront{{{*/
    8803 ElementVector* Penta::CreatePVectorDiagnosticFSFront(void){
     8802/*FUNCTION Penta::CreatePVectorStressbalanceFSFront{{{*/
     8803ElementVector* Penta::CreatePVectorStressbalanceFSFront(void){
    88048804
    88058805        /*Intermediaries */
    … …  
    89808980}
    89818981/*}}}*/
    8982 /*FUNCTION Penta::CreatePVectorDiagnosticFSViscous {{{*/
    8983 ElementVector* Penta::CreatePVectorDiagnosticFSViscous(void){
     8982/*FUNCTION Penta::CreatePVectorStressbalanceFSViscous {{{*/
     8983ElementVector* Penta::CreatePVectorStressbalanceFSViscous(void){
    89848984
    89858985        /*Intermediaries*/
    … …  
    90479047}
    90489048/*}}}*/
    9049 /*FUNCTION Penta::CreatePVectorDiagnosticFSShelf{{{*/
    9050 ElementVector* Penta::CreatePVectorDiagnosticFSShelf(void){
     9049/*FUNCTION Penta::CreatePVectorStressbalanceFSShelf{{{*/
     9050ElementVector* Penta::CreatePVectorStressbalanceFSShelf(void){
    90519051
    90529052        /*Intermediaries*/
    … …  
    90819081
    90829082        /*Retrieve all inputs and parameters*/
    9083         this->parameters->FindParam(&shelf_dampening,DiagnosticShelfDampeningEnum);
     9083        this->parameters->FindParam(&shelf_dampening,StressbalanceShelfDampeningEnum);
    90849084        rho_water=matpar->GetRhoWater();
    90859085        gravity=matpar->GetG();
    … …  
    91329132}
    91339133/*}}}*/
    9134 /*FUNCTION Penta::CreatePVectorDiagnosticVert {{{*/
    9135 ElementVector* Penta::CreatePVectorDiagnosticVert(void){
     9134/*FUNCTION Penta::CreatePVectorStressbalanceVert {{{*/
     9135ElementVector* Penta::CreatePVectorStressbalanceVert(void){
    91369136
    91379137        /*compute all load vectors for this element*/
    9138         ElementVector* pe1=CreatePVectorDiagnosticVertVolume();
    9139         ElementVector* pe2=CreatePVectorDiagnosticVertBase();
     9138        ElementVector* pe1=CreatePVectorStressbalanceVertVolume();
     9139        ElementVector* pe2=CreatePVectorStressbalanceVertBase();
    91409140        ElementVector* pe =new ElementVector(pe1,pe2);
    91419141
    … …  
    91469146}
    91479147/*}}}*/
    9148 /*FUNCTION Penta::CreatePVectorDiagnosticVertVolume {{{*/
    9149 ElementVector* Penta::CreatePVectorDiagnosticVertVolume(void){
     9148/*FUNCTION Penta::CreatePVectorStressbalanceVertVolume {{{*/
     9149ElementVector* Penta::CreatePVectorStressbalanceVertVolume(void){
    91509150
    91519151        /*Constants*/
    … …  
    92019201}
    92029202/*}}}*/
    9203 /*FUNCTION Penta::CreatePVectorDiagnosticVertBase {{{*/
    9204 ElementVector* Penta::CreatePVectorDiagnosticVertBase(void){
     9203/*FUNCTION Penta::CreatePVectorStressbalanceVertBase {{{*/
     9204ElementVector* Penta::CreatePVectorStressbalanceVertBase(void){
    92059205
    92069206        /*Constants*/
    … …  
    92659265}
    92669266/*}}}*/
    9267 /*FUNCTION Penta::CreateJacobianDiagnosticHoriz{{{*/
    9268 ElementMatrix* Penta::CreateJacobianDiagnosticHoriz(void){
     9267/*FUNCTION Penta::CreateJacobianStressbalanceHoriz{{{*/
     9268ElementMatrix* Penta::CreateJacobianStressbalanceHoriz(void){
    92699269
    92709270        int approximation;
    … …  
    92739273        switch(approximation){
    92749274                case SSAApproximationEnum:
    9275                         return CreateJacobianDiagnosticSSA2d();
     9275                        return CreateJacobianStressbalanceSSA2d();
    92769276                case HOApproximationEnum:
    9277                         return CreateJacobianDiagnosticHO();
     9277                        return CreateJacobianStressbalanceHO();
    92789278                case FSApproximationEnum:
    9279                         return CreateJacobianDiagnosticFS();
     9279                        return CreateJacobianStressbalanceFS();
    92809280                case NoneApproximationEnum:
    92819281                        return NULL;
    … …  
    92859285}
    92869286/*}}}*/
    9287 /*FUNCTION Penta::CreateJacobianDiagnosticSSA2d{{{*/
    9288 ElementMatrix* Penta::CreateJacobianDiagnosticSSA2d(void){
     9287/*FUNCTION Penta::CreateJacobianStressbalanceSSA2d{{{*/
     9288ElementMatrix* Penta::CreateJacobianStressbalanceSSA2d(void){
    92899289
    92909290        /*Figure out if this penta is collapsed. If so, then bailout, except if it is at the
    … …  
    93089308        /*Call Tria function*/
    93099309        Tria* tria=(Tria*)SpawnTria(0); //lower face is 0, upper face is 1.
    9310         ElementMatrix* Ke=tria->CreateJacobianDiagnosticSSA();
     9310        ElementMatrix* Ke=tria->CreateJacobianStressbalanceSSA();
    93119311        delete tria->material; delete tria;
    93129312
    … …  
    93199319}
    93209320/*}}}*/
    9321 /*FUNCTION Penta::CreateJacobianDiagnosticHO{{{*/
    9322 ElementMatrix* Penta::CreateJacobianDiagnosticHO(void){
     9321/*FUNCTION Penta::CreateJacobianStressbalanceHO{{{*/
     9322ElementMatrix* Penta::CreateJacobianStressbalanceHO(void){
    93239323
    93249324        /*Constants*/
    … …  
    93389338
    93399339        /*Initialize Jacobian with regular HO (first part of the Gateau derivative)*/
    9340         ElementMatrix* Ke=CreateKMatrixDiagnosticHO();
     9340        ElementMatrix* Ke=CreateKMatrixStressbalanceHO();
    93419341
    93429342        /*Retrieve all inputs and parameters*/
    … …  
    93839383}
    93849384/*}}}*/
    9385 /*FUNCTION Penta::CreateJacobianDiagnosticFS{{{*/
    9386 ElementMatrix* Penta::CreateJacobianDiagnosticFS(void){
     9385/*FUNCTION Penta::CreateJacobianStressbalanceFS{{{*/
     9386ElementMatrix* Penta::CreateJacobianStressbalanceFS(void){
    93879387
    93889388        /*Intermediaries */
    … …  
    94139413
    94149414        /*Initialize Jacobian with regular FS (first part of the Gateau derivative)*/
    9415         ElementMatrix* Ke=CreateKMatrixDiagnosticFS();
     9415        ElementMatrix* Ke=CreateKMatrixStressbalanceFS();
    94169416        IssmDouble*    dbasis = xNew<IssmDouble>(3*vnumnodes);
    94179417
    … …  
    94769476}
    94779477/*}}}*/
    9478 /*FUNCTION Penta::GetSolutionFromInputsDiagnosticHoriz{{{*/
    9479 void  Penta::GetSolutionFromInputsDiagnosticHoriz(Vector<IssmDouble>* solution){
     9478/*FUNCTION Penta::GetSolutionFromInputsStressbalanceHoriz{{{*/
     9479void  Penta::GetSolutionFromInputsStressbalanceHoriz(Vector<IssmDouble>* solution){
    94809480
    94819481        int         approximation;
    … …  
    95179517}
    95189518/*}}}*/
    9519 /*FUNCTION Penta::GetSolutionFromInputsDiagnosticSIA{{{*/
    9520 void  Penta::GetSolutionFromInputsDiagnosticSIA(Vector<IssmDouble>* solution){
     9519/*FUNCTION Penta::GetSolutionFromInputsStressbalanceSIA{{{*/
     9520void  Penta::GetSolutionFromInputsStressbalanceSIA(Vector<IssmDouble>* solution){
    95219521
    95229522        const int    numdof=NDOF2*NUMVERTICES;
    … …  
    95539553}
    95549554/*}}}*/
    9555 /*FUNCTION Penta::GetSolutionFromInputsDiagnosticVert{{{*/
    9556 void  Penta::GetSolutionFromInputsDiagnosticVert(Vector<IssmDouble>* solution){
     9555/*FUNCTION Penta::GetSolutionFromInputsStressbalanceVert{{{*/
     9556void  Penta::GetSolutionFromInputsStressbalanceVert(Vector<IssmDouble>* solution){
    95579557
    95589558        const int    numdof=NDOF1*NUMVERTICES;
    … …  
    95869586}
    95879587/*}}}*/
    9588 /*FUNCTION Penta::GetSolutionFromInputsDiagnosticFS{{{*/
    9589 void  Penta::GetSolutionFromInputsDiagnosticFS(Vector<IssmDouble>* solution){
     9588/*FUNCTION Penta::GetSolutionFromInputsStressbalanceFS{{{*/
     9589void  Penta::GetSolutionFromInputsStressbalanceFS(Vector<IssmDouble>* solution){
    95909590
    95919591        int*         vdoflist=NULL;
    … …  
    96139613        Input* p_input =inputs->GetInput(PressureEnum); _assert_(p_input);
    96149614
    9615         this->parameters->FindParam(&FSreconditioning,DiagnosticFSreconditioningEnum);
     9615        this->parameters->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum);
    96169616
    96179617        /*Ok, we have vx vy vz in values, fill in vx vy vz arrays: */
    … …  
    97149714}
    97159715/*}}}*/
    9716 /*FUNCTION Penta::InputUpdateFromSolutionDiagnosticHoriz {{{*/
    9717 void  Penta::InputUpdateFromSolutionDiagnosticHoriz(IssmDouble* solution){
     9716/*FUNCTION Penta::InputUpdateFromSolutionStressbalanceHoriz {{{*/
     9717void  Penta::InputUpdateFromSolutionStressbalanceHoriz(IssmDouble* solution){
    97189718
    97199719        int  approximation;
    … …  
    97299729                }
    97309730                else{
    9731                         InputUpdateFromSolutionDiagnosticSSA(solution);
     9731                        InputUpdateFromSolutionStressbalanceSSA(solution);
    97329732                        return;
    97339733                }
    … …  
    97359735        if (approximation==L1L2ApproximationEnum){
    97369736                if (!IsOnBed()) return;
    9737                 InputUpdateFromSolutionDiagnosticL1L2(solution);
     9737                InputUpdateFromSolutionStressbalanceL1L2(solution);
    97389738                return;
    97399739        }
    97409740        else if (approximation==HOApproximationEnum){
    9741                 InputUpdateFromSolutionDiagnosticHO(solution);
     9741                InputUpdateFromSolutionStressbalanceHO(solution);
    97429742        }
    97439743        else if (approximation==HOFSApproximationEnum){
    9744                 InputUpdateFromSolutionDiagnosticHOFS(solution);
     9744                InputUpdateFromSolutionStressbalanceHOFS(solution);
    97459745        }
    97469746        else if (approximation==SSAFSApproximationEnum){
    9747                 InputUpdateFromSolutionDiagnosticSSAFS(solution);
     9747                InputUpdateFromSolutionStressbalanceSSAFS(solution);
    97489748        }
    97499749        else if (approximation==FSApproximationEnum || approximation==NoneApproximationEnum){
    9750                 InputUpdateFromSolutionDiagnosticFS(solution);
     9750                InputUpdateFromSolutionStressbalanceFS(solution);
    97519751        }
    97529752        else if (approximation==SSAHOApproximationEnum){
    9753                 InputUpdateFromSolutionDiagnosticSSAHO(solution);
    9754         }
    9755 }
    9756 /*}}}*/
    9757 /*FUNCTION Penta::InputUpdateFromSolutionDiagnosticSSA {{{*/
    9758 void  Penta::InputUpdateFromSolutionDiagnosticSSA(IssmDouble* solution){
     9753                InputUpdateFromSolutionStressbalanceSSAHO(solution);
     9754        }
     9755}
     9756/*}}}*/
     9757/*FUNCTION Penta::InputUpdateFromSolutionStressbalanceSSA {{{*/
     9758void  Penta::InputUpdateFromSolutionStressbalanceSSA(IssmDouble* solution){
    97599759
    97609760        int         numnodes = this->NumberofNodes();
    … …  
    98379837}
    98389838/*}}}*/
    9839 /*FUNCTION Penta::InputUpdateFromSolutionDiagnosticSSAHO {{{*/
    9840 void  Penta::InputUpdateFromSolutionDiagnosticSSAHO(IssmDouble* solution){
     9839/*FUNCTION Penta::InputUpdateFromSolutionStressbalanceSSAHO {{{*/
     9840void  Penta::InputUpdateFromSolutionStressbalanceSSAHO(IssmDouble* solution){
    98419841
    98429842        const int    numdof=NDOF2*NUMVERTICES;
    … …  
    99219921}
    99229922/*}}}*/
    9923 /*FUNCTION Penta::InputUpdateFromSolutionDiagnosticSSAFS {{{*/
    9924 void  Penta::InputUpdateFromSolutionDiagnosticSSAFS(IssmDouble* solution){
     9923/*FUNCTION Penta::InputUpdateFromSolutionStressbalanceSSAFS {{{*/
     9924void  Penta::InputUpdateFromSolutionStressbalanceSSAFS(IssmDouble* solution){
    99259925
    99269926        const int    numdofm=NDOF2*NUMVERTICES;
    … …  
    99559955        GetDofList(&doflists,FSvelocityEnum,GsetEnum);
    99569956        GetDofListPressure(&doflistpressure,GsetEnum);
    9957         this->parameters->FindParam(&FSreconditioning,DiagnosticFSreconditioningEnum);
     9957        this->parameters->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum);
    99589958
    99599959        /*Get node data: */
    … …  
    1002410024}
    1002510025/*}}}*/
    10026 /*FUNCTION Penta::InputUpdateFromSolutionDiagnosticL1L2 {{{*/
    10027 void  Penta::InputUpdateFromSolutionDiagnosticL1L2(IssmDouble* solution){
     10026/*FUNCTION Penta::InputUpdateFromSolutionStressbalanceL1L2 {{{*/
     10027void  Penta::InputUpdateFromSolutionStressbalanceL1L2(IssmDouble* solution){
    1002810028
    1002910029        const int    numdof=NDOF2*NUMVERTICES;
    … …  
    1010510105}
    1010610106/*}}}*/
    10107 /*FUNCTION Penta::InputUpdateFromSolutionDiagnosticHO {{{*/
    10108 void  Penta::InputUpdateFromSolutionDiagnosticHO(IssmDouble* solution){
     10107/*FUNCTION Penta::InputUpdateFromSolutionStressbalanceHO {{{*/
     10108void  Penta::InputUpdateFromSolutionStressbalanceHO(IssmDouble* solution){
    1010910109
    1011010110        int         i;
    … …  
    1017810178}
    1017910179/*}}}*/
    10180 /*FUNCTION Penta::InputUpdateFromSolutionDiagnosticHOFS {{{*/
    10181 void  Penta::InputUpdateFromSolutionDiagnosticHOFS(IssmDouble* solution){
     10180/*FUNCTION Penta::InputUpdateFromSolutionStressbalanceHOFS {{{*/
     10181void  Penta::InputUpdateFromSolutionStressbalanceHOFS(IssmDouble* solution){
    1018210182
    1018310183        const int    numdofp=NDOF2*NUMVERTICES;
    … …  
    1021110211        GetDofList(&doflists,FSvelocityEnum,GsetEnum);
    1021210212        GetDofListPressure(&doflistpressure,GsetEnum);
    10213         this->parameters->FindParam(&FSreconditioning,DiagnosticFSreconditioningEnum);
     10213        this->parameters->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum);
    1021410214
    1021510215        /*Get node data: */
    … …  
    1027810278}
    1027910279/*}}}*/
    10280 /*FUNCTION Penta::InputUpdateFromSolutionDiagnosticSIA {{{*/
    10281 void  Penta::InputUpdateFromSolutionDiagnosticSIA(IssmDouble* solution){
     10280/*FUNCTION Penta::InputUpdateFromSolutionStressbalanceSIA {{{*/
     10281void  Penta::InputUpdateFromSolutionStressbalanceSIA(IssmDouble* solution){
    1028210282
    1028310283        int         numnodes = this->NumberofNodes();
    … …  
    1034210342}
    1034310343/*}}}*/
    10344 /*FUNCTION Penta::InputUpdateFromSolutionDiagnosticVert {{{*/
    10345 void  Penta::InputUpdateFromSolutionDiagnosticVert(IssmDouble* solution){
     10344/*FUNCTION Penta::InputUpdateFromSolutionStressbalanceVert {{{*/
     10345void  Penta::InputUpdateFromSolutionStressbalanceVert(IssmDouble* solution){
    1034610346
    1034710347        int          numnodes = this->NumberofNodes();
    … …  
    1044610446}
    1044710447/*}}}*/
    10448 /*FUNCTION Penta::InputUpdateFromSolutionDiagnosticFS {{{*/
    10449 void  Penta::InputUpdateFromSolutionDiagnosticFS(IssmDouble* solution){
     10448/*FUNCTION Penta::InputUpdateFromSolutionStressbalanceFS {{{*/
     10449void  Penta::InputUpdateFromSolutionStressbalanceFS(IssmDouble* solution){
    1045010450
    1045110451        int          i;
    … …  
    1049610496
    1049710497        /*Recondition pressure and compute vel: */
    10498         this->parameters->FindParam(&FSreconditioning,DiagnosticFSreconditioningEnum);
     10498        this->parameters->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum);
    1049910499        for(i=0;i<pnumnodes;i++) pressure[i]=pressure[i]*FSreconditioning;
    1050010500        for(i=0;i<vnumnodes;i++) vel[i]=pow( pow(vx[i],2.0) + pow(vy[i],2.0) + pow(vz[i],2.0) , 0.5);

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

    r15767 r15771  
    228228                void           UpdateConstraints(void);
    229229
    230                 #ifdef _HAVE_DIAGNOSTIC_
     230                #ifdef _HAVE_STRESSBALANCE_
    231231                ElementMatrix* CreateKMatrixCouplingSSAHO(void);
    232232                ElementMatrix* CreateKMatrixCouplingSSAHOViscous(void);
    … …  
    236236                ElementMatrix* CreateKMatrixCouplingSSAFSFriction(void);
    237237                ElementMatrix* CreateKMatrixCouplingHOFS(void);
    238                 ElementMatrix* CreateKMatrixDiagnosticHoriz(void);
     238                ElementMatrix* CreateKMatrixStressbalanceHoriz(void);
    239239                ElementMatrix* CreateKMatrixAdjointHoriz(void);
    240                 ElementVector* CreateDVectorDiagnosticHoriz(void);
    241                 ElementVector* CreateDVectorDiagnosticFS(void);
    242                 ElementMatrix* CreateKMatrixDiagnosticSIA(void);
    243                 ElementMatrix* CreateKMatrixDiagnosticSSA2d(void);
    244                 ElementMatrix* CreateKMatrixDiagnosticSSA3d(void);
    245                 ElementMatrix* CreateKMatrixDiagnosticSSA3dViscous(void);
    246                 ElementMatrix* CreateKMatrixDiagnosticSSA3dFriction(void);
    247                 ElementMatrix* CreateKMatrixDiagnosticSSAHO(void);
    248                 ElementMatrix* CreateKMatrixDiagnosticSSAFS(void);
    249                 ElementMatrix* CreateKMatrixDiagnosticL1L2(void);
    250                 ElementMatrix* CreateKMatrixDiagnosticL1L2Viscous(void);
    251                 ElementMatrix* CreateKMatrixDiagnosticL1L2Friction(void);
    252                 ElementMatrix* CreateKMatrixDiagnosticHO(void);
    253                 ElementMatrix* CreateKMatrixDiagnosticHOViscous(void);
    254                 ElementMatrix* CreateKMatrixDiagnosticHOFriction(void);
    255                 ElementMatrix* CreateKMatrixDiagnosticHOFS(void);
    256                 ElementMatrix* CreateKMatrixDiagnosticFS(void);
    257                 ElementMatrix* CreateKMatrixDiagnosticFSViscous(void);
     240                ElementVector* CreateDVectorStressbalanceHoriz(void);
     241                ElementVector* CreateDVectorStressbalanceFS(void);
     242                ElementMatrix* CreateKMatrixStressbalanceSIA(void);
     243                ElementMatrix* CreateKMatrixStressbalanceSSA2d(void);
     244                ElementMatrix* CreateKMatrixStressbalanceSSA3d(void);
     245                ElementMatrix* CreateKMatrixStressbalanceSSA3dViscous(void);
     246                ElementMatrix* CreateKMatrixStressbalanceSSA3dFriction(void);
     247                ElementMatrix* CreateKMatrixStressbalanceSSAHO(void);
     248                ElementMatrix* CreateKMatrixStressbalanceSSAFS(void);
     249                ElementMatrix* CreateKMatrixStressbalanceL1L2(void);
     250                ElementMatrix* CreateKMatrixStressbalanceL1L2Viscous(void);
     251                ElementMatrix* CreateKMatrixStressbalanceL1L2Friction(void);
     252                ElementMatrix* CreateKMatrixStressbalanceHO(void);
     253                ElementMatrix* CreateKMatrixStressbalanceHOViscous(void);
     254                ElementMatrix* CreateKMatrixStressbalanceHOFriction(void);
     255                ElementMatrix* CreateKMatrixStressbalanceHOFS(void);
     256                ElementMatrix* CreateKMatrixStressbalanceFS(void);
     257                ElementMatrix* CreateKMatrixStressbalanceFSViscous(void);
    258258                void           KMatrixGLSstabilization(ElementMatrix* Ke);
    259                 ElementMatrix* CreateKMatrixDiagnosticFSFriction(void);
    260                 ElementMatrix* CreateKMatrixDiagnosticVert(void);
    261                 ElementMatrix* CreateKMatrixDiagnosticVertVolume(void);
    262                 ElementMatrix* CreateKMatrixDiagnosticVertSurface(void);
    263                 ElementMatrix* CreateJacobianDiagnosticHoriz(void);
    264                 ElementMatrix* CreateJacobianDiagnosticSSA2d(void);
    265                 ElementMatrix* CreateJacobianDiagnosticHO(void);
    266                 ElementMatrix* CreateJacobianDiagnosticFS(void);
    267                 void           InputUpdateFromSolutionDiagnosticHoriz( IssmDouble* solutiong);
    268                 void           InputUpdateFromSolutionDiagnosticSSA( IssmDouble* solutiong);
    269                 void           InputUpdateFromSolutionDiagnosticSSAHO( IssmDouble* solutiong);
    270                 void           InputUpdateFromSolutionDiagnosticSSAFS( IssmDouble* solutiong);
    271                 void           InputUpdateFromSolutionDiagnosticL1L2( IssmDouble* solutiong);
    272                 void           InputUpdateFromSolutionDiagnosticHO( IssmDouble* solutiong);
    273                 void           InputUpdateFromSolutionDiagnosticHOFS( IssmDouble* solutiong);
    274                 void           InputUpdateFromSolutionDiagnosticSIA( IssmDouble* solutiong);
    275                 void           InputUpdateFromSolutionDiagnosticVert( IssmDouble* solutiong);
    276                 void           InputUpdateFromSolutionDiagnosticFS( IssmDouble* solutiong);
    277                 void             GetSolutionFromInputsDiagnosticHoriz(Vector<IssmDouble>* solutiong);
    278                 void             GetSolutionFromInputsDiagnosticSIA(Vector<IssmDouble>* solutiong);
    279                 void             GetSolutionFromInputsDiagnosticFS(Vector<IssmDouble>* solutiong);
    280                 void             GetSolutionFromInputsDiagnosticVert(Vector<IssmDouble>* solutiong);
     259                ElementMatrix* CreateKMatrixStressbalanceFSFriction(void);
     260                ElementMatrix* CreateKMatrixStressbalanceVert(void);
     261                ElementMatrix* CreateKMatrixStressbalanceVertVolume(void);
     262                ElementMatrix* CreateKMatrixStressbalanceVertSurface(void);
     263                ElementMatrix* CreateJacobianStressbalanceHoriz(void);
     264                ElementMatrix* CreateJacobianStressbalanceSSA2d(void);
     265                ElementMatrix* CreateJacobianStressbalanceHO(void);
     266                ElementMatrix* CreateJacobianStressbalanceFS(void);
     267                void           InputUpdateFromSolutionStressbalanceHoriz( IssmDouble* solutiong);
     268                void           InputUpdateFromSolutionStressbalanceSSA( IssmDouble* solutiong);
     269                void           InputUpdateFromSolutionStressbalanceSSAHO( IssmDouble* solutiong);
     270                void           InputUpdateFromSolutionStressbalanceSSAFS( IssmDouble* solutiong);
     271                void           InputUpdateFromSolutionStressbalanceL1L2( IssmDouble* solutiong);
     272                void           InputUpdateFromSolutionStressbalanceHO( IssmDouble* solutiong);
     273                void           InputUpdateFromSolutionStressbalanceHOFS( IssmDouble* solutiong);
     274                void           InputUpdateFromSolutionStressbalanceSIA( IssmDouble* solutiong);
     275                void           InputUpdateFromSolutionStressbalanceVert( IssmDouble* solutiong);
     276                void           InputUpdateFromSolutionStressbalanceFS( IssmDouble* solutiong);
     277                void             GetSolutionFromInputsStressbalanceHoriz(Vector<IssmDouble>* solutiong);
     278                void             GetSolutionFromInputsStressbalanceSIA(Vector<IssmDouble>* solutiong);
     279                void             GetSolutionFromInputsStressbalanceFS(Vector<IssmDouble>* solutiong);
     280                void             GetSolutionFromInputsStressbalanceVert(Vector<IssmDouble>* solutiong);
    281281                ElementVector* CreatePVectorCouplingSSAFS(void);
    282282                ElementVector* CreatePVectorCouplingSSAFSViscous(void);
    … …  
    285285                ElementVector* CreatePVectorCouplingHOFSViscous(void);
    286286                ElementVector* CreatePVectorCouplingHOFSFriction(void);
    287                 ElementVector* CreatePVectorDiagnosticHoriz(void);
    288                 ElementVector* CreatePVectorDiagnosticSIA(void);
    289                 ElementVector* CreatePVectorDiagnosticSSA(void);
    290                 ElementVector* CreatePVectorDiagnosticSSAHO(void);
    291                 ElementVector* CreatePVectorDiagnosticSSAFS(void);
    292                 ElementVector* CreatePVectorDiagnosticL1L2(void);
    293                 ElementVector* CreatePVectorDiagnosticHO(void);
    294                 ElementVector* CreatePVectorDiagnosticHODrivingStress(void);
    295                 ElementVector* CreatePVectorDiagnosticHOFront(void);
    296                 ElementVector* CreatePVectorDiagnosticHOFS(void);
    297                 ElementVector* CreatePVectorDiagnosticFS(void);
    298                 ElementVector* CreatePVectorDiagnosticFSFront(void);
    299                 ElementVector* CreatePVectorDiagnosticFSViscous(void);
     287                ElementVector* CreatePVectorStressbalanceHoriz(void);
     288                ElementVector* CreatePVectorStressbalanceSIA(void);
     289                ElementVector* CreatePVectorStressbalanceSSA(void);
     290                ElementVector* CreatePVectorStressbalanceSSAHO(void);
     291                ElementVector* CreatePVectorStressbalanceSSAFS(void);
     292                ElementVector* CreatePVectorStressbalanceL1L2(void);
     293                ElementVector* CreatePVectorStressbalanceHO(void);
     294                ElementVector* CreatePVectorStressbalanceHODrivingStress(void);
     295                ElementVector* CreatePVectorStressbalanceHOFront(void);
     296                ElementVector* CreatePVectorStressbalanceHOFS(void);
     297                ElementVector* CreatePVectorStressbalanceFS(void);
     298                ElementVector* CreatePVectorStressbalanceFSFront(void);
     299                ElementVector* CreatePVectorStressbalanceFSViscous(void);
    300300                void           PVectorGLSstabilization(ElementVector* pe);
    301                 ElementVector* CreatePVectorDiagnosticFSShelf(void);
    302                 ElementVector* CreatePVectorDiagnosticVert(void);
    303                 ElementVector* CreatePVectorDiagnosticVertVolume(void);
    304                 ElementVector* CreatePVectorDiagnosticVertBase(void);
     301                ElementVector* CreatePVectorStressbalanceFSShelf(void);
     302                ElementVector* CreatePVectorStressbalanceVert(void);
     303                ElementVector* CreatePVectorStressbalanceVertVolume(void);
     304                ElementVector* CreatePVectorStressbalanceVertBase(void);
    305305                void           GetL1L2Viscosity(IssmDouble*, IssmDouble*, GaussPenta*, Input*, Input*, Input*);
    306306                #endif

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

    r15767 r15771  
    215215        /*Just branch to the correct element stiffness matrix generator, according to the type of analysis we are carrying out: */
    216216        switch(analysis_type){
    217                 #ifdef _HAVE_DIAGNOSTIC_
    218                 case DiagnosticHorizAnalysisEnum:
    219                         return CreateKMatrixDiagnosticSSA();
     217                #ifdef _HAVE_STRESSBALANCE_
     218                case StressbalanceAnalysisEnum:
     219                        return CreateKMatrixStressbalanceSSA();
    220220                        break;
    221                 case DiagnosticSIAAnalysisEnum:
    222                         return CreateKMatrixDiagnosticSIA();
     221                case StressbalanceSIAAnalysisEnum:
     222                        return CreateKMatrixStressbalanceSIA();
    223223                        break;
    224224                 #endif
    … …  
    357357        /*Just branch to the correct load generator, according to the type of analysis we are carrying out: */
    358358        switch(analysis_type){
    359 #ifdef _HAVE_DIAGNOSTIC_
    360                 case DiagnosticHorizAnalysisEnum:
    361                         return CreatePVectorDiagnosticSSA();
     359#ifdef _HAVE_STRESSBALANCE_
     360                case StressbalanceAnalysisEnum:
     361                        return CreatePVectorStressbalanceSSA();
    362362                        break;
    363                 case DiagnosticSIAAnalysisEnum:
    364                         return CreatePVectorDiagnosticSIA();
     363                case StressbalanceSIAAnalysisEnum:
     364                        return CreatePVectorStressbalanceSIA();
    365365                        break;
    366366#endif
    … …  
    472472        /*Just branch to the correct element stiffness matrix generator, according to the type of analysis we are carrying out: */
    473473        switch(analysis_type){
    474 #ifdef _HAVE_DIAGNOSTIC_
    475                 case DiagnosticHorizAnalysisEnum:
    476                         Ke=CreateJacobianDiagnosticSSA();
     474#ifdef _HAVE_STRESSBALANCE_
     475                case StressbalanceAnalysisEnum:
     476                        Ke=CreateJacobianStressbalanceSSA();
    477477                        break;
    478478#endif
    … …  
    12481248        /*Just branch to the correct InputUpdateFromSolution generator, according to the type of analysis we are carrying out: */
    12491249        switch(analysis_type){
    1250         #ifdef _HAVE_DIAGNOSTIC_
    1251         case DiagnosticHorizAnalysisEnum:
    1252                 GetSolutionFromInputsDiagnosticHoriz(solution);
     1250        #ifdef _HAVE_STRESSBALANCE_
     1251        case StressbalanceAnalysisEnum:
     1252                GetSolutionFromInputsStressbalanceHoriz(solution);
    12531253                break;
    1254         case DiagnosticSIAAnalysisEnum:
    1255                 GetSolutionFromInputsDiagnosticSIA(solution);
     1254        case StressbalanceSIAAnalysisEnum:
     1255                GetSolutionFromInputsStressbalanceSIA(solution);
    12561256                break;
    12571257        #endif
    … …  
    15691569        /*Just branch to the correct InputUpdateFromSolution generator, according to the type of analysis we are carrying out: */
    15701570        switch(analysis_type){
    1571                 #ifdef _HAVE_DIAGNOSTIC_
    1572                 case DiagnosticHorizAnalysisEnum:
    1573                         InputUpdateFromSolutionDiagnosticHoriz(solution);
     1571                #ifdef _HAVE_STRESSBALANCE_
     1572                case StressbalanceAnalysisEnum:
     1573                        InputUpdateFromSolutionStressbalanceHoriz(solution);
    15741574                        break;
    1575                 case DiagnosticSIAAnalysisEnum:
    1576                         InputUpdateFromSolutionDiagnosticHoriz(solution);
     1575                case StressbalanceSIAAnalysisEnum:
     1576                        InputUpdateFromSolutionStressbalanceHoriz(solution);
    15771577                        break;
    15781578                #endif
    … …  
    24632463        switch(analysis_type){
    24642464
    2465                 case DiagnosticHorizAnalysisEnum:
     2465                case StressbalanceAnalysisEnum:
    24662466
    24672467                        /*default vx,vy and vz: either observation or 0 */
    … …  
    29442944#endif
    29452945
    2946 #ifdef _HAVE_DIAGNOSTIC_
    2947 /*FUNCTION Tria::CreateKMatrixDiagnosticSSA {{{*/
    2948 ElementMatrix* Tria::CreateKMatrixDiagnosticSSA(void){
     2946#ifdef _HAVE_STRESSBALANCE_
     2947/*FUNCTION Tria::CreateKMatrixStressbalanceSSA {{{*/
     2948ElementMatrix* Tria::CreateKMatrixStressbalanceSSA(void){
    29492949
    29502950        /*compute all stiffness matrices for this element*/
    2951         ElementMatrix* Ke1=CreateKMatrixDiagnosticSSAViscous();
    2952         ElementMatrix* Ke2=CreateKMatrixDiagnosticSSAFriction();
     2951        ElementMatrix* Ke1=CreateKMatrixStressbalanceSSAViscous();
     2952        ElementMatrix* Ke2=CreateKMatrixStressbalanceSSAFriction();
    29532953        ElementMatrix* Ke =new ElementMatrix(Ke1,Ke2);
    29542954
    … …  
    29592959}
    29602960/*}}}*/
    2961 /*FUNCTION Tria::CreateKMatrixDiagnosticSSAViscous{{{*/
    2962 ElementMatrix* Tria::CreateKMatrixDiagnosticSSAViscous(void){
     2961/*FUNCTION Tria::CreateKMatrixStressbalanceSSAViscous{{{*/
     2962ElementMatrix* Tria::CreateKMatrixStressbalanceSSAViscous(void){
    29632963
    29642964        /*Intermediaries*/
    … …  
    29872987        Input* vxold_input=inputs->GetInput(VxPicardEnum);      _assert_(vxold_input);
    29882988        Input* vyold_input=inputs->GetInput(VyPicardEnum);      _assert_(vyold_input);
    2989         this->parameters->FindParam(&viscosity_overshoot,DiagnosticViscosityOvershootEnum);
     2989        this->parameters->FindParam(&viscosity_overshoot,StressbalanceViscosityOvershootEnum);
    29902990
    29912991        /* Start  looping on the number of gaussian points: */
    … …  
    30263026}
    30273027/*}}}*/
    3028 /*FUNCTION Tria::CreateKMatrixDiagnosticSSAFriction {{{*/
    3029 ElementMatrix* Tria::CreateKMatrixDiagnosticSSAFriction(void){
     3028/*FUNCTION Tria::CreateKMatrixStressbalanceSSAFriction {{{*/
     3029ElementMatrix* Tria::CreateKMatrixStressbalanceSSAFriction(void){
    30303030
    30313031        /*Intermediaries*/
    … …  
    31143114}
    31153115/*}}}*/
    3116 /*FUNCTION Tria::CreateKMatrixDiagnosticSIA{{{*/
    3117 ElementMatrix* Tria::CreateKMatrixDiagnosticSIA(void){
     3116/*FUNCTION Tria::CreateKMatrixStressbalanceSIA{{{*/
     3117ElementMatrix* Tria::CreateKMatrixStressbalanceSIA(void){
    31183118
    31193119        /*Intermediaries*/
    … …  
    31383138}
    31393139/*}}}*/
    3140 /*FUNCTION Tria::CreatePVectorDiagnosticSSA {{{*/
    3141 ElementVector* Tria::CreatePVectorDiagnosticSSA(){
     3140/*FUNCTION Tria::CreatePVectorStressbalanceSSA {{{*/
     3141ElementVector* Tria::CreatePVectorStressbalanceSSA(){
    31423142
    31433143        /*compute all load vectors for this element*/
    3144         ElementVector* pe1=CreatePVectorDiagnosticSSADrivingStress();
    3145         ElementVector* pe2=CreatePVectorDiagnosticSSAFront();
     3144        ElementVector* pe1=CreatePVectorStressbalanceSSADrivingStress();
     3145        ElementVector* pe2=CreatePVectorStressbalanceSSAFront();
    31463146        ElementVector* pe =new ElementVector(pe1,pe2);
    31473147
    … …  
    31523152}
    31533153/*}}}*/
    3154 /*FUNCTION Tria::CreatePVectorDiagnosticSSADrivingStress {{{*/
    3155 ElementVector* Tria::CreatePVectorDiagnosticSSADrivingStress(){
     3154/*FUNCTION Tria::CreatePVectorStressbalanceSSADrivingStress {{{*/
     3155ElementVector* Tria::CreatePVectorStressbalanceSSADrivingStress(){
    31563156
    31573157        /*Intermediaries */
    … …  
    32073207}
    32083208/*}}}*/
    3209 /*FUNCTION Tria::CreatePVectorDiagnosticSSAFront {{{*/
    3210 ElementVector* Tria::CreatePVectorDiagnosticSSAFront(){
     3209/*FUNCTION Tria::CreatePVectorStressbalanceSSAFront {{{*/
     3210ElementVector* Tria::CreatePVectorStressbalanceSSAFront(){
    32113211
    32123212        /*Intermediaries */
    … …  
    32873287}
    32883288/*}}}*/
    3289 /*FUNCTION Tria::CreatePVectorDiagnosticSIA{{{*/
    3290 ElementVector* Tria::CreatePVectorDiagnosticSIA(void){
     3289/*FUNCTION Tria::CreatePVectorStressbalanceSIA{{{*/
     3290ElementVector* Tria::CreatePVectorStressbalanceSIA(void){
    32913291
    32923292        /*Intermediaries */
    … …  
    33393339}
    33403340/*}}}*/
    3341 /*FUNCTION Tria::CreateJacobianDiagnosticSSA{{{*/
    3342 ElementMatrix* Tria::CreateJacobianDiagnosticSSA(void){
     3341/*FUNCTION Tria::CreateJacobianStressbalanceSSA{{{*/
     3342ElementMatrix* Tria::CreateJacobianStressbalanceSSA(void){
    33433343
    33443344        /*Intermediaries */
    … …  
    33583358
    33593359        /*Initialize Element matrix, vectors and Gaussian points*/
    3360         ElementMatrix* Ke=CreateKMatrixDiagnosticSSA(); //Initialize Jacobian with regular SSA (first part of the Gateau derivative)
     3360        ElementMatrix* Ke=CreateKMatrixStressbalanceSSA(); //Initialize Jacobian with regular SSA (first part of the Gateau derivative)
    33613361        IssmDouble*    dbasis = xNew<IssmDouble>(2*numnodes);
    33623362
    … …  
    34063406}
    34073407/*}}}*/
    3408 /*FUNCTION Tria::GetSolutionFromInputsDiagnosticHoriz{{{*/
    3409 void  Tria::GetSolutionFromInputsDiagnosticHoriz(Vector<IssmDouble>* solution){
     3408/*FUNCTION Tria::GetSolutionFromInputsStressbalanceHoriz{{{*/
     3409void  Tria::GetSolutionFromInputsStressbalanceHoriz(Vector<IssmDouble>* solution){
    34103410
    34113411        IssmDouble   vx,vy;
    … …  
    34453445}
    34463446/*}}}*/
    3447 /*FUNCTION Tria::GetSolutionFromInputsDiagnosticSIA{{{*/
    3448 void  Tria::GetSolutionFromInputsDiagnosticSIA(Vector<IssmDouble>* solution){
     3447/*FUNCTION Tria::GetSolutionFromInputsStressbalanceSIA{{{*/
     3448void  Tria::GetSolutionFromInputsStressbalanceSIA(Vector<IssmDouble>* solution){
    34493449
    34503450        const int    numdof=NDOF2*NUMVERTICES;
    … …  
    34843484}
    34853485/*}}}*/
    3486 /*FUNCTION Tria::InputUpdateFromSolutionDiagnosticHoriz {{{*/
    3487 void  Tria::InputUpdateFromSolutionDiagnosticHoriz(IssmDouble* solution){
     3486/*FUNCTION Tria::InputUpdateFromSolutionStressbalanceHoriz {{{*/
     3487void  Tria::InputUpdateFromSolutionStressbalanceHoriz(IssmDouble* solution){
    34883488
    34893489        int        i;
    … …  
    35563556}
    35573557/*}}}*/
    3558 /*FUNCTION Tria::InputUpdateFromSolutionDiagnosticSIA {{{*/
    3559 void  Tria::InputUpdateFromSolutionDiagnosticSIA(IssmDouble* solution){
     3558/*FUNCTION Tria::InputUpdateFromSolutionStressbalanceSIA {{{*/
     3559void  Tria::InputUpdateFromSolutionStressbalanceSIA(IssmDouble* solution){
    35603560
    35613561        int        i;
    … …  
    52845284        /*Initialize Jacobian with regular SSA (first part of the Gateau derivative)*/
    52855285        parameters->FindParam(&incomplete_adjoint,InversionIncompleteAdjointEnum);
    5286         ElementMatrix* Ke=CreateKMatrixDiagnosticSSA();
     5286        ElementMatrix* Ke=CreateKMatrixStressbalanceSSA();
    52875287        if(incomplete_adjoint) return Ke;
    52885288

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

    r15767 r15771  
    222222                void             UpdateConstraints(void);
    223223
    224                 #ifdef _HAVE_DIAGNOSTIC_
    225                 ElementMatrix* CreateKMatrixDiagnosticSSA(void);
    226                 ElementMatrix* CreateKMatrixDiagnosticSSAViscous(void);
    227                 ElementMatrix* CreateKMatrixDiagnosticSSAFriction(void);
    228                 ElementMatrix* CreateKMatrixDiagnosticSIA(void);
    229                 ElementVector* CreatePVectorDiagnosticSSA(void);
    230                 ElementVector* CreatePVectorDiagnosticSSADrivingStress(void);
    231                 ElementVector* CreatePVectorDiagnosticSSAFront(void);
    232                 ElementVector* CreatePVectorDiagnosticSIA(void);
    233                 ElementMatrix* CreateJacobianDiagnosticSSA(void);
    234                 void      GetSolutionFromInputsDiagnosticHoriz(Vector<IssmDouble>* solution);
    235                 void      GetSolutionFromInputsDiagnosticSIA(Vector<IssmDouble>* solution);
    236                 void      InputUpdateFromSolutionDiagnosticHoriz( IssmDouble* solution);
    237                 void      InputUpdateFromSolutionDiagnosticSIA( IssmDouble* solution);
     224                #ifdef _HAVE_STRESSBALANCE_
     225                ElementMatrix* CreateKMatrixStressbalanceSSA(void);
     226                ElementMatrix* CreateKMatrixStressbalanceSSAViscous(void);
     227                ElementMatrix* CreateKMatrixStressbalanceSSAFriction(void);
     228                ElementMatrix* CreateKMatrixStressbalanceSIA(void);
     229                ElementVector* CreatePVectorStressbalanceSSA(void);
     230                ElementVector* CreatePVectorStressbalanceSSADrivingStress(void);
     231                ElementVector* CreatePVectorStressbalanceSSAFront(void);
     232                ElementVector* CreatePVectorStressbalanceSIA(void);
     233                ElementMatrix* CreateJacobianStressbalanceSSA(void);
     234                void      GetSolutionFromInputsStressbalanceHoriz(Vector<IssmDouble>* solution);
     235                void      GetSolutionFromInputsStressbalanceSIA(Vector<IssmDouble>* solution);
     236                void      InputUpdateFromSolutionStressbalanceHoriz( IssmDouble* solution);
     237                void      InputUpdateFromSolutionStressbalanceSIA( IssmDouble* solution);
    238238                #endif
    239239

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

    r15740 r15771  
    261261                        pe=PenaltyCreatePVectorMelting(kmax);
    262262                        break;
    263                 case DiagnosticHorizAnalysisEnum: case AdjointHorizAnalysisEnum:
     263                case StressbalanceAnalysisEnum: case AdjointHorizAnalysisEnum:
    264264                        break;
    265265                #endif
    … …  
    418418        this->parameters->FindParam(&analysis_type,AnalysisTypeEnum);
    419419
    420         if (analysis_type==DiagnosticHorizAnalysisEnum){
     420        if (analysis_type==StressbalanceAnalysisEnum){
    421421                /*No penalty to check*/
    422422                return;

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

    r15767 r15771  
    173173
    174174        switch(analysis_type){
    175                 case DiagnosticHorizAnalysisEnum:
    176                         Ke=PenaltyCreateKMatrixDiagnosticHoriz(kmax);
     175                case StressbalanceAnalysisEnum:
     176                        Ke=PenaltyCreateKMatrixStressbalanceHoriz(kmax);
    177177                        break;
    178178                case MasstransportAnalysisEnum:
    … …  
    292292
    293293/*Penpair management:*/
    294 /*FUNCTION Penpair::PenaltyCreateKMatrixDiagnosticHoriz{{{*/
    295 ElementMatrix* Penpair::PenaltyCreateKMatrixDiagnosticHoriz(IssmDouble kmax){
     294/*FUNCTION Penpair::PenaltyCreateKMatrixStressbalanceHoriz{{{*/
     295ElementMatrix* Penpair::PenaltyCreateKMatrixStressbalanceHoriz(IssmDouble kmax){
    296296
    297297        int    approximation0=nodes[0]->GetApproximation();
    … …  
    301301                case SSAApproximationEnum:
    302302                        switch(approximation1){
    303                                 case SSAApproximationEnum: return PenaltyCreateKMatrixDiagnosticSSAHO(kmax);
    304                                 case HOApproximationEnum:   return PenaltyCreateKMatrixDiagnosticSSAHO(kmax);
     303                                case SSAApproximationEnum: return PenaltyCreateKMatrixStressbalanceSSAHO(kmax);
     304                                case HOApproximationEnum:   return PenaltyCreateKMatrixStressbalanceSSAHO(kmax);
    305305                                default: _error_("not supported yet");
    306306                        }
    307307                case HOApproximationEnum:
    308308                        switch(approximation1){
    309                                 case SSAApproximationEnum: return PenaltyCreateKMatrixDiagnosticSSAHO(kmax);
    310                                 case HOApproximationEnum:   return PenaltyCreateKMatrixDiagnosticSSAHO(kmax);
     309                                case SSAApproximationEnum: return PenaltyCreateKMatrixStressbalanceSSAHO(kmax);
     310                                case HOApproximationEnum:   return PenaltyCreateKMatrixStressbalanceSSAHO(kmax);
    311311                                default: _error_("not supported yet");
    312312                        }
    313313                case FSApproximationEnum:
    314314                        switch(approximation1){
    315                                 case FSApproximationEnum: return PenaltyCreateKMatrixDiagnosticFS(kmax);
    316                                 case NoneApproximationEnum: return   PenaltyCreateKMatrixDiagnosticFS(kmax);
     315                                case FSApproximationEnum: return PenaltyCreateKMatrixStressbalanceFS(kmax);
     316                                case NoneApproximationEnum: return   PenaltyCreateKMatrixStressbalanceFS(kmax);
    317317                                default: _error_("not supported yet");
    318318                        }
    319319                case NoneApproximationEnum:
    320320                        switch(approximation1){
    321                                 case FSApproximationEnum: return PenaltyCreateKMatrixDiagnosticFS(kmax);
    322                                 case NoneApproximationEnum: return   PenaltyCreateKMatrixDiagnosticFS(kmax);
     321                                case FSApproximationEnum: return PenaltyCreateKMatrixStressbalanceFS(kmax);
     322                                case NoneApproximationEnum: return   PenaltyCreateKMatrixStressbalanceFS(kmax);
    323323                                default: _error_("not supported yet");
    324324                        }
    … …  
    327327}
    328328/*}}}*/
    329 /*FUNCTION Penpair::PenaltyCreateKMatrixDiagnosticSSAHO {{{*/
    330 ElementMatrix* Penpair::PenaltyCreateKMatrixDiagnosticSSAHO(IssmDouble kmax){
     329/*FUNCTION Penpair::PenaltyCreateKMatrixStressbalanceSSAHO {{{*/
     330ElementMatrix* Penpair::PenaltyCreateKMatrixStressbalanceSSAHO(IssmDouble kmax){
    331331
    332332        const int numdof=NUMVERTICES*NDOF2;
    … …  
    337337
    338338        /*recover parameters: */
    339         parameters->FindParam(&penalty_offset,DiagnosticPenaltyFactorEnum);
     339        parameters->FindParam(&penalty_offset,StressbalancePenaltyFactorEnum);
    340340
    341341        //Create elementary matrix: add penalty to
    … …  
    354354}
    355355/*}}}*/
    356 /*FUNCTION Penpair::PenaltyCreateKMatrixDiagnosticFS {{{*/
    357 ElementMatrix* Penpair::PenaltyCreateKMatrixDiagnosticFS(IssmDouble kmax){
     356/*FUNCTION Penpair::PenaltyCreateKMatrixStressbalanceFS {{{*/
     357ElementMatrix* Penpair::PenaltyCreateKMatrixStressbalanceFS(IssmDouble kmax){
    358358
    359359        const int numdof=NUMVERTICES*NDOF4;
    … …  
    364364
    365365        /*recover parameters: */
    366         parameters->FindParam(&penalty_offset,DiagnosticPenaltyFactorEnum);
     366        parameters->FindParam(&penalty_offset,StressbalancePenaltyFactorEnum);
    367367
    368368        //Create elementary matrix: add penalty to

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

    r15767 r15771  
    6767                /*}}}*/
    6868                        /*Penpair management: {{{*/
    69                 ElementMatrix* PenaltyCreateKMatrixDiagnosticHoriz(IssmDouble kmax);
    70                 ElementMatrix* PenaltyCreateKMatrixDiagnosticSSAHO(IssmDouble kmax);
    71                 ElementMatrix* PenaltyCreateKMatrixDiagnosticFS(IssmDouble kmax);
     69                ElementMatrix* PenaltyCreateKMatrixStressbalanceHoriz(IssmDouble kmax);
     70                ElementMatrix* PenaltyCreateKMatrixStressbalanceSSAHO(IssmDouble kmax);
     71                ElementMatrix* PenaltyCreateKMatrixStressbalanceFS(IssmDouble kmax);
    7272                ElementMatrix* PenaltyCreateKMatrixMasstransport(IssmDouble kmax);
    7373                /*}}}*/

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

    r15740 r15771  
    5151
    5252        /*Fetch parameters: */
    53         iomodel->Constant(&penalty_lock,DiagnosticRiftPenaltyLockEnum);
     53        iomodel->Constant(&penalty_lock,StressbalanceRiftPenaltyLockEnum);
    5454
    5555        /*Ok, retrieve all the data needed to add a penalty between the two nodes: */
    … …  
    308308
    309309        switch(analysis_type){
    310                 case DiagnosticHorizAnalysisEnum:
    311                         Ke=PenaltyCreateKMatrixDiagnosticHoriz(kmax);
     310                case StressbalanceAnalysisEnum:
     311                        Ke=PenaltyCreateKMatrixStressbalanceHoriz(kmax);
    312312                        break;
    313313                case AdjointHorizAnalysisEnum:
    314                         Ke=PenaltyCreateKMatrixDiagnosticHoriz(kmax);
     314                        Ke=PenaltyCreateKMatrixStressbalanceHoriz(kmax);
    315315                        break;
    316316                default:
    … …  
    334334
    335335        switch(analysis_type){
    336                 case DiagnosticHorizAnalysisEnum:
    337                         pe=PenaltyCreatePVectorDiagnosticHoriz(kmax);
     336                case StressbalanceAnalysisEnum:
     337                        pe=PenaltyCreatePVectorStressbalanceHoriz(kmax);
    338338                        break;
    339339                case AdjointHorizAnalysisEnum:
    … …  
    437437
    438438/*Riftfront numerics*/
    439 /*FUNCTION Riftfront::PenaltyCreateKMatrixDiagnosticHoriz {{{*/
    440 ElementMatrix* Riftfront::PenaltyCreateKMatrixDiagnosticHoriz(IssmDouble kmax){
     439/*FUNCTION Riftfront::PenaltyCreateKMatrixStressbalanceHoriz {{{*/
     440ElementMatrix* Riftfront::PenaltyCreateKMatrixStressbalanceHoriz(IssmDouble kmax){
    441441
    442442        const int   numdof = NDOF2*NUMVERTICES;
    … …  
    461461
    462462        /*Get some parameters: */
    463         this->parameters->FindParam(&penalty_offset,DiagnosticPenaltyFactorEnum);
     463        this->parameters->FindParam(&penalty_offset,StressbalancePenaltyFactorEnum);
    464464        this->inputs->GetInputValue(&friction,FrictionEnum);
    465465        tria1->GetInputValue(&h[0],nodes[0],ThicknessEnum);
    … …  
    518518}
    519519/*}}}*/
    520 /*FUNCTION Riftfront::PenaltyCreatePVectorDiagnosticHoriz {{{*/
    521 ElementVector* Riftfront::PenaltyCreatePVectorDiagnosticHoriz(IssmDouble kmax){
     520/*FUNCTION Riftfront::PenaltyCreatePVectorStressbalanceHoriz {{{*/
     521ElementVector* Riftfront::PenaltyCreatePVectorStressbalanceHoriz(IssmDouble kmax){
    522522
    523523        const int  numdof = NDOF2*NUMVERTICES;

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

    r13925 r15771  
    8989                /*Riftfront specific routines: {{{*/
    9090                bool  PreStable();
    91                 ElementMatrix* PenaltyCreateKMatrixDiagnosticHoriz(IssmDouble kmax);
    92                 ElementVector* PenaltyCreatePVectorDiagnosticHoriz(IssmDouble kmax);
     91                ElementMatrix* PenaltyCreateKMatrixStressbalanceHoriz(IssmDouble kmax);
     92                ElementVector* PenaltyCreatePVectorStressbalanceHoriz(IssmDouble kmax);
    9393                void  SetPreStable();
    9494                int   PreConstrain(int* punstable);

  • issm/trunk-jpl/src/c/classes/Node.cpp

    r15767 r15771  
    4242        gsize=this->indexing.gsize;
    4343
    44         if(analysis_type==DiagnosticHorizAnalysisEnum)
     44        if(analysis_type==StressbalanceAnalysisEnum)
    4545         this->approximation=in_approximation;
    4646        else
    … …  
    5454          this->inputs->AddInput(new BoolInput(MaskVertexongroundediceEnum,reCast<bool>(iomodel->Data(MaskVertexongroundediceEnum)[io_index])));
    5555
    56         /*Diagnostic Horiz*/
    57         #ifdef _HAVE_DIAGNOSTIC_
    58         if(analysis_type==DiagnosticHorizAnalysisEnum){
     56        /*Stressbalance Horiz*/
     57        #ifdef _HAVE_STRESSBALANCE_
     58        if(analysis_type==StressbalanceAnalysisEnum){
    5959
    6060                /*Coordinate system provided, convert to coord_system matrix*/
    61                 _assert_(iomodel->Data(DiagnosticReferentialEnum));
    62                 XZvectorsToCoordinateSystem(&this->coord_system[0][0],&iomodel->Data(DiagnosticReferentialEnum)[io_index*6]);
     61                _assert_(iomodel->Data(StressbalanceReferentialEnum));
     62                XZvectorsToCoordinateSystem(&this->coord_system[0][0],&iomodel->Data(StressbalanceReferentialEnum)[io_index*6]);
    6363
    6464                if(iomodel->dim==3){
    … …  
    338338int    Node::Sid(void){ return sid; }
    339339/*}}}*/
    340 #ifdef _HAVE_DIAGNOSTIC_
     340#ifdef _HAVE_STRESSBALANCE_
    341341/*FUNCTION Node::GetCoordinateSystem{{{*/
    342342void Node::GetCoordinateSystem(IssmDouble* coord_system_out){
    … …  
    972972}
    973973/*}}}*/
    974 #ifdef _HAVE_DIAGNOSTIC_
     974#ifdef _HAVE_STRESSBALANCE_
    975975void TransformInvStiffnessMatrixCoord(ElementMatrix* Ke,Node** nodes,int numnodes,int cs_enum){/*{{{*/
    976976

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

    r15583 r15771  
    6868                void  SetCurrentConfiguration(DataSet* nodes,Vertices* vertices);
    6969                int   Sid(void);
    70 #ifdef _HAVE_DIAGNOSTIC_
     70#ifdef _HAVE_STRESSBALANCE_
    7171                void  GetCoordinateSystem(IssmDouble* coord_system_out);
    7272#endif
    … …  
    103103int* GetGlobalDofList(Node** nodes,int numnodes,int setenum,int approximation);
    104104int  GetNumberOfDofs(Node** nodes,int numnodes,int setenum,int approximation);
    105 #ifdef _HAVE_DIAGNOSTIC_
     105#ifdef _HAVE_STRESSBALANCE_
    106106void TransformInvStiffnessMatrixCoord(ElementMatrix* Ke,Node** nodes,int numnodes,int cs_enum);
    107107void TransformInvStiffnessMatrixCoord(ElementMatrix* Ke,Node** nodes,int numnodes,int* cs_array);

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

    r15104 r15771  
    2020
    2121        /*recover parameters: */
    22         parameters->FindParam(&min_mechanical_constraints,DiagnosticRiftPenaltyThresholdEnum);
     22        parameters->FindParam(&min_mechanical_constraints,StressbalanceRiftPenaltyThresholdEnum);
    2323        parameters->FindParam(&analysis_type,AnalysisTypeEnum);
    2424

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

    r15767 r15771  
    4040        switch(analysis_type){
    4141
    42                 #ifdef _HAVE_DIAGNOSTIC_
    43                 case DiagnosticHorizAnalysisEnum:
    44                         CreateNodesDiagnosticHoriz(pnodes, iomodel);
    45                         CreateConstraintsDiagnosticHoriz(pconstraints,iomodel);
    46                         CreateLoadsDiagnosticHoriz(ploads,iomodel);
    47                         UpdateElementsDiagnosticHoriz(elements,iomodel,analysis_counter,analysis_type);
     42                #ifdef _HAVE_STRESSBALANCE_
     43                case StressbalanceAnalysisEnum:
     44                        CreateNodesStressbalance(pnodes,iomodel);
     45                        CreateConstraintsStressbalance(pconstraints,iomodel);
     46                        CreateLoadsStressbalance(ploads,iomodel);
     47                        UpdateElementsStressbalance(elements,iomodel,analysis_counter,analysis_type);
    4848                        break;
    4949
    50                 case DiagnosticVertAnalysisEnum:
    51                         CreateNodesDiagnosticVert(pnodes, iomodel);
    52                         CreateConstraintsDiagnosticVert(pconstraints,iomodel);
    53                         CreateLoadsDiagnosticVert(ploads,iomodel);
    54                         UpdateElementsDiagnosticVert(elements,iomodel,analysis_counter,analysis_type);
     50                case StressbalanceVerticalAnalysisEnum:
     51                        CreateNodesStressbalanceVertical(pnodes, iomodel);
     52                        CreateConstraintsStressbalanceVertical(pconstraints,iomodel);
     53                        CreateLoadsStressbalanceVertical(ploads,iomodel);
     54                        UpdateElementsStressbalanceVertical(elements,iomodel,analysis_counter,analysis_type);
    5555                        break;
    5656
    57                 case DiagnosticSIAAnalysisEnum:
    58                         CreateNodesDiagnosticSIA(pnodes, iomodel);
    59                         CreateConstraintsDiagnosticSIA(pconstraints,iomodel);
    60                         CreateLoadsDiagnosticSIA(ploads,iomodel);
    61                         UpdateElementsDiagnosticSIA(elements,iomodel,analysis_counter,analysis_type);
     57                case StressbalanceSIAAnalysisEnum:
     58                        CreateNodesStressbalanceSIA(pnodes, iomodel);
     59                        CreateConstraintsStressbalanceSIA(pconstraints,iomodel);
     60                        CreateLoadsStressbalanceSIA(ploads,iomodel);
     61                        UpdateElementsStressbalanceSIA(elements,iomodel,analysis_counter,analysis_type);
    6262                        break;
    6363                #endif

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

    r15595 r15771  
    11/*
    2  * CreateElementsNodesAndMaterialsDiagnosticHoriz.c:
     2 * CreateElementsNodesAndMaterialsStressbalanceHoriz.c:
    33 */
    44

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

    r15767 r15771  
    5252        parameters->AddObject(iomodel->CopyConstantObject(FlowequationFeFSEnum));
    5353        parameters->AddObject(iomodel->CopyConstantObject(SettingsOutputFrequencyEnum));
    54         parameters->AddObject(iomodel->CopyConstantObject(DiagnosticRestolEnum));
    55         parameters->AddObject(iomodel->CopyConstantObject(DiagnosticReltolEnum));
    56         parameters->AddObject(iomodel->CopyConstantObject(DiagnosticAbstolEnum));
    57         parameters->AddObject(iomodel->CopyConstantObject(DiagnosticIsnewtonEnum));
    58         parameters->AddObject(iomodel->CopyConstantObject(DiagnosticMaxiterEnum));
     54        parameters->AddObject(iomodel->CopyConstantObject(StressbalanceRestolEnum));
     55        parameters->AddObject(iomodel->CopyConstantObject(StressbalanceReltolEnum));
     56        parameters->AddObject(iomodel->CopyConstantObject(StressbalanceAbstolEnum));
     57        parameters->AddObject(iomodel->CopyConstantObject(StressbalanceIsnewtonEnum));
     58        parameters->AddObject(iomodel->CopyConstantObject(StressbalanceMaxiterEnum));
    5959        parameters->AddObject(iomodel->CopyConstantObject(SteadystateReltolEnum));
    6060        parameters->AddObject(iomodel->CopyConstantObject(SteadystateMaxiterEnum));
    … …  
    6767        parameters->AddObject(iomodel->CopyConstantObject(MasstransportHydrostaticAdjustmentEnum));
    6868        parameters->AddObject(iomodel->CopyConstantObject(MasstransportStabilizationEnum));
    69         parameters->AddObject(iomodel->CopyConstantObject(DiagnosticPenaltyFactorEnum));
     69        parameters->AddObject(iomodel->CopyConstantObject(StressbalancePenaltyFactorEnum));
    7070        parameters->AddObject(iomodel->CopyConstantObject(MasstransportMinThicknessEnum));
    7171        parameters->AddObject(iomodel->CopyConstantObject(MasstransportPenaltyFactorEnum));
    … …  
    8181        parameters->AddObject(iomodel->CopyConstantObject(ThermalPenaltyThresholdEnum));
    8282        parameters->AddObject(iomodel->CopyConstantObject(ThermalPenaltyLockEnum));
    83         parameters->AddObject(iomodel->CopyConstantObject(DiagnosticRiftPenaltyThresholdEnum));
    84         parameters->AddObject(iomodel->CopyConstantObject(DiagnosticFSreconditioningEnum));
    85         parameters->AddObject(iomodel->CopyConstantObject(DiagnosticShelfDampeningEnum));
    86         parameters->AddObject(iomodel->CopyConstantObject(DiagnosticViscosityOvershootEnum));
     83        parameters->AddObject(iomodel->CopyConstantObject(StressbalanceRiftPenaltyThresholdEnum));
     84        parameters->AddObject(iomodel->CopyConstantObject(StressbalanceFSreconditioningEnum));
     85        parameters->AddObject(iomodel->CopyConstantObject(StressbalanceShelfDampeningEnum));
     86        parameters->AddObject(iomodel->CopyConstantObject(StressbalanceViscosityOvershootEnum));
    8787        parameters->AddObject(iomodel->CopyConstantObject(SettingsWaitonlockEnum));
    8888        parameters->AddObject(iomodel->CopyConstantObject(MeshNumberofelementsEnum));
    … …  
    9292        parameters->AddObject(iomodel->CopyConstantObject(SettingsResultsAsPatchesEnum));
    9393        parameters->AddObject(iomodel->CopyConstantObject(GroundinglineMigrationEnum));
    94         parameters->AddObject(iomodel->CopyConstantObject(TransientIsdiagnosticEnum));
     94        parameters->AddObject(iomodel->CopyConstantObject(TransientIsstressbalanceEnum));
    9595        parameters->AddObject(iomodel->CopyConstantObject(TransientIsmasstransportEnum));
    9696        parameters->AddObject(iomodel->CopyConstantObject(TransientIsthermalEnum));
    … …  
    147147
    148148        /*Requested outputs*/
    149         iomodel->FetchData(&requestedoutputs,&numoutputs,NULL,DiagnosticRequestedOutputsEnum);
    150         parameters->AddObject(new IntParam(DiagnosticNumRequestedOutputsEnum,numoutputs));
    151         if(numoutputs)parameters->AddObject(new IntVecParam(DiagnosticRequestedOutputsEnum,requestedoutputs,numoutputs));
    152         iomodel->DeleteData(requestedoutputs,DiagnosticRequestedOutputsEnum);
     149        iomodel->FetchData(&requestedoutputs,&numoutputs,NULL,StressbalanceRequestedOutputsEnum);
     150        parameters->AddObject(new IntParam(StressbalanceNumRequestedOutputsEnum,numoutputs));
     151        if(numoutputs)parameters->AddObject(new IntVecParam(StressbalanceRequestedOutputsEnum,requestedoutputs,numoutputs));
     152        iomodel->DeleteData(requestedoutputs,StressbalanceRequestedOutputsEnum);
    153153
    154154        iomodel->FetchData(&requestedoutputs,&numoutputs,NULL,TransientRequestedOutputsEnum);

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

    r15767 r15771  
    1616        /*ok, according to analysis type: */
    1717        switch(analysis_type){
    18                 case DiagnosticHorizAnalysisEnum:
     18                case StressbalanceAnalysisEnum:
    1919                        switch(node_type){
    2020                                case SSAApproximationEnum:
    … …  
    6666                                        break;
    6767                                default:
    68                                         _error_("Approximationtype " << node_type << " (" << EnumToStringx(node_type) << ") not implemented yet for DiagnosticHoriz");
     68                                        _error_("Approximationtype " << node_type << " (" << EnumToStringx(node_type) << ") not implemented yet for StressbalanceHoriz");
    6969
    7070                        }
    7171                        break;
    72                 case DiagnosticVertAnalysisEnum:
     72                case StressbalanceVerticalAnalysisEnum:
    7373                        numdofs=1;
    7474                        break;
    75                 case DiagnosticSIAAnalysisEnum:
     75                case StressbalanceSIAAnalysisEnum:
    7676                        numdofs=2;
    7777                        break;

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

    r15767 r15771  
    110110         * penpair has 2 nodes that are poointing toward 2 vertices.
    111111         * The 2 vertices must be in the same cpu as the penpair*/
    112         iomodel->FetchData(&vertex_pairing,&numvertex_pairing,NULL,DiagnosticVertexPairingEnum);
     112        iomodel->FetchData(&vertex_pairing,&numvertex_pairing,NULL,StressbalanceVertexPairingEnum);
    113113        for(i=0;i<numvertex_pairing;i++){
    114114                if(my_vertices[vertex_pairing[2*i+0]-1] && !my_vertices[vertex_pairing[2*i+1]-1]){

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

    r15767 r15771  
    1616
    1717        int   i,analysis_type,verbose;
    18         bool  isthermal,ismasstransport,isdiagnostic,isgroundingline,isenthalpy;
     18        bool  isthermal,ismasstransport,isstressbalance,isgroundingline,isenthalpy;
    1919
    2020        /*output: */
    … …  
    3535        iomodel->Constant(&isenthalpy,ThermalIsenthalpyEnum);
    3636        iomodel->Constant(&ismasstransport,TransientIsmasstransportEnum);
    37         iomodel->Constant(&isdiagnostic,TransientIsdiagnosticEnum);
     37        iomodel->Constant(&isstressbalance,TransientIsstressbalanceEnum);
    3838        iomodel->Constant(&isgroundingline,TransientIsgroundinglineEnum);
    3939
    … …  
    5757                if(solution_type==TransientSolutionEnum && analysis_type==EnthalpyAnalysisEnum && isenthalpy==false) continue;
    5858                if(solution_type==TransientSolutionEnum && analysis_type==MasstransportAnalysisEnum && ismasstransport==false && isgroundingline==false) continue;
    59                 if(solution_type==TransientSolutionEnum && analysis_type==DiagnosticHorizAnalysisEnum && isdiagnostic==false) continue;
    60                 if(solution_type==TransientSolutionEnum && analysis_type==DiagnosticVertAnalysisEnum && isdiagnostic==false) continue;
    61                 if(solution_type==TransientSolutionEnum && analysis_type==DiagnosticSIAAnalysisEnum && isdiagnostic==false) continue;
     59                if(solution_type==TransientSolutionEnum && analysis_type==StressbalanceAnalysisEnum && isstressbalance==false) continue;
     60                if(solution_type==TransientSolutionEnum && analysis_type==StressbalanceVerticalAnalysisEnum && isstressbalance==false) continue;
     61                if(solution_type==TransientSolutionEnum && analysis_type==StressbalanceSIAAnalysisEnum && isstressbalance==false) continue;
    6262                if(solution_type==SteadystateSolutionEnum && analysis_type==ThermalAnalysisEnum && isenthalpy==true) continue;
    6363                if(solution_type==SteadystateSolutionEnum && analysis_type==MeltingAnalysisEnum && isenthalpy==true) continue;

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/ModelProcessorx.h

    r15767 r15771  
    2727/*Creation of fem datasets: specialised drivers: */
    2828
    29 /*diagnostic horizontal*/
    30 void CreateNodesDiagnosticHoriz(Nodes** pnodes,IoModel* iomodel);
    31 void CreateConstraintsDiagnosticHoriz(Constraints** pconstraints,IoModel* iomodel);
    32 void CreateLoadsDiagnosticHoriz(Loads** ploads, IoModel* iomodel);
    33 void UpdateElementsDiagnosticHoriz(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
     29/*stressbalance horizontal*/
     30void CreateNodesStressbalance(Nodes** pnodes,IoModel* iomodel);
     31void CreateConstraintsStressbalance(Constraints** pconstraints,IoModel* iomodel);
     32void CreateLoadsStressbalance(Loads** ploads, IoModel* iomodel);
     33void UpdateElementsStressbalance(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
    3434
    35 /*diagnostic vertical*/
    36 void CreateNodesDiagnosticVert(Nodes** pnodes,IoModel* iomodel);
    37 void CreateConstraintsDiagnosticVert(Constraints** pconstraints,IoModel* iomodel);
    38 void CreateLoadsDiagnosticVert(Loads** ploads, IoModel* iomodel);
    39 void UpdateElementsDiagnosticVert(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
     35/*stressbalance vertical*/
     36void CreateNodesStressbalanceVertical(Nodes** pnodes,IoModel* iomodel);
     37void CreateConstraintsStressbalanceVertical(Constraints** pconstraints,IoModel* iomodel);
     38void CreateLoadsStressbalanceVertical(Loads** ploads, IoModel* iomodel);
     39void UpdateElementsStressbalanceVertical(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
    4040
    41 /*diagnostic SIA*/
    42 void CreateNodesDiagnosticSIA(Nodes** pnodes,IoModel* iomodel);
    43 void CreateConstraintsDiagnosticSIA(Constraints** pconstraints,IoModel* iomodel);
    44 void CreateLoadsDiagnosticSIA(Loads** ploads, IoModel* iomodel);
    45 void UpdateElementsDiagnosticSIA(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
     41/*stressbalance SIA*/
     42void CreateNodesStressbalanceSIA(Nodes** pnodes,IoModel* iomodel);
     43void CreateConstraintsStressbalanceSIA(Constraints** pconstraints,IoModel* iomodel);
     44void CreateLoadsStressbalanceSIA(Loads** ploads, IoModel* iomodel);
     45void UpdateElementsStressbalanceSIA(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
    4646
    4747#ifdef _HAVE_GIA_

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

    r15769 r15771  
    11/*
    2  * CreateConstraintsDiagnosticHoriz.c:
     2 * CreateConstraintsStressbalance.c:
    33 */
    44
    … …  
    99#include "../ModelProcessorx.h"
    1010
    11 void    CreateConstraintsDiagnosticHoriz(Constraints** pconstraints, IoModel* iomodel){
     11void    CreateConstraintsStressbalance(Constraints** pconstraints, IoModel* iomodel){
    1212
    1313        /*Intermediary*/
    … …  
    4545        iomodel->Constant(&g,ConstantsGEnum);
    4646        iomodel->Constant(&rho_ice,MaterialsRhoIceEnum);
    47         iomodel->Constant(&FSreconditioning,DiagnosticFSreconditioningEnum);
     47        iomodel->Constant(&FSreconditioning,StressbalanceFSreconditioningEnum);
    4848        iomodel->Constant(&isSIA,FlowequationIsSIAEnum);
    4949        iomodel->Constant(&isSSA,FlowequationIsSSAEnum);
    … …  
    108108                        }
    109109                }
    110                 IoModelToConstraintsx(constraints,iomodel,DiagnosticSpcvxEnum,DiagnosticHorizAnalysisEnum,finiteelement,1);
    111                 IoModelToConstraintsx(constraints,iomodel,DiagnosticSpcvyEnum,DiagnosticHorizAnalysisEnum,finiteelement,2);
     110                IoModelToConstraintsx(constraints,iomodel,StressbalanceSpcvxEnum,StressbalanceAnalysisEnum,finiteelement,1);
     111                IoModelToConstraintsx(constraints,iomodel,StressbalanceSpcvyEnum,StressbalanceAnalysisEnum,finiteelement,2);
    112112
    113113                if(isFS){
    114114
    115115                        /*Constraint at the bedrock interface (v.n = vz = 0) (Coordinates will be updated according to the bed slope)*/
    116                         iomodel->FetchData(&spcvz,&Mz,&Nz,DiagnosticSpcvzEnum);
     116                        iomodel->FetchData(&spcvz,&Mz,&Nz,StressbalanceSpcvzEnum);
    117117                        iomodel->FetchData(&vertices_type,NULL,NULL,FlowequationVertexEquationEnum);
    118118                        iomodel->FetchData(&nodeonFS,NULL,NULL,FlowequationBorderFSEnum);
    … …  
    131131                                }
    132132                        }
    133                         IoModelToConstraintsx(constraints,iomodel,spcvz,Mz,Nz,DiagnosticHorizAnalysisEnum,finiteelement,3);
    134                         iomodel->DeleteData(spcvz,DiagnosticSpcvzEnum);
     133                        IoModelToConstraintsx(constraints,iomodel,spcvz,Mz,Nz,StressbalanceAnalysisEnum,finiteelement,3);
     134                        iomodel->DeleteData(spcvz,StressbalanceSpcvzEnum);
    135135                        iomodel->DeleteData(vertices_type,FlowequationVertexEquationEnum);
    136136                        iomodel->DeleteData(nodeonFS,FlowequationBorderFSEnum);
    … …  
    148148                                                if(iomodel->my_vertices[i]){
    149149                                                        if (reCast<int,IssmDouble>(vertices_type[i])==NoneApproximationEnum){
    150                                                                 constraints->AddObject(new SpcStatic(count+1,iomodel->nodecounter+iomodel->numberofvertices+iomodel->numberofelements+i+1,1,g*rho_ice*(surface[i]-z[i])/FSreconditioning,DiagnosticHorizAnalysisEnum));
     150                                                                constraints->AddObject(new SpcStatic(count+1,iomodel->nodecounter+iomodel->numberofvertices+iomodel->numberofelements+i+1,1,g*rho_ice*(surface[i]-z[i])/FSreconditioning,StressbalanceAnalysisEnum));
    151151                                                                count++;
    152152                                                        }
    … …  
    158158                                                if(iomodel->my_vertices[i]){
    159159                                                        if (reCast<int,IssmDouble>(vertices_type[i])==NoneApproximationEnum){
    160                                                                 constraints->AddObject(new SpcStatic(count+1,iomodel->nodecounter+iomodel->numberofvertices+iomodel->numberofedges+i+1,1,g*rho_ice*(surface[i]-z[i])/FSreconditioning,DiagnosticHorizAnalysisEnum));
     160                                                                constraints->AddObject(new SpcStatic(count+1,iomodel->nodecounter+iomodel->numberofvertices+iomodel->numberofedges+i+1,1,g*rho_ice*(surface[i]-z[i])/FSreconditioning,StressbalanceAnalysisEnum));
    161161                                                                count++;
    162162                                                        }
    … …  
    177177
    178178        /*Constraints: fetch data: */
    179         iomodel->FetchData(&spcvx,&Mx,&Nx,DiagnosticSpcvxEnum);
    180         iomodel->FetchData(&spcvy,&My,&Ny,DiagnosticSpcvyEnum);
    181         iomodel->FetchData(&spcvz,&Mz,&Nz,DiagnosticSpcvzEnum);
     179        iomodel->FetchData(&spcvx,&Mx,&Nx,StressbalanceSpcvxEnum);
     180        iomodel->FetchData(&spcvy,&My,&Ny,StressbalanceSpcvyEnum);
     181        iomodel->FetchData(&spcvz,&Mz,&Nz,StressbalanceSpcvzEnum);
    182182        iomodel->FetchData(&nodeonSSA,NULL,NULL,FlowequationBorderSSAEnum);
    183183        if(iomodel->dim==3)iomodel->FetchData(&nodeonHO,NULL,NULL,FlowequationBorderHOEnum);
    … …  
    216216                                /*If grionSSA, spc HO dofs: 3 & 4*/
    217217                                        if (reCast<int,IssmDouble>(nodeonHO[i])){
    218                                                 constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,1,0,DiagnosticHorizAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
    219                                                 count++;
    220                                                 constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,2,0,DiagnosticHorizAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
    221                                                 count++;
    222                                                 if (!xIsNan<IssmDouble>(spcvx[i])){
    223                                                         constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,3,spcvx[i],DiagnosticHorizAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
    224                                                         count++;
    225                                                 }
    226                                                 if (!xIsNan<IssmDouble>(spcvy[i])){
    227                                                         constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,4,spcvy[i],DiagnosticHorizAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
     218                                                constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,1,0,StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
     219                                                count++;
     220                                                constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,2,0,StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
     221                                                count++;
     222                                                if (!xIsNan<IssmDouble>(spcvx[i])){
     223                                                        constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,3,spcvx[i],StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
     224                                                        count++;
     225                                                }
     226                                                if (!xIsNan<IssmDouble>(spcvy[i])){
     227                                                        constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,4,spcvy[i],StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
    228228                                                        count++;
    229229                                                }
    … …  
    231231                                        }
    232232                                        else if (reCast<int,IssmDouble>(nodeonSSA[i])){
    233                                                 constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,3,0,DiagnosticHorizAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
    234                                                 count++;
    235                                                 constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,4,0,DiagnosticHorizAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
    236                                                 count++;
    237                                                 if (!xIsNan<IssmDouble>(spcvx[i])){
    238                                                         constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,1,spcvx[i],DiagnosticHorizAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
    239                                                         count++;
    240                                                 }
    241                                                 if (!xIsNan<IssmDouble>(spcvy[i])){
    242                                                         constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,2,spcvy[i],DiagnosticHorizAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
     233                                                constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,3,0,StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
     234                                                count++;
     235                                                constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,4,0,StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
     236                                                count++;
     237                                                if (!xIsNan<IssmDouble>(spcvx[i])){
     238                                                        constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,1,spcvx[i],StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
     239                                                        count++;
     240                                                }
     241                                                if (!xIsNan<IssmDouble>(spcvy[i])){
     242                                                        constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,2,spcvy[i],StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
    243243                                                        count++;
    244244                                                }
    … …  
    251251                                /*If grion,HO spc FS dofs: 3 4 & 5*/
    252252                                        if (reCast<int,IssmDouble>(nodeonHO[i])){
    253                                                 constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,3,0,DiagnosticHorizAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
    254                                                 count++;
    255                                                 constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,4,0,DiagnosticHorizAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
    256                                                 count++;
    257                                                 constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,5,0,DiagnosticHorizAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
    258                                                 count++;
    259                                                 if (!xIsNan<IssmDouble>(spcvx[i])){
    260                                                         constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,1,spcvx[i],DiagnosticHorizAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
    261                                                         count++;
    262                                                 }
    263                                                 if (!xIsNan<IssmDouble>(spcvy[i])){
    264                                                         constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,2,spcvy[i],DiagnosticHorizAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
     253                                                constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,3,0,StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
     254                                                count++;
     255                                                constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,4,0,StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
     256                                                count++;
     257                                                constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,5,0,StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
     258                                                count++;
     259                                                if (!xIsNan<IssmDouble>(spcvx[i])){
     260                                                        constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,1,spcvx[i],StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
     261                                                        count++;
     262                                                }
     263                                                if (!xIsNan<IssmDouble>(spcvy[i])){
     264                                                        constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,2,spcvy[i],StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
    265265                                                        count++;
    266266                                                }
    … …  
    268268                                        }
    269269                                        else if (reCast<int,IssmDouble>(nodeonFS[i])){ //spc HO nodes: 1 & 2
    270                                                 constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,1,0,DiagnosticHorizAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
    271                                                 count++;
    272                                                 constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,2,0,DiagnosticHorizAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
    273                                                 count++;
    274                                                 if (!xIsNan<IssmDouble>(spcvx[i])){
    275                                                         constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,3,spcvx[i],DiagnosticHorizAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
    276                                                         count++;
    277                                                 }
    278                                                 if (!xIsNan<IssmDouble>(spcvy[i])){
    279                                                         constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,4,spcvy[i],DiagnosticHorizAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
     270                                                constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,1,0,StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
     271                                                count++;
     272                                                constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,2,0,StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
     273                                                count++;
     274                                                if (!xIsNan<IssmDouble>(spcvx[i])){
     275                                                        constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,3,spcvx[i],StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
     276                                                        count++;
     277                                                }
     278                                                if (!xIsNan<IssmDouble>(spcvy[i])){
     279                                                        constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,4,spcvy[i],StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
    280280                                                        count++;
    281281                                                }
    282282                                                if (!xIsNan<IssmDouble>(spcvz[i])){
    283                                                         constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,5,spcvz[i],DiagnosticHorizAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
     283                                                        constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,5,spcvz[i],StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
    284284                                                        count++;
    285285                                                }
    … …  
    291291                                /*If grion,HO spc FS dofs: 3 4 & 5*/
    292292                                        if (reCast<int,IssmDouble>(nodeonSSA[i])){
    293                                                 constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,3,0,DiagnosticHorizAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
    294                                                 count++;
    295                                                 constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,4,0,DiagnosticHorizAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
    296                                                 count++;
    297                                                 constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,5,0,DiagnosticHorizAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
    298                                                 count++;
    299                                                 if (!xIsNan<IssmDouble>(spcvx[i])){
    300                                                         constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,1,spcvx[i],DiagnosticHorizAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
    301                                                         count++;
    302                                                 }
    303                                                 if (!xIsNan<IssmDouble>(spcvy[i])){
    304                                                         constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,2,spcvy[i],DiagnosticHorizAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
     293                                                constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,3,0,StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
     294                                                count++;
     295                                                constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,4,0,StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
     296                                                count++;
     297                                                constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,5,0,StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
     298                                                count++;
     299                                                if (!xIsNan<IssmDouble>(spcvx[i])){
     300                                                        constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,1,spcvx[i],StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
     301                                                        count++;
     302                                                }
     303                                                if (!xIsNan<IssmDouble>(spcvy[i])){
     304                                                        constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,2,spcvy[i],StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
    305305                                                        count++;
    306306                                                }
    … …  
    308308                                        }
    309309                                        else if (reCast<int,IssmDouble>(nodeonFS[i])){ //spc SSA nodes: 1 & 2
    310                                                 constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,1,0,DiagnosticHorizAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
    311                                                 count++;
    312                                                 constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,2,0,DiagnosticHorizAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
    313                                                 count++;
    314                                                 if (!xIsNan<IssmDouble>(spcvx[i])){
    315                                                         constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,3,spcvx[i],DiagnosticHorizAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
    316                                                         count++;
    317                                                 }
    318                                                 if (!xIsNan<IssmDouble>(spcvy[i])){
    319                                                         constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,4,spcvy[i],DiagnosticHorizAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
     310                                                constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,1,0,StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
     311                                                count++;
     312                                                constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,2,0,StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
     313                                                count++;
     314                                                if (!xIsNan<IssmDouble>(spcvx[i])){
     315                                                        constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,3,spcvx[i],StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
     316                                                        count++;
     317                                                }
     318                                                if (!xIsNan<IssmDouble>(spcvy[i])){
     319                                                        constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,4,spcvy[i],StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
    320320                                                        count++;
    321321                                                }
    322322                                                if (!xIsNan<IssmDouble>(spcvz[i])){
    323                                                         constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,5,spcvz[i],DiagnosticHorizAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
     323                                                        constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,5,spcvz[i],StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
    324324                                                        count++;
    325325                                                }
    … …  
    330330                        else{
    331331                                if (Mx==iomodel->numberofvertices && !xIsNan<IssmDouble>(spcvx[i])){
    332                                         constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,1,spcvx[i],DiagnosticHorizAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
     332                                        constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,1,spcvx[i],StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
    333333                                        count++;
    334334
    … …  
    344344
    345345                                        if(spcpresent){
    346                                                 constraints->AddObject(new SpcTransient(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,1,Nx,timesx,values,DiagnosticHorizAnalysisEnum));
     346                                                constraints->AddObject(new SpcTransient(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,1,Nx,timesx,values,StressbalanceAnalysisEnum));
    347347                                                count++;
    348348                                        }
    … …  
    350350                                }
    351351                                else if (vertices_type[i]==SIAApproximationEnum){
    352                                         constraints->AddObject(new SpcDynamic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,1,DiagnosticHorizAnalysisEnum));
     352                                        constraints->AddObject(new SpcDynamic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,1,StressbalanceAnalysisEnum));
    353353                                        count++;
    354354                                }
    355355
    356356                                if (My==iomodel->numberofvertices && !xIsNan<IssmDouble>(spcvy[i])){
    357                                         constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,2,spcvy[i],DiagnosticHorizAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vy.
     357                                        constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,2,spcvy[i],StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vy.
    358358                                        count++;
    359359                                }
    … …  
    367367                                        }
    368368                                        if(spcpresent){
    369                                                 constraints->AddObject(new SpcTransient(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,2,Ny,timesy,values,DiagnosticHorizAnalysisEnum));
     369                                                constraints->AddObject(new SpcTransient(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,2,Ny,timesy,values,StressbalanceAnalysisEnum));
    370370                                                count++;
    371371                                        }
    … …  
    373373                                }
    374374                                else if (vertices_type[i]==SIAApproximationEnum){
    375                                         constraints->AddObject(new SpcDynamic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,2,DiagnosticHorizAnalysisEnum));
     375                                        constraints->AddObject(new SpcDynamic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,2,StressbalanceAnalysisEnum));
    376376                                        count++;
    377377                                }
    … …  
    379379                                if (reCast<int,IssmDouble>(vertices_type[i])==FSApproximationEnum ||  (reCast<int,IssmDouble>(vertices_type[i])==NoneApproximationEnum)){
    380380                                        if (Mz==iomodel->numberofvertices && !xIsNan<IssmDouble>(spcvz[i])){
    381                                                 constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,3,spcvz[i],DiagnosticHorizAnalysisEnum)); //add count'th spc, on node i+1, setting dof 2 to vy
     381                                                constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,3,spcvz[i],StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 2 to vy
    382382                                                count++;
    383383                                        }
    … …  
    391391                                                }
    392392                                                if(spcpresent){
    393                                                         constraints->AddObject(new SpcTransient(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,3,Nz,timesz,values,DiagnosticHorizAnalysisEnum));
     393                                                        constraints->AddObject(new SpcTransient(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,3,Nz,timesz,values,StressbalanceAnalysisEnum));
    394394                                                        count++;
    395395                                                }
    … …  
    399399                                }
    400400                                if (reCast<int,IssmDouble>(vertices_type[i])==NoneApproximationEnum){
    401                                         constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+iomodel->numberofvertices+i+1,1,g*rho_ice*(surface[i]-z[i])/FSreconditioning,DiagnosticHorizAnalysisEnum)); //add count'th spc, on node i+1, setting dof 2 to vy
     401                                        constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+iomodel->numberofvertices+i+1,1,g*rho_ice*(surface[i]-z[i])/FSreconditioning,StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 2 to vy
    402402                                        count++;
    403403                                }
    … …  
    408408                                 switch(reCast<int,IssmDouble>(vertices_type[i])){
    409409                                        case SSAFSApproximationEnum:
    410                                                 constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,5,0.,DiagnosticHorizAnalysisEnum));
     410                                                constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,5,0.,StressbalanceAnalysisEnum));
    411411                                                count++;
    412412                                                break;
    413413                                        case HOFSApproximationEnum:
    414                                                 constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,5,0.,DiagnosticHorizAnalysisEnum));
     414                                                constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,5,0.,StressbalanceAnalysisEnum));
    415415                                                count++;
    416416                                                break;
    417417                                        case FSApproximationEnum:
    418                                                 constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,3,0.,DiagnosticHorizAnalysisEnum));
     418                                                constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,3,0.,StressbalanceAnalysisEnum));
    419419                                                count++;
    420420                                                break;
    … …  
    426426
    427427        /*Free data: */
    428         iomodel->DeleteData(spcvx,DiagnosticSpcvxEnum);
    429         iomodel->DeleteData(spcvy,DiagnosticSpcvyEnum);
    430         iomodel->DeleteData(spcvz,DiagnosticSpcvzEnum);
     428        iomodel->DeleteData(spcvx,StressbalanceSpcvxEnum);
     429        iomodel->DeleteData(spcvy,StressbalanceSpcvyEnum);
     430        iomodel->DeleteData(spcvz,StressbalanceSpcvzEnum);
    431431        iomodel->DeleteData(nodeonSSA,FlowequationBorderSSAEnum);
    432432        if(iomodel->dim==3)iomodel->DeleteData(nodeonHO,FlowequationBorderHOEnum);

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

    r15769 r15771  
    1 /*! \file CreateLoadsDiagnosticHoriz.c:
     1/*! \file CreateLoadsStressbalance.c:
    22 */
    33
    … …  
    77#include "../ModelProcessorx.h"
    88
    9 void    CreateLoadsDiagnosticHoriz(Loads** ploads, IoModel* iomodel){
     9void    CreateLoadsStressbalance(Loads** ploads, IoModel* iomodel){
    1010
    1111        /*DataSets*/
    … …  
    4747
    4848        /*Create Penpair for penalties: */
    49         iomodel->FetchData(&penalties,&numpenalties,NULL,DiagnosticVertexPairingEnum);
     49        iomodel->FetchData(&penalties,&numpenalties,NULL,StressbalanceVertexPairingEnum);
    5050
    5151        for(i=0;i<numpenalties;i++){
    … …  
    6161
    6262                        /*Create Load*/
    63                         loads->AddObject(new Penpair(iomodel->loadcounter+count+1,&penpair_ids[0],DiagnosticHorizAnalysisEnum));
     63                        loads->AddObject(new Penpair(iomodel->loadcounter+count+1,&penpair_ids[0],StressbalanceAnalysisEnum));
    6464                        count++;
    6565                }
    … …  
    6767
    6868        /*free ressources: */
    69         iomodel->DeleteData(penalties,DiagnosticVertexPairingEnum);
     69        iomodel->DeleteData(penalties,StressbalanceVertexPairingEnum);
    7070
    7171        /*Create Riffront loads for rifts: */
    … …  
    7676                for(i=0;i<numriftsegments;i++){
    7777                        if(iomodel->my_elements[reCast<int,IssmDouble>(*(riftinfo+RIFTINFOSIZE*i+2))-1]){
    78                                 loads->AddObject(new Riftfront(iomodel->loadcounter+count+1,i,iomodel,DiagnosticHorizAnalysisEnum));
     78                                loads->AddObject(new Riftfront(iomodel->loadcounter+count+1,i,iomodel,StressbalanceAnalysisEnum));
    7979                                count++;
    8080                        }

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

    r15769 r15771  
    11/*
    2  * CreateNodesDiagnosticHoriz.c:
     2 * CreateNodesStressbalance.c:
    33 */
    44
    … …  
    99#include "../ModelProcessorx.h"
    1010
    11 void    CreateNodesDiagnosticHoriz(Nodes** pnodes, IoModel* iomodel){
     11void    CreateNodesStressbalance(Nodes** pnodes, IoModel* iomodel){
    1212
    1313        /*Intermediary*/
    … …  
    7575                }
    7676                iomodel->FetchData(8,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,FlowequationBorderSSAEnum,FlowequationBorderFSEnum,
    77                                         MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,DiagnosticReferentialEnum);
    78                 CreateNodes(pnodes,iomodel,DiagnosticHorizAnalysisEnum,finiteelement,approximation);
     77                                        MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,StressbalanceReferentialEnum);
     78                CreateNodes(pnodes,iomodel,StressbalanceAnalysisEnum,finiteelement,approximation);
    7979                iomodel->DeleteData(8,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,FlowequationBorderSSAEnum,FlowequationBorderFSEnum,
    80                                         MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,DiagnosticReferentialEnum);
     80                                        MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,StressbalanceReferentialEnum);
    8181        }
    8282        else{
    … …  
    8989
    9090                iomodel->FetchData(8,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,FlowequationBorderSSAEnum,FlowequationBorderFSEnum,
    91                                         MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,DiagnosticReferentialEnum);
     91                                        MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,StressbalanceReferentialEnum);
    9292                if(isFS){
    9393                        /*P1+ velocity*/
    … …  
    9696                                        approximation=reCast<int>(iomodel->Data(FlowequationVertexEquationEnum)[i]);
    9797                                        if(approximation==FSApproximationEnum)  approximation=FSvelocityEnum;
    98                                         nodes->AddObject(new Node(iomodel->nodecounter+i+1,i,i,iomodel,DiagnosticHorizAnalysisEnum,approximation));
     98                                        nodes->AddObject(new Node(iomodel->nodecounter+i+1,i,i,iomodel,StressbalanceAnalysisEnum,approximation));
    9999                                }
    100100                        }
    101101                        for(int i=0;i<iomodel->numberofelements;i++){
    102102                                if(iomodel->my_elements[i]){
    103                                         node = new Node(iomodel->nodecounter+iomodel->numberofvertices+i+1,iomodel->numberofvertices+i,0,iomodel,DiagnosticHorizAnalysisEnum,FSvelocityEnum);
     103                                        node = new Node(iomodel->nodecounter+iomodel->numberofvertices+i+1,iomodel->numberofvertices+i,0,iomodel,StressbalanceAnalysisEnum,FSvelocityEnum);
    104104                                        node->Deactivate();
    105105                                        nodes->AddObject(node);
    … …  
    110110                                if(iomodel->my_vertices[i]){
    111111                                        approximation=reCast<int>(iomodel->Data(FlowequationVertexEquationEnum)[i]);
    112                                         node = new Node(iomodel->nodecounter+iomodel->numberofvertices+iomodel->numberofelements+i+1,iomodel->numberofvertices+iomodel->numberofelements+i,i,iomodel,DiagnosticHorizAnalysisEnum,FSpressureEnum);
     112                                        node = new Node(iomodel->nodecounter+iomodel->numberofvertices+iomodel->numberofelements+i+1,iomodel->numberofvertices+iomodel->numberofelements+i,i,iomodel,StressbalanceAnalysisEnum,FSpressureEnum);
    113113                                        if(approximation==HOApproximationEnum || approximation==SSAApproximationEnum){
    114114                                                node->Deactivate();
    … …  
    121121                        for(int i=0;i<iomodel->numberofvertices;i++){
    122122                                if(iomodel->my_vertices[i]){
    123                                         nodes->AddObject(new Node(iomodel->nodecounter+i+1,i,i,iomodel,DiagnosticHorizAnalysisEnum,reCast<int>(iomodel->Data(FlowequationVertexEquationEnum)[i])));
     123                                        nodes->AddObject(new Node(iomodel->nodecounter+i+1,i,i,iomodel,StressbalanceAnalysisEnum,reCast<int>(iomodel->Data(FlowequationVertexEquationEnum)[i])));
    124124                                }
    125125                        }
    126126                }
    127127                iomodel->DeleteData(8,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,FlowequationBorderSSAEnum,FlowequationBorderFSEnum,
    128                                         MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,DiagnosticReferentialEnum);
     128                                        MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,StressbalanceReferentialEnum);
    129129
    130130                /*Assign output pointer: */

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

    r15769 r15771  
    11/*
    2  * UpdateElementsDiagnosticHoriz:
     2 * UpdateElementsStressbalance:
    33 */
    44#ifdef HAVE_CONFIG_H
    … …  
    1414#include "../ModelProcessorx.h"
    1515
    16 void    UpdateElementsDiagnosticHoriz(Elements* elements, IoModel* iomodel,int analysis_counter,int analysis_type){
     16void    UpdateElementsStressbalance(Elements* elements, IoModel* iomodel,int analysis_counter,int analysis_type){
    1717
    1818        int    materials_type,finiteelement,temp;

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

    r15769 r15771  
    11/*
    2  * CreateConstraintsDiagnosticSIA.c:
     2 * CreateConstraintsStressbalanceSIA.c:
    33 */
    44
    … …  
    88#include "../ModelProcessorx.h"
    99
    10 void    CreateConstraintsDiagnosticSIA(Constraints** pconstraints, IoModel* iomodel){
     10void    CreateConstraintsStressbalanceSIA(Constraints** pconstraints, IoModel* iomodel){
    1111
    1212        /*Intermediary*/
    … …  
    3030
    3131        /*Fetch data: */
    32         iomodel->FetchData(3,DiagnosticSpcvxEnum,DiagnosticSpcvyEnum,FlowequationVertexEquationEnum);
     32        iomodel->FetchData(3,StressbalanceSpcvxEnum,StressbalanceSpcvyEnum,FlowequationVertexEquationEnum);
    3333
    3434        /*Initialize conunter*/
    … …  
    4141                        if (!reCast<int,IssmDouble>(iomodel->Data(FlowequationVertexEquationEnum)[i])==SIAApproximationEnum){
    4242
    43                                 constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,1,0,DiagnosticSIAAnalysisEnum));
     43                                constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,1,0,StressbalanceSIAAnalysisEnum));
    4444                                count++;
    4545
    46                                 constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,2,0,DiagnosticSIAAnalysisEnum));
     46                                constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,2,0,StressbalanceSIAAnalysisEnum));
    4747                                count++;
    4848                        }
    4949                        else{
    50                                 if (!xIsNan<IssmDouble>(iomodel->Data(DiagnosticSpcvxEnum)[i])){
    51                                         constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,1,iomodel->Data(DiagnosticSpcvxEnum)[i]/yts,DiagnosticSIAAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
     50                                if (!xIsNan<IssmDouble>(iomodel->Data(StressbalanceSpcvxEnum)[i])){
     51                                        constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,1,iomodel->Data(StressbalanceSpcvxEnum)[i]/yts,StressbalanceSIAAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
    5252                                        count++;
    5353                                }
    5454
    55                                 if (!xIsNan<IssmDouble>(iomodel->Data(DiagnosticSpcvyEnum)[i])){
    56                                         constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,2,iomodel->Data(DiagnosticSpcvyEnum)[i]/yts,DiagnosticSIAAnalysisEnum)); //add count'th spc, on node i+1, setting dof 2 to vy
     55                                if (!xIsNan<IssmDouble>(iomodel->Data(StressbalanceSpcvyEnum)[i])){
     56                                        constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,2,iomodel->Data(StressbalanceSpcvyEnum)[i]/yts,StressbalanceSIAAnalysisEnum)); //add count'th spc, on node i+1, setting dof 2 to vy
    5757                                        count++;
    5858                                }
    … …  
    6262
    6363        /*Free data: */
    64         iomodel->DeleteData(3,DiagnosticSpcvxEnum,DiagnosticSpcvyEnum,FlowequationVertexEquationEnum);
     64        iomodel->DeleteData(3,StressbalanceSpcvxEnum,StressbalanceSpcvyEnum,FlowequationVertexEquationEnum);
    6565
    6666        /*Assign output pointer: */

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

    r15769 r15771  
    1 /*! \file CreateLoadsDiagnosticSIA.c:
     1/*! \file CreateLoadsStressbalanceSIA.c:
    22 */
    33
    … …  
    77#include "../ModelProcessorx.h"
    88
    9 void    CreateLoadsDiagnosticSIA(Loads** ploads, IoModel* iomodel){
     9void    CreateLoadsStressbalanceSIA(Loads** ploads, IoModel* iomodel){
    1010
    1111        /*No loads*/

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

    r15769 r15771  
    11/*
    2  * CreateNodesDiagnosticSIA.c:
     2 * CreateNodesStressbalanceSIA.c:
    33 */
    44
    … …  
    99#include "../ModelProcessorx.h"
    1010
    11 void    CreateNodesDiagnosticSIA(Nodes** pnodes, IoModel* iomodel){
     11void    CreateNodesStressbalanceSIA(Nodes** pnodes, IoModel* iomodel){
    1212
    1313        /*Intermediaries*/
    … …  
    2626
    2727        iomodel->FetchData(8,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,FlowequationBorderSSAEnum,FlowequationBorderFSEnum,
    28                                 MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,DiagnosticReferentialEnum);
     28                                MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,StressbalanceReferentialEnum);
    2929
    3030        for(int i=0;i<iomodel->numberofvertices;i++){
    … …  
    3232
    3333                        /*Create new node if is in this processor's partition*/
    34                         node = new Node(iomodel->nodecounter+i+1,i,i,iomodel,DiagnosticSIAAnalysisEnum,reCast<int>(iomodel->Data(FlowequationVertexEquationEnum)[i]));
     34                        node = new Node(iomodel->nodecounter+i+1,i,i,iomodel,StressbalanceSIAAnalysisEnum,reCast<int>(iomodel->Data(FlowequationVertexEquationEnum)[i]));
    3535
    3636                        /*Deactivate node if not SIA*/
    … …  
    4545
    4646        iomodel->DeleteData(8,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,FlowequationBorderSSAEnum,FlowequationBorderFSEnum,
    47                                 MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,DiagnosticReferentialEnum);
     47                                MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,StressbalanceReferentialEnum);
    4848
    4949        /*Assign output pointer: */

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

    r15769 r15771  
    11/*
    2  * UpdateElementsDiagnosticSIA:
     2 * UpdateElementsStressbalanceSIA:
    33 */
    44
    … …  
    99#include "../ModelProcessorx.h"
    1010
    11 void    UpdateElementsDiagnosticSIA(Elements* elements, IoModel* iomodel,int analysis_counter,int analysis_type){
     11void    UpdateElementsStressbalanceSIA(Elements* elements, IoModel* iomodel,int analysis_counter,int analysis_type){
    1212
    1313        /*Fetch data needed: */

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

    r15769 r15771  
    11/*
    2  * CreateConstraintsDiagnosticHoriz.c:
     2 * CreateConstraintsStressbalanceHoriz.c:
    33 */
    44
    … …  
    88#include "../ModelProcessorx.h"
    99
    10 void    CreateConstraintsDiagnosticVert(Constraints** pconstraints, IoModel* iomodel){
     10void    CreateConstraintsStressbalanceVertical(Constraints** pconstraints, IoModel* iomodel){
    1111
    1212        /*Intermediary*/
    … …  
    2424
    2525        /*Fetch data: */
    26         iomodel->FetchData(2,DiagnosticSpcvzEnum,FlowequationBorderFSEnum);
     26        iomodel->FetchData(2,StressbalanceSpcvzEnum,FlowequationBorderFSEnum);
    2727
    2828        /*Initialize counter*/
    … …  
    3636
    3737                        if (reCast<int,IssmDouble>(iomodel->Data(FlowequationBorderFSEnum)[i])){
    38                                 constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,1,0,DiagnosticVertAnalysisEnum)); //spc to zero as vertical velocity is done in Horiz for FS
     38                                constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,1,0,StressbalanceVerticalAnalysisEnum)); //spc to zero as vertical velocity is done in Horiz for FS
    3939                                count++;
    4040                        }
    41                         else if (!xIsNan<IssmDouble>(iomodel->Data(DiagnosticSpcvzEnum)[i])){
     41                        else if (!xIsNan<IssmDouble>(iomodel->Data(StressbalanceSpcvzEnum)[i])){
    4242                                constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,1,
    43                                                                 iomodel->Data(DiagnosticSpcvzEnum)[i]/yts,DiagnosticVertAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
     43                                                                iomodel->Data(StressbalanceSpcvzEnum)[i]/yts,StressbalanceVerticalAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
    4444                                count++;
    4545
    … …  
    4949
    5050        /*Free data: */
    51         iomodel->DeleteData(2,DiagnosticSpcvzEnum,FlowequationBorderFSEnum);
     51        iomodel->DeleteData(2,StressbalanceSpcvzEnum,FlowequationBorderFSEnum);
    5252
    5353        /*Assign output pointer: */

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

    r15769 r15771  
    1 /*! \file CreateLoadsDiagnosticVert.c:
     1/*! \file CreateLoadsStressbalanceVertical.c:
    22 */
    33
    … …  
    77#include "../ModelProcessorx.h"
    88
    9 void    CreateLoadsDiagnosticVert(Loads** ploads, IoModel* iomodel){
     9void    CreateLoadsStressbalanceVertical(Loads** ploads, IoModel* iomodel){
    1010
    1111        /*No loads*/

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

    r15769 r15771  
    11/*
    2  * CreateNodesDiagnosticVert.c:
     2 * CreateNodesStressbalanceVertical.c:
    33 */
    44
    … …  
    99#include "../ModelProcessorx.h"
    1010
    11 void    CreateNodesDiagnosticVert(Nodes** pnodes, IoModel* iomodel){
     11void    CreateNodesStressbalanceVertical(Nodes** pnodes, IoModel* iomodel){
    1212
    1313        /*Now, is the flag macayaealHO on? otherwise, do nothing: */
    … …  
    1515
    1616        iomodel->FetchData(5,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum);
    17         CreateNodes(pnodes,iomodel,DiagnosticVertAnalysisEnum,P1Enum);
     17        CreateNodes(pnodes,iomodel,StressbalanceVerticalAnalysisEnum,P1Enum);
    1818        iomodel->DeleteData(5,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum);
    1919}

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

    r15769 r15771  
    11/*
    2  * UpdateElementsDiagnosticVert:
     2 * UpdateElementsStressbalanceVertical:
    33 */
    44
    … …  
    99#include "../ModelProcessorx.h"
    1010
    11 void    UpdateElementsDiagnosticVert(Elements* elements, IoModel* iomodel,int analysis_counter,int analysis_type){
     11void    UpdateElementsStressbalanceVertical(Elements* elements, IoModel* iomodel,int analysis_counter,int analysis_type){
    1212
    1313        /*Now, is the model 3d? otherwise, do nothing: */

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

    r14999 r15771  
    11/*!\file OutputRiftsx
    2  * \brief: output results from diagnostic solution, for rifts. Notably: fraction of
     2 * \brief: output results from stressbalance solution, for rifts. Notably: fraction of
    33 * melange, and penetration.
    44 */

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

    r15767 r15771  
    4141        ConstantsYtsEnum,
    4242        DependentObjectEnum,
    43         DiagnosticAbstolEnum,
    44         DiagnosticIcefrontEnum,
    45         DiagnosticIsnewtonEnum,
    46         DiagnosticMaxiterEnum,
    47         DiagnosticNumRequestedOutputsEnum,
    48         DiagnosticPenaltyFactorEnum,
    49         DiagnosticReferentialEnum,
    50         DiagnosticReltolEnum,
    51         DiagnosticRequestedOutputsEnum,
    52         DiagnosticRestolEnum,
    53         DiagnosticRiftPenaltyLockEnum,
    54         DiagnosticRiftPenaltyThresholdEnum,
    55         DiagnosticShelfDampeningEnum,
    56         DiagnosticSpcvxEnum,
    57         DiagnosticSpcvyEnum,
    58         DiagnosticSpcvzEnum,
    59         DiagnosticFSreconditioningEnum,
    60         DiagnosticVertexPairingEnum,
    61         DiagnosticViscosityOvershootEnum,
     43        StressbalanceAbstolEnum,
     44        StressbalanceIcefrontEnum,
     45        StressbalanceIsnewtonEnum,
     46        StressbalanceMaxiterEnum,
     47        StressbalanceNumRequestedOutputsEnum,
     48        StressbalancePenaltyFactorEnum,
     49        StressbalanceReferentialEnum,
     50        StressbalanceReltolEnum,
     51        StressbalanceRequestedOutputsEnum,
     52        StressbalanceRestolEnum,
     53        StressbalanceRiftPenaltyLockEnum,
     54        StressbalanceRiftPenaltyThresholdEnum,
     55        StressbalanceShelfDampeningEnum,
     56        StressbalanceSpcvxEnum,
     57        StressbalanceSpcvyEnum,
     58        StressbalanceSpcvzEnum,
     59        StressbalanceFSreconditioningEnum,
     60        StressbalanceVertexPairingEnum,
     61        StressbalanceViscosityOvershootEnum,
    6262        LoadingforceXEnum,
    6363        LoadingforceYEnum,
    … …  
    254254        TimesteppingTimeAdaptEnum,
    255255        TimesteppingTimeStepEnum,
    256         TransientIsdiagnosticEnum,
     256        TransientIsstressbalanceEnum,
    257257        TransientIsgroundinglineEnum,
    258258        TransientIsmasstransportEnum,
    … …  
    280280        BedSlopeXAnalysisEnum,
    281281        BedSlopeYAnalysisEnum,
    282         DiagnosticHorizAnalysisEnum,
    283         DiagnosticSIAAnalysisEnum,
    284         DiagnosticSolutionEnum,
    285         DiagnosticVertAnalysisEnum,
     282        StressbalanceAnalysisEnum,
     283        StressbalanceSIAAnalysisEnum,
     284        StressbalanceSolutionEnum,
     285        StressbalanceVerticalAnalysisEnum,
    286286        EnthalpyAnalysisEnum,
    287287        EnthalpySolutionEnum,

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

    r15767 r15771  
    4949                case ConstantsYtsEnum : return "ConstantsYts";
    5050                case DependentObjectEnum : return "DependentObject";
    51                 case DiagnosticAbstolEnum : return "DiagnosticAbstol";
    52                 case DiagnosticIcefrontEnum : return "DiagnosticIcefront";
    53                 case DiagnosticIsnewtonEnum : return "DiagnosticIsnewton";
    54                 case DiagnosticMaxiterEnum : return "DiagnosticMaxiter";
    55                 case DiagnosticNumRequestedOutputsEnum : return "DiagnosticNumRequestedOutputs";
    56                 case DiagnosticPenaltyFactorEnum : return "DiagnosticPenaltyFactor";
    57                 case DiagnosticReferentialEnum : return "DiagnosticReferential";
    58                 case DiagnosticReltolEnum : return "DiagnosticReltol";
    59                 case DiagnosticRequestedOutputsEnum : return "DiagnosticRequestedOutputs";
    60                 case DiagnosticRestolEnum : return "DiagnosticRestol";
    61                 case DiagnosticRiftPenaltyLockEnum : return "DiagnosticRiftPenaltyLock";
    62                 case DiagnosticRiftPenaltyThresholdEnum : return "DiagnosticRiftPenaltyThreshold";
    63                 case DiagnosticShelfDampeningEnum : return "DiagnosticShelfDampening";
    64                 case DiagnosticSpcvxEnum : return "DiagnosticSpcvx";
    65                 case DiagnosticSpcvyEnum : return "DiagnosticSpcvy";
    66                 case DiagnosticSpcvzEnum : return "DiagnosticSpcvz";
    67                 case DiagnosticFSreconditioningEnum : return "DiagnosticFSreconditioning";
    68                 case DiagnosticVertexPairingEnum : return "DiagnosticVertexPairing";
    69                 case DiagnosticViscosityOvershootEnum : return "DiagnosticViscosityOvershoot";
     51                case StressbalanceAbstolEnum : return "StressbalanceAbstol";
     52                case StressbalanceIcefrontEnum : return "StressbalanceIcefront";
     53                case StressbalanceIsnewtonEnum : return "StressbalanceIsnewton";
     54                case StressbalanceMaxiterEnum : return "StressbalanceMaxiter";
     55                case StressbalanceNumRequestedOutputsEnum : return "StressbalanceNumRequestedOutputs";
     56                case StressbalancePenaltyFactorEnum : return "StressbalancePenaltyFactor";
     57                case StressbalanceReferentialEnum : return "StressbalanceReferential";
     58                case StressbalanceReltolEnum : return "StressbalanceReltol";
     59                case StressbalanceRequestedOutputsEnum : return "StressbalanceRequestedOutputs";
     60                case StressbalanceRestolEnum : return "StressbalanceRestol";
     61                case StressbalanceRiftPenaltyLockEnum : return "StressbalanceRiftPenaltyLock";
     62                case StressbalanceRiftPenaltyThresholdEnum : return "StressbalanceRiftPenaltyThreshold";
     63                case StressbalanceShelfDampeningEnum : return "StressbalanceShelfDampening";
     64                case StressbalanceSpcvxEnum : return "StressbalanceSpcvx";
     65                case StressbalanceSpcvyEnum : return "StressbalanceSpcvy";
     66                case StressbalanceSpcvzEnum : return "StressbalanceSpcvz";
     67                case StressbalanceFSreconditioningEnum : return "StressbalanceFSreconditioning";
     68                case StressbalanceVertexPairingEnum : return "StressbalanceVertexPairing";
     69                case StressbalanceViscosityOvershootEnum : return "StressbalanceViscosityOvershoot";
    7070                case LoadingforceXEnum : return "LoadingforceX";
    7171                case LoadingforceYEnum : return "LoadingforceY";
    … …  
    262262                case TimesteppingTimeAdaptEnum : return "TimesteppingTimeAdapt";
    263263                case TimesteppingTimeStepEnum : return "TimesteppingTimeStep";
    264                 case TransientIsdiagnosticEnum : return "TransientIsdiagnostic";
     264                case TransientIsstressbalanceEnum : return "TransientIsstressbalance";
    265265                case TransientIsgroundinglineEnum : return "TransientIsgroundingline";
    266266                case TransientIsmasstransportEnum : return "TransientIsmasstransport";
    … …  
    286286                case BedSlopeXAnalysisEnum : return "BedSlopeXAnalysis";
    287287                case BedSlopeYAnalysisEnum : return "BedSlopeYAnalysis";
    288                 case DiagnosticHorizAnalysisEnum : return "DiagnosticHorizAnalysis";
    289                 case DiagnosticSIAAnalysisEnum : return "DiagnosticSIAAnalysis";
    290                 case DiagnosticSolutionEnum : return "DiagnosticSolution";
    291                 case DiagnosticVertAnalysisEnum : return "DiagnosticVertAnalysis";
     288                case StressbalanceAnalysisEnum : return "StressbalanceAnalysis";
     289                case StressbalanceSIAAnalysisEnum : return "StressbalanceSIAAnalysis";
     290                case StressbalanceSolutionEnum : return "StressbalanceSolution";
     291                case StressbalanceVerticalAnalysisEnum : return "StressbalanceVerticalAnalysis";
    292292                case EnthalpyAnalysisEnum : return "EnthalpyAnalysis";
    293293                case EnthalpySolutionEnum : return "EnthalpySolution";

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

    r15767 r15771  
    4949              else if (strcmp(name,"ConstantsYts")==0) return ConstantsYtsEnum;
    5050              else if (strcmp(name,"DependentObject")==0) return DependentObjectEnum;
    51               else if (strcmp(name,"DiagnosticAbstol")==0) return DiagnosticAbstolEnum;
    52               else if (strcmp(name,"DiagnosticIcefront")==0) return DiagnosticIcefrontEnum;
    53               else if (strcmp(name,"DiagnosticIsnewton")==0) return DiagnosticIsnewtonEnum;
    54               else if (strcmp(name,"DiagnosticMaxiter")==0) return DiagnosticMaxiterEnum;
    55               else if (strcmp(name,"DiagnosticNumRequestedOutputs")==0) return DiagnosticNumRequestedOutputsEnum;
    56               else if (strcmp(name,"DiagnosticPenaltyFactor")==0) return DiagnosticPenaltyFactorEnum;
    57               else if (strcmp(name,"DiagnosticReferential")==0) return DiagnosticReferentialEnum;
    58               else if (strcmp(name,"DiagnosticReltol")==0) return DiagnosticReltolEnum;
    59               else if (strcmp(name,"DiagnosticRequestedOutputs")==0) return DiagnosticRequestedOutputsEnum;
    60               else if (strcmp(name,"DiagnosticRestol")==0) return DiagnosticRestolEnum;
    61               else if (strcmp(name,"DiagnosticRiftPenaltyLock")==0) return DiagnosticRiftPenaltyLockEnum;
    62               else if (strcmp(name,"DiagnosticRiftPenaltyThreshold")==0) return DiagnosticRiftPenaltyThresholdEnum;
    63               else if (strcmp(name,"DiagnosticShelfDampening")==0) return DiagnosticShelfDampeningEnum;
    64               else if (strcmp(name,"DiagnosticSpcvx")==0) return DiagnosticSpcvxEnum;
    65               else if (strcmp(name,"DiagnosticSpcvy")==0) return DiagnosticSpcvyEnum;
    66               else if (strcmp(name,"DiagnosticSpcvz")==0) return DiagnosticSpcvzEnum;
    67               else if (strcmp(name,"DiagnosticFSreconditioning")==0) return DiagnosticFSreconditioningEnum;
    68               else if (strcmp(name,"DiagnosticVertexPairing")==0) return DiagnosticVertexPairingEnum;
    69               else if (strcmp(name,"DiagnosticViscosityOvershoot")==0) return DiagnosticViscosityOvershootEnum;
     51              else if (strcmp(name,"StressbalanceAbstol")==0) return StressbalanceAbstolEnum;
     52              else if (strcmp(name,"StressbalanceIcefront")==0) return StressbalanceIcefrontEnum;
     53              else if (strcmp(name,"StressbalanceIsnewton")==0) return StressbalanceIsnewtonEnum;
     54              else if (strcmp(name,"StressbalanceMaxiter")==0) return StressbalanceMaxiterEnum;
     55              else if (strcmp(name,"StressbalanceNumRequestedOutputs")==0) return StressbalanceNumRequestedOutputsEnum;
     56              else if (strcmp(name,"StressbalancePenaltyFactor")==0) return StressbalancePenaltyFactorEnum;
     57              else if (strcmp(name,"StressbalanceReferential")==0) return StressbalanceReferentialEnum;
     58              else if (strcmp(name,"StressbalanceReltol")==0) return StressbalanceReltolEnum;
     59              else if (strcmp(name,"StressbalanceRequestedOutputs")==0) return StressbalanceRequestedOutputsEnum;
     60              else if (strcmp(name,"StressbalanceRestol")==0) return StressbalanceRestolEnum;
     61              else if (strcmp(name,"StressbalanceRiftPenaltyLock")==0) return StressbalanceRiftPenaltyLockEnum;
     62              else if (strcmp(name,"StressbalanceRiftPenaltyThreshold")==0) return StressbalanceRiftPenaltyThresholdEnum;
     63              else if (strcmp(name,"StressbalanceShelfDampening")==0) return StressbalanceShelfDampeningEnum;
     64              else if (strcmp(name,"StressbalanceSpcvx")==0) return StressbalanceSpcvxEnum;
     65              else if (strcmp(name,"StressbalanceSpcvy")==0) return StressbalanceSpcvyEnum;
     66              else if (strcmp(name,"StressbalanceSpcvz")==0) return StressbalanceSpcvzEnum;
     67              else if (strcmp(name,"StressbalanceFSreconditioning")==0) return StressbalanceFSreconditioningEnum;
     68              else if (strcmp(name,"StressbalanceVertexPairing")==0) return StressbalanceVertexPairingEnum;
     69              else if (strcmp(name,"StressbalanceViscosityOvershoot")==0) return StressbalanceViscosityOvershootEnum;
    7070              else if (strcmp(name,"LoadingforceX")==0) return LoadingforceXEnum;
    7171              else if (strcmp(name,"LoadingforceY")==0) return LoadingforceYEnum;
    … …  
    268268              else if (strcmp(name,"TimesteppingTimeAdapt")==0) return TimesteppingTimeAdaptEnum;
    269269              else if (strcmp(name,"TimesteppingTimeStep")==0) return TimesteppingTimeStepEnum;
    270               else if (strcmp(name,"TransientIsdiagnostic")==0) return TransientIsdiagnosticEnum;
     270              else if (strcmp(name,"TransientIsstressbalance")==0) return TransientIsstressbalanceEnum;
    271271              else if (strcmp(name,"TransientIsgroundingline")==0) return TransientIsgroundinglineEnum;
    272272              else if (strcmp(name,"TransientIsmasstransport")==0) return TransientIsmasstransportEnum;
    … …  
    292292              else if (strcmp(name,"BedSlopeXAnalysis")==0) return BedSlopeXAnalysisEnum;
    293293              else if (strcmp(name,"BedSlopeYAnalysis")==0) return BedSlopeYAnalysisEnum;
    294               else if (strcmp(name,"DiagnosticHorizAnalysis")==0) return DiagnosticHorizAnalysisEnum;
    295               else if (strcmp(name,"DiagnosticSIAAnalysis")==0) return DiagnosticSIAAnalysisEnum;
    296               else if (strcmp(name,"DiagnosticSolution")==0) return DiagnosticSolutionEnum;
    297               else if (strcmp(name,"DiagnosticVertAnalysis")==0) return DiagnosticVertAnalysisEnum;
     294              else if (strcmp(name,"StressbalanceAnalysis")==0) return StressbalanceAnalysisEnum;
     295              else if (strcmp(name,"StressbalanceSIAAnalysis")==0) return StressbalanceSIAAnalysisEnum;
     296              else if (strcmp(name,"StressbalanceSolution")==0) return StressbalanceSolutionEnum;
     297              else if (strcmp(name,"StressbalanceVerticalAnalysis")==0) return StressbalanceVerticalAnalysisEnum;
    298298              else if (strcmp(name,"EnthalpyAnalysis")==0) return EnthalpyAnalysisEnum;
    299299              else if (strcmp(name,"EnthalpySolution")==0) return EnthalpySolutionEnum;

  • issm/trunk-jpl/src/c/solutionsequences/convergence.cpp

    r15104 r15771  
    4040
    4141        /*get convergence options*/
    42         parameters->FindParam(&eps_res,DiagnosticRestolEnum);
    43         parameters->FindParam(&eps_rel,DiagnosticReltolEnum);
    44         parameters->FindParam(&eps_abs,DiagnosticAbstolEnum);
     42        parameters->FindParam(&eps_res,StressbalanceRestolEnum);
     43        parameters->FindParam(&eps_rel,StressbalanceReltolEnum);
     44        parameters->FindParam(&eps_abs,StressbalanceAbstolEnum);
    4545        parameters->FindParam(&yts,ConstantsYtsEnum);
    4646

  • issm/trunk-jpl/src/c/solutionsequences/solutionsequence_newton.cpp

    r15453 r15771  
    3333
    3434        /*Recover parameters: */
    35         femmodel->parameters->FindParam(&max_nonlinear_iterations,DiagnosticMaxiterEnum);
     35        femmodel->parameters->FindParam(&max_nonlinear_iterations,StressbalanceMaxiterEnum);
    3636        femmodel->parameters->FindParam(&configuration_type,ConfigurationTypeEnum);
    37         femmodel->parameters->FindParam(&newton,DiagnosticIsnewtonEnum);
     37        femmodel->parameters->FindParam(&newton,StressbalanceIsnewtonEnum);
    3838        femmodel->UpdateConstraintsx();
    3939

  • issm/trunk-jpl/src/c/solutionsequences/solutionsequence_nonlinear.cpp

    r15197 r15771  
    3333
    3434        /*Recover parameters: */
    35         femmodel->parameters->FindParam(&min_mechanical_constraints,DiagnosticRiftPenaltyThresholdEnum);
    36         femmodel->parameters->FindParam(&max_nonlinear_iterations,DiagnosticMaxiterEnum);
     35        femmodel->parameters->FindParam(&min_mechanical_constraints,StressbalanceRiftPenaltyThresholdEnum);
     36        femmodel->parameters->FindParam(&max_nonlinear_iterations,StressbalanceMaxiterEnum);
    3737        femmodel->parameters->FindParam(&configuration_type,ConfigurationTypeEnum);
    3838        femmodel->UpdateConstraintsx();

  • issm/trunk-jpl/src/c/solutionsequences/solutionsequence_stokescoupling_nonlinear.cpp

    r15564 r15771  
    3535
    3636        /*Recover parameters: */
    37         femmodel->parameters->FindParam(&min_mechanical_constraints,DiagnosticRiftPenaltyThresholdEnum);
    38         femmodel->parameters->FindParam(&max_nonlinear_iterations,DiagnosticMaxiterEnum);
     37        femmodel->parameters->FindParam(&min_mechanical_constraints,StressbalanceRiftPenaltyThresholdEnum);
     38        femmodel->parameters->FindParam(&max_nonlinear_iterations,StressbalanceMaxiterEnum);
    3939        femmodel->UpdateConstraintsx();
    4040
    … …  
    4343
    4444        /*First get ug_horiz:*/
    45         femmodel->SetCurrentConfiguration(DiagnosticHorizAnalysisEnum);
     45        femmodel->SetCurrentConfiguration(StressbalanceAnalysisEnum);
    4646        GetSolutionFromInputsx(&ug_horiz, femmodel->elements, femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters);
    4747        Reducevectorgtofx(&uf_horiz, ug_horiz, femmodel->nodes,femmodel->parameters);
    … …  
    4949        for(;;){
    5050
    51                 /*First diagnostic horiz:*/
    52                 femmodel->SetCurrentConfiguration(DiagnosticHorizAnalysisEnum);
     51                /*First stressbalance horiz:*/
     52                femmodel->SetCurrentConfiguration(StressbalanceAnalysisEnum);
    5353                femmodel->parameters->FindParam(&configuration_type,ConfigurationTypeEnum);
    5454
    … …  
    7171
    7272                /*Second compute vertical velocity: */
    73                 femmodel->SetCurrentConfiguration(DiagnosticVertAnalysisEnum);
     73                femmodel->SetCurrentConfiguration(StressbalanceVerticalAnalysisEnum);
    7474                femmodel->parameters->FindParam(&configuration_type,ConfigurationTypeEnum);
    7575

  • issm/trunk-jpl/src/m/boundaryconditions/SetIceSheetBC.m

    r15767 r15771  
    11function md=SetIceSheetBC(md)
    2 %SETICESHEETBC - Create the boundary conditions for diagnostic and thermal models for an IceSheet with no Ice Front
     2%SETICESHEETBC - Create the boundary conditions for stressbalance and thermal models for an IceSheet with no Ice Front
    33%
    44%   Usage:
    … …  
    99%node on Dirichlet
    1010pos=find(md.mesh.vertexonboundary);
    11 md.diagnostic.spcvx=NaN*ones(md.mesh.numberofvertices,1);
    12 md.diagnostic.spcvy=NaN*ones(md.mesh.numberofvertices,1);
    13 md.diagnostic.spcvz=NaN*ones(md.mesh.numberofvertices,1);
    14 md.diagnostic.spcvx(pos)=0;
    15 md.diagnostic.spcvy(pos)=0;
    16 md.diagnostic.spcvz(pos)=0;
    17 md.diagnostic.referential=NaN*ones(md.mesh.numberofvertices,6);
    18 md.diagnostic.loadingforce=0*ones(md.mesh.numberofvertices,3);
     11md.stressbalance.spcvx=NaN*ones(md.mesh.numberofvertices,1);
     12md.stressbalance.spcvy=NaN*ones(md.mesh.numberofvertices,1);
     13md.stressbalance.spcvz=NaN*ones(md.mesh.numberofvertices,1);
     14md.stressbalance.spcvx(pos)=0;
     15md.stressbalance.spcvy(pos)=0;
     16md.stressbalance.spcvz(pos)=0;
     17md.stressbalance.referential=NaN*ones(md.mesh.numberofvertices,6);
     18md.stressbalance.loadingforce=0*ones(md.mesh.numberofvertices,3);
    1919
    2020%Dirichlet Values
    2121if (length(md.inversion.vx_obs)==md.mesh.numberofvertices & length(md.inversion.vy_obs)==md.mesh.numberofvertices)
    22         disp('      boundary conditions for diagnostic model: spc set as observed velocities');
    23         md.diagnostic.spcvx(pos)=md.inversion.vx_obs(pos);
    24         md.diagnostic.spcvy(pos)=md.inversion.vy_obs(pos);
     22        disp('      boundary conditions for stressbalance model: spc set as observed velocities');
     23        md.stressbalance.spcvx(pos)=md.inversion.vx_obs(pos);
     24        md.stressbalance.spcvy(pos)=md.inversion.vy_obs(pos);
    2525else
    26         disp('      boundary conditions for diagnostic model: spc set as zero');
     26        disp('      boundary conditions for stressbalance model: spc set as zero');
    2727end
    2828

  • issm/trunk-jpl/src/m/boundaryconditions/SetIceSheetBC.py

    r15767 r15771  
    55def SetIceSheetBC(md):
    66        """
    7         SETICESHEETBC - Create the boundary conditions for diagnostic and thermal models for an IceSheet with no Ice Front
     7        SETICESHEETBC - Create the boundary conditions for stressbalance and thermal models for an IceSheet with no Ice Front
    88
    99           Usage:
    … …  
    1515        #node on Dirichlet
    1616        pos=numpy.nonzero(md.mesh.vertexonboundary)
    17         md.diagnostic.spcvx=float('nan')*numpy.ones((md.mesh.numberofvertices,1))
    18         md.diagnostic.spcvy=float('nan')*numpy.ones((md.mesh.numberofvertices,1))
    19         md.diagnostic.spcvz=float('nan')*numpy.ones((md.mesh.numberofvertices,1))
    20         md.diagnostic.spcvx[pos]=0
    21         md.diagnostic.spcvy[pos]=0
    22         md.diagnostic.spcvz[pos]=0
    23         md.diagnostic.referential=float('nan')*numpy.ones((md.mesh.numberofvertices,6))
    24         md.diagnostic.loadingforce=0*numpy.ones((md.mesh.numberofvertices,3))
     17        md.stressbalance.spcvx=float('nan')*numpy.ones((md.mesh.numberofvertices,1))
     18        md.stressbalance.spcvy=float('nan')*numpy.ones((md.mesh.numberofvertices,1))
     19        md.stressbalance.spcvz=float('nan')*numpy.ones((md.mesh.numberofvertices,1))
     20        md.stressbalance.spcvx[pos]=0
     21        md.stressbalance.spcvy[pos]=0
     22        md.stressbalance.spcvz[pos]=0
     23        md.stressbalance.referential=float('nan')*numpy.ones((md.mesh.numberofvertices,6))
     24        md.stressbalance.loadingforce=0*numpy.ones((md.mesh.numberofvertices,3))
    2525
    2626        #Dirichlet Values
    2727        if isinstance(md.inversion.vx_obs,numpy.ndarray) and numpy.size(md.inversion.vx_obs,axis=0)==md.mesh.numberofvertices and isinstance(md.inversion.vy_obs,numpy.ndarray) and numpy.size(md.inversion.vy_obs,axis=0)==md.mesh.numberofvertices:
    28                 print "      boundary conditions for diagnostic model: spc set as observed velocities"
    29                 md.diagnostic.spcvx[pos]=md.inversion.vx_obs[pos]
    30                 md.diagnostic.spcvy[pos]=md.inversion.vy_obs[pos]
     28                print "      boundary conditions for stressbalance model: spc set as observed velocities"
     29                md.stressbalance.spcvx[pos]=md.inversion.vx_obs[pos]
     30                md.stressbalance.spcvy[pos]=md.inversion.vy_obs[pos]
    3131        else:
    32                 print "      boundary conditions for diagnostic model: spc set as zero"
     32                print "      boundary conditions for stressbalance model: spc set as zero"
    3333
    3434        #No ice front -> do nothing

  • issm/trunk-jpl/src/m/boundaryconditions/SetIceShelfBC.m

    r15767 r15771  
    11function md=SetIceShelfBC(md,varargin)
    2 %SETICESHELFBC - Create the boundary conditions for diagnostic and thermal models for a  Ice Shelf with Ice Front
     2%SETICESHELFBC - Create the boundary conditions for stressbalance and thermal models for a  Ice Shelf with Ice Front
    33%
    44%   Neumann BC are used on the ice front (an ANRGUS contour around the ice front
    55%   must be given in input)
    6 %   Dirichlet BC are used elsewhere for diagnostic
     6%   Dirichlet BC are used elsewhere for stressbalance
    77%
    88%   Usage:
    … …  
    2828end
    2929pos=find(md.mesh.vertexonboundary & ~nodeonicefront);
    30 md.diagnostic.spcvx=NaN*ones(md.mesh.numberofvertices,1);
    31 md.diagnostic.spcvy=NaN*ones(md.mesh.numberofvertices,1);
    32 md.diagnostic.spcvz=NaN*ones(md.mesh.numberofvertices,1);
    33 md.diagnostic.spcvx(pos)=0;
    34 md.diagnostic.spcvy(pos)=0;
    35 md.diagnostic.spcvz(pos)=0;
    36 md.diagnostic.referential=NaN*ones(md.mesh.numberofvertices,6);
    37 md.diagnostic.loadingforce=0*ones(md.mesh.numberofvertices,3);
     30md.stressbalance.spcvx=NaN*ones(md.mesh.numberofvertices,1);
     31md.stressbalance.spcvy=NaN*ones(md.mesh.numberofvertices,1);
     32md.stressbalance.spcvz=NaN*ones(md.mesh.numberofvertices,1);
     33md.stressbalance.spcvx(pos)=0;
     34md.stressbalance.spcvy(pos)=0;
     35md.stressbalance.spcvz(pos)=0;
     36md.stressbalance.referential=NaN*ones(md.mesh.numberofvertices,6);
     37md.stressbalance.loadingforce=0*ones(md.mesh.numberofvertices,3);
    3838
    3939%Dirichlet Values
    4040if (length(md.inversion.vx_obs)==md.mesh.numberofvertices & length(md.inversion.vy_obs)==md.mesh.numberofvertices)
    41         disp('      boundary conditions for diagnostic model: spc set as observed velocities');
    42         md.diagnostic.spcvx(pos)=md.inversion.vx_obs(pos);
    43         md.diagnostic.spcvy(pos)=md.inversion.vy_obs(pos);
     41        disp('      boundary conditions for stressbalance model: spc set as observed velocities');
     42        md.stressbalance.spcvx(pos)=md.inversion.vx_obs(pos);
     43        md.stressbalance.spcvy(pos)=md.inversion.vy_obs(pos);
    4444else
    45         disp('      boundary conditions for diagnostic model: spc set as zero');
     45        disp('      boundary conditions for stressbalance model: spc set as zero');
    4646end
    4747

  • issm/trunk-jpl/src/m/boundaryconditions/SetIceShelfBC.py

    r15767 r15771  
    55def SetIceShelfBC(md,icefrontfile=''):
    66        """
    7         SETICESHELFBC - Create the boundary conditions for diagnostic and thermal models for a  Ice Shelf with Ice Front
     7        SETICESHELFBC - Create the boundary conditions for stressbalance and thermal models for a  Ice Shelf with Ice Front
    88
    99           Neumann BC are used on the ice front (an ARGUS contour around the ice front
    1010           must be given in input)
    11            Dirichlet BC are used elsewhere for diagnostic
     11           Dirichlet BC are used elsewhere for stressbalance
    1212
    1313           Usage:
    … …  
    3232#       pos=find(md.mesh.vertexonboundary & ~nodeonicefront);
    3333        pos=numpy.nonzero(numpy.logical_and(md.mesh.vertexonboundary,numpy.logical_not(nodeonicefront)))[0]
    34         md.diagnostic.spcvx=float('nan')*numpy.ones((md.mesh.numberofvertices,1))
    35         md.diagnostic.spcvy=float('nan')*numpy.ones((md.mesh.numberofvertices,1))
    36         md.diagnostic.spcvz=float('nan')*numpy.ones((md.mesh.numberofvertices,1))
    37         md.diagnostic.spcvx[pos]=0
    38         md.diagnostic.spcvy[pos]=0
    39         md.diagnostic.spcvz[pos]=0
    40         md.diagnostic.referential=float('nan')*numpy.ones((md.mesh.numberofvertices,6))
    41         md.diagnostic.loadingforce=0*numpy.ones((md.mesh.numberofvertices,3))
     34        md.stressbalance.spcvx=float('nan')*numpy.ones((md.mesh.numberofvertices,1))
     35        md.stressbalance.spcvy=float('nan')*numpy.ones((md.mesh.numberofvertices,1))
     36        md.stressbalance.spcvz=float('nan')*numpy.ones((md.mesh.numberofvertices,1))
     37        md.stressbalance.spcvx[pos]=0
     38        md.stressbalance.spcvy[pos]=0
     39        md.stressbalance.spcvz[pos]=0
     40        md.stressbalance.referential=float('nan')*numpy.ones((md.mesh.numberofvertices,6))
     41        md.stressbalance.loadingforce=0*numpy.ones((md.mesh.numberofvertices,3))
    4242
    4343        #Dirichlet Values
    … …  
    4848                if numpy.ndim(md.inversion.vy_obs)==1:
    4949                        md.inversion.vy_obs=md.inversion.vy_obs.reshape(-1,1)
    50                 print "      boundary conditions for diagnostic model: spc set as observed velocities"
    51                 md.diagnostic.spcvx[pos]=md.inversion.vx_obs[pos]
    52                 md.diagnostic.spcvy[pos]=md.inversion.vy_obs[pos]
     50                print "      boundary conditions for stressbalance model: spc set as observed velocities"
     51                md.stressbalance.spcvx[pos]=md.inversion.vx_obs[pos]
     52                md.stressbalance.spcvy[pos]=md.inversion.vy_obs[pos]
    5353        else:
    54                 print "      boundary conditions for diagnostic model: spc set as zero"
     54                print "      boundary conditions for stressbalance model: spc set as zero"
    5555
    5656        #Icefront position

  • issm/trunk-jpl/src/m/boundaryconditions/SetMarineIceSheetBC.m

    r15767 r15771  
    11function md=SetMarineIceSheetBC(md,varargin)
    2 %SETICEMARINESHEETBC - Create the boundary conditions for diagnostic and thermal models for a  Marine Ice Sheet with Ice Front
     2%SETICEMARINESHEETBC - Create the boundary conditions for stressbalance and thermal models for a  Marine Ice Sheet with Ice Front
    33%
    44%   Neumann BC are used on the ice front (an ARGUS contour around the ice front
    55%   can be given in input, or it will be deduced as onfloatingice & onboundary)
    6 %   Dirichlet BC are used elsewhere for diagnostic
     6%   Dirichlet BC are used elsewhere for stressbalance
    77%
    88%   Usage:
    … …  
    3535        warning('SetMarineIceSheetBC warning: ice front all around the glacier, no dirichlet found. Dirichlet must be added manually')
    3636end
    37 md.diagnostic.spcvx=NaN*ones(md.mesh.numberofvertices,1);
    38 md.diagnostic.spcvy=NaN*ones(md.mesh.numberofvertices,1);
    39 md.diagnostic.spcvz=NaN*ones(md.mesh.numberofvertices,1);
    40 md.diagnostic.spcvx(pos)=0;
    41 md.diagnostic.spcvy(pos)=0;
    42 md.diagnostic.spcvz(pos)=0;
    43 md.diagnostic.referential=NaN*ones(md.mesh.numberofvertices,6);
    44 md.diagnostic.loadingforce=0*ones(md.mesh.numberofvertices,3);
     37md.stressbalance.spcvx=NaN*ones(md.mesh.numberofvertices,1);
     38md.stressbalance.spcvy=NaN*ones(md.mesh.numberofvertices,1);
     39md.stressbalance.spcvz=NaN*ones(md.mesh.numberofvertices,1);
     40md.stressbalance.spcvx(pos)=0;
     41md.stressbalance.spcvy(pos)=0;
     42md.stressbalance.spcvz(pos)=0;
     43md.stressbalance.referential=NaN*ones(md.mesh.numberofvertices,6);
     44md.stressbalance.loadingforce=0*ones(md.mesh.numberofvertices,3);
    4545
    4646%Dirichlet Values
    4747if (length(md.inversion.vx_obs)==md.mesh.numberofvertices & length(md.inversion.vy_obs)==md.mesh.numberofvertices)
    48         disp('      boundary conditions for diagnostic model: spc set as observed velocities');
    49         md.diagnostic.spcvx(pos)=md.inversion.vx_obs(pos);
    50         md.diagnostic.spcvy(pos)=md.inversion.vy_obs(pos);
     48        disp('      boundary conditions for stressbalance model: spc set as observed velocities');
     49        md.stressbalance.spcvx(pos)=md.inversion.vx_obs(pos);
     50        md.stressbalance.spcvy(pos)=md.inversion.vy_obs(pos);
    5151else
    52         disp('      boundary conditions for diagnostic model: spc set as zero');
     52        disp('      boundary conditions for stressbalance model: spc set as zero');
    5353end
    5454

  • issm/trunk-jpl/src/m/boundaryconditions/SetMarineIceSheetBC.py

    r15767 r15771  
    55def SetMarineIceSheetBC(md,icefrontfile=''):
    66        """
    7         SETICEMARINESHEETBC - Create the boundary conditions for diagnostic and thermal models for a  Marine Ice Sheet with Ice Front
     7        SETICEMARINESHEETBC - Create the boundary conditions for stressbalance and thermal models for a  Marine Ice Sheet with Ice Front
    88
    99           Neumann BC are used on the ice front (an ARGUS contour around the ice front
    1010           can be given in input, or it will be deduced as onfloatingice & onboundary)
    11            Dirichlet BC are used elsewhere for diagnostic
     11           Dirichlet BC are used elsewhere for stressbalance
    1212
    1313           Usage:
    … …  
    4040                print "SetMarineIceSheetBC warning: ice front all around the glacier, no dirichlet found. Dirichlet must be added manually."
    4141
    42         md.diagnostic.spcvx=float('nan')*numpy.ones((md.mesh.numberofvertices,1))
    43         md.diagnostic.spcvy=float('nan')*numpy.ones((md.mesh.numberofvertices,1))
    44         md.diagnostic.spcvz=float('nan')*numpy.ones((md.mesh.numberofvertices,1))
    45         md.diagnostic.spcvx[pos]=0
    46         md.diagnostic.spcvy[pos]=0
    47         md.diagnostic.spcvz[pos]=0
    48         md.diagnostic.referential=float('nan')*numpy.ones((md.mesh.numberofvertices,6))
    49         md.diagnostic.loadingforce=0*numpy.ones((md.mesh.numberofvertices,3))
     42        md.stressbalance.spcvx=float('nan')*numpy.ones((md.mesh.numberofvertices,1))
     43        md.stressbalance.spcvy=float('nan')*numpy.ones((md.mesh.numberofvertices,1))
     44        md.stressbalance.spcvz=float('nan')*numpy.ones((md.mesh.numberofvertices,1))
     45        md.stressbalance.spcvx[pos]=0
     46        md.stressbalance.spcvy[pos]=0
     47        md.stressbalance.spcvz[pos]=0
     48        md.stressbalance.referential=float('nan')*numpy.ones((md.mesh.numberofvertices,6))
     49        md.stressbalance.loadingforce=0*numpy.ones((md.mesh.numberofvertices,3))
    5050
    5151        #Dirichlet Values
    5252        if isinstance(md.inversion.vx_obs,numpy.ndarray) and numpy.size(md.inversion.vx_obs,axis=0)==md.mesh.numberofvertices and isinstance(md.inversion.vy_obs,numpy.ndarray) and numpy.size(md.inversion.vy_obs,axis=0)==md.mesh.numberofvertices:
    53                 print "      boundary conditions for diagnostic model: spc set as observed velocities"
    54                 md.diagnostic.spcvx[pos]=md.inversion.vx_obs[pos]
    55                 md.diagnostic.spcvy[pos]=md.inversion.vy_obs[pos]
     53                print "      boundary conditions for stressbalance model: spc set as observed velocities"
     54                md.stressbalance.spcvx[pos]=md.inversion.vx_obs[pos]
     55                md.stressbalance.spcvy[pos]=md.inversion.vy_obs[pos]
    5656        else:
    57                 print "      boundary conditions for diagnostic model: spc set as zero"
     57                print "      boundary conditions for stressbalance model: spc set as zero"
    5858
    5959        md.hydrology.spcwatercolumn=numpy.zeros((md.mesh.numberofvertices,2))

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

    r15694 r15771  
    7474                function md = checkconsistency(obj,md,solution,analyses) % {{{
    7575
    76                         if ismember(DiagnosticHorizAnalysisEnum(),analyses),
     76                        if ismember(StressbalanceAnalysisEnum(),analyses),
    7777
    7878                                md = checkfield(md,'flowequation.isSIA','numel',[1],'values',[0 1]);
    … …  
    9898                                end
    9999                        end
    100                         if ismember(DiagnosticSIAAnalysisEnum(),analyses),
     100                        if ismember(StressbalanceSIAAnalysisEnum(),analyses),
    101101                                if any(obj.element_equation==1),
    102102                                        if(obj.element_equation & md.mask.elementonfloatingice),

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

    r15689 r15771  
    6161        def checkconsistency(self,md,solution,analyses):    # {{{
    6262
    63                 if DiagnosticHorizAnalysisEnum() in analyses:
     63                if StressbalanceAnalysisEnum() in analyses:
    6464                        md = checkfield(md,'flowequation.isSIA','numel',[1],'values',[0,1])
    6565                        md = checkfield(md,'flowequation.isSSA','numel',[1],'values',[0,1])
    … …  
    8282                                md.checkmessage("no element types set for this model")
    8383
    84                 if DiagnosticSIAAnalysisEnum() in analyses:
     84                if StressbalanceSIAAnalysisEnum() in analyses:
    8585                        if any(self.element_equation==1):
    8686                                if numpy.any(numpy.logical_and(self.element_equation,md.mask.elementonfloatingice)):

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

    r15131 r15771  
    2525
    2626                        %Early return
    27                         if ~ismember(DiagnosticHorizAnalysisEnum(),analyses) & ~ismember(ThermalAnalysisEnum(),analyses), return; end
     27                        if ~ismember(StressbalanceAnalysisEnum(),analyses) & ~ismember(ThermalAnalysisEnum(),analyses), return; end
    2828
    2929                        md = checkfield(md,'friction.coefficient','NaN',1,'size',[md.mesh.numberofvertices 1]);

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

    r15131 r15771  
    3535
    3636                #Early return
    37                 if DiagnosticHorizAnalysisEnum() not in analyses and ThermalAnalysisEnum() not in analyses:
     37                if StressbalanceAnalysisEnum() not in analyses and ThermalAnalysisEnum() not in analyses:
    3838                        return md
    3939

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

    r15767 r15771  
    3030                end % }}}
    3131                function md = checkconsistency(obj,md,solution,analyses) % {{{
    32                         if ismember(DiagnosticHorizAnalysisEnum(),analyses)
     32                        if ismember(StressbalanceAnalysisEnum(),analyses)
    3333                                if ~(isnan(md.initialization.vx) | isnan(md.initialization.vy)),
    3434                                        md = checkfield(md,'initialization.vx','NaN',1,'size',[md.mesh.numberofvertices 1]);

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

    r15767 r15771  
    4848        #}}}
    4949        def checkconsistency(self,md,solution,analyses):    # {{{
    50                 if DiagnosticHorizAnalysisEnum() in analyses:
     50                if StressbalanceAnalysisEnum() in analyses:
    5151                        if not numpy.any(numpy.logical_or(numpy.isnan(md.initialization.vx),numpy.isnan(md.initialization.vy))):
    5252                                md = checkfield(md,'initialization.vx','NaN',1,'size',[md.mesh.numberofvertices])

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

    r15768 r15771  
    2929
    3030                balancethickness = 0;
    31                 diagnostic       = 0;
     31                stressbalance       = 0;
    3232                groundingline    = 0;
    3333                hydrology        = 0;
    … …  
    8484                        end
    8585                        %2013 April 12
    86                         if numel(md.diagnostic.loadingforce==1)
    87                                 md.diagnostic.loadingforce=0*ones(md.mesh.numberofvertices,3);
     86                        if numel(md.stressbalance.loadingforce==1)
     87                                md.stressbalance.loadingforce=0*ones(md.mesh.numberofvertices,3);
    8888                        end
    8989                        %2013 April 17
    … …  
    9191                                disp('Recovering old hydrology class');
    9292                                md.hydrology=hydrologyshreve(md.materials);
    93                         end
    94                         %2013 July 25th
    95                         if isa(md.diagnostic,'diagnostic'),
    96                                 disp('Recovering old stressbalance class');
    97                                 icefront = md.diagnostic.icefront;
    98                                 md.diagnostic=stressbalance(md.diagnostic);
    99                                 md.mask.icelevelset=ones(md.mesh.numberofvertices,1);
    100                                 md.mask.icelevelset(icefront(:,1:end-2))=0;
    10193                        end
    10294                end% }}}
    … …  
    184176
    185177                        %boundary conditions
    186                         md.diagnostic.spcvx=project2d(md,md.diagnostic.spcvx,md.mesh.numberoflayers);
    187                         md.diagnostic.spcvy=project2d(md,md.diagnostic.spcvy,md.mesh.numberoflayers);
    188                         md.diagnostic.spcvz=project2d(md,md.diagnostic.spcvz,md.mesh.numberoflayers);
    189                         md.diagnostic.referential=project2d(md,md.diagnostic.referential,md.mesh.numberoflayers);
    190                         md.diagnostic.loadingforce=project2d(md,md.diagnostic.loadingforce,md.mesh.numberoflayers);
     178                        md.stressbalance.spcvx=project2d(md,md.stressbalance.spcvx,md.mesh.numberoflayers);
     179                        md.stressbalance.spcvy=project2d(md,md.stressbalance.spcvy,md.mesh.numberoflayers);
     180                        md.stressbalance.spcvz=project2d(md,md.stressbalance.spcvz,md.mesh.numberoflayers);
     181                        md.stressbalance.referential=project2d(md,md.stressbalance.referential,md.mesh.numberoflayers);
     182                        md.stressbalance.loadingforce=project2d(md,md.stressbalance.loadingforce,md.mesh.numberoflayers);
    191183                        md.masstransport.spcthickness=project2d(md,md.masstransport.spcthickness,md.mesh.numberoflayers);
    192184                        md.thermal.spctemperature=project2d(md,md.thermal.spctemperature,md.mesh.numberoflayers);
    … …  
    442434
    443435                        %Penalties
    444                         if ~isnan(md2.diagnostic.vertex_pairing),
    445                                 for i=1:size(md1.diagnostic.vertex_pairing,1);
    446                                         md2.diagnostic.vertex_pairing(i,:)=Pnode(md1.diagnostic.vertex_pairing(i,:));
     436                        if ~isnan(md2.stressbalance.vertex_pairing),
     437                                for i=1:size(md1.stressbalance.vertex_pairing,1);
     438                                        md2.stressbalance.vertex_pairing(i,:)=Pnode(md1.stressbalance.vertex_pairing(i,:));
    447439                                end
    448                                 md2.diagnostic.vertex_pairing=md2.diagnostic.vertex_pairing(find(md2.diagnostic.vertex_pairing(:,1)),:);
     440                                md2.stressbalance.vertex_pairing=md2.stressbalance.vertex_pairing(find(md2.stressbalance.vertex_pairing(:,1)),:);
    449441                        end
    450442                        if ~isnan(md2.masstransport.vertex_pairing),
    … …  
    480472                        nodestoflag1=intersect(orphans_node,pos_node);
    481473                        nodestoflag2=Pnode(nodestoflag1);
    482                         if numel(md1.diagnostic.spcvx)>1 & numel(md1.diagnostic.spcvy)>2 & numel(md1.diagnostic.spcvz)>2,
     474                        if numel(md1.stressbalance.spcvx)>1 & numel(md1.stressbalance.spcvy)>2 & numel(md1.stressbalance.spcvz)>2,
    483475                                if numel(md1.inversion.vx_obs)>1 & numel(md1.inversion.vy_obs)>1
    484                                         md2.diagnostic.spcvx(nodestoflag2)=md2.inversion.vx_obs(nodestoflag2);
    485                                         md2.diagnostic.spcvy(nodestoflag2)=md2.inversion.vy_obs(nodestoflag2);
     476                                        md2.stressbalance.spcvx(nodestoflag2)=md2.inversion.vx_obs(nodestoflag2);
     477                                        md2.stressbalance.spcvy(nodestoflag2)=md2.inversion.vy_obs(nodestoflag2);
    486478                                else
    487                                         md2.diagnostic.spcvx(nodestoflag2)=NaN;
    488                                         md2.diagnostic.spcvy(nodestoflag2)=NaN;
     479                                        md2.stressbalance.spcvx(nodestoflag2)=NaN;
     480                                        md2.stressbalance.spcvy(nodestoflag2)=NaN;
    489481                                        disp(' ')
    490482                                        disp('!! extract warning: spc values should be checked !!')
    … …  
    492484                                end
    493485                                %put 0 for vz
    494                                 md2.diagnostic.spcvz(nodestoflag2)=0;
     486                                md2.stressbalance.spcvz(nodestoflag2)=0;
    495487                        end
    496488                        if ~isnan(md1.thermal.spctemperature),
    … …  
    711703
    712704                        %boundary conditions
    713                         md.diagnostic.spcvx=project3d(md,'vector',md.diagnostic.spcvx,'type','node');
    714                         md.diagnostic.spcvy=project3d(md,'vector',md.diagnostic.spcvy,'type','node');
    715                         md.diagnostic.spcvz=project3d(md,'vector',md.diagnostic.spcvz,'type','node');
     705                        md.stressbalance.spcvx=project3d(md,'vector',md.stressbalance.spcvx,'type','node');
     706                        md.stressbalance.spcvy=project3d(md,'vector',md.stressbalance.spcvy,'type','node');
     707                        md.stressbalance.spcvz=project3d(md,'vector',md.stressbalance.spcvz,'type','node');
    716708                        md.thermal.spctemperature=project3d(md,'vector',md.thermal.spctemperature,'type','node','layer',md.mesh.numberoflayers,'padding',NaN);
    717709                        md.masstransport.spcthickness=project3d(md,'vector',md.masstransport.spcthickness,'type','node');
    718710                        md.balancethickness.spcthickness=project3d(md,'vector',md.balancethickness.spcthickness,'type','node');
    719                         md.diagnostic.referential=project3d(md,'vector',md.diagnostic.referential,'type','node');
    720                         md.diagnostic.loadingforce=project3d(md,'vector',md.diagnostic.loadingforce,'type','node');
     711                        md.stressbalance.referential=project3d(md,'vector',md.stressbalance.referential,'type','node');
     712                        md.stressbalance.loadingforce=project3d(md,'vector',md.stressbalance.loadingforce,'type','node');
    721713
    722714                        %connectivity
    … …  
    864856                        if isfield(structmd,'eps_rel'), md.steadystate.reltol=structmd.eps_rel; end
    865857                        if isfield(structmd,'max_steadystate_iterations'), md.steadystate.maxiter=structmd.max_steadystate_iterations; end
    866                         if isfield(structmd,'isdiagnostic'), md.transient.isdiagnostic=structmd.isdiagnostic; end
     858                        if isfield(structmd,'isdiagnostic'), md.transient.isstressbalance=structmd.isdiagnostic; end
    867859                        if isfield(structmd,'isprognostic'), md.transient.ismasstransport=structmd.isprognostic; end
    868860                        if isfield(structmd,'isthermal'), md.transient.isthermal=structmd.isthermal; end
    … …  
    929921                        if isfield(structmd,'z'), md.mesh.z=structmd.z; end
    930922                        if isfield(structmd,'mask'), md.flaim.criterion=structmd.mask; end
    931                         if isfield(structmd,'pressureload'), md.diagnostic.icefront=structmd.pressureload; end
    932                         if isfield(structmd,'diagnostic_ref'), md.diagnostic.referential=structmd.diagnostic_ref; end
     923                        if isfield(structmd,'diagnostic_ref'), md.stressbalance.referential=structmd.diagnostic_ref; end
    933924                        if isfield(structmd,'npart'); md.qmu.numberofpartitions=structmd.npart; end
    934925                        if isfield(structmd,'part'); md.qmu.partition=structmd.part; end
    … …  
    944935
    945936                        if isfield(structmd,'spcvelocity'),
    946                                 md.diagnostic.spcvx=NaN*ones(md.mesh.numberofvertices,1);
    947                                 md.diagnostic.spcvy=NaN*ones(md.mesh.numberofvertices,1);
    948                                 md.diagnostic.spcvz=NaN*ones(md.mesh.numberofvertices,1);
    949                                 pos=find(structmd.spcvelocity(:,1)); md.diagnostic.spcvx(pos)=structmd.spcvelocity(pos,4);
    950                                 pos=find(structmd.spcvelocity(:,2)); md.diagnostic.spcvy(pos)=structmd.spcvelocity(pos,5);
    951                                 pos=find(structmd.spcvelocity(:,3)); md.diagnostic.spcvz(pos)=structmd.spcvelocity(pos,6);
     937                                md.stressbalance.spcvx=NaN*ones(md.mesh.numberofvertices,1);
     938                                md.stressbalance.spcvy=NaN*ones(md.mesh.numberofvertices,1);
     939                                md.stressbalance.spcvz=NaN*ones(md.mesh.numberofvertices,1);
     940                                pos=find(structmd.spcvelocity(:,1)); md.stressbalance.spcvx(pos)=structmd.spcvelocity(pos,4);
     941                                pos=find(structmd.spcvelocity(:,2)); md.stressbalance.spcvy(pos)=structmd.spcvelocity(pos,5);
     942                                pos=find(structmd.spcvelocity(:,3)); md.stressbalance.spcvz(pos)=structmd.spcvelocity(pos,6);
    952943                        end
    953944                        if isfield(structmd,'spcvx'),
    954                                 md.diagnostic.spcvx=NaN*ones(md.mesh.numberofvertices,1);
    955                                 pos=find(~isnan(structmd.spcvx)); md.diagnostic.spcvx(pos)=structmd.spcvx(pos);
     945                                md.stressbalance.spcvx=NaN*ones(md.mesh.numberofvertices,1);
     946                                pos=find(~isnan(structmd.spcvx)); md.stressbalance.spcvx(pos)=structmd.spcvx(pos);
    956947                        end
    957948                        if isfield(structmd,'spcvy'),
    958                                 md.diagnostic.spcvy=NaN*ones(md.mesh.numberofvertices,1);
    959                                 pos=find(~isnan(structmd.spcvy)); md.diagnostic.spcvy(pos)=structmd.spcvy(pos);     
     949                                md.stressbalance.spcvy=NaN*ones(md.mesh.numberofvertices,1);
     950                                pos=find(~isnan(structmd.spcvy)); md.stressbalance.spcvy(pos)=structmd.spcvy(pos);     
    960951                        end
    961952                        if isfield(structmd,'spcvz'),
    962                                 md.diagnostic.spcvz=NaN*ones(md.mesh.numberofvertices,1);
    963                                 pos=find(~isnan(structmd.spcvz)); md.diagnostic.spcvz(pos)=structmd.spcvz(pos);     
     953                                md.stressbalance.spcvz=NaN*ones(md.mesh.numberofvertices,1);
     954                                pos=find(~isnan(structmd.spcvz)); md.stressbalance.spcvz(pos)=structmd.spcvz(pos);     
    964955                        end
    965956                        if isfield(structmd,'pressureload'),
    966957                                if ~isempty(structmd.pressureload) & ismember(structmd.pressureload(end,end),[118 119 120]),
    967                                         pos=find(structmd.pressureload(:,end)==120); md.diagnostic.icefront(pos,end)=0;
    968                                         pos=find(structmd.pressureload(:,end)==118); md.diagnostic.icefront(pos,end)=1;
    969                                         pos=find(structmd.pressureload(:,end)==119); md.diagnostic.icefront(pos,end)=2;
     958                                        pos=find(structmd.pressureload(:,end)==120); md.stressbalance.icefront(pos,end)=0;
     959                                        pos=find(structmd.pressureload(:,end)==118); md.stressbalance.icefront(pos,end)=1;
     960                                        pos=find(structmd.pressureload(:,end)==119); md.stressbalance.icefront(pos,end)=2;
    970961                                end
    971962                        end
    … …  
    10391030                                md.mesh.lowerelements(1:md.mesh.numberofelements2d)=NaN;
    10401031                        end
    1041 
    10421032                        if ~isfield(structmd,'diagnostic_ref');
    1043                                 md.diagnostic.referential=NaN*ones(md.mesh.numberofvertices,6);
     1033                                md.stressbalance.referential=NaN*ones(md.mesh.numberofvertices,6);
    10441034                        end
    10451035                        if ~isfield(structmd,'loadingforce');
    1046                                 md.diagnostic.loadingforce=0*ones(md.mesh.numberofvertices,3);
     1036                                md.stressbalance.loadingforce=0*ones(md.mesh.numberofvertices,3);
    10471037                        end
    10481038
    … …  
    10511041                                disp('Recovering old prognostic class');
    10521042                                md.masstransport=masstransport(structmd.prognostic);
     1043                        end
     1044                        %2013 August 9
     1045                        if isfield(structmd,'diagnostic') & isa(structmd.diagnostic,'diagnostic'),
     1046                                disp('Recovering old diagnostic class');
     1047                                md.stressbalance=masstransport(structmd.diagnostic);
    10531048                        end
    10541049                end% }}}
    … …  
    10751070                        md.cluster          = generic();
    10761071                        md.balancethickness = balancethickness();
    1077                         md.diagnostic       = stressbalance();
     1072                        md.stressbalance       = stressbalance();
    10781073                        md.hydrology        = hydrologyshreve();
    10791074                        md.masstransport       = masstransport();
    … …  
    11111106                        disp(sprintf('%19s: %-22s -- %s','cluster'         ,['[1x1 ' class(obj.cluster) ']'],'cluster parameters (number of cpus...)'));
    11121107                        disp(sprintf('%19s: %-22s -- %s','balancethickness',['[1x1 ' class(obj.balancethickness) ']'],'parameters for balancethickness solution'));
    1113                         disp(sprintf('%19s: %-22s -- %s','diagnostic'      ,['[1x1 ' class(obj.diagnostic) ']'],'parameters for diagnostic solution'));
     1108                        disp(sprintf('%19s: %-22s -- %s','stressbalance'      ,['[1x1 ' class(obj.stressbalance) ']'],'parameters for stressbalance solution'));
    11141109                        disp(sprintf('%19s: %-22s -- %s','groundingline'   ,['[1x1 ' class(obj.groundingline) ']'],'parameters for groundingline solution'));
    11151110                        disp(sprintf('%19s: %-22s -- %s','hydrology'       ,['[1x1 ' class(obj.hydrology) ']'],'parameters for hydrology solution'));

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

    r15767 r15771  
    7272
    7373                self.balancethickness = balancethickness()
    74                 self.diagnostic       = stressbalance()
     74                self.stressbalance       = stressbalance()
    7575                self.groundingline    = groundingline()
    7676                self.hydrology        = hydrologyshreve()
    … …  
    111111                        'cluster',\
    112112                        'balancethickness',\
    113                         'diagnostic',\
     113                        'stressbalance',\
    114114                        'groundingline',\
    115115                        'hydrology',\
    … …  
    148148                string="%s\n%s" % (string,"%19s: %-22s -- %s" % ("cluster","[%s,%s]" % ("1x1",obj.cluster.__class__.__name__),"cluster parameters (number of cpus...)"))
    149149                string="%s\n%s" % (string,"%19s: %-22s -- %s" % ("balancethickness","[%s,%s]" % ("1x1",obj.balancethickness.__class__.__name__),"parameters for balancethickness solution"))
    150                 string="%s\n%s" % (string,"%19s: %-22s -- %s" % ("diagnostic","[%s,%s]" % ("1x1",obj.diagnostic.__class__.__name__),"parameters for diagnostic solution"))
     150                string="%s\n%s" % (string,"%19s: %-22s -- %s" % ("stressbalance","[%s,%s]" % ("1x1",obj.stressbalance.__class__.__name__),"parameters for stressbalance solution"))
    151151                string="%s\n%s" % (string,"%19s: %-22s -- %s" % ("groundingline","[%s,%s]" % ("1x1",obj.groundingline.__class__.__name__),"parameters for groundingline solution"))
    152152                string="%s\n%s" % (string,"%19s: %-22s -- %s" % ("hydrology","[%s,%s]" % ("1x1",obj.hydrology.__class__.__name__),"parameters for hydrology solution"))
    … …  
    344344
    345345                #Penalties
    346                 if numpy.any(numpy.logical_not(numpy.isnan(md2.diagnostic.vertex_pairing))):
    347                         for i in xrange(numpy.size(md1.diagnostic.vertex_pairing,axis=0)):
    348                                 md2.diagnostic.vertex_pairing[i,:]=Pnode[md1.diagnostic.vertex_pairing[i,:]]
    349                         md2.diagnostic.vertex_pairing=md2.diagnostic.vertex_pairing[numpy.nonzero(md2.diagnostic.vertex_pairing[:,0])[0],:]
     346                if numpy.any(numpy.logical_not(numpy.isnan(md2.stressbalance.vertex_pairing))):
     347                        for i in xrange(numpy.size(md1.stressbalance.vertex_pairing,axis=0)):
     348                                md2.stressbalance.vertex_pairing[i,:]=Pnode[md1.stressbalance.vertex_pairing[i,:]]
     349                        md2.stressbalance.vertex_pairing=md2.stressbalance.vertex_pairing[numpy.nonzero(md2.stressbalance.vertex_pairing[:,0])[0],:]
    350350                if numpy.any(numpy.logical_not(numpy.isnan(md2.masstransport.vertex_pairing))):
    351351                        for i in xrange(numpy.size(md1.masstransport.vertex_pairing,axis=0)):
    … …  
    379379                nodestoflag1=numpy.intersect1d(orphans_node,pos_node)
    380380                nodestoflag2=Pnode[nodestoflag1].astype(int)-1
    381                 if numpy.size(md1.diagnostic.spcvx)>1 and numpy.size(md1.diagnostic.spcvy)>2 and numpy.size(md1.diagnostic.spcvz)>2:
     381                if numpy.size(md1.stressbalance.spcvx)>1 and numpy.size(md1.stressbalance.spcvy)>2 and numpy.size(md1.stressbalance.spcvz)>2:
    382382                        if numpy.size(md1.inversion.vx_obs)>1 and numpy.size(md1.inversion.vy_obs)>1:
    383                                 md2.diagnostic.spcvx[nodestoflag2]=md2.inversion.vx_obs[nodestoflag2]
    384                                 md2.diagnostic.spcvy[nodestoflag2]=md2.inversion.vy_obs[nodestoflag2]
     383                                md2.stressbalance.spcvx[nodestoflag2]=md2.inversion.vx_obs[nodestoflag2]
     384                                md2.stressbalance.spcvy[nodestoflag2]=md2.inversion.vy_obs[nodestoflag2]
    385385                        else:
    386                                 md2.diagnostic.spcvx[nodestoflag2]=float('NaN')
    387                                 md2.diagnostic.spcvy[nodestoflag2]=float('NaN')
     386                                md2.stressbalance.spcvx[nodestoflag2]=float('NaN')
     387                                md2.stressbalance.spcvy[nodestoflag2]=float('NaN')
    388388                                print "\n!! extract warning: spc values should be checked !!\n\n"
    389389                        #put 0 for vz
    390                         md2.diagnostic.spcvz[nodestoflag2]=0
     390                        md2.stressbalance.spcvz[nodestoflag2]=0
    391391                if numpy.any(numpy.logical_not(numpy.isnan(md1.thermal.spctemperature))):
    392392                        md2.thermal.spctemperature[nodestoflag2,0]=1
    … …  
    608608
    609609                #boundary conditions
    610                 md.diagnostic.spcvx=project3d(md,'vector',md.diagnostic.spcvx,'type','node')
    611                 md.diagnostic.spcvy=project3d(md,'vector',md.diagnostic.spcvy,'type','node')
    612                 md.diagnostic.spcvz=project3d(md,'vector',md.diagnostic.spcvz,'type','node')
     610                md.stressbalance.spcvx=project3d(md,'vector',md.stressbalance.spcvx,'type','node')
     611                md.stressbalance.spcvy=project3d(md,'vector',md.stressbalance.spcvy,'type','node')
     612                md.stressbalance.spcvz=project3d(md,'vector',md.stressbalance.spcvz,'type','node')
    613613                md.thermal.spctemperature=project3d(md,'vector',md.thermal.spctemperature,'type','node','layer',md.mesh.numberoflayers,'padding',float('NaN'))
    614614                md.masstransport.spcthickness=project3d(md,'vector',md.masstransport.spcthickness,'type','node')
    615615                md.balancethickness.spcthickness=project3d(md,'vector',md.balancethickness.spcthickness,'type','node')
    616                 md.diagnostic.referential=project3d(md,'vector',md.diagnostic.referential,'type','node')
    617                 md.diagnostic.loadingforce=project3d(md,'vector',md.diagnostic.loadingforce,'type','node')
     616                md.stressbalance.referential=project3d(md,'vector',md.stressbalance.referential,'type','node')
     617                md.stressbalance.loadingforce=project3d(md,'vector',md.stressbalance.loadingforce,'type','node')
    618618
    619619                #connectivity

  • issm/trunk-jpl/src/m/classes/model/planet.m

    r15767 r15771  
    3939                         md.solver           = solver();
    4040                         if ismumps(),
    41                                  md.solver           = addoptions(md.solver,DiagnosticVertAnalysisEnum(),mumpsoptions());
     41                                 md.solver           = addoptions(md.solver,StressbalanceVerticalAnalysisEnum(),mumpsoptions());
    4242                         else
    43                                  md.solver           = addoptions(md.solver,DiagnosticVertAnalysisEnum(),iluasmoptions());
     43                                 md.solver           = addoptions(md.solver,StressbalanceVerticalAnalysisEnum(),iluasmoptions());
    4444                         end
    4545                         md.cluster          = generic();
    4646                         md.balancethickness = balancethickness();
    47                          md.diagnostic       = diagnostic();
     47                         md.stressbalance       = stressbalance();
    4848                         md.hydrology        = hydrology();
    4949                         md.masstransport       = masstransport();

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

    r15767 r15771  
    214214                        %      obj=solve(obj,varargin)
    215215                        %      where varargin is a lit of paired arguments.
    216                         %      arguments can be: 'analysis_type': 'diagnostic','thermal','masstransport','transient'
     216                        %      arguments can be: 'analysis_type': 'stressbalance','thermal','masstransport','transient'
    217217                        %
    218218                        %   Examples:
    219                         %      obj=solve(obj,'analysis_type','diagnostic');
     219                        %      obj=solve(obj,'analysis_type','stressbalance');
    220220
    221221                        %recover options

  • issm/trunk-jpl/src/m/classes/oldclasses/diagnostic.m

    r15768 r15771  
    1 %DIAGNOSTIC class definition
     1%STRESSBALANCE class definition
    22%
    33%   Usage:
    4 %      diagnostic=diagnostic();
    5 
    6 classdef diagnostic
     4%      stressbalance=stressbalance();
     5
     6classdef stressbalance
    77        properties (SetAccess=public)
    88                spcvx                    = NaN;
    … …  
    4545                        end
    4646
    47                         if size(md.diagnostic.icefront,2)==3 || size(md.diagnostic.icefront,2)==5,
    48                                 front=md.diagnostic.icefront;
    49                                 md.diagnostic.icefront=[front 1*md.mask.elementonfloatingice(front(:,end))];
     47                        if size(md.stressbalance.icefront,2)==3 || size(md.stressbalance.icefront,2)==5,
     48                                front=md.stressbalance.icefront;
     49                                md.stressbalance.icefront=[front 1*md.mask.elementonfloatingice(front(:,end))];
    5050                        end
    5151                end% }}}
    5252        end
    5353        methods
    54                 function obj = diagnostic(varargin) % {{{
     54                function obj = stressbalance(varargin) % {{{
    5555                        switch nargin
    5656                                case 0
    … …  
    7777
    7878                         %coefficient to update the viscosity between each iteration of
    79                          %a diagnostic according to the following formula
     79                         %a stressbalance according to the following formula
    8080                         %viscosity(n)=viscosity(n)+viscosity_overshoot(viscosity(n)-viscosity(n-1))
    8181                         obj.viscosity_overshoot=0;
    … …  
    9393
    9494                        %Early return
    95                         if ~ismember(DiagnosticHorizAnalysisEnum(),analyses), return; end
    96                         %if ~ismember(DiagnosticHorizAnalysisEnum(),analyses) |  (solution==TransientSolutionEnum() & md.transient.isdiagnostic==0), return; end
    97 
    98                         md = checkfield(md,'diagnostic.spcvx','forcing',1);
    99                         md = checkfield(md,'diagnostic.spcvy','forcing',1);
    100                         if md.mesh.dimension==3, md = checkfield(md,'diagnostic.spcvz','forcing',1); end
    101                         md = checkfield(md,'diagnostic.restol','size',[1 1],'>',0,'NaN',1);
    102                         md = checkfield(md,'diagnostic.reltol','size',[1 1]);
    103                         md = checkfield(md,'diagnostic.abstol','size',[1 1]);
    104                         md = checkfield(md,'diagnostic.isnewton','numel',[1],'values',[0 1 2]);
    105                         md = checkfield(md,'diagnostic.FSreconditioning','size',[1 1],'NaN',1);
    106                         md = checkfield(md,'diagnostic.viscosity_overshoot','size',[1 1],'NaN',1);
     95                        if ~ismember(StressbalanceAnalysisEnum(),analyses), return; end
     96                        %if ~ismember(StressbalanceAnalysisEnum(),analyses) |  (solution==TransientSolutionEnum() & md.transient.isstressbalance==0), return; end
     97
     98                        md = checkfield(md,'stressbalance.spcvx','forcing',1);
     99                        md = checkfield(md,'stressbalance.spcvy','forcing',1);
     100                        if md.mesh.dimension==3, md = checkfield(md,'stressbalance.spcvz','forcing',1); end
     101                        md = checkfield(md,'stressbalance.restol','size',[1 1],'>',0,'NaN',1);
     102                        md = checkfield(md,'stressbalance.reltol','size',[1 1]);
     103                        md = checkfield(md,'stressbalance.abstol','size',[1 1]);
     104                        md = checkfield(md,'stressbalance.isnewton','numel',[1],'values',[0 1 2]);
     105                        md = checkfield(md,'stressbalance.FSreconditioning','size',[1 1],'NaN',1);
     106                        md = checkfield(md,'stressbalance.viscosity_overshoot','size',[1 1],'NaN',1);
    107107                        if md.mesh.dimension==2,
    108                                 md = checkfield(md,'diagnostic.icefront','size',[NaN 4],'NaN',1);
     108                                md = checkfield(md,'stressbalance.icefront','size',[NaN 4],'NaN',1);
    109109                        else
    110                                 md = checkfield(md,'diagnostic.icefront','size',[NaN 6],'NaN',1);
    111                         end
    112                         md = checkfield(md,'diagnostic.icefront(:,end)','values',[0 1 2]);
    113                         md = checkfield(md,'diagnostic.maxiter','size',[1 1],'>=',1);
    114                         md = checkfield(md,'diagnostic.referential','size',[md.mesh.numberofvertices 6]);
    115                         md = checkfield(md,'diagnostic.loadingforce','size',[md.mesh.numberofvertices 3]);
    116                         if ~isempty(md.diagnostic.requested_outputs),
    117                                 md = checkfield(md,'diagnostic.requested_outputs','size',[NaN 1]);
     110                                md = checkfield(md,'stressbalance.icefront','size',[NaN 6],'NaN',1);
     111                        end
     112                        md = checkfield(md,'stressbalance.icefront(:,end)','values',[0 1 2]);
     113                        md = checkfield(md,'stressbalance.maxiter','size',[1 1],'>=',1);
     114                        md = checkfield(md,'stressbalance.referential','size',[md.mesh.numberofvertices 6]);
     115                        md = checkfield(md,'stressbalance.loadingforce','size',[md.mesh.numberofvertices 3]);
     116                        if ~isempty(md.stressbalance.requested_outputs),
     117                                md = checkfield(md,'stressbalance.requested_outputs','size',[NaN 1]);
    118118                        end
    119119
    120120                        %singular solution
    121                         if ~(any(~isnan(md.diagnostic.spcvx)) & any(~isnan(md.diagnostic.spcvy))),
     121                        if ~(any(~isnan(md.stressbalance.spcvx)) & any(~isnan(md.stressbalance.spcvy))),
    122122                                md = checkmessage(md,['model is not well posed (singular). You need at least one node with fixed velocity!']);
    123123                        end
    124124                        %CHECK THAT EACH LINES CONTAINS ONLY NAN VALUES OR NO NAN VALUES
    125                         if any(sum(isnan(md.diagnostic.referential),2)~=0 & sum(isnan(md.diagnostic.referential),2)~=6),
    126                                 md = checkmessage(md,['Each line of diagnostic.referential should contain either only NaN values or no NaN values']);
     125                        if any(sum(isnan(md.stressbalance.referential),2)~=0 & sum(isnan(md.stressbalance.referential),2)~=6),
     126                                md = checkmessage(md,['Each line of stressbalance.referential should contain either only NaN values or no NaN values']);
    127127                        end
    128128                        %CHECK THAT THE TWO VECTORS PROVIDED ARE ORTHOGONAL
    129                         if any(sum(isnan(md.diagnostic.referential),2)==0),
    130                                 pos=find(sum(isnan(md.diagnostic.referential),2)==0);
    131                                 if any(abs(dot(md.diagnostic.referential(pos,1:3),md.diagnostic.referential(pos,4:6),2))>eps),
    132                                         md = checkmessage(md,['Vectors in diagnostic.referential (columns 1 to 3 and 4 to 6) must be orthogonal']);
     129                        if any(sum(isnan(md.stressbalance.referential),2)==0),
     130                                pos=find(sum(isnan(md.stressbalance.referential),2)==0);
     131                                if any(abs(dot(md.stressbalance.referential(pos,1:3),md.stressbalance.referential(pos,4:6),2))>eps),
     132                                        md = checkmessage(md,['Vectors in stressbalance.referential (columns 1 to 3 and 4 to 6) must be orthogonal']);
    133133                                end
    134134                        end
    … …  
    136136                        if md.mesh.dimension==3 & md.flowequation.isFS,
    137137                                pos=find(md.mask.vertexongroundedice & md.mesh.vertexonbed);
    138                                 if any(~isnan(md.diagnostic.referential(pos,:))),
     138                                if any(~isnan(md.stressbalance.referential(pos,:))),
    139139                                        md = checkmessage(md,['no referential should be specified for basal vertices of grounded ice']);
    140140                                end
    141                                 md = checkfield(md,'diagnostic.FSreconditioning','>',0);
     141                                md = checkfield(md,'stressbalance.FSreconditioning','>',0);
    142142                        end
    143143                end % }}}
    144144                function disp(obj) % {{{
    145145
    146                         disp(sprintf('   Diagnostic solution parameters:'));
     146                        disp(sprintf('   Stressbalance solution parameters:'));
    147147
    148148                        disp(sprintf('\n      %s','Convergence criteria:'));
    … …  
    204204                        pos=find(data(:,end)==1); data(pos,end)=WaterEnum();
    205205                        pos=find(data(:,end)==2); data(pos,end)=IceEnum();
    206                         WriteData(fid,'data',data,'enum',DiagnosticIcefrontEnum(),'format','DoubleMat','mattype',3);
     206                        WriteData(fid,'data',data,'enum',StressbalanceIcefrontEnum(),'format','DoubleMat','mattype',3);
    207207                end % }}}
    208208        end

  • issm/trunk-jpl/src/m/classes/qmu/@dakota_method/dakota_method.m

    r14264 r15771  
    560560                                dm.params.initial_trust_radius=-1.;
    561561                                dm.params.covariance=0;
    562                                 dm.params.regression_diagnostics=false;
     562                                dm.params.regression_stressbalances=false;
    563563                            case {'nlssol_sqp'}
    564564                                dm.type     ='lsq';

  • issm/trunk-jpl/src/m/classes/qmu/@dakota_method/dmeth_params_write.m

    r15284 r15771  
    300300                param_write(fid,sbeg,'initial_trust_radius',' = ','\n',dm.params);
    301301                param_write(fid,sbeg,'covariance','           = ','\n',dm.params);
    302                 param_write(fid,sbeg,'regression_diagnostics','','\n',dm.params);
     302                param_write(fid,sbeg,'regression_stressbalances','','\n',dm.params);
    303303
    304304            case {'nlssol_sqp'}

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

    r15131 r15771  
    3535                        end
    3636
    37                         if isnan(md.diagnostic.reltol),
    38                                 md = checkmessage(md,['for a steadystate computation, diagnostic.reltol (relative convergence criterion) must be defined!']);
     37                        if isnan(md.stressbalance.reltol),
     38                                md = checkmessage(md,['for a steadystate computation, stressbalance.reltol (relative convergence criterion) must be defined!']);
    3939                        end
    4040                end % }}}

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

    r15131 r15771  
    4848                        md.checkmessage("for a steadystate computation, timestepping.time_step must be zero.")
    4949
    50                 if numpy.isnan(md.diagnostic.reltol):
    51                         md.checkmessage("for a steadystate computation, diagnostic.reltol (relative convergence criterion) must be defined!")
     50                if numpy.isnan(md.stressbalance.reltol):
     51                        md.checkmessage("for a steadystate computation, stressbalance.reltol (relative convergence criterion) must be defined!")
    5252
    5353                return md

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

    r15621 r15771  
    7777
    7878                        %Early return
    79                         if ~ismember(DiagnosticHorizAnalysisEnum(),analyses), return; end
     79                        if ~ismember(StressbalanceAnalysisEnum(),analyses), return; end
    8080
    81                         md = checkfield(md,'diagnostic.spcvx','forcing',1);
    82                         md = checkfield(md,'diagnostic.spcvy','forcing',1);
    83                         if md.mesh.dimension==3, md = checkfield(md,'diagnostic.spcvz','forcing',1); end
    84                         md = checkfield(md,'diagnostic.restol','size',[1 1],'>',0,'NaN',1);
    85                         md = checkfield(md,'diagnostic.reltol','size',[1 1]);
    86                         md = checkfield(md,'diagnostic.abstol','size',[1 1]);
    87                         md = checkfield(md,'diagnostic.isnewton','numel',[1],'values',[0 1 2]);
    88                         md = checkfield(md,'diagnostic.FSreconditioning','size',[1 1],'NaN',1);
    89                         md = checkfield(md,'diagnostic.viscosity_overshoot','size',[1 1],'NaN',1);
    90                         md = checkfield(md,'diagnostic.maxiter','size',[1 1],'>=',1);
    91                         md = checkfield(md,'diagnostic.referential','size',[md.mesh.numberofvertices 6]);
    92                         md = checkfield(md,'diagnostic.loadingforce','size',[md.mesh.numberofvertices 3]);
    93                         if ~isempty(md.diagnostic.requested_outputs),
    94                                 md = checkfield(md,'diagnostic.requested_outputs','size',[NaN 1]);
     81                        md = checkfield(md,'stressbalance.spcvx','forcing',1);
     82                        md = checkfield(md,'stressbalance.spcvy','forcing',1);
     83                        if md.mesh.dimension==3, md = checkfield(md,'stressbalance.spcvz','forcing',1); end
     84                        md = checkfield(md,'stressbalance.restol','size',[1 1],'>',0,'NaN',1);
     85                        md = checkfield(md,'stressbalance.reltol','size',[1 1]);
     86                        md = checkfield(md,'stressbalance.abstol','size',[1 1]);
     87                        md = checkfield(md,'stressbalance.isnewton','numel',[1],'values',[0 1 2]);
     88                        md = checkfield(md,'stressbalance.FSreconditioning','size',[1 1],'NaN',1);
     89                        md = checkfield(md,'stressbalance.viscosity_overshoot','size',[1 1],'NaN',1);
     90                        md = checkfield(md,'stressbalance.maxiter','size',[1 1],'>=',1);
     91                        md = checkfield(md,'stressbalance.referential','size',[md.mesh.numberofvertices 6]);
     92                        md = checkfield(md,'stressbalance.loadingforce','size',[md.mesh.numberofvertices 3]);
     93                        if ~isempty(md.stressbalance.requested_outputs),
     94                                md = checkfield(md,'stressbalance.requested_outputs','size',[NaN 1]);
    9595                        end
    9696
    9797                        %singular solution
    98                         if ~(any(~isnan(md.diagnostic.spcvx)) & any(~isnan(md.diagnostic.spcvy))),
     98                        if ~(any(~isnan(md.stressbalance.spcvx)) & any(~isnan(md.stressbalance.spcvy))),
    9999                                md = checkmessage(md,['model is not well posed (singular). You need at least one node with fixed velocity!']);
    100100                        end
    101101                        %CHECK THAT EACH LINES CONTAINS ONLY NAN VALUES OR NO NAN VALUES
    102                         if any(sum(isnan(md.diagnostic.referential),2)~=0 & sum(isnan(md.diagnostic.referential),2)~=6),
    103                                 md = checkmessage(md,['Each line of diagnostic.referential should contain either only NaN values or no NaN values']);
     102                        if any(sum(isnan(md.stressbalance.referential),2)~=0 & sum(isnan(md.stressbalance.referential),2)~=6),
     103                                md = checkmessage(md,['Each line of stressbalance.referential should contain either only NaN values or no NaN values']);
    104104                        end
    105105                        %CHECK THAT THE TWO VECTORS PROVIDED ARE ORTHOGONAL
    106                         if any(sum(isnan(md.diagnostic.referential),2)==0),
    107                                 pos=find(sum(isnan(md.diagnostic.referential),2)==0);
    108                                 if any(abs(dot(md.diagnostic.referential(pos,1:3),md.diagnostic.referential(pos,4:6),2))>eps),
    109                                         md = checkmessage(md,['Vectors in diagnostic.referential (columns 1 to 3 and 4 to 6) must be orthogonal']);
     106                        if any(sum(isnan(md.stressbalance.referential),2)==0),
     107                                pos=find(sum(isnan(md.stressbalance.referential),2)==0);
     108                                if any(abs(dot(md.stressbalance.referential(pos,1:3),md.stressbalance.referential(pos,4:6),2))>eps),
     109                                        md = checkmessage(md,['Vectors in stressbalance.referential (columns 1 to 3 and 4 to 6) must be orthogonal']);
    110110                                end
    111111                        end
    … …  
    113113                        if md.mesh.dimension==3 & md.flowequation.isFS,
    114114                                pos=find(md.mask.vertexongroundedice & md.mesh.vertexonbed);
    115                                 if any(~isnan(md.diagnostic.referential(pos,:))),
     115                                if any(~isnan(md.stressbalance.referential(pos,:))),
    116116                                        md = checkmessage(md,['no referential should be specified for basal vertices of grounded ice']);
    117117                                end
    118                                 md = checkfield(md,'diagnostic.FSreconditioning','>',0);
     118                                md = checkfield(md,'stressbalance.FSreconditioning','>',0);
    119119                        end
    120120                end % }}}
    … …  
    156156                        yts=365.0*24.0*3600.0;
    157157
    158                         WriteData(fid,'object',obj,'class','diagnostic','fieldname','spcvx','format','DoubleMat','mattype',1,'scale',1./yts,'forcinglength',md.mesh.numberofvertices+1);
    159                         WriteData(fid,'object',obj,'class','diagnostic','fieldname','spcvy','format','DoubleMat','mattype',1,'scale',1./yts,'forcinglength',md.mesh.numberofvertices+1);
    160                         WriteData(fid,'object',obj,'class','diagnostic','fieldname','spcvz','format','DoubleMat','mattype',1,'scale',1./yts,'forcinglength',md.mesh.numberofvertices+1);
    161                         WriteData(fid,'object',obj,'class','diagnostic','fieldname','restol','format','Double');
    162                         WriteData(fid,'object',obj,'class','diagnostic','fieldname','reltol','format','Double');
    163                         WriteData(fid,'object',obj,'class','diagnostic','fieldname','abstol','format','Double');
    164                         WriteData(fid,'object',obj,'class','diagnostic','fieldname','isnewton','format','Integer');
    165                         WriteData(fid,'object',obj,'class','diagnostic','fieldname','FSreconditioning','format','Double');
    166                         WriteData(fid,'object',obj,'class','diagnostic','fieldname','viscosity_overshoot','format','Double');
    167                         WriteData(fid,'object',obj,'class','diagnostic','fieldname','maxiter','format','Integer');
    168                         WriteData(fid,'object',obj,'class','diagnostic','fieldname','shelf_dampening','format','Integer');
    169                         WriteData(fid,'object',obj,'class','diagnostic','fieldname','vertex_pairing','format','DoubleMat','mattype',3);
    170                         WriteData(fid,'object',obj,'class','diagnostic','fieldname','penalty_factor','format','Double');
    171                         WriteData(fid,'object',obj,'class','diagnostic','fieldname','rift_penalty_lock','format','Integer');
    172                         WriteData(fid,'object',obj,'class','diagnostic','fieldname','rift_penalty_threshold','format','Integer');
    173                         WriteData(fid,'object',obj,'class','diagnostic','fieldname','referential','format','DoubleMat','mattype',1);
    174                         WriteData(fid,'object',obj,'class','diagnostic','fieldname','requested_outputs','format','DoubleMat','mattype',3);
     158                        WriteData(fid,'object',obj,'class','stressbalance','fieldname','spcvx','format','DoubleMat','mattype',1,'scale',1./yts,'forcinglength',md.mesh.numberofvertices+1);
     159                        WriteData(fid,'object',obj,'class','stressbalance','fieldname','spcvy','format','DoubleMat','mattype',1,'scale',1./yts,'forcinglength',md.mesh.numberofvertices+1);
     160                        WriteData(fid,'object',obj,'class','stressbalance','fieldname','spcvz','format','DoubleMat','mattype',1,'scale',1./yts,'forcinglength',md.mesh.numberofvertices+1);
     161                        WriteData(fid,'object',obj,'class','stressbalance','fieldname','restol','format','Double');
     162                        WriteData(fid,'object',obj,'class','stressbalance','fieldname','reltol','format','Double');
     163                        WriteData(fid,'object',obj,'class','stressbalance','fieldname','abstol','format','Double');
     164                        WriteData(fid,'object',obj,'class','stressbalance','fieldname','isnewton','format','Integer');
     165                        WriteData(fid,'object',obj,'class','stressbalance','fieldname','FSreconditioning','format','Double');
     166                        WriteData(fid,'object',obj,'class','stressbalance','fieldname','viscosity_overshoot','format','Double');
     167                        WriteData(fid,'object',obj,'class','stressbalance','fieldname','maxiter','format','Integer');
     168                        WriteData(fid,'object',obj,'class','stressbalance','fieldname','shelf_dampening','format','Integer');
     169                        WriteData(fid,'object',obj,'class','stressbalance','fieldname','vertex_pairing','format','DoubleMat','mattype',3);
     170                        WriteData(fid,'object',obj,'class','stressbalance','fieldname','penalty_factor','format','Double');
     171                        WriteData(fid,'object',obj,'class','stressbalance','fieldname','rift_penalty_lock','format','Integer');
     172                        WriteData(fid,'object',obj,'class','stressbalance','fieldname','rift_penalty_threshold','format','Integer');
     173                        WriteData(fid,'object',obj,'class','stressbalance','fieldname','referential','format','DoubleMat','mattype',1);
     174                        WriteData(fid,'object',obj,'class','stressbalance','fieldname','requested_outputs','format','DoubleMat','mattype',3);
    175175                        WriteData(fid,'data',obj.loadingforce(:,1),'format','DoubleMat','mattype',1,'enum',LoadingforceXEnum);
    176176                        WriteData(fid,'data',obj.loadingforce(:,2),'format','DoubleMat','mattype',1,'enum',LoadingforceYEnum);

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

    r15621 r15771  
    107107
    108108                #Early return
    109                 if DiagnosticHorizAnalysisEnum() not in analyses:
     109                if StressbalanceAnalysisEnum() not in analyses:
    110110                        return md
    111111
    112                 md = checkfield(md,'diagnostic.spcvx','forcing',1)
    113                 md = checkfield(md,'diagnostic.spcvy','forcing',1)
     112                md = checkfield(md,'stressbalance.spcvx','forcing',1)
     113                md = checkfield(md,'stressbalance.spcvy','forcing',1)
    114114                if md.mesh.dimension==3:
    115                         md = checkfield(md,'diagnostic.spcvz','forcing',1)
    116                 md = checkfield(md,'diagnostic.restol','size',[1],'>',0)
    117                 md = checkfield(md,'diagnostic.reltol','size',[1])
    118                 md = checkfield(md,'diagnostic.abstol','size',[1])
    119                 md = checkfield(md,'diagnostic.isnewton','numel',[1],'values',[0,1,2])
    120                 md = checkfield(md,'diagnostic.FSreconditioning','size',[1],'NaN',1)
    121                 md = checkfield(md,'diagnostic.viscosity_overshoot','size',[1],'NaN',1)
    122                 md = checkfield(md,'diagnostic.maxiter','size',[1],'>=',1)
    123                 md = checkfield(md,'diagnostic.referential','size',[md.mesh.numberofvertices,6])
    124                 md = checkfield(md,'diagnostic.loadingforce','size',[md.mesh.numberofvertices,3])
    125                 if not md.diagnostic.requested_outputs:
    126                         md = checkfield(md,'diagnostic.requested_outputs','size',[float('NaN'),1])
     115                        md = checkfield(md,'stressbalance.spcvz','forcing',1)
     116                md = checkfield(md,'stressbalance.restol','size',[1],'>',0)
     117                md = checkfield(md,'stressbalance.reltol','size',[1])
     118                md = checkfield(md,'stressbalance.abstol','size',[1])
     119                md = checkfield(md,'stressbalance.isnewton','numel',[1],'values',[0,1,2])
     120                md = checkfield(md,'stressbalance.FSreconditioning','size',[1],'NaN',1)
     121                md = checkfield(md,'stressbalance.viscosity_overshoot','size',[1],'NaN',1)
     122                md = checkfield(md,'stressbalance.maxiter','size',[1],'>=',1)
     123                md = checkfield(md,'stressbalance.referential','size',[md.mesh.numberofvertices,6])
     124                md = checkfield(md,'stressbalance.loadingforce','size',[md.mesh.numberofvertices,3])
     125                if not md.stressbalance.requested_outputs:
     126                        md = checkfield(md,'stressbalance.requested_outputs','size',[float('NaN'),1])
    127127
    128128                #singular solution
    129 #               if ~any((~isnan(md.diagnostic.spcvx)+~isnan(md.diagnostic.spcvy))==2),
    130                 if not numpy.any(numpy.logical_and(numpy.logical_not(numpy.isnan(md.diagnostic.spcvx)),numpy.logical_not(numpy.isnan(md.diagnostic.spcvy)))):
     129#               if ~any((~isnan(md.stressbalance.spcvx)+~isnan(md.stressbalance.spcvy))==2),
     130                if not numpy.any(numpy.logical_and(numpy.logical_not(numpy.isnan(md.stressbalance.spcvx)),numpy.logical_not(numpy.isnan(md.stressbalance.spcvy)))):
    131131                        md.checkmessage("model is not well posed (singular). You need at least one node with fixed velocity!")
    132132                #CHECK THAT EACH LINES CONTAINS ONLY NAN VALUES OR NO NAN VALUES
    133 #               if any(sum(isnan(md.diagnostic.referential),2)~=0 & sum(isnan(md.diagnostic.referential),2)~=6),
    134                 if numpy.any(numpy.logical_and(numpy.sum(numpy.isnan(md.diagnostic.referential),axis=1)!=0,numpy.sum(numpy.isnan(md.diagnostic.referential),axis=1)!=6)):
    135                         md.checkmessage("Each line of diagnostic.referential should contain either only NaN values or no NaN values")
     133#               if any(sum(isnan(md.stressbalance.referential),2)~=0 & sum(isnan(md.stressbalance.referential),2)~=6),
     134                if numpy.any(numpy.logical_and(numpy.sum(numpy.isnan(md.stressbalance.referential),axis=1)!=0,numpy.sum(numpy.isnan(md.stressbalance.referential),axis=1)!=6)):
     135                        md.checkmessage("Each line of stressbalance.referential should contain either only NaN values or no NaN values")
    136136                #CHECK THAT THE TWO VECTORS PROVIDED ARE ORTHOGONAL
    137 #               if any(sum(isnan(md.diagnostic.referential),2)==0),
    138                 if numpy.any(numpy.sum(numpy.isnan(md.diagnostic.referential),axis=1)==0):
    139                         pos=[i for i,item in enumerate(numpy.sum(numpy.isnan(md.diagnostic.referential),axis=1)) if item==0]
     137#               if any(sum(isnan(md.stressbalance.referential),2)==0),
     138                if numpy.any(numpy.sum(numpy.isnan(md.stressbalance.referential),axis=1)==0):
     139                        pos=[i for i,item in enumerate(numpy.sum(numpy.isnan(md.stressbalance.referential),axis=1)) if item==0]
    140140#                       numpy.inner (and numpy.dot) calculate all the dot product permutations, resulting in a full matrix multiply
    141 #                       if numpy.any(numpy.abs(numpy.inner(md.diagnostic.referential[pos,0:2],md.diagnostic.referential[pos,3:5]).diagonal())>sys.float_info.epsilon):
    142 #                               md.checkmessage("Vectors in diagnostic.referential (columns 1 to 3 and 4 to 6) must be orthogonal")
    143                         for item in md.diagnostic.referential[pos,:]:
     141#                       if numpy.any(numpy.abs(numpy.inner(md.stressbalance.referential[pos,0:2],md.stressbalance.referential[pos,3:5]).diagonal())>sys.float_info.epsilon):
     142#                               md.checkmessage("Vectors in stressbalance.referential (columns 1 to 3 and 4 to 6) must be orthogonal")
     143                        for item in md.stressbalance.referential[pos,:]:
    144144                                if numpy.abs(numpy.inner(item[0:2],item[3:5]))>sys.float_info.epsilon:
    145                                         md.checkmessage("Vectors in diagnostic.referential (columns 1 to 3 and 4 to 6) must be orthogonal")
     145                                        md.checkmessage("Vectors in stressbalance.referential (columns 1 to 3 and 4 to 6) must be orthogonal")
    146146                #CHECK THAT NO rotation specified for FS Grounded ice at base
    147147#               if md.mesh.dimension==3 & md.flowequation.isFS,
    148148                if md.mesh.dimension==3 and md.flowequation.isFS:
    149149                        pos=numpy.nonzero(numpy.logical_and(md.mask.vertexongroundedice,md.mesh.vertexonbed))
    150                         if numpy.any(numpy.logical_not(numpy.isnan(md.diagnostic.referential[pos,:]))):
     150                        if numpy.any(numpy.logical_not(numpy.isnan(md.stressbalance.referential[pos,:]))):
    151151                                md.checkmessage("no referential should be specified for basal vertices of grounded ice")
    152152
    … …  
    157157                yts=365.0*24.0*3600.0
    158158
    159                 WriteData(fid,'object',self,'class','diagnostic','fieldname','spcvx','format','DoubleMat','mattype',1,'scale',1./yts,'forcinglength',md.mesh.numberofvertices+1)
    160                 WriteData(fid,'object',self,'class','diagnostic','fieldname','spcvy','format','DoubleMat','mattype',1,'scale',1./yts,'forcinglength',md.mesh.numberofvertices+1)
    161                 WriteData(fid,'object',self,'class','diagnostic','fieldname','spcvz','format','DoubleMat','mattype',1,'scale',1./yts,'forcinglength',md.mesh.numberofvertices+1)
    162                 WriteData(fid,'object',self,'class','diagnostic','fieldname','restol','format','Double')
    163                 WriteData(fid,'object',self,'class','diagnostic','fieldname','reltol','format','Double')
    164                 WriteData(fid,'object',self,'class','diagnostic','fieldname','abstol','format','Double')
    165                 WriteData(fid,'object',self,'class','diagnostic','fieldname','isnewton','format','Integer')
    166                 WriteData(fid,'object',self,'class','diagnostic','fieldname','FSreconditioning','format','Double')
    167                 WriteData(fid,'object',self,'class','diagnostic','fieldname','viscosity_overshoot','format','Double')
    168                 WriteData(fid,'object',self,'class','diagnostic','fieldname','maxiter','format','Integer')
    169                 WriteData(fid,'object',self,'class','diagnostic','fieldname','shelf_dampening','format','Integer')
    170                 WriteData(fid,'object',self,'class','diagnostic','fieldname','vertex_pairing','format','DoubleMat','mattype',3)
    171                 WriteData(fid,'object',self,'class','diagnostic','fieldname','penalty_factor','format','Double')
    172                 WriteData(fid,'object',self,'class','diagnostic','fieldname','rift_penalty_lock','format','Integer')
    173                 WriteData(fid,'object',self,'class','diagnostic','fieldname','rift_penalty_threshold','format','Integer')
    174                 WriteData(fid,'object',self,'class','diagnostic','fieldname','referential','format','DoubleMat','mattype',1)
    175                 WriteData(fid,'object',self,'class','diagnostic','fieldname','requested_outputs','format','DoubleMat','mattype',3)
     159                WriteData(fid,'object',self,'class','stressbalance','fieldname','spcvx','format','DoubleMat','mattype',1,'scale',1./yts,'forcinglength',md.mesh.numberofvertices+1)
     160                WriteData(fid,'object',self,'class','stressbalance','fieldname','spcvy','format','DoubleMat','mattype',1,'scale',1./yts,'forcinglength',md.mesh.numberofvertices+1)
     161                WriteData(fid,'object',self,'class','stressbalance','fieldname','spcvz','format','DoubleMat','mattype',1,'scale',1./yts,'forcinglength',md.mesh.numberofvertices+1)
     162                WriteData(fid,'object',self,'class','stressbalance','fieldname','restol','format','Double')
     163                WriteData(fid,'object',self,'class','stressbalance','fieldname','reltol','format','Double')
     164                WriteData(fid,'object',self,'class','stressbalance','fieldname','abstol','format','Double')
     165                WriteData(fid,'object',self,'class','stressbalance','fieldname','isnewton','format','Integer')
     166                WriteData(fid,'object',self,'class','stressbalance','fieldname','FSreconditioning','format','Double')
     167                WriteData(fid,'object',self,'class','stressbalance','fieldname','viscosity_overshoot','format','Double')
     168                WriteData(fid,'object',self,'class','stressbalance','fieldname','maxiter','format','Integer')
     169                WriteData(fid,'object',self,'class','stressbalance','fieldname','shelf_dampening','format','Integer')
     170                WriteData(fid,'object',self,'class','stressbalance','fieldname','vertex_pairing','format','DoubleMat','mattype',3)
     171                WriteData(fid,'object',self,'class','stressbalance','fieldname','penalty_factor','format','Double')
     172                WriteData(fid,'object',self,'class','stressbalance','fieldname','rift_penalty_lock','format','Integer')
     173                WriteData(fid,'object',self,'class','stressbalance','fieldname','rift_penalty_threshold','format','Integer')
     174                WriteData(fid,'object',self,'class','stressbalance','fieldname','referential','format','DoubleMat','mattype',1)
     175                WriteData(fid,'object',self,'class','stressbalance','fieldname','requested_outputs','format','DoubleMat','mattype',3)
    176176                WriteData(fid,'data',self.loadingforce[:,0],'format','DoubleMat','mattype',1,'enum',LoadingforceXEnum())
    177177                WriteData(fid,'data',self.loadingforce[:,1],'format','DoubleMat','mattype',1,'enum',LoadingforceYEnum())

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

    r15564 r15771  
    2222                 function obj = addoptions(obj,analysis,varargin) % {{{
    2323                 % Usage example:
    24                  %    md.toolkits=addoptions(md.toolkits,DiagnosticHorizAnalysisEnum(),FSoptions());
    25                  %    md.toolkits=addoptions(md.toolkits,DiagnosticHorizAnalysisEnum());
     24                 %    md.toolkits=addoptions(md.toolkits,StressbalanceAnalysisEnum(),FSoptions());
     25                 %    md.toolkits=addoptions(md.toolkits,StressbalanceAnalysisEnum());
    2626
    2727                         %Convert analysis from enum to string

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

    r15564 r15771  
    3939        def addoptions(self,analysis,*args):    # {{{
    4040                # Usage example:
    41                 #    md.toolkits=addoptions(md.toolkits,DiagnosticHorizAnalysisEnum(),FSoptions());
    42                 #    md.toolkits=addoptions(md.toolkits,DiagnosticHorizAnalysisEnum());
     41                #    md.toolkits=addoptions(md.toolkits,StressbalanceAnalysisEnum(),FSoptions());
     42                #    md.toolkits=addoptions(md.toolkits,StressbalanceAnalysisEnum());
    4343
    4444                #Convert analysis from enum to string

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

    r15767 r15771  
    77        properties (SetAccess=public)
    88                ismasstransport      = 0;
    9                 isdiagnostic      = 0;
     9                isstressbalance      = 0;
    1010                isthermal         = 0;
    1111                isgroundingline   = 0;
    … …  
    2424                function obj = setdefaultparameters(obj) % {{{
    2525
    26                         %full analysis: Diagnostic, Masstransport and Thermal but no groundingline migration for now
     26                        %full analysis: Stressbalance, Masstransport and Thermal but no groundingline migration for now
    2727                        obj.ismasstransport=1;
    28                         obj.isdiagnostic=1;
     28                        obj.isstressbalance=1;
    2929                        obj.isthermal=1;
    3030                        obj.isgroundingline=0;
    … …  
    3838
    3939                        md = checkfield(md,'transient.ismasstransport','numel',[1],'values',[0 1]);
    40                         md = checkfield(md,'transient.isdiagnostic','numel',[1],'values',[0 1]);
     40                        md = checkfield(md,'transient.isstressbalance','numel',[1],'values',[0 1]);
    4141                        md = checkfield(md,'transient.isthermal','numel',[1],'values',[0 1]);
    4242                        md = checkfield(md,'transient.isgroundingline','numel',[1],'values',[0 1]);
    … …  
    4949
    5050                        fielddisplay(obj,'ismasstransport','indicates if a masstransport solution is used in the transient');
    51                         fielddisplay(obj,'isdiagnostic','indicates if a diagnostic solution is used in the transient');
     51                        fielddisplay(obj,'isstressbalance','indicates if a stressbalance solution is used in the transient');
    5252                        fielddisplay(obj,'isthermal','indicates if a thermal solution is used in the transient');
    5353                        fielddisplay(obj,'isgroundingline','indicates if a groundingline migration is used in the transient');
    … …  
    5858                function marshall(obj,md,fid) % {{{
    5959                        WriteData(fid,'object',obj,'fieldname','ismasstransport','format','Boolean');
    60                         WriteData(fid,'object',obj,'fieldname','isdiagnostic','format','Boolean');
     60                        WriteData(fid,'object',obj,'fieldname','isstressbalance','format','Boolean');
    6161                        WriteData(fid,'object',obj,'fieldname','isthermal','format','Boolean');
    6262                        WriteData(fid,'object',obj,'fieldname','isgroundingline','format','Boolean');

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

    r15767 r15771  
    1414        def __init__(self): # {{{
    1515                self.ismasstransport      = False
    16                 self.isdiagnostic      = False
     16                self.isstressbalance      = False
    1717                self.isthermal         = False
    1818                self.isgroundingline   = False
    … …  
    2727                string='   transient solution parameters:'
    2828                string="%s\n%s"%(string,fielddisplay(self,'ismasstransport','indicates if a masstransport solution is used in the transient'))
    29                 string="%s\n%s"%(string,fielddisplay(self,'isdiagnostic','indicates if a diagnostic solution is used in the transient'))
     29                string="%s\n%s"%(string,fielddisplay(self,'isstressbalance','indicates if a stressbalance solution is used in the transient'))
    3030                string="%s\n%s"%(string,fielddisplay(self,'isthermal','indicates if a thermal solution is used in the transient'))
    3131                string="%s\n%s"%(string,fielddisplay(self,'isgroundingline','indicates if a groundingline migration is used in the transient'))
    … …  
    3636        def setdefaultparameters(self): # {{{
    3737               
    38                 #full analysis: Diagnostic, Masstransport and Thermal but no groundingline migration for now
     38                #full analysis: Stressbalance, Masstransport and Thermal but no groundingline migration for now
    3939                self.ismasstransport=True
    40                 self.isdiagnostic=True
     40                self.isstressbalance=True
    4141                self.isthermal=True
    4242                self.isgroundingline=False
    … …  
    5252
    5353                md = checkfield(md,'transient.ismasstransport','numel',[1],'values',[0,1])
    54                 md = checkfield(md,'transient.isdiagnostic','numel',[1],'values',[0,1])
     54                md = checkfield(md,'transient.isstressbalance','numel',[1],'values',[0,1])
    5555                md = checkfield(md,'transient.isthermal','numel',[1],'values',[0,1])
    5656                md = checkfield(md,'transient.isgroundingline','numel',[1],'values',[0,1])
    … …  
    6363        def marshall(self,md,fid):    # {{{
    6464                WriteData(fid,'object',self,'fieldname','ismasstransport','format','Boolean')
    65                 WriteData(fid,'object',self,'fieldname','isdiagnostic','format','Boolean')
     65                WriteData(fid,'object',self,'fieldname','isstressbalance','format','Boolean')
    6666                WriteData(fid,'object',self,'fieldname','isthermal','format','Boolean')
    6767                WriteData(fid,'object',self,'fieldname','isgroundingline','format','Boolean')

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

    r15767 r15771  
    4545switch solutiontype,
    4646
    47         case DiagnosticSolutionEnum(),
     47        case StressbalanceSolutionEnum(),
    4848                numanalyses=5;
    49                 analyses=[DiagnosticHorizAnalysisEnum();DiagnosticVertAnalysisEnum();DiagnosticSIAAnalysisEnum();SurfaceSlopeAnalysisEnum();BedSlopeAnalysisEnum()];
     49                analyses=[StressbalanceAnalysisEnum();StressbalanceVerticalAnalysisEnum();StressbalanceSIAAnalysisEnum();SurfaceSlopeAnalysisEnum();BedSlopeAnalysisEnum()];
    5050
    5151        case SteadystateSolutionEnum(),
    5252                numanalyses=7;
    53                 analyses=[DiagnosticHorizAnalysisEnum();DiagnosticVertAnalysisEnum();DiagnosticSIAAnalysisEnum();SurfaceSlopeAnalysisEnum();BedSlopeAnalysisEnum();ThermalAnalysisEnum();MeltingAnalysisEnum()];
     53                analyses=[StressbalanceAnalysisEnum();StressbalanceVerticalAnalysisEnum();StressbalanceSIAAnalysisEnum();SurfaceSlopeAnalysisEnum();BedSlopeAnalysisEnum();ThermalAnalysisEnum();MeltingAnalysisEnum()];
    5454
    5555        case ThermalSolutionEnum(),
    … …  
    8787        case TransientSolutionEnum(),
    8888                numanalyses=9;
    89                 analyses=[DiagnosticHorizAnalysisEnum();DiagnosticVertAnalysisEnum();DiagnosticSIAAnalysisEnum();SurfaceSlopeAnalysisEnum();BedSlopeAnalysisEnum();ThermalAnalysisEnum();MeltingAnalysisEnum();EnthalpyAnalysisEnum();MasstransportAnalysisEnum()];
     89                analyses=[StressbalanceAnalysisEnum();StressbalanceVerticalAnalysisEnum();StressbalanceSIAAnalysisEnum();SurfaceSlopeAnalysisEnum();BedSlopeAnalysisEnum();ThermalAnalysisEnum();MeltingAnalysisEnum();EnthalpyAnalysisEnum();MasstransportAnalysisEnum()];
    9090
    9191        case FlaimSolutionEnum(),

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

    r15767 r15771  
    1010        """
    1111
    12         if   solutiontype == DiagnosticSolutionEnum():
     12        if   solutiontype == StressbalanceSolutionEnum():
    1313                numanalyses=5
    14                 analyses=[DiagnosticHorizAnalysisEnum(),DiagnosticVertAnalysisEnum(),DiagnosticSIAAnalysisEnum(),SurfaceSlopeAnalysisEnum(),BedSlopeAnalysisEnum()]
     14                analyses=[StressbalanceAnalysisEnum(),StressbalanceVerticalAnalysisEnum(),StressbalanceSIAAnalysisEnum(),SurfaceSlopeAnalysisEnum(),BedSlopeAnalysisEnum()]
    1515
    1616        elif solutiontype == SteadystateSolutionEnum():
    1717                numanalyses=7
    18                 analyses=[DiagnosticHorizAnalysisEnum(),DiagnosticVertAnalysisEnum(),DiagnosticSIAAnalysisEnum(),SurfaceSlopeAnalysisEnum(),BedSlopeAnalysisEnum(),ThermalAnalysisEnum(),MeltingAnalysisEnum()]
     18                analyses=[StressbalanceAnalysisEnum(),StressbalanceVerticalAnalysisEnum(),StressbalanceSIAAnalysisEnum(),SurfaceSlopeAnalysisEnum(),BedSlopeAnalysisEnum(),ThermalAnalysisEnum(),MeltingAnalysisEnum()]
    1919
    2020        elif solutiontype == ThermalSolutionEnum():
    … …  
    4848        elif solutiontype == TransientSolutionEnum():
    4949                numanalyses=9
    50                 analyses=[DiagnosticHorizAnalysisEnum(),DiagnosticVertAnalysisEnum(),DiagnosticSIAAnalysisEnum(),SurfaceSlopeAnalysisEnum(),BedSlopeAnalysisEnum(),ThermalAnalysisEnum(),MeltingAnalysisEnum(),EnthalpyAnalysisEnum(),MasstransportAnalysisEnum()]
     50                analyses=[StressbalanceAnalysisEnum(),StressbalanceVerticalAnalysisEnum(),StressbalanceSIAAnalysisEnum(),SurfaceSlopeAnalysisEnum(),BedSlopeAnalysisEnum(),ThermalAnalysisEnum(),MeltingAnalysisEnum(),EnthalpyAnalysisEnum(),MasstransportAnalysisEnum()]
    5151
    5252        elif solutiontype == FlaimSolutionEnum():

  • issm/trunk-jpl/src/m/contrib/hack/tres.m

    r13806 r15771  
    44%    Usage: md=tres(md,string)
    55%
    6 %    Example: md=tres(md,'diagnostic');
     6%    Example: md=tres(md,'stressbalance');
    77
    88%check number of arguments
    99
    10 if strcmpi(string,'diagnostic'),
     10if strcmpi(string,'stressbalance'),
    1111        if md.mesh.dimension==2,
    12                 md.initialization.vx=md.results.DiagnosticSolution.Vx;
    13                 md.initialization.vy=md.results.DiagnosticSolution.Vy;
     12                md.initialization.vx=md.results.StressbalanceSolution.Vx;
     13                md.initialization.vy=md.results.StressbalanceSolution.Vy;
    1414        else
    15                 md.initialization.vx=md.results.DiagnosticSolution.Vx;
    16                 md.initialization.vy=md.results.DiagnosticSolution.Vy;
    17                 md.initialization.vz=md.results.DiagnosticSolution.Vz;
     15                md.initialization.vx=md.results.StressbalanceSolution.Vx;
     16                md.initialization.vy=md.results.StressbalanceSolution.Vy;
     17                md.initialization.vz=md.results.StressbalanceSolution.Vz;
    1818        end
    19         md.initialization.vel=md.results.DiagnosticSolution.Vel;
     19        md.initialization.vel=md.results.StressbalanceSolution.Vel;
    2020
    21         if isfield(md.results.DiagnosticSolution,'Pressure'),
    22                 md.initialization.pressure=md.results.DiagnosticSolution.Pressure;
     21        if isfield(md.results.StressbalanceSolution,'Pressure'),
     22                md.initialization.pressure=md.results.StressbalanceSolution.Pressure;
    2323        end
    2424        if ~isempty(md.rifts.riftstruct),
    25                 if isfield(md.results.DiagnosticSolution,'riftproperties'),
    26                         md.rifts.riftproperties=md.results.DiagnosticSolution.riftproperties;
     25                if isfield(md.results.StressbalanceSolution,'riftproperties'),
     26                        md.rifts.riftproperties=md.results.StressbalanceSolution.riftproperties;
    2727                end
    2828        end

  • issm/trunk-jpl/src/m/contrib/massbalance/contourmassbalance.m

    r13006 r15771  
    1919%Get segments enveloping contour
    2020segments=contourenvelope(md,file);
    21 %md.diagnostic.icefront=segments; plotmodel(md,'data','pressureload','expdisp',file);
     21%md.stressbalance.icefront=segments; plotmodel(md,'data','pressureload','expdisp',file);
    2222
    2323%get flag list of elements and nodes inside the contour

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

    r15767 r15771  
    4141def ConstantsYtsEnum(): return StringToEnum("ConstantsYts")[0]
    4242def DependentObjectEnum(): return StringToEnum("DependentObject")[0]
    43 def DiagnosticAbstolEnum(): return StringToEnum("DiagnosticAbstol")[0]
    44 def DiagnosticIcefrontEnum(): return StringToEnum("DiagnosticIcefront")[0]
    45 def DiagnosticIsnewtonEnum(): return StringToEnum("DiagnosticIsnewton")[0]
    46 def DiagnosticMaxiterEnum(): return StringToEnum("DiagnosticMaxiter")[0]
    47 def DiagnosticNumRequestedOutputsEnum(): return StringToEnum("DiagnosticNumRequestedOutputs")[0]
    48 def DiagnosticPenaltyFactorEnum(): return StringToEnum("DiagnosticPenaltyFactor")[0]
    49 def DiagnosticReferentialEnum(): return StringToEnum("DiagnosticReferential")[0]
    50 def DiagnosticReltolEnum(): return StringToEnum("DiagnosticReltol")[0]
    51 def DiagnosticRequestedOutputsEnum(): return StringToEnum("DiagnosticRequestedOutputs")[0]
    52 def DiagnosticRestolEnum(): return StringToEnum("DiagnosticRestol")[0]
    53 def DiagnosticRiftPenaltyLockEnum(): return StringToEnum("DiagnosticRiftPenaltyLock")[0]
    54 def DiagnosticRiftPenaltyThresholdEnum(): return StringToEnum("DiagnosticRiftPenaltyThreshold")[0]
    55 def DiagnosticShelfDampeningEnum(): return StringToEnum("DiagnosticShelfDampening")[0]
    56 def DiagnosticSpcvxEnum(): return StringToEnum("DiagnosticSpcvx")[0]
    57 def DiagnosticSpcvyEnum(): return StringToEnum("DiagnosticSpcvy")[0]
    58 def DiagnosticSpcvzEnum(): return StringToEnum("DiagnosticSpcvz")[0]
    59 def DiagnosticFSreconditioningEnum(): return StringToEnum("DiagnosticFSreconditioning")[0]
    60 def DiagnosticVertexPairingEnum(): return StringToEnum("DiagnosticVertexPairing")[0]
    61 def DiagnosticViscosityOvershootEnum(): return StringToEnum("DiagnosticViscosityOvershoot")[0]
     43def StressbalanceAbstolEnum(): return StringToEnum("StressbalanceAbstol")[0]
     44def StressbalanceIcefrontEnum(): return StringToEnum("StressbalanceIcefront")[0]
     45def StressbalanceIsnewtonEnum(): return StringToEnum("StressbalanceIsnewton")[0]
     46def StressbalanceMaxiterEnum(): return StringToEnum("StressbalanceMaxiter")[0]
     47def StressbalanceNumRequestedOutputsEnum(): return StringToEnum("StressbalanceNumRequestedOutputs")[0]
     48def StressbalancePenaltyFactorEnum(): return StringToEnum("StressbalancePenaltyFactor")[0]
     49def StressbalanceReferentialEnum(): return StringToEnum("StressbalanceReferential")[0]
     50def StressbalanceReltolEnum(): return StringToEnum("StressbalanceReltol")[0]
     51def StressbalanceRequestedOutputsEnum(): return StringToEnum("StressbalanceRequestedOutputs")[0]
     52def StressbalanceRestolEnum(): return StringToEnum("StressbalanceRestol")[0]
     53def StressbalanceRiftPenaltyLockEnum(): return StringToEnum("StressbalanceRiftPenaltyLock")[0]
     54def StressbalanceRiftPenaltyThresholdEnum(): return StringToEnum("StressbalanceRiftPenaltyThreshold")[0]
     55def StressbalanceShelfDampeningEnum(): return StringToEnum("StressbalanceShelfDampening")[0]
     56def StressbalanceSpcvxEnum(): return StringToEnum("StressbalanceSpcvx")[0]
     57def StressbalanceSpcvyEnum(): return StringToEnum("StressbalanceSpcvy")[0]
     58def StressbalanceSpcvzEnum(): return StringToEnum("StressbalanceSpcvz")[0]
     59def StressbalanceFSreconditioningEnum(): return StringToEnum("StressbalanceFSreconditioning")[0]
     60def StressbalanceVertexPairingEnum(): return StringToEnum("StressbalanceVertexPairing")[0]
     61def StressbalanceViscosityOvershootEnum(): return StringToEnum("StressbalanceViscosityOvershoot")[0]
    6262def LoadingforceXEnum(): return StringToEnum("LoadingforceX")[0]
    6363def LoadingforceYEnum(): return StringToEnum("LoadingforceY")[0]
    … …  
    254254def TimesteppingTimeAdaptEnum(): return StringToEnum("TimesteppingTimeAdapt")[0]
    255255def TimesteppingTimeStepEnum(): return StringToEnum("TimesteppingTimeStep")[0]
    256 def TransientIsdiagnosticEnum(): return StringToEnum("TransientIsdiagnostic")[0]
     256def TransientIsstressbalanceEnum(): return StringToEnum("TransientIsstressbalance")[0]
    257257def TransientIsgroundinglineEnum(): return StringToEnum("TransientIsgroundingline")[0]
    258258def TransientIsmasstransportEnum(): return StringToEnum("TransientIsmasstransport")[0]
    … …  
    278278def BedSlopeXAnalysisEnum(): return StringToEnum("BedSlopeXAnalysis")[0]
    279279def BedSlopeYAnalysisEnum(): return StringToEnum("BedSlopeYAnalysis")[0]
    280 def DiagnosticHorizAnalysisEnum(): return StringToEnum("DiagnosticHorizAnalysis")[0]
    281 def DiagnosticSIAAnalysisEnum(): return StringToEnum("DiagnosticSIAAnalysis")[0]
    282 def DiagnosticSolutionEnum(): return StringToEnum("DiagnosticSolution")[0]
    283 def DiagnosticVertAnalysisEnum(): return StringToEnum("DiagnosticVertAnalysis")[0]
     280def StressbalanceAnalysisEnum(): return StringToEnum("StressbalanceAnalysis")[0]
     281def StressbalanceSIAAnalysisEnum(): return StringToEnum("StressbalanceSIAAnalysis")[0]
     282def StressbalanceSolutionEnum(): return StringToEnum("StressbalanceSolution")[0]
     283def StressbalanceVerticalAnalysisEnum(): return StringToEnum("StressbalanceVerticalAnalysis")[0]
    284284def EnthalpyAnalysisEnum(): return StringToEnum("EnthalpyAnalysis")[0]
    285285def EnthalpySolutionEnum(): return StringToEnum("EnthalpySolution")[0]

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

    r13010 r15771  
    66%
    77%   Example:
    8 %      Jstruct=MisfitDeinterlace(md.results.diagnostic.J,md.fit)
     8%      Jstruct=MisfitDeinterlace(md.results.stressbalance.J,md.fit)
    99%
    1010%

  • issm/trunk-jpl/src/m/mech/cfl_step.m

    r13730 r15771  
    88%
    99%   Example:
    10 %      dt=cfl_step(md,md.results.DiagnosticSolution.Vx,md.results.DiagnosticSolution.Vy)
     10%      dt=cfl_step(md,md.results.StressbalanceSolution.Vx,md.results.StressbalanceSolution.Vy)
    1111
    1212%Check length of velocities

  • issm/trunk-jpl/src/m/miscellaneous/issmdoc.m

    r15567 r15771  
    1212disp(sprintf('%-63s %s','       md=parameterize(md,''Square.par'');','%fills all the other fields of the model'));
    1313disp(sprintf('%-63s %s','       md=setflowequation(md,''SSA'',''all'');','%defines all elements as SSA''s SSA'));
    14 disp(sprintf('%-63s %s','       md=solve(md,DiagnosticSolutionEnum());','%solve for stress balance'));
    15 disp(sprintf('%-63s %s','       plotmodel(md,''data'',md.results.DiagnosticSolution.Vel);','%displays the velocity (type plotdoc for plotmodel help)'));
     14disp(sprintf('%-63s %s','       md=solve(md,StressbalanceSolutionEnum());','%solve for stress balance'));
     15disp(sprintf('%-63s %s','       plotmodel(md,''data'',md.results.StressbalanceSolution.Vel);','%displays the velocity (type plotdoc for plotmodel help)'));

  • issm/trunk-jpl/src/m/parameterization/setflowequation.m

    r15567 r15771  
    9797%First modify FSflag to get rid of elements contrained everywhere (spc + border with HO or SSA)
    9898if any(FSflag),
    99         fullspcnodes=double((~isnan(md.diagnostic.spcvx)+~isnan(md.diagnostic.spcvy)+~isnan(md.diagnostic.spcvz))==3 | (nodeonHO & nodeonFS));         %find all the nodes on the boundary of the domain without icefront
     99        fullspcnodes=double((~isnan(md.stressbalance.spcvx)+~isnan(md.stressbalance.spcvy)+~isnan(md.stressbalance.spcvz))==3 | (nodeonHO & nodeonFS));         %find all the nodes on the boundary of the domain without icefront
    100100        fullspcelems=double(sum(fullspcnodes(md.mesh.elements),2)==6);         %find all the nodes on the boundary of the domain without icefront
    101101        FSflag(find(fullspcelems))=0;
    … …  
    117117
    118118%Now take care of the coupling between SSA and HO
    119 md.diagnostic.vertex_pairing=[];
     119md.stressbalance.vertex_pairing=[];
    120120nodeonSSAHO=zeros(md.mesh.numberofvertices,1);
    121121nodeonHOFS=zeros(md.mesh.numberofvertices,1);
    … …  
    136136                        penalties=[penalties; [bordernodes2d bordernodes2d+md.mesh.numberofvertices2d*(i)]];
    137137                end
    138                 md.diagnostic.vertex_pairing=penalties;
     138                md.stressbalance.vertex_pairing=penalties;
    139139        end
    140140elseif strcmpi(coupling_method,'tiling'),

  • issm/trunk-jpl/src/m/parameterization/setflowequation.py

    r15567 r15771  
    9191        #First modify FSflag to get rid of elements contrained everywhere (spc + border with HO or SSA)
    9292        if any(FSflag):
    93 #               fullspcnodes=double((~isnan(md.diagnostic.spcvx)+~isnan(md.diagnostic.spcvy)+~isnan(md.diagnostic.spcvz))==3 | (nodeonHO & nodeonFS));         %find all the nodes on the boundary of the domain without icefront
    94                 fullspcnodes=numpy.logical_or(numpy.logical_not(numpy.isnan(md.diagnostic.spcvx)).astype(int)+ \
    95                                               numpy.logical_not(numpy.isnan(md.diagnostic.spcvy)).astype(int)+ \
    96                                               numpy.logical_not(numpy.isnan(md.diagnostic.spcvz)).astype(int)==3, \
     93#               fullspcnodes=double((~isnan(md.stressbalance.spcvx)+~isnan(md.stressbalance.spcvy)+~isnan(md.stressbalance.spcvz))==3 | (nodeonHO & nodeonFS));         %find all the nodes on the boundary of the domain without icefront
     94                fullspcnodes=numpy.logical_or(numpy.logical_not(numpy.isnan(md.stressbalance.spcvx)).astype(int)+ \
     95                                              numpy.logical_not(numpy.isnan(md.stressbalance.spcvy)).astype(int)+ \
     96                                              numpy.logical_not(numpy.isnan(md.stressbalance.spcvz)).astype(int)==3, \
    9797                                              numpy.logical_and(nodeonHO,nodeonFS).reshape(-1,1)).astype(int)    #find all the nodes on the boundary of the domain without icefront
    9898#               fullspcelems=double(sum(fullspcnodes(md.mesh.elements),2)==6);         %find all the nodes on the boundary of the domain without icefront
    … …  
    113113
    114114        #Now take care of the coupling between SSA and HO
    115         md.diagnostic.vertex_pairing=numpy.array([])
     115        md.stressbalance.vertex_pairing=numpy.array([])
    116116        nodeonSSAHO=numpy.zeros(md.mesh.numberofvertices,bool)
    117117        nodeonHOFS=numpy.zeros(md.mesh.numberofvertices,bool)
    … …  
    131131                        for     i in xrange(1,numlayers):
    132132                                penalties=numpy.vstack((penalties,numpy.hstack((bordernodes2d.reshape(-1,1),bordernodes2d.reshape(-1,1)+md.mesh.numberofvertices2d*(i)))))
    133                         md.diagnostic.vertex_pairing=penalties
     133                        md.stressbalance.vertex_pairing=penalties
    134134
    135135        elif strcmpi(coupling_method,'tiling'):

  • issm/trunk-jpl/src/m/plot/plot_BC.m

    r14286 r15771  
    1010if strcmpi(dirichleton,'on'),
    1111        h1=plot3(...
    12                 md.mesh.x(find(~isnan(md.diagnostic.spcvx(1:md.mesh.numberofvertices,1)))),...
    13                 md.mesh.y(find(~isnan(md.diagnostic.spcvx(1:md.mesh.numberofvertices,1)))),...
    14                 md.mesh.z(find(~isnan(md.diagnostic.spcvx(1:md.mesh.numberofvertices,1)))),...
     12                md.mesh.x(find(~isnan(md.stressbalance.spcvx(1:md.mesh.numberofvertices,1)))),...
     13                md.mesh.y(find(~isnan(md.stressbalance.spcvx(1:md.mesh.numberofvertices,1)))),...
     14                md.mesh.z(find(~isnan(md.stressbalance.spcvx(1:md.mesh.numberofvertices,1)))),...
    1515                'ro','MarkerSize',14,'MarkerFaceColor','r');
    1616        h2=plot3(...
    17                 md.mesh.x(find(~isnan(md.diagnostic.spcvy(1:md.mesh.numberofvertices,1)))),...
    18                 md.mesh.y(find(~isnan(md.diagnostic.spcvy(1:md.mesh.numberofvertices,1)))),...
    19                 md.mesh.z(find(~isnan(md.diagnostic.spcvy(1:md.mesh.numberofvertices,1)))),...
     17                md.mesh.x(find(~isnan(md.stressbalance.spcvy(1:md.mesh.numberofvertices,1)))),...
     18                md.mesh.y(find(~isnan(md.stressbalance.spcvy(1:md.mesh.numberofvertices,1)))),...
     19                md.mesh.z(find(~isnan(md.stressbalance.spcvy(1:md.mesh.numberofvertices,1)))),...
    2020                'bo','MarkerSize',10,'MarkerFaceColor','b');
    2121        h3=plot3(...
    22                 md.mesh.x(find(~isnan(md.diagnostic.spcvz(1:md.mesh.numberofvertices,1)))),...
    23                 md.mesh.y(find(~isnan(md.diagnostic.spcvz(1:md.mesh.numberofvertices,1)))),...
    24                 md.mesh.z(find(~isnan(md.diagnostic.spcvz(1:md.mesh.numberofvertices,1)))),...
     22                md.mesh.x(find(~isnan(md.stressbalance.spcvz(1:md.mesh.numberofvertices,1)))),...
     23                md.mesh.y(find(~isnan(md.stressbalance.spcvz(1:md.mesh.numberofvertices,1)))),...
     24                md.mesh.z(find(~isnan(md.stressbalance.spcvz(1:md.mesh.numberofvertices,1)))),...
    2525                'yo','MarkerSize',6 ,'MarkerFaceColor','y');
    2626end

  • issm/trunk-jpl/src/m/plot/plot_referential.m

    r13730 r15771  
    1212%process mesh and data
    1313[x y z elements is2d isplanet]=processmesh(md,[],options);
    14 referential=md.diagnostic.referential;
     14referential=md.stressbalance.referential;
    1515
    16 Xhat=md.diagnostic.referential(:,1:3);
     16Xhat=md.stressbalance.referential(:,1:3);
    1717pos=find(sum(isnan(Xhat),2));
    1818Xhat(pos,:)=repmat([1 0 0],size(pos,1),1);
    … …  
    2020Xhat=Xhat./[Xhatnorm Xhatnorm Xhatnorm];
    2121
    22 Zhat=md.diagnostic.referential(:,4:6);
     22Zhat=md.stressbalance.referential(:,4:6);
    2323pos=find(sum(isnan(Zhat),2));
    2424Zhat(pos,:)=repmat([0 0 1],size(pos,1),1);
    … …  
    8787
    8888%apply options
    89 options=addfielddefault(options,'title','Diagnostic referential');
     89options=addfielddefault(options,'title','Stressbalance referential');
    9090options=addfielddefault(options,'colorbar',0);
    9191applyoptions(md,[],options);

  • issm/trunk-jpl/src/m/plot/plotdoc.m

    r15035 r15771  
    2727disp('                  - ''highlightvertices'': to highlight vertices (use highlight option to enter the vertex list');
    2828disp('                  - ''mesh'': draw mesh using trisurf');
    29 disp('                  - ''referential'': diagnostic referential');
     29disp('                  - ''referential'': stressbalance referential');
    3030disp('                  - ''riftvel'': velocities along rifts');
    3131disp('                  - ''riftrelvel'': relative velocities along rifts');

  • issm/trunk-jpl/src/m/qmu/dakota_m_write.m

    r3092 r15771  
    207207fprintf(fidm,'%%  Run the solution.\n\n');
    208208
    209 fprintf(fidm,['\tmd=solve(md,''diagnostic'',''' package ''');\n\n']);
     209fprintf(fidm,['\tmd=solve(md,''stressbalance'',''' package ''');\n\n']);
    210210
    211211end

  • issm/trunk-jpl/src/m/qmu/examples/direct.m

    r13646 r15771  
    11%using library mode of Dakota, only for parallel runs.
    22md.qmu.params.direct=true;
    3 md.qmu.params.analysis_driver='diagnostic';
     3md.qmu.params.analysis_driver='stressbalance';
    44md.qmu.params.evaluation_concurrency=1;
    55

  • issm/trunk-jpl/src/m/qmu/examples/lrel_mmf.m

    r13646 r15771  
    8686%%  sample analysis
    8787
    88 %md=solve(md,'analysis_type','diagnostic');
     88%md=solve(md,'analysis_type','stressbalance');
    8989
    9090%plotmodel(md,'data','mesh')

  • issm/trunk-jpl/src/m/qmu/examples/samp_direct.m

    r9650 r15771  
    5050
    5151md.qmu.params.direct=true;
    52 md.qmu.params.analysis_driver='diagnostic';
     52md.qmu.params.analysis_driver='stressbalance';
    5353md.qmu.params.evaluation_concurrency=1;
    5454

  • issm/trunk-jpl/src/m/qmu/preqmu.m

    r12365 r15771  
    11function md=preqmu(md,options)
    22%QMU - apply Quantification of Margins and Uncertainties techniques
    3 %      to a solution sequence (like diagnostic.m, progonstic.m, etc ...),
     3%      to a solution sequence (like stressbalance.m, progonstic.m, etc ...),
    44%      using the Dakota software from Sandia.
    55%

  • issm/trunk-jpl/src/m/qmu/process_qmu_options.m

    r15767 r15771  
    3939%check solution type is supported
    4040if ~(strcmpi(analysis_type,'control') |  ...
    41                 strcmpi(analysis_type,'diagnostic') |  ...
     41                strcmpi(analysis_type,'stressbalance') |  ...
    4242                strcmpi(analysis_type,'masstransport') |  ...
    4343                strcmpi(analysis_type,'thermal') |  ...

  • issm/trunk-jpl/src/m/regional/BasinConstrain.m

    r13730 r15771  
    4848
    4949%all elements outside the constraint domain are equivalent to water. all nodes outside are spc'd.
    50 md.diagnostic.spcvx(vertexnotondomain)=md.inversion.vx_obs(vertexnotondomain);
    51 md.diagnostic.spcvy(vertexnotondomain)=md.inversion.vy_obs(vertexnotondomain);
     50md.stressbalance.spcvx(vertexnotondomain)=md.inversion.vx_obs(vertexnotondomain);
     51md.stressbalance.spcvy(vertexnotondomain)=md.inversion.vy_obs(vertexnotondomain);
    5252md.mask.elementonwater(elementnotondomain)=1;
    5353
    … …  
    5656numpos=unique(md.mesh.elements(pos,:));
    5757nodes=setdiff(1:1:md.mesh.numberofvertices,numpos);
    58 md.diagnostic.spcvx(nodes)=md.inversion.vx_obs(nodes);
    59 md.diagnostic.spcvy(nodes)=md.inversion.vy_obs(nodes);
     58md.stressbalance.spcvx(nodes)=md.inversion.vx_obs(nodes);
     59md.stressbalance.spcvy(nodes)=md.inversion.vy_obs(nodes);
    6060
    6161%make sure icefronts that are completely spc'd are taken out:
    62 free_segments=find((~isnan(md.diagnostic.spcvx(md.diagnostic.icefront(:,1:2))) + ~isnan(md.diagnostic.spcvy(md.diagnostic.icefront(:,1:2))))~=2);
    63 md.diagnostic.icefront=md.diagnostic.icefront(free_segments,:);
     62free_segments=find((~isnan(md.stressbalance.spcvx(md.stressbalance.icefront(:,1:2))) + ~isnan(md.stressbalance.spcvy(md.stressbalance.icefront(:,1:2))))~=2);
     63md.stressbalance.icefront=md.stressbalance.icefront(free_segments,:);

  • issm/trunk-jpl/src/m/regional/BasinConstrainShelf.m

    r13730 r15771  
    4848
    4949%all elements outside the constraint domain are equivalent to water. all nodes outside are spc'd.
    50 md.diagnostic.spcvx(vertexnotondomain)=md.inversion.vx_obs(vertexnotondomain);
    51 md.diagnostic.spcvy(vertexnotondomain)=md.inversion.vy_obs(vertexnotondomain);
     50md.stressbalance.spcvx(vertexnotondomain)=md.inversion.vx_obs(vertexnotondomain);
     51md.stressbalance.spcvy(vertexnotondomain)=md.inversion.vy_obs(vertexnotondomain);
    5252md.mask.elementonwater(elementnotondomain)=1;
    5353
    … …  
    5656numpos=unique(md.mesh.elements(pos,:));
    5757nodes=setdiff(1:1:md.mesh.numberofvertices,numpos);
    58 md.diagnostic.spcvx(nodes)=md.inversion.vx_obs(nodes);
    59 md.diagnostic.spcvy(nodes)=md.inversion.vy_obs(nodes);
     58md.stressbalance.spcvx(nodes)=md.inversion.vx_obs(nodes);
     59md.stressbalance.spcvy(nodes)=md.inversion.vy_obs(nodes);
    6060
    6161%make sure any node with NaN velocity is spc'd:
    6262%we spc to the smoothed value, so that control methods don't go berserk trying to figure out what reaction force to apply for the spc to stand.
    6363pos=find(isnan(md.inversion.vel_obs_raw));
    64 md.diagnostic.spcvx(pos)=md.inversion.vx_obs(pos);
    65 md.diagnostic.spcvy(pos)=md.inversion.vy_obs(pos);
     64md.stressbalance.spcvx(pos)=md.inversion.vx_obs(pos);
     65md.stressbalance.spcvy(pos)=md.inversion.vy_obs(pos);
    6666
    6767%iceshelves: any vertex on floating ice is spc'd
    6868pos=find(md.mask.vertexongroundedice);
    69 md.diagnostic.spcvx(pos)=md.inversion.vx_obs(pos);
    70 md.diagnostic.spcvy(pos)=md.inversion.vy_obs(pos);
     69md.stressbalance.spcvx(pos)=md.inversion.vx_obs(pos);
     70md.stressbalance.spcvy(pos)=md.inversion.vy_obs(pos);
    7171
    7272%make sure icefronts that are completely spc'd are taken out:
    73 free_segments=find((~isnan(md.diagnostic.spcvx(md.diagnostic.icefront(:,1:2))) + ~isnan(md.diagnostic.spcvy(md.diagnostic.icefront(:,1:2))) )~=2);
    74 md.diagnostic.icefront=md.diagnostic.icefront(free_segments,:);
     73free_segments=find((~isnan(md.stressbalance.spcvx(md.stressbalance.icefront(:,1:2))) + ~isnan(md.stressbalance.spcvy(md.stressbalance.icefront(:,1:2))) )~=2);
     74md.stressbalance.icefront=md.stressbalance.icefront(free_segments,:);

  • issm/trunk-jpl/src/m/regional/regionaltransient2d.m

    r15767 r15771  
    115115        %As long as there are recorded time steps, spc the boundaries with velocities
    116116        if nsteps > 0
    117                 md2.diagnostic.spcvx=md2.diagnostic.spcvx*ones(1,size(spcx,2));
    118                 md2.diagnostic.spcvy=md2.diagnostic.spcvy*ones(1,size(spcy,2));
    119                 md2.diagnostic.spcvz=md2.diagnostic.spcvz*ones(1,size(spcx,2));
     117                md2.stressbalance.spcvx=md2.stressbalance.spcvx*ones(1,size(spcx,2));
     118                md2.stressbalance.spcvy=md2.stressbalance.spcvy*ones(1,size(spcy,2));
     119                md2.stressbalance.spcvz=md2.stressbalance.spcvz*ones(1,size(spcx,2));
    120120                md2.masstransport.spcthickness=md2.masstransport.spcthickness*ones(1,size(spct,2));
    121                 md2.diagnostic.spcvx(find(md2.mesh.vertexonboundary),:)=spcx(find(md2.mesh.vertexonboundary),:);
    122                 md2.diagnostic.spcvy(find(md2.mesh.vertexonboundary),:)=spcy(find(md2.mesh.vertexonboundary),:);
    123                 md2.diagnostic.spcvz(find(md2.mesh.vertexonboundary),:)=0;
     121                md2.stressbalance.spcvx(find(md2.mesh.vertexonboundary),:)=spcx(find(md2.mesh.vertexonboundary),:);
     122                md2.stressbalance.spcvy(find(md2.mesh.vertexonboundary),:)=spcy(find(md2.mesh.vertexonboundary),:);
     123                md2.stressbalance.spcvz(find(md2.mesh.vertexonboundary),:)=0;
    124124                md2.masstransport.spcthickness(find(md2.mesh.vertexonboundary),:)=spct(find(md2.mesh.vertexonboundary),:);
    125                 md2.diagnostic.spcvx=[md2.diagnostic.spcvx; steps];
    126                 md2.diagnostic.spcvy=[md2.diagnostic.spcvy; steps];
    127                 md2.diagnostic.spcvz=[md2.diagnostic.spcvz; steps];
     125                md2.stressbalance.spcvx=[md2.stressbalance.spcvx; steps];
     126                md2.stressbalance.spcvy=[md2.stressbalance.spcvy; steps];
     127                md2.stressbalance.spcvz=[md2.stressbalance.spcvz; steps];
    128128                md2.masstransport.spcthickness=[md2.masstransport.spcthickness; steps];
    129129        end
    130130
    131         %Diagnostic.  Don't spc the icefront vertices.
    132         if ~isnan(md2.diagnostic.icefront)
     131        %Stressbalance.  Don't spc the icefront vertices.
     132        if ~isnan(md2.stressbalance.icefront)
    133133                md1s=md1.extract(area);
    134                 %md2.diagnostic.icefront=[md2.mesh.segments 2];
     134                %md2.stressbalance.icefront=[md2.mesh.segments 2];
    135135                e2=md2.mesh.segments(:,end);
    136136                e1=md1s.mesh.segments(:,end);
    137137
    138138                pload = nan*ones(size(md1s.mesh.elements,1),1);
    139                 pload(md1s.diagnostic.icefront(:,end-1))=md1s.diagnostic.icefront(:,end);
     139                pload(md1s.stressbalance.icefront(:,end-1))=md1s.stressbalance.icefront(:,end);
    140140
    141141                x2=mean(md2.mesh.x(md2.mesh.elements(e2,:)),2);
    … …  
    145145
    146146                pload2=griddata(x1,y1,pload,x2,y2,'nearest');
    147                 md2.diagnostic.icefront=[md2.mesh.segments(~isnan(pload2),:) pload2(~isnan(pload2))];
    148                 md2.diagnostic.spcvx(unique(md2.diagnostic.icefront(:,1:2)),:)=nan;
    149                 md2.diagnostic.spcvy(unique(md2.diagnostic.icefront(:,1:2)),:)=nan;
    150                 md2.diagnostic.spcvz(unique(md2.diagnostic.icefront(:,1:2)),:)=nan;
    151                 md2.masstransport.spcthickness(unique(md2.diagnostic.icefront(:,1:2)),:)=nan;
     147                md2.stressbalance.icefront=[md2.mesh.segments(~isnan(pload2),:) pload2(~isnan(pload2))];
     148                md2.stressbalance.spcvx(unique(md2.stressbalance.icefront(:,1:2)),:)=nan;
     149                md2.stressbalance.spcvy(unique(md2.stressbalance.icefront(:,1:2)),:)=nan;
     150                md2.stressbalance.spcvz(unique(md2.stressbalance.icefront(:,1:2)),:)=nan;
     151                md2.masstransport.spcthickness(unique(md2.stressbalance.icefront(:,1:2)),:)=nan;
    152152        end
    153153

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

    r15767 r15771  
    99%solution_type: check on this option, error out otherwise
    1010solution_type=getfieldvalue(options,'solution_type');
    11 if ~ismember(solution_type,[DiagnosticSolutionEnum(),MasstransportSolutionEnum(),ThermalSolutionEnum(),...
     11if ~ismember(solution_type,[StressbalanceSolutionEnum(),MasstransportSolutionEnum(),ThermalSolutionEnum(),...
    1212                SteadystateSolutionEnum(),TransientSolutionEnum(),EnthalpySolutionEnum(),...
    1313                BalancethicknessSolutionEnum(),BalancethicknessSoftSolutionEnum(),BedSlopeSolutionEnum(),...

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

    r15767 r15771  
    1818        #solution_type: check on this option, error out otherwise
    1919        solution_type=options.getfieldvalue('solution_type')
    20         if solution_type not in (DiagnosticSolutionEnum(),MasstransportSolutionEnum(),ThermalSolutionEnum(),\
     20        if solution_type not in (StressbalanceSolutionEnum(),MasstransportSolutionEnum(),ThermalSolutionEnum(),\
    2121                        SteadystateSolutionEnum(),TransientSolutionEnum(),EnthalpySolutionEnum(),\
    2222                        BalancethicknessSolutionEnum(),BedSlopeSolutionEnum(),SurfaceSlopeSolutionEnum(),\

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

    r15767 r15771  
    77%
    88%   solution types available comprise:
    9 %                - DiagnosticSolutionEnum
     9%                - StressbalanceSolutionEnum
    1010%                - MasstransportSolutionEnum
    1111%                - ThermalSolutionEnum
    … …  
    2222%
    2323%   Examples:
    24 %      md=solve(md,DiagnosticSolutionEnum);
     24%      md=solve(md,StressbalanceSolutionEnum);
    2525
    2626%recover and process solve options

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

    r15767 r15771  
    2121 
    2222           solution types available comprise:
    23               - DiagnosticSolutionEnum
     23              - StressbalanceSolutionEnum
    2424              - MasstransportSolutionEnum
    2525              - ThermalSolutionEnum
    … …  
    3636 
    3737           Examples:
    38               md=solve(md,DiagnosticSolutionEnum);
     38              md=solve(md,StressbalanceSolutionEnum);
    3939        """
    4040
Note: See TracChangeset for help on using the changeset viewer.