Changeset 24335


Ignore:
Timestamp:
11/15/19 16:28:40 (5 years ago)
Author:
Mathieu Morlighem
Message:

NEW: added Inputs2, TODO: still AMR, GEMB and DC do not work, and need to delete current Inputs

Location:
issm/trunk-jpl/src/c
Files:
24 added
154 edited

Legend:

Unmodified
Added
Removed

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

    r24205 r24335  
    326326                                        ./modules/InterpFromMeshToMesh2dx/InterpFromMeshToMesh2dx.cpp\
    327327                                        ./classes/Inputs/PentaInput.cpp\
    328                                         ./classes/Inputs/TetraInput.cpp
     328                                        ./classes/Inputs/TetraInput.cpp\
     329                                        ./classes/Inputs2/Inputs2.cpp\
     330                                        ./classes/Inputs2/BoolInput2.cpp\
     331                                        ./classes/Inputs2/IntInput2.cpp\
     332                                        ./classes/Inputs2/ElementInput2.cpp\
     333                                        ./classes/Inputs2/SegInput2.cpp\
     334                                        ./classes/Inputs2/TriaInput2.cpp\
     335                                        ./classes/Inputs2/PentaInput2.cpp\
     336                                        ./classes/Inputs2/DatasetInput2.cpp\
     337                                        ./classes/Inputs2/ControlInput2.cpp\
     338                                        ./classes/Inputs2/TransientInput2.cpp\
     339                                        ./classes/Inputs2/ArrayInput2.cpp
    329340#}}}
    330341#ADJOINTMPI/MeDiPack sources {{{

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

    r23585 r24335  
    44#include "../shared/shared.h"
    55#include "../modules/modules.h"
     6#include "../classes/Inputs2/DatasetInput2.h"
    67
    78/*Model processor*/
    … …  
    1819        return 1;
    1920}/*}}}*/
    20 void AdjointBalancethickness2Analysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
     21void AdjointBalancethickness2Analysis::UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
    2122        _error_("not implemented yet");
    2223}/*}}}*/
    … …  
    6566        element->FindParam(&num_responses,InversionNumCostFunctionsEnum);
    6667        element->FindParam(&responses,NULL,InversionCostFunctionsEnum);
    67         Input* surface_input      = element->GetInput(SurfaceEnum);                          _assert_(surface_input);
    68         Input* surfaceobs_input   = element->GetInput(InversionSurfaceObsEnum);              _assert_(surfaceobs_input);
    69         Input* weights_input      = element->GetInput(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
    70         Input* vx_input           = element->GetInput(VxEnum);                                 _assert_(vx_input);
    71         Input* vy_input           = element->GetInput(VyEnum);                                 _assert_(vy_input);
     68        Input2* surface_input      = element->GetInput2(SurfaceEnum);                          _assert_(surface_input);
     69        Input2* surfaceobs_input   = element->GetInput2(InversionSurfaceObsEnum);              _assert_(surfaceobs_input);
     70        DatasetInput2* weights_input      = element->GetDatasetInput2(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
     71        Input2* vx_input           = element->GetInput2(VxEnum);                                 _assert_(vx_input);
     72        Input2* vy_input           = element->GetInput2(VyEnum);                                 _assert_(vy_input);
    7273
    7374        /* Start  looping on the number of gaussian points: */
    … …  
    171172        element->GetVerticesCoordinates(&xyz_list);
    172173        element->GradientIndexing(&vertexpidlist[0],control_index);
    173         Input* adjoint_input = element->GetInput(AdjointEnum);            _assert_(adjoint_input);
     174        Input2* adjoint_input = element->GetInput2(AdjointEnum);            _assert_(adjoint_input);
    174175
    175176        Gauss* gauss=element->NewGauss(2);
    … …  
    215216        element->GetVerticesCoordinates(&xyz_list);
    216217        element->GradientIndexing(&vertexpidlist[0],control_index);
    217         Input* adjoint_input = element->GetInput(AdjointEnum);            _assert_(adjoint_input);
    218         Input* omega_input   = element->GetInput(BalancethicknessOmegaEnum); _assert_(omega_input);
    219         Input* surface_input = element->GetInput(SurfaceEnum); _assert_(surface_input);
    220         Input* surfaceslopex_input = element->GetInput(SurfaceSlopeXEnum); _assert_(surfaceslopex_input);
    221         Input* surfaceslopey_input = element->GetInput(SurfaceSlopeYEnum); _assert_(surfaceslopey_input);
    222         Input* velobs_input        = element->GetInput(InversionVelObsEnum); _assert_(velobs_input);
     218        Input2* adjoint_input = element->GetInput2(AdjointEnum);            _assert_(adjoint_input);
     219        Input2* omega_input   = element->GetInput2(BalancethicknessOmegaEnum); _assert_(omega_input);
     220        Input2* surface_input = element->GetInput2(SurfaceEnum); _assert_(surface_input);
     221        Input2* surfaceslopex_input = element->GetInput2(SurfaceSlopeXEnum); _assert_(surfaceslopex_input);
     222        Input2* surfaceslopey_input = element->GetInput2(SurfaceSlopeYEnum); _assert_(surfaceslopey_input);
     223        Input2* velobs_input        = element->GetInput2(InversionVelObsEnum); _assert_(velobs_input);
    223224
    224225        Gauss* gauss=element->NewGauss(2);
    … …  
    272273        element->GetVerticesCoordinates(&xyz_list);
    273274        element->GradientIndexing(&vertexpidlist[0],control_index);
    274         Input* omega_input = element->GetInput(BalancethicknessOmegaEnum); _assert_(omega_input);
    275         Input* weights_input         = element->GetInput(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
     275        Input2* omega_input = element->GetInput2(BalancethicknessOmegaEnum); _assert_(omega_input);
     276        DatasetInput2* weights_input         = element->GetDatasetInput2(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
    276277
    277278        /* Start  looping on the number of gaussian points: */
    … …  
    321322        element->GetVerticesCoordinates(&xyz_list);
    322323        element->GradientIndexing(&vertexpidlist[0],control_index);
    323         Input* omega_input = element->GetInput(BalancethicknessOmegaEnum);   _assert_(omega_input);
    324         Input* omega0_input = element->GetInput(BalancethicknessOmega0Enum); _assert_(omega0_input);
    325         Input* weights_input = element->GetInput(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
     324        Input2* omega_input = element->GetInput2(BalancethicknessOmegaEnum);   _assert_(omega_input);
     325        Input2* omega0_input = element->GetInput2(BalancethicknessOmega0Enum); _assert_(omega0_input);
     326        DatasetInput2* weights_input = element->GetDatasetInput2(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
    326327
    327328        /* Start  looping on the number of gaussian points: */

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

    r23585 r24335  
    1717                void CreateNodes(Nodes* nodes,IoModel* iomodel,bool isamr=false);
    1818                int  DofsPerNode(int** doflist,int domaintype,int approximation);
    19                 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
     19                void UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type);
    2020                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    2121

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

    r23585 r24335  
    44#include "../shared/shared.h"
    55#include "../modules/modules.h"
     6#include "../classes/Inputs2/DatasetInput2.h"
    67
    78/*Model processor*/
    … …  
    1819        return 1;
    1920}/*}}}*/
    20 void AdjointBalancethicknessAnalysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
     21void AdjointBalancethicknessAnalysis::UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
    2122        _error_("not implemented yet");
    2223}/*}}}*/
    … …  
    8586        basalelement->FindParam(&num_responses,InversionNumCostFunctionsEnum);
    8687        basalelement->FindParam(&responses,NULL,InversionCostFunctionsEnum);
    87         Input* thickness_input    = basalelement->GetInput(ThicknessEnum);                          _assert_(thickness_input);
    88         Input* thicknessobs_input = basalelement->GetInput(InversionThicknessObsEnum);              _assert_(thicknessobs_input);
    89         Input* weights_input      = basalelement->GetInput(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
    90         Input* vx_input           = basalelement->GetInput(VxEnum);                                 _assert_(vx_input);
    91         Input* vy_input           = basalelement->GetInput(VyEnum);                                 _assert_(vy_input);
     88        Input2* thickness_input    = basalelement->GetInput2(ThicknessEnum);                          _assert_(thickness_input);
     89        Input2* thicknessobs_input = basalelement->GetInput2(InversionThicknessObsEnum);              _assert_(thicknessobs_input);
     90        DatasetInput2* weights_input      = basalelement->GetDatasetInput2(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
     91        Input2* vx_input           = basalelement->GetInput2(VxEnum);                                 _assert_(vx_input);
     92        Input2* vy_input           = basalelement->GetInput2(VyEnum);                                 _assert_(vy_input);
    9293
    9394        /* Start  looping on the number of gaussian points: */
    … …  
    282283        element->GetVerticesCoordinates(&xyz_list);
    283284        element->GradientIndexing(&vertexpidlist[0],control_index);
    284         Input* thickness_input = element->GetInput(ThicknessEnum); _assert_(thickness_input);
    285         Input* adjoint_input   = element->GetInput(AdjointEnum);   _assert_(adjoint_input);
     285        Input2* thickness_input = element->GetInput2(ThicknessEnum); _assert_(thickness_input);
     286        Input2* adjoint_input   = element->GetInput2(AdjointEnum);   _assert_(adjoint_input);
    286287
    287288        /* Start  looping on the number of gaussian points: */
    … …  
    329330        element->GetVerticesCoordinates(&xyz_list);
    330331        element->GradientIndexing(&vertexpidlist[0],control_index);
    331         Input* thickness_input = element->GetInput(ThicknessEnum); _assert_(thickness_input);
    332         Input* adjoint_input   = element->GetInput(AdjointEnum);   _assert_(adjoint_input);
     332        Input2* thickness_input = element->GetInput2(ThicknessEnum); _assert_(thickness_input);
     333        Input2* adjoint_input   = element->GetInput2(AdjointEnum);   _assert_(adjoint_input);
    333334
    334335        /* Start  looping on the number of gaussian points: */

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

    r23585 r24335  
    1717                void CreateNodes(Nodes* nodes,IoModel* iomodel,bool isamr=false);
    1818                int  DofsPerNode(int** doflist,int domaintype,int approximation);
    19                 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
     19                void UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type);
    2020                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    2121

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

    r24270 r24335  
    44#include "../shared/shared.h"
    55#include "../modules/modules.h"
     6#include "../classes/Inputs2/DatasetInput2.h"
    67
    78/*Model processing*/
    … …  
    1819        _error_("not implemented");
    1920}/*}}}*/
    20 void AdjointHorizAnalysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
     21void AdjointHorizAnalysis::UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
    2122           _error_("not implemented yet");
    2223}/*}}}*/
    … …  
    8687        /*Retrieve all inputs and parameters*/
    8788        element->GetVerticesCoordinates(&xyz_list);
    88         Input* vx_input = element->GetInput(VxEnum);_assert_(vx_input);
    89         Input* vy_input = element->GetInput(VyEnum);_assert_(vy_input);
    90         Input* vz_input = NULL;
     89        Input2* vx_input = element->GetInput2(VxEnum);_assert_(vx_input);
     90        Input2* vy_input = element->GetInput2(VyEnum);_assert_(vy_input);
     91        Input2* vz_input = NULL;
    9192        if(dim==3){
    92                 vz_input = element->GetInput(VzEnum);
     93                vz_input = element->GetInput2(VzEnum);
    9394        }
    9495        else{
    … …  
    170171        /*Retrieve all inputs and parameters*/
    171172        element->GetVerticesCoordinates(&xyz_list);
    172         Input* vx_input = element->GetInput(VxEnum); _assert_(vx_input);
    173         Input* vy_input = element->GetInput(VyEnum); _assert_(vy_input);
     173        Input2* vx_input = element->GetInput2(VxEnum); _assert_(vx_input);
     174        Input2* vy_input = element->GetInput2(VyEnum); _assert_(vy_input);
    174175
    175176        /*Allocate dbasis*/
    … …  
    275276        /*Retrieve all inputs and parameters*/
    276277        basalelement->GetVerticesCoordinates(&xyz_list);
    277         Input* vx_input        = basalelement->GetInput(VxEnum);       _assert_(vx_input);
    278         Input* vy_input        = basalelement->GetInput(VyEnum);       _assert_(vy_input);
    279         Input* thickness_input = basalelement->GetInput(ThicknessEnum); _assert_(thickness_input);
     278        Input2* vx_input        = basalelement->GetInput2(VxEnum);       _assert_(vx_input);
     279        Input2* vy_input        = basalelement->GetInput2(VyEnum);       _assert_(vy_input);
     280        Input2* thickness_input = basalelement->GetInput2(ThicknessEnum); _assert_(thickness_input);
    280281
    281282        /*Allocate dbasis*/
    … …  
    374375        element->FindParam(&num_responses,InversionNumCostFunctionsEnum);
    375376        element->FindParam(&responses,NULL,InversionCostFunctionsEnum);
    376         Input* weights_input = element->GetInput(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
    377         Input* vx_input      = element->GetInput(VxEnum);                                 _assert_(vx_input);
    378         Input* vxobs_input   = element->GetInput(InversionVxObsEnum);                     _assert_(vxobs_input);
    379         Input* vy_input    = NULL;
    380         Input* vyobs_input = NULL;
     377        DatasetInput2* weights_input = element->GetDatasetInput2(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
     378        Input2* vx_input      = element->GetInput2(VxEnum);                                 _assert_(vx_input);
     379        Input2* vxobs_input   = element->GetInput2(InversionVxObsEnum);                     _assert_(vxobs_input);
     380        Input2* vy_input    = NULL;
     381        Input2* vyobs_input = NULL;
    381382        if(domaintype!=Domain2DverticalEnum){
    382                 vy_input      = element->GetInput(VyEnum);                                 _assert_(vy_input);
    383                 vyobs_input   = element->GetInput(InversionVyObsEnum);                     _assert_(vyobs_input);
     383                vy_input      = element->GetInput2(VyEnum);                                 _assert_(vy_input);
     384                vyobs_input   = element->GetInput2(InversionVyObsEnum);                     _assert_(vyobs_input);
    384385        }
    385386        IssmDouble epsvel  = 2.220446049250313e-16;
    … …  
    611612        element->FindParam(&num_responses,InversionNumCostFunctionsEnum);
    612613        element->FindParam(&responses,NULL,InversionCostFunctionsEnum);
    613         Input* weights_input = element->GetInput(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
    614         Input* vx_input      = element->GetInput(VxEnum);                                 _assert_(vx_input);
    615         Input* vxobs_input   = element->GetInput(InversionVxObsEnum);                     _assert_(vxobs_input);
    616         Input* vy_input=NULL;
    617         Input* vyobs_input=NULL;
     614        DatasetInput2* weights_input = element->GetDatasetInput2(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
     615        Input2* vx_input      = element->GetInput2(VxEnum);                                 _assert_(vx_input);
     616        Input2* vxobs_input   = element->GetInput2(InversionVxObsEnum);                     _assert_(vxobs_input);
     617        Input2* vy_input=NULL;
     618        Input2* vyobs_input=NULL;
    618619        if(domaintype!=Domain2DverticalEnum){
    619                 vy_input      = element->GetInput(VyEnum);                                 _assert_(vy_input);
    620                 vyobs_input   = element->GetInput(InversionVyObsEnum);                     _assert_(vyobs_input);
     620                vy_input      = element->GetInput2(VyEnum);                                 _assert_(vy_input);
     621                vyobs_input   = element->GetInput2(InversionVyObsEnum);                     _assert_(vyobs_input);
    621622        }
    622623        IssmDouble epsvel  = 2.220446049250313e-16;
    … …  
    862863        basalelement->FindParam(&num_responses,InversionNumCostFunctionsEnum);
    863864        basalelement->FindParam(&responses,NULL,InversionCostFunctionsEnum);
    864         Input* weights_input = basalelement->GetInput(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
    865         Input* vx_input      = basalelement->GetInput(VxEnum);                                 _assert_(vx_input);
    866         Input* vxobs_input   = basalelement->GetInput(InversionVxObsEnum);                     _assert_(vxobs_input);
    867         Input* vy_input=NULL;
    868         Input* vyobs_input=NULL;
     865        DatasetInput2* weights_input = basalelement->GetDatasetInput2(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
     866        Input2* vx_input      = basalelement->GetInput2(VxEnum);                                               _assert_(vx_input);
     867        Input2* vxobs_input   = basalelement->GetInput2(InversionVxObsEnum);                                   _assert_(vxobs_input);
     868        Input2* vy_input=NULL;
     869        Input2* vyobs_input=NULL;
    869870        if(domaintype!=Domain2DverticalEnum){
    870                 vy_input      = basalelement->GetInput(VyEnum);                                 _assert_(vy_input);
    871                 vyobs_input   = basalelement->GetInput(InversionVyObsEnum);                     _assert_(vyobs_input);
     871                vy_input      = basalelement->GetInput2(VyEnum);              _assert_(vy_input);
     872                vyobs_input   = basalelement->GetInput2(InversionVyObsEnum);  _assert_(vyobs_input);
    872873        }
    873874        IssmDouble epsvel  = 2.220446049250313e-16;
    … …  
    12141215        basalelement->GetVerticesCoordinates(&xyz_list);
    12151216        basalelement->GradientIndexing(&vertexpidlist[0],control_index);
    1216         Input* rheologyb_input = basalelement->GetInput(MaterialsRheologyBbarEnum);              _assert_(rheologyb_input);
    1217         Input* weights_input   = basalelement->GetInput(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
     1217        Input2* rheologyb_input = basalelement->GetInput2(MaterialsRheologyBbarEnum);              _assert_(rheologyb_input);
     1218        DatasetInput2* weights_input   = basalelement->GetDatasetInput2(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
    12181219
    12191220        /* Start  looping on the number of gaussian points: */
    … …  
    13031304        basalelement->GetVerticesCoordinates(&xyz_list);
    13041305        basalelement->GradientIndexing(&vertexpidlist[0],control_index);
    1305         Input* thickness_input = basalelement->GetInput(ThicknessEnum);             _assert_(thickness_input);
    1306         Input* vx_input        = basalelement->GetInput(VxEnum);                    _assert_(vx_input);
    1307         Input* vy_input        = basalelement->GetInput(VyEnum);                    _assert_(vy_input);
    1308         Input* adjointx_input  = basalelement->GetInput(AdjointxEnum);              _assert_(adjointx_input);
    1309         Input* adjointy_input  = basalelement->GetInput(AdjointyEnum);              _assert_(adjointy_input);
    1310         Input* rheologyb_input = basalelement->GetInput(MaterialsRheologyBbarEnum); _assert_(rheologyb_input);
     1306        Input2* thickness_input = basalelement->GetInput2(ThicknessEnum);             _assert_(thickness_input);
     1307        Input2* vx_input        = basalelement->GetInput2(VxEnum);                    _assert_(vx_input);
     1308        Input2* vy_input        = basalelement->GetInput2(VyEnum);                    _assert_(vy_input);
     1309        Input2* adjointx_input  = basalelement->GetInput2(AdjointxEnum);              _assert_(adjointx_input);
     1310        Input2* adjointy_input  = basalelement->GetInput2(AdjointyEnum);              _assert_(adjointy_input);
     1311        Input2* rheologyb_input = basalelement->GetInput2(MaterialsRheologyBbarEnum); _assert_(rheologyb_input);
    13111312
    13121313        /* Start  looping on the number of gaussian points: */
    … …  
    13811382        element->GetVerticesCoordinates(&xyz_list);
    13821383        element->GradientIndexing(&vertexpidlist[0],control_index);
    1383         Input* rheology_input = element->GetInput(MaterialsRheologyBEnum);              _assert_(rheology_input);
    1384         Input* weights_input   = element->GetInput(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
     1384        Input2* rheology_input = element->GetInput2(MaterialsRheologyBEnum);              _assert_(rheology_input);
     1385        DatasetInput2* weights_input   = element->GetDatasetInput2(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
    13851386        /* Start  looping on the number of gaussian points: */
    13861387        Gauss* gauss=element->NewGauss(2);
    … …  
    14471448        element->GetVerticesCoordinates(&xyz_list);
    14481449        element->GradientIndexing(&vertexpidlist[0],control_index);
    1449         Input* rheology_input  = element->GetInput(MaterialsRheologyBbarEnum);              _assert_(rheology_input);
    1450         Input* rheology0_input = element->GetInput(RheologyBInitialguessEnum);              _assert_(rheology0_input);
    1451         Input* weights_input   = element->GetInput(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
     1450        Input2* rheology_input  = element->GetInput2(MaterialsRheologyBbarEnum);              _assert_(rheology_input);
     1451        Input2* rheology0_input = element->GetInput2(RheologyBInitialguessEnum);              _assert_(rheology0_input);
     1452        DatasetInput2* weights_input   = element->GetDatasetInput2(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
    14521453
    14531454        /* Start  looping on the number of gaussian points: */
    … …  
    15021503        element->GetVerticesCoordinates(&xyz_list);
    15031504        element->GradientIndexing(&vertexpidlist[0],control_index);
    1504         Input* thickness_input = element->GetInput(ThicknessEnum);             _assert_(thickness_input);
    1505         Input* vx_input        = element->GetInput(VxEnum);                    _assert_(vx_input);
    1506         Input* vy_input        = NULL;
    1507         Input* adjointx_input  = element->GetInput(AdjointxEnum);              _assert_(adjointx_input);
    1508         Input* adjointy_input  = NULL;
    1509         Input* rheologyb_input = element->GetInput(MaterialsRheologyBEnum); _assert_(rheologyb_input);
     1505        Input2* thickness_input = element->GetInput2(ThicknessEnum);             _assert_(thickness_input);
     1506        Input2* vx_input        = element->GetInput2(VxEnum);                    _assert_(vx_input);
     1507        Input2* vy_input        = NULL;
     1508        Input2* adjointx_input  = element->GetInput2(AdjointxEnum);              _assert_(adjointx_input);
     1509        Input2* adjointy_input  = NULL;
     1510        Input2* rheologyb_input = element->GetInput2(MaterialsRheologyBEnum); _assert_(rheologyb_input);
    15101511        if(domaintype!=Domain2DverticalEnum){
    1511                 vy_input        = element->GetInput(VyEnum);                   _assert_(vy_input);
    1512                 adjointy_input  = element->GetInput(AdjointyEnum);             _assert_(adjointy_input);
     1512                vy_input        = element->GetInput2(VyEnum);                   _assert_(vy_input);
     1513                adjointy_input  = element->GetInput2(AdjointyEnum);             _assert_(adjointy_input);
    15131514        }
    15141515        /* Start  looping on the number of gaussian points: */
    … …  
    15971598        basalelement->GetVerticesCoordinates(&xyz_list);
    15981599        basalelement->GradientIndexing(&vertexpidlist[0],control_index);
    1599         Input* thickness_input = basalelement->GetInput(ThicknessEnum);             _assert_(thickness_input);
    1600         Input* vx_input        = basalelement->GetInput(VxEnum);                    _assert_(vx_input);
    1601         Input* vy_input        = basalelement->GetInput(VyEnum);                    _assert_(vy_input);
    1602         Input* adjointx_input  = basalelement->GetInput(AdjointxEnum);              _assert_(adjointx_input);
    1603         Input* adjointy_input  = basalelement->GetInput(AdjointyEnum);              _assert_(adjointy_input);
    1604         Input* rheologyb_input = basalelement->GetInput(MaterialsRheologyBEnum); _assert_(rheologyb_input);
     1600        Input2* thickness_input = basalelement->GetInput2(ThicknessEnum);             _assert_(thickness_input);
     1601        Input2* vx_input        = basalelement->GetInput2(VxEnum);                    _assert_(vx_input);
     1602        Input2* vy_input        = basalelement->GetInput2(VyEnum);                    _assert_(vy_input);
     1603        Input2* adjointx_input  = basalelement->GetInput2(AdjointxEnum);              _assert_(adjointx_input);
     1604        Input2* adjointy_input  = basalelement->GetInput2(AdjointyEnum);              _assert_(adjointy_input);
     1605        Input2* rheologyb_input = basalelement->GetInput2(MaterialsRheologyBEnum); _assert_(rheologyb_input);
    16051606
    16061607        /* Start  looping on the number of gaussian points: */
    … …  
    16831684        basalelement->GetVerticesCoordinates(&xyz_list);
    16841685        basalelement->GradientIndexing(&vertexpidlist[0],control_index);
    1685         Input* dragcoefficient_input = basalelement->GetInput(FrictionCoefficientEnum);                _assert_(dragcoefficient_input);
    1686         Input* weights_input         = basalelement->GetInput(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
     1686        Input2* dragcoefficient_input = basalelement->GetInput2(FrictionCoefficientEnum);                _assert_(dragcoefficient_input);
     1687        DatasetInput2* weights_input         = basalelement->GetDatasetInput2(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
    16871688
    16881689        /* Start  looping on the number of gaussian points: */
    … …  
    17521753        element->GetVerticesCoordinatesBase(&xyz_list_base);
    17531754        element->GradientIndexing(&vertexpidlist[0],control_index);
    1754         Input* vx_input        = element->GetInput(VxEnum);                   _assert_(vx_input);
    1755         Input* vy_input        = element->GetInput(VyEnum);                   _assert_(vy_input);
    1756         Input* adjointx_input  = element->GetInput(AdjointxEnum);             _assert_(adjointx_input);
    1757         Input* adjointy_input  = element->GetInput(AdjointyEnum);             _assert_(adjointy_input);
    1758         Input* vz_input        = NULL;
    1759         Input* adjointz_input  = NULL;
     1755        Input2* vx_input        = element->GetInput2(VxEnum);                   _assert_(vx_input);
     1756        Input2* vy_input        = element->GetInput2(VyEnum);                   _assert_(vy_input);
     1757        Input2* adjointx_input  = element->GetInput2(AdjointxEnum);             _assert_(adjointx_input);
     1758        Input2* adjointy_input  = element->GetInput2(AdjointyEnum);             _assert_(adjointy_input);
     1759        Input2* vz_input        = NULL;
     1760        Input2* adjointz_input  = NULL;
    17601761        if(domaintype!=Domain2DverticalEnum){
    1761                 vz_input        = element->GetInput(VzEnum);                   _assert_(vy_input);
    1762                 adjointz_input  = element->GetInput(AdjointzEnum);             _assert_(adjointz_input);
    1763         }
    1764         Input* dragcoeff_input = element->GetInput(FrictionCoefficientEnum);  _assert_(dragcoeff_input);
     1762                vz_input        = element->GetInput2(VzEnum);                   _assert_(vy_input);
     1763                adjointz_input  = element->GetInput2(AdjointzEnum);             _assert_(adjointz_input);
     1764        }
     1765        Input2* dragcoeff_input = element->GetInput2(FrictionCoefficientEnum);  _assert_(dragcoeff_input);
    17651766
    17661767        /* Start  looping on the number of gaussian points: */
    … …  
    18511852        element->GetVerticesCoordinatesBase(&xyz_list_base);
    18521853        element->GradientIndexing(&vertexpidlist[0],control_index);
    1853         Input* vx_input        = element->GetInput(VxEnum);                   _assert_(vx_input);
    1854         Input* vy_input        = NULL;
    1855         Input* adjointx_input  = element->GetInput(AdjointxEnum);             _assert_(adjointx_input);
    1856         Input* adjointy_input  = NULL;
    1857         Input* dragcoeff_input = element->GetInput(FrictionCoefficientEnum);  _assert_(dragcoeff_input);
     1854        Input2* vx_input        = element->GetInput2(VxEnum);                   _assert_(vx_input);
     1855        Input2* vy_input        = NULL;
     1856        Input2* adjointx_input  = element->GetInput2(AdjointxEnum);             _assert_(adjointx_input);
     1857        Input2* adjointy_input  = NULL;
     1858        Input2* dragcoeff_input = element->GetInput2(FrictionCoefficientEnum);  _assert_(dragcoeff_input);
    18581859        if(domaintype!=Domain2DverticalEnum){
    1859                 vy_input        = element->GetInput(VyEnum);                   _assert_(vy_input);
    1860                 adjointy_input  = element->GetInput(AdjointyEnum);             _assert_(adjointy_input);
     1860                vy_input        = element->GetInput2(VyEnum);                   _assert_(vy_input);
     1861                adjointy_input  = element->GetInput2(AdjointyEnum);             _assert_(adjointy_input);
    18611862        }
    18621863        /* Start  looping on the number of gaussian points: */
    … …  
    19441945        basalelement->GetVerticesCoordinates(&xyz_list);
    19451946        basalelement->GradientIndexing(&vertexpidlist[0],control_index);
    1946         Input* vx_input        = basalelement->GetInput(VxEnum);                   _assert_(vx_input);
    1947         Input* vy_input        = basalelement->GetInput(VyEnum);                   _assert_(vy_input);
    1948         Input* adjointx_input  = basalelement->GetInput(AdjointxEnum);             _assert_(adjointx_input);
    1949         Input* adjointy_input  = basalelement->GetInput(AdjointyEnum);             _assert_(adjointy_input);
    1950         Input* dragcoeff_input = basalelement->GetInput(FrictionCoefficientEnum);  _assert_(dragcoeff_input);
     1947        Input2* vx_input        = basalelement->GetInput2(VxEnum);                   _assert_(vx_input);
     1948        Input2* vy_input        = basalelement->GetInput2(VyEnum);                   _assert_(vy_input);
     1949        Input2* adjointx_input  = basalelement->GetInput2(AdjointxEnum);             _assert_(adjointx_input);
     1950        Input2* adjointy_input  = basalelement->GetInput2(AdjointyEnum);             _assert_(adjointy_input);
     1951        Input2* dragcoeff_input = basalelement->GetInput2(FrictionCoefficientEnum);  _assert_(dragcoeff_input);
    19511952
    19521953        /* Start  looping on the number of gaussian points: */
    … …  
    20162017        element->GetVerticesCoordinatesBase(&xyz_list_base);
    20172018        element->GradientIndexing(&vertexpidlist[0],control_index);
    2018         Input* vx_input        = element->GetInput(VxEnum);                   _assert_(vx_input);
    2019         Input* vy_input        = element->GetInput(VyEnum);                   _assert_(vy_input);
    2020         Input* adjointx_input  = element->GetInput(AdjointxEnum);             _assert_(adjointx_input);
    2021         Input* adjointy_input  = element->GetInput(AdjointyEnum);             _assert_(adjointy_input);
    2022         Input* vz_input        = NULL;
    2023         Input* adjointz_input  = NULL;
     2019        Input2* vx_input        = element->GetInput2(VxEnum);                   _assert_(vx_input);
     2020        Input2* vy_input        = element->GetInput2(VyEnum);                   _assert_(vy_input);
     2021        Input2* adjointx_input  = element->GetInput2(AdjointxEnum);             _assert_(adjointx_input);
     2022        Input2* adjointy_input  = element->GetInput2(AdjointyEnum);             _assert_(adjointy_input);
     2023        Input2* vz_input        = NULL;
     2024        Input2* adjointz_input  = NULL;
    20242025        if(domaintype!=Domain2DverticalEnum){
    2025                 vz_input        = element->GetInput(VzEnum);                   _assert_(vy_input);
    2026                 adjointz_input  = element->GetInput(AdjointzEnum);             _assert_(adjointz_input);
     2026                vz_input        = element->GetInput2(VzEnum);                   _assert_(vy_input);
     2027                adjointz_input  = element->GetInput2(AdjointzEnum);             _assert_(adjointz_input);
    20272028        }
    20282029
    … …  
    21132114        element->GetVerticesCoordinatesBase(&xyz_list_base);
    21142115        element->GradientIndexing(&vertexpidlist[0],control_index);
    2115         Input* vx_input        = element->GetInput(VxEnum);                   _assert_(vx_input);
    2116         Input* vy_input        = NULL;
    2117         Input* adjointx_input  = element->GetInput(AdjointxEnum);             _assert_(adjointx_input);
    2118         Input* adjointy_input  = NULL;
     2116        Input2* vx_input        = element->GetInput2(VxEnum);                   _assert_(vx_input);
     2117        Input2* vy_input        = NULL;
     2118        Input2* adjointx_input  = element->GetInput2(AdjointxEnum);             _assert_(adjointx_input);
     2119        Input2* adjointy_input  = NULL;
    21192120        if(domaintype!=Domain2DverticalEnum){
    2120                 vy_input        = element->GetInput(VyEnum);                   _assert_(vy_input);
    2121                 adjointy_input  = element->GetInput(AdjointyEnum);             _assert_(adjointy_input);
     2121                vy_input        = element->GetInput2(VyEnum);                   _assert_(vy_input);
     2122                adjointy_input  = element->GetInput2(AdjointyEnum);             _assert_(adjointy_input);
    21222123        }
    21232124        /* Start  looping on the number of gaussian points: */
    … …  
    22062207        basalelement->GetVerticesCoordinates(&xyz_list);
    22072208        basalelement->GradientIndexing(&vertexpidlist[0],control_index);
    2208         Input* vx_input        = basalelement->GetInput(VxEnum);          _assert_(vx_input);
    2209         Input* vy_input        = basalelement->GetInput(VyEnum);          _assert_(vy_input);
    2210         Input* adjointx_input  = basalelement->GetInput(AdjointxEnum);    _assert_(adjointx_input);
    2211         Input* adjointy_input  = basalelement->GetInput(AdjointyEnum);    _assert_(adjointy_input);
     2209        Input2* vx_input        = basalelement->GetInput2(VxEnum);          _assert_(vx_input);
     2210        Input2* vy_input        = basalelement->GetInput2(VyEnum);          _assert_(vy_input);
     2211        Input2* adjointx_input  = basalelement->GetInput2(AdjointxEnum);    _assert_(adjointx_input);
     2212        Input2* adjointy_input  = basalelement->GetInput2(AdjointyEnum);    _assert_(adjointy_input);
    22122213
    22132214        IssmDouble  q_exp;
    … …  
    22222223
    22232224        /*Recover parameters: */
    2224         Input* qinput = basalelement->GetInput(FrictionQEnum);
    2225         Input* cinput = basalelement->GetInput(FrictionCEnum);
    2226         Input* Asinput = basalelement->GetInput(FrictionAsEnum);
    2227         Input* nInput =basalelement->GetInput(MaterialsRheologyNEnum);
    2228         Input* Ninput = basalelement->GetInput(FrictionEffectivePressureEnum); 
     2225        Input2* qinput = basalelement->GetInput2(FrictionQEnum);
     2226        Input2* cinput = basalelement->GetInput2(FrictionCEnum);
     2227        Input2* Asinput = basalelement->GetInput2(FrictionAsEnum);
     2228        Input2* nInput =basalelement->GetInput2(MaterialsRheologyNEnum);
     2229        Input2* Ninput = basalelement->GetInput2(FrictionEffectivePressureEnum);       
    22292230        /* Start  looping on the number of gaussian points: */
    22302231        Gauss* gauss=basalelement->NewGauss(4);
    … …  
    23252326        basalelement->GetVerticesCoordinates(&xyz_list);
    23262327        basalelement->GradientIndexing(&vertexpidlist[0],control_index);
    2327         Input* thickness_input = basalelement->GetInput(ThicknessEnum);             _assert_(thickness_input);
    2328         Input* vx_input        = basalelement->GetInput(VxEnum);                    _assert_(vx_input);
    2329         Input* vy_input        = basalelement->GetInput(VyEnum);                    _assert_(vy_input);
    2330         Input* adjointx_input  = basalelement->GetInput(AdjointxEnum);              _assert_(adjointx_input);
    2331         Input* adjointy_input  = basalelement->GetInput(AdjointyEnum);              _assert_(adjointy_input);
    2332         Input* rheologyb_input = basalelement->GetInput(MaterialsRheologyBbarEnum); _assert_(rheologyb_input);
     2328        Input2* thickness_input = basalelement->GetInput2(ThicknessEnum);             _assert_(thickness_input);
     2329        Input2* vx_input        = basalelement->GetInput2(VxEnum);                    _assert_(vx_input);
     2330        Input2* vy_input        = basalelement->GetInput2(VyEnum);                    _assert_(vy_input);
     2331        Input2* adjointx_input  = basalelement->GetInput2(AdjointxEnum);              _assert_(adjointx_input);
     2332        Input2* adjointy_input  = basalelement->GetInput2(AdjointyEnum);              _assert_(adjointy_input);
     2333        Input2* rheologyb_input = basalelement->GetInput2(MaterialsRheologyBbarEnum); _assert_(rheologyb_input);
    23332334
    23342335        /* Start  looping on the number of gaussian points: */
    … …  
    24502451
    24512452        /*Add vx and vy as inputs to the tria element: */
    2452         element->AddInput(AdjointxEnum,lambdax,element->VelocityInterpolation());
    2453         element->AddInput(AdjointyEnum,lambday,element->VelocityInterpolation());
    2454         if(domaintype!=Domain2DverticalEnum) element->AddInput(AdjointzEnum,lambdaz,element->VelocityInterpolation());
     2453        element->AddInput2(AdjointxEnum,lambdax,element->VelocityInterpolation());
     2454        element->AddInput2(AdjointyEnum,lambday,element->VelocityInterpolation());
     2455        if(domaintype!=Domain2DverticalEnum) element->AddInput2(AdjointzEnum,lambdaz,element->VelocityInterpolation());
    24552456
    24562457        element->FindParam(&fe_FS,FlowequationFeFSEnum);
    24572458        if(fe_FS!=LATaylorHoodEnum && fe_FS!=LACrouzeixRaviartEnum)     
    2458          element->AddInput(AdjointpEnum,lambdap,element->PressureInterpolation());     
     2459         element->AddInput2(AdjointpEnum,lambdap,element->PressureInterpolation());     
    24592460
    24602461        /*Free ressources:*/
    … …  
    25072508
    25082509        /*Add vx and vy as inputs to the tria element: */
    2509         element->AddInput(AdjointxEnum,lambdax,element->GetElementType());
    2510         element->AddInput(AdjointyEnum,lambday,element->GetElementType());
     2510        element->AddInput2(AdjointxEnum,lambdax,element->GetElementType());
     2511        element->AddInput2(AdjointyEnum,lambday,element->GetElementType());
    25112512
    25122513        /*Free ressources:*/

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

    r23867 r24335  
    1717                void CreateNodes(Nodes* nodes,IoModel* iomodel,bool isamr=false);
    1818                int  DofsPerNode(int** doflist,int domaintype,int approximation);
    19                 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
     19                void UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type);
    2020                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    2121

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

    r23585 r24335  
    1616
    1717class Parameters;
     18class Inputs2;
    1819class IoModel;
    1920class Elements;
    … …  
    3839                virtual void CreateNodes(Nodes* nodes,IoModel* iomodel,bool isamr=false)=0;
    3940                virtual int  DofsPerNode(int** doflist,int domaintype,int approximation)=0;
    40                 virtual void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type)=0;
     41                virtual void UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type)=0;
    4142                virtual void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum)=0;
    4243

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

    r23585 r24335  
    2323        return 1;
    2424}/*}}}*/
    25 void Balancethickness2Analysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
     25void Balancethickness2Analysis::UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
    2626
    2727        /*Finite element type*/
    … …  
    2929
    3030        /*Load variables in element*/
    31         iomodel->FetchDataToInput(elements,"md.geometry.thickness",ThicknessEnum);
    32         iomodel->FetchDataToInput(elements,"md.geometry.surface",SurfaceEnum);
    33         iomodel->FetchDataToInput(elements,"md.geometry.base",BaseEnum);
    34         iomodel->FetchDataToInput(elements,"md.slr.sealevel",SealevelEnum,0);
    35         iomodel->FetchDataToInput(elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
    36         iomodel->FetchDataToInput(elements,"md.initialization.vx",VxEnum);
    37         iomodel->FetchDataToInput(elements,"md.initialization.vy",VyEnum);
    38         iomodel->FetchDataToInput(elements,"md.basalforcings.groundedice_melting_rate",BasalforcingsGroundediceMeltingRateEnum);
    39         iomodel->FetchDataToInput(elements,"md.smb.mass_balance",SmbMassBalanceEnum);
    40         iomodel->FetchDataToInput(elements,"md.balancethickness.thickening_rate",BalancethicknessThickeningRateEnum);
     31        iomodel->FetchDataToInput(inputs2,elements,"md.geometry.thickness",ThicknessEnum);
     32        iomodel->FetchDataToInput(inputs2,elements,"md.geometry.surface",SurfaceEnum);
     33        iomodel->FetchDataToInput(inputs2,elements,"md.geometry.base",BaseEnum);
     34        iomodel->FetchDataToInput(inputs2,elements,"md.slr.sealevel",SealevelEnum,0);
     35        iomodel->FetchDataToInput(inputs2,elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
     36        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.vx",VxEnum);
     37        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.vy",VyEnum);
     38        iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.groundedice_melting_rate",BasalforcingsGroundediceMeltingRateEnum);
     39        iomodel->FetchDataToInput(inputs2,elements,"md.smb.mass_balance",SmbMassBalanceEnum);
     40        iomodel->FetchDataToInput(inputs2,elements,"md.balancethickness.thickening_rate",BalancethicknessThickeningRateEnum);
    4141
    4242        /*Update elements: */
    … …  
    4545                if(iomodel->my_elements[i]){
    4646                        Element* element=(Element*)elements->GetObjectByOffset(counter);
    47                         element->Update(i,iomodel,analysis_counter,analysis_type,finiteelement);
     47                        element->Update(inputs2,i,iomodel,analysis_counter,analysis_type,finiteelement);
    4848
    4949                        counter++;
    … …  
    8282        /*Retrieve all inputs and parameters*/
    8383        element->GetVerticesCoordinates(&xyz_list);
    84         Input* vx_input = element->GetInput(VxEnum); _assert_(vx_input);
    85         Input* vy_input = element->GetInput(VyEnum); _assert_(vy_input);
     84        Input2* vx_input = element->GetInput2(VxEnum); _assert_(vx_input);
     85        Input2* vy_input = element->GetInput2(VyEnum); _assert_(vy_input);
    8686
    8787        /*Get element characteristic length*/
    … …  
    142142        /*Retrieve all inputs and parameters*/
    143143        element->GetVerticesCoordinates(&xyz_list);
    144         Input* ms_input   = element->GetInput(SmbMassBalanceEnum);                _assert_(ms_input);
    145         Input* mb_input   = element->GetInput(BasalforcingsGroundediceMeltingRateEnum);       _assert_(mb_input);
    146         Input* dhdt_input = element->GetInput(BalancethicknessThickeningRateEnum);            _assert_(dhdt_input);
     144        Input2* ms_input   = element->GetInput2(SmbMassBalanceEnum);                _assert_(ms_input);
     145        Input2* mb_input   = element->GetInput2(BasalforcingsGroundediceMeltingRateEnum);       _assert_(mb_input);
     146        Input2* dhdt_input = element->GetInput2(BalancethicknessThickeningRateEnum);            _assert_(dhdt_input);
    147147
    148148        /* Start  looping on the number of gaussian points: */

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

    r23585 r24335  
    1717                void CreateNodes(Nodes* nodes,IoModel* iomodel,bool isamr=false);
    1818                int  DofsPerNode(int** doflist,int domaintype,int approximation);
    19                 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
     19                void UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type);
    2020                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    2121

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

    r23959 r24335  
    44#include "../shared/shared.h"
    55#include "../modules/modules.h"
     6#include "../classes/Inputs2/DatasetInput2.h"
    67
    78/*Model processing*/
    … …  
    7273        return 1;
    7374}/*}}}*/
    74 void BalancethicknessAnalysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
     75void BalancethicknessAnalysis::UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
    7576
    7677        int    stabilization,finiteelement;
    … …  
    9091                if(iomodel->my_elements[i]){
    9192                        Element* element=(Element*)elements->GetObjectByOffset(counter);
    92                         element->Update(i,iomodel,analysis_counter,analysis_type,finiteelement);
     93                        element->Update(inputs2,i,iomodel,analysis_counter,analysis_type,finiteelement);
    9394                        counter++;
    9495                }
    9596        }
    9697
    97         iomodel->FetchDataToInput(elements,"md.geometry.thickness",ThicknessEnum);
    98         iomodel->FetchDataToInput(elements,"md.geometry.surface",SurfaceEnum);
    99         iomodel->FetchDataToInput(elements,"md.geometry.base",BaseEnum);
    100         iomodel->FetchDataToInput(elements,"md.slr.sealevel",SealevelEnum,0);
    101         iomodel->FetchDataToInput(elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
    102         iomodel->FetchDataToInput(elements,"md.initialization.vx",VxEnum);
    103         iomodel->FetchDataToInput(elements,"md.initialization.vy",VyEnum);
    104         iomodel->FetchDataToInput(elements,"md.basalforcings.groundedice_melting_rate",BasalforcingsGroundediceMeltingRateEnum);
    105         iomodel->FetchDataToInput(elements,"md.smb.mass_balance",SmbMassBalanceEnum);
    106         iomodel->FetchDataToInput(elements,"md.balancethickness.thickening_rate",BalancethicknessThickeningRateEnum);
     98        iomodel->FetchDataToInput(inputs2,elements,"md.geometry.thickness",ThicknessEnum);
     99        iomodel->FetchDataToInput(inputs2,elements,"md.geometry.surface",SurfaceEnum);
     100        iomodel->FetchDataToInput(inputs2,elements,"md.geometry.base",BaseEnum);
     101        iomodel->FetchDataToInput(inputs2,elements,"md.slr.sealevel",SealevelEnum,0);
     102        iomodel->FetchDataToInput(inputs2,elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
     103        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.vx",VxEnum);
     104        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.vy",VyEnum);
     105        iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.groundedice_melting_rate",BasalforcingsGroundediceMeltingRateEnum);
     106        iomodel->FetchDataToInput(inputs2,elements,"md.smb.mass_balance",SmbMassBalanceEnum);
     107        iomodel->FetchDataToInput(inputs2,elements,"md.balancethickness.thickening_rate",BalancethicknessThickeningRateEnum);
    107108
    108109        if(iomodel->domaintype!=Domain2DhorizontalEnum){
    109                 iomodel->FetchDataToInput(elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum);
    110                 iomodel->FetchDataToInput(elements,"md.mesh.vertexonsurface",MeshVertexonsurfaceEnum);
     110                iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum);
     111                iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonsurface",MeshVertexonsurfaceEnum);
    111112        }
    112113}/*}}}*/
    … …  
    171172        element->FindParam(&domaintype,DomainTypeEnum);
    172173        element->FindParam(&stabilization,BalancethicknessStabilizationEnum);
    173         Input* vxaverage_input=NULL;
    174         Input* vyaverage_input=NULL;
     174        Input2* vxaverage_input=NULL;
     175        Input2* vyaverage_input=NULL;
    175176        if(domaintype==Domain2DhorizontalEnum){
    176                 vxaverage_input=element->GetInput(VxEnum); _assert_(vxaverage_input);
    177                 vyaverage_input=element->GetInput(VyEnum); _assert_(vyaverage_input);
     177                vxaverage_input=element->GetInput2(VxEnum); _assert_(vxaverage_input);
     178                vyaverage_input=element->GetInput2(VyEnum); _assert_(vyaverage_input);
    178179        }
    179180        else{
    180                 vxaverage_input=element->GetInput(VxAverageEnum); _assert_(vxaverage_input);
    181                 vyaverage_input=element->GetInput(VyAverageEnum); _assert_(vyaverage_input);
     181                vxaverage_input=element->GetInput2(VxAverageEnum); _assert_(vxaverage_input);
     182                vyaverage_input=element->GetInput2(VyAverageEnum); _assert_(vyaverage_input);
    182183        }
    183184        h = element->CharacteristicLength();
    … …  
    272273        element->GetVerticesCoordinates(&xyz_list);
    273274        element->FindParam(&domaintype,DomainTypeEnum);
    274         Input* vxaverage_input=NULL;
    275         Input* vyaverage_input=NULL;
     275        Input2* vxaverage_input=NULL;
     276        Input2* vyaverage_input=NULL;
    276277        if(domaintype==Domain2DhorizontalEnum){
    277                 vxaverage_input=element->GetInput(VxEnum); _assert_(vxaverage_input);
    278                 vyaverage_input=element->GetInput(VyEnum); _assert_(vyaverage_input);
     278                vxaverage_input=element->GetInput2(VxEnum); _assert_(vxaverage_input);
     279                vyaverage_input=element->GetInput2(VyEnum); _assert_(vyaverage_input);
    279280        }
    280281        else{
    281                 vxaverage_input=element->GetInput(VxAverageEnum); _assert_(vxaverage_input);
    282                 vyaverage_input=element->GetInput(VyAverageEnum); _assert_(vyaverage_input);
     282                vxaverage_input=element->GetInput2(VxAverageEnum); _assert_(vxaverage_input);
     283                vyaverage_input=element->GetInput2(VyAverageEnum); _assert_(vyaverage_input);
    283284        }
    284285
    … …  
    355356        /*Retrieve all inputs and parameters*/
    356357        element->GetVerticesCoordinates(&xyz_list);
    357         Input* mb_input   = element->GetInput(BasalforcingsGroundediceMeltingRateEnum);       _assert_(mb_input);
    358         Input* ms_input   = element->GetInput(SmbMassBalanceEnum);     _assert_(ms_input);
    359         Input* dhdt_input = element->GetInput(BalancethicknessThickeningRateEnum); _assert_(dhdt_input);
     358        Input2* mb_input   = element->GetInput2(BasalforcingsGroundediceMeltingRateEnum);       _assert_(mb_input);
     359        Input2* ms_input   = element->GetInput2(SmbMassBalanceEnum);     _assert_(ms_input);
     360        Input2* dhdt_input = element->GetInput2(BalancethicknessThickeningRateEnum); _assert_(dhdt_input);
    360361
    361362        /*Initialize mb_correction to 0, do not forget!:*/
    … …  
    396397        /*Retrieve all inputs and parameters*/
    397398        element->GetVerticesCoordinates(&xyz_list);
    398         Input* mb_input   = element->GetInput(BasalforcingsGroundediceMeltingRateEnum);       _assert_(mb_input);
    399         Input* ms_input   = element->GetInput(SmbMassBalanceEnum);     _assert_(ms_input);
    400         Input* dhdt_input = element->GetInput(BalancethicknessThickeningRateEnum); _assert_(dhdt_input);
     399        Input2* mb_input   = element->GetInput2(BasalforcingsGroundediceMeltingRateEnum);       _assert_(mb_input);
     400        Input2* ms_input   = element->GetInput2(SmbMassBalanceEnum);     _assert_(ms_input);
     401        Input2* dhdt_input = element->GetInput2(BalancethicknessThickeningRateEnum); _assert_(dhdt_input);
    401402
    402403        /*Initialize mb_correction to 0, do not forget!:*/
    … …  
    513514        element->GetVerticesCoordinates(&xyz_list);
    514515        element->GradientIndexing(&vertexpidlist[0],control_index);
    515         Input* thickness_input            = element->GetInput(ThicknessEnum);                           _assert_(thickness_input);
    516         Input* thicknessobs_input         = element->GetInput(InversionThicknessObsEnum);               _assert_(thicknessobs_input);
    517         Input* weights_input              = element->GetInput(InversionCostFunctionsCoefficientsEnum);  _assert_(weights_input);
    518         Input* vx_input                   = element->GetInput(VxEnum);                                  _assert_(vx_input);
    519         Input* vy_input                   = element->GetInput(VyEnum);                                  _assert_(vy_input);
    520         Input* surface_mass_balance_input = element->GetInput(SmbMassBalanceEnum);          _assert_(surface_mass_balance_input);
    521         Input* basal_melting_input        = element->GetInput(BasalforcingsGroundediceMeltingRateEnum); _assert_(basal_melting_input);
    522         Input* dhdt_input                 = element->GetInput(BalancethicknessThickeningRateEnum);      _assert_(dhdt_input);
     516        DatasetInput2* weights_input       = element->GetDatasetInput2(InversionCostFunctionsCoefficientsEnum);  _assert_(weights_input);
     517        Input2* thickness_input            = element->GetInput2(ThicknessEnum);                           _assert_(thickness_input);
     518        Input2* thicknessobs_input         = element->GetInput2(InversionThicknessObsEnum);               _assert_(thicknessobs_input);
     519        Input2* vx_input                   = element->GetInput2(VxEnum);                                  _assert_(vx_input);
     520        Input2* vy_input                   = element->GetInput2(VyEnum);                                  _assert_(vy_input);
     521        Input2* surface_mass_balance_input = element->GetInput2(SmbMassBalanceEnum);          _assert_(surface_mass_balance_input);
     522        Input2* basal_melting_input        = element->GetInput2(BasalforcingsGroundediceMeltingRateEnum); _assert_(basal_melting_input);
     523        Input2* dhdt_input                 = element->GetInput2(BalancethicknessThickeningRateEnum);      _assert_(dhdt_input);
    523524
    524525        /* Start  looping on the number of gaussian points: */

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

    r23585 r24335  
    1717                void CreateNodes(Nodes* nodes,IoModel* iomodel,bool isamr=false);
    1818                int  DofsPerNode(int** doflist,int domaintype,int approximation);
    19                 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
     19                void UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type);
    2020                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    2121

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

    r23585 r24335  
    1212           _error_("not implemented yet");
    1313}/*}}}*/
    14 void BalancethicknessSoftAnalysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
     14void BalancethicknessSoftAnalysis::UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
    1515           _error_("not implemented yet");
    1616}/*}}}*/

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

    r23585 r24335  
    1515                int  DofsPerNode(int** doflist,int domaintype,int approximation);
    1616                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    17                 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
     17                void UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type);
    1818                void CreateNodes(Nodes* nodes,IoModel* iomodel,bool isamr=false);
    1919                void CreateConstraints(Constraints* constraints,IoModel* iomodel);

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

    r23585 r24335  
    2626        return 1;
    2727}/*}}}*/
    28 void BalancevelocityAnalysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
     28void BalancevelocityAnalysis::UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
    2929
    3030        /*Update elements: */
    … …  
    3333                if(iomodel->my_elements[i]){
    3434                        Element* element=(Element*)elements->GetObjectByOffset(counter);
    35                         element->Update(i,iomodel,analysis_counter,analysis_type,P1Enum);
     35                        element->Update(inputs2,i,iomodel,analysis_counter,analysis_type,P1Enum);
    3636                        counter++;
    3737                }
    3838        }
    3939
    40         iomodel->FetchDataToInput(elements,"md.geometry.thickness",ThicknessEnum);
    41         iomodel->FetchDataToInput(elements,"md.geometry.surface",SurfaceEnum);
    42         iomodel->FetchDataToInput(elements,"md.geometry.base",BaseEnum);
    43         iomodel->FetchDataToInput(elements,"md.slr.sealevel",SealevelEnum,0);
    44         iomodel->FetchDataToInput(elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
    45         iomodel->FetchDataToInput(elements,"md.initialization.vx",VxEnum);
    46         iomodel->FetchDataToInput(elements,"md.initialization.vy",VyEnum);
    47         iomodel->FetchDataToInput(elements,"md.basalforcings.groundedice_melting_rate",BasalforcingsGroundediceMeltingRateEnum);
    48         iomodel->FetchDataToInput(elements,"md.smb.mass_balance",SmbMassBalanceEnum);
    49         iomodel->FetchDataToInput(elements,"md.balancethickness.thickening_rate",BalancethicknessThickeningRateEnum);
     40        iomodel->FetchDataToInput(inputs2,elements,"md.geometry.thickness",ThicknessEnum);
     41        iomodel->FetchDataToInput(inputs2,elements,"md.geometry.surface",SurfaceEnum);
     42        iomodel->FetchDataToInput(inputs2,elements,"md.geometry.base",BaseEnum);
     43        iomodel->FetchDataToInput(inputs2,elements,"md.slr.sealevel",SealevelEnum,0);
     44        iomodel->FetchDataToInput(inputs2,elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
     45        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.vx",VxEnum);
     46        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.vy",VyEnum);
     47        iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.groundedice_melting_rate",BasalforcingsGroundediceMeltingRateEnum);
     48        iomodel->FetchDataToInput(inputs2,elements,"md.smb.mass_balance",SmbMassBalanceEnum);
     49        iomodel->FetchDataToInput(inputs2,elements,"md.balancethickness.thickening_rate",BalancethicknessThickeningRateEnum);
    5050
    5151        if(iomodel->domaintype!=Domain2DhorizontalEnum){
    52                 iomodel->FetchDataToInput(elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum);
    53                 iomodel->FetchDataToInput(elements,"md.mesh.vertexonsurface",MeshVertexonsurfaceEnum);
     52                iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum);
     53                iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonsurface",MeshVertexonsurfaceEnum);
    5454        }
    5555}/*}}}*/
    … …  
    9292        /*Retrieve all Inputs and parameters: */
    9393        element->GetVerticesCoordinates(&xyz_list);
    94         Input* H_input = element->GetInput(ThicknessEnum); _assert_(H_input);
     94        Input2* H_input = element->GetInput2(ThicknessEnum); _assert_(H_input);
    9595        h = element->CharacteristicLength();
    9696
    … …  
    184184        /*Retrieve all inputs and parameters*/
    185185        basalelement->GetVerticesCoordinates(&xyz_list);
    186         Input* ms_input   = basalelement->GetInput(SmbMassBalanceEnum);          _assert_(ms_input);
    187         Input* mb_input   = basalelement->GetInput(BasalforcingsGroundediceMeltingRateEnum); _assert_(mb_input);
    188         Input* dhdt_input = basalelement->GetInput(BalancethicknessThickeningRateEnum);      _assert_(dhdt_input);
    189         Input* H_input    = basalelement->GetInput(ThicknessEnum);                           _assert_(H_input);
     186        Input2* ms_input   = basalelement->GetInput2(SmbMassBalanceEnum);          _assert_(ms_input);
     187        Input2* mb_input   = basalelement->GetInput2(BasalforcingsGroundediceMeltingRateEnum); _assert_(mb_input);
     188        Input2* dhdt_input = basalelement->GetInput2(BalancethicknessThickeningRateEnum);      _assert_(dhdt_input);
     189        Input2* H_input    = basalelement->GetInput2(ThicknessEnum);                           _assert_(H_input);
    190190        IssmDouble h = basalelement->CharacteristicLength();
    191191

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

    r23585 r24335  
    1717                void CreateNodes(Nodes* nodes,IoModel* iomodel,bool isamr=false);
    1818                int  DofsPerNode(int** doflist,int domaintype,int approximation);
    19                 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
     19                void UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type);
    2020                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    2121

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

    r24240 r24335  
    4040        return 1;
    4141}/*}}}*/
    42 void DamageEvolutionAnalysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
     42void DamageEvolutionAnalysis::UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
    4343
    4444        int finiteelement;
    … …  
    5454                if(iomodel->my_elements[i]){
    5555                        Element* element=(Element*)elements->GetObjectByOffset(counter);
    56                         element->Update(i,iomodel,analysis_counter,analysis_type,finiteelement);
     56                        element->Update(inputs2,i,iomodel,analysis_counter,analysis_type,finiteelement);
     57
     58                        /*Need to know the type of approximation for this element*/
     59                        if(iomodel->Data("md.flowequation.element_equation")){
     60                                inputs2->SetInput(ApproximationEnum,counter,IoCodeToEnumElementEquation(reCast<int>(iomodel->Data("md.flowequation.element_equation")[i])));
     61                        }
    5762                        counter++;
    5863                }
    … …  
    6368        for(int i=0;i<elements->Size();i++){
    6469                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    65                 int numvertices = element->GetNumberOfVertices();
    66                 IssmDouble* values = xNewZeroInit<IssmDouble>(numvertices);
    67                 element->AddInput(DamageFEnum,values,P1Enum);
    68                 xDelete<IssmDouble>(values);
     70                element->SetElementInput(inputs2,DamageFEnum,0.);
    6971        }
    7072
    7173
    7274        /*What input do I need to run my damage evolution model?*/
    73         iomodel->FetchDataToInput(elements,"md.initialization.vx",VxEnum);
    74         iomodel->FetchDataToInput(elements,"md.initialization.vy",VyEnum);
    75         if(iomodel->domaintype==Domain3DEnum) iomodel->FetchDataToInput(elements,"md.initialization.vz",VzEnum);
    76         iomodel->FetchDataToInput(elements,"md.damage.D",DamageDEnum);
    77         iomodel->FetchDataToInput(elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
    78         iomodel->FetchDataToInput(elements,"md.initialization.pressure",PressureEnum);
     75        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.vx",VxEnum);
     76        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.vy",VyEnum);
     77        if(iomodel->domaintype==Domain3DEnum) iomodel->FetchDataToInput(inputs2,elements,"md.initialization.vz",VzEnum);
     78        iomodel->FetchDataToInput(inputs2,elements,"md.damage.D",DamageDEnum);
     79        iomodel->FetchDataToInput(inputs2,elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
     80        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.pressure",PressureEnum);
    7981
    8082}/*}}}*/
    … …  
    137139
    138140        /*Add input*/
    139         element->AddInput(DamageFEnum,f,element->GetElementType());
     141        element->AddInput2(DamageFEnum,f,element->GetElementType());
    140142
    141143        /*Clean up and return*/
    … …  
    172174        element->ComputeDeviatoricStressTensor();
    173175
    174         Input* principalDevStress1_input = element->GetInput(DeviatoricStress1Enum);     _assert_(principalDevStress1_input);
    175         Input* principalDevStress2_input = element->GetInput(DeviatoricStress2Enum);     _assert_(principalDevStress2_input);
    176 
    177         Input* damage_input = NULL;
     176        Input2* principalDevStress1_input = element->GetInput2(DeviatoricStress1Enum);     _assert_(principalDevStress1_input);
     177        Input2* principalDevStress2_input = element->GetInput2(DeviatoricStress2Enum);     _assert_(principalDevStress2_input);
     178
     179        Input2* damage_input = NULL;
    178180        if(domaintype==Domain2DhorizontalEnum){
    179                 damage_input = element->GetInput(DamageDbarEnum);       _assert_(damage_input);
     181                damage_input = element->GetInput2(DamageDbarEnum);      _assert_(damage_input);
    180182        }
    181183        else{
    182                 damage_input = element->GetInput(DamageDEnum);   _assert_(damage_input);
     184                damage_input = element->GetInput2(DamageDEnum);   _assert_(damage_input);
    183185        }
    184186
    … …  
    220222
    221223        /*Add input*/
    222         element->AddInput(DamageFEnum,f,element->GetElementType());
     224        element->AddInput2(DamageFEnum,f,element->GetElementType());
    223225
    224226        /*Clean up and return*/
    … …  
    248250
    249251        /*retrieve what we need: */
    250         Input* eps_xx_input  = element->GetInput(StrainRatexxEnum);     _assert_(eps_xx_input);
    251         Input* eps_xy_input  = element->GetInput(StrainRatexyEnum);     _assert_(eps_xy_input);
    252         Input* eps_yy_input  = element->GetInput(StrainRateyyEnum);     _assert_(eps_yy_input);
    253         Input*  n_input=element->GetInput(MaterialsRheologyNEnum); _assert_(n_input);
    254         Input* damage_input = NULL;
    255         Input* B_input = NULL;
     252        Input2* eps_xx_input  = element->GetInput2(StrainRatexxEnum);     _assert_(eps_xx_input);
     253        Input2* eps_xy_input  = element->GetInput2(StrainRatexyEnum);     _assert_(eps_xy_input);
     254        Input2* eps_yy_input  = element->GetInput2(StrainRateyyEnum);     _assert_(eps_yy_input);
     255        Input2*  n_input=element->GetInput2(MaterialsRheologyNEnum); _assert_(n_input);
     256        Input2* damage_input = NULL;
     257        Input2* B_input = NULL;
    256258        if(domaintype==Domain2DhorizontalEnum){
    257                 damage_input = element->GetInput(DamageDbarEnum);       _assert_(damage_input);
    258                 B_input=element->GetInput(MaterialsRheologyBbarEnum); _assert_(B_input);
     259                damage_input = element->GetInput2(DamageDbarEnum);      _assert_(damage_input);
     260                B_input=element->GetInput2(MaterialsRheologyBbarEnum); _assert_(B_input);
    259261        }
    260262        else{
    261                 damage_input = element->GetInput(DamageDEnum);   _assert_(damage_input);
    262                 B_input=element->GetInput(MaterialsRheologyBEnum); _assert_(B_input);
     263                damage_input = element->GetInput2(DamageDEnum);   _assert_(damage_input);
     264                B_input=element->GetInput2(MaterialsRheologyBEnum); _assert_(B_input);
    263265        }
    264266
    … …  
    295297
    296298        /*Add input*/
    297         element->AddInput(DamageFEnum,f,element->GetElementType());
     299        element->AddInput2(DamageFEnum,f,P1DGEnum);
    298300
    299301        /*Clean up and return*/
    … …  
    335337        }
    336338        /*retrieve what we need: */
    337         Input* tau_xx_input  = element->GetInput(DeviatoricStressxxEnum);     _assert_(tau_xx_input);
    338         Input* tau_xy_input  = element->GetInput(DeviatoricStressxyEnum);     _assert_(tau_xy_input);
    339         Input* tau_yy_input  = element->GetInput(DeviatoricStressyyEnum);     _assert_(tau_yy_input);
    340         Input* tau_xz_input  = NULL;
    341         Input* tau_yz_input  = NULL;
    342         Input* tau_zz_input  = NULL;
    343         Input* stressMaxPrincipal_input = NULL;
     339        Input2* tau_xx_input  = element->GetInput2(DeviatoricStressxxEnum);     _assert_(tau_xx_input);
     340        Input2* tau_xy_input  = element->GetInput2(DeviatoricStressxyEnum);     _assert_(tau_xy_input);
     341        Input2* tau_yy_input  = element->GetInput2(DeviatoricStressyyEnum);     _assert_(tau_yy_input);
     342        Input2* tau_xz_input  = NULL;
     343        Input2* tau_yz_input  = NULL;
     344        Input2* tau_zz_input  = NULL;
     345        Input2* stressMaxPrincipal_input = NULL;
    344346        if(dim==3){
    345                 tau_xz_input  = element->GetInput(DeviatoricStressxzEnum);     _assert_(tau_xz_input);
    346                 tau_yz_input  = element->GetInput(DeviatoricStressyzEnum);     _assert_(tau_yz_input);
    347                 tau_zz_input  = element->GetInput(DeviatoricStresszzEnum);     _assert_(tau_zz_input);
    348                 stressMaxPrincipal_input = element->GetInput(StressMaxPrincipalEnum); _assert_(stressMaxPrincipal_input);
    349         }
    350         Input* damage_input = NULL;
     347                tau_xz_input  = element->GetInput2(DeviatoricStressxzEnum);     _assert_(tau_xz_input);
     348                tau_yz_input  = element->GetInput2(DeviatoricStressyzEnum);     _assert_(tau_yz_input);
     349                tau_zz_input  = element->GetInput2(DeviatoricStresszzEnum);     _assert_(tau_zz_input);
     350                stressMaxPrincipal_input = element->GetInput2(StressMaxPrincipalEnum); _assert_(stressMaxPrincipal_input);
     351        }
     352        Input2* damage_input = NULL;
    351353        if(domaintype==Domain2DhorizontalEnum){
    352                 damage_input = element->GetInput(DamageDbarEnum);       _assert_(damage_input);
     354                damage_input = element->GetInput2(DamageDbarEnum);      _assert_(damage_input);
    353355        }
    354356        else{
    355                 damage_input = element->GetInput(DamageDEnum);   _assert_(damage_input);
     357                damage_input = element->GetInput2(DamageDEnum);   _assert_(damage_input);
    356358        }
    357359
    … …  
    414416        }
    415417        /*Add input*/
    416         element->AddInput(DamageFEnum,f,element->GetElementType());
     418        element->AddInput2(DamageFEnum,f,P1DGEnum);
    417419
    418420        /*Clean up and return*/
    … …  
    461463        //printf("dt %f\n", dt);
    462464        element->FindParam(&stabilization,DamageStabilizationEnum);
    463         Input* vx_input = element->GetInput(VxEnum); _assert_(vx_input);
    464         Input* vy_input = element->GetInput(VyEnum); _assert_(vy_input);
    465         Input* vz_input = NULL;
     465        Input2* vx_input = element->GetInput2(VxEnum); _assert_(vx_input);
     466        Input2* vy_input = element->GetInput2(VyEnum); _assert_(vy_input);
     467        Input2* vz_input = NULL;
    466468        if(dim==3){
    467                 vz_input=element->GetInput(VzEnum); _assert_(vz_input);
     469                vz_input=element->GetInput2(VzEnum); _assert_(vz_input);
    468470        }
    469471
    … …  
    634636        }
    635637
    636         Input* damaged_input = NULL;
    637         Input* damagef_input = element->GetInput(DamageFEnum); _assert_(damagef_input);
     638        Input2* damaged_input = NULL;
     639        Input2* damagef_input = element->GetInput2(DamageFEnum); _assert_(damagef_input);
    638640        if(domaintype==Domain2DhorizontalEnum){
    639                 damaged_input = element->GetInput(DamageDbarEnum); _assert_(damaged_input);
     641                damaged_input = element->GetInput2(DamageDbarEnum); _assert_(damaged_input);
    640642        }
    641643        else{
    642                 damaged_input = element->GetInput(DamageDEnum); _assert_(damaged_input);
     644                damaged_input = element->GetInput2(DamageDEnum); _assert_(damaged_input);
    643645        }
    644646
    … …  
    755757        element->FindParam(&domaintype,DomainTypeEnum);
    756758        if(domaintype==Domain2DhorizontalEnum){
    757                 element->AddInput(DamageDbarEnum,newdamage,element->GetElementType());
     759                element->AddInput2(DamageDbarEnum,newdamage,element->GetElementType());
    758760        }
    759761        else{
    760                 element->AddInput(DamageDEnum,newdamage,element->GetElementType());
     762                element->AddInput2(DamageDEnum,newdamage,element->GetElementType());
    761763        }
    762764
    … …  
    792794        /*Retrieve all inputs and parameters*/
    793795        element->GetVerticesCoordinates(&xyz_list);
    794         Input* vxaverage_input=element->GetInput(VxEnum); _assert_(vxaverage_input);
    795         Input* vyaverage_input=element->GetInput(VyEnum); _assert_(vyaverage_input);
     796        Input2* vxaverage_input=element->GetInput2(VxEnum); _assert_(vxaverage_input);
     797        Input2* vyaverage_input=element->GetInput2(VyEnum); _assert_(vyaverage_input);
    796798
    797799        /* Start  looping on the number of gaussian points: */

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

    r24146 r24335  
    1717                void CreateNodes(Nodes* nodes,IoModel* iomodel,bool isamr=false);
    1818                int  DofsPerNode(int** doflist,int domaintype,int approximation);
    19                 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
     19                void UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type);
    2020                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    2121

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

    r23585 r24335  
    1818        return 1;
    1919}/*}}}*/
    20 void DepthAverageAnalysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
     20void DepthAverageAnalysis::UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
    2121
    2222        int counter=0;
    … …  
    2424                if(iomodel->my_elements[i]){
    2525                        Element* element=(Element*)elements->GetObjectByOffset(counter);
    26                         element->Update(i,iomodel,analysis_counter,analysis_type,P1Enum);
     26                        element->Update(inputs2,i,iomodel,analysis_counter,analysis_type,P1Enum);
    2727                        counter++;
    2828                }
    … …  
    3030
    3131        if(iomodel->domaintype==Domain2DverticalEnum){
    32                 iomodel->FetchDataToInput(elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum);
     32                iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum);
    3333        }
    3434}/*}}}*/
    … …  
    114114        element->GetVerticesCoordinates(&xyz_list);
    115115        element->FindParam(&input_enum,InputToDepthaverageInEnum);
    116         Input* input = element->GetInput(input_enum); _assert_(input);
     116        Input2* input = element->GetInput2(input_enum); _assert_(input);
    117117
    118118        /* Start  looping on the number of gaussian points: */

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

    r23585 r24335  
    1717                void CreateNodes(Nodes* nodes,IoModel* iomodel,bool isamr=false);
    1818                int  DofsPerNode(int** doflist,int domaintype,int approximation);
    19                 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
     19                void UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type);
    2020                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    2121

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

    r24240 r24335  
    9999        return 1;
    100100}/*}}}*/
    101 void EnthalpyAnalysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
     101void EnthalpyAnalysis::UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
    102102
    103103        bool dakota_analysis,ismovingfront,isenthalpy;
    … …  
    124124                if(iomodel->my_elements[i]){
    125125                        Element* element=(Element*)elements->GetObjectByOffset(counter);
    126                         element->Update(i,iomodel,analysis_counter,analysis_type,finiteelement);
     126                        element->Update(inputs2,i,iomodel,analysis_counter,analysis_type,finiteelement);
    127127                        counter++;
    128128                }
    … …  
    134134        iomodel->FindConstant(&materialstype,"md.materials.type");
    135135
    136         iomodel->FetchDataToInput(elements,"md.geometry.thickness",ThicknessEnum);
    137         iomodel->FetchDataToInput(elements,"md.geometry.surface",SurfaceEnum);
    138         iomodel->FetchDataToInput(elements,"md.slr.sealevel",SealevelEnum,0);
    139         iomodel->FetchDataToInput(elements,"md.geometry.base",BaseEnum);
    140         iomodel->FetchDataToInput(elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
    141         iomodel->FetchDataToInput(elements,"md.mask.groundedice_levelset",MaskGroundediceLevelsetEnum);
     136        iomodel->FetchDataToInput(inputs2,elements,"md.geometry.thickness",ThicknessEnum);
     137        iomodel->FetchDataToInput(inputs2,elements,"md.geometry.surface",SurfaceEnum);
     138        iomodel->FetchDataToInput(inputs2,elements,"md.slr.sealevel",SealevelEnum,0);
     139        iomodel->FetchDataToInput(inputs2,elements,"md.geometry.base",BaseEnum);
     140        iomodel->FetchDataToInput(inputs2,elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
     141        iomodel->FetchDataToInput(inputs2,elements,"md.mask.groundedice_levelset",MaskGroundediceLevelsetEnum);
    142142        if(iomodel->domaintype!=Domain2DhorizontalEnum){
    143                 iomodel->FetchDataToInput(elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum);
    144                 iomodel->FetchDataToInput(elements,"md.mesh.vertexonsurface",MeshVertexonsurfaceEnum);
    145         }
    146         iomodel->FetchDataToInput(elements,"md.initialization.pressure",PressureEnum);
    147         iomodel->FetchDataToInput(elements,"md.initialization.temperature",TemperatureEnum);
    148         iomodel->FetchDataToInput(elements,"md.initialization.waterfraction",WaterfractionEnum);
    149         iomodel->FetchDataToInput(elements,"md.initialization.enthalpy",EnthalpyEnum);
    150         iomodel->FetchDataToInput(elements,"md.initialization.watercolumn",WatercolumnEnum);
    151         iomodel->FetchDataToInput(elements,"md.basalforcings.groundedice_melting_rate",BasalforcingsGroundediceMeltingRateEnum);
    152         iomodel->FetchDataToInput(elements,"md.initialization.vx",VxEnum);
    153         iomodel->FetchDataToInput(elements,"md.initialization.vy",VyEnum);
    154         iomodel->FetchDataToInput(elements,"md.initialization.vz",VzEnum);
    155         InputUpdateFromConstantx(elements,0.,VxMeshEnum);
    156         InputUpdateFromConstantx(elements,0.,VyMeshEnum);
    157         InputUpdateFromConstantx(elements,0.,VzMeshEnum);
     143                iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum);
     144                iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonsurface",MeshVertexonsurfaceEnum);
     145        }
     146        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.pressure",PressureEnum);
     147        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.temperature",TemperatureEnum);
     148        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.waterfraction",WaterfractionEnum);
     149        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.enthalpy",EnthalpyEnum);
     150        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.watercolumn",WatercolumnEnum);
     151        iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.groundedice_melting_rate",BasalforcingsGroundediceMeltingRateEnum);
     152        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.vx",VxEnum);
     153        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.vy",VyEnum);
     154        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.vz",VzEnum);
     155        InputUpdateFromConstantx(inputs2,elements,0.,VxMeshEnum);
     156        InputUpdateFromConstantx(inputs2,elements,0.,VyMeshEnum);
     157        InputUpdateFromConstantx(inputs2,elements,0.,VzMeshEnum);
    158158        if(ismovingfront){
    159                 iomodel->FetchDataToInput(elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum); // required for updating active nodes
     159                iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum); // required for updating active nodes
    160160        }
    161161
    … …  
    166166                        break;
    167167                default:
    168                         iomodel->FetchDataToInput(elements,"md.basalforcings.geothermalflux",BasalforcingsGeothermalfluxEnum);
     168                        iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.geothermalflux",BasalforcingsGeothermalfluxEnum);
    169169                        break;
    170170        }
    171171
    172172        /*Rheology type*/
    173         iomodel->FetchDataToInput(elements,"md.materials.rheology_B",MaterialsRheologyBEnum);
     173        iomodel->FetchDataToInput(inputs2,elements,"md.materials.rheology_B",MaterialsRheologyBEnum);
    174174        switch(materialstype){
    175175                case MatenhancediceEnum:
    176                         iomodel->FetchDataToInput(elements,"md.materials.rheology_n",MaterialsRheologyNEnum);
    177                         iomodel->FetchDataToInput(elements,"md.materials.rheology_E",MaterialsRheologyEEnum);
     176                        iomodel->FetchDataToInput(inputs2,elements,"md.materials.rheology_n",MaterialsRheologyNEnum);
     177                        iomodel->FetchDataToInput(inputs2,elements,"md.materials.rheology_E",MaterialsRheologyEEnum);
    178178                        break;
    179179                case MatdamageiceEnum:
    180                         iomodel->FetchDataToInput(elements,"md.materials.rheology_n",MaterialsRheologyNEnum);
     180                        iomodel->FetchDataToInput(inputs2,elements,"md.materials.rheology_n",MaterialsRheologyNEnum);
    181181                        break;
    182182                case MatestarEnum:
    183                         iomodel->FetchDataToInput(elements,"md.materials.rheology_Ec",MaterialsRheologyEcEnum);
    184                         iomodel->FetchDataToInput(elements,"md.materials.rheology_Es",MaterialsRheologyEsEnum);
     183                        iomodel->FetchDataToInput(inputs2,elements,"md.materials.rheology_Ec",MaterialsRheologyEcEnum);
     184                        iomodel->FetchDataToInput(inputs2,elements,"md.materials.rheology_Es",MaterialsRheologyEsEnum);
    185185                        break;
    186186                case MaticeEnum:
    187                         iomodel->FetchDataToInput(elements,"md.materials.rheology_n",MaterialsRheologyNEnum);
     187                        iomodel->FetchDataToInput(inputs2,elements,"md.materials.rheology_n",MaterialsRheologyNEnum);
    188188                        break;
    189189                default:
    … …  
    195195                case 1:
    196196                        iomodel->FindConstant(&FrictionCoupling,"md.friction.coupling");
    197                         iomodel->FetchDataToInput(elements,"md.friction.coefficient",FrictionCoefficientEnum);
    198                         iomodel->FetchDataToInput(elements,"md.friction.p",FrictionPEnum);
    199                         iomodel->FetchDataToInput(elements,"md.friction.q",FrictionQEnum);
     197                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.coefficient",FrictionCoefficientEnum);
     198                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.p",FrictionPEnum);
     199                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.q",FrictionQEnum);
    200200                        if (FrictionCoupling==3){
    201                                 iomodel->FetchDataToInput(elements,"md.friction.effective_pressure",FrictionEffectivePressureEnum);}
     201                                iomodel->FetchDataToInput(inputs2,elements,"md.friction.effective_pressure",FrictionEffectivePressureEnum);}
    202202                        else if(FrictionCoupling==4){
    203                                 iomodel->FetchDataToInput(elements,"md.friction.effective_pressure",EffectivePressureEnum);
     203                                iomodel->FetchDataToInput(inputs2,elements,"md.friction.effective_pressure",EffectivePressureEnum);
    204204                        }
    205205                        break;
    206206                case 2:
    207                         iomodel->FetchDataToInput(elements,"md.friction.C",FrictionCEnum);
    208                         iomodel->FetchDataToInput(elements,"md.friction.m",FrictionMEnum);
     207                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.C",FrictionCEnum);
     208                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.m",FrictionMEnum);
    209209                        break;
    210210                case 3:
    211211                        iomodel->FindConstant(&FrictionCoupling,"md.friction.coupling");
    212                         iomodel->FetchDataToInput(elements,"md.friction.C",FrictionCEnum);
    213                         iomodel->FetchDataToInput(elements,"md.friction.As",FrictionAsEnum);
    214                         iomodel->FetchDataToInput(elements,"md.friction.q",FrictionQEnum);
     212                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.C",FrictionCEnum);
     213                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.As",FrictionAsEnum);
     214                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.q",FrictionQEnum);
    215215                        if (FrictionCoupling==3){
    216                                 iomodel->FetchDataToInput(elements,"md.friction.effective_pressure",FrictionEffectivePressureEnum);}
     216                                iomodel->FetchDataToInput(inputs2,elements,"md.friction.effective_pressure",FrictionEffectivePressureEnum);}
    217217                        else if(FrictionCoupling==4){
    218                                 iomodel->FetchDataToInput(elements,"md.friction.effective_pressure",EffectivePressureEnum);
     218                                iomodel->FetchDataToInput(inputs2,elements,"md.friction.effective_pressure",EffectivePressureEnum);
    219219                        }
    220220                        break;
    221221                case 4:
    222                         iomodel->FetchDataToInput(elements,"md.friction.coefficient",FrictionCoefficientEnum);
    223                         iomodel->FetchDataToInput(elements,"md.friction.p",FrictionPEnum);
    224                         iomodel->FetchDataToInput(elements,"md.friction.q",FrictionQEnum);
    225                         iomodel->FetchDataToInput(elements,"md.initialization.pressure",PressureEnum);
    226                         iomodel->FetchDataToInput(elements,"md.initialization.temperature",TemperatureEnum);
     222                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.coefficient",FrictionCoefficientEnum);
     223                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.p",FrictionPEnum);
     224                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.q",FrictionQEnum);
     225                        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.pressure",PressureEnum);
     226                        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.temperature",TemperatureEnum);
    227227                        iomodel->FindConstant(&FrictionCoupling,"md.friction.coupling");
    228228                        break;
    229229                case 5:
    230                         iomodel->FetchDataToInput(elements,"md.friction.coefficient",FrictionCoefficientEnum);
    231                         iomodel->FetchDataToInput(elements,"md.friction.p",FrictionPEnum);
    232                         iomodel->FetchDataToInput(elements,"md.friction.q",FrictionQEnum);
    233                         iomodel->FetchDataToInput(elements,"md.friction.water_layer",FrictionWaterLayerEnum);
     230                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.coefficient",FrictionCoefficientEnum);
     231                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.p",FrictionPEnum);
     232                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.q",FrictionQEnum);
     233                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.water_layer",FrictionWaterLayerEnum);
    234234                        break;
    235235                case 6:
    236                         iomodel->FetchDataToInput(elements,"md.friction.C",FrictionCEnum);
    237                         iomodel->FetchDataToInput(elements,"md.friction.m",FrictionMEnum);
    238                         iomodel->FetchDataToInput(elements,"md.initialization.pressure",PressureEnum);
    239                         iomodel->FetchDataToInput(elements,"md.initialization.temperature",TemperatureEnum);
     236                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.C",FrictionCEnum);
     237                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.m",FrictionMEnum);
     238                        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.pressure",PressureEnum);
     239                        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.temperature",TemperatureEnum);
    240240                        break;
    241241                case 7:
    242242                        iomodel->FindConstant(&FrictionCoupling,"md.friction.coupling");
    243                         iomodel->FetchDataToInput(elements,"md.friction.coefficient",FrictionCoefficientEnum);
    244                         iomodel->FetchDataToInput(elements,"md.friction.coefficientcoulomb",FrictionCoefficientcoulombEnum);
    245                         iomodel->FetchDataToInput(elements,"md.friction.p",FrictionPEnum);
    246                         iomodel->FetchDataToInput(elements,"md.friction.q",FrictionQEnum);
     243                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.coefficient",FrictionCoefficientEnum);
     244                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.coefficientcoulomb",FrictionCoefficientcoulombEnum);
     245                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.p",FrictionPEnum);
     246                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.q",FrictionQEnum);
    247247                        if (FrictionCoupling==3){
    248                                 iomodel->FetchDataToInput(elements,"md.friction.effective_pressure",FrictionEffectivePressureEnum);}
     248                                iomodel->FetchDataToInput(inputs2,elements,"md.friction.effective_pressure",FrictionEffectivePressureEnum);}
    249249                        else if(FrictionCoupling==4){
    250                                 iomodel->FetchDataToInput(elements,"md.friction.effective_pressure",EffectivePressureEnum);
     250                                iomodel->FetchDataToInput(inputs2,elements,"md.friction.effective_pressure",EffectivePressureEnum);
    251251                        }
    252252                        break;
    253253                case 9:
    254                         iomodel->FetchDataToInput(elements,"md.friction.coefficient",FrictionCoefficientEnum);
    255                         iomodel->FetchDataToInput(elements,"md.friction.pressure_adjusted_temperature",FrictionPressureAdjustedTemperatureEnum);
    256                         InputUpdateFromConstantx(elements,1.,FrictionPEnum);
    257                         InputUpdateFromConstantx(elements,1.,FrictionQEnum);
     254                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.coefficient",FrictionCoefficientEnum);
     255                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.pressure_adjusted_temperature",FrictionPressureAdjustedTemperatureEnum);
     256                        InputUpdateFromConstantx(inputs2,elements,1.,FrictionPEnum);
     257                        InputUpdateFromConstantx(inputs2,elements,1.,FrictionQEnum);
    258258                        break;
    259259                default:
    … …  
    318318
    319319        /*Get parameters and inputs: */
    320         Input* pressure_input            = element->GetInput(PressureEnum);                                                      _assert_(pressure_input);
     320        Input2* pressure_input           = element->GetInput2(PressureEnum);                                                     _assert_(pressure_input);
    321321
    322322        /*Fetch indices of basal & surface nodes for this finite element*/
    … …  
    400400
    401401        /*retrieve inputs*/
    402         Input* enthalpy_input         = element->GetInput(enthalpy_enum);                    _assert_(enthalpy_input);
    403         Input* pressure_input                   = element->GetInput(PressureEnum);                                                      _assert_(pressure_input);
    404         Input* geothermalflux_input   = element->GetInput(BasalforcingsGeothermalfluxEnum); _assert_(geothermalflux_input);
    405         Input* vx_input               = element->GetInput(VxEnum);                          _assert_(vx_input);
    406         Input* vy_input               = element->GetInput(VyEnum);                          _assert_(vy_input);
    407         Input* vz_input               = element->GetInput(VzEnum);                          _assert_(vz_input);
     402        Input2* enthalpy_input       = element->GetInput2(enthalpy_enum);                   _assert_(enthalpy_input);
     403        Input2* pressure_input       = element->GetInput2(PressureEnum);                    _assert_(pressure_input);
     404        Input2* geothermalflux_input = element->GetInput2(BasalforcingsGeothermalfluxEnum); _assert_(geothermalflux_input);
     405        Input2* vx_input             = element->GetInput2(VxEnum);                          _assert_(vx_input);
     406        Input2* vy_input             = element->GetInput2(VyEnum);                          _assert_(vy_input);
     407        Input2* vz_input             = element->GetInput2(VzEnum);                          _assert_(vz_input);
    408408
    409409        /*Build friction element, needed later: */
    … …  
    503503        /*feed updated variables back into model*/
    504504        if(dt!=0.){
    505                 element->AddInput(enthalpy_enum,enthalpies,element->GetElementType());
    506                 element->AddInput(WatercolumnEnum,watercolumns,element->GetElementType());
    507         }
    508         element->AddInput(BasalforcingsGroundediceMeltingRateEnum,basalmeltingrates,element->GetElementType());
     505                element->AddInput2(enthalpy_enum,enthalpies,P1DGEnum);
     506                element->AddInput2(WatercolumnEnum,watercolumns,P1DGEnum);
     507        }
     508        element->AddInput2(BasalforcingsGroundediceMeltingRateEnum,basalmeltingrates,P1DGEnum);
    509509
    510510        /*Clean up and return*/
    … …  
    595595        IssmDouble  heatcapacity        = element->FindParam(MaterialsHeatcapacityEnum);
    596596        IssmDouble  thermalconductivity = element->FindParam(MaterialsThermalconductivityEnum);
    597         Input* vx_input  = element->GetInput(VxEnum);     _assert_(vx_input);
    598         Input* vy_input  = element->GetInput(VyEnum);     _assert_(vy_input);
    599         Input* vz_input  = element->GetInput(VzEnum);     _assert_(vz_input);
    600         Input* vxm_input = element->GetInput(VxMeshEnum); _assert_(vxm_input);
    601         Input* vym_input = element->GetInput(VyMeshEnum); _assert_(vym_input);
    602         Input* vzm_input = element->GetInput(VzMeshEnum); _assert_(vzm_input);
     597        Input2* vx_input  = element->GetInput2(VxEnum);     _assert_(vx_input);
     598        Input2* vy_input  = element->GetInput2(VyEnum);     _assert_(vy_input);
     599        Input2* vz_input  = element->GetInput2(VzEnum);     _assert_(vz_input);
     600        Input2* vxm_input = element->GetInput2(VxMeshEnum); _assert_(vxm_input);
     601        Input2* vym_input = element->GetInput2(VyMeshEnum); _assert_(vym_input);
     602        Input2* vzm_input = element->GetInput2(VzMeshEnum); _assert_(vzm_input);
    603603
    604604        /*Enthalpy diffusion parameter*/
    … …  
    818818        element->FindParam(&dt,TimesteppingTimeStepEnum);
    819819        element->FindParam(&stabilization,ThermalStabilizationEnum);
    820         Input* vx_input=element->GetInput(VxEnum); _assert_(vx_input);
    821         Input* vy_input=element->GetInput(VyEnum); _assert_(vy_input);
    822         Input* vz_input=element->GetInput(VzEnum); _assert_(vz_input);
    823         Input* enthalpypicard_input=element->GetInput(EnthalpyPicardEnum); _assert_(enthalpypicard_input);
    824         Input* pressure_input=element->GetInput(PressureEnum); _assert_(pressure_input);
    825         Input* enthalpy_input=NULL;
    826         if(reCast<bool,IssmDouble>(dt)){enthalpy_input = element->GetInput(EnthalpyEnum); _assert_(enthalpy_input);}
     820        Input2* vx_input=element->GetInput2(VxEnum); _assert_(vx_input);
     821        Input2* vy_input=element->GetInput2(VyEnum); _assert_(vy_input);
     822        Input2* vz_input=element->GetInput2(VzEnum); _assert_(vz_input);
     823        Input2* enthalpypicard_input=element->GetInput2(EnthalpyPicardEnum); _assert_(enthalpypicard_input);
     824        Input2* pressure_input=element->GetInput2(PressureEnum); _assert_(pressure_input);
     825        Input2* enthalpy_input=NULL;
     826        if(reCast<bool,IssmDouble>(dt)){enthalpy_input = element->GetInput2(EnthalpyEnum); _assert_(enthalpy_input);}
    827827
    828828        /* Start  looping on the number of gaussian points: */
    … …  
    940940        if(dt==0. && !converged) enthalpy_enum=EnthalpyPicardEnum; // use enthalpy from last iteration
    941941        else enthalpy_enum=EnthalpyEnum; // use enthalpy from last time step
    942         Input* vx_input             = element->GetInput(VxEnum);                          _assert_(vx_input);
    943         Input* vy_input             = element->GetInput(VyEnum);                          _assert_(vy_input);
    944         Input* vz_input             = element->GetInput(VzEnum);                          _assert_(vz_input);
    945         Input* enthalpy_input            = element->GetInput(enthalpy_enum);                                     _assert_(enthalpy_input);
    946         Input* pressure_input            = element->GetInput(PressureEnum);                                                      _assert_(pressure_input);
    947         Input* watercolumn_input         = element->GetInput(WatercolumnEnum);                                                   _assert_(watercolumn_input);
    948         Input* meltingrate_input         = element->GetInput(BasalforcingsGroundediceMeltingRateEnum);                                                   _assert_(meltingrate_input);
    949         Input* geothermalflux_input = element->GetInput(BasalforcingsGeothermalfluxEnum); _assert_(geothermalflux_input);
     942        Input2* vx_input             = element->GetInput2(VxEnum);                          _assert_(vx_input);
     943        Input2* vy_input             = element->GetInput2(VyEnum);                          _assert_(vy_input);
     944        Input2* vz_input             = element->GetInput2(VzEnum);                          _assert_(vz_input);
     945        Input2* enthalpy_input           = element->GetInput2(enthalpy_enum);                                    _assert_(enthalpy_input);
     946        Input2* pressure_input           = element->GetInput2(PressureEnum);                                                     _assert_(pressure_input);
     947        Input2* watercolumn_input        = element->GetInput2(WatercolumnEnum);                                                  _assert_(watercolumn_input);
     948        Input2* meltingrate_input        = element->GetInput2(BasalforcingsGroundediceMeltingRateEnum);                                                  _assert_(meltingrate_input);
     949        Input2* geothermalflux_input = element->GetInput2(BasalforcingsGeothermalfluxEnum); _assert_(geothermalflux_input);
    950950        IssmDouble  rho_ice                      = element->FindParam(MaterialsRhoIceEnum);
    951951
    … …  
    10331033        element->GetVerticesCoordinatesBase(&xyz_list_base);
    10341034        element->FindParam(&dt,TimesteppingTimeStepEnum);
    1035         Input*      pressure_input=element->GetInput(PressureEnum); _assert_(pressure_input);
     1035        Input2*      pressure_input=element->GetInput2(PressureEnum); _assert_(pressure_input);
    10361036        IssmDouble  gravity             = element->FindParam(ConstantsGEnum);
    10371037        IssmDouble  rho_water           = element->FindParam(MaterialsRhoSeawaterEnum);
    … …  
    10881088                        drainage[k]=DrainageFunctionWaterfraction(waterfractions[k], dt);
    10891089                }
    1090                 element->AddInput(WaterfractionDrainageEnum,drainage,element->GetElementType());
     1090                element->AddInput2(WaterfractionDrainageEnum,drainage,P1DGEnum);
    10911091
    10921092                xDelete<IssmDouble>(waterfractions);
    … …  
    11211121                        drainage_int[k]*=thicknesses[k];
    11221122                }
    1123                 element->AddInput(WaterfractionDrainageIntegratedEnum, drainage_int, element->GetElementType());
     1123                element->AddInput2(WaterfractionDrainageIntegratedEnum, drainage_int, P1DGEnum);
    11241124
    11251125                xDelete<IssmDouble>(drainage_int);
    … …  
    11441144                        watercolumn[basalnodeindices[k]]+=dt*drainage_int[basalnodeindices[k]];
    11451145                }
    1146                 element->AddInput(WatercolumnEnum, watercolumn, element->GetElementType());
     1146                element->AddInput2(WatercolumnEnum, watercolumn,P1DGEnum);
    11471147
    11481148                xDelete<IssmDouble>(watercolumn);
    … …  
    11801180                        element->ThermalToEnthalpy(&enthalpies[k], temperatures[k], waterfractions[k], pressures[k]);
    11811181                }
    1182                 element->AddInput(WaterfractionEnum,waterfractions,element->GetElementType());
    1183                 element->AddInput(EnthalpyEnum,enthalpies,element->GetElementType());
     1182                element->AddInput2(WaterfractionEnum,waterfractions,P1DGEnum);
     1183                element->AddInput2(EnthalpyEnum,enthalpies,P1DGEnum);
    11841184
    11851185                xDelete<IssmDouble>(enthalpies);
    … …  
    13661366
    13671367        /*Get parameters and inputs: */
    1368         Input* enthalpy_input            = element->GetInput(EnthalpyPicardEnum);                                        _assert_(enthalpy_input);
    1369         Input* pressure_input            = element->GetInput(PressureEnum);                                                      _assert_(pressure_input);
    1370         Input* watercolumn_input         = element->GetInput(WatercolumnEnum);                                                   _assert_(watercolumn_input);
    1371         Input* meltingrate_input         = element->GetInput(BasalforcingsGroundediceMeltingRateEnum);                                                   _assert_(meltingrate_input);
     1368        Input2* enthalpy_input           = element->GetInput2(EnthalpyPicardEnum);                                       _assert_(enthalpy_input);
     1369        Input2* pressure_input           = element->GetInput2(PressureEnum);                                                     _assert_(pressure_input);
     1370        Input2* watercolumn_input        = element->GetInput2(WatercolumnEnum);                                                  _assert_(watercolumn_input);
     1371        Input2* meltingrate_input        = element->GetInput2(BasalforcingsGroundediceMeltingRateEnum);                                                  _assert_(meltingrate_input);
    13721372
    13731373        /*Fetch indices of basal & surface nodes for this finite element*/
    … …  
    14371437
    14381438        /*Get parameters and inputs: */
    1439         Input* enthalpy_input       = element->GetInput(EnthalpyEnum);                    _assert_(enthalpy_input); //TODO: check EnthalpyPicard?
    1440         Input* pressure_input            = element->GetInput(PressureEnum);                                                      _assert_(pressure_input);
    1441         Input* watercolumn_input         = element->GetInput(WatercolumnEnum);                                                  _assert_(watercolumn_input);
    1442         Input* meltingrate_input         = element->GetInput(BasalforcingsGroundediceMeltingRateEnum);                                                  _assert_(meltingrate_input);
     1439        Input2* enthalpy_input    = element->GetInput2(EnthalpyEnum);                            _assert_(enthalpy_input); //TODO: check EnthalpyPicard?
     1440        Input2* pressure_input    = element->GetInput2(PressureEnum);                            _assert_(pressure_input);
     1441        Input2* watercolumn_input = element->GetInput2(WatercolumnEnum);                        _assert_(watercolumn_input);
     1442        Input2* meltingrate_input = element->GetInput2(BasalforcingsGroundediceMeltingRateEnum); _assert_(meltingrate_input);
    14431443
    14441444        /*Fetch indices of basal & surface nodes for this finite element*/
    … …  
    16081608                        //if(waterfraction[i]>1.) _error_("Water fraction >1 found in solution vector");
    16091609                }
    1610                 element->AddInput(EnthalpyEnum,values,element->GetElementType());
    1611                 element->AddInput(WaterfractionEnum,waterfraction,element->GetElementType());
    1612                 element->AddInput(TemperatureEnum,temperature,element->GetElementType());
     1610                _assert_(element->GetElementType()==P1Enum);
     1611                element->AddInput2(EnthalpyEnum,values,P1DGEnum);
     1612                element->AddInput2(WaterfractionEnum,waterfraction,P1DGEnum);
     1613                element->AddInput2(TemperatureEnum,temperature,P1DGEnum);
    16131614
    16141615                IssmDouble* n = xNew<IssmDouble>(numnodes);
    … …  
    16301631                        case BuddJackaEnum:
    16311632                                for(i=0;i<numnodes;i++) B[i]=BuddJacka(temperature[i]);
    1632                                 element->AddInput(MaterialsRheologyBEnum,&B[0],element->GetElementType());
     1633                                element->AddInput2(MaterialsRheologyBEnum,&B[0],P1DGEnum);
    16331634                                break;
    16341635                        case CuffeyEnum:
    16351636                                for(i=0;i<numnodes;i++) B[i]=Cuffey(temperature[i]);
    1636                                 element->AddInput(MaterialsRheologyBEnum,&B[0],element->GetElementType());
     1637                                element->AddInput2(MaterialsRheologyBEnum,&B[0],P1DGEnum);
    16371638                                break;
    16381639                        case CuffeyTemperateEnum:
    16391640                                for(i=0;i<numnodes;i++) B[i]=CuffeyTemperate(temperature[i], waterfraction[i],n[i]);
    1640                                 element->AddInput(MaterialsRheologyBEnum,&B[0],element->GetElementType());
     1641                                element->AddInput2(MaterialsRheologyBEnum,&B[0],P1DGEnum);
    16411642                                break;
    16421643                        case PatersonEnum:
    16431644                                for(i=0;i<numnodes;i++) B[i]=Paterson(temperature[i]);
    1644                                 element->AddInput(MaterialsRheologyBEnum,&B[0],element->GetElementType());
     1645                                element->AddInput2(MaterialsRheologyBEnum,&B[0],P1DGEnum);
    16451646                                break;
    16461647                        case NyeH2OEnum:
    16471648                                for(i=0;i<numnodes;i++) B[i]=NyeH2O(values[i]);
    1648                                 element->AddInput(MaterialsRheologyBEnum,&B[0],element->GetElementType());
     1649                                element->AddInput2(MaterialsRheologyBEnum,&B[0],P1DGEnum);
    16491650                                break;
    16501651                        case NyeCO2Enum:
    16511652                                for(i=0;i<numnodes;i++) B[i]=NyeCO2(values[i]);
    1652                                 element->AddInput(MaterialsRheologyBEnum,&B[0],element->GetElementType());
     1653                                element->AddInput2(MaterialsRheologyBEnum,&B[0],P1DGEnum);
    16531654                                break;
    16541655                        case ArrheniusEnum:{
    16551656                                element->GetVerticesCoordinates(&xyz_list);
    16561657                                for(i=0;i<numnodes;i++) B[i]=Arrhenius(temperature[i],surface[i]-xyz_list[i*3+2],n[i]);
    1657                                 element->AddInput(MaterialsRheologyBEnum,&B[0],element->GetElementType());
     1658                                element->AddInput2(MaterialsRheologyBEnum,&B[0],P1DGEnum);
    16581659                                break;
    16591660                                }
    16601661                        case LliboutryDuvalEnum:{
    1661                                 for(i=0;i<numnodes;i++) B[i]=LliboutryDuval(values[i],pressure[i],n[i],element->FindParam(MaterialsBetaEnum),element->FindParam(ConstantsReferencetemperatureEnum),element->FindParam(MaterialsHeatcapacityEnum),element->FindParam(MaterialsLatentheatEnum));
    1662                                 element->AddInput(MaterialsRheologyBEnum,&B[0],element->GetElementType());
    1663                                 break;
     1662                                for(i=0;i<numnodes;i++) B[i]=LliboutryDuval(values[i],pressure[i],n[i],element->FindParam(MaterialsBetaEnum),element->FindParam(ConstantsReferencetemperatureEnum),element->FindParam(MaterialsHeatcapacityEnum),element->FindParam(MaterialsLatentheatEnum)); 
     1663                                element->AddInput2(MaterialsRheologyBEnum,&B[0],P1DGEnum);
     1664                                break; 
    16641665                                }
    16651666                        default: _error_("Rheology law " << EnumToStringx(rheology_law) << " not supported yet");
    … …  
    16681669        }
    16691670        else{
    1670                 element->AddInput(EnthalpyPicardEnum,values,element->GetElementType());
     1671                element->AddInput2(EnthalpyPicardEnum,values,P1DGEnum);
    16711672        }
    16721673
    … …  
    16911692        femmodel->parameters->FindParam(&isdrainicecolumn,ThermalIsdrainicecolumnEnum);
    16921693
    1693         if(isdrainicecolumn)    DrainWaterfraction(femmodel);
    1694         if(computebasalmeltingrates)    ComputeBasalMeltingrate(femmodel);
     1694        if(isdrainicecolumn){
     1695                DrainWaterfraction(femmodel);
     1696        }
     1697        if(computebasalmeltingrates){
     1698                ComputeBasalMeltingrate(femmodel);
     1699        }
    16951700
    16961701}/*}}}*/

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

    r23585 r24335  
    1818                void CreateNodes(Nodes* nodes,IoModel* iomodel,bool isamr=false);
    1919                int  DofsPerNode(int** doflist,int domaintype,int approximation);
    20                 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
     20                void UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type);
    2121                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    2222

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

    r23585 r24335  
    1010                int  DofsPerNode(int** doflist,int domaintype,int approximation);
    1111                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    12                 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
     12                void UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type);
    1313                void CreateNodes(Nodes* nodes,IoModel* iomodel,bool isamr=false);
    1414                void CreateConstraints(Constraints* constraints,IoModel* iomodel);

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

    r23585 r24335  
    1818        return 1;
    1919}/*}}}*/
    20 void EsaAnalysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
     20void EsaAnalysis::UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
    2121
    2222        /*Update elements: */
    … …  
    2525                if(iomodel->my_elements[i]){
    2626                        Element* element=(Element*)elements->GetObjectByOffset(counter);
    27                         element->Update(i,iomodel,analysis_counter,analysis_type,P1Enum);
     27                        element->Update(inputs2,i,iomodel,analysis_counter,analysis_type,P1Enum);
    2828                        counter++;
    2929                }
    … …  
    3131
    3232        /*Create inputs: */
    33         iomodel->FetchDataToInput(elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
    34         iomodel->FetchDataToInput(elements,"md.esa.deltathickness",EsaDeltathicknessEnum);
     33        iomodel->FetchDataToInput(inputs2,elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
     34        iomodel->FetchDataToInput(inputs2,elements,"md.esa.deltathickness",EsaDeltathicknessEnum);
    3535
    3636}/*}}}*/

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

    r23585 r24335  
    1717                void CreateNodes(Nodes* nodes,IoModel* iomodel,bool isamr=false);
    1818                int  DofsPerNode(int** doflist,int domaintype,int approximation);
    19                 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
     19                void UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type);
    2020                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    2121

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

    r23585 r24335  
    2626}
    2727/*}}}*/
    28 void ExtrapolationAnalysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
     28void ExtrapolationAnalysis::UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
    2929        int    finiteelement;
    3030
    … …  
    3737                if(iomodel->my_elements[i]){
    3838                        Element* element=(Element*)elements->GetObjectByOffset(counter);
    39                         element->Update(i,iomodel,analysis_counter,analysis_type,finiteelement);
     39                        element->Update(inputs2,i,iomodel,analysis_counter,analysis_type,finiteelement);
    4040                        counter++;
    4141                }
    4242        }
    4343        if(iomodel->domaintype!=Domain2DhorizontalEnum){
    44                 iomodel->FetchDataToInput(elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum);
    45                 iomodel->FetchDataToInput(elements,"md.mesh.vertexonsurface",MeshVertexonsurfaceEnum);
     44                iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum);
     45                iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonsurface",MeshVertexonsurfaceEnum);
    4646        }
    4747}
    … …  
    124124
    125125        /*Retrieve all inputs and parameters*/
    126         Input* lsf_slopex_input=workelement->GetInput(LevelsetfunctionSlopeXEnum); _assert_(lsf_slopex_input);
    127         Input* lsf_slopey_input=workelement->GetInput(LevelsetfunctionSlopeYEnum); _assert_(lsf_slopey_input);
     126        Input2* lsf_slopex_input=workelement->GetInput2(LevelsetfunctionSlopeXEnum); _assert_(lsf_slopex_input);
     127        Input2* lsf_slopey_input=workelement->GetInput2(LevelsetfunctionSlopeYEnum); _assert_(lsf_slopey_input);
    128128        workelement->GetVerticesCoordinates(&xyz_list);
    129129
    … …  
    338338        element->FindParam(&extvar_enum, ExtrapolationVariableEnum);
    339339
    340         Input* active_input=element->GetInput(IceMaskNodeActivationEnum); _assert_(active_input);
    341         Input* extvar_input=element->GetInput(extvar_enum); _assert_(extvar_input);
     340        Input2* active_input=element->GetInput2(IceMaskNodeActivationEnum); _assert_(active_input);
     341        Input2* extvar_input=element->GetInput2(extvar_enum); _assert_(extvar_input);
    342342
    343343        Gauss* gauss=element->NewGauss();

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

    r23585 r24335  
    1717        void CreateNodes(Nodes* nodes,IoModel* iomodel,bool isamr=false);
    1818        int  DofsPerNode(int** doflist,int domaintype,int approximation);
    19         void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
     19        void UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type);
    2020        void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    2121

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

    r23585 r24335  
    1818        return 1;
    1919}/*}}}*/
    20 void ExtrudeFromBaseAnalysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
     20void ExtrudeFromBaseAnalysis::UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
    2121
    2222        int counter=0;
    … …  
    2424                if(iomodel->my_elements[i]){
    2525                        Element* element=(Element*)elements->GetObjectByOffset(counter);
    26                         element->Update(i,iomodel,analysis_counter,analysis_type,P1Enum);
     26                        element->Update(inputs2,i,iomodel,analysis_counter,analysis_type,P1Enum);
    2727                        counter++;
    2828                }
    … …  
    3030
    3131        if(iomodel->domaintype==Domain2DverticalEnum){
    32                 iomodel->FetchDataToInput(elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum);
     32                iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum);
    3333        }
    3434}/*}}}*/

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

    r23585 r24335  
    1717                void CreateNodes(Nodes* nodes,IoModel* iomodel,bool isamr=false);
    1818                int  DofsPerNode(int** doflist,int domaintype,int approximation);
    19                 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
     19                void UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type);
    2020                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    2121

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

    r23585 r24335  
    1818        return 1;
    1919}/*}}}*/
    20 void ExtrudeFromTopAnalysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
     20void ExtrudeFromTopAnalysis::UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
    2121
    2222        int counter=0;
    … …  
    2424                if(iomodel->my_elements[i]){
    2525                        Element* element=(Element*)elements->GetObjectByOffset(counter);
    26                         element->Update(i,iomodel,analysis_counter,analysis_type,P1Enum);
     26                        element->Update(inputs2,i,iomodel,analysis_counter,analysis_type,P1Enum);
    2727                        counter++;
    2828                }
    … …  
    3030
    3131        if(iomodel->domaintype==Domain2DverticalEnum){
    32                 iomodel->FetchDataToInput(elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum);
     32                iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum);
    3333        }
    3434}/*}}}*/

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

    r23585 r24335  
    1717                void CreateNodes(Nodes* nodes,IoModel* iomodel,bool isamr=false);
    1818                int  DofsPerNode(int** doflist,int domaintype,int approximation);
    19                 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
     19                void UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type);
    2020                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    2121

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

    r24145 r24335  
    5555        return 1;
    5656}/*}}}*/
    57 void FreeSurfaceBaseAnalysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
     57void FreeSurfaceBaseAnalysis::UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
    5858
    5959        /*Now, is the model 3d? otherwise, do nothing: */
    … …  
    6868                if(iomodel->my_elements[i]){
    6969                        Element* element=(Element*)elements->GetObjectByOffset(counter);
    70                         element->Update(i,iomodel,analysis_counter,analysis_type,finiteelement);
     70                        element->Update(inputs2,i,iomodel,analysis_counter,analysis_type,finiteelement);
    7171                        counter++;
    7272                }
    7373        }
    7474
    75         iomodel->FetchDataToInput(elements,"md.geometry.surface",SurfaceEnum);
    76         iomodel->FetchDataToInput(elements,"md.slr.sealevel",SealevelEnum,0);
    77         iomodel->FetchDataToInput(elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
    78         iomodel->FetchDataToInput(elements,"md.basalforcings.groundedice_melting_rate",BasalforcingsGroundediceMeltingRateEnum,0.);
    79         iomodel->FetchDataToInput(elements,"md.initialization.vx",VxEnum);
    80         iomodel->FetchDataToInput(elements,"md.initialization.vy",VyEnum);
     75        iomodel->FetchDataToInput(inputs2,elements,"md.geometry.surface",SurfaceEnum);
     76        iomodel->FetchDataToInput(inputs2,elements,"md.slr.sealevel",SealevelEnum,0);
     77        iomodel->FetchDataToInput(inputs2,elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
     78        iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.groundedice_melting_rate",BasalforcingsGroundediceMeltingRateEnum,0.);
     79        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.vx",VxEnum);
     80        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.vy",VyEnum);
    8181        if(iomodel->domaindim==3){
    82                 iomodel->FetchDataToInput(elements,"md.initialization.vz",VzEnum);
     82                iomodel->FetchDataToInput(inputs2,elements,"md.initialization.vz",VzEnum);
    8383        }
    8484        if(iomodel->domaintype!=Domain2DhorizontalEnum){
    85                 iomodel->FetchDataToInput(elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum);
    86                 iomodel->FetchDataToInput(elements,"md.mesh.vertexonsurface",MeshVertexonsurfaceEnum);
     85                iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum);
     86                iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonsurface",MeshVertexonsurfaceEnum);
    8787        }
    8888
    … …  
    9292        switch(basalforcing_model){
    9393                case FloatingMeltRateEnum:
    94                         iomodel->FetchDataToInput(elements,"md.basalforcings.floatingice_melting_rate",BasalforcingsFloatingiceMeltingRateEnum);
     94                        iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.floatingice_melting_rate",BasalforcingsFloatingiceMeltingRateEnum);
    9595                        break;
    9696                case LinearFloatingMeltRateEnum:
    … …  
    101101                        break;
    102102                case SpatialLinearFloatingMeltRateEnum:
    103                         iomodel->FetchDataToInput(elements,"md.basalforcings.deepwater_melting_rate",BasalforcingsDeepwaterMeltingRateEnum);
    104                         iomodel->FetchDataToInput(elements,"md.basalforcings.deepwater_elevation",BasalforcingsDeepwaterElevationEnum);
    105                         iomodel->FetchDataToInput(elements,"md.basalforcings.upperwater_elevation",BasalforcingsUpperwaterElevationEnum);
     103                        iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.deepwater_melting_rate",BasalforcingsDeepwaterMeltingRateEnum);
     104                        iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.deepwater_elevation",BasalforcingsDeepwaterElevationEnum);
     105                        iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.upperwater_elevation",BasalforcingsUpperwaterElevationEnum);
    106106                        break;
    107107                case BasalforcingsPicoEnum:
    108                         iomodel->FetchDataToInput(elements,"md.basalforcings.basin_id",BasalforcingsPicoBasinIdEnum);
     108                        iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.basin_id",BasalforcingsPicoBasinIdEnum);
    109109                        break;
    110110                case BasalforcingsIsmip6Enum:
    111                         iomodel->FetchDataToInput(elements,"md.basalforcings.basin_id",BasalforcingsIsmip6BasinIdEnum);
     111                        iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.basin_id",BasalforcingsIsmip6BasinIdEnum);
    112112                        break;
    113113                case BeckmannGoosseFloatingMeltRateEnum:
    114                         iomodel->FetchDataToInput(elements,"md.basalforcings.ocean_salinity",BasalforcingsOceanSalinityEnum);
    115                         iomodel->FetchDataToInput(elements,"md.basalforcings.ocean_temp",BasalforcingsOceanTempEnum);
     114                        iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.ocean_salinity",BasalforcingsOceanSalinityEnum);
     115                        iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.ocean_temp",BasalforcingsOceanTempEnum);
    116116                        break;
    117117                default:
    … …  
    176176        basalelement->FindParam(&dt,TimesteppingTimeStepEnum);
    177177        basalelement->FindParam(&stabilization,MasstransportStabilizationEnum);
    178         Input* vx_input=basalelement->GetInput(VxEnum); _assert_(vx_input);
    179         Input* vy_input=NULL;
    180         if(dim>1){vy_input = basalelement->GetInput(VyEnum); _assert_(vy_input);}
     178        Input2* vx_input=basalelement->GetInput2(VxEnum); _assert_(vx_input);
     179        Input2* vy_input=NULL;
     180        if(dim>1){vy_input = basalelement->GetInput2(VyEnum); _assert_(vy_input);}
    181181        h = basalelement->CharacteristicLength();
    182182
    … …  
    295295        basalelement->GetVerticesCoordinates(&xyz_list);
    296296        basalelement->FindParam(&dt,TimesteppingTimeStepEnum);
    297         Input* groundedice_input   = basalelement->GetInput(MaskGroundediceLevelsetEnum);              _assert_(groundedice_input);
    298         Input* gmb_input           = basalelement->GetInput(BasalforcingsGroundediceMeltingRateEnum);  _assert_(gmb_input);
    299         Input* fmb_input           = basalelement->GetInput(BasalforcingsFloatingiceMeltingRateEnum);  _assert_(fmb_input);
    300         Input* base_input          = basalelement->GetInput(BaseEnum);                                 _assert_(base_input);
    301         Input* vz_input      = NULL;
     297        Input2* groundedice_input   = basalelement->GetInput2(MaskGroundediceLevelsetEnum);              _assert_(groundedice_input);
     298        Input2* gmb_input           = basalelement->GetInput2(BasalforcingsGroundediceMeltingRateEnum);  _assert_(gmb_input);
     299        Input2* fmb_input           = basalelement->GetInput2(BasalforcingsFloatingiceMeltingRateEnum);  _assert_(fmb_input);
     300        Input2* base_input          = basalelement->GetInput2(BaseEnum);                                 _assert_(base_input);
     301        Input2* vz_input      = NULL;
    302302        switch(dim){
    303                 case 1: vz_input = basalelement->GetInput(VyEnum); _assert_(vz_input); break;
    304                 case 2: vz_input = basalelement->GetInput(VzEnum); _assert_(vz_input); break;
     303                case 1: vz_input = basalelement->GetInput2(VyEnum); _assert_(vz_input); break;
     304                case 2: vz_input = basalelement->GetInput2(VzEnum); _assert_(vz_input); break;
    305305                default: _error_("not implemented");
    306306        }
    … …  
    410410
    411411                int             numnodes = element->GetNumberOfNodes();
    412                 Input* groundedice_input = element->GetInput(MaskGroundediceLevelsetEnum);  _assert_(groundedice_input);
    413                 Input* onbase_input       = element->GetInput(MeshVertexonbaseEnum);          _assert_(onbase_input);
    414                 Input* base_input        = element->GetInput(BaseEnum);                     _assert_(base_input);
     412                Input2* groundedice_input = element->GetInput2(MaskGroundediceLevelsetEnum);  _assert_(groundedice_input);
     413                Input2* onbase_input       = element->GetInput2(MeshVertexonbaseEnum);          _assert_(onbase_input);
     414                Input2* base_input        = element->GetInput2(BaseEnum);                     _assert_(base_input);
    415415
    416416                Gauss* gauss=element->NewGauss();

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

    r23585 r24335  
    1717                void CreateNodes(Nodes* nodes,IoModel* iomodel,bool isamr=false);
    1818                int  DofsPerNode(int** doflist,int domaintype,int approximation);
    19                 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
     19                void UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type);
    2020                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    2121

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

    r23959 r24335  
    5555        return 1;
    5656}/*}}}*/
    57 void FreeSurfaceTopAnalysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
     57void FreeSurfaceTopAnalysis::UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
    5858
    5959        /*Now, is the model 3d? otherwise, do nothing: */
    … …  
    7171                if(iomodel->my_elements[i]){
    7272                        Element* element=(Element*)elements->GetObjectByOffset(counter);
    73                         element->Update(i,iomodel,analysis_counter,analysis_type,finiteelement);
     73                        element->Update(inputs2,i,iomodel,analysis_counter,analysis_type,finiteelement);
    7474                        counter++;
    7575                }
    7676        }
    7777
    78         iomodel->FetchDataToInput(elements,"md.geometry.surface",SurfaceEnum);
    79         iomodel->FetchDataToInput(elements,"md.slr.sealevel",SealevelEnum,0);
    80         iomodel->FetchDataToInput(elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
    81         iomodel->FetchDataToInput(elements,"md.initialization.vx",VxEnum);
     78        iomodel->FetchDataToInput(inputs2,elements,"md.geometry.surface",SurfaceEnum);
     79        iomodel->FetchDataToInput(inputs2,elements,"md.slr.sealevel",SealevelEnum,0);
     80        iomodel->FetchDataToInput(inputs2,elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
     81        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.vx",VxEnum);
    8282        if(iomodel->domaintype!=Domain2DhorizontalEnum){
    83                 iomodel->FetchDataToInput(elements,"md.mesh.vertexonsurface",MeshVertexonsurfaceEnum);
    84                 iomodel->FetchDataToInput(elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum);
     83                iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonsurface",MeshVertexonsurfaceEnum);
     84                iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum);
    8585        }
    8686        if(iomodel->domaindim==3){
    87                 iomodel->FetchDataToInput(elements,"md.initialization.vz",VzEnum);
     87                iomodel->FetchDataToInput(inputs2,elements,"md.initialization.vz",VzEnum);
    8888        }
    8989        switch(smb_model){
    9090                case SMBforcingEnum:
    91                         iomodel->FetchDataToInput(elements,"md.smb.mass_balance",SmbMassBalanceEnum,0.);
     91                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.mass_balance",SmbMassBalanceEnum,0.);
    9292                        break;
    9393                default:
    … …  
    153153        topelement->FindParam(&dt,TimesteppingTimeStepEnum);
    154154        topelement->FindParam(&stabilization,MasstransportStabilizationEnum);
    155         Input* vx_input=topelement->GetInput(VxEnum); _assert_(vx_input);
    156         Input* vy_input=NULL;
    157         if(dim>1){vy_input = topelement->GetInput(VyEnum); _assert_(vy_input);}
     155        Input2* vx_input=topelement->GetInput2(VxEnum); _assert_(vx_input);
     156        Input2* vy_input=NULL;
     157        if(dim>1){vy_input = topelement->GetInput2(VyEnum); _assert_(vy_input);}
    158158        h = topelement->CharacteristicLength();
    159159
    … …  
    211211                                vx_input->GetInputAverage(&vx);
    212212                                vy_input->GetInputAverage(&vy);
     213
    213214                                D[0*dim+0]=h/2.0*fabs(vx);
    214215                                D[1*dim+1]=h/2.0*fabs(vy);
    … …  
    272273        topelement->GetVerticesCoordinates(&xyz_list);
    273274        topelement->FindParam(&dt,TimesteppingTimeStepEnum);
    274         Input* ms_input      = topelement->GetInput(SmbMassBalanceEnum);  _assert_(ms_input);
    275         Input* surface_input = topelement->GetInput(SurfaceEnum);                     _assert_(surface_input);
    276         Input* vz_input      = NULL;
     275        Input2* ms_input      = topelement->GetInput2(SmbMassBalanceEnum);  _assert_(ms_input);
     276        Input2* surface_input = topelement->GetInput2(SurfaceEnum);                     _assert_(surface_input);
     277        Input2* vz_input      = NULL;
    277278        switch(dim){
    278                 case 1: vz_input = topelement->GetInput(VyEnum); _assert_(vz_input); break;
    279                 case 2: vz_input = topelement->GetInput(VzEnum); _assert_(vz_input); break;
     279                case 1: vz_input = topelement->GetInput2(VyEnum); _assert_(vz_input); break;
     280                case 2: vz_input = topelement->GetInput2(VzEnum); _assert_(vz_input); break;
    280281                default: _error_("not implemented");
    281282        }

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

    r23585 r24335  
    1717                void CreateNodes(Nodes* nodes,IoModel* iomodel,bool isamr=false);
    1818                int  DofsPerNode(int** doflist,int domaintype,int approximation);
    19                 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
     19                void UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type);
    2020                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    2121

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

    r24010 r24335  
    2424        return 1;
    2525}/*}}}*/
    26 void GLheightadvectionAnalysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
     26void GLheightadvectionAnalysis::UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
    2727
    2828        /*Update elements: */
    … …  
    3131                if(iomodel->my_elements[i]){
    3232                        Element* element=(Element*)elements->GetObjectByOffset(counter);
    33                         element->Update(i,iomodel,analysis_counter,analysis_type,P1Enum);
     33                        element->Update(inputs2,i,iomodel,analysis_counter,analysis_type,P1Enum);
    3434                        counter++;
    3535                }
    … …  
    3737
    3838        if(iomodel->domaintype!=Domain2DhorizontalEnum){
    39                 iomodel->FetchDataToInput(elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum);
    40                 iomodel->FetchDataToInput(elements,"md.mesh.vertexonsurface",MeshVertexonsurfaceEnum);
    41         }
    42         iomodel->FetchDataToInput(elements,"md.mesh.vertexonboundary",MeshVertexonboundaryEnum);
     39                iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum);
     40                iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonsurface",MeshVertexonsurfaceEnum);
     41        }
     42        iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonboundary",MeshVertexonboundaryEnum);
    4343}/*}}}*/
    4444void GLheightadvectionAnalysis::UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
    … …  
    7171        IssmDouble vel,vx,vy;
    7272        IssmDouble* xyz_list      = NULL;
    73         Input* vx_input           = NULL;
    74         Input* vy_input           = NULL;
    75         Input* bc_input           = NULL;
     73        Input2* vx_input           = NULL;
     74        Input2* vy_input           = NULL;
     75        Input2* bc_input           = NULL;
    7676
    7777        /*Get problem dimension*/
    … …  
    9797        switch(domaintype){
    9898                case Domain2DhorizontalEnum:
    99                         vx_input=basalelement->GetInput(VxEnum); _assert_(vx_input);
    100                         vy_input=basalelement->GetInput(VyEnum); _assert_(vy_input);
    101                    bc_input=basalelement->GetInput(MeshVertexonboundaryEnum); _assert_(bc_input);
     99                        vx_input=basalelement->GetInput2(VxEnum); _assert_(vx_input);
     100                        vy_input=basalelement->GetInput2(VyEnum); _assert_(vy_input);
     101                   bc_input=basalelement->GetInput2(MeshVertexonboundaryEnum); _assert_(bc_input);
    102102                break;
    103103                case Domain3DEnum:
    104                         vx_input=basalelement->GetInput(VxAverageEnum); _assert_(vx_input);
    105                         vy_input=basalelement->GetInput(VyAverageEnum); _assert_(vy_input);
    106                         bc_input=basalelement->GetInput(MeshVertexonboundaryEnum); _assert_(bc_input);
     104                        vx_input=basalelement->GetInput2(VxAverageEnum); _assert_(vx_input);
     105                        vy_input=basalelement->GetInput2(VyAverageEnum); _assert_(vy_input);
     106                        bc_input=basalelement->GetInput2(MeshVertexonboundaryEnum); _assert_(bc_input);
    107107                break;
    108108                default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");

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

    r23585 r24335  
    1717                void CreateNodes(Nodes* nodes,IoModel* iomodel,bool isamr=false);
    1818                int  DofsPerNode(int** doflist,int domaintype,int approximation);
    19                 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
     19                void UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type);
    2020                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    2121

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

    r23585 r24335  
    1818        return 1;
    1919}/*}}}*/
    20 void GiaIvinsAnalysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
     20void GiaIvinsAnalysis::UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
    2121
    2222        /*Update elements: */
    … …  
    2525                if(iomodel->my_elements[i]){
    2626                        Element* element=(Element*)elements->GetObjectByOffset(counter);
    27                         element->Update(i,iomodel,analysis_counter,analysis_type,P1Enum);
     27                        element->Update(inputs2,i,iomodel,analysis_counter,analysis_type,P1Enum);
    2828                        counter++;
    2929                }
    3030        }
    3131
    32         iomodel->FetchDataToInput(elements,"md.geometry.thickness",ThicknessEnum);
    33         iomodel->FetchDataToInput(elements,"md.gia.mantle_viscosity",GiaMantleViscosityEnum);
    34         iomodel->FetchDataToInput(elements,"md.gia.lithosphere_thickness",GiaLithosphereThicknessEnum);
    35         iomodel->FetchDataToInput(elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
     32        iomodel->FetchDataToInput(inputs2,elements,"md.geometry.thickness",ThicknessEnum);
     33        iomodel->FetchDataToInput(inputs2,elements,"md.gia.mantle_viscosity",GiaMantleViscosityEnum);
     34        iomodel->FetchDataToInput(inputs2,elements,"md.gia.lithosphere_thickness",GiaLithosphereThicknessEnum);
     35        iomodel->FetchDataToInput(inputs2,elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
    3636}/*}}}*/
    3737void GiaIvinsAnalysis::UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/

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

    r23585 r24335  
    1717                void CreateNodes(Nodes* nodes,IoModel* iomodel,bool isamr=false);
    1818                int  DofsPerNode(int** doflist,int domaintype,int approximation);
    19                 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
     19                void UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type);
    2020                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    2121

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

    r24240 r24335  
    99        return 1;
    1010}/*}}}*/
    11 
    1211void HydrologyDCEfficientAnalysis::UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
    1312
    … …  
    3534        parameters->AddObject(new IntParam(HydrologydcEplThickCompEnum,eplthickcomp));
    3635}/*}}}*/
    37 
    38 void HydrologyDCEfficientAnalysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
     36void HydrologyDCEfficientAnalysis::UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
    3937
    4038        bool   isefficientlayer;
    … …  
    5452                if(iomodel->my_elements[i]){
    5553                        Element* element=(Element*)elements->GetObjectByOffset(counter);
    56                         element->Update(i,iomodel,analysis_counter,analysis_type,P1Enum);
     54                        element->Update(inputs2,i,iomodel,analysis_counter,analysis_type,P1Enum);
    5755                        counter++;
    5856                }
    5957        }
    60         iomodel->FetchDataToInput(elements,"md.geometry.thickness",ThicknessEnum);
    61         iomodel->FetchDataToInput(elements,"md.geometry.base",BaseEnum);
    62         iomodel->FetchDataToInput(elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
    63         iomodel->FetchDataToInput(elements,"md.initialization.epl_head",EplHeadSubstepEnum);
    64         iomodel->FetchDataToInput(elements,"md.initialization.sediment_head",SedimentHeadSubstepEnum);
    65         iomodel->FetchDataToInput(elements,"md.initialization.epl_thickness",HydrologydcEplThicknessSubstepEnum);
    66         iomodel->FetchDataToInput(elements,"md.hydrology.basal_moulin_input",HydrologydcBasalMoulinInputEnum);
     58        iomodel->FetchDataToInput(inputs2,elements,"md.geometry.thickness",ThicknessEnum);
     59        iomodel->FetchDataToInput(inputs2,elements,"md.geometry.base",BaseEnum);
     60        iomodel->FetchDataToInput(inputs2,elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
     61        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.epl_head",EplHeadSubstepEnum);
     62        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.sediment_head",SedimentHeadSubstepEnum);
     63        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.epl_thickness",HydrologydcEplThicknessSubstepEnum);
     64        iomodel->FetchDataToInput(inputs2,elements,"md.hydrology.basal_moulin_input",HydrologydcBasalMoulinInputEnum);
    6765        if(iomodel->domaintype!=Domain2DhorizontalEnum){
    68                 iomodel->FetchDataToInput(elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum);
    69                 iomodel->FetchDataToInput(elements,"md.mesh.vertexonsurface",MeshVertexonsurfaceEnum);
    70         }
    71 }/*}}}*/
    72 
     66                iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum);
     67                iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonsurface",MeshVertexonsurfaceEnum);
     68        }
     69}/*}}}*/
    7370void HydrologyDCEfficientAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel,bool isamr){/*{{{*/
    7471
    … …  
    8986        iomodel->DeleteData(2,"md.mesh.vertexonbase","md.mesh.vertexonsurface");
    9087}/*}}}*/
    91 
    9288void HydrologyDCEfficientAnalysis::CreateConstraints(Constraints* constraints,IoModel* iomodel){/*{{{*/
    9389
    … …  
    104100        IoModelToConstraintsx(constraints,iomodel,"md.hydrology.spcepl_head",HydrologyDCEfficientAnalysisEnum,P1Enum);
    105101}/*}}}*/
    106 
    107102void HydrologyDCEfficientAnalysis::CreateLoads(Loads* loads, IoModel* iomodel){/*{{{*/
    108103
    … …  
    139134        iomodel->DeleteData(1,"md.mesh.vertexonbase");
    140135}/*}}}*/
    141 
    142136void HydrologyDCEfficientAnalysis::InitZigZagCounter(FemModel* femmodel){/*{{{*/
    143137
    … …  
    147141        xDelete<int>(eplzigzag_counter);
    148142}/*}}}*/
    149 
    150143void HydrologyDCEfficientAnalysis::ResetCounter(FemModel* femmodel){/*{{{*/
    151144
    … …  
    163156        _error_("not implemented");
    164157}/*}}}*/
    165 
    166158ElementVector* HydrologyDCEfficientAnalysis::CreateDVector(Element* element){/*{{{*/
    167159        /*Default, return NULL*/
    168160        return NULL;
    169161}/*}}}*/
    170 
    171162ElementMatrix* HydrologyDCEfficientAnalysis::CreateJacobianMatrix(Element* element){/*{{{*/
    172163_error_("Not implemented");
    173164}/*}}}*/
    174 
    175165ElementMatrix* HydrologyDCEfficientAnalysis::CreateKMatrix(Element* element){/*{{{*/
    176166
    … …  
    193183        }
    194184
    195         Input* active_element_input = basalelement->GetInput(HydrologydcMaskEplactiveEltEnum); _assert_(active_element_input);
    196         active_element_input->GetInputValue(&active_element);
     185        basalelement->GetInputValue(&active_element,HydrologydcMaskEplactiveEltEnum);
    197186
    198187        /*Check that all nodes are active, else return empty matrix*/
    … …  
    224213        basalelement->GetVerticesCoordinates(&xyz_list);
    225214        basalelement->FindParam(&dt,TimesteppingTimeStepEnum);
    226 
    227         Input* epl_thick_input = basalelement->GetInput(HydrologydcEplThicknessSubstepEnum); _assert_(epl_thick_input);
    228         Input* epl_head_input   = basalelement->GetInput(EplHeadSubstepEnum);  _assert_(epl_head_input);
    229         Input* base_input                       = basalelement->GetInput(BaseEnum); _assert_(base_input);
     215        Input2* epl_thick_input = basalelement->GetInput2(HydrologydcEplThicknessSubstepEnum); _assert_(epl_thick_input);
     216        Input2* epl_head_input  = basalelement->GetInput2(EplHeadSubstepEnum);  _assert_(epl_head_input);
     217        Input2* base_input      = basalelement->GetInput2(BaseEnum); _assert_(base_input);
    230218
    231219        /* Start  looping on the number of gaussian points: */
    … …  
    279267        return Ke;
    280268}/*}}}*/
    281 
    282269ElementVector* HydrologyDCEfficientAnalysis::CreatePVector(Element* element){/*{{{*/
    283270
    … …  
    300287        }
    301288
    302         Input* active_element_input = basalelement->GetInput(HydrologydcMaskEplactiveEltEnum); _assert_(active_element_input);
    303         active_element_input->GetInputValue(&active_element);
     289        basalelement->GetInputValue(&active_element,HydrologydcMaskEplactiveEltEnum);
    304290
    305291        /*Check that all nodes are active, else return empty matrix*/
    … …  
    319305        IssmDouble residual,connectivity;
    320306
    321         IssmDouble              *xyz_list                                = NULL;
    322         Input*                   old_wh_input                    = NULL;
    323         Input*                   surface_runoff_input = NULL;
     307        IssmDouble *xyz_list            = NULL;
     308        Input2     *old_wh_input        = NULL;
     309        Input2     *surface_runoff_input = NULL;
    324310
    325311        /*Fetch number of nodes and dof for this finite element*/
    … …  
    336322        basalelement ->FindParam(&smb_model,SmbEnum);
    337323
    338         Input*  epl_thick_input                  = basalelement->GetInput(HydrologydcEplThicknessSubstepEnum); _assert_(epl_thick_input);
    339         Input*  sed_head_input                   = basalelement->GetInput(SedimentHeadSubstepEnum); _assert_(sed_head_input);
    340         Input*  epl_head_input                   = basalelement->GetInput(EplHeadSubstepEnum); _assert_(epl_head_input);
    341         Input*  basal_melt_input                 = basalelement->GetInput(BasalforcingsGroundediceMeltingRateEnum); _assert_(basal_melt_input);
    342         Input*  residual_input                   = basalelement->GetInput(SedimentHeadResidualEnum); _assert_(residual_input);
    343         Input*  base_input                                       = basalelement->GetInput(BaseEnum); _assert_(base_input);
     324        Input2* epl_thick_input  = basalelement->GetInput2(HydrologydcEplThicknessSubstepEnum); _assert_(epl_thick_input);
     325        Input2* sed_head_input   = basalelement->GetInput2(SedimentHeadSubstepEnum); _assert_(sed_head_input);
     326        Input2* epl_head_input   = basalelement->GetInput2(EplHeadSubstepEnum); _assert_(epl_head_input);
     327        Input2* basal_melt_input = basalelement->GetInput2(BasalforcingsGroundediceMeltingRateEnum); _assert_(basal_melt_input);
     328        Input2* residual_input   = basalelement->GetInput2(SedimentHeadResidualEnum); _assert_(residual_input);
     329        Input2* base_input       = basalelement->GetInput2(BaseEnum); _assert_(base_input);
    344330
    345331        if(dt!= 0.){
    346                 old_wh_input = basalelement->GetInput(EplHeadOldEnum);            _assert_(old_wh_input);
     332                old_wh_input = basalelement->GetInput2(EplHeadOldEnum);            _assert_(old_wh_input);
    347333        }
    348334        if(smb_model==SMBgradientscomponentsEnum){
    349                 surface_runoff_input = basalelement->GetInput(SmbRunoffEnum); _assert_(surface_runoff_input);
     335                surface_runoff_input = basalelement->GetInput2(SmbRunoffEnum); _assert_(surface_runoff_input);
    350336        }
    351337
    … …  
    397383        return pe;
    398384}/*}}}*/
    399 
    400385void HydrologyDCEfficientAnalysis::GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element){/*{{{*/
    401386        element->GetSolutionFromInputsOneDof(solution,EplHeadSubstepEnum);
    402387}/*}}}*/
    403 
    404388void HydrologyDCEfficientAnalysis::GradientJ(Vector<IssmDouble>* gradient,Element* element,int control_type,int control_index){/*{{{*/
    405389        _error_("Not implemented yet");
    406390}/*}}}*/
    407 
    408391void HydrologyDCEfficientAnalysis::InputUpdateFromSolution(IssmDouble* solution,Element* element){/*{{{*/
    409392        /*Intermediaries*/
    … …  
    441424        }
    442425        /*Add input to the element: */
    443         element->AddBasalInput(EplHeadSubstepEnum,eplHeads,P1Enum);
     426        element->AddBasalInput2(EplHeadSubstepEnum,eplHeads,P1Enum);
     427
    444428        /*Free ressources:*/
    445429        xDelete<IssmDouble>(eplHeads);
    … …  
    447431        if(domaintype!=Domain2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
    448432} /*}}}*/
    449 
    450433void HydrologyDCEfficientAnalysis::UpdateConstraints(FemModel* femmodel){/*{{{*/
    451434        /*Default, do nothing*/
    … …  
    475458        return transfer;
    476459}/*}}}*/
    477 
    478 IssmDouble HydrologyDCEfficientAnalysis::GetHydrologyPVectorTransfer(Element* element, Gauss* gauss, Input* sed_head_input){/*{{{*/
     460IssmDouble HydrologyDCEfficientAnalysis::GetHydrologyPVectorTransfer(Element* element, Gauss* gauss, Input2* sed_head_input){/*{{{*/
    479461
    480462        int transfermethod;
    … …  
    501483        return transfer;
    502484}/*}}}*/
    503 
    504485void HydrologyDCEfficientAnalysis::ComputeEPLThickness(FemModel* femmodel){/*{{{*/
    505486
    … …  
    534515                IssmDouble* bed           = xNew<IssmDouble>(numnodes);
    535516
    536                 Input*  active_element_input=element->GetInput(HydrologydcMaskEplactiveEltEnum); _assert_(active_element_input);
    537                 active_element_input->GetInputValue(&active_element);
     517                element->GetInputValue(&active_element,HydrologydcMaskEplactiveEltEnum);
    538518                element->FindParam(&dt,TimesteppingTimeStepEnum);
    539519
    … …  
    590570                        }
    591571                }
    592                 element->AddInput(HydrologydcEplThicknessSubstepEnum,thickness,element->GetElementType());
     572                element->AddInput2(HydrologydcEplThicknessSubstepEnum,thickness,element->GetElementType());
    593573                xDelete<IssmDouble>(thickness);
    594574                xDelete<IssmDouble>(eplhead);
    … …  
    602582        }
    603583}/*}}}*/
    604 
    605584void HydrologyDCEfficientAnalysis::GetB(IssmDouble* B,Element* element,IssmDouble* xyz_list,Gauss* gauss){/*{{{*/
    606585        /*Compute B  matrix. B=[B1 B2 B3] where Bi is of size 3*NDOF2.
    … …  
    630609        xDelete<IssmDouble>(dbasis);
    631610}/*}}}*/
    632 
    633 void  HydrologyDCEfficientAnalysis::HydrologyEPLGetMask(Vector<IssmDouble>* vec_mask, Vector<IssmDouble>* recurence, Element* element){
     611void  HydrologyDCEfficientAnalysis::HydrologyEPLGetMask(Vector<IssmDouble>* vec_mask, Vector<IssmDouble>* recurence, Element* element){/*{{{*/
    634612
    635613        bool        active_element;
    … …  
    663641        IssmDouble colapse_thick =basalelement->FindParam(HydrologydcEplColapseThicknessEnum);
    664642
    665         Input* active_element_input=basalelement->GetInput(HydrologydcMaskEplactiveEltEnum); _assert_(active_element_input);
    666         active_element_input->GetInputValue(&active_element);
     643        basalelement->GetInputValue(&active_element,HydrologydcMaskEplactiveEltEnum);
    667644
    668645        basalelement-> GetInputListOnVertices(&old_active[0],HydrologydcMaskEplactiveNodeEnum);
    … …  
    712689                }
    713690        }
    714         basalelement->AddInput(HydrologydcEplThicknessSubstepEnum,epl_thickness,basalelement->GetElementType());
     691        basalelement->AddInput2(HydrologydcEplThicknessSubstepEnum,epl_thickness,basalelement->GetElementType());
    715692
    716693        if(domaintype!=Domain2DhorizontalEnum){
    … …  
    726703}
    727704/*}}}*/
    728 IssmDouble HydrologyDCEfficientAnalysis::EplStoring(Element* element,Gauss* gauss, Input* epl_thick_input, Input* epl_head_input, Input* base_input){/*{{{*/
     705IssmDouble HydrologyDCEfficientAnalysis::EplStoring(Element* element,Gauss* gauss, Input2* epl_thick_input, Input2* epl_head_input, Input2* base_input){/*{{{*/
    729706        IssmDouble epl_storing;
    730707        IssmDouble water_sheet,storing;
    … …  
    757734        return storing;
    758735}/*}}}*/
    759 
    760 IssmDouble HydrologyDCEfficientAnalysis::EplTransmitivity(Element* element,Gauss* gauss, Input* epl_thick_input, Input* epl_head_input, Input* base_input){/*{{{*/
     736IssmDouble HydrologyDCEfficientAnalysis::EplTransmitivity(Element* element,Gauss* gauss, Input2* epl_thick_input, Input2* epl_head_input, Input2* base_input){/*{{{*/
    761737        IssmDouble epl_transmitivity;
    762738        IssmDouble water_sheet;
    … …  
    772748        return epl_transmitivity;
    773749}/*}}}*/
    774 
    775750void HydrologyDCEfficientAnalysis::HydrologyEPLGetActive(Vector<IssmDouble>* active_vec, Element* element){/*{{{*/
    776751        /*Constants*/
    … …  
    798773        /*Pass the activity mask from elements to nodes*/
    799774        basalelement->GetInputListOnVertices(&active[0],HydrologydcMaskEplactiveNodeEnum);
    800         Input*  active_element_input=basalelement->GetInput(HydrologydcMaskEplactiveEltEnum); _assert_(active_element_input);
    801         active_element_input->GetInputValue(&active_element);
     775        basalelement->GetInputValue(&active_element,HydrologydcMaskEplactiveEltEnum);
    802776
    803777        for(int i=0;i<numnodes;i++) flag+=active[i];
    … …  
    822796}
    823797/*}}}*/
    824 
    825798void HydrologyDCEfficientAnalysis::GetHydrologyDCInefficientHmax(IssmDouble* ph_max,Element* element, Node* innode){/*{{{*/
    826799

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

    r23585 r24335  
    99#include "./Analysis.h"
    1010class Node;
    11 class Input;
     11class Input2;
    1212class HydrologyDCEfficientAnalysis: public Analysis{
    1313
    … …  
    1616                int  DofsPerNode(int** doflist,int domaintype,int approximation);
    1717                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    18                 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
     18                void UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type);
    1919                void CreateNodes(Nodes* nodes,IoModel* iomodel,bool isamr=false);
    2020                void CreateConstraints(Constraints* constraints,IoModel* iomodel);
    … …  
    3737                void GetB(IssmDouble* B,Element* element,IssmDouble* xyz_list,Gauss* gauss);
    3838                IssmDouble GetHydrologyKMatrixTransfer(Element* element);
    39                 IssmDouble GetHydrologyPVectorTransfer(Element* element, Gauss* gauss, Input* sed_head_input);
    40                 IssmDouble EplStoring(Element* element,Gauss* gauss, Input* epl_thick_input, Input* epl_head_input, Input* base_input);
    41                 IssmDouble EplTransmitivity(Element* element,Gauss* gauss, Input* epl_thick_input, Input* epl_head_input, Input* base_input);
     39                IssmDouble GetHydrologyPVectorTransfer(Element* element, Gauss* gauss, Input2* sed_head_input);
     40                IssmDouble EplStoring(Element* element,Gauss* gauss, Input2* epl_thick_input, Input2* epl_head_input, Input2* base_input);
     41                IssmDouble EplTransmitivity(Element* element,Gauss* gauss, Input2* epl_thick_input, Input2* epl_head_input, Input2* base_input);
    4242                void HydrologyEPLGetMask(Vector<IssmDouble>* vec_mask, Vector<IssmDouble>* recurence, Element* element);
    4343                void HydrologyEPLGetActive(Vector<IssmDouble>* active_vec, Element* element);

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

    r24240 r24335  
    55#include "../shared/shared.h"
    66#include "../modules/modules.h"
     7#include "../classes/Inputs2/TransientInput2.h"
    78
    89/*Model processing*/
    … …  
    7475  iomodel->DeleteData(&requestedoutputs,numoutputs,"md.hydrology.requested_outputs");
    7576}/*}}}*/
    76 void HydrologyDCInefficientAnalysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
     77void HydrologyDCInefficientAnalysis::UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
    7778
    7879        bool   isefficientlayer;
    … …  
    9394                if(iomodel->my_elements[i]){
    9495                        Element* element=(Element*)elements->GetObjectByOffset(counter);
    95                         element->Update(i,iomodel,analysis_counter,analysis_type,P1Enum);
     96                        element->Update(inputs2,i,iomodel,analysis_counter,analysis_type,P1Enum);
    9697                        counter++;
    9798                }
    9899        }
    99         iomodel->FetchDataToInput(elements,"md.geometry.thickness",ThicknessEnum);
    100         iomodel->FetchDataToInput(elements,"md.geometry.base",BaseEnum);
    101         iomodel->FetchDataToInput(elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
    102         iomodel->FetchDataToInput(elements,"md.basalforcings.groundedice_melting_rate",BasalforcingsGroundediceMeltingRateEnum);
    103         iomodel->FetchDataToInput(elements,"md.hydrology.basal_moulin_input",HydrologydcBasalMoulinInputEnum);
    104         iomodel->FetchDataToInput(elements,"md.initialization.sediment_head",SedimentHeadSubstepEnum);
    105         iomodel->FetchDataToInput(elements,"md.hydrology.sediment_transmitivity",HydrologydcSedimentTransmitivityEnum);
    106         iomodel->FetchDataToInput(elements,"md.hydrology.mask_thawed_node",HydrologydcMaskThawedNodeEnum);
     100        iomodel->FetchDataToInput(inputs2,elements,"md.geometry.thickness",ThicknessEnum);
     101        iomodel->FetchDataToInput(inputs2,elements,"md.geometry.base",BaseEnum);
     102        iomodel->FetchDataToInput(inputs2,elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
     103        iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.groundedice_melting_rate",BasalforcingsGroundediceMeltingRateEnum);
     104        iomodel->FetchDataToInput(inputs2,elements,"md.hydrology.basal_moulin_input",HydrologydcBasalMoulinInputEnum);
     105        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.sediment_head",SedimentHeadSubstepEnum);
     106        iomodel->FetchDataToInput(inputs2,elements,"md.hydrology.sediment_transmitivity",HydrologydcSedimentTransmitivityEnum);
     107        iomodel->FetchDataToInput(inputs2,elements,"md.hydrology.mask_thawed_node",HydrologydcMaskThawedNodeEnum);
    107108        if(iomodel->domaintype!=Domain2DhorizontalEnum){
    108                 iomodel->FetchDataToInput(elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum);
    109                 iomodel->FetchDataToInput(elements,"md.mesh.vertexonsurface",MeshVertexonsurfaceEnum);
     109                iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum);
     110                iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonsurface",MeshVertexonsurfaceEnum);
    110111        }
    111112        if(isefficientlayer){
    112                 iomodel->FetchDataToInput(elements,"md.hydrology.mask_eplactive_node",HydrologydcMaskEplactiveNodeEnum);
    113                 iomodel->FetchDataToInput(elements,"md.initialization.epl_head",EplHeadSubstepEnum);
     113                iomodel->FetchDataToInput(inputs2,elements,"md.hydrology.mask_eplactive_node",HydrologydcMaskEplactiveNodeEnum);
     114                iomodel->FetchDataToInput(inputs2,elements,"md.initialization.epl_head",EplHeadSubstepEnum);
    114115        }
    115116
    … …  
    200201        }
    201202
    202         Input* thawed_element_input = basalelement->GetInput(HydrologydcMaskThawedEltEnum); _assert_(thawed_element_input);
    203         thawed_element_input->GetInputValue(&thawed_element);
     203        basalelement->GetInput2Value(&thawed_element,HydrologydcMaskThawedEltEnum);
    204204
    205205        /*Check that all nodes are active, else return empty matrix*/
    … …  
    219219        IssmDouble *xyz_list  = NULL;
    220220
    221         /*Define transfer related variables*/
    222         Input* active_element_input =NULL;
    223 
    224221        /*Fetch number of nodes and dof for this finite element*/
    225222        int numnodes = basalelement->GetNumberOfNodes();
    … …  
    235232        basalelement ->FindParam(&dt,TimesteppingTimeStepEnum);
    236233        basalelement ->FindParam(&isefficientlayer,HydrologydcIsefficientlayerEnum);
    237         Input* SedTrans_input = basalelement->GetInput(HydrologydcSedimentTransmitivityEnum); _assert_(SedTrans_input);
    238         Input* sed_head_input = basalelement->GetInput(SedimentHeadSubstepEnum);
    239         Input* base_input     = basalelement->GetInput(BaseEnum);
    240         Input* old_wh_input = basalelement->GetInput(SedimentHeadOldEnum);                  _assert_(old_wh_input);
     234        Input2* SedTrans_input = basalelement->GetInput2(HydrologydcSedimentTransmitivityEnum); _assert_(SedTrans_input);
     235        Input2* sed_head_input = basalelement->GetInput2(SedimentHeadSubstepEnum);
     236        Input2* base_input     = basalelement->GetInput2(BaseEnum);
     237        Input2* old_wh_input   = basalelement->GetInput2(SedimentHeadOldEnum);                  _assert_(old_wh_input);
    241238
    242239        /*Transfer related Inputs*/
    243240        if(isefficientlayer){
    244                 active_element_input = basalelement->GetInput(HydrologydcMaskEplactiveEltEnum); _assert_(active_element_input);
     241                basalelement->GetInput2Value(&active_element,HydrologydcMaskEplactiveEltEnum);
    245242        }
    246243
    … …  
    279276                        /*Transfer EPL part*/
    280277                        if(isefficientlayer){
    281                                 active_element_input->GetInputValue(&active_element);
    282278                                if(active_element){
    283279                                        transfer=GetHydrologyKMatrixTransfer(basalelement);
    … …  
    324320        }
    325321
    326         Input* thawed_element_input = basalelement->GetInput(HydrologydcMaskThawedEltEnum); _assert_(thawed_element_input);
    327         thawed_element_input->GetInputValue(&thawed_element);
     322        basalelement->GetInput2Value(&thawed_element,HydrologydcMaskThawedEltEnum);
    328323
    329324        /*Check that all nodes are active, else return empty matrix*/
    … …  
    345340        IssmDouble Jdet;
    346341
    347         IssmDouble *xyz_list             = NULL;
    348         Input*      active_element_input = NULL;
    349         Input*      old_wh_input         = NULL;
    350         Input*      dummy_input          = NULL;
    351         TransientInput*  surface_runoff_input          = NULL;
     342        IssmDouble      *xyz_list             = NULL;
     343        Input2          *active_element_input = NULL;
     344        Input2          *old_wh_input         = NULL;
     345        Input2          *dummy_input          = NULL;
     346        TransientInput2 *surface_runoff_input = NULL;
    352347
    353348        /*Fetch number of nodes and dof for this finite element*/
    … …  
    364359        basalelement->FindParam(&smb_model,SmbEnum);
    365360
    366         Input*  sed_head_input                   = basalelement->GetInput(SedimentHeadSubstepEnum);
    367         Input*  epl_head_input                   = basalelement->GetInput(EplHeadSubstepEnum);
    368         Input*  base_input                               = basalelement->GetInput(BaseEnum);
    369         Input*  basal_melt_input                 = basalelement->GetInput(BasalforcingsGroundediceMeltingRateEnum); _assert_(basal_melt_input);
    370         Input*  SedTrans_input                   = basalelement->GetInput(HydrologydcSedimentTransmitivityEnum); _assert_(SedTrans_input);
     361        Input2* sed_head_input   = basalelement->GetInput2(SedimentHeadSubstepEnum);
     362        Input2* epl_head_input   = basalelement->GetInput2(EplHeadSubstepEnum);
     363        Input2* base_input       = basalelement->GetInput2(BaseEnum);
     364        Input2* basal_melt_input = basalelement->GetInput2(BasalforcingsGroundediceMeltingRateEnum); _assert_(basal_melt_input);
     365        Input2* SedTrans_input   = basalelement->GetInput2(HydrologydcSedimentTransmitivityEnum); _assert_(SedTrans_input);
    371366
    372367        IssmDouble time;
    … …  
    375370
    376371        if(dt!= 0.){
    377                 old_wh_input = basalelement->GetInput(SedimentHeadOldEnum);                  _assert_(old_wh_input);
     372                old_wh_input = basalelement->GetInput2(SedimentHeadOldEnum);                  _assert_(old_wh_input);
    378373        }
    379374        if(smb_model==SMBgradientscomponentsEnum){
    380375                basalelement->FindParam(&smbsubstepping,SmbStepsPerStepEnum);
    381376                if(smbsubstepping>1) {
    382                         dummy_input = basalelement->GetInput(SmbRunoffTransientEnum); _assert_(dummy_input);
     377                        dummy_input = basalelement->GetInput2(SmbRunoffTransientEnum); _assert_(dummy_input);
    383378                }
    384379                else {
    385                         dummy_input = basalelement->GetInput(SmbRunoffEnum); _assert_(dummy_input);
    386                 }
    387                 surface_runoff_input=xDynamicCast<TransientInput*>(dummy_input); _assert_(surface_runoff_input);
     380                        dummy_input = basalelement->GetInput2(SmbRunoffEnum); _assert_(dummy_input);
     381                }
     382                _assert_(surface_runoff_input->InstanceEnum()==TransientInput2Enum);
     383                surface_runoff_input=xDynamicCast<TransientInput2*>(dummy_input); _assert_(surface_runoff_input);
    388384        }
    389385
    390386        /*Transfer related Inputs*/
    391387        if(isefficientlayer){
    392                 active_element_input = basalelement->GetInput(HydrologydcMaskEplactiveEltEnum); _assert_(active_element_input);
     388                basalelement->GetInput2Value(&active_element,HydrologydcMaskEplactiveEltEnum);
    393389        }
    394390
    … …  
    419415                else{
    420416                        /*if EPL is present and active input is there not here*/
    421                         active_element_input->GetInputValue(&active_element);
    422417                        if(!active_element){
    423418                                basal_melt_input->GetInputValue(&water_load,gauss);
    … …  
    439434                        if(isefficientlayer){
    440435                                /*Dealing with the sediment part of the transfer term*/
    441                                 active_element_input->GetInputValue(&active_element);
    442436                                if(active_element){
    443437                                        transfer=GetHydrologyPVectorTransfer(basalelement,gauss,epl_head_input);
    … …  
    575569
    576570        /*Add input to the element: */
    577         element->AddBasalInput(SedimentHeadSubstepEnum,values,P1Enum);
    578         element->AddBasalInput(EffectivePressureSubstepEnum,pressure,P1Enum);
    579         element->AddBasalInput(SedimentHeadResidualEnum,residual,P1Enum);
     571        element->AddBasalInput2(SedimentHeadSubstepEnum,values,P1Enum);
     572        element->AddBasalInput2(EffectivePressureSubstepEnum,pressure,P1Enum);
     573        element->AddBasalInput2(SedimentHeadResidualEnum,residual,P1Enum);
    580574
    581575        /*Free ressources:*/
    … …  
    593587        return;
    594588}/*}}}*/
    595 IssmDouble HydrologyDCInefficientAnalysis::SedimentStoring(Element* element,Gauss* gauss,Input* sed_head_input, Input* base_input){/*{{{*/
     589IssmDouble HydrologyDCInefficientAnalysis::SedimentStoring(Element* element,Gauss* gauss,Input2* sed_head_input, Input2* base_input){/*{{{*/
    596590        int unconf_scheme;
    597591        IssmDouble expfac;
    … …  
    632626        return sediment_storing;
    633627}/*}}}*/
    634 IssmDouble HydrologyDCInefficientAnalysis::SedimentTransmitivity(Element* element,Gauss* gauss,Input* sed_head_input, Input* base_input,Input* SedTrans_input){/*{{{*/
     628IssmDouble HydrologyDCInefficientAnalysis::SedimentTransmitivity(Element* element,Gauss* gauss,Input2* sed_head_input, Input2* base_input,Input2* SedTrans_input){/*{{{*/
    635629        int unconf_scheme;
    636630        IssmDouble ratio,expfac;
    … …  
    722716        return transfer;
    723717}/*}}}*/
    724 IssmDouble HydrologyDCInefficientAnalysis::GetHydrologyPVectorTransfer(Element* element, Gauss* gauss, Input* epl_head_input){/*{{{*/
     718IssmDouble HydrologyDCInefficientAnalysis::GetHydrologyPVectorTransfer(Element* element, Gauss* gauss, Input2* epl_head_input){/*{{{*/
    725719
    726720        int transfermethod;
    … …  
    753747        for(int i=0;i<femmodel->elements->Size();i++){
    754748                element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
    755                         Input* node_mask_input = element->GetInput(HydrologydcMaskEplactiveNodeEnum); _assert_(node_mask_input);
    756 
    757                 if(node_mask_input->Max()>0.){
     749
     750                Input2* input=element->GetInput2(HydrologydcMaskEplactiveNodeEnum); _assert_(input);
     751                if(input->GetInputMax()>0.){
    758752                        element_active = true;
    759753                }
    … …  
    761755                        element_active = false;
    762756                }
    763                 element->AddInput(new BoolInput(HydrologydcMaskEplactiveEltEnum,element_active));
     757                element->SetBoolInput(element->inputs2,HydrologydcMaskEplactiveEltEnum,element_active);
    764758        }
    765759}/*}}}*/
    … …  
    813807        for(int i=0;i<femmodel->elements->Size();i++){
    814808                element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
    815                         Input* node_mask_input = element->GetInput(HydrologydcMaskThawedNodeEnum); _assert_(node_mask_input);
    816 
    817                 if(node_mask_input->Max()>0.){
     809
     810                Input2* input=element->GetInput2(HydrologydcMaskThawedNodeEnum); _assert_(input);
     811                if(input->GetInputMax()>0.){
    818812                        element_active = true;
    819813                }
    … …  
    821815                        element_active = false;
    822816                }
    823                 element->AddInput(new BoolInput(HydrologydcMaskThawedEltEnum,element_active));
     817                element->SetBoolInput(element->inputs2,HydrologydcMaskThawedEltEnum,element_active);
    824818        }
    825819}/*}}}*/
    … …  
    849843        /*Pass the activity mask from elements to nodes*/
    850844        basalelement->GetInputListOnVertices(&active[0],HydrologydcMaskThawedNodeEnum);
    851         Input*  active_element_input=basalelement->GetInput(HydrologydcMaskThawedEltEnum); _assert_(active_element_input);
    852         active_element_input->GetInputValue(&active_element);
     845        basalelement->GetInput2Value(&active_element,HydrologydcMaskThawedEltEnum);
    853846
    854847        for(int i=0;i<numnodes;i++) flag+=active[i];

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

    r23585 r24335  
    99#include "./Analysis.h"
    1010class Node;
    11 class Input;
     11class Input2;
    1212class HydrologyDCInefficientAnalysis: public Analysis{
    1313
    … …  
    1616                int  DofsPerNode(int** doflist,int domaintype,int approximation);
    1717                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    18                 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
     18                void UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type);
    1919                void CreateNodes(Nodes* nodes,IoModel* iomodel,bool isamr=false);
    2020                void CreateConstraints(Constraints* constraints,IoModel* iomodel);
    … …  
    3434                /*Intermediaries*/
    3535                void GetB(IssmDouble* B,Element* element,IssmDouble* xyz_list,Gauss* gauss);
    36                 IssmDouble SedimentStoring(Element* element, Gauss* gauss, Input* sed_head_input, Input* base_input);
    37                 IssmDouble SedimentTransmitivity(Element* element,Gauss* gauss,Input* sed_head_input, Input* base_input,Input* SedTrans_input);
     36                IssmDouble SedimentStoring(Element* element, Gauss* gauss, Input2* sed_head_input, Input2* base_input);
     37                IssmDouble SedimentTransmitivity(Element* element,Gauss* gauss,Input2* sed_head_input, Input2* base_input,Input2* SedTrans_input);
    3838                void GetHydrologyDCInefficientHmax(IssmDouble* ph_max,Element* element, Node* innode);
    3939                IssmDouble GetHydrologyKMatrixTransfer(Element* element);
    40                 IssmDouble GetHydrologyPVectorTransfer(Element* element, Gauss* gauss, Input* epl_head_input);
     40                IssmDouble GetHydrologyPVectorTransfer(Element* element, Gauss* gauss, Input2* epl_head_input);
    4141                void ElementizeEplMask(FemModel* femmodel);
    4242                void HydrologyIDSGetMask(Vector<IssmDouble>* vec_mask, Element* element);

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

    r24133 r24335  
    107107        return 1;
    108108}/*}}}*/
    109 void HydrologyGlaDSAnalysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
     109void HydrologyGlaDSAnalysis::UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
    110110
    111111        /*Fetch data needed: */
    … …  
    121121                if(iomodel->my_elements[i]){
    122122                        Element* element=(Element*)elements->GetObjectByOffset(counter);
    123                         element->Update(i,iomodel,analysis_counter,analysis_type,P1Enum);
     123                        element->Update(inputs2,i,iomodel,analysis_counter,analysis_type,P1Enum);
    124124                        counter++;
    125125                }
    126126        }
    127127
    128         iomodel->FetchDataToInput(elements,"md.geometry.thickness",ThicknessEnum);
    129         iomodel->FetchDataToInput(elements,"md.geometry.base",BaseEnum);
    130         iomodel->FetchDataToInput(elements,"md.geometry.bed",BedEnum);
    131         iomodel->FetchDataToInput(elements,"md.basalforcings.geothermalflux",BasalforcingsGeothermalfluxEnum);
    132         iomodel->FetchDataToInput(elements,"md.basalforcings.groundedice_melting_rate",BasalforcingsGroundediceMeltingRateEnum);
     128        iomodel->FetchDataToInput(inputs2,elements,"md.geometry.thickness",ThicknessEnum);
     129        iomodel->FetchDataToInput(inputs2,elements,"md.geometry.base",BaseEnum);
     130        iomodel->FetchDataToInput(inputs2,elements,"md.geometry.bed",BedEnum);
     131        iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.geothermalflux",BasalforcingsGeothermalfluxEnum);
     132        iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.groundedice_melting_rate",BasalforcingsGroundediceMeltingRateEnum);
    133133        if(iomodel->domaintype!=Domain2DhorizontalEnum){
    134                 iomodel->FetchDataToInput(elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum);
    135                 iomodel->FetchDataToInput(elements,"md.mesh.vertexonsurface",MeshVertexonsurfaceEnum);
    136         }
    137         iomodel->FetchDataToInput(elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
    138         iomodel->FetchDataToInput(elements,"md.mask.groundedice_levelset",MaskGroundediceLevelsetEnum);
    139         iomodel->FetchDataToInput(elements,"md.hydrology.bump_height",HydrologyBumpHeightEnum);
    140         iomodel->FetchDataToInput(elements,"md.hydrology.sheet_conductivity",HydrologySheetConductivityEnum);
    141         iomodel->FetchDataToInput(elements,"md.hydrology.neumannflux",HydrologyNeumannfluxEnum);
    142         iomodel->FetchDataToInput(elements,"md.hydrology.moulin_input",HydrologyMoulinInputEnum);
    143         iomodel->FetchDataToInput(elements,"md.initialization.watercolumn",HydrologySheetThicknessEnum);
    144         iomodel->FetchDataToInput(elements,"md.initialization.hydraulic_potential",HydraulicPotentialEnum);
    145         iomodel->FetchDataToInput(elements,"md.initialization.vx",VxEnum);
    146         iomodel->FetchDataToInput(elements,"md.initialization.vy",VyEnum);
     134                iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum);
     135                iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonsurface",MeshVertexonsurfaceEnum);
     136        }
     137        iomodel->FetchDataToInput(inputs2,elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
     138        iomodel->FetchDataToInput(inputs2,elements,"md.mask.groundedice_levelset",MaskGroundediceLevelsetEnum);
     139        iomodel->FetchDataToInput(inputs2,elements,"md.hydrology.bump_height",HydrologyBumpHeightEnum);
     140        iomodel->FetchDataToInput(inputs2,elements,"md.hydrology.sheet_conductivity",HydrologySheetConductivityEnum);
     141        iomodel->FetchDataToInput(inputs2,elements,"md.hydrology.neumannflux",HydrologyNeumannfluxEnum);
     142        iomodel->FetchDataToInput(inputs2,elements,"md.hydrology.moulin_input",HydrologyMoulinInputEnum);
     143        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.watercolumn",HydrologySheetThicknessEnum);
     144        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.hydraulic_potential",HydraulicPotentialEnum);
     145        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.vx",VxEnum);
     146        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.vy",VyEnum);
    147147        iomodel->FindConstant(&frictionlaw,"md.friction.law");
    148148
    … …  
    150150        switch(frictionlaw){
    151151                case 1:
    152                         iomodel->FetchDataToInput(elements,"md.friction.coefficient",FrictionCoefficientEnum);
    153                         iomodel->FetchDataToInput(elements,"md.friction.p",FrictionPEnum);
    154                         iomodel->FetchDataToInput(elements,"md.friction.q",FrictionQEnum);
     152                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.coefficient",FrictionCoefficientEnum);
     153                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.p",FrictionPEnum);
     154                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.q",FrictionQEnum);
    155155                        break;
    156156                case 8:
    157                         iomodel->FetchDataToInput(elements,"md.friction.coefficient",FrictionCoefficientEnum);
     157                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.coefficient",FrictionCoefficientEnum);
    158158                        break;
    159159                default:
    … …  
    242242        IssmDouble g         = element->FindParam(ConstantsGEnum);
    243243        IssmDouble e_v       = element->FindParam(HydrologyEnglacialVoidRatioEnum);
    244         Input* k_input   = element->GetInput(HydrologySheetConductivityEnum);_assert_(k_input);
    245         Input* phi_input = element->GetInput(HydraulicPotentialEnum);      _assert_(phi_input);
    246         Input* h_input   = element->GetInput(HydrologySheetThicknessEnum); _assert_(h_input);
    247         Input* H_input      = element->GetInput(ThicknessEnum); _assert_(H_input);
    248         Input* b_input      = element->GetInput(BedEnum); _assert_(b_input);
    249         Input* B_input      = element->GetInput(MaterialsRheologyBEnum);         _assert_(B_input);
    250         Input* n_input      = element->GetInput(MaterialsRheologyNEnum);         _assert_(n_input);
     244        Input2* k_input   = element->GetInput2(HydrologySheetConductivityEnum);_assert_(k_input);
     245        Input2* phi_input = element->GetInput2(HydraulicPotentialEnum);      _assert_(phi_input);
     246        Input2* h_input   = element->GetInput2(HydrologySheetThicknessEnum); _assert_(h_input);
     247        Input2* H_input      = element->GetInput2(ThicknessEnum); _assert_(H_input);
     248        Input2* b_input      = element->GetInput2(BedEnum); _assert_(b_input);
     249        Input2* B_input      = element->GetInput2(MaterialsRheologyBEnum);         _assert_(B_input);
     250        Input2* n_input      = element->GetInput2(MaterialsRheologyNEnum);         _assert_(n_input);
    251251
    252252        /* Start  looping on the number of gaussian points: */
    … …  
    342342        IssmDouble g         = element->FindParam(ConstantsGEnum);
    343343        IssmDouble e_v       = element->FindParam(HydrologyEnglacialVoidRatioEnum);
    344         Input* hr_input     = element->GetInput(HydrologyBumpHeightEnum);_assert_(hr_input);
    345         Input* vx_input     = element->GetInput(VxEnum);_assert_(vx_input);
    346         Input* vy_input     = element->GetInput(VyEnum);_assert_(vy_input);
    347         Input* h_input      = element->GetInput(HydrologySheetThicknessEnum);_assert_(h_input);
    348         Input* H_input      = element->GetInput(ThicknessEnum); _assert_(H_input);
    349         Input* b_input      = element->GetInput(BedEnum); _assert_(b_input);
    350         Input* G_input      = element->GetInput(BasalforcingsGeothermalfluxEnum);_assert_(G_input);
    351         Input* m_input      = element->GetInput(BasalforcingsGroundediceMeltingRateEnum);_assert_(m_input);
    352         Input* B_input      = element->GetInput(MaterialsRheologyBEnum);         _assert_(B_input);
    353         Input* n_input      = element->GetInput(MaterialsRheologyNEnum);         _assert_(n_input);
    354         Input* phiold_input = element->GetInput(HydraulicPotentialOldEnum);      _assert_(phiold_input);
    355         Input* phi_input    = element->GetInput(HydraulicPotentialEnum);         _assert_(phi_input);
     344        Input2* hr_input     = element->GetInput2(HydrologyBumpHeightEnum);_assert_(hr_input);
     345        Input2* vx_input     = element->GetInput2(VxEnum);_assert_(vx_input);
     346        Input2* vy_input     = element->GetInput2(VyEnum);_assert_(vy_input);
     347        Input2* h_input      = element->GetInput2(HydrologySheetThicknessEnum);_assert_(h_input);
     348        Input2* H_input      = element->GetInput2(ThicknessEnum); _assert_(H_input);
     349        Input2* b_input      = element->GetInput2(BedEnum); _assert_(b_input);
     350        Input2* G_input      = element->GetInput2(BasalforcingsGeothermalfluxEnum);_assert_(G_input);
     351        Input2* m_input      = element->GetInput2(BasalforcingsGroundediceMeltingRateEnum);_assert_(m_input);
     352        Input2* B_input      = element->GetInput2(MaterialsRheologyBEnum);         _assert_(B_input);
     353        Input2* n_input      = element->GetInput2(MaterialsRheologyNEnum);         _assert_(n_input);
     354        Input2* phiold_input = element->GetInput2(HydraulicPotentialOldEnum);      _assert_(phiold_input);
     355        Input2* phi_input    = element->GetInput2(HydraulicPotentialEnum);         _assert_(phi_input);
    356356
    357357        /*Build friction element, needed later: */
    … …  
    479479        IssmDouble rho_water = element->FindParam(MaterialsRhoFreshwaterEnum);
    480480        IssmDouble g         = element->FindParam(ConstantsGEnum);
    481         Input* hr_input = element->GetInput(HydrologyBumpHeightEnum);_assert_(hr_input);
    482         Input* vx_input = element->GetInput(VxEnum);_assert_(vx_input);
    483         Input* vy_input = element->GetInput(VyEnum);_assert_(vy_input);
    484         Input* H_input  = element->GetInput(ThicknessEnum); _assert_(H_input);
    485         Input* b_input  = element->GetInput(BedEnum); _assert_(b_input);
    486         Input* hold_input  = element->GetInput(HydrologySheetThicknessOldEnum);_assert_(hold_input);
    487         Input* B_input  = element->GetInput(MaterialsRheologyBEnum);         _assert_(B_input);
    488         Input* n_input  = element->GetInput(MaterialsRheologyNEnum);         _assert_(n_input);
    489         Input* phi_input = element->GetInput(HydraulicPotentialEnum);         _assert_(phi_input);
     481        Input2* hr_input = element->GetInput2(HydrologyBumpHeightEnum);_assert_(hr_input);
     482        Input2* vx_input = element->GetInput2(VxEnum);_assert_(vx_input);
     483        Input2* vy_input = element->GetInput2(VyEnum);_assert_(vy_input);
     484        Input2* H_input  = element->GetInput2(ThicknessEnum); _assert_(H_input);
     485        Input2* b_input  = element->GetInput2(BedEnum); _assert_(b_input);
     486        Input2* hold_input  = element->GetInput2(HydrologySheetThicknessOldEnum);_assert_(hold_input);
     487        Input2* B_input  = element->GetInput2(MaterialsRheologyBEnum);         _assert_(B_input);
     488        Input2* n_input  = element->GetInput2(MaterialsRheologyNEnum);         _assert_(n_input);
     489        Input2* phi_input = element->GetInput2(HydraulicPotentialEnum);         _assert_(phi_input);
    490490
    491491        /* Start  looping on the number of gaussian points: */
    … …  
    532532        }
    533533
    534         element->AddInput(HydrologySheetThicknessEnum,h_new,P1Enum);
     534        element->AddInput2(HydrologySheetThicknessEnum,h_new,P1Enum);
    535535
    536536        /*Clean up and return*/
    … …  
    562562        IssmDouble  rho_water = element->FindParam(MaterialsRhoFreshwaterEnum);
    563563        IssmDouble  g         = element->FindParam(ConstantsGEnum);
    564         Input* H_input   = element->GetInput(ThicknessEnum); _assert_(H_input);
    565         Input* b_input   = element->GetInput(BedEnum); _assert_(b_input);
    566         Input* phi_input = element->GetInput(HydraulicPotentialEnum); _assert_(phi_input);
     564        Input2* H_input   = element->GetInput2(ThicknessEnum); _assert_(H_input);
     565        Input2* b_input   = element->GetInput2(BedEnum); _assert_(b_input);
     566        Input2* phi_input = element->GetInput2(HydraulicPotentialEnum); _assert_(phi_input);
    567567
    568568        /* Start  looping on the number of gaussian points: */
    … …  
    592592        }
    593593
    594         element->AddInput(EffectivePressureEnum,N,element->FiniteElement());
     594        element->AddInput2(EffectivePressureEnum,N,element->FiniteElement());
    595595
    596596        /*Clean up and return*/

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

    r24080 r24335  
    1717                void CreateNodes(Nodes* nodes,IoModel* iomodel,bool isamr=false);
    1818                int  DofsPerNode(int** doflist,int domaintype,int approximation);
    19                 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
     19                void UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type);
    2020                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    2121

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

    r23644 r24335  
    2222        return 0;
    2323}/*}}}*/
    24 void HydrologyPismAnalysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
     24void HydrologyPismAnalysis::UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
    2525
    2626        /*Fetch data needed: */
    … …  
    3232
    3333        /*Add input to elements*/
    34         iomodel->FetchDataToInput(elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
    35         iomodel->FetchDataToInput(elements,"md.mask.groundedice_levelset",MaskGroundediceLevelsetEnum);
    36         iomodel->FetchDataToInput(elements,"md.basalforcings.groundedice_melting_rate",BasalforcingsGroundediceMeltingRateEnum);
    37         iomodel->FetchDataToInput(elements,"md.hydrology.drainage_rate",HydrologyDrainageRateEnum);
    38         iomodel->FetchDataToInput(elements,"md.hydrology.watercolumn_max",HydrologyWatercolumnMaxEnum);
    39         iomodel->FetchDataToInput(elements,"md.initialization.watercolumn",WatercolumnEnum,0.);
     34        iomodel->FetchDataToInput(inputs2,elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
     35        iomodel->FetchDataToInput(inputs2,elements,"md.mask.groundedice_levelset",MaskGroundediceLevelsetEnum);
     36        iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.groundedice_melting_rate",BasalforcingsGroundediceMeltingRateEnum);
     37        iomodel->FetchDataToInput(inputs2,elements,"md.hydrology.drainage_rate",HydrologyDrainageRateEnum);
     38        iomodel->FetchDataToInput(inputs2,elements,"md.hydrology.watercolumn_max",HydrologyWatercolumnMaxEnum);
     39        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.watercolumn",WatercolumnEnum,0.);
    4040}/*}}}*/
    4141void HydrologyPismAnalysis::UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
    … …  
    117117        IssmDouble* meltingrate  = xNew<IssmDouble>(numvertices);
    118118        IssmDouble* watercolumn_max  = xNew<IssmDouble>(numvertices);
    119         element->GetInputListOnVertices(&watercolumn[0],WatercolumnEnum);
     119        element->GetInputListOnVertices(&watercolumn[0],WaterColumnOldEnum);
    120120        element->GetInputListOnVertices(&drainagerate[0],HydrologyDrainageRateEnum);
    121121        element->GetInputListOnVertices(&meltingrate[0],BasalforcingsGroundediceMeltingRateEnum);
    … …  
    131131
    132132        /* Divide by connectivity, add degree of channelization as an input */
    133         element->AddInput(WatercolumnEnum,&watercolumn[0],P1Enum);
     133        /*FIXME: should be changed to P1, this is due to the NR, IsFloating will return 0 on this element, but it should not be DG*/
     134        element->AddInput2(WatercolumnEnum,&watercolumn[0],P1DGEnum);
    134135
    135136        /*Clean up and return*/

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

    r23585 r24335  
    1717                void CreateNodes(Nodes* nodes,IoModel* iomodel,bool isamr=false);
    1818                int  DofsPerNode(int** doflist,int domaintype,int approximation);
    19                 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
     19                void UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type);
    2020                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    2121

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

    r23972 r24335  
    8080        return 1;
    8181}/*}}}*/
    82 void HydrologyShaktiAnalysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
     82void HydrologyShaktiAnalysis::UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
    8383
    8484        /*Fetch data needed: */
    … …  
    9494                if(iomodel->my_elements[i]){
    9595                        Element* element=(Element*)elements->GetObjectByOffset(counter);
    96                         element->Update(i,iomodel,analysis_counter,analysis_type,P1Enum);
     96                        element->Update(inputs2,i,iomodel,analysis_counter,analysis_type,P1Enum);
    9797                        counter++;
    9898                }
    9999        }
    100100
    101         iomodel->FetchDataToInput(elements,"md.geometry.thickness",ThicknessEnum);
    102         iomodel->FetchDataToInput(elements,"md.geometry.base",BaseEnum);
     101        iomodel->FetchDataToInput(inputs2,elements,"md.geometry.thickness",ThicknessEnum);
     102        iomodel->FetchDataToInput(inputs2,elements,"md.geometry.base",BaseEnum);
    103103        if(iomodel->domaintype!=Domain2DhorizontalEnum){
    104                 iomodel->FetchDataToInput(elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum);
    105                 iomodel->FetchDataToInput(elements,"md.mesh.vertexonsurface",MeshVertexonsurfaceEnum);
    106         }
    107         iomodel->FetchDataToInput(elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
    108         iomodel->FetchDataToInput(elements,"md.mask.groundedice_levelset",MaskGroundediceLevelsetEnum);
    109         iomodel->FetchDataToInput(elements,"md.basalforcings.groundedice_melting_rate",BasalforcingsGroundediceMeltingRateEnum);
    110         iomodel->FetchDataToInput(elements,"md.basalforcings.geothermalflux",BasalforcingsGeothermalfluxEnum);
    111         iomodel->FetchDataToInput(elements,"md.hydrology.head",HydrologyHeadEnum);
    112         iomodel->FetchDataToInput(elements,"md.hydrology.gap_height",HydrologyGapHeightEnum);
    113         iomodel->FetchDataToInput(elements,"md.hydrology.englacial_input",HydrologyEnglacialInputEnum);
    114         iomodel->FetchDataToInput(elements,"md.hydrology.moulin_input",HydrologyMoulinInputEnum);
    115         iomodel->FetchDataToInput(elements,"md.hydrology.bump_spacing",HydrologyBumpSpacingEnum);
    116         iomodel->FetchDataToInput(elements,"md.hydrology.bump_height",HydrologyBumpHeightEnum);
    117         iomodel->FetchDataToInput(elements,"md.hydrology.reynolds",HydrologyReynoldsEnum);
    118         iomodel->FetchDataToInput(elements,"md.hydrology.neumannflux",HydrologyNeumannfluxEnum);
    119         iomodel->FetchDataToInput(elements,"md.initialization.vx",VxEnum);
    120         iomodel->FetchDataToInput(elements,"md.initialization.vy",VyEnum);
     104                iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum);
     105                iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonsurface",MeshVertexonsurfaceEnum);
     106        }
     107        iomodel->FetchDataToInput(inputs2,elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
     108        iomodel->FetchDataToInput(inputs2,elements,"md.mask.groundedice_levelset",MaskGroundediceLevelsetEnum);
     109        iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.groundedice_melting_rate",BasalforcingsGroundediceMeltingRateEnum);
     110        iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.geothermalflux",BasalforcingsGeothermalfluxEnum);
     111        iomodel->FetchDataToInput(inputs2,elements,"md.hydrology.head",HydrologyHeadEnum);
     112        iomodel->FetchDataToInput(inputs2,elements,"md.hydrology.gap_height",HydrologyGapHeightEnum);
     113        iomodel->FetchDataToInput(inputs2,elements,"md.hydrology.englacial_input",HydrologyEnglacialInputEnum);
     114        iomodel->FetchDataToInput(inputs2,elements,"md.hydrology.moulin_input",HydrologyMoulinInputEnum);
     115        iomodel->FetchDataToInput(inputs2,elements,"md.hydrology.bump_spacing",HydrologyBumpSpacingEnum);
     116        iomodel->FetchDataToInput(inputs2,elements,"md.hydrology.bump_height",HydrologyBumpHeightEnum);
     117        iomodel->FetchDataToInput(inputs2,elements,"md.hydrology.reynolds",HydrologyReynoldsEnum);
     118        iomodel->FetchDataToInput(inputs2,elements,"md.hydrology.neumannflux",HydrologyNeumannfluxEnum);
     119        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.vx",VxEnum);
     120        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.vy",VyEnum);
    121121        iomodel->FindConstant(&frictionlaw,"md.friction.law");
    122122
    … …  
    124124        switch(frictionlaw){
    125125                case 1:
    126                         iomodel->FetchDataToInput(elements,"md.friction.coefficient",FrictionCoefficientEnum);
    127                         iomodel->FetchDataToInput(elements,"md.friction.p",FrictionPEnum);
    128                         iomodel->FetchDataToInput(elements,"md.friction.q",FrictionQEnum);
     126                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.coefficient",FrictionCoefficientEnum);
     127                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.p",FrictionPEnum);
     128                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.q",FrictionQEnum);
    129129                        break;
    130130                case 8:
    131                         iomodel->FetchDataToInput(elements,"md.friction.coefficient",FrictionCoefficientEnum);
     131                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.coefficient",FrictionCoefficientEnum);
    132132                        break;
    133133                default:
    … …  
    244244        IssmDouble  rho_ice         = element->FindParam(MaterialsRhoIceEnum);
    245245        IssmDouble  rho_water       = element->FindParam(MaterialsRhoFreshwaterEnum);
    246         Input* geothermalflux_input = element->GetInput(BasalforcingsGeothermalfluxEnum);_assert_(geothermalflux_input);
    247         Input* head_input           = element->GetInput(HydrologyHeadEnum);              _assert_(head_input);
    248         Input* gap_input            = element->GetInput(HydrologyGapHeightEnum);         _assert_(gap_input);
    249         Input* thickness_input      = element->GetInput(ThicknessEnum);                  _assert_(thickness_input);
    250         Input* base_input           = element->GetInput(BaseEnum);                       _assert_(base_input);
    251         Input* B_input              = element->GetInput(MaterialsRheologyBEnum);         _assert_(B_input);
    252         Input* n_input              = element->GetInput(MaterialsRheologyNEnum);         _assert_(n_input);
    253         Input* englacial_input      = element->GetInput(HydrologyEnglacialInputEnum);    _assert_(englacial_input);
    254         Input* vx_input             = element->GetInput(VxEnum);                         _assert_(vx_input);
    255         Input* vy_input             = element->GetInput(VyEnum);                         _assert_(vy_input);
    256         Input* lr_input             = element->GetInput(HydrologyBumpSpacingEnum);       _assert_(lr_input);
    257         Input* br_input             = element->GetInput(HydrologyBumpHeightEnum);        _assert_(br_input);
    258    Input* headold_input        = element->GetInput(HydrologyHeadOldEnum);           _assert_(headold_input);
     246        Input2* geothermalflux_input = element->GetInput2(BasalforcingsGeothermalfluxEnum);_assert_(geothermalflux_input);
     247        Input2* head_input           = element->GetInput2(HydrologyHeadEnum);              _assert_(head_input);
     248        Input2* gap_input            = element->GetInput2(HydrologyGapHeightEnum);         _assert_(gap_input);
     249        Input2* thickness_input      = element->GetInput2(ThicknessEnum);                  _assert_(thickness_input);
     250        Input2* base_input           = element->GetInput2(BaseEnum);                       _assert_(base_input);
     251        Input2* B_input              = element->GetInput2(MaterialsRheologyBEnum);         _assert_(B_input);
     252        Input2* n_input              = element->GetInput2(MaterialsRheologyNEnum);         _assert_(n_input);
     253        Input2* englacial_input      = element->GetInput2(HydrologyEnglacialInputEnum);    _assert_(englacial_input);
     254        Input2* vx_input             = element->GetInput2(VxEnum);                         _assert_(vx_input);
     255        Input2* vy_input             = element->GetInput2(VyEnum);                         _assert_(vy_input);
     256        Input2* lr_input             = element->GetInput2(HydrologyBumpSpacingEnum);       _assert_(lr_input);
     257        Input2* br_input             = element->GetInput2(HydrologyBumpHeightEnum);        _assert_(br_input);
     258   Input2* headold_input        = element->GetInput2(HydrologyHeadOldEnum);           _assert_(headold_input);
    259259
    260260        /*Get conductivity from inputs*/
    … …  
    403403
    404404        /*Add input to the element: */
    405         element->AddInput(HydrologyHeadEnum,values,element->GetElementType());
    406    element->AddInput(EffectivePressureEnum,eff_pressure,P1Enum);
     405        element->AddInput2(HydrologyHeadEnum,values,element->GetElementType());
     406   element->AddInput2(EffectivePressureEnum,eff_pressure,P1Enum);
    407407
    408408        /*Update reynolds number according to new solution*/
    409409        element->GetVerticesCoordinates(&xyz_list);
    410         Input* head_input = element->GetInput(HydrologyHeadEnum);_assert_(head_input);
    411         head_input->GetInputDerivativeAverageValue(&dh[0],xyz_list);
     410        Input2* head_input = element->GetInput2(HydrologyHeadEnum);_assert_(head_input);
    412411        IssmDouble conductivity = GetConductivity(element);
    413412
     413        /*Get gap height derivatives at the center of the element*/
     414        Gauss* gauss=element->NewGauss(0);
     415        head_input->GetInputDerivativeValue(&dh[0],xyz_list,gauss);
     416        delete gauss;
     417
    414418        IssmDouble reynolds = conductivity*sqrt(dh[0]*dh[0]+dh[1]*dh[1])/NU;
    415         element->AddInput(HydrologyReynoldsEnum,&reynolds,P0Enum);
     419        element->AddInput2(HydrologyReynoldsEnum,&reynolds,P0Enum);
    416420
    417421        /*Free resources:*/
    … …  
    439443
    440444        /*Get Reynolds and gap average values*/
    441         Input* reynolds_input = element->GetInput(HydrologyReynoldsEnum);  _assert_(reynolds_input);
    442         Input* gap_input      = element->GetInput(HydrologyGapHeightEnum); _assert_(gap_input);
     445        Input2* reynolds_input = element->GetInput2(HydrologyReynoldsEnum);  _assert_(reynolds_input);
     446        Input2* gap_input      = element->GetInput2(HydrologyGapHeightEnum); _assert_(gap_input);
    443447        reynolds_input->GetInputAverage(&reynolds);
    444448        gap_input->GetInputAverage(&gap);
    … …  
    482486        IssmDouble  rho_ice         = element->FindParam(MaterialsRhoIceEnum);
    483487        IssmDouble  rho_water       = element->FindParam(MaterialsRhoFreshwaterEnum);
    484         Input* geothermalflux_input = element->GetInput(BasalforcingsGeothermalfluxEnum);_assert_(geothermalflux_input);
    485         Input* head_input           = element->GetInput(HydrologyHeadEnum);              _assert_(head_input);
    486         Input* gap_input            = element->GetInput(HydrologyGapHeightEnum);         _assert_(gap_input);
    487         Input* thickness_input      = element->GetInput(ThicknessEnum);                  _assert_(thickness_input);
    488         Input* base_input           = element->GetInput(BaseEnum);                       _assert_(base_input);
    489         Input* B_input              = element->GetInput(MaterialsRheologyBEnum);         _assert_(B_input);
    490         Input* n_input              = element->GetInput(MaterialsRheologyNEnum);         _assert_(n_input);
    491         Input* englacial_input      = element->GetInput(HydrologyEnglacialInputEnum);    _assert_(englacial_input);
    492         Input* vx_input             = element->GetInput(VxEnum);                         _assert_(vx_input);
    493         Input* vy_input             = element->GetInput(VyEnum);                         _assert_(vy_input);
    494         Input* lr_input             = element->GetInput(HydrologyBumpSpacingEnum);       _assert_(lr_input);
    495         Input* br_input             = element->GetInput(HydrologyBumpHeightEnum);        _assert_(br_input);
     488        Input2* geothermalflux_input = element->GetInput2(BasalforcingsGeothermalfluxEnum);_assert_(geothermalflux_input);
     489        Input2* head_input           = element->GetInput2(HydrologyHeadEnum);              _assert_(head_input);
     490        Input2* gap_input            = element->GetInput2(HydrologyGapHeightEnum);         _assert_(gap_input);
     491        Input2* thickness_input      = element->GetInput2(ThicknessEnum);                  _assert_(thickness_input);
     492        Input2* base_input           = element->GetInput2(BaseEnum);                       _assert_(base_input);
     493        Input2* B_input              = element->GetInput2(MaterialsRheologyBEnum);         _assert_(B_input);
     494        Input2* n_input              = element->GetInput2(MaterialsRheologyNEnum);         _assert_(n_input);
     495        Input2* englacial_input      = element->GetInput2(HydrologyEnglacialInputEnum);    _assert_(englacial_input);
     496        Input2* vx_input             = element->GetInput2(VxEnum);                         _assert_(vx_input);
     497        Input2* vy_input             = element->GetInput2(VyEnum);                         _assert_(vy_input);
     498        Input2* lr_input             = element->GetInput2(HydrologyBumpSpacingEnum);       _assert_(lr_input);
     499        Input2* br_input             = element->GetInput2(HydrologyBumpHeightEnum);        _assert_(br_input);
    496500
    497501        /*Get conductivity from inputs*/
    … …  
    578582
    579583        /*Add new gap as an input*/
    580         element->AddInput(HydrologyGapHeightEnum,&newgap,P0Enum);
     584        element->AddInput2(HydrologyGapHeightEnum,&newgap,P0Enum);
    581585
    582586        /*Divide by connectivity, add basal flux as an input*/
    583587        q = q/totalweights;
    584         element->AddInput(HydrologyBasalFluxEnum,&q,P0Enum);
     588        element->AddInput2(HydrologyBasalFluxEnum,&q,P0Enum);
    585589
    586590        /* Divide by connectivity, add degree of channelization as an input */
    587591        channelization = channelization/totalweights;
    588         element->AddInput(DegreeOfChannelizationEnum,&channelization,P0Enum);
     592        element->AddInput2(DegreeOfChannelizationEnum,&channelization,P0Enum);
    589593
    590594        /*Clean up and return*/

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

    r23585 r24335  
    1717                void CreateNodes(Nodes* nodes,IoModel* iomodel,bool isamr=false);
    1818                int  DofsPerNode(int** doflist,int domaintype,int approximation);
    19                 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
     19                void UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type);
    2020                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    2121

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

    r23644 r24335  
    3636        return 1;
    3737}/*}}}*/
    38 void HydrologyShreveAnalysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
     38void HydrologyShreveAnalysis::UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
    3939
    4040        /*Fetch data needed: */
    … …  
    5050                if(iomodel->my_elements[i]){
    5151                        Element* element=(Element*)elements->GetObjectByOffset(counter);
    52                         element->Update(i,iomodel,analysis_counter,analysis_type,P1Enum);
     52                        element->Update(inputs2,i,iomodel,analysis_counter,analysis_type,P1Enum);
    5353                        counter++;
    5454                }
    5555        }
    5656
    57         iomodel->FetchDataToInput(elements,"md.geometry.thickness",ThicknessEnum);
    58         iomodel->FetchDataToInput(elements,"md.geometry.surface",SurfaceEnum);
    59         iomodel->FetchDataToInput(elements,"md.geometry.base",BaseEnum);
    60         iomodel->FetchDataToInput(elements,"md.slr.sealevel",SealevelEnum,0);
     57        iomodel->FetchDataToInput(inputs2,elements,"md.geometry.thickness",ThicknessEnum);
     58        iomodel->FetchDataToInput(inputs2,elements,"md.geometry.surface",SurfaceEnum);
     59        iomodel->FetchDataToInput(inputs2,elements,"md.geometry.base",BaseEnum);
     60        iomodel->FetchDataToInput(inputs2,elements,"md.slr.sealevel",SealevelEnum,0);
    6161        if(iomodel->domaintype!=Domain2DhorizontalEnum){
    62                 iomodel->FetchDataToInput(elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum);
    63                 iomodel->FetchDataToInput(elements,"md.mesh.vertexonsurface",MeshVertexonsurfaceEnum);
    64         }
    65         iomodel->FetchDataToInput(elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
    66         iomodel->FetchDataToInput(elements,"md.mask.groundedice_levelset",MaskGroundediceLevelsetEnum);
    67         iomodel->FetchDataToInput(elements,"md.basalforcings.groundedice_melting_rate",BasalforcingsGroundediceMeltingRateEnum);
    68         iomodel->FetchDataToInput(elements,"md.initialization.watercolumn",WatercolumnEnum);
    69 
    70         elements->InputDuplicate(WatercolumnEnum,WaterColumnOldEnum);
     62                iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum);
     63                iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonsurface",MeshVertexonsurfaceEnum);
     64        }
     65        iomodel->FetchDataToInput(inputs2,elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
     66        iomodel->FetchDataToInput(inputs2,elements,"md.mask.groundedice_levelset",MaskGroundediceLevelsetEnum);
     67        iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.groundedice_melting_rate",BasalforcingsGroundediceMeltingRateEnum);
     68        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.watercolumn",WatercolumnEnum);
     69
     70        inputs2->DuplicateInput(WatercolumnEnum,WaterColumnOldEnum);
    7171}/*}}}*/
    7272void HydrologyShreveAnalysis::UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
    … …  
    109109        IssmDouble  g         = element->FindParam(ConstantsGEnum);
    110110        IssmDouble  mu_water  = element->FindParam(MaterialsMuWaterEnum);
    111         Input* surfaceslopex_input = element->GetInput(SurfaceSlopeXEnum); _assert_(surfaceslopex_input);
    112         Input* surfaceslopey_input = element->GetInput(SurfaceSlopeYEnum); _assert_(surfaceslopey_input);
    113         Input* bedslopex_input     = element->GetInput(BedSlopeXEnum);     _assert_(bedslopex_input);
    114         Input* bedslopey_input     = element->GetInput(BedSlopeYEnum);     _assert_(bedslopey_input);
    115         Input* watercolumn_input   = element->GetInput(WatercolumnEnum);   _assert_(watercolumn_input);
     111        Input2* surfaceslopex_input = element->GetInput2(SurfaceSlopeXEnum); _assert_(surfaceslopex_input);
     112        Input2* surfaceslopey_input = element->GetInput2(SurfaceSlopeYEnum); _assert_(surfaceslopey_input);
     113        Input2* bedslopex_input     = element->GetInput2(BedSlopeXEnum);     _assert_(bedslopex_input);
     114        Input2* bedslopey_input     = element->GetInput2(BedSlopeYEnum);     _assert_(bedslopey_input);
     115        Input2* watercolumn_input   = element->GetInput2(WatercolumnEnum);   _assert_(watercolumn_input);
    116116
    117117        /*Fetch number of vertices and allocate output*/
    … …  
    138138
    139139        /*Add to inputs*/
    140         element->AddInput(HydrologyWaterVxEnum,vx,P1Enum);
    141         element->AddInput(HydrologyWaterVyEnum,vy,P1Enum);
     140        element->AddInput2(HydrologyWaterVxEnum,vx,P1Enum);
     141        element->AddInput2(HydrologyWaterVyEnum,vy,P1Enum);
    142142        xDelete<IssmDouble>(vx);
    143143        xDelete<IssmDouble>(vy);
    … …  
    172172        element->FindParam(&dt,TimesteppingTimeStepEnum);
    173173        element->FindParam(&diffusivity,HydrologyshreveStabilizationEnum);
    174         Input* vx_input=element->GetInput(HydrologyWaterVxEnum); _assert_(vx_input);
    175         Input* vy_input=element->GetInput(HydrologyWaterVyEnum); _assert_(vy_input);
     174        Input2* vx_input=element->GetInput2(HydrologyWaterVxEnum); _assert_(vx_input);
     175        Input2* vy_input=element->GetInput2(HydrologyWaterVyEnum); _assert_(vy_input);
    176176        h = element->CharacteristicLength();
    177177
    … …  
    257257        element->GetVerticesCoordinates(&xyz_list);
    258258        element->FindParam(&dt,TimesteppingTimeStepEnum);
    259         Input* mb_input   = element->GetInput(BasalforcingsGroundediceMeltingRateEnum); _assert_(mb_input);
    260         Input* oldw_input = element->GetInput(WaterColumnOldEnum);                      _assert_(oldw_input);
     259        Input2* mb_input   = element->GetInput2(BasalforcingsGroundediceMeltingRateEnum); _assert_(mb_input);
     260        Input2* oldw_input = element->GetInput2(WaterColumnOldEnum);                      _assert_(oldw_input);
    261261
    262262        /*Initialize mb_correction to 0, do not forget!:*/
    … …  
    368368
    369369        /*Add input to the element: */
    370         element->AddInput(WatercolumnEnum,values,element->GetElementType());
     370        element->AddInput2(WatercolumnEnum,values,element->GetElementType());
    371371
    372372        /*Free ressources:*/

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

    r23585 r24335  
    1717                void CreateNodes(Nodes* nodes,IoModel* iomodel,bool isamr=false);
    1818                int  DofsPerNode(int** doflist,int domaintype,int approximation);
    19                 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
     19                void UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type);
    2020                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    2121

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

    r23585 r24335  
    2828        return 1;
    2929}/*}}}*/
    30 void L2ProjectionBaseAnalysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
     30void L2ProjectionBaseAnalysis::UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
    3131
    3232        /*Update elements: */
    … …  
    3535                if(iomodel->my_elements[i]){
    3636                        Element* element=(Element*)elements->GetObjectByOffset(counter);
    37                         element->Update(i,iomodel,analysis_counter,analysis_type,P1Enum);
     37                        element->Update(inputs2,i,iomodel,analysis_counter,analysis_type,P1Enum);
    3838                        counter++;
    3939                }
    4040        }
    4141
    42         iomodel->FetchDataToInput(elements,"md.geometry.surface",SurfaceEnum);
    43    iomodel->FetchDataToInput(elements,"md.geometry.base",BaseEnum);
    44         iomodel->FetchDataToInput(elements,"md.slr.sealevel",SealevelEnum,0);
    45         iomodel->FetchDataToInput(elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
     42        iomodel->FetchDataToInput(inputs2,elements,"md.geometry.surface",SurfaceEnum);
     43   iomodel->FetchDataToInput(inputs2,elements,"md.geometry.base",BaseEnum);
     44        iomodel->FetchDataToInput(inputs2,elements,"md.slr.sealevel",SealevelEnum,0);
     45        iomodel->FetchDataToInput(inputs2,elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
    4646        if(iomodel->domaintype!=Domain2DhorizontalEnum & iomodel->domaintype!=Domain3DsurfaceEnum){
    47                 iomodel->FetchDataToInput(elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum);
    48                 iomodel->FetchDataToInput(elements,"md.mesh.vertexonsurface",MeshVertexonsurfaceEnum);
     47                iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum);
     48                iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonsurface",MeshVertexonsurfaceEnum);
    4949        }
    5050}/*}}}*/
    … …  
    148148        int         input_enum;
    149149        IssmDouble  Jdet,value,slopes[2];
    150         Input      *input     = NULL;
    151         Input      *input2    = NULL;
     150        Input2     *input     = NULL;
     151        Input2     *input2    = NULL;
    152152        IssmDouble *xyz_list  = NULL;
    153153
    … …  
    163163        basalelement->FindParam(&input_enum,InputToL2ProjectEnum);
    164164        switch(input_enum){
    165                 case SurfaceSlopeXEnum: input2 = basalelement->GetInput(SurfaceEnum); _assert_(input2); break;
    166                 case SurfaceSlopeYEnum: input2 = basalelement->GetInput(SurfaceEnum); _assert_(input2); break;
    167                 case BedSlopeXEnum:     input2 = basalelement->GetInput(BaseEnum);     _assert_(input2); break;
    168                 case BedSlopeYEnum:     input2 = basalelement->GetInput(BaseEnum);     _assert_(input2); break;
    169                 case BaseSlopeXEnum:    input2 = basalelement->GetInput(BaseEnum);    _assert_(input2); break;
    170                 case BaseSlopeYEnum:    input2 = basalelement->GetInput(BaseEnum);    _assert_(input2); break;
    171                 case LevelsetfunctionSlopeXEnum: input2 = basalelement->GetInput(MaskIceLevelsetEnum);     _assert_(input2); break;
    172                 case LevelsetfunctionSlopeYEnum: input2 = basalelement->GetInput(MaskIceLevelsetEnum);     _assert_(input2); break;
    173                 default: input = element->GetInput(input_enum);
     165                case SurfaceSlopeXEnum: input2 = basalelement->GetInput2(SurfaceEnum); _assert_(input2); break;
     166                case SurfaceSlopeYEnum: input2 = basalelement->GetInput2(SurfaceEnum); _assert_(input2); break;
     167                case BedSlopeXEnum:     input2 = basalelement->GetInput2(BaseEnum);     _assert_(input2); break;
     168                case BedSlopeYEnum:     input2 = basalelement->GetInput2(BaseEnum);     _assert_(input2); break;
     169                case BaseSlopeXEnum:    input2 = basalelement->GetInput2(BaseEnum);    _assert_(input2); break;
     170                case BaseSlopeYEnum:    input2 = basalelement->GetInput2(BaseEnum);    _assert_(input2); break;
     171                case LevelsetfunctionSlopeXEnum: input2 = basalelement->GetInput2(MaskIceLevelsetEnum);     _assert_(input2); break;
     172                case LevelsetfunctionSlopeYEnum: input2 = basalelement->GetInput2(MaskIceLevelsetEnum);     _assert_(input2); break;
     173                default: input = element->GetInput2(input_enum);
    174174        }
    175175

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

    r23585 r24335  
    1717                void CreateNodes(Nodes* nodes,IoModel* iomodel,bool isamr=false);
    1818                int  DofsPerNode(int** doflist,int domaintype,int approximation);
    19                 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
     19                void UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type);
    2020                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    2121

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

    r24240 r24335  
    3737        return 1;
    3838}/*}}}*/
    39 void L2ProjectionEPLAnalysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
     39void L2ProjectionEPLAnalysis::UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
    4040
    4141        bool   isefficientlayer;
    … …  
    5555                if(iomodel->my_elements[i]){
    5656                        Element* element=(Element*)elements->GetObjectByOffset(counter);
    57                         element->Update(i,iomodel,analysis_counter,analysis_type,P1Enum);
     57                        element->Update(inputs2,i,iomodel,analysis_counter,analysis_type,P1Enum);
    5858                        counter++;
    5959                }
    6060        }
    6161
    62         iomodel->FetchDataToInput(elements,"md.initialization.epl_head",EplHeadSubstepEnum);
    63         iomodel->FetchDataToInput(elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
     62        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.epl_head",EplHeadSubstepEnum);
     63        iomodel->FetchDataToInput(inputs2,elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
    6464        if(iomodel->domaintype!=Domain2DhorizontalEnum){
    65                 iomodel->FetchDataToInput(elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum);
    66                 iomodel->FetchDataToInput(elements,"md.mesh.vertexonsurface",MeshVertexonsurfaceEnum);
     65                iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum);
     66                iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonsurface",MeshVertexonsurfaceEnum);
    6767        }
    6868}/*}}}*/
    … …  
    105105        }
    106106
    107         Input* active_element_input=basalelement->GetInput(HydrologydcMaskEplactiveEltEnum); _assert_(active_element_input);
    108         active_element_input->GetInputValue(&active_element);
     107        basalelement->GetInput2Value(&active_element,HydrologydcMaskEplactiveEltEnum);
    109108
    110109        /* Check that all nodes are active, else return empty matrix */
    … …  
    173172        }
    174173
    175         Input* active_element_input = basalelement->GetInput(HydrologydcMaskEplactiveEltEnum); _assert_(active_element_input);
    176         active_element_input->GetInputValue(&active_element);
     174        basalelement->GetInput2Value(&active_element,HydrologydcMaskEplactiveEltEnum);
    177175
    178176        /*Check that all nodes are active, else return empty matrix*/
    … …  
    188186        int         input_enum,index;
    189187        IssmDouble  Jdet,slopes[2];
    190         Input      *input     = NULL;
     188        Input2     *input     = NULL;
    191189        IssmDouble *xyz_list  = NULL;
    192190
    … …  
    202200        basalelement->FindParam(&input_enum,InputToL2ProjectEnum);
    203201        switch(input_enum){
    204                 case EplHeadSlopeXEnum: input = basalelement->GetInput(EplHeadSubstepEnum); index = 0; _assert_(input); break;
    205                 case EplHeadSlopeYEnum: input = basalelement->GetInput(EplHeadSubstepEnum); index = 1; _assert_(input); break;
     202                case EplHeadSlopeXEnum: input = basalelement->GetInput2(EplHeadSubstepEnum); index = 0; _assert_(input); break;
     203                case EplHeadSlopeYEnum: input = basalelement->GetInput2(EplHeadSubstepEnum); index = 1; _assert_(input); break;
    206204                default: _error_("not implemented");
    207205        }

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

    r23585 r24335  
    1717                void CreateNodes(Nodes* nodes,IoModel* iomodel,bool isamr=false);
    1818                int  DofsPerNode(int** doflist,int domaintype,int approximation);
    19                 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
     19                void UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type);
    2020                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    2121

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

    r24240 r24335  
    3232}
    3333/*}}}*/
    34 void LevelsetAnalysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
     34void LevelsetAnalysis::UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
    3535
    3636        /*Finite element type*/
    … …  
    4343                if(iomodel->my_elements[i]){
    4444                        Element* element=(Element*)elements->GetObjectByOffset(counter);
    45                         element->Update(i,iomodel,analysis_counter,analysis_type,finiteelement);
     45                        element->Update(inputs2,i,iomodel,analysis_counter,analysis_type,finiteelement);
    4646                        counter++;
    4747                }
    4848        }
    4949
    50         iomodel->FetchDataToInput(elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
    51         iomodel->FetchDataToInput(elements,"md.initialization.vx",VxEnum);
    52         iomodel->FetchDataToInput(elements,"md.initialization.vy",VyEnum);
     50        iomodel->FetchDataToInput(inputs2,elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
     51        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.vx",VxEnum);
     52        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.vy",VyEnum);
    5353
    5454        /*Get moving front parameters*/
    … …  
    5757        switch(calvinglaw){
    5858                case DefaultCalvingEnum:
    59                         iomodel->FetchDataToInput(elements,"md.calving.calvingrate",CalvingCalvingrateEnum);
     59                        iomodel->FetchDataToInput(inputs2,elements,"md.calving.calvingrate",CalvingCalvingrateEnum);
    6060                        break;
    6161                case CalvingLevermannEnum:
    62                         iomodel->FetchDataToInput(elements,"md.calving.coeff",CalvinglevermannCoeffEnum);
     62                        iomodel->FetchDataToInput(inputs2,elements,"md.calving.coeff",CalvinglevermannCoeffEnum);
    6363                        break;
    6464                case CalvingVonmisesEnum:
    65                         iomodel->FetchDataToInput(elements,"md.calving.stress_threshold_groundedice",CalvingStressThresholdGroundediceEnum);
    66                         iomodel->FetchDataToInput(elements,"md.calving.stress_threshold_floatingice",CalvingStressThresholdFloatingiceEnum);
    67                         iomodel->FetchDataToInput(elements,"md.geometry.bed",BedEnum);
     65                        iomodel->FetchDataToInput(inputs2,elements,"md.calving.stress_threshold_groundedice",CalvingStressThresholdGroundediceEnum);
     66                        iomodel->FetchDataToInput(inputs2,elements,"md.calving.stress_threshold_floatingice",CalvingStressThresholdFloatingiceEnum);
     67                        iomodel->FetchDataToInput(inputs2,elements,"md.geometry.bed",BedEnum);
    6868                        break;
    6969                case CalvingMinthicknessEnum:
    70                         iomodel->FetchDataToInput(elements,"md.geometry.bed",BedEnum);
     70                        iomodel->FetchDataToInput(inputs2,elements,"md.geometry.bed",BedEnum);
    7171                        break;
    7272                case CalvingHabEnum:
    73                         iomodel->FetchDataToInput(elements,"md.calving.flotation_fraction",CalvingHabFractionEnum);
     73                        iomodel->FetchDataToInput(inputs2,elements,"md.calving.flotation_fraction",CalvingHabFractionEnum);
    7474                        break;
    7575                case CalvingCrevasseDepthEnum:
    76                         iomodel->FetchDataToInput(elements,"md.calving.water_height",WaterheightEnum);
     76                        iomodel->FetchDataToInput(inputs2,elements,"md.calving.water_height",WaterheightEnum);
    7777                        break;
    7878                case CalvingDev2Enum:
    79                         iomodel->FetchDataToInput(elements,"md.calving.stress_threshold_groundedice",CalvingStressThresholdGroundediceEnum);
    80                         iomodel->FetchDataToInput(elements,"md.calving.stress_threshold_floatingice",CalvingStressThresholdFloatingiceEnum);
     79                        iomodel->FetchDataToInput(inputs2,elements,"md.calving.stress_threshold_groundedice",CalvingStressThresholdGroundediceEnum);
     80                        iomodel->FetchDataToInput(inputs2,elements,"md.calving.stress_threshold_floatingice",CalvingStressThresholdFloatingiceEnum);
    8181                        break;
    8282                default:
    … …  
    8989        switch(melt_parameterization){
    9090                case FrontalForcingsDefaultEnum:
    91                         iomodel->FetchDataToInput(elements,"md.frontalforcings.meltingrate",CalvingMeltingrateEnum);
     91                        iomodel->FetchDataToInput(inputs2,elements,"md.frontalforcings.meltingrate",CalvingMeltingrateEnum);
    9292                        break;
    9393                case FrontalForcingsRignotEnum:
    94                         iomodel->FetchDataToInput(elements,"md.frontalforcings.basin",FrontalForcingsBasinIdEnum);
    95                         iomodel->FetchDataToInput(elements,"md.frontalforcings.subglacial_discharge",FrontalForcingsSubglacialDischargeEnum);
    96                         iomodel->FetchDataToInput(elements,"md.frontalforcings.thermalforcing",FrontalForcingsThermalForcingEnum);
     94                        iomodel->FetchDataToInput(inputs2,elements,"md.frontalforcings.basin",FrontalForcingsBasinIdEnum);
     95                        iomodel->FetchDataToInput(inputs2,elements,"md.frontalforcings.subglacial_discharge",FrontalForcingsSubglacialDischargeEnum);
     96                        iomodel->FetchDataToInput(inputs2,elements,"md.frontalforcings.thermalforcing",FrontalForcingsThermalForcingEnum);
    9797                        break;
    9898                default:
    … …  
    226226        basalelement->FindParam(&dt,TimesteppingTimeStepEnum);
    227227        basalelement->FindParam(&calvingmax,CalvingMaxEnum);
    228         Input* vx_input           = NULL;
    229         Input* vy_input           = NULL;
    230         Input* calvingratex_input = NULL;
    231         Input* calvingratey_input = NULL;
    232         Input* lsf_slopex_input   = NULL;
    233         Input* lsf_slopey_input   = NULL;
    234         Input* calvingrate_input  = NULL;
    235         Input* meltingrate_input  = NULL;
    236         Input* gr_input           = NULL;
     228        Input2* vx_input           = NULL;
     229        Input2* vy_input           = NULL;
     230        Input2* calvingratex_input = NULL;
     231        Input2* calvingratey_input = NULL;
     232        Input2* lsf_slopex_input   = NULL;
     233        Input2* lsf_slopey_input   = NULL;
     234        Input2* calvingrate_input  = NULL;
     235        Input2* meltingrate_input  = NULL;
     236        Input2* gr_input           = NULL;
    237237
    238238        /*Load velocities*/
    239239        switch(domaintype){
    240240                case Domain2DverticalEnum:
    241                         vx_input=basalelement->GetInput(VxEnum); _assert_(vx_input);
     241                        vx_input=basalelement->GetInput2(VxEnum); _assert_(vx_input);
    242242                        break;
    243243                case Domain2DhorizontalEnum:
    244                         vx_input=basalelement->GetInput(VxEnum); _assert_(vx_input);
    245                         vy_input=basalelement->GetInput(VyEnum); _assert_(vy_input);
    246                         gr_input=basalelement->GetInput(MaskGroundediceLevelsetEnum); _assert_(gr_input);
     244                        vx_input=basalelement->GetInput2(VxEnum); _assert_(vx_input);
     245                        vy_input=basalelement->GetInput2(VyEnum); _assert_(vy_input);
     246                        gr_input=basalelement->GetInput2(MaskGroundediceLevelsetEnum); _assert_(gr_input);
    247247                        break;
    248248                case Domain3DEnum:
    249                         vx_input=basalelement->GetInput(VxAverageEnum); _assert_(vx_input);
    250                         vy_input=basalelement->GetInput(VyAverageEnum); _assert_(vy_input);
    251                         gr_input=basalelement->GetInput(MaskGroundediceLevelsetEnum); _assert_(gr_input);
     249                        vx_input=basalelement->GetInput2(VxAverageEnum); _assert_(vx_input);
     250                        vy_input=basalelement->GetInput2(VyAverageEnum); _assert_(vy_input);
     251                        gr_input=basalelement->GetInput2(MaskGroundediceLevelsetEnum); _assert_(gr_input);
    252252                        break;
    253253                default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
    … …  
    258258                case DefaultCalvingEnum:
    259259                case CalvingVonmisesEnum:
    260                         lsf_slopex_input  = basalelement->GetInput(LevelsetfunctionSlopeXEnum); _assert_(lsf_slopex_input);
    261                         if(dim==2) lsf_slopey_input  = basalelement->GetInput(LevelsetfunctionSlopeYEnum); _assert_(lsf_slopey_input);
    262                         calvingrate_input = basalelement->GetInput(CalvingCalvingrateEnum);     _assert_(calvingrate_input);
    263                         meltingrate_input = basalelement->GetInput(CalvingMeltingrateEnum);     _assert_(meltingrate_input);
     260                        lsf_slopex_input  = basalelement->GetInput2(LevelsetfunctionSlopeXEnum); _assert_(lsf_slopex_input);
     261                        if(dim==2) lsf_slopey_input  = basalelement->GetInput2(LevelsetfunctionSlopeYEnum); _assert_(lsf_slopey_input);
     262                        calvingrate_input = basalelement->GetInput2(CalvingCalvingrateEnum);     _assert_(calvingrate_input);
     263                        meltingrate_input = basalelement->GetInput2(CalvingMeltingrateEnum);     _assert_(meltingrate_input);
    264264                        break;
    265265                case CalvingLevermannEnum:
    266266                        switch(domaintype){
    267267                                case Domain2DverticalEnum:
    268                                         calvingratex_input=basalelement->GetInput(CalvingratexEnum); _assert_(calvingratex_input);
     268                                        calvingratex_input=basalelement->GetInput2(CalvingratexEnum); _assert_(calvingratex_input);
    269269                                        break;
    270270                                case Domain2DhorizontalEnum:
    271                                         calvingratex_input=basalelement->GetInput(CalvingratexEnum); _assert_(calvingratex_input);
    272                                         calvingratey_input=basalelement->GetInput(CalvingrateyEnum); _assert_(calvingratey_input);
     271                                        calvingratex_input=basalelement->GetInput2(CalvingratexEnum); _assert_(calvingratex_input);
     272                                        calvingratey_input=basalelement->GetInput2(CalvingrateyEnum); _assert_(calvingratey_input);
    273273                                        break;
    274274                                case Domain3DEnum:
    275                                         calvingratex_input=basalelement->GetInput(CalvingratexAverageEnum); _assert_(calvingratex_input);
    276                                         calvingratey_input=basalelement->GetInput(CalvingrateyAverageEnum); _assert_(calvingratey_input);
     275                                        calvingratex_input=basalelement->GetInput2(CalvingratexAverageEnum); _assert_(calvingratex_input);
     276                                        calvingratey_input=basalelement->GetInput2(CalvingrateyAverageEnum); _assert_(calvingratey_input);
    277277                                        break;
    278278                                default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
    279279                        }
    280                         meltingrate_input = basalelement->GetInput(CalvingMeltingrateEnum);     _assert_(meltingrate_input);
     280                        meltingrate_input = basalelement->GetInput2(CalvingMeltingrateEnum);     _assert_(meltingrate_input);
    281281                        break;
    282282                case CalvingMinthicknessEnum:
    283                         lsf_slopex_input  = basalelement->GetInput(LevelsetfunctionSlopeXEnum); _assert_(lsf_slopex_input);
    284                         if(dim==2) lsf_slopey_input  = basalelement->GetInput(LevelsetfunctionSlopeYEnum); _assert_(lsf_slopey_input);
    285                         meltingrate_input = basalelement->GetInput(CalvingMeltingrateEnum);     _assert_(meltingrate_input);
     283                        lsf_slopex_input  = basalelement->GetInput2(LevelsetfunctionSlopeXEnum); _assert_(lsf_slopex_input);
     284                        if(dim==2) lsf_slopey_input  = basalelement->GetInput2(LevelsetfunctionSlopeYEnum); _assert_(lsf_slopey_input);
     285                        meltingrate_input = basalelement->GetInput2(CalvingMeltingrateEnum);     _assert_(meltingrate_input);
    286286                        break;
    287287                case CalvingHabEnum:
    288                         lsf_slopex_input  = basalelement->GetInput(LevelsetfunctionSlopeXEnum); _assert_(lsf_slopex_input);
    289                         if(dim==2) lsf_slopey_input  = basalelement->GetInput(LevelsetfunctionSlopeYEnum); _assert_(lsf_slopey_input);
    290                         meltingrate_input = basalelement->GetInput(CalvingMeltingrateEnum);     _assert_(meltingrate_input);
     288                        lsf_slopex_input  = basalelement->GetInput2(LevelsetfunctionSlopeXEnum); _assert_(lsf_slopex_input);
     289                        if(dim==2) lsf_slopey_input  = basalelement->GetInput2(LevelsetfunctionSlopeYEnum); _assert_(lsf_slopey_input);
     290                        meltingrate_input = basalelement->GetInput2(CalvingMeltingrateEnum);     _assert_(meltingrate_input);
    291291                        break;
    292292                case CalvingCrevasseDepthEnum:
    293                         lsf_slopex_input  = basalelement->GetInput(LevelsetfunctionSlopeXEnum); _assert_(lsf_slopex_input);
    294                         if(dim==2) lsf_slopey_input  = basalelement->GetInput(LevelsetfunctionSlopeYEnum); _assert_(lsf_slopey_input);
    295                         meltingrate_input = basalelement->GetInput(CalvingMeltingrateEnum);     _assert_(meltingrate_input);
     293                        lsf_slopex_input  = basalelement->GetInput2(LevelsetfunctionSlopeXEnum); _assert_(lsf_slopex_input);
     294                        if(dim==2) lsf_slopey_input  = basalelement->GetInput2(LevelsetfunctionSlopeYEnum); _assert_(lsf_slopey_input);
     295                        meltingrate_input = basalelement->GetInput2(CalvingMeltingrateEnum);     _assert_(meltingrate_input);
    296296                        break;
    297297                case CalvingDev2Enum:
    298298                        basalelement->FindParam(&calvinghaf,CalvingHeightAboveFloatationEnum);
    299                         lsf_slopex_input  = basalelement->GetInput(LevelsetfunctionSlopeXEnum); _assert_(lsf_slopex_input);
    300                         if(dim==2) lsf_slopey_input  = basalelement->GetInput(LevelsetfunctionSlopeYEnum); _assert_(lsf_slopey_input);
    301                         calvingrate_input = basalelement->GetInput(CalvingCalvingrateEnum);     _assert_(calvingrate_input);
    302                         meltingrate_input = basalelement->GetInput(CalvingMeltingrateEnum);     _assert_(meltingrate_input);
     299                        lsf_slopex_input  = basalelement->GetInput2(LevelsetfunctionSlopeXEnum); _assert_(lsf_slopex_input);
     300                        if(dim==2) lsf_slopey_input  = basalelement->GetInput2(LevelsetfunctionSlopeYEnum); _assert_(lsf_slopey_input);
     301                        calvingrate_input = basalelement->GetInput2(CalvingCalvingrateEnum);     _assert_(calvingrate_input);
     302                        meltingrate_input = basalelement->GetInput2(CalvingMeltingrateEnum);     _assert_(meltingrate_input);
    303303                        break;
    304304                default:
    … …  
    571571                /*Retrieve all inputs and parameters*/
    572572                basalelement->GetVerticesCoordinates(&xyz_list);
    573                 Input* levelset_input     = basalelement->GetInput(MaskIceLevelsetEnum);                    _assert_(levelset_input);
     573                Input2* levelset_input     = basalelement->GetInput2(MaskIceLevelsetEnum);                    _assert_(levelset_input);
    574574
    575575                /* Start  looping on the number of gaussian points: */
    … …  
    718718                        int      numnodes = element->GetNumberOfNodes();
    719719                        Gauss*   gauss    = element->NewGauss();
    720                         Input*   H_input  = element->GetInput(ThicknessEnum); _assert_(H_input);
    721                         Input*   b_input = element->GetInput(BedEnum); _assert_(b_input);
    722                         Input*   sl_input = element->GetInput(SealevelEnum); _assert_(sl_input);
     720                        Input2*   H_input  = element->GetInput2(ThicknessEnum); _assert_(H_input);
     721                        Input2*   b_input = element->GetInput2(BedEnum); _assert_(b_input);
     722                        Input2*   sl_input = element->GetInput2(SealevelEnum); _assert_(sl_input);
    723723
    724724                        /*Potentially constrain nodes of this element*/
    … …  
    746746
    747747                /*Get the fraction of the flotation thickness at the terminus*/
    748                 femmodel->elements->InputDuplicate(MaskIceLevelsetEnum, DistanceToCalvingfrontEnum);
     748                InputDuplicatex(femmodel,MaskIceLevelsetEnum,DistanceToCalvingfrontEnum);
    749749                femmodel->DistanceToFieldValue(MaskIceLevelsetEnum,0,DistanceToCalvingfrontEnum);
    750750
    … …  
    758758                        int      numnodes           = element->GetNumberOfNodes();
    759759                        Gauss*   gauss              = element->NewGauss();
    760                         Input*   H_input            = element->GetInput(ThicknessEnum); _assert_(H_input);
    761                         Input*   bed_input          = element->GetInput(BedEnum); _assert_(bed_input);
    762                         Input*   hab_fraction_input = element->GetInput(CalvingHabFractionEnum); _assert_(hab_fraction_input);
    763                         Input*   ls_input           = element->GetInput(DistanceToCalvingfrontEnum); _assert_(ls_input);
     760                        Input2*   H_input            = element->GetInput2(ThicknessEnum); _assert_(H_input);
     761                        Input2*   bed_input          = element->GetInput2(BedEnum); _assert_(bed_input);
     762                        Input2*   hab_fraction_input = element->GetInput2(CalvingHabFractionEnum); _assert_(hab_fraction_input);
     763                        Input2*   ls_input           = element->GetInput2(DistanceToCalvingfrontEnum); _assert_(ls_input);
    764764
    765765                        /*Potentially constrain nodes of this element*/
    … …  
    793793
    794794                /*Get the DistanceToCalvingfront*/
    795                 femmodel->elements->InputDuplicate(MaskIceLevelsetEnum,DistanceToCalvingfrontEnum);
     795                InputDuplicatex(femmodel,MaskIceLevelsetEnum,DistanceToCalvingfrontEnum);
    796796                femmodel->DistanceToFieldValue(MaskIceLevelsetEnum,0,DistanceToCalvingfrontEnum);
    797797
    … …  
    803803                        int      numnodes              = element->GetNumberOfNodes();
    804804                        Gauss*   gauss                 = element->NewGauss();
    805                         Input*   crevassedepth_input   = element->GetInput(CrevasseDepthEnum); _assert_(crevassedepth_input);
    806                         Input*   bed_input             = element->GetInput(BedEnum); _assert_(bed_input);
    807                         Input*   surface_crevasse_input = element->GetInput(SurfaceCrevasseEnum); _assert_(surface_crevasse_input);
    808                         Input*   thickness_input       = element->GetInput(ThicknessEnum); _assert_(thickness_input);
    809                         Input*   surface_input         = element->GetInput(SurfaceEnum); _assert_(surface_input);
     805                        Input2*   crevassedepth_input   = element->GetInput2(CrevasseDepthEnum); _assert_(crevassedepth_input);
     806                        Input2*   bed_input             = element->GetInput2(BedEnum); _assert_(bed_input);
     807                        Input2*   surface_crevasse_input = element->GetInput2(SurfaceCrevasseEnum); _assert_(surface_crevasse_input);
     808                        Input2*   thickness_input       = element->GetInput2(ThicknessEnum); _assert_(thickness_input);
     809                        Input2*   surface_input         = element->GetInput2(SurfaceEnum); _assert_(surface_input);
    810810
    811811                        /*First, look at ice front and figure out if any of the nodes will be calved*/
    … …  
    841841                                int      numnodes               = element->GetNumberOfNodes();
    842842                                Gauss*   gauss                  = element->NewGauss();
    843                                 Input*   levelset_input         = element->GetInput(DistanceToCalvingfrontEnum); _assert_(levelset_input);
    844                                 Input*   crevassedepth_input    = element->GetInput(CrevasseDepthEnum); _assert_(crevassedepth_input);
    845                                 Input*   bed_input              = element->GetInput(BedEnum); _assert_(bed_input);
    846                                 Input*   surface_crevasse_input = element->GetInput(SurfaceCrevasseEnum); _assert_(surface_crevasse_input);
    847                                 Input*   thickness_input        = element->GetInput(ThicknessEnum); _assert_(thickness_input);
    848                                 Input*   surface_input          = element->GetInput(SurfaceEnum); _assert_(surface_input);
     843                                Input2*   levelset_input         = element->GetInput2(DistanceToCalvingfrontEnum); _assert_(levelset_input);
     844                                Input2*   crevassedepth_input    = element->GetInput2(CrevasseDepthEnum); _assert_(crevassedepth_input);
     845                                Input2*   bed_input              = element->GetInput2(BedEnum); _assert_(bed_input);
     846                                Input2*   surface_crevasse_input = element->GetInput2(SurfaceCrevasseEnum); _assert_(surface_crevasse_input);
     847                                Input2*   thickness_input        = element->GetInput2(ThicknessEnum); _assert_(thickness_input);
     848                                Input2*   surface_input          = element->GetInput2(SurfaceEnum); _assert_(surface_input);
    849849
    850850                                /*Is this element connected to a node that should be calved*/

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

    r23585 r24335  
    1717                void CreateNodes(Nodes* nodes,IoModel* iomodel,bool isamr=false);
    1818                int  DofsPerNode(int** doflist,int domaintype,int approximation);
    19                 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
     19                void UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type);
    2020                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    2121

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

    r23601 r24335  
    1515        _error_("not needed!");
    1616}/*}}}*/
    17 void LoveAnalysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
     17void LoveAnalysis::UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
    1818
    1919}/*}}}*/

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

    r23585 r24335  
    1717                void CreateNodes(Nodes* nodes,IoModel* iomodel,bool isamr=false);
    1818                int  DofsPerNode(int** doflist,int domaintype,int approximation);
    19                 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
     19                void UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type);
    2020                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    2121

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

    r24145 r24335  
    111111        return 1;
    112112}/*}}}*/
    113 void MasstransportAnalysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
     113void MasstransportAnalysis::UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
    114114
    115115        int    stabilization,finiteelement;
    … …  
    140140                if(iomodel->my_elements[i]){
    141141                        Element* element=(Element*)elements->GetObjectByOffset(counter);
    142                         element->Update(i,iomodel,analysis_counter,analysis_type,finiteelement);
     142                        element->Update(inputs2,i,iomodel,analysis_counter,analysis_type,finiteelement);
    143143                        counter++;
    144144                }
    145145        }
    146146
    147         iomodel->FetchDataToInput(elements,"md.geometry.thickness",ThicknessEnum);
    148         iomodel->FetchDataToInput(elements,"md.geometry.surface",SurfaceEnum);
    149         iomodel->FetchDataToInput(elements,"md.geometry.base",BaseEnum);
    150         iomodel->FetchDataToInput(elements,"md.slr.sealevel",SealevelEnum,0);
    151         iomodel->FetchDataToInput(elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
    152         iomodel->FetchDataToInput(elements,"md.mask.groundedice_levelset",MaskGroundediceLevelsetEnum);
    153         iomodel->FetchDataToInput(elements,"md.basalforcings.groundedice_melting_rate",BasalforcingsGroundediceMeltingRateEnum);
    154         iomodel->FetchDataToInput(elements,"md.initialization.vx",VxEnum);
    155         iomodel->FetchDataToInput(elements,"md.initialization.vy",VyEnum);
    156         if(isgroundingline)     iomodel->FetchDataToInput(elements,"md.geometry.bed",BedEnum);
     147        iomodel->FetchDataToInput(inputs2,elements,"md.geometry.thickness",ThicknessEnum);
     148        iomodel->FetchDataToInput(inputs2,elements,"md.geometry.surface",SurfaceEnum);
     149        iomodel->FetchDataToInput(inputs2,elements,"md.geometry.base",BaseEnum);
     150        iomodel->FetchDataToInput(inputs2,elements,"md.slr.sealevel",SealevelEnum,0);
     151        iomodel->FetchDataToInput(inputs2,elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
     152        iomodel->FetchDataToInput(inputs2,elements,"md.mask.groundedice_levelset",MaskGroundediceLevelsetEnum);
     153        iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.groundedice_melting_rate",BasalforcingsGroundediceMeltingRateEnum);
     154        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.vx",VxEnum);
     155        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.vy",VyEnum);
     156        if(isgroundingline)     iomodel->FetchDataToInput(inputs2,elements,"md.geometry.bed",BedEnum);
    157157        /*Initialize cumdeltalthickness input*/
    158         InputUpdateFromConstantx(elements,0.,SealevelriseCumDeltathicknessEnum);
     158        InputUpdateFromConstantx(inputs2,elements,0.,SealevelriseCumDeltathicknessEnum);
    159159        /*Initialize ThicknessResidual input*/
    160         InputUpdateFromConstantx(elements,0.,ThicknessResidualEnum);
     160        InputUpdateFromConstantx(inputs2,elements,0.,ThicknessResidualEnum);
    161161
    162162        /*Get what we need for ocean-induced basal melting*/
    … …  
    165165        switch(basalforcing_model){
    166166                case FloatingMeltRateEnum:
    167                         iomodel->FetchDataToInput(elements,"md.basalforcings.floatingice_melting_rate",BasalforcingsFloatingiceMeltingRateEnum);
     167                        iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.floatingice_melting_rate",BasalforcingsFloatingiceMeltingRateEnum);
    168168                        break;
    169169                case LinearFloatingMeltRateEnum:
    … …  
    174174                        break;
    175175                case SpatialLinearFloatingMeltRateEnum:
    176                         iomodel->FetchDataToInput(elements,"md.basalforcings.deepwater_melting_rate",BasalforcingsDeepwaterMeltingRateEnum);
    177                         iomodel->FetchDataToInput(elements,"md.basalforcings.deepwater_elevation",BasalforcingsDeepwaterElevationEnum);
    178                         iomodel->FetchDataToInput(elements,"md.basalforcings.upperwater_elevation",BasalforcingsUpperwaterElevationEnum);
     176                        iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.deepwater_melting_rate",BasalforcingsDeepwaterMeltingRateEnum);
     177                        iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.deepwater_elevation",BasalforcingsDeepwaterElevationEnum);
     178                        iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.upperwater_elevation",BasalforcingsUpperwaterElevationEnum);
    179179                        break;
    180180                case BasalforcingsPicoEnum:
    181                         iomodel->FetchDataToInput(elements,"md.basalforcings.basin_id",BasalforcingsPicoBasinIdEnum);
     181                        iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.basin_id",BasalforcingsPicoBasinIdEnum);
    182182                        break;
    183183                case BasalforcingsIsmip6Enum:{
    184                         iomodel->FetchDataToInput(elements,"md.basalforcings.basin_id",BasalforcingsIsmip6BasinIdEnum);
    185                         iomodel->FetchDataToInput(elements,"md.basalforcings.melt_anomaly",BasalforcingsIsmip6MeltAnomalyEnum,0.);
     184                        iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.basin_id",BasalforcingsIsmip6BasinIdEnum);
     185                        iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.melt_anomaly",BasalforcingsIsmip6MeltAnomalyEnum,0.);
    186186                        IssmDouble** array3d = NULL; int* Ms = NULL; int* Ns = NULL; int K;
    187187                        iomodel->FetchData(&array3d,&Ms,&Ns,&K,"md.basalforcings.tf");
    … …  
    191191                                if(iomodel->domaintype!=Domain2DhorizontalEnum && !element->IsOnBase()) continue;
    192192                                for(int kk=0;kk<K;kk++){
    193                                         element->DatasetInputAdd(BasalforcingsIsmip6TfEnum,array3d[kk],iomodel,Ms[kk],Ns[kk],1,BasalforcingsIsmip6TfEnum,7,kk);
     193                                        element->DatasetInputAdd(BasalforcingsIsmip6TfEnum,array3d[kk],inputs2,iomodel,Ms[kk],Ns[kk],1,BasalforcingsIsmip6TfEnum,7,kk);
    194194                                }
    195195                        }
    … …  
    200200                        break;
    201201                case BeckmannGoosseFloatingMeltRateEnum:
    202                         iomodel->FetchDataToInput(elements,"md.basalforcings.ocean_salinity",BasalforcingsOceanSalinityEnum);
    203                         iomodel->FetchDataToInput(elements,"md.basalforcings.ocean_temp",BasalforcingsOceanTempEnum);
     202                        iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.ocean_salinity",BasalforcingsOceanSalinityEnum);
     203                        iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.ocean_temp",BasalforcingsOceanTempEnum);
    204204                        break;
    205205                default:
    … …  
    208208
    209209        if(!issmb){
    210                 iomodel->FetchDataToInput(elements,"md.smb.mass_balance",SmbMassBalanceEnum);
     210                iomodel->FetchDataToInput(inputs2,elements,"md.smb.mass_balance",SmbMassBalanceEnum);
    211211        }
    212212        if(stabilization==3){
    213                 iomodel->FetchDataToInput(elements,"md.masstransport.spcthickness",MasstransportSpcthicknessEnum); //for DG, we need the spc in the element
     213                iomodel->FetchDataToInput(inputs2,elements,"md.masstransport.spcthickness",MasstransportSpcthicknessEnum); //for DG, we need the spc in the element
    214214        }
    215215        if(stabilization==4){
    216                 iomodel->FetchDataToInput(elements,"md.masstransport.spcthickness",MasstransportSpcthicknessEnum); //for FCT, we need the spc in the element (penlaties)
     216                iomodel->FetchDataToInput(inputs2,elements,"md.masstransport.spcthickness",MasstransportSpcthicknessEnum); //for FCT, we need the spc in the element (penlaties)
    217217        }
    218218
    219219        if(iomodel->domaintype!=Domain2DhorizontalEnum){
    220                 iomodel->FetchDataToInput(elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum);
    221                 iomodel->FetchDataToInput(elements,"md.mesh.vertexonsurface",MeshVertexonsurfaceEnum);
     220                iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum);
     221                iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonsurface",MeshVertexonsurfaceEnum);
    222222        }
    223223
    … …  
    318318        element->FindParam(&domaintype,DomainTypeEnum);
    319319        element->FindParam(&stabilization,MasstransportStabilizationEnum);
    320         Input* vxaverage_input=element->GetInput(VxAverageEnum); _assert_(vxaverage_input);
    321         Input* vyaverage_input=NULL;
     320        Input2* vxaverage_input=element->GetInput2(VxAverageEnum); _assert_(vxaverage_input);
     321        Input2* vyaverage_input=NULL;
    322322        if(dim==2){
    323                 vyaverage_input=element->GetInput(VyAverageEnum); _assert_(vyaverage_input);
     323                vyaverage_input=element->GetInput2(VyAverageEnum); _assert_(vyaverage_input);
    324324        }
    325325
    … …  
    507507        element->FindParam(&dt,TimesteppingTimeStepEnum);
    508508        element->FindParam(&domaintype,DomainTypeEnum);
    509         Input* vxaverage_input=element->GetInput(VxAverageEnum); _assert_(vxaverage_input);
    510         Input* vyaverage_input=element->GetInput(VyAverageEnum); _assert_(vyaverage_input);
     509        Input2* vxaverage_input=element->GetInput2(VxAverageEnum); _assert_(vxaverage_input);
     510        Input2* vyaverage_input=element->GetInput2(VyAverageEnum); _assert_(vyaverage_input);
    511511
    512512        /* Start  looping on the number of gaussian points: */
    … …  
    617617        element->FindParam(&dt,TimesteppingTimeStepEnum);
    618618        element->FindParam(&stabilization,MasstransportStabilizationEnum);
    619         Input* gmb_input        = element->GetInput(BasalforcingsGroundediceMeltingRateEnum);  _assert_(gmb_input);
    620         Input* fmb_input        = element->GetInput(BasalforcingsFloatingiceMeltingRateEnum);  _assert_(fmb_input);
    621         Input* gllevelset_input = element->GetInput(MaskGroundediceLevelsetEnum);              _assert_(gllevelset_input);
    622         Input* ms_input         = element->GetInput(SmbMassBalanceEnum);                       _assert_(ms_input);
    623         Input* thickness_input  = element->GetInput(ThicknessEnum);                            _assert_(thickness_input);
    624         Input* vxaverage_input  = element->GetInput(VxAverageEnum);                                                                             _assert_(vxaverage_input);
    625         Input* vyaverage_input  = element->GetInput(VyAverageEnum);                                                                             _assert_(vyaverage_input);
     619        Input2* gmb_input        = element->GetInput2(BasalforcingsGroundediceMeltingRateEnum);  _assert_(gmb_input);
     620        Input2* fmb_input        = element->GetInput2(BasalforcingsFloatingiceMeltingRateEnum);  _assert_(fmb_input);
     621        Input2* gllevelset_input = element->GetInput2(MaskGroundediceLevelsetEnum);              _assert_(gllevelset_input);
     622        Input2* ms_input         = element->GetInput2(SmbMassBalanceEnum);                       _assert_(ms_input);
     623        Input2* thickness_input  = element->GetInput2(ThicknessEnum);                            _assert_(thickness_input);
     624        Input2* vxaverage_input  = element->GetInput2(VxAverageEnum);                                                                           _assert_(vxaverage_input);
     625        Input2* vyaverage_input  = element->GetInput2(VyAverageEnum);                                                                           _assert_(vyaverage_input);
     626
     627//      if(element->Id()==9){
     628//              gmb_input->Echo();
     629//              _error_("S");
     630//      }
    626631
    627632        h=element->CharacteristicLength();
    … …  
    726731        element->FindParam(&dt,TimesteppingTimeStepEnum);
    727732        element->FindParam(&melt_style,GroundinglineMeltInterpolationEnum);
    728         Input* gmb_input        = element->GetInput(BasalforcingsGroundediceMeltingRateEnum); _assert_(gmb_input);
    729         Input* fmb_input        = element->GetInput(BasalforcingsFloatingiceMeltingRateEnum); _assert_(fmb_input);
    730         Input* ms_input         = element->GetInput(SmbMassBalanceEnum);                      _assert_(ms_input);
    731         Input* gllevelset_input = element->GetInput(MaskGroundediceLevelsetEnum);             _assert_(gllevelset_input);
    732         Input* thickness_input  = element->GetInput(ThicknessEnum);                           _assert_(thickness_input);
     733        Input2* gmb_input        = element->GetInput2(BasalforcingsGroundediceMeltingRateEnum); _assert_(gmb_input);
     734        Input2* fmb_input        = element->GetInput2(BasalforcingsFloatingiceMeltingRateEnum); _assert_(fmb_input);
     735        Input2* ms_input         = element->GetInput2(SmbMassBalanceEnum);                      _assert_(ms_input);
     736        Input2* gllevelset_input = element->GetInput2(MaskGroundediceLevelsetEnum);             _assert_(gllevelset_input);
     737        Input2* thickness_input  = element->GetInput2(ThicknessEnum);                           _assert_(thickness_input);
    733738
    734739   /*Recover portion of element that is grounded*/
    … …  
    872877                }
    873878        }
    874         element->AddBasalInput(ThicknessEnum,newthickness,element->GetElementType());
    875         element->AddBasalInput(ThicknessResidualEnum,thicknessresidual,element->GetElementType());
     879        element->AddBasalInput2(ThicknessEnum,newthickness,element->GetElementType());
     880        element->AddBasalInput2(ThicknessResidualEnum,thicknessresidual,element->GetElementType());
    876881       
    877882        xDelete<int>(doflist);
    … …  
    905910        basalelement->GetInputListOnVertices(&newthickness[0],ThicknessEnum);
    906911        basalelement->GetInputListOnVertices(&oldthickness[0],ThicknessOldEnum);
    907         basalelement->GetInputListOnVertices(&oldbase[0],BaseEnum);
    908         basalelement->GetInputListOnVertices(&oldsurface[0],SurfaceEnum);
     912        basalelement->GetInputListOnVertices(&oldbase[0],BaseOldEnum);
     913        basalelement->GetInputListOnVertices(&oldsurface[0],SurfaceOldEnum);
    909914        basalelement->GetInputListOnVertices(&phi[0],MaskGroundediceLevelsetEnum);
    910915        basalelement->GetInputListOnVertices(&sealevel[0],SealevelEnum);
    911         basalelement->GetInputListOnVertices(&cumdeltathickness[0],SealevelriseCumDeltathicknessEnum);
     916        basalelement->GetInputListOnVertices(&cumdeltathickness[0],SealevelriseCumDeltathicknessOldEnum);
    912917
    913918        /*Do we do grounding line migration?*/
    … …  
    953958
    954959        /*Add input to the element: */
    955         element->AddBasalInput(SurfaceEnum,newsurface,P1Enum);
    956         element->AddBasalInput(BaseEnum,newbase,P1Enum);
    957         element->AddBasalInput(SealevelriseCumDeltathicknessEnum,cumdeltathickness,P1Enum);
    958         element->AddBasalInput(SealevelriseDeltathicknessEnum,deltathickness,P1Enum);
     960        element->AddBasalInput2(SurfaceEnum,newsurface,P1Enum);
     961        element->AddBasalInput2(BaseEnum,newbase,P1Enum);
     962        element->AddBasalInput2(SealevelriseCumDeltathicknessEnum,cumdeltathickness,P1Enum);
     963        element->AddBasalInput2(SealevelriseDeltathicknessEnum,deltathickness,P1Enum);
    959964
    960965        /*Free ressources:*/
    … …  
    10001005        /*Retrieve all inputs and parameters*/
    10011006        element->GetVerticesCoordinates(&xyz_list);
    1002         Input* vxaverage_input=element->GetInput(VxEnum); _assert_(vxaverage_input);
    1003         Input* vyaverage_input=element->GetInput(VyEnum); _assert_(vyaverage_input);
     1007        Input2* vxaverage_input=element->GetInput2(VxEnum); _assert_(vxaverage_input);
     1008        Input2* vyaverage_input=element->GetInput2(VyEnum); _assert_(vyaverage_input);
    10041009
    10051010        /* Start  looping on the number of gaussian points: */

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

    r23585 r24335  
    1717                void CreateNodes(Nodes* nodes,IoModel* iomodel,bool isamr=false);
    1818                int  DofsPerNode(int** doflist,int domaintype,int approximation);
    19                 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
     19                void UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type);
    2020                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    2121

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

    r23959 r24335  
    3737        return 1;
    3838}/*}}}*/
    39 void MeltingAnalysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
     39void MeltingAnalysis::UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
    4040
    4141        /*Now, is the model 3d? otherwise, do nothing: */
    … …  
    4747                if(iomodel->my_elements[i]){
    4848                        Element* element=(Element*)elements->GetObjectByOffset(counter);
    49                         element->Update(i,iomodel,analysis_counter,analysis_type,P1Enum);
     49                        element->Update(inputs2,i,iomodel,analysis_counter,analysis_type,P1Enum);
    5050                        counter++;
    5151                }
    … …  
    5353
    5454        /*Create inputs: */
    55         iomodel->FetchDataToInput(elements,"md.geometry.thickness",ThicknessEnum);
    56         iomodel->FetchDataToInput(elements,"md.geometry.surface",SurfaceEnum);
    57         iomodel->FetchDataToInput(elements,"md.geometry.base",BaseEnum);
    58         iomodel->FetchDataToInput(elements,"md.slr.sealevel",SealevelEnum,0);
    59         iomodel->FetchDataToInput(elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
     55        iomodel->FetchDataToInput(inputs2,elements,"md.geometry.thickness",ThicknessEnum);
     56        iomodel->FetchDataToInput(inputs2,elements,"md.geometry.surface",SurfaceEnum);
     57        iomodel->FetchDataToInput(inputs2,elements,"md.geometry.base",BaseEnum);
     58        iomodel->FetchDataToInput(inputs2,elements,"md.slr.sealevel",SealevelEnum,0);
     59        iomodel->FetchDataToInput(inputs2,elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
    6060        if(iomodel->domaintype!=Domain2DhorizontalEnum){
    61                 iomodel->FetchDataToInput(elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum);
    62                 iomodel->FetchDataToInput(elements,"md.mesh.vertexonsurface",MeshVertexonsurfaceEnum);
     61                iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum);
     62                iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonsurface",MeshVertexonsurfaceEnum);
    6363        }
    64         iomodel->FetchDataToInput(elements,"md.initialization.pressure",PressureEnum);
     64        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.pressure",PressureEnum);
    6565}/*}}}*/
    6666void MeltingAnalysis::UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/

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

    r23585 r24335  
    1717                void CreateNodes(Nodes* nodes,IoModel* iomodel,bool isamr=false);
    1818                int  DofsPerNode(int** doflist,int domaintype,int approximation);
    19                 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
     19                void UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type);
    2020                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    2121

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

    r24259 r24335  
    1818        return 1;
    1919}/*}}}*/
    20 void SealevelriseAnalysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
     20void SealevelriseAnalysis::UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
    2121
    2222        int geodetic=0;
    … …  
    2727                if(iomodel->my_elements[i]){
    2828                        Element* element=(Element*)elements->GetObjectByOffset(counter);
    29                         element->Update(i,iomodel,analysis_counter,analysis_type,P1Enum);
     29                        element->Update(inputs2,i,iomodel,analysis_counter,analysis_type,P1Enum);
    3030                        counter++;
    3131                }
    … …  
    3333
    3434        /*Create inputs: */
    35         iomodel->FetchDataToInput(elements,"md.mask.groundedice_levelset",MaskGroundediceLevelsetEnum);
    36         iomodel->FetchDataToInput(elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
     35        iomodel->FetchDataToInput(inputs2,elements,"md.mask.groundedice_levelset",MaskGroundediceLevelsetEnum);
     36        iomodel->FetchDataToInput(inputs2,elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
    3737        //those only if we have requested geodetic computations:
    3838        iomodel->FetchData(&geodetic,"md.slr.geodetic");
    … …  
    4141                iomodel->FetchData(&masktype,"md.mask.type");
    4242                if (strcmp(masktype,"maskpsl")==0){
    43                         iomodel->FetchDataToInput(elements,"md.mask.ocean_levelset",MaskOceanLevelsetEnum);
    44                         iomodel->FetchDataToInput(elements,"md.mask.land_levelset",MaskLandLevelsetEnum);
     43                        iomodel->FetchDataToInput(inputs2,elements,"md.mask.ocean_levelset",MaskOceanLevelsetEnum);
     44                        iomodel->FetchDataToInput(inputs2,elements,"md.mask.land_levelset",MaskLandLevelsetEnum);
    4545                }
    4646                xDelete<char>(masktype);
    4747        }
    48         iomodel->FetchDataToInput(elements,"md.slr.deltathickness",SealevelriseDeltathicknessEnum);
    49         iomodel->FetchDataToInput(elements,"md.slr.spcthickness",SealevelriseSpcthicknessEnum);
    50         iomodel->FetchDataToInput(elements,"md.slr.sealevel",SealevelEnum,0);
    51         iomodel->FetchDataToInput(elements,"md.geometry.bed",BedEnum);
    52         iomodel->FetchDataToInput(elements,"md.slr.Ngia",SealevelNGiaRateEnum);
    53         iomodel->FetchDataToInput(elements,"md.slr.Ugia",SealevelUGiaRateEnum);
    54         iomodel->FetchDataToInput(elements,"md.slr.steric_rate",SealevelriseStericRateEnum);
    55         iomodel->FetchDataToInput(elements,"md.slr.hydro_rate",SealevelriseHydroRateEnum);
     48        iomodel->FetchDataToInput(inputs2,elements,"md.slr.deltathickness",SealevelriseDeltathicknessEnum);
     49        iomodel->FetchDataToInput(inputs2,elements,"md.slr.spcthickness",SealevelriseSpcthicknessEnum);
     50        iomodel->FetchDataToInput(inputs2,elements,"md.slr.sealevel",SealevelEnum,0);
     51        iomodel->FetchDataToInput(inputs2,elements,"md.geometry.bed",BedEnum);
     52        iomodel->FetchDataToInput(inputs2,elements,"md.slr.Ngia",SealevelNGiaRateEnum);
     53        iomodel->FetchDataToInput(inputs2,elements,"md.slr.Ugia",SealevelUGiaRateEnum);
     54        iomodel->FetchDataToInput(inputs2,elements,"md.slr.steric_rate",SealevelriseStericRateEnum);
     55        iomodel->FetchDataToInput(inputs2,elements,"md.slr.hydro_rate",SealevelriseHydroRateEnum);
    5656
    5757        /*Initialize cumdeltalthickness and sealevel rise rate input*/
    58         InputUpdateFromConstantx(elements,0.,SealevelriseCumDeltathicknessEnum);
    59         InputUpdateFromConstantx(elements,0.,SealevelNEsaRateEnum);
    60         InputUpdateFromConstantx(elements,0.,SealevelUEsaRateEnum);
    61         InputUpdateFromConstantx(elements,0.,SealevelRSLRateEnum);
    62         InputUpdateFromConstantx(elements,0.,SealevelEustaticMaskEnum);
    63         InputUpdateFromConstantx(elements,0.,SealevelEustaticOceanMaskEnum);
     58        InputUpdateFromConstantx(inputs2,elements,0.,SealevelriseCumDeltathicknessEnum);
     59        InputUpdateFromConstantx(inputs2,elements,0.,SealevelNEsaRateEnum);
     60        InputUpdateFromConstantx(inputs2,elements,0.,SealevelUEsaRateEnum);
     61        InputUpdateFromConstantx(inputs2,elements,0.,SealevelRSLRateEnum);
     62        InputUpdateFromConstantx(inputs2,elements,0.,SealevelEustaticMaskEnum);
     63        InputUpdateFromConstantx(inputs2,elements,0.,SealevelEustaticOceanMaskEnum);
    6464
    6565}/*}}}*/

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

    r23585 r24335  
    1717                void CreateNodes(Nodes* nodes,IoModel* iomodel,bool isamr=false);
    1818                int  DofsPerNode(int** doflist,int domaintype,int approximation);
    19                 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
     19                void UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type);
    2020                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    2121

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

    r24253 r24335  
    2121        return 1;
    2222}/*}}}*/
    23 void SmbAnalysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
     23void SmbAnalysis::UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
    2424
    2525        int    smb_model;
    … …  
    3131                if(iomodel->my_elements[i]){
    3232                        Element* element=(Element*)elements->GetObjectByOffset(counter);
    33                         element->Update(i,iomodel,analysis_counter,analysis_type,P1Enum);
     33                        element->Update(inputs2,i,iomodel,analysis_counter,analysis_type,P1Enum);
    3434                        counter++;
    3535                }
    … …  
    4040        switch(smb_model){
    4141                case SMBforcingEnum:
    42                         iomodel->FetchDataToInput(elements,"md.smb.mass_balance",SmbMassBalanceEnum,0.);
     42                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.mass_balance",SmbMassBalanceEnum,0.);
    4343                        break;
    4444                case SMBgembEnum:
    45                         iomodel->FetchDataToInput(elements,"md.smb.Ta",SmbTaEnum);
    46                         iomodel->FetchDataToInput(elements,"md.smb.V",SmbVEnum);
    47                         iomodel->FetchDataToInput(elements,"md.smb.dswrf",SmbDswrfEnum);
    48                         iomodel->FetchDataToInput(elements,"md.smb.dlwrf",SmbDlwrfEnum);
    49                         iomodel->FetchDataToInput(elements,"md.smb.P",SmbPEnum);
    50                         iomodel->FetchDataToInput(elements,"md.smb.eAir",SmbEAirEnum);
    51                         iomodel->FetchDataToInput(elements,"md.smb.pAir",SmbPAirEnum);
    52                         iomodel->FetchDataToInput(elements,"md.smb.zTop",SmbZTopEnum);
    53                         iomodel->FetchDataToInput(elements,"md.smb.dzTop",SmbDzTopEnum);
    54                         iomodel->FetchDataToInput(elements,"md.smb.dzMin",SmbDzMinEnum);
    55                         iomodel->FetchDataToInput(elements,"md.smb.zY",SmbZYEnum);
    56                         iomodel->FetchDataToInput(elements,"md.smb.zMax",SmbZMaxEnum);
    57                         iomodel->FetchDataToInput(elements,"md.smb.zMin",SmbZMinEnum);
    58                         iomodel->FetchDataToInput(elements,"md.smb.Tmean",SmbTmeanEnum);
    59                         iomodel->FetchDataToInput(elements,"md.smb.Vmean",SmbVmeanEnum);
    60                         iomodel->FetchDataToInput(elements,"md.smb.C",SmbCEnum);
    61                         iomodel->FetchDataToInput(elements,"md.smb.Tz",SmbTzEnum);
    62                         iomodel->FetchDataToInput(elements,"md.smb.Vz",SmbVzEnum);
    63                         InputUpdateFromConstantx(elements,0.,SmbIsInitializedEnum);
    64                         iomodel->FetchDataToInput(elements,"md.smb.Dzini",SmbDziniEnum);
    65                         iomodel->FetchDataToInput(elements,"md.smb.Dini",SmbDiniEnum);
    66                         iomodel->FetchDataToInput(elements,"md.smb.Reini",SmbReiniEnum);
    67                         iomodel->FetchDataToInput(elements,"md.smb.Gdnini",SmbGdniniEnum);
    68                         iomodel->FetchDataToInput(elements,"md.smb.Gspini",SmbGspiniEnum);
    69                         iomodel->FetchDataToInput(elements,"md.smb.ECini",SmbECiniEnum);
    70                         iomodel->FetchDataToInput(elements,"md.smb.Wini",SmbWiniEnum);
    71                         iomodel->FetchDataToInput(elements,"md.smb.Aini",SmbAiniEnum);
    72                         iomodel->FetchDataToInput(elements,"md.smb.Tini",SmbTiniEnum);
    73                         iomodel->FetchDataToInput(elements,"md.smb.Sizeini",SmbSizeiniEnum);
    74                         iomodel->FetchDataToInput(elements,"md.smb.aValue",SmbAValueEnum);
    75                         iomodel->FetchDataToInput(elements,"md.smb.teValue",SmbTeValueEnum);
     45                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.Ta",SmbTaEnum);
     46                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.V",SmbVEnum);
     47                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.dswrf",SmbDswrfEnum);
     48                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.dlwrf",SmbDlwrfEnum);
     49                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.P",SmbPEnum);
     50                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.eAir",SmbEAirEnum);
     51                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.pAir",SmbPAirEnum);
     52                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.zTop",SmbZTopEnum);
     53                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.dzTop",SmbDzTopEnum);
     54                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.dzMin",SmbDzMinEnum);
     55                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.zY",SmbZYEnum);
     56                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.zMax",SmbZMaxEnum);
     57                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.zMin",SmbZMinEnum);
     58                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.Tmean",SmbTmeanEnum);
     59                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.Vmean",SmbVmeanEnum);
     60                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.C",SmbCEnum);
     61                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.Tz",SmbTzEnum);
     62                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.Vz",SmbVzEnum);
     63                        InputUpdateFromConstantx(inputs2,elements,0.,SmbIsInitializedEnum);
     64                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.Dzini",SmbDziniEnum);
     65                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.Dini",SmbDiniEnum);
     66                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.Reini",SmbReiniEnum);
     67                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.Gdnini",SmbGdniniEnum);
     68                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.Gspini",SmbGspiniEnum);
     69                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.ECini",SmbECiniEnum);
     70                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.Wini",SmbWiniEnum);
     71                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.Aini",SmbAiniEnum);
     72                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.Tini",SmbTiniEnum);
     73                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.Sizeini",SmbSizeiniEnum);
     74                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.aValue",SmbAValueEnum);
     75                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.teValue",SmbTeValueEnum);
    7676                        break;
    7777                case SMBpddEnum:
    7878                        iomodel->FindConstant(&isdelta18o,"md.smb.isdelta18o");
    7979                        iomodel->FindConstant(&ismungsm,"md.smb.ismungsm");
    80                         iomodel->FetchDataToInput(elements,"md.thermal.spctemperature",ThermalSpctemperatureEnum);
    81                         iomodel->FetchDataToInput(elements,"md.smb.s0p",SmbS0pEnum);
    82                         iomodel->FetchDataToInput(elements,"md.smb.s0t",SmbS0tEnum);
     80                        iomodel->FetchDataToInput(inputs2,elements,"md.thermal.spctemperature",ThermalSpctemperatureEnum);
     81                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.s0p",SmbS0pEnum);
     82                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.s0t",SmbS0tEnum);
    8383                        if(isdelta18o || ismungsm){
    84                                 iomodel->FetchDataToInput(elements,"md.smb.temperatures_lgm",SmbTemperaturesLgmEnum);
    85                                 iomodel->FetchDataToInput(elements,"md.smb.temperatures_presentday",SmbTemperaturesPresentdayEnum);
    86                                 iomodel->FetchDataToInput(elements,"md.smb.precipitations_presentday",SmbPrecipitationsPresentdayEnum);
    87                                 iomodel->FetchDataToInput(elements,"md.smb.precipitations_lgm",SmbPrecipitationsLgmEnum);
     84                                iomodel->FetchDataToInput(inputs2,elements,"md.smb.temperatures_lgm",SmbTemperaturesLgmEnum);
     85                                iomodel->FetchDataToInput(inputs2,elements,"md.smb.temperatures_presentday",SmbTemperaturesPresentdayEnum);
     86                                iomodel->FetchDataToInput(inputs2,elements,"md.smb.precipitations_presentday",SmbPrecipitationsPresentdayEnum);
     87                                iomodel->FetchDataToInput(inputs2,elements,"md.smb.precipitations_lgm",SmbPrecipitationsLgmEnum);
    8888                        }else{
    89                                 iomodel->FetchDataToInput(elements,"md.smb.precipitation",SmbPrecipitationEnum);
    90                                 iomodel->FetchDataToInput(elements,"md.smb.monthlytemperatures",SmbMonthlytemperaturesEnum);
     89                                iomodel->FetchDataToInput(inputs2,elements,"md.smb.precipitation",SmbPrecipitationEnum);
     90                                iomodel->FetchDataToInput(inputs2,elements,"md.smb.monthlytemperatures",SmbMonthlytemperaturesEnum);
    9191                        }
    9292                        break;
    9393                case SMBpddSicopolisEnum:
    94                         iomodel->FetchDataToInput(elements,"md.smb.s0p",SmbS0pEnum);
    95                         iomodel->FetchDataToInput(elements,"md.smb.s0t",SmbS0tEnum);
     94                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.s0p",SmbS0pEnum);
     95                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.s0t",SmbS0tEnum);
    9696                        iomodel->FindConstant(&isfirnwarming,"md.smb.isfirnwarming");
    97                         iomodel->FetchDataToInput(elements,"md.smb.smb_corr",SmbSmbCorrEnum);
    98                         iomodel->FetchDataToInput(elements,"md.smb.precipitation",SmbPrecipitationEnum);
    99                         iomodel->FetchDataToInput(elements,"md.smb.monthlytemperatures",SmbMonthlytemperaturesEnum);
    100                         iomodel->FetchDataToInput(elements,"md.smb.precipitation_anomaly",SmbPrecipitationsAnomalyEnum);
    101                         iomodel->FetchDataToInput(elements,"md.smb.temperature_anomaly",SmbTemperaturesAnomalyEnum);
     97                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.smb_corr",SmbSmbCorrEnum);
     98                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.precipitation",SmbPrecipitationEnum);
     99                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.monthlytemperatures",SmbMonthlytemperaturesEnum);
     100                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.precipitation_anomaly",SmbPrecipitationsAnomalyEnum);
     101                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.temperature_anomaly",SmbTemperaturesAnomalyEnum);
    102102                        break;
    103103                case SMBd18opddEnum:
    … …  
    107107                        iomodel->FindConstant(&isd18opd,"md.smb.isd18opd");
    108108                        iomodel->FindConstant(&issetpddfac,"md.smb.issetpddfac");
    109                         iomodel->FetchDataToInput(elements,"md.thermal.spctemperature",ThermalSpctemperatureEnum);
    110                         iomodel->FetchDataToInput(elements,"md.smb.s0p",SmbS0pEnum);
    111                         iomodel->FetchDataToInput(elements,"md.smb.s0t",SmbS0tEnum);
     109                        iomodel->FetchDataToInput(inputs2,elements,"md.thermal.spctemperature",ThermalSpctemperatureEnum);
     110                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.s0p",SmbS0pEnum);
     111                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.s0t",SmbS0tEnum);
    112112                        if(isd18opd){
    113                                 iomodel->FetchDataToInput(elements,"md.smb.temperatures_presentday",SmbTemperaturesPresentdayEnum);
    114                                 iomodel->FetchDataToInput(elements,"md.smb.precipitations_presentday",SmbPrecipitationsPresentdayEnum);
     113                                iomodel->FetchDataToInput(inputs2,elements,"md.smb.temperatures_presentday",SmbTemperaturesPresentdayEnum);
     114                                iomodel->FetchDataToInput(inputs2,elements,"md.smb.precipitations_presentday",SmbPrecipitationsPresentdayEnum);
    115115                                if(!istemperaturescaled){
    116                                         iomodel->FetchDataToInput(elements,"md.smb.temperatures_reconstructed",SmbTemperaturesReconstructedEnum);
     116                                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.temperatures_reconstructed",SmbTemperaturesReconstructedEnum);
    117117                                }
    118118                                if(!isprecipscaled){
    119                                         iomodel->FetchDataToInput(elements,"md.smb.precipitations_reconstructed",SmbPrecipitationsReconstructedEnum);
     119                                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.precipitations_reconstructed",SmbPrecipitationsReconstructedEnum);
    120120                                }
    121121                        }
    122122                        if(issetpddfac){
    123                                 iomodel->FetchDataToInput(elements,"md.smb.pddfac_snow",SmbPddfacSnowEnum,-1.);
    124                                 iomodel->FetchDataToInput(elements,"md.smb.pddfac_ice",SmbPddfacIceEnum,-1.);
     123                                iomodel->FetchDataToInput(inputs2,elements,"md.smb.pddfac_snow",SmbPddfacSnowEnum,-1.);
     124                                iomodel->FetchDataToInput(inputs2,elements,"md.smb.pddfac_ice",SmbPddfacIceEnum,-1.);
    125125                        }
    126126                        break;
    127127                case SMBgradientsEnum:
    128                         iomodel->FetchDataToInput(elements,"md.smb.href",SmbHrefEnum);
    129                         iomodel->FetchDataToInput(elements,"md.smb.smbref",SmbSmbrefEnum);
    130                         iomodel->FetchDataToInput(elements,"md.smb.b_pos",SmbBPosEnum);
    131                         iomodel->FetchDataToInput(elements,"md.smb.b_neg",SmbBNegEnum);
     128                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.href",SmbHrefEnum);
     129                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.smbref",SmbSmbrefEnum);
     130                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.b_pos",SmbBPosEnum);
     131                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.b_neg",SmbBNegEnum);
    132132                        break;
    133133                case SMBgradientselaEnum:
    134                         iomodel->FetchDataToInput(elements,"md.smb.ela",SmbElaEnum);
    135                         iomodel->FetchDataToInput(elements,"md.smb.b_pos",SmbBPosEnum);
    136                         iomodel->FetchDataToInput(elements,"md.smb.b_neg",SmbBNegEnum);
    137                         iomodel->FetchDataToInput(elements,"md.smb.b_max",SmbBMaxEnum);
    138                         iomodel->FetchDataToInput(elements,"md.smb.b_min",SmbBMinEnum);
     134                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.ela",SmbElaEnum);
     135                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.b_pos",SmbBPosEnum);
     136                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.b_neg",SmbBNegEnum);
     137                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.b_max",SmbBMaxEnum);
     138                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.b_min",SmbBMinEnum);
    139139                        break;
    140140                case SMBhenningEnum:
    141                         iomodel->FetchDataToInput(elements,"md.smb.smbref",SmbSmbrefEnum,0.);
     141                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.smbref",SmbSmbrefEnum,0.);
    142142                        break;
    143143                case SMBcomponentsEnum:
    144                         iomodel->FetchDataToInput(elements,"md.smb.accumulation",SmbAccumulationEnum,0.);
    145                         iomodel->FetchDataToInput(elements,"md.smb.evaporation",SmbEvaporationEnum,0.);
    146                         iomodel->FetchDataToInput(elements,"md.smb.runoff",SmbRunoffEnum,0.);
     144                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.accumulation",SmbAccumulationEnum,0.);
     145                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.evaporation",SmbEvaporationEnum,0.);
     146                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.runoff",SmbRunoffEnum,0.);
    147147                        break;
    148148                case SMBmeltcomponentsEnum:
    149                         iomodel->FetchDataToInput(elements,"md.smb.accumulation",SmbAccumulationEnum,0.);
    150                         iomodel->FetchDataToInput(elements,"md.smb.evaporation",SmbEvaporationEnum,0.);
    151                         iomodel->FetchDataToInput(elements,"md.smb.melt",SmbMeltEnum,0.);
    152                         iomodel->FetchDataToInput(elements,"md.smb.refreeze",SmbRefreezeEnum,0.);
     149                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.accumulation",SmbAccumulationEnum,0.);
     150                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.evaporation",SmbEvaporationEnum,0.);
     151                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.melt",SmbMeltEnum,0.);
     152                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.refreeze",SmbRefreezeEnum,0.);
    153153                        break;
    154154                case SMBgradientscomponentsEnum:
    155                         iomodel->FetchDataToInput(elements,"md.smb.accualti",SmbAccualtiEnum);
    156                         iomodel->FetchDataToInput(elements,"md.smb.accugrad",SmbAccugradEnum);
    157                         iomodel->FetchDataToInput(elements,"md.smb.runoffalti",SmbRunoffaltiEnum);
    158                         iomodel->FetchDataToInput(elements,"md.smb.runoffgrad",SmbRunoffgradEnum);
     155                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.accualti",SmbAccualtiEnum);
     156                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.accugrad",SmbAccugradEnum);
     157                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.runoffalti",SmbRunoffaltiEnum);
     158                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.runoffgrad",SmbRunoffgradEnum);
    159159                        break;
    160160                case SMBsemicEnum:
    161                         iomodel->FetchDataToInput(elements,"md.thermal.spctemperature",ThermalSpctemperatureEnum);
    162                         iomodel->FetchDataToInput(elements,"md.smb.s0gcm",SmbS0gcmEnum);
    163                         iomodel->FetchDataToInput(elements,"md.smb.dailysnowfall",SmbDailysnowfallEnum);
    164                         iomodel->FetchDataToInput(elements,"md.smb.dailyrainfall",SmbDailyrainfallEnum);
    165                         iomodel->FetchDataToInput(elements,"md.smb.dailydsradiation",SmbDailydsradiationEnum);
    166                         iomodel->FetchDataToInput(elements,"md.smb.dailydlradiation",SmbDailydlradiationEnum);
    167                         iomodel->FetchDataToInput(elements,"md.smb.dailywindspeed",SmbDailywindspeedEnum);
    168                         iomodel->FetchDataToInput(elements,"md.smb.dailypressure",SmbDailypressureEnum);
    169                         iomodel->FetchDataToInput(elements,"md.smb.dailyairdensity",SmbDailyairdensityEnum);
    170                         iomodel->FetchDataToInput(elements,"md.smb.dailyairhumidity",SmbDailyairhumidityEnum);
    171                         iomodel->FetchDataToInput(elements,"md.smb.dailytemperature",SmbDailytemperatureEnum);
     161                        iomodel->FetchDataToInput(inputs2,elements,"md.thermal.spctemperature",ThermalSpctemperatureEnum);
     162                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.s0gcm",SmbS0gcmEnum);
     163                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.dailysnowfall",SmbDailysnowfallEnum);
     164                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.dailyrainfall",SmbDailyrainfallEnum);
     165                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.dailydsradiation",SmbDailydsradiationEnum);
     166                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.dailydlradiation",SmbDailydlradiationEnum);
     167                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.dailywindspeed",SmbDailywindspeedEnum);
     168                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.dailypressure",SmbDailypressureEnum);
     169                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.dailyairdensity",SmbDailyairdensityEnum);
     170                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.dailyairhumidity",SmbDailyairhumidityEnum);
     171                        iomodel->FetchDataToInput(inputs2,elements,"md.smb.dailytemperature",SmbDailytemperatureEnum);
    172172                        break;
    173173                default:

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

    r23585 r24335  
    1717                void CreateNodes(Nodes* nodes,IoModel* iomodel,bool isamr=false);
    1818                int  DofsPerNode(int** doflist,int domaintype,int approximation);
    19                 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
     19                void UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type);
    2020                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    2121

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

    r23644 r24335  
    1818        return 1;
    1919}/*}}}*/
    20 void SmoothAnalysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
     20void SmoothAnalysis::UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
    2121
    2222        /*Update elements: */
    … …  
    2525                if(iomodel->my_elements[i]){
    2626                        Element* element=(Element*)elements->GetObjectByOffset(counter);
    27                         element->Update(i,iomodel,analysis_counter,analysis_type,P1Enum);
     27                        element->Update(inputs2,i,iomodel,analysis_counter,analysis_type,P1Enum);
    2828                        counter++;
    2929                }
    … …  
    7070        element->FindParam(&l,SmoothThicknessMultiplierEnum); _assert_(l>0.);
    7171        element->GetVerticesCoordinates(&xyz_list);
    72         Input* thickness_input = element->GetInput(ThicknessEnum); _assert_(thickness_input);
     72        Input2* thickness_input = element->GetInput2(ThicknessEnum); _assert_(thickness_input);
    7373
    7474        /* Start looping on the number of gaussian points: */
    … …  
    116116        IssmDouble  Jdet,value;
    117117        IssmDouble *xyz_list  = NULL;
    118         Input      *input = NULL;
     118        Input2     *input = NULL;
    119119
    120120        /*SPECIFICS: Driving stress for balance velocities*/
    121         Input*      H_input = NULL, *surface_input = NULL, *vx_input = NULL, *vy_input = NULL;
     121        Input2*      H_input = NULL, *surface_input = NULL, *vx_input = NULL, *vy_input = NULL;
    122122        IssmDouble  taud_x,norms,normv,vx,vy;
    123123        IssmDouble  rho_ice,gravity,slope[2],thickness;
    … …  
    139139                        rho_ice       = element->FindParam(MaterialsRhoIceEnum);
    140140                        gravity       = element->FindParam(ConstantsGEnum);
    141                         H_input       = element->GetInput(ThicknessEnum); _assert_(H_input);
    142                         surface_input = element->GetInput(SurfaceEnum);   _assert_(surface_input);
    143                         vx_input      = element->GetInput(VxEnum);
    144                         vy_input      = element->GetInput(VyEnum);
     141                        H_input       = element->GetInput2(ThicknessEnum); _assert_(H_input);
     142                        surface_input = element->GetInput2(SurfaceEnum);   _assert_(surface_input);
     143                        vx_input      = element->GetInput2(VxEnum);
     144                        vy_input      = element->GetInput2(VyEnum);
    145145                        }
    146146                        break;
    147147                case SurfaceSlopeXEnum:
    148148                case SurfaceSlopeYEnum:{
    149                         surface_input = element->GetInput(SurfaceEnum);   _assert_(surface_input);
    150                         }
    151                         break;
    152                 default: input = element->GetInput(input_enum);
     149                        surface_input = element->GetInput2(SurfaceEnum);   _assert_(surface_input);
     150                        }
     151                        break;
     152                default: input = element->GetInput2(input_enum);
    153153        }
    154154

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

    r23585 r24335  
    1717                void CreateNodes(Nodes* nodes,IoModel* iomodel,bool isamr=false);
    1818                int  DofsPerNode(int** doflist,int domaintype,int approximation);
    19                 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
     19                void UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type);
    2020                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    2121

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

    r24221 r24335  
    659659        return numdofs;
    660660}/*}}}*/
    661 void StressbalanceAnalysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
     661void StressbalanceAnalysis::UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
    662662
    663663        /*Intermediaries*/
    … …  
    730730                if(iomodel->my_elements[i]){
    731731                        Element* element=(Element*)elements->GetObjectByOffset(counter);
    732                         element->Update(i,iomodel,analysis_counter,analysis_type,finiteelement_list[i]);
     732                        element->Update(inputs2,i,iomodel,analysis_counter,analysis_type,finiteelement_list[i]);
     733
     734                        /*Need to know the type of approximation for this element*/
     735                        if(iomodel->Data("md.flowequation.element_equation")){
     736                                inputs2->SetInput(ApproximationEnum,counter,IoCodeToEnumElementEquation(reCast<int>(iomodel->Data("md.flowequation.element_equation")[i])));
     737                        }
     738
    733739                        counter++;
    734740                }
    … …  
    736742
    737743        /*Create inputs: */
    738         iomodel->FetchDataToInput(elements,"md.geometry.thickness",ThicknessEnum);
    739         iomodel->FetchDataToInput(elements,"md.geometry.surface",SurfaceEnum);
    740         iomodel->FetchDataToInput(elements,"md.geometry.base",BaseEnum);
    741         iomodel->FetchDataToInput(elements,"md.slr.sealevel",SealevelEnum,0);
    742         iomodel->FetchDataToInput(elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
    743         iomodel->FetchDataToInput(elements,"md.mask.groundedice_levelset",MaskGroundediceLevelsetEnum);
    744         iomodel->FetchDataToInput(elements,"md.initialization.vx",VxEnum,0.);
    745         iomodel->FetchDataToInput(elements,"md.initialization.vy",VyEnum,0.);
    746         iomodel->FetchDataToInput(elements,"md.stressbalance.loadingforcex",LoadingforceXEnum);
    747         iomodel->FetchDataToInput(elements,"md.stressbalance.loadingforcey",LoadingforceYEnum);
     744        iomodel->FetchDataToInput(inputs2,elements,"md.geometry.thickness",ThicknessEnum);
     745        iomodel->FetchDataToInput(inputs2,elements,"md.geometry.surface",SurfaceEnum);
     746        iomodel->FetchDataToInput(inputs2,elements,"md.geometry.base",BaseEnum);
     747        iomodel->FetchDataToInput(inputs2,elements,"md.slr.sealevel",SealevelEnum,0);
     748        iomodel->FetchDataToInput(inputs2,elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
     749        iomodel->FetchDataToInput(inputs2,elements,"md.mask.groundedice_levelset",MaskGroundediceLevelsetEnum);
     750        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.vx",VxEnum,0.);
     751        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.vy",VyEnum,0.);
     752        iomodel->FetchDataToInput(inputs2,elements,"md.stressbalance.loadingforcex",LoadingforceXEnum);
     753        iomodel->FetchDataToInput(inputs2,elements,"md.stressbalance.loadingforcey",LoadingforceYEnum);
    748754        #ifdef LATERALFRICTION
    749         iomodel->FetchDataToInput(elements,"md.mesh.vertexonboundary",MeshVertexonboundaryEnum);
     755        iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonboundary",MeshVertexonboundaryEnum);
    750756        #endif
    751757
    752758        if(iomodel->domaintype!=Domain2DhorizontalEnum){
    753                 iomodel->FetchDataToInput(elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum);
    754                 iomodel->FetchDataToInput(elements,"md.mesh.vertexonsurface",MeshVertexonsurfaceEnum);
     759                iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum);
     760                iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonsurface",MeshVertexonsurfaceEnum);
    755761        }
    756762        if(iomodel->domaintype==Domain3DEnum){
    757                 iomodel->FetchDataToInput(elements,"md.flowequation.borderFS",FlowequationBorderFSEnum);
    758                 iomodel->FetchDataToInput(elements,"md.stressbalance.loadingforcez",LoadingforceZEnum);
    759                 iomodel->FetchDataToInput(elements,"md.initialization.vz",VzEnum,0.);
     763                iomodel->FetchDataToInput(inputs2,elements,"md.flowequation.borderFS",FlowequationBorderFSEnum);
     764                iomodel->FetchDataToInput(inputs2,elements,"md.stressbalance.loadingforcez",LoadingforceZEnum);
     765                iomodel->FetchDataToInput(inputs2,elements,"md.initialization.vz",VzEnum,0.);
    760766        }
    761767        if(isFS){
    762                 iomodel->FetchDataToInput(elements,"md.initialization.pressure",PressureEnum,0.);
     768                iomodel->FetchDataToInput(inputs2,elements,"md.initialization.pressure",PressureEnum,0.);
    763769
    764770                /*Add basal forcings to compute melt rate*/
    … …  
    767773                switch(basalforcing_model){
    768774                        case FloatingMeltRateEnum:
    769                                 iomodel->FetchDataToInput(elements,"md.basalforcings.floatingice_melting_rate",BasalforcingsFloatingiceMeltingRateEnum);
     775                                iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.floatingice_melting_rate",BasalforcingsFloatingiceMeltingRateEnum);
    770776                                break;
    771777                        case LinearFloatingMeltRateEnum:
    … …  
    776782                                break;
    777783                        case SpatialLinearFloatingMeltRateEnum:
    778                                 iomodel->FetchDataToInput(elements,"md.basalforcings.deepwater_melting_rate",BasalforcingsDeepwaterMeltingRateEnum);
    779                                 iomodel->FetchDataToInput(elements,"md.basalforcings.deepwater_elevation",BasalforcingsDeepwaterElevationEnum);
    780                                 iomodel->FetchDataToInput(elements,"md.basalforcings.upperwater_elevation",BasalforcingsUpperwaterElevationEnum);
     784                                iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.deepwater_melting_rate",BasalforcingsDeepwaterMeltingRateEnum);
     785                                iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.deepwater_elevation",BasalforcingsDeepwaterElevationEnum);
     786                                iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.upperwater_elevation",BasalforcingsUpperwaterElevationEnum);
    781787                                break;
    782788                        case BasalforcingsPicoEnum:
    783                                 iomodel->FetchDataToInput(elements,"md.basalforcings.basin_id",BasalforcingsPicoBasinIdEnum);
     789                                iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.basin_id",BasalforcingsPicoBasinIdEnum);
    784790                                break;
    785791                        case BasalforcingsIsmip6Enum:
    786                                 iomodel->FetchDataToInput(elements,"md.basalforcings.basin_id",BasalforcingsIsmip6BasinIdEnum);
     792                                iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.basin_id",BasalforcingsIsmip6BasinIdEnum);
    787793                                break;
    788794                        case BeckmannGoosseFloatingMeltRateEnum:
    789                                 iomodel->FetchDataToInput(elements,"md.basalforcings.ocean_salinity",BasalforcingsOceanSalinityEnum);
    790                                 iomodel->FetchDataToInput(elements,"md.basalforcings.ocean_temp",BasalforcingsOceanTempEnum);
     795                                iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.ocean_salinity",BasalforcingsOceanSalinityEnum);
     796                                iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.ocean_temp",BasalforcingsOceanTempEnum);
    791797                                break;
    792798                        default:
    … …  
    797803        iomodel->FindConstant(&fe_FS,"md.flowequation.fe_FS");
    798804        if(fe_FS==LATaylorHoodEnum || fe_FS==LACrouzeixRaviartEnum){
    799                 InputUpdateFromConstantx(elements,0.,SigmaNNEnum);
     805                InputUpdateFromConstantx(inputs2,elements,0.,SigmaNNEnum);
    800806        }
    801807
    … …  
    804810                case 1:
    805811                        iomodel->FindConstant(&FrictionCoupling,"md.friction.coupling");
    806                         iomodel->FetchDataToInput(elements,"md.friction.coefficient",FrictionCoefficientEnum);
    807                         iomodel->FetchDataToInput(elements,"md.friction.p",FrictionPEnum);
    808                         iomodel->FetchDataToInput(elements,"md.friction.q",FrictionQEnum);
     812                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.coefficient",FrictionCoefficientEnum);
     813                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.p",FrictionPEnum);
     814                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.q",FrictionQEnum);
    809815                        if(FrictionCoupling==3){
    810                                 iomodel->FetchDataToInput(elements,"md.friction.effective_pressure",FrictionEffectivePressureEnum);}
     816                                iomodel->FetchDataToInput(inputs2,elements,"md.friction.effective_pressure",FrictionEffectivePressureEnum);}
    811817                        else if(FrictionCoupling==4){
    812                                 iomodel->FetchDataToInput(elements,"md.friction.effective_pressure",EffectivePressureEnum);
     818                                iomodel->FetchDataToInput(inputs2,elements,"md.friction.effective_pressure",EffectivePressureEnum);
    813819                        }
    814820                        break;
    815821                case 2:
    816                         iomodel->FetchDataToInput(elements,"md.friction.C",FrictionCEnum);
    817                         iomodel->FetchDataToInput(elements,"md.friction.m",FrictionMEnum);
     822                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.C",FrictionCEnum);
     823                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.m",FrictionMEnum);
    818824                        break;
    819825                case 3:
    820826                        iomodel->FindConstant(&FrictionCoupling,"md.friction.coupling");
    821                         iomodel->FetchDataToInput(elements,"md.friction.C",FrictionCEnum);
    822                         iomodel->FetchDataToInput(elements,"md.friction.As",FrictionAsEnum);
    823                         iomodel->FetchDataToInput(elements,"md.friction.q",FrictionQEnum);
     827                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.C",FrictionCEnum);
     828                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.As",FrictionAsEnum);
     829                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.q",FrictionQEnum);
    824830                        if(FrictionCoupling==3){
    825                                 iomodel->FetchDataToInput(elements,"md.friction.effective_pressure",FrictionEffectivePressureEnum);}
     831                                iomodel->FetchDataToInput(inputs2,elements,"md.friction.effective_pressure",FrictionEffectivePressureEnum);}
    826832                        else if(FrictionCoupling==4){
    827                                 iomodel->FetchDataToInput(elements,"md.friction.effective_pressure",EffectivePressureEnum);
     833                                iomodel->FetchDataToInput(inputs2,elements,"md.friction.effective_pressure",EffectivePressureEnum);
    828834                        }
    829835                        break;
    830836                case 4:
    831                         iomodel->FetchDataToInput(elements,"md.friction.coefficient",FrictionCoefficientEnum);
    832                         iomodel->FetchDataToInput(elements,"md.friction.p",FrictionPEnum);
    833                         iomodel->FetchDataToInput(elements,"md.friction.q",FrictionQEnum);
    834                         iomodel->FetchDataToInput(elements,"md.initialization.pressure",PressureEnum);
    835                         iomodel->FetchDataToInput(elements,"md.initialization.temperature",TemperatureEnum);
     837                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.coefficient",FrictionCoefficientEnum);
     838                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.p",FrictionPEnum);
     839                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.q",FrictionQEnum);
     840                        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.pressure",PressureEnum);
     841                        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.temperature",TemperatureEnum);
    836842                        iomodel->FindConstant(&FrictionCoupling,"md.friction.coupling");
    837843                        break;
    838844                case 5:
    839                         iomodel->FetchDataToInput(elements,"md.friction.coefficient",FrictionCoefficientEnum);
    840                         iomodel->FetchDataToInput(elements,"md.friction.p",FrictionPEnum);
    841                         iomodel->FetchDataToInput(elements,"md.friction.q",FrictionQEnum);
    842                         iomodel->FetchDataToInput(elements,"md.friction.water_layer",FrictionWaterLayerEnum);
     845                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.coefficient",FrictionCoefficientEnum);
     846                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.p",FrictionPEnum);
     847                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.q",FrictionQEnum);
     848                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.water_layer",FrictionWaterLayerEnum);
    843849                        break;
    844850                case 6:
    845                         iomodel->FetchDataToInput(elements,"md.friction.C",FrictionCEnum);
    846                         iomodel->FetchDataToInput(elements,"md.friction.m",FrictionMEnum);
    847                         iomodel->FetchDataToInput(elements,"md.initialization.pressure",PressureEnum);
    848                         iomodel->FetchDataToInput(elements,"md.initialization.temperature",TemperatureEnum);
     851                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.C",FrictionCEnum);
     852                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.m",FrictionMEnum);
     853                        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.pressure",PressureEnum);
     854                        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.temperature",TemperatureEnum);
    849855                        break;
    850856                case 7:
    851857                        iomodel->FindConstant(&FrictionCoupling,"md.friction.coupling");
    852                         iomodel->FetchDataToInput(elements,"md.friction.coefficient",FrictionCoefficientEnum);
    853                         iomodel->FetchDataToInput(elements,"md.friction.coefficientcoulomb",FrictionCoefficientcoulombEnum);
    854                         iomodel->FetchDataToInput(elements,"md.friction.p",FrictionPEnum);
    855                         iomodel->FetchDataToInput(elements,"md.friction.q",FrictionQEnum);
     858                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.coefficient",FrictionCoefficientEnum);
     859                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.coefficientcoulomb",FrictionCoefficientcoulombEnum);
     860                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.p",FrictionPEnum);
     861                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.q",FrictionQEnum);
    856862                        if(FrictionCoupling==3){
    857                                 iomodel->FetchDataToInput(elements,"md.friction.effective_pressure",FrictionEffectivePressureEnum);}
     863                                iomodel->FetchDataToInput(inputs2,elements,"md.friction.effective_pressure",FrictionEffectivePressureEnum);}
    858864                        else if(FrictionCoupling==4){
    859                                 iomodel->FetchDataToInput(elements,"md.friction.effective_pressure",EffectivePressureEnum);
     865                                iomodel->FetchDataToInput(inputs2,elements,"md.friction.effective_pressure",EffectivePressureEnum);
    860866
    861867                        }
    862868                        break;
    863869                case 9:
    864                         iomodel->FetchDataToInput(elements,"md.initialization.temperature",TemperatureEnum);
    865                         iomodel->FetchDataToInput(elements,"md.friction.coefficient",FrictionCoefficientEnum);
    866                         iomodel->FetchDataToInput(elements,"md.friction.pressure_adjusted_temperature",FrictionPressureAdjustedTemperatureEnum);
    867                         InputUpdateFromConstantx(elements,1.,FrictionPEnum);
    868                         InputUpdateFromConstantx(elements,1.,FrictionQEnum);
     870                        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.temperature",TemperatureEnum);
     871                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.coefficient",FrictionCoefficientEnum);
     872                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.pressure_adjusted_temperature",FrictionPressureAdjustedTemperatureEnum);
     873                        InputUpdateFromConstantx(inputs2,elements,1.,FrictionPEnum);
     874                        InputUpdateFromConstantx(inputs2,elements,1.,FrictionQEnum);
    869875                        break;
    870876                case 10:
    871                         iomodel->FetchDataToInput(elements,"md.friction.till_friction_angle",FrictionTillFrictionAngleEnum);
    872                         iomodel->FetchDataToInput(elements,"md.friction.sediment_compressibility_coefficient",FrictionSedimentCompressibilityCoefficientEnum);
    873                         iomodel->FetchDataToInput(elements,"md.hydrology.watercolumn_max",HydrologyWatercolumnMaxEnum);
    874                         iomodel->FetchDataToInput(elements,"md.initialization.watercolumn",WatercolumnEnum,0.);
     877                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.till_friction_angle",FrictionTillFrictionAngleEnum);
     878                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.sediment_compressibility_coefficient",FrictionSedimentCompressibilityCoefficientEnum);
     879                        iomodel->FetchDataToInput(inputs2,elements,"md.hydrology.watercolumn_max",HydrologyWatercolumnMaxEnum);
     880                        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.watercolumn",WatercolumnEnum,0.);
    875881                        break;
    876882                case 11:
    877                         iomodel->FetchDataToInput(elements,"md.friction.m",FrictionMEnum);
    878                         iomodel->FetchDataToInput(elements,"md.friction.C",FrictionCEnum);
    879                         iomodel->FetchDataToInput(elements,"md.friction.Cmax",FrictionCmaxEnum);
     883                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.m",FrictionMEnum);
     884                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.C",FrictionCEnum);
     885                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.Cmax",FrictionCmaxEnum);
    880886                        break;
    881887                case 12:
    882                         iomodel->FetchDataToInput(elements,"md.friction.m",FrictionMEnum);
    883                         iomodel->FetchDataToInput(elements,"md.friction.C",FrictionCEnum);
    884                         iomodel->FetchDataToInput(elements,"md.friction.f",FrictionfEnum);
     888                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.m",FrictionMEnum);
     889                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.C",FrictionCEnum);
     890                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.f",FrictionfEnum);
    885891                        break;
    886892                default:
    … …  
    889895
    890896#ifdef _HAVE_ANDROID_
    891         elements->InputDuplicate(FrictionCoefficientEnum,AndroidFrictionCoefficientEnum);
     897        inputs2->DuplicateInput(FrictionCoefficientEnum,AndroidFrictionCoefficientEnum);
    892898#endif
    893899
    … …  
    10591065
    10601066        int approximation;
    1061         element->GetInputValue(&approximation,ApproximationEnum);
     1067        element->GetInput2Value(&approximation,ApproximationEnum);
    10621068        switch(approximation){
    10631069                case FSApproximationEnum:
    … …  
    10721078
    10731079        int approximation;
    1074         element->GetInputValue(&approximation,ApproximationEnum);
     1080        element->GetInput2Value(&approximation,ApproximationEnum);
    10751081        switch(approximation){
    10761082                case SSAApproximationEnum:
    … …  
    10881094ElementMatrix* StressbalanceAnalysis::CreateKMatrix(Element* element){/*{{{*/
    10891095        int approximation;
    1090         element->GetInputValue(&approximation,ApproximationEnum);
     1096        element->GetInput2Value(&approximation,ApproximationEnum);
    10911097        switch(approximation){
    10921098                case SIAApproximationEnum:
    … …  
    11151121
    11161122        int approximation;
    1117         element->GetInputValue(&approximation,ApproximationEnum);
     1123        element->GetInput2Value(&approximation,ApproximationEnum);
    11181124        switch(approximation){
    11191125                case SIAApproximationEnum:
    … …  
    11421148
    11431149        int approximation;
    1144         element->GetInputValue(&approximation,ApproximationEnum);
     1150        element->GetInput2Value(&approximation,ApproximationEnum);
    11451151        switch(approximation){
    11461152                case FSApproximationEnum: case NoneApproximationEnum:
    … …  
    11781184        int numnodes = element->GetNumberOfNodes();
    11791185        int numdof   = numnodes*dofpernode;
    1180         element->GetInputValue(&approximation,ApproximationEnum);
     1186        element->GetInput2Value(&approximation,ApproximationEnum);
    11811187
    11821188        /*Fetch dof list and allocate solution vector*/
    … …  
    11851191
    11861192        /*Get inputs*/
    1187         Input* vx_input=element->GetInput(VxEnum); _assert_(vx_input);
    1188         Input* vy_input=NULL;
    1189         if(domaintype!=Domain2DverticalEnum){vy_input=element->GetInput(VyEnum); _assert_(vy_input);}
     1193        Input2* vx_input=element->GetInput2(VxEnum); _assert_(vx_input);
     1194        Input2* vy_input=NULL;
     1195        if(domaintype!=Domain2DverticalEnum){vy_input=element->GetInput2(VyEnum); _assert_(vy_input);}
    11901196
    11911197        /*Ok, we have vx and vy in values, fill in vx and vy arrays: */
    … …  
    12161222
    12171223        int approximation;
    1218         element->GetInputValue(&approximation,ApproximationEnum);
     1224        element->GetInput2Value(&approximation,ApproximationEnum);
    12191225        switch(approximation){
    12201226                case FSApproximationEnum: case NoneApproximationEnum:
    … …  
    12871293        /*Retrieve all inputs and parameters*/
    12881294        element->GetVerticesCoordinates(&xyz_list);
    1289         Input* thickness_input = basalelement->GetInput(ThicknessEnum);_assert_(thickness_input);
    1290         Input* vx_input        = basalelement->GetInput(VxEnum);       _assert_(vx_input);
    1291         Input* vy_input        = basalelement->GetInput(VyEnum);       _assert_(vy_input);
     1295        Input2* thickness_input = basalelement->GetInput2(ThicknessEnum);_assert_(thickness_input);
     1296        Input2* vx_input        = basalelement->GetInput2(VxEnum);       _assert_(vx_input);
     1297        Input2* vy_input        = basalelement->GetInput2(VyEnum);       _assert_(vy_input);
    12921298
    12931299        /* Start  looping on the number of gaussian points: */
    … …  
    14061412        element->GetVerticesCoordinates(&xyz_list);
    14071413        element->FindParam(&friction_style,GroundinglineFrictionInterpolationEnum);
    1408         Input* surface_input    = element->GetInput(SurfaceEnum); _assert_(surface_input);
    1409         Input* gllevelset_input = NULL;
     1414        Input2* surface_input    = element->GetInput2(SurfaceEnum); _assert_(surface_input);
     1415        Input2* gllevelset_input = NULL;
    14101416
    14111417        /*build friction object, used later on: */
    … …  
    14151421        if(!(friction_style==SubelementFriction2Enum)) phi=element->GetGroundedPortion(xyz_list);
    14161422        if(friction_style==SubelementFriction2Enum){
    1417                 gllevelset_input=element->GetInput(MaskGroundediceLevelsetEnum); _assert_(gllevelset_input);
     1423                gllevelset_input=element->GetInput2(MaskGroundediceLevelsetEnum); _assert_(gllevelset_input);
    14181424                element->GetGroundedPart(&point1,&fraction1,&fraction2,&mainlyfloating);
    14191425           gauss = element->NewGauss(point1,fraction1,fraction2,mainlyfloating,2);
    … …  
    15011507        element->GetVerticesCoordinates(&xyz_list);
    15021508        element->GetLevelCoordinates(&xyz_list_boundary,xyz_list,MeshVertexonboundaryEnum,1.);
    1503         Input* icelevelset_input = element->GetInput(MaskIceLevelsetEnum); _assert_(icelevelset_input);
     1509        Input2* icelevelset_input = element->GetInput2(MaskIceLevelsetEnum); _assert_(icelevelset_input);
    15041510
    15051511        /* Start  looping on the number of gaussian points: */
    … …  
    15631569        /*Retrieve all inputs and parameters*/
    15641570        element->GetVerticesCoordinates(&xyz_list);
    1565         Input* thickness_input=element->GetInput(ThicknessEnum); _assert_(thickness_input);
    1566         Input* vx_input=element->GetInput(VxEnum);               _assert_(vx_input);
    1567         Input* vy_input    = NULL;
     1571        Input2* thickness_input=element->GetInput2(ThicknessEnum); _assert_(thickness_input);
     1572        Input2* vx_input=element->GetInput2(VxEnum);               _assert_(vx_input);
     1573        Input2* vy_input    = NULL;
    15681574        if(dim==2){
    1569                 vy_input    = element->GetInput(VyEnum);       _assert_(vy_input);
     1575                vy_input    = element->GetInput2(VyEnum);       _assert_(vy_input);
    15701576        }
    15711577
    … …  
    16801686        /*Retrieve all inputs and parameters*/
    16811687        element->GetVerticesCoordinates(&xyz_list);
    1682         Input*     thickness_input=element->GetInput(ThicknessEnum); _assert_(thickness_input);
    1683         Input*     surface_input  =element->GetInput(SurfaceEnum);   _assert_(surface_input);
     1688        Input2*     thickness_input=element->GetInput2(ThicknessEnum); _assert_(thickness_input);
     1689        Input2*     surface_input  =element->GetInput2(SurfaceEnum);   _assert_(surface_input);
    16841690        IssmDouble rhog = element->FindParam(MaterialsRhoIceEnum)*element->FindParam(ConstantsGEnum);
    16851691
    … …  
    17441750
    17451751        /*Retrieve all inputs and parameters*/
    1746         Input* thickness_input = element->GetInput(ThicknessEnum); _assert_(thickness_input);
    1747         Input* base_input       = element->GetInput(BaseEnum);       _assert_(base_input);
    1748         Input* sealevel_input       = element->GetInput(SealevelEnum);       _assert_(sealevel_input);
     1752        Input2* thickness_input = element->GetInput2(ThicknessEnum); _assert_(thickness_input);
     1753        Input2* base_input       = element->GetInput2(BaseEnum);       _assert_(base_input);
     1754        Input2* sealevel_input       = element->GetInput2(SealevelEnum);       _assert_(sealevel_input);
    17491755        IssmDouble rho_water   = element->FindParam(MaterialsRhoSeawaterEnum);
    17501756        IssmDouble rho_ice     = element->FindParam(MaterialsRhoIceEnum);
    … …  
    19411947                default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
    19421948        }
    1943         element->AddInput(PressureEnum,pressure,P1Enum);
     1949        element->AddInput2(PressureEnum,pressure,P1Enum);
    19441950        xDelete<IssmDouble>(pressure);
    19451951        xDelete<IssmDouble>(thickness);
    … …  
    19641970        /*Fetch dof list and allocate solution vectors*/
    19651971        basalelement->GetDofListLocal(&doflist,SSAApproximationEnum,GsetEnum);
    1966         IssmDouble* values    = xNew<IssmDouble>(numdof);
    1967         IssmDouble* vx        = xNew<IssmDouble>(numnodes);
    1968         IssmDouble* vy        = xNew<IssmDouble>(numnodes);
    1969         IssmDouble* vz        = xNew<IssmDouble>(numnodes);
    1970         IssmDouble* vel       = xNew<IssmDouble>(numnodes);
     1972        IssmDouble* values = xNew<IssmDouble>(numdof);
     1973        IssmDouble* vx     = xNew<IssmDouble>(numnodes);
     1974        IssmDouble* vy     = xNew<IssmDouble>(numnodes);
     1975        IssmDouble* vz     = xNew<IssmDouble>(numnodes);
     1976        IssmDouble* vel    = xNew<IssmDouble>(numnodes);
    19711977
    19721978        /*Use the dof list to index into the solution vector: */
    … …  
    20002006
    20012007        /*Add vx and vy as inputs to the tria element: */
    2002         element->AddBasalInput(VxEnum,vx,element->GetElementType());
    2003         if(dim==2)element->AddBasalInput(VyEnum,vy,element->GetElementType());
    2004         element->AddBasalInput(VelEnum,vel,element->GetElementType());
     2008        element->AddBasalInput2(VxEnum,vx,element->GetElementType());
     2009        if(dim==2)element->AddBasalInput2(VyEnum,vy,element->GetElementType());
     2010        element->AddBasalInput2(VelEnum,vel,element->GetElementType());
    20052011
    20062012        /*Free ressources:*/
    … …  
    20622068        /*Retrieve all inputs and parameters*/
    20632069        element->GetVerticesCoordinates(&xyz_list);
    2064         Input* surface_input = element->GetInput(SurfaceEnum); _assert_(surface_input);
    2065         Input* vx_input      = element->GetInput(VxEnum);      _assert_(vx_input);
    2066         Input* vy_input      = element->GetInput(VyEnum);      _assert_(vy_input);
     2070        Input2* surface_input = element->GetInput2(SurfaceEnum); _assert_(surface_input);
     2071        Input2* vx_input      = element->GetInput2(VxEnum);      _assert_(vx_input);
     2072        Input2* vy_input      = element->GetInput2(VyEnum);      _assert_(vy_input);
    20672073
    20682074        /* Start  looping on the number of gaussian points: */
    … …  
    21492155        /*Retrieve all inputs and parameters*/
    21502156        element->GetVerticesCoordinates(&xyz_list);
    2151         Input*     thickness_input=element->GetInput(ThicknessEnum); _assert_(thickness_input);
    2152         Input*     surface_input  =element->GetInput(SurfaceEnum);   _assert_(surface_input);
     2157        Input2*     thickness_input=element->GetInput2(ThicknessEnum); _assert_(thickness_input);
     2158        Input2*     surface_input  =element->GetInput2(SurfaceEnum);   _assert_(surface_input);
    21532159        IssmDouble rhog = element->FindParam(MaterialsRhoIceEnum)*element->FindParam(ConstantsGEnum);
    21542160
    … …  
    22002206
    22012207        /*Retrieve all inputs and parameters*/
    2202         Input* thickness_input = element->GetInput(ThicknessEnum); _assert_(thickness_input);
    2203         Input* base_input       = element->GetInput(BaseEnum);       _assert_(base_input);
    2204         Input* sealevel_input       = element->GetInput(SealevelEnum);       _assert_(sealevel_input);
     2208        Input2* thickness_input = element->GetInput2(ThicknessEnum); _assert_(thickness_input);
     2209        Input2* base_input       = element->GetInput2(BaseEnum);       _assert_(base_input);
     2210        Input2* sealevel_input       = element->GetInput2(SealevelEnum);       _assert_(sealevel_input);
    22052211        IssmDouble rho_water   = element->FindParam(MaterialsRhoSeawaterEnum);
    22062212        IssmDouble rho_ice     = element->FindParam(MaterialsRhoIceEnum);
    … …  
    22702276                for(i=0;i<numvertices;i++) pressure[i]=rho_ice*g*(surface[i]-xyz_list[i*3+2]);
    22712277        }
    2272         element->AddInput(PressureEnum,pressure,P1Enum);
     2278        element->AddInput2(PressureEnum,pressure,P1Enum);
    22732279        xDelete<IssmDouble>(pressure);
    22742280        xDelete<IssmDouble>(thickness);
    … …  
    23232329
    23242330        /*Add vx and vy as inputs to the tria element: */
    2325         element->AddBasalInput(VxEnum,vx,element->GetElementType());
    2326         element->AddBasalInput(VyEnum,vy,element->GetElementType());
    2327         element->AddBasalInput(VelEnum,vel,element->GetElementType());
     2331        element->AddBasalInput2(VxEnum,vx,element->GetElementType());
     2332        element->AddBasalInput2(VyEnum,vy,element->GetElementType());
     2333        element->AddBasalInput2(VelEnum,vel,element->GetElementType());
    23282334
    23292335        /*Free ressources:*/
    … …  
    23592365        /*Retrieve all inputs and parameters*/
    23602366        element->GetVerticesCoordinates(&xyz_list);
    2361         Input* vx_input = element->GetInput(VxEnum); _assert_(vx_input);
    2362         Input* vy_input = element->GetInput(VyEnum); _assert_(vy_input);
     2367        Input2* vx_input = element->GetInput2(VxEnum); _assert_(vx_input);
     2368        Input2* vy_input = element->GetInput2(VyEnum); _assert_(vy_input);
    23632369
    23642370        /* Start  looping on the number of gaussian points: */
    … …  
    24452451        element->GetVerticesCoordinatesBase(&xyz_list_base);
    24462452        element->FindParam(&friction_style,GroundinglineFrictionInterpolationEnum);
    2447         Input* gllevelset_input = NULL;
     2453        Input2* gllevelset_input = NULL;
    24482454
    24492455        /*build friction object, used later on: */
    … …  
    24532459        if(!(friction_style==SubelementFriction2Enum)) phi=element->GetGroundedPortion(xyz_list_base);
    24542460        if(friction_style==SubelementFriction2Enum){
    2455                 gllevelset_input=element->GetInput(MaskGroundediceLevelsetEnum); _assert_(gllevelset_input);
     2461                gllevelset_input=element->GetInput2(MaskGroundediceLevelsetEnum); _assert_(gllevelset_input);
    24562462                element->GetGroundedPart(&point1,&fraction1,&fraction2,&mainlyfloating);
    24572463                gauss = element->NewGauss(point1,fraction1,fraction2,mainlyfloating,2);
    … …  
    25132519        /*Intermediaries*/
    25142520        int         dim,bsize;
    2515         IssmDouble  viscosity,thickness,Jdet;
     2521        IssmDouble  viscosity,Jdet;
    25162522        IssmDouble *xyz_list = NULL;
    25172523
    … …  
    25292535        /*Retrieve all inputs and parameters*/
    25302536        element->GetVerticesCoordinates(&xyz_list);
    2531         Input* vx_input    = element->GetInput(VxEnum);       _assert_(vx_input);
    2532         Input* vy_input    = NULL;
     2537        Input2* vx_input    = element->GetInput2(VxEnum);       _assert_(vx_input);
     2538        Input2* vy_input    = NULL;
    25332539        if(dim==3){
    2534                 vy_input=element->GetInput(VyEnum);          _assert_(vy_input);
     2540                vy_input=element->GetInput2(VyEnum);          _assert_(vy_input);
    25352541        }
    25362542
    … …  
    26772683        /*Retrieve all inputs and parameters*/
    26782684        element->GetVerticesCoordinates(&xyz_list);
    2679         Input*     surface_input = element->GetInput(SurfaceEnum);   _assert_(surface_input);
     2685        Input2*     surface_input = element->GetInput2(SurfaceEnum);   _assert_(surface_input);
    26802686        IssmDouble rhog = element->FindParam(MaterialsRhoIceEnum)*element->FindParam(ConstantsGEnum);
    26812687
    … …  
    27332739
    27342740        /*Retrieve all inputs and parameters*/
    2735         Input* surface_input = element->GetInput(SurfaceEnum); _assert_(surface_input);
    2736         Input* sealevel_input       = element->GetInput(SealevelEnum);       _assert_(sealevel_input);
     2741        Input2* surface_input = element->GetInput2(SurfaceEnum); _assert_(surface_input);
     2742        Input2* sealevel_input       = element->GetInput2(SealevelEnum);       _assert_(sealevel_input);
    27372743        IssmDouble rho_water = element->FindParam(MaterialsRhoSeawaterEnum);
    27382744        IssmDouble rho_ice   = element->FindParam(MaterialsRhoIceEnum);
    … …  
    29382944                default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
    29392945        }
    2940         element->AddInput(PressureEnum,pressure,P1Enum);
     2946        element->AddInput2(PressureEnum,pressure,P1Enum);
    29412947        xDelete<IssmDouble>(pressure);
    29422948        xDelete<IssmDouble>(surface);
    … …  
    29832989
    29842990        /*Add vx and vy as inputs to the element: */
    2985         element->AddInput(VxEnum,vx,element->GetElementType());
    2986         if(dim==3)element->AddInput(VyEnum,vy,element->GetElementType());
    2987         element->AddInput(VelEnum,vel,element->GetElementType());
     2991        element->AddInput2(VxEnum,vx,element->GetElementType());
     2992        if(dim==3)element->AddInput2(VyEnum,vy,element->GetElementType());
     2993        element->AddInput2(VelEnum,vel,element->GetElementType());
    29882994
    29892995        /*Free ressources:*/
    … …  
    30513057        /*Retrieve all inputs and parameters*/
    30523058        element->GetVerticesCoordinates(&xyz_list);
    3053         Input* vx_input = element->GetInput(VxEnum); _assert_(vx_input);
    3054         Input* vy_input = element->GetInput(VyEnum); _assert_(vy_input);
    3055         Input* vz_input = element->GetInput(VzEnum); _assert_(vz_input);
     3059        Input2* vx_input = element->GetInput2(VxEnum); _assert_(vx_input);
     3060        Input2* vy_input = element->GetInput2(VyEnum); _assert_(vy_input);
     3061        Input2* vz_input = element->GetInput2(VzEnum); _assert_(vz_input);
    30563062
    30573063        /* Start  looping on the number of gaussian points: */
    … …  
    31413147        /*If on not water or not FS, skip stiffness: */
    31423148        int approximation,shelf_dampening;
    3143         element->GetInputValue(&approximation,ApproximationEnum);
     3149        element->GetInput2Value(&approximation,ApproximationEnum);
    31443150        if(approximation!=FSApproximationEnum && approximation!=SSAFSApproximationEnum && approximation!=HOFSApproximationEnum) return NULL;
    31453151        element->FindParam(&shelf_dampening,StressbalanceShelfDampeningEnum);
    … …  
    31743180        IssmDouble  rho_water     = element->FindParam(MaterialsRhoSeawaterEnum);
    31753181        IssmDouble  gravity       = element->FindParam(ConstantsGEnum);
    3176         Input*      base_input = element->GetInput(BaseEnum); _assert_(base_input);
     3182        Input2*      base_input = element->GetInput2(BaseEnum); _assert_(base_input);
    31773183
    31783184        /* Start  looping on the number of gaussian points: */
    … …  
    32323238        element->GetVerticesCoordinates(&xyz_list);
    32333239        element->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum);
    3234         Input* vx_input=element->GetInput(VxEnum);     _assert_(vx_input);
    3235         Input* vy_input=element->GetInput(VyEnum);     _assert_(vy_input);
    3236         Input* vz_input = NULL;
    3237         if(dim==3){vz_input=element->GetInput(VzEnum); _assert_(vz_input);}
     3240        Input2* vx_input=element->GetInput2(VxEnum);     _assert_(vx_input);
     3241        Input2* vy_input=element->GetInput2(VyEnum);     _assert_(vy_input);
     3242        Input2* vz_input = NULL;
     3243        if(dim==3){vz_input=element->GetInput2(VzEnum); _assert_(vz_input);}
    32383244
    32393245        /* Start  looping on the number of gaussian points: */
    … …  
    33823388        element->GetVerticesCoordinates(&xyz_list);
    33833389        //element->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum);
    3384         Input* vx_input=element->GetInput(VxEnum);     _assert_(vx_input);
    3385         Input* vy_input=element->GetInput(VyEnum);     _assert_(vy_input);
    3386         Input* vz_input = NULL;
    3387         if(dim==3){vz_input=element->GetInput(VzEnum); _assert_(vz_input);}
     3390        Input2* vx_input=element->GetInput2(VxEnum);     _assert_(vx_input);
     3391        Input2* vy_input=element->GetInput2(VyEnum);     _assert_(vy_input);
     3392        Input2* vz_input = NULL;
     3393        if(dim==3){vz_input=element->GetInput2(VzEnum); _assert_(vz_input);}
    33883394
    33893395
    … …  
    34563462        /*Retrieve all inputs and parameters*/
    34573463        element->GetVerticesCoordinates(&xyz_list);
    3458         Input* vx_input = element->GetInput(VxEnum);     _assert_(vx_input);
    3459         Input* vy_input = element->GetInput(VyEnum);     _assert_(vy_input);
    3460         Input* vz_input = NULL;
    3461         if(dim==3){vz_input = element->GetInput(VzEnum); _assert_(vz_input);}
     3464        Input2* vx_input = element->GetInput2(VxEnum);     _assert_(vx_input);
     3465        Input2* vy_input = element->GetInput2(VyEnum);     _assert_(vy_input);
     3466        Input2* vz_input = NULL;
     3467        if(dim==3){vz_input = element->GetInput2(VzEnum); _assert_(vz_input);}
    34623468
    34633469        /* Start  looping on the number of gaussian points: */
    … …  
    35813587        element->GetVerticesCoordinates(&xyz_list);
    35823588        element->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum);
    3583         Input* vx_input=element->GetInput(VxEnum);     _assert_(vx_input);
    3584         Input* vy_input=element->GetInput(VyEnum);     _assert_(vy_input);
    3585         Input* vz_input;
    3586         if(dim==3){vz_input=element->GetInput(VzEnum); _assert_(vz_input);}
     3589        Input2* vx_input=element->GetInput2(VxEnum);     _assert_(vx_input);
     3590        Input2* vy_input=element->GetInput2(VyEnum);     _assert_(vy_input);
     3591        Input2* vz_input;
     3592        if(dim==3){vz_input=element->GetInput2(VzEnum); _assert_(vz_input);}
    35873593
    35883594        /* Start  looping on the number of gaussian points: */
    … …  
    36233629        /*If on water or not FS, skip stiffness: */
    36243630        int approximation;
    3625         element->GetInputValue(&approximation,ApproximationEnum);
     3631        element->GetInput2Value(&approximation,ApproximationEnum);
    36263632        if(approximation!=FSApproximationEnum && approximation!=SSAFSApproximationEnum && approximation!=HOFSApproximationEnum) return NULL;
    36273633
    … …  
    36503656        element->GetVerticesCoordinatesBase(&xyz_list_base);
    36513657        element->GetVerticesCoordinates(&xyz_list);
    3652         Input* vx_input         = element->GetInput(VxEnum);      _assert_(vx_input);
    3653         Input* vy_input         = element->GetInput(VyEnum);      _assert_(vy_input);
    3654         Input* vz_input         = NULL;
    3655         if(dim==3){    vz_input = element->GetInput(VzEnum);      _assert_(vz_input);}
     3658        Input2* vx_input         = element->GetInput2(VxEnum);      _assert_(vx_input);
     3659        Input2* vy_input         = element->GetInput2(VyEnum);      _assert_(vy_input);
     3660        Input2* vz_input         = NULL;
     3661        if(dim==3){    vz_input = element->GetInput2(VzEnum);      _assert_(vz_input);}
    36563662
    36573663        /* Start  looping on the number of gaussian points: */
    … …  
    37283734        /*Retrieve all inputs and parameters*/
    37293735        element->GetVerticesCoordinatesBase(&xyz_list_base);
    3730         Input*  alpha2_input=element->GetInput(FrictionCoefficientEnum); _assert_(alpha2_input);
     3736        Input2*  alpha2_input=element->GetInput2(FrictionCoefficientEnum); _assert_(alpha2_input);
    37313737
    37323738        /* Start  looping on the number of gaussian points: */
    … …  
    37823788        /*Retrieve all inputs and parameters*/
    37833789        element->GetVerticesCoordinatesBase(&xyz_list_base);
    3784         Input*  sigmann_input=element->GetInput(VzEnum); _assert_(sigmann_input);
    3785         Input*  sigmant_input=element->GetInput(TemperatureEnum); _assert_(sigmant_input);
    3786         Input*  bedslope_input=element->GetInput(BedSlopeXEnum);     _assert_(bedslope_input);
     3790        Input2*  sigmann_input=element->GetInput2(VzEnum); _assert_(sigmann_input);
     3791        Input2*  sigmant_input=element->GetInput2(TemperatureEnum); _assert_(sigmant_input);
     3792        Input2*  bedslope_input=element->GetInput2(BedSlopeXEnum);     _assert_(bedslope_input);
    37873793
    37883794        /* Start  looping on the number of gaussian points: */
    … …  
    38993905        /*If on water or not FS, skip stiffness: */
    39003906        int approximation;
    3901         element->GetInputValue(&approximation,ApproximationEnum);
     3907        element->GetInput2Value(&approximation,ApproximationEnum);
    39023908        if(approximation!=FSApproximationEnum && approximation!=SSAFSApproximationEnum && approximation!=HOFSApproximationEnum) return NULL;
    39033909
    … …  
    39273933        element->GetVerticesCoordinatesBase(&xyz_list_base);
    39283934        element->FindParam(&friction_style,GroundinglineFrictionInterpolationEnum);
    3929         Input* gllevelset_input = NULL;
     3935        Input2* gllevelset_input = NULL;
    39303936
    39313937        /*build friction object, used later on: */
    … …  
    39363942        if(friction_style==SubelementFriction2Enum){
    39373943                if(domaintype==Domain2DverticalEnum) _error_("Subelement Friction 2 not implemented yet for Flowline");
    3938                 gllevelset_input=element->GetInput(MaskGroundediceLevelsetEnum); _assert_(gllevelset_input);
     3944                gllevelset_input=element->GetInput2(MaskGroundediceLevelsetEnum); _assert_(gllevelset_input);
    39393945                element->GetGroundedPart(&point1,&fraction1,&fraction2,&mainlyfloating);
    39403946                //gauss = element->NewGauss(point1,fraction1,fraction2,mainlyfloating,2);
    … …  
    40684074        IssmDouble  rho_ice =element->FindParam(MaterialsRhoIceEnum);
    40694075        IssmDouble  gravity =element->FindParam(ConstantsGEnum);
    4070         Input*      loadingforcex_input=element->GetInput(LoadingforceXEnum);  _assert_(loadingforcex_input);
    4071         Input*      loadingforcey_input=element->GetInput(LoadingforceYEnum);  _assert_(loadingforcey_input);
    4072         Input*      loadingforcez_input=NULL;
     4076        Input2*      loadingforcex_input=element->GetInput2(LoadingforceXEnum);  _assert_(loadingforcex_input);
     4077        Input2*      loadingforcey_input=element->GetInput2(LoadingforceYEnum);  _assert_(loadingforcey_input);
     4078        Input2*      loadingforcez_input=NULL;
    40734079        if(dim==3){
    4074                 loadingforcez_input=element->GetInput(LoadingforceZEnum);  _assert_(loadingforcez_input);
     4080                loadingforcez_input=element->GetInput2(LoadingforceZEnum);  _assert_(loadingforcez_input);
    40754081        }
    40764082
    … …  
    41464152        element->GetIcefrontCoordinates(&xyz_list_front,xyz_list,MaskIceLevelsetEnum);
    41474153        element->NormalSection(&normal[0],xyz_list_front);
    4148         Input* surface_input  = element->GetInput(SurfaceEnum); _assert_(surface_input);
    4149         Input* sealevel_input       = element->GetInput(SealevelEnum);       _assert_(sealevel_input);
     4154        Input2* surface_input  = element->GetInput2(SurfaceEnum); _assert_(surface_input);
     4155        Input2* sealevel_input       = element->GetInput2(SealevelEnum);       _assert_(sealevel_input);
    41504156        IssmDouble  rho_water = element->FindParam(MaterialsRhoSeawaterEnum);
    41514157        IssmDouble  gravity   = element->FindParam(ConstantsGEnum);
    … …  
    42154221        /*Retrieve all inputs and parameters*/
    42164222        element->GetVerticesCoordinatesBase(&xyz_list_base);
    4217         Input*      base_input=element->GetInput(BaseEnum); _assert_(base_input);
     4223        Input2*      base_input=element->GetInput2(BaseEnum); _assert_(base_input);
    42184224        IssmDouble  rho_water=element->FindParam(MaterialsRhoSeawaterEnum);
    42194225        IssmDouble  gravity  =element->FindParam(ConstantsGEnum);
    … …  
    42394245        element->FindParam(&shelf_dampening,StressbalanceShelfDampeningEnum);
    42404246        if(shelf_dampening) {
    4241                 Input*      mb_input=element->GetInput(BasalforcingsFloatingiceMeltingRateEnum); _assert_(mb_input);
     4247                Input2*      mb_input=element->GetInput2(BasalforcingsFloatingiceMeltingRateEnum); _assert_(mb_input);
    42424248                IssmDouble  dt,mb;
    42434249                element->FindParam(&dt,TimesteppingTimeStepEnum);
    … …  
    42904296
    42914297        /*Get pressure and sigmann*/
    4292         Input* pressure_input=element->GetInput(PressureEnum); _assert_(pressure_input);
    4293         Input* sigmann_input =element->GetInput(SigmaNNEnum);  _assert_(sigmann_input);
     4298        Input2* pressure_input=element->GetInput2(PressureEnum); _assert_(pressure_input);
     4299        Input2* sigmann_input =element->GetInput2(SigmaNNEnum);  _assert_(sigmann_input);
    42944300
    42954301        gauss=element->NewGauss(5);
    … …  
    43834389
    43844390        /*Get d and tau*/
    4385         Input* epsxx_input=element->GetInput(StrainRatexxEnum); _assert_(epsxx_input);
    4386         Input* epsyy_input=element->GetInput(StrainRateyyEnum); _assert_(epsyy_input);
    4387         Input* epsxy_input=element->GetInput(StrainRatexyEnum); _assert_(epsxy_input);
    4388         Input* epszz_input=NULL; Input* epsxz_input=NULL; Input* epsyz_input=NULL;
    4389         Input* sigmapxx_input=element->GetInput(DeviatoricStressxxEnum); _assert_(sigmapxx_input);
    4390         Input* sigmapyy_input=element->GetInput(DeviatoricStressyyEnum); _assert_(sigmapyy_input);
    4391         Input* sigmapxy_input=element->GetInput(DeviatoricStressxyEnum); _assert_(sigmapxy_input);
    4392         Input* sigmapzz_input=NULL; Input* sigmapxz_input=NULL; Input* sigmapyz_input=NULL;
     4391        Input2* epsxx_input=element->GetInput2(StrainRatexxEnum); _assert_(epsxx_input);
     4392        Input2* epsyy_input=element->GetInput2(StrainRateyyEnum); _assert_(epsyy_input);
     4393        Input2* epsxy_input=element->GetInput2(StrainRatexyEnum); _assert_(epsxy_input);
     4394        Input2* epszz_input=NULL; Input2* epsxz_input=NULL; Input2* epsyz_input=NULL;
     4395        Input2* sigmapxx_input=element->GetInput2(DeviatoricStressxxEnum); _assert_(sigmapxx_input);
     4396        Input2* sigmapyy_input=element->GetInput2(DeviatoricStressyyEnum); _assert_(sigmapyy_input);
     4397        Input2* sigmapxy_input=element->GetInput2(DeviatoricStressxyEnum); _assert_(sigmapxy_input);
     4398        Input2* sigmapzz_input=NULL; Input2* sigmapxz_input=NULL; Input2* sigmapyz_input=NULL;
    43934399        if(dim==3){
    4394                 epszz_input=element->GetInput(StrainRatezzEnum); _assert_(epszz_input);
    4395                 epsxz_input=element->GetInput(StrainRatexzEnum); _assert_(epsxz_input);
    4396                 epsyz_input=element->GetInput(StrainRateyzEnum); _assert_(epsyz_input);
    4397                 sigmapzz_input=element->GetInput(DeviatoricStresszzEnum); _assert_(sigmapzz_input);
    4398                 sigmapxz_input=element->GetInput(DeviatoricStressxzEnum); _assert_(sigmapxz_input);
    4399                 sigmapyz_input=element->GetInput(DeviatoricStressyzEnum); _assert_(sigmapyz_input);
     4400                epszz_input=element->GetInput2(StrainRatezzEnum); _assert_(epszz_input);
     4401                epsxz_input=element->GetInput2(StrainRatexzEnum); _assert_(epsxz_input);
     4402                epsyz_input=element->GetInput2(StrainRateyzEnum); _assert_(epsyz_input);
     4403                sigmapzz_input=element->GetInput2(DeviatoricStresszzEnum); _assert_(sigmapzz_input);
     4404                sigmapxz_input=element->GetInput2(DeviatoricStressxzEnum); _assert_(sigmapxz_input);
     4405                sigmapyz_input=element->GetInput2(DeviatoricStressyzEnum); _assert_(sigmapyz_input);
    44004406        }
    44014407
    … …  
    50595065        int*         vdoflist=NULL;
    50605066        int*         pdoflist=NULL;
    5061         Input*       vz_input=NULL;
     5067        Input2*       vz_input=NULL;
    50625068        int          dim;
    50635069        IssmDouble   vx,vy,vz,p;
    … …  
    50815087        element->GetDofListVelocity(&vdoflist,GsetEnum);
    50825088        element->GetDofListPressure(&pdoflist,GsetEnum);
    5083         Input*     vx_input=element->GetInput(VxEnum);       _assert_(vx_input);
    5084         Input*     vy_input=element->GetInput(VyEnum);       _assert_(vy_input);
    5085         if(dim==3){vz_input=element->GetInput(VzEnum);       _assert_(vz_input);}
    5086         Input*     p_input =element->GetInput(PressureEnum); _assert_(p_input);
     5089        Input2*     vx_input=element->GetInput2(VxEnum);       _assert_(vx_input);
     5090        Input2*     vy_input=element->GetInput2(VyEnum);       _assert_(vy_input);
     5091        if(dim==3){vz_input=element->GetInput2(VzEnum);       _assert_(vz_input);}
     5092        Input2*     p_input =element->GetInput2(PressureEnum); _assert_(p_input);
    50875093
    50885094        element->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum);
    … …  
    51425148                /*Get inputs and parameters*/
    51435149                element->GetVerticesCoordinates(&xyz_list);
    5144                 Input* vx_input=element->GetInput(VxEnum); _assert_(vx_input);
    5145                 Input* vy_input=element->GetInput(VyEnum); _assert_(vy_input);
    5146                 Input* vz_input;
    5147                 if(dim==3){vz_input=element->GetInput(VzEnum); _assert_(vz_input);}
     5150                Input2* vx_input=element->GetInput2(VxEnum); _assert_(vx_input);
     5151                Input2* vy_input=element->GetInput2(VyEnum); _assert_(vy_input);
     5152                Input2* vz_input;
     5153                if(dim==3){vz_input=element->GetInput2(VzEnum); _assert_(vz_input);}
    51485154
    51495155                /*Allocate new inputs*/
    … …  
    51845190
    51855191                /*Add inputs*/
    5186                 element->AddInput(StrainRatexxEnum,epsxx,P1DGEnum); element->AddInput(DeviatoricStressxxEnum,sigmapxx,P1DGEnum);
    5187                 element->AddInput(StrainRateyyEnum,epsyy,P1DGEnum); element->AddInput(DeviatoricStressyyEnum,sigmapyy,P1DGEnum);
    5188                 element->AddInput(StrainRatexyEnum,epsxy,P1DGEnum); element->AddInput(DeviatoricStressxyEnum,sigmapxy,P1DGEnum);
     5192                element->AddInput2(StrainRatexxEnum,epsxx,P1DGEnum); element->AddInput2(DeviatoricStressxxEnum,sigmapxx,P1DGEnum);
     5193                element->AddInput2(StrainRateyyEnum,epsyy,P1DGEnum); element->AddInput2(DeviatoricStressyyEnum,sigmapyy,P1DGEnum);
     5194                element->AddInput2(StrainRatexyEnum,epsxy,P1DGEnum); element->AddInput2(DeviatoricStressxyEnum,sigmapxy,P1DGEnum);
    51895195                if(dim==3){
    5190                         element->AddInput(StrainRatezzEnum,epszz,P1DGEnum); element->AddInput(DeviatoricStresszzEnum,sigmapzz,P1DGEnum);
    5191                         element->AddInput(StrainRatexzEnum,epsxz,P1DGEnum); element->AddInput(DeviatoricStressxzEnum,sigmapxz,P1DGEnum);
    5192                         element->AddInput(StrainRateyzEnum,epsyz,P1DGEnum); element->AddInput(DeviatoricStressyzEnum,sigmapyz,P1DGEnum);
     5196                        element->AddInput2(StrainRatezzEnum,epszz,P1DGEnum); element->AddInput2(DeviatoricStresszzEnum,sigmapzz,P1DGEnum);
     5197                        element->AddInput2(StrainRatexzEnum,epsxz,P1DGEnum); element->AddInput2(DeviatoricStressxzEnum,sigmapxz,P1DGEnum);
     5198                        element->AddInput2(StrainRateyzEnum,epsyz,P1DGEnum); element->AddInput2(DeviatoricStressyzEnum,sigmapyz,P1DGEnum);
    51935199                }
    51945200
    … …  
    52735279
    52745280        /*Add vx and vy as inputs to the tria element: */
    5275         int fe_v = element->VelocityInterpolation();
    5276         //if(fe_v == P1bubblecondensedEnum) fe_v = P1Enum;
    5277         //if(fe_v == P1bubbleEnum) fe_v = P1Enum;
    5278         element->AddInput(VxEnum, vx, fe_v);
    5279         element->AddInput(VyEnum, vy, fe_v);
    5280         element->AddInput(VelEnum,vel,fe_v);
    5281         if(pnumdof>0) element->AddInput(PressureEnum,pressure,element->PressureInterpolation());
    5282         if(dim==3) element->AddInput(VzEnum,vz, fe_v);
     5281        int v_interp = element->VelocityInterpolation();
     5282        if(v_interp==P1bubbleEnum) v_interp=P1Enum;
     5283        if(v_interp == P1bubblecondensedEnum) v_interp = P1Enum;
     5284        element->AddInput2(VxEnum, vx, v_interp);
     5285        element->AddInput2(VyEnum, vy, v_interp);
     5286        element->AddInput2(VelEnum,vel,v_interp);
     5287        if(pnumdof>0) element->AddInput2(PressureEnum,pressure,element->PressureInterpolation());
     5288        if(dim==3) element->AddInput2(VzEnum,vz,v_interp);
    52835289
    52845290        /*Free ressources:*/
    … …  
    53145320                /*Get inputs and parameters*/
    53155321                element->GetVerticesCoordinates(&xyz_list);
    5316                 Input*  B_input=element->GetInput(MaterialsRheologyBEnum); _assert_(B_input);
    5317                 Input*  n_input=element->GetInput(MaterialsRheologyNEnum); _assert_(n_input);
    5318                 Input* vx_input=element->GetInput(VxEnum);                 _assert_(vx_input);
    5319                 Input* vy_input=element->GetInput(VyEnum);                 _assert_(vy_input);
    5320                 Input* vz_input;
    5321                 if(dim==3){vz_input=element->GetInput(VzEnum); _assert_(vz_input);}
     5322                Input2*  B_input=element->GetInput2(MaterialsRheologyBEnum); _assert_(B_input);
     5323                Input2*  n_input=element->GetInput2(MaterialsRheologyNEnum); _assert_(n_input);
     5324                Input2* vx_input=element->GetInput2(VxEnum);                 _assert_(vx_input);
     5325                Input2* vy_input=element->GetInput2(VyEnum);                 _assert_(vy_input);
     5326                Input2* vz_input;
     5327                if(dim==3){vz_input=element->GetInput2(VzEnum); _assert_(vz_input);}
    53225328
    53235329                /*Fetch number of nodes and dof for this finite element*/
    … …  
    53385344
    53395345                /*Get previous d*/
    5340                 Input* epsxx_input=element->GetInput(StrainRatexxEnum); _assert_(epsxx_input);
    5341                 Input* epsyy_input=element->GetInput(StrainRateyyEnum); _assert_(epsyy_input);
    5342                 Input* epsxy_input=element->GetInput(StrainRatexyEnum); _assert_(epsxy_input);
    5343                 Input* epszz_input=NULL; Input* epsxz_input=NULL; Input* epsyz_input=NULL;
     5346                Input2* epsxx_input=element->GetInput2(StrainRatexxEnum); _assert_(epsxx_input);
     5347                Input2* epsyy_input=element->GetInput2(StrainRateyyEnum); _assert_(epsyy_input);
     5348                Input2* epsxy_input=element->GetInput2(StrainRatexyEnum); _assert_(epsxy_input);
     5349                Input2* epszz_input=NULL; Input2* epsxz_input=NULL; Input2* epsyz_input=NULL;
    53445350                if(dim==3){
    5345                         epszz_input=element->GetInput(StrainRatezzEnum); _assert_(epszz_input);
    5346                         epsxz_input=element->GetInput(StrainRatexzEnum); _assert_(epsxz_input);
    5347                         epsyz_input=element->GetInput(StrainRateyzEnum); _assert_(epsyz_input);
     5351                        epszz_input=element->GetInput2(StrainRatezzEnum); _assert_(epszz_input);
     5352                        epsxz_input=element->GetInput2(StrainRatexzEnum); _assert_(epsxz_input);
     5353                        epsyz_input=element->GetInput2(StrainRateyzEnum); _assert_(epsyz_input);
    53485354                }
    53495355
    53505356                /*Get tau*/
    5351                 Input* sigmapxx_input=element->GetInput(DeviatoricStressxxEnum); _assert_(sigmapxx_input);
    5352                 Input* sigmapyy_input=element->GetInput(DeviatoricStressyyEnum); _assert_(sigmapyy_input);
    5353                 Input* sigmapxy_input=element->GetInput(DeviatoricStressxyEnum); _assert_(sigmapxy_input);
    5354                 Input* sigmapzz_input=NULL; Input* sigmapxz_input=NULL; Input* sigmapyz_input=NULL;
     5357                Input2* sigmapxx_input=element->GetInput2(DeviatoricStressxxEnum); _assert_(sigmapxx_input);
     5358                Input2* sigmapyy_input=element->GetInput2(DeviatoricStressyyEnum); _assert_(sigmapyy_input);
     5359                Input2* sigmapxy_input=element->GetInput2(DeviatoricStressxyEnum); _assert_(sigmapxy_input);
     5360                Input2* sigmapzz_input=NULL; Input2* sigmapxz_input=NULL; Input2* sigmapyz_input=NULL;
    53555361                if(dim==3){
    5356                         sigmapzz_input=element->GetInput(DeviatoricStresszzEnum); _assert_(sigmapzz_input);
    5357                         sigmapxz_input=element->GetInput(DeviatoricStressxzEnum); _assert_(sigmapxz_input);
    5358                         sigmapyz_input=element->GetInput(DeviatoricStressyzEnum); _assert_(sigmapyz_input);
     5362                        sigmapzz_input=element->GetInput2(DeviatoricStresszzEnum); _assert_(sigmapzz_input);
     5363                        sigmapxz_input=element->GetInput2(DeviatoricStressxzEnum); _assert_(sigmapxz_input);
     5364                        sigmapyz_input=element->GetInput2(DeviatoricStressyzEnum); _assert_(sigmapyz_input);
    53595365                }
    53605366
    … …  
    54705476                        for(int i=0;i<3;i++) _assert_(!xIsNan<IssmDouble>(d_yy[i]));
    54715477                        for(int i=0;i<3;i++) _assert_(!xIsNan<IssmDouble>(d_xx[i]));
    5472                         element->AddInput(StrainRatexxEnum,d_xx,P1DGEnum);
    5473                         element->AddInput(StrainRateyyEnum,d_yy,P1DGEnum);
    5474                         element->AddInput(StrainRatexyEnum,d_xy,P1DGEnum);
     5478                        element->AddInput2(StrainRatexxEnum,d_xx,P1DGEnum);
     5479                        element->AddInput2(StrainRateyyEnum,d_yy,P1DGEnum);
     5480                        element->AddInput2(StrainRatexyEnum,d_xy,P1DGEnum);
    54755481                }
    54765482                else{
    … …  
    54855491                        Matrix4x4Solve(&d_xz[0],Ke,pe_xz);
    54865492                        Matrix4x4Solve(&d_yz[0],Ke,pe_yz);
    5487                         element->AddInput(StrainRatexxEnum,d_xx,P1DGEnum);
    5488                         element->AddInput(StrainRateyyEnum,d_yy,P1DGEnum);
    5489                         element->AddInput(StrainRatexyEnum,d_xy,P1DGEnum);
    5490                         element->AddInput(StrainRatezzEnum,d_zz,P1DGEnum);
    5491                         element->AddInput(StrainRatexzEnum,d_xz,P1DGEnum);
    5492                         element->AddInput(StrainRateyzEnum,d_yz,P1DGEnum);
     5493                        element->AddInput2(StrainRatexxEnum,d_xx,P1DGEnum);
     5494                        element->AddInput2(StrainRateyyEnum,d_yy,P1DGEnum);
     5495                        element->AddInput2(StrainRatexyEnum,d_xy,P1DGEnum);
     5496                        element->AddInput2(StrainRatezzEnum,d_zz,P1DGEnum);
     5497                        element->AddInput2(StrainRatexzEnum,d_xz,P1DGEnum);
     5498                        element->AddInput2(StrainRateyzEnum,d_yz,P1DGEnum);
    54935499                }
    54945500
    … …  
    55275533                /*Get inputs and parameters*/
    55285534                element->GetVerticesCoordinates(&xyz_list);
    5529                 Input* vx_input=element->GetInput(VxEnum);                 _assert_(vx_input);
    5530                 Input* vy_input=element->GetInput(VyEnum);                 _assert_(vy_input);
    5531                 Input* vz_input=NULL;
    5532                 if(dim==3){vz_input=element->GetInput(VzEnum); _assert_(vz_input);}
     5535                Input2* vx_input=element->GetInput2(VxEnum);                 _assert_(vx_input);
     5536                Input2* vy_input=element->GetInput2(VyEnum);                 _assert_(vy_input);
     5537                Input2* vz_input=NULL;
     5538                if(dim==3){vz_input=element->GetInput2(VzEnum); _assert_(vz_input);}
    55335539
    55345540                /*Get previous tau*/
    5535                 Input* sigmapxx_input=element->GetInput(DeviatoricStressxxEnum); _assert_(sigmapxx_input);
    5536                 Input* sigmapyy_input=element->GetInput(DeviatoricStressyyEnum); _assert_(sigmapyy_input);
    5537                 Input* sigmapxy_input=element->GetInput(DeviatoricStressxyEnum); _assert_(sigmapxy_input);
    5538                 Input* sigmapzz_input=NULL; Input* sigmapxz_input=NULL; Input* sigmapyz_input=NULL;
     5541                Input2* sigmapxx_input=element->GetInput2(DeviatoricStressxxEnum); _assert_(sigmapxx_input);
     5542                Input2* sigmapyy_input=element->GetInput2(DeviatoricStressyyEnum); _assert_(sigmapyy_input);
     5543                Input2* sigmapxy_input=element->GetInput2(DeviatoricStressxyEnum); _assert_(sigmapxy_input);
     5544                Input2* sigmapzz_input=NULL; Input2* sigmapxz_input=NULL; Input2* sigmapyz_input=NULL;
    55395545                if(dim==3){
    5540                         sigmapzz_input=element->GetInput(DeviatoricStresszzEnum); _assert_(sigmapzz_input);
    5541                         sigmapxz_input=element->GetInput(DeviatoricStressxzEnum); _assert_(sigmapxz_input);
    5542                         sigmapyz_input=element->GetInput(DeviatoricStressyzEnum); _assert_(sigmapyz_input);
     5546                        sigmapzz_input=element->GetInput2(DeviatoricStresszzEnum); _assert_(sigmapzz_input);
     5547                        sigmapxz_input=element->GetInput2(DeviatoricStressxzEnum); _assert_(sigmapxz_input);
     5548                        sigmapyz_input=element->GetInput2(DeviatoricStressyzEnum); _assert_(sigmapyz_input);
    55435549                }
    55445550
    55455551                /*Get NEW d*/
    5546                 Input* epsxx_input=element->GetInput(StrainRatexxEnum); _assert_(epsxx_input);
    5547                 Input* epsyy_input=element->GetInput(StrainRateyyEnum); _assert_(epsyy_input);
    5548                 Input* epsxy_input=element->GetInput(StrainRatexyEnum); _assert_(epsxy_input);
    5549                 Input* epszz_input=NULL; Input* epsxz_input=NULL; Input* epsyz_input=NULL;
     5552                Input2* epsxx_input=element->GetInput2(StrainRatexxEnum); _assert_(epsxx_input);
     5553                Input2* epsyy_input=element->GetInput2(StrainRateyyEnum); _assert_(epsyy_input);
     5554                Input2* epsxy_input=element->GetInput2(StrainRatexyEnum); _assert_(epsxy_input);
     5555                Input2* epszz_input=NULL; Input2* epsxz_input=NULL; Input2* epsyz_input=NULL;
    55505556                if(dim==3){
    5551                         epszz_input=element->GetInput(StrainRatezzEnum); _assert_(epszz_input);
    5552                         epsxz_input=element->GetInput(StrainRatexzEnum); _assert_(epsxz_input);
    5553                         epsyz_input=element->GetInput(StrainRateyzEnum); _assert_(epsyz_input);
     5557                        epszz_input=element->GetInput2(StrainRatezzEnum); _assert_(epszz_input);
     5558                        epsxz_input=element->GetInput2(StrainRatexzEnum); _assert_(epsxz_input);
     5559                        epsyz_input=element->GetInput2(StrainRateyzEnum); _assert_(epsyz_input);
    55545560                }
    55555561
    … …  
    56205626
    56215627                /*Add inputs*/
    5622                 element->AddInput(DeviatoricStressxxEnum,tau_xx,P1DGEnum);
    5623                 element->AddInput(DeviatoricStressyyEnum,tau_yy,P1DGEnum);
    5624                 element->AddInput(DeviatoricStressxyEnum,tau_xy,P1DGEnum);
     5628                element->AddInput2(DeviatoricStressxxEnum,tau_xx,P1DGEnum);
     5629                element->AddInput2(DeviatoricStressyyEnum,tau_yy,P1DGEnum);
     5630                element->AddInput2(DeviatoricStressxyEnum,tau_xy,P1DGEnum);
    56255631                if(dim==3){
    5626                         element->AddInput(DeviatoricStresszzEnum,tau_zz,P1DGEnum);
    5627                         element->AddInput(DeviatoricStressxzEnum,tau_xz,P1DGEnum);
    5628                         element->AddInput(DeviatoricStressyzEnum,tau_yz,P1DGEnum);
     5632                        element->AddInput2(DeviatoricStresszzEnum,tau_zz,P1DGEnum);
     5633                        element->AddInput2(DeviatoricStressxzEnum,tau_xz,P1DGEnum);
     5634                        element->AddInput2(DeviatoricStressyzEnum,tau_yz,P1DGEnum);
    56295635                }
    56305636
    … …  
    57525758
    57535759        /*If on water or not FS, skip stiffness: */
    5754         element->GetInputValue(&approximation,ApproximationEnum);
     5760        element->GetInput2Value(&approximation,ApproximationEnum);
    57555761        if(element->IsFloating() || !element->IsOnBase()) return NULL;
    57565762
    … …  
    57845790        element->GetVerticesCoordinatesBase(&xyz_list_tria);
    57855791        element->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum);
    5786         Input* vx_input=element->GetInput(VxEnum); _assert_(vx_input);
    5787         Input* vy_input=element->GetInput(VyEnum); _assert_(vy_input);
    5788         Input* vz_input=element->GetInput(VzEnum); _assert_(vz_input);
     5792        Input2* vx_input=element->GetInput2(VxEnum); _assert_(vx_input);
     5793        Input2* vy_input=element->GetInput2(VyEnum); _assert_(vy_input);
     5794        Input2* vz_input=element->GetInput2(VzEnum); _assert_(vz_input);
    57895795
    57905796        /*build friction object, used later on: */
    … …  
    59055911        element->GetVerticesCoordinates(&xyz_list);
    59065912        element->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum);
    5907         Input* vx_input=element->GetInput(VxEnum); _assert_(vx_input);
    5908         Input* vy_input=element->GetInput(VyEnum); _assert_(vy_input);
    5909         Input* vz_input=element->GetInput(VzEnum); _assert_(vz_input);
     5913        Input2* vx_input=element->GetInput2(VxEnum); _assert_(vx_input);
     5914        Input2* vy_input=element->GetInput2(VyEnum); _assert_(vy_input);
     5915        Input2* vz_input=element->GetInput2(VzEnum); _assert_(vz_input);
    59105916
    59115917        /* Start  looping on the number of gaussian points: */
    … …  
    60926098        /* Get node coordinates and dof list: */
    60936099        element->GetVerticesCoordinates(&xyz_list);
    6094         Input* vx_input   =element->GetInput(VxEnum);       _assert_(vx_input);
    6095         Input* vy_input   =element->GetInput(VyEnum);       _assert_(vy_input);
     6100        Input2* vx_input   =element->GetInput2(VxEnum);       _assert_(vx_input);
     6101        Input2* vy_input   =element->GetInput2(VyEnum);       _assert_(vy_input);
    60966102
    60976103        /* Start  looping on the number of gaussian points: */
    … …  
    62456251        /*Initialize Element matrix*/
    62466252        ElementMatrix* Ke=basaltria->NewElementMatrix(SSAApproximationEnum);
    6247         element->GetInputValue(&approximation,ApproximationEnum);
     6253        element->GetInput2Value(&approximation,ApproximationEnum);
    62486254
    62496255        /*Retrieve all inputs and parameters*/
    62506256        element->GetVerticesCoordinates(&xyz_list);
    6251         Input* vx_input   =element->GetInput(VxEnum);       _assert_(vx_input);
    6252         Input* vy_input   =element->GetInput(VyEnum);       _assert_(vy_input);
    6253         Input* vz_input   =element->GetInput(VzEnum);       _assert_(vz_input);
     6257        Input2* vx_input   =element->GetInput2(VxEnum);       _assert_(vx_input);
     6258        Input2* vy_input   =element->GetInput2(VyEnum);       _assert_(vy_input);
     6259        Input2* vz_input   =element->GetInput2(VzEnum);       _assert_(vz_input);
    62546260
    62556261        /* Start  looping on the number of gaussian points: */
    … …  
    63266332        /*Initialize Element vector and return if necessary*/
    63276333        if(!element->IsOnBase() || element->IsFloating()) return NULL;
    6328         element->GetInputValue(&approximation,ApproximationEnum);
     6334        element->GetInput2Value(&approximation,ApproximationEnum);
    63296335        if(approximation!=HOFSApproximationEnum) return NULL;
    63306336
    … …  
    63516357        element->GetVerticesCoordinatesBase(&xyz_list_tria);
    63526358        element->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum);
    6353         Input* vx_input=  element->GetInput(VxEnum);   _assert_(vx_input);
    6354         Input* vy_input=  element->GetInput(VyEnum);   _assert_(vy_input);
    6355         Input* vz_input=  element->GetInput(VzEnum);   _assert_(vz_input);
    6356         Input* vzHO_input=element->GetInput(VzHOEnum); _assert_(vzHO_input);
     6359        Input2* vx_input=  element->GetInput2(VxEnum);   _assert_(vx_input);
     6360        Input2* vy_input=  element->GetInput2(VyEnum);   _assert_(vy_input);
     6361        Input2* vz_input=  element->GetInput2(VzEnum);   _assert_(vz_input);
     6362        Input2* vzHO_input=element->GetInput2(VzHOEnum); _assert_(vzHO_input);
    63576363
    63586364        /*build friction object, used later on: */
    … …  
    64096415
    64106416        /*Initialize Element vector and return if necessary*/
    6411         element->GetInputValue(&approximation,ApproximationEnum);
     6417        element->GetInput2Value(&approximation,ApproximationEnum);
    64126418        if(approximation!=HOFSApproximationEnum) return NULL;
    64136419        int   vnumnodes = element->NumberofNodesVelocity();
    … …  
    64306436        element->GetVerticesCoordinates(&xyz_list);
    64316437        element->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum);
    6432         Input* vx_input   =element->GetInput(VxEnum);   _assert_(vx_input);
    6433         Input* vy_input   =element->GetInput(VyEnum);   _assert_(vy_input);
    6434         Input* vz_input   =element->GetInput(VzEnum);   _assert_(vz_input);
    6435         Input* vzHO_input=element->GetInput(VzHOEnum);  _assert_(vzHO_input);
     6438        Input2* vx_input   =element->GetInput2(VxEnum);   _assert_(vx_input);
     6439        Input2* vy_input   =element->GetInput2(VyEnum);   _assert_(vy_input);
     6440        Input2* vz_input   =element->GetInput2(VzEnum);   _assert_(vz_input);
     6441        Input2* vzHO_input=element->GetInput2(VzHOEnum);  _assert_(vzHO_input);
    64366442
    64376443        /* Start  looping on the number of gaussian points: */
    … …  
    64966502        /*Initialize Element vector and return if necessary*/
    64976503        if(!element->IsOnBase() || element->IsFloating()) return NULL;
    6498         element->GetInputValue(&approximation,ApproximationEnum);
     6504        element->GetInput2Value(&approximation,ApproximationEnum);
    64996505        if(approximation!=SSAFSApproximationEnum) return NULL;
    65006506        int vnumnodes = element->NumberofNodesVelocity();
    … …  
    65186524        element->GetVerticesCoordinatesBase(&xyz_list_tria);
    65196525        element->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum);
    6520         Input* vx_input=   element->GetInput(VxEnum);    _assert_(vx_input);
    6521         Input* vy_input=   element->GetInput(VyEnum);    _assert_(vy_input);
    6522         Input* vz_input=   element->GetInput(VzEnum);    _assert_(vz_input);
    6523         Input* vzSSA_input=element->GetInput(VzSSAEnum); _assert_(vzSSA_input);
     6526        Input2* vx_input=   element->GetInput2(VxEnum);    _assert_(vx_input);
     6527        Input2* vy_input=   element->GetInput2(VyEnum);    _assert_(vy_input);
     6528        Input2* vz_input=   element->GetInput2(VzEnum);    _assert_(vz_input);
     6529        Input2* vzSSA_input=element->GetInput2(VzSSAEnum); _assert_(vzSSA_input);
    65246530
    65256531        /*build friction object, used later on: */
    … …  
    65756581
    65766582        /*Initialize Element vector and return if necessary*/
    6577         element->GetInputValue(&approximation,ApproximationEnum);
     6583        element->GetInput2Value(&approximation,ApproximationEnum);
    65786584        if(approximation!=SSAFSApproximationEnum) return NULL;
    65796585        int vnumnodes = element->NumberofNodesVelocity();
    … …  
    65966602        element->GetVerticesCoordinates(&xyz_list);
    65976603        element->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum);
    6598         Input* vx_input   =element->GetInput(VxEnum);      _assert_(vx_input);
    6599         Input* vy_input   =element->GetInput(VyEnum);      _assert_(vy_input);
    6600         Input* vz_input   =element->GetInput(VzEnum);      _assert_(vz_input);
    6601         Input* vzSSA_input=element->GetInput(VzSSAEnum);   _assert_(vzSSA_input);
     6604        Input2* vx_input   =element->GetInput2(VxEnum);      _assert_(vx_input);
     6605        Input2* vy_input   =element->GetInput2(VyEnum);      _assert_(vy_input);
     6606        Input2* vz_input   =element->GetInput2(VzEnum);      _assert_(vz_input);
     6607        Input2* vzSSA_input=element->GetInput2(VzSSAEnum);   _assert_(vzSSA_input);
    66026608
    66036609        /* Start  looping on the number of gaussian points: */
    … …  
    71927198
    71937199        /*Add vx and vy as inputs to element: */
    7194         element->AddInput(VxEnum,vx,P1Enum);
    7195         element->AddInput(VyEnum,vy,P1Enum);
    7196         element->AddInput(VzEnum,vz,P1Enum);
    7197         element->AddInput(VzFSEnum,vzFS,P1Enum);
    7198         element->AddInput(VelEnum,vel,P1Enum);
    7199         element->AddInput(PressureEnum,pressure,P1Enum);
     7200        element->AddInput2(VxEnum,vx,P1Enum);
     7201        element->AddInput2(VyEnum,vy,P1Enum);
     7202        element->AddInput2(VzEnum,vz,P1Enum);
     7203        element->AddInput2(VzFSEnum,vzFS,P1Enum);
     7204        element->AddInput2(VelEnum,vel,P1Enum);
     7205        //element->AddInput2(PressureEnum,pressure,P1Enum);
    72007206
    72017207        /*Free ressources:*/
    … …  
    72957301
    72967302        /*Add vx and vy as inputs to element: */
    7297         element->AddInput(VxEnum,vx,P1Enum);
    7298         element->AddInput(VyEnum,vy,P1Enum);
    7299         element->AddInput(VzEnum,vz,P1Enum);
    7300         element->AddInput(VzFSEnum,vzFS,P1Enum);
    7301         element->AddInput(VelEnum,vel,P1Enum);
    7302         element->AddInput(PressureEnum,pressure,P1Enum);
     7303        element->AddInput2(VxEnum,vx,P1Enum);
     7304        element->AddInput2(VyEnum,vy,P1Enum);
     7305        element->AddInput2(VzEnum,vz,P1Enum);
     7306        element->AddInput2(VzFSEnum,vzFS,P1Enum);
     7307        element->AddInput2(VelEnum,vel,P1Enum);
     7308        //element->AddInput2(PressureEnum,pressure,P1Enum);
    73037309
    73047310        /*Free ressources:*/
    … …  
    73887394
    73897395        /*Add vx and vy as inputs to element: */
    7390         element->AddInput(VxEnum,vx,P1Enum);
    7391         element->AddInput(VyEnum,vy,P1Enum);
    7392         element->AddInput(VelEnum,vel,P1Enum);
    7393         element->AddInput(PressureEnum,pressure,P1Enum);
     7396        element->AddInput2(VxEnum,vx,P1Enum);
     7397        element->AddInput2(VyEnum,vy,P1Enum);
     7398        element->AddInput2(VelEnum,vel,P1Enum);
     7399        element->AddInput2(PressureEnum,pressure,P1Enum);
    73947400
    73957401        /*Free ressources:*/

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

    r23585 r24335  
    1717                void CreateNodes(Nodes* nodes,IoModel* iomodel,bool isamr=false);
    1818                int  DofsPerNode(int** doflist,int domaintype,int approximation);
    19                 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
     19                void UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type);
    2020                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    2121

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

    r23644 r24335  
    107107        return 2;
    108108}/*}}}*/
    109 void StressbalanceSIAAnalysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
     109void StressbalanceSIAAnalysis::UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
    110110
    111111        /*Fetch data needed: */
    … …  
    127127                if(iomodel->my_elements[i]){
    128128                        Element* element=(Element*)elements->GetObjectByOffset(counter);
    129                         element->Update(i,iomodel,analysis_counter,analysis_type,P1Enum);
     129                        element->Update(inputs2,i,iomodel,analysis_counter,analysis_type,P1Enum);
     130                        /*Need to know the type of approximation for this element*/
     131                        if(iomodel->Data("md.flowequation.element_equation")){
     132                                inputs2->SetInput(ApproximationEnum,counter,IoCodeToEnumElementEquation(reCast<int>(iomodel->Data("md.flowequation.element_equation")[i])));
     133                        }
    130134                        counter++;
    131135                }
    132136        }
     137
     138        /*Free data: */
     139        iomodel->DeleteData(1,"md.flowequation.element_equation");
    133140
    134141        /*Friction law variables*/
    135142        switch(frictionlaw){
    136143                case 1:
    137                         iomodel->FetchDataToInput(elements,"md.friction.coefficient",FrictionCoefficientEnum);
    138                         iomodel->FetchDataToInput(elements,"md.friction.p",FrictionPEnum);
    139                         iomodel->FetchDataToInput(elements,"md.friction.q",FrictionQEnum);
     144                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.coefficient",FrictionCoefficientEnum);
     145                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.p",FrictionPEnum);
     146                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.q",FrictionQEnum);
    140147                        break;
    141148                case 2:
    142                         iomodel->FetchDataToInput(elements,"md.friction.C",FrictionCEnum);
    143                         iomodel->FetchDataToInput(elements,"md.friction.m",FrictionMEnum);
     149                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.C",FrictionCEnum);
     150                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.m",FrictionMEnum);
    144151                        break;
    145152                case 6:
    146                         iomodel->FetchDataToInput(elements,"md.friction.C",FrictionCEnum);
    147                         iomodel->FetchDataToInput(elements,"md.friction.m",FrictionMEnum);
    148                         iomodel->FetchDataToInput(elements,"md.initialization.pressure",PressureEnum);
    149                         iomodel->FetchDataToInput(elements,"md.initialization.temperature",TemperatureEnum);
     153                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.C",FrictionCEnum);
     154                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.m",FrictionMEnum);
     155                        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.pressure",PressureEnum);
     156                        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.temperature",TemperatureEnum);
    150157                        break;
    151158                default:
    … …  
    153160        }
    154161
    155         iomodel->FetchDataToInput(elements,"md.geometry.thickness",ThicknessEnum);
    156         iomodel->FetchDataToInput(elements,"md.mask.groundedice_levelset",MaskGroundediceLevelsetEnum);
     162        iomodel->FetchDataToInput(inputs2,elements,"md.geometry.thickness",ThicknessEnum);
     163        iomodel->FetchDataToInput(inputs2,elements,"md.mask.groundedice_levelset",MaskGroundediceLevelsetEnum);
    157164        if(ismovingfront){
    158165                if(iomodel->domaintype!=Domain2DhorizontalEnum)
    159                         iomodel->FetchDataToInput(elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum); // required for updating active nodes
    160         }
    161 
    162         /*Free data: */
    163         iomodel->DeleteData(1,"md.flowequation.element_equation");
     166                        iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum); // required for updating active nodes
     167        }
     168
    164169}/*}}}*/
    165170void StressbalanceSIAAnalysis::UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
    … …  
    321326        IssmDouble  gravity    = element->FindParam(ConstantsGEnum);
    322327        IssmDouble  B,n;
    323         Input* B_input         = element->GetInput(MaterialsRheologyBbarEnum);_assert_(B_input);
    324         Input* n_input         = element->GetInput(MaterialsRheologyNEnum);   _assert_(n_input);
    325         Input* slopex_input    = element->GetInput(SurfaceSlopeXEnum);        _assert_(slopex_input);
    326         Input* slopey_input    = element->GetInput(SurfaceSlopeYEnum);        _assert_(slopey_input);
    327         Input* thickness_input = element->GetInput(ThicknessEnum);            _assert_(thickness_input);
    328         Input* surface_input   = element->GetInput(SurfaceEnum);              _assert_(surface_input);
    329         Input* drag_input      = NULL;
     328        Input2* B_input         = element->GetInput2(MaterialsRheologyBbarEnum);_assert_(B_input);
     329        Input2* n_input         = element->GetInput2(MaterialsRheologyNEnum);   _assert_(n_input);
     330        Input2* slopex_input    = element->GetInput2(SurfaceSlopeXEnum);        _assert_(slopex_input);
     331        Input2* slopey_input    = element->GetInput2(SurfaceSlopeYEnum);        _assert_(slopey_input);
     332        Input2* thickness_input = element->GetInput2(ThicknessEnum);            _assert_(thickness_input);
     333        Input2* surface_input   = element->GetInput2(SurfaceEnum);              _assert_(surface_input);
     334        Input2* drag_input      = NULL;
    330335        if(frictionlaw!=5 && frictionlaw!=1){
    331                 drag_input = element->GetInput(FrictionCoefficientEnum);  _assert_(drag_input);
     336                drag_input = element->GetInput2(FrictionCoefficientEnum);  _assert_(drag_input);
    332337        }
    333338
    … …  
    411416        IssmDouble  gravity    = element->FindParam(ConstantsGEnum);
    412417        IssmDouble B,n;
    413         Input* B_input         = element->GetInput(MaterialsRheologyBEnum);   _assert_(B_input);
    414         Input* n_input         = element->GetInput(MaterialsRheologyNEnum);   _assert_(n_input);
    415         Input* surface_input   = element->GetInput(SurfaceEnum);              _assert_(surface_input);
    416         Input* slopex_input    = element->GetInput(SurfaceSlopeXEnum);        _assert_(slopex_input);
    417         Input* slopey_input    = element->GetInput(SurfaceSlopeYEnum);        _assert_(slopey_input);
    418         Input* thickness_input = element->GetInput(ThicknessEnum);            _assert_(thickness_input);
    419         Input* drag_input      = NULL;
     418        Input2* B_input         = element->GetInput2(MaterialsRheologyBEnum);   _assert_(B_input);
     419        Input2* n_input         = element->GetInput2(MaterialsRheologyNEnum);   _assert_(n_input);
     420        Input2* surface_input   = element->GetInput2(SurfaceEnum);              _assert_(surface_input);
     421        Input2* slopex_input    = element->GetInput2(SurfaceSlopeXEnum);        _assert_(slopex_input);
     422        Input2* slopey_input    = element->GetInput2(SurfaceSlopeYEnum);        _assert_(slopey_input);
     423        Input2* thickness_input = element->GetInput2(ThicknessEnum);            _assert_(thickness_input);
     424        Input2* drag_input      = NULL;
    420425        Friction* friction     = NULL;
    421426        if(frictionlaw!=5 && frictionlaw!=1){
    422                 drag_input = element->GetInput(FrictionCoefficientEnum);  _assert_(drag_input);
     427                drag_input = element->GetInput2(FrictionCoefficientEnum);  _assert_(drag_input);
    423428        }
    424429        else if(frictionlaw==5){
    … …  
    530535        /*Get dof list and inputs */
    531536        element->GetDofList(&doflist,NoneApproximationEnum,GsetEnum);
    532         Input* vx_input=element->GetInput(VxEnum); _assert_(vx_input);
    533         Input* vy_input=element->GetInput(VyEnum); _assert_(vy_input);
     537        Input2* vx_input=element->GetInput2(VxEnum); _assert_(vx_input);
     538        Input2* vy_input=element->GetInput2(VyEnum); _assert_(vy_input);
    534539
    535540        /*Ok, we have the velocities in inputs, fill in solution */
    … …  
    617622
    618623        /*Add vx and vy as inputs to the tria element: */
    619         element->AddInput(VxEnum,vx,P1Enum);
    620         element->AddInput(VyEnum,vy,P1Enum);
    621         element->AddInput(VelEnum,vel,P1Enum);
    622         element->AddInput(PressureEnum,pressure,P1Enum);
     624        element->AddInput2(VxEnum,vx,P1Enum);
     625        element->AddInput2(VyEnum,vy,P1Enum);
     626        element->AddInput2(VelEnum,vel,P1Enum);
     627        element->AddInput2(PressureEnum,pressure,P1Enum);
    623628
    624629        /*Free ressources:*/

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

    r23585 r24335  
    1717                void CreateNodes(Nodes* nodes,IoModel* iomodel,bool isamr=false);
    1818                int  DofsPerNode(int** doflist,int domaintype,int approximation);
    19                 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
     19                void UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type);
    2020                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    2121

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

    r24145 r24335  
    8686        return 1;
    8787}/*}}}*/
    88 void StressbalanceVerticalAnalysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
     88void StressbalanceVerticalAnalysis::UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
    8989
    9090        /*return if not 3d mesh*/
    … …  
    9696                if(iomodel->my_elements[i]){
    9797                        Element* element=(Element*)elements->GetObjectByOffset(counter);
    98                         element->Update(i,iomodel,analysis_counter,analysis_type,P1Enum);
     98                        element->Update(inputs2,i,iomodel,analysis_counter,analysis_type,P1Enum);
    9999                        counter++;
    100100                }
    101101        }
    102102
    103         iomodel->FetchDataToInput(elements,"md.geometry.thickness",ThicknessEnum);
    104         iomodel->FetchDataToInput(elements,"md.geometry.surface",SurfaceEnum);
    105         iomodel->FetchDataToInput(elements,"md.geometry.base",BaseEnum);
    106         iomodel->FetchDataToInput(elements,"md.slr.sealevel",SealevelEnum,0);
    107         iomodel->FetchDataToInput(elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
     103        iomodel->FetchDataToInput(inputs2,elements,"md.geometry.thickness",ThicknessEnum);
     104        iomodel->FetchDataToInput(inputs2,elements,"md.geometry.surface",SurfaceEnum);
     105        iomodel->FetchDataToInput(inputs2,elements,"md.geometry.base",BaseEnum);
     106        iomodel->FetchDataToInput(inputs2,elements,"md.slr.sealevel",SealevelEnum,0);
     107        iomodel->FetchDataToInput(inputs2,elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
    108108        if(iomodel->domaintype!=Domain2DhorizontalEnum){
    109                 iomodel->FetchDataToInput(elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum);
    110                 iomodel->FetchDataToInput(elements,"md.mesh.vertexonsurface",MeshVertexonsurfaceEnum);
    111         }
    112         iomodel->FetchDataToInput(elements,"md.basalforcings.groundedice_melting_rate",BasalforcingsGroundediceMeltingRateEnum);
    113         //iomodel->FetchDataToInput(elements,"md.smb.mass_balance",SmbMassBalanceEnum);
     109                iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum);
     110                iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonsurface",MeshVertexonsurfaceEnum);
     111        }
     112        iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.groundedice_melting_rate",BasalforcingsGroundediceMeltingRateEnum);
     113        //iomodel->FetchDataToInput(inputs2,elements,"md.smb.mass_balance",SmbMassBalanceEnum);
    114114
    115115
    … …  
    119119        switch(basalforcing_model){
    120120                case FloatingMeltRateEnum:
    121                         iomodel->FetchDataToInput(elements,"md.basalforcings.floatingice_melting_rate",BasalforcingsFloatingiceMeltingRateEnum);
     121                        iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.floatingice_melting_rate",BasalforcingsFloatingiceMeltingRateEnum);
    122122                        break;
    123123                case LinearFloatingMeltRateEnum:
    … …  
    128128                        break;
    129129                case SpatialLinearFloatingMeltRateEnum:
    130                         iomodel->FetchDataToInput(elements,"md.basalforcings.deepwater_melting_rate",BasalforcingsDeepwaterMeltingRateEnum);
    131                         iomodel->FetchDataToInput(elements,"md.basalforcings.deepwater_elevation",BasalforcingsDeepwaterElevationEnum);
    132                         iomodel->FetchDataToInput(elements,"md.basalforcings.upperwater_elevation",BasalforcingsUpperwaterElevationEnum);
     130                        iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.deepwater_melting_rate",BasalforcingsDeepwaterMeltingRateEnum);
     131                        iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.deepwater_elevation",BasalforcingsDeepwaterElevationEnum);
     132                        iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.upperwater_elevation",BasalforcingsUpperwaterElevationEnum);
    133133                        break;
    134134                case BasalforcingsPicoEnum:
    135                         iomodel->FetchDataToInput(elements,"md.basalforcings.basin_id",BasalforcingsPicoBasinIdEnum);
     135                        iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.basin_id",BasalforcingsPicoBasinIdEnum);
    136136                        break;
    137137                case BasalforcingsIsmip6Enum:
    138                         iomodel->FetchDataToInput(elements,"md.basalforcings.basin_id",BasalforcingsIsmip6BasinIdEnum);
     138                        iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.basin_id",BasalforcingsIsmip6BasinIdEnum);
    139139                        break;
    140140                case BeckmannGoosseFloatingMeltRateEnum:
    141                         iomodel->FetchDataToInput(elements,"md.basalforcings.ocean_salinity",BasalforcingsOceanSalinityEnum);
    142                         iomodel->FetchDataToInput(elements,"md.basalforcings.ocean_temp",BasalforcingsOceanTempEnum);
     141                        iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.ocean_salinity",BasalforcingsOceanSalinityEnum);
     142                        iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.ocean_temp",BasalforcingsOceanTempEnum);
    143143                        break;
    144144                default:
    145145                        _error_("Basal forcing model "<<EnumToStringx(basalforcing_model)<<" not supported yet");
    146146        }
    147         iomodel->FetchDataToInput(elements,"md.initialization.vx",VxEnum,0.);
    148         iomodel->FetchDataToInput(elements,"md.initialization.vy",VyEnum,0.);
     147        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.vx",VxEnum,0.);
     148        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.vy",VyEnum,0.);
    149149}/*}}}*/
    150150void StressbalanceVerticalAnalysis::UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
    … …  
    353353        element->GetVerticesCoordinatesBase(&xyz_list_base);
    354354        element->GetInputValue(&approximation,ApproximationEnum);
    355         Input* base_input=element->GetInput(BaseEnum);                                               _assert_(base_input);
    356         Input* groundedice_input=element->GetInput(MaskGroundediceLevelsetEnum);                     _assert_(groundedice_input);
    357         Input* groundedice_melting_input=element->GetInput(BasalforcingsGroundediceMeltingRateEnum); _assert_(groundedice_melting_input);
    358         Input* floatingice_melting_input=element->GetInput(BasalforcingsFloatingiceMeltingRateEnum); _assert_(floatingice_melting_input);
    359         Input* vx_input=element->GetInput(VxEnum);                                                   _assert_(vx_input);
    360         Input* vy_input=element->GetInput(VyEnum);                                                   _assert_(vy_input);
    361         Input* vzFS_input=NULL;
     355        Input2* base_input=element->GetInput2(BaseEnum);                                               _assert_(base_input);
     356        Input2* groundedice_input=element->GetInput2(MaskGroundediceLevelsetEnum);                     _assert_(groundedice_input);
     357        Input2* groundedice_melting_input=element->GetInput2(BasalforcingsGroundediceMeltingRateEnum); _assert_(groundedice_melting_input);
     358        Input2* floatingice_melting_input=element->GetInput2(BasalforcingsFloatingiceMeltingRateEnum); _assert_(floatingice_melting_input);
     359        Input2* vx_input=element->GetInput2(VxEnum);                                                   _assert_(vx_input);
     360        Input2* vy_input=element->GetInput2(VyEnum);                                                   _assert_(vy_input);
     361        Input2* vzFS_input=NULL;
    362362        if(approximation==HOFSApproximationEnum || approximation==SSAFSApproximationEnum){
    363                 vzFS_input=element->GetInput(VzFSEnum);       _assert_(vzFS_input);
     363                vzFS_input=element->GetInput2(VzFSEnum);       _assert_(vzFS_input);
    364364        }
    365365
    … …  
    419419        element->GetVerticesCoordinatesTop(&xyz_list_surface);
    420420        element->GetInputValue(&approximation,ApproximationEnum);
    421         Input* surface_input    =element->GetInput(SurfaceEnum);               _assert_(surface_input);
    422         Input* smb_input=element->GetInput(SmbMassBalanceEnum);    _assert_(smb_input);
    423         Input* vx_input=element->GetInput(VxEnum);                             _assert_(vx_input);
    424         Input* vy_input=element->GetInput(VyEnum);                             _assert_(vy_input);
    425         Input* vzFS_input=NULL;
     421        Input2* surface_input    =element->GetInput2(SurfaceEnum);   _assert_(surface_input);
     422        Input2* smb_input=element->GetInput2(SmbMassBalanceEnum);    _assert_(smb_input);
     423        Input2* vx_input=element->GetInput2(VxEnum);                 _assert_(vx_input);
     424        Input2* vy_input=element->GetInput2(VyEnum);                 _assert_(vy_input);
     425        Input2* vzFS_input=NULL;
    426426        if(approximation==HOFSApproximationEnum || approximation==SSAFSApproximationEnum){
    427                 vzFS_input=element->GetInput(VzFSEnum);      _assert_(vzFS_input);
     427                vzFS_input=element->GetInput2(VzFSEnum); _assert_(vzFS_input);
    428428        }
    429429
    … …  
    474474        element->GetVerticesCoordinates(&xyz_list);
    475475        element->GetInputValue(&approximation,ApproximationEnum);
    476         Input* vx_input=element->GetInput(VxEnum); _assert_(vx_input);
    477         Input* vy_input=element->GetInput(VyEnum); _assert_(vy_input);
    478         Input* vzFS_input=NULL;
     476        Input2* vx_input=element->GetInput2(VxEnum); _assert_(vx_input);
     477        Input2* vy_input=element->GetInput2(VyEnum); _assert_(vy_input);
     478        Input2* vzFS_input=NULL;
    479479        if(approximation==HOFSApproximationEnum || approximation==SSAFSApproximationEnum){
    480                 vzFS_input=element->GetInput(VzFSEnum); _assert_(vzFS_input);
     480                vzFS_input=element->GetInput2(VzFSEnum); _assert_(vzFS_input);
    481481        }
    482482
    … …  
    561561        /*Do some modifications if we actually have a HOFS or SSAFS element*/
    562562        if(approximation==HOFSApproximationEnum){
    563                 Input* vzFS_input=element->GetInput(VzFSEnum);
     563                Input2* vzFS_input=element->GetInput2(VzFSEnum);
    564564                if (vzFS_input){
    565                         if (vzFS_input->ObjectEnum()!=PentaInputEnum) _error_("Cannot compute Vel as VzFS is of type " << EnumToStringx(vzFS_input->ObjectEnum()));
     565                        if (vzFS_input->ObjectEnum()!=PentaInput2Enum) _error_("Cannot compute Vel as VzFS is of type " << EnumToStringx(vzFS_input->ObjectEnum()));
    566566                        element->GetInputListOnNodes(&vzFS[0],VzFSEnum,0.);
    567567                }
    … …  
    573573        }
    574574        else if(approximation==SSAFSApproximationEnum){
    575                 Input* vzFS_input=element->GetInput(VzFSEnum);
     575                Input2* vzFS_input=element->GetInput2(VzFSEnum);
    576576                if (vzFS_input){
    577                         if (vzFS_input->ObjectEnum()!=PentaInputEnum) _error_("Cannot compute Vel as VzFS is of type " << EnumToStringx(vzFS_input->ObjectEnum()));
     577                        if (vzFS_input->ObjectEnum()!=PentaInput2Enum) _error_("Cannot compute Vel as VzFS is of type " << EnumToStringx(vzFS_input->ObjectEnum()));
    578578                        element->GetInputListOnNodes(&vzFS[0],VzFSEnum,0.);
    579579                }
    … …  
    597597        }
    598598        if(approximation!=HOFSApproximationEnum && approximation!=SSAFSApproximationEnum){
    599                 element->AddInput(PressureEnum,pressure,element->GetElementType());
     599                element->AddInput2(PressureEnum,pressure,element->GetElementType());
    600600        }
    601601        else if(approximation==HOFSApproximationEnum){
    602                 element->AddInput(VzHOEnum,vzHO,P1Enum);
     602                element->AddInput2(VzHOEnum,vzHO,P1Enum);
    603603        }
    604604        else if(approximation==SSAFSApproximationEnum){
    605                 element->AddInput(VzSSAEnum,vzSSA,P1Enum);
    606         }
    607         element->AddInput(VzEnum,vz,P1Enum);
    608         element->AddInput(VelEnum,vel,P1Enum);
     605                element->AddInput2(VzSSAEnum,vzSSA,P1Enum);
     606        }
     607        element->AddInput2(VzEnum,vz,P1Enum);
     608        element->AddInput2(VelEnum,vel,P1Enum);
    609609
    610610        /*Free ressources:*/

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

    r23585 r24335  
    1717                void CreateNodes(Nodes* nodes,IoModel* iomodel,bool isamr=false);
    1818                int  DofsPerNode(int** doflist,int domaintype,int approximation);
    19                 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
     19                void UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type);
    2020                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    2121

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

    r24136 r24335  
    104104        return 1;
    105105}/*}}}*/
    106 void ThermalAnalysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
     106void ThermalAnalysis::UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
    107107
    108108        int frictionlaw,basalforcing_model,materialstype;
    … …  
    119119                if(iomodel->my_elements[i]){
    120120                        Element* element=(Element*)elements->GetObjectByOffset(counter);
    121                         element->Update(i,iomodel,analysis_counter,analysis_type,finiteelement);
     121                        element->Update(inputs2,i,iomodel,analysis_counter,analysis_type,finiteelement);
    122122                        counter++;
    123123                }
    … …  
    130130        iomodel->FindConstant(&materialstype,"md.materials.type");
    131131
    132         iomodel->FetchDataToInput(elements,"md.geometry.thickness",ThicknessEnum);
    133         iomodel->FetchDataToInput(elements,"md.geometry.surface",SurfaceEnum);
    134         iomodel->FetchDataToInput(elements,"md.geometry.base",BaseEnum);
    135         iomodel->FetchDataToInput(elements,"md.slr.sealevel",SealevelEnum,0);
    136         iomodel->FetchDataToInput(elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
    137         iomodel->FetchDataToInput(elements,"md.mask.groundedice_levelset",MaskGroundediceLevelsetEnum);
     132        iomodel->FetchDataToInput(inputs2,elements,"md.geometry.thickness",ThicknessEnum);
     133        iomodel->FetchDataToInput(inputs2,elements,"md.geometry.surface",SurfaceEnum);
     134        iomodel->FetchDataToInput(inputs2,elements,"md.geometry.base",BaseEnum);
     135        iomodel->FetchDataToInput(inputs2,elements,"md.slr.sealevel",SealevelEnum,0);
     136        iomodel->FetchDataToInput(inputs2,elements,"md.mask.ice_levelset",MaskIceLevelsetEnum);
     137        iomodel->FetchDataToInput(inputs2,elements,"md.mask.groundedice_levelset",MaskGroundediceLevelsetEnum);
    138138        if(iomodel->domaintype!=Domain2DhorizontalEnum){
    139                 iomodel->FetchDataToInput(elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum);
    140                 iomodel->FetchDataToInput(elements,"md.mesh.vertexonsurface",MeshVertexonsurfaceEnum);
    141         }
    142         iomodel->FetchDataToInput(elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum);
    143         iomodel->FetchDataToInput(elements,"md.mesh.vertexonsurface",MeshVertexonsurfaceEnum);
    144         iomodel->FetchDataToInput(elements,"md.initialization.pressure",PressureEnum);
    145         iomodel->FetchDataToInput(elements,"md.initialization.temperature",TemperatureEnum);
    146         iomodel->FetchDataToInput(elements,"md.initialization.vx",VxEnum);
    147         iomodel->FetchDataToInput(elements,"md.initialization.vy",VyEnum);
    148         iomodel->FetchDataToInput(elements,"md.initialization.vz",VzEnum);
    149         InputUpdateFromConstantx(elements,0.,VxMeshEnum);
    150         InputUpdateFromConstantx(elements,0.,VyMeshEnum);
    151         InputUpdateFromConstantx(elements,0.,VzMeshEnum);
     139                iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum);
     140                iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonsurface",MeshVertexonsurfaceEnum);
     141        }
     142        iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum);
     143        iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonsurface",MeshVertexonsurfaceEnum);
     144        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.pressure",PressureEnum);
     145        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.temperature",TemperatureEnum);
     146        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.vx",VxEnum);
     147        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.vy",VyEnum);
     148        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.vz",VzEnum);
     149        InputUpdateFromConstantx(inputs2,elements,0.,VxMeshEnum);
     150        InputUpdateFromConstantx(inputs2,elements,0.,VyMeshEnum);
     151        InputUpdateFromConstantx(inputs2,elements,0.,VzMeshEnum);
    152152
    153153        /*Rheology type*/
    154         iomodel->FetchDataToInput(elements,"md.materials.rheology_B",MaterialsRheologyBEnum);
     154        iomodel->FetchDataToInput(inputs2,elements,"md.materials.rheology_B",MaterialsRheologyBEnum);
    155155        switch(materialstype){
    156156                case MatenhancediceEnum:
    157                         iomodel->FetchDataToInput(elements,"md.materials.rheology_n",MaterialsRheologyNEnum);
    158                         iomodel->FetchDataToInput(elements,"md.materials.rheology_E",MaterialsRheologyEEnum);
     157                        iomodel->FetchDataToInput(inputs2,elements,"md.materials.rheology_n",MaterialsRheologyNEnum);
     158                        iomodel->FetchDataToInput(inputs2,elements,"md.materials.rheology_E",MaterialsRheologyEEnum);
    159159                        break;
    160160                case MatdamageiceEnum:
    161                         iomodel->FetchDataToInput(elements,"md.materials.rheology_n",MaterialsRheologyNEnum);
     161                        iomodel->FetchDataToInput(inputs2,elements,"md.materials.rheology_n",MaterialsRheologyNEnum);
    162162                        break;
    163163                case MatestarEnum:
    164                         iomodel->FetchDataToInput(elements,"md.materials.rheology_Ec",MaterialsRheologyEcEnum);
    165                         iomodel->FetchDataToInput(elements,"md.materials.rheology_Es",MaterialsRheologyEsEnum);
     164                        iomodel->FetchDataToInput(inputs2,elements,"md.materials.rheology_Ec",MaterialsRheologyEcEnum);
     165                        iomodel->FetchDataToInput(inputs2,elements,"md.materials.rheology_Es",MaterialsRheologyEsEnum);
    166166                        break;
    167167                case MaticeEnum:
    168                         iomodel->FetchDataToInput(elements,"md.materials.rheology_n",MaterialsRheologyNEnum);
     168                        iomodel->FetchDataToInput(inputs2,elements,"md.materials.rheology_n",MaterialsRheologyNEnum);
    169169                        break;
    170170                default:
    … …  
    172172        }
    173173        if(ismovingfront){
    174                 iomodel->FetchDataToInput(elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum); // required for updating active nodes
     174                iomodel->FetchDataToInput(inputs2,elements,"md.mesh.vertexonbase",MeshVertexonbaseEnum); // required for updating active nodes
    175175        }
    176176        /*Basal forcings variables*/
    … …  
    180180                        break;
    181181                default:
    182                         iomodel->FetchDataToInput(elements,"md.basalforcings.geothermalflux",BasalforcingsGeothermalfluxEnum);
     182                        iomodel->FetchDataToInput(inputs2,elements,"md.basalforcings.geothermalflux",BasalforcingsGeothermalfluxEnum);
    183183                        break;
    184184        }
    … …  
    187187                case 1:
    188188                        iomodel->FindConstant(&FrictionCoupling,"md.friction.coupling");
    189                         iomodel->FetchDataToInput(elements,"md.friction.coefficient",FrictionCoefficientEnum);
    190                         iomodel->FetchDataToInput(elements,"md.friction.p",FrictionPEnum);
    191                         iomodel->FetchDataToInput(elements,"md.friction.q",FrictionQEnum);
     189                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.coefficient",FrictionCoefficientEnum);
     190                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.p",FrictionPEnum);
     191                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.q",FrictionQEnum);
    192192                        if (FrictionCoupling==3){
    193                                 iomodel->FetchDataToInput(elements,"md.friction.effective_pressure",FrictionEffectivePressureEnum);}
     193                                iomodel->FetchDataToInput(inputs2,elements,"md.friction.effective_pressure",FrictionEffectivePressureEnum);}
    194194                        else if(FrictionCoupling==4){
    195                                 iomodel->FetchDataToInput(elements,"md.friction.effective_pressure",EffectivePressureEnum);
     195                                iomodel->FetchDataToInput(inputs2,elements,"md.friction.effective_pressure",EffectivePressureEnum);
    196196                        }
    197197                        break;
    198198                case 2:
    199                         iomodel->FetchDataToInput(elements,"md.friction.C",FrictionCEnum);
    200                         iomodel->FetchDataToInput(elements,"md.friction.m",FrictionMEnum);
     199                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.C",FrictionCEnum);
     200                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.m",FrictionMEnum);
    201201                        break;
    202202                case 3:
    203203                        iomodel->FindConstant(&FrictionCoupling,"md.friction.coupling");
    204                         iomodel->FetchDataToInput(elements,"md.friction.C",FrictionCEnum);
    205                         iomodel->FetchDataToInput(elements,"md.friction.As",FrictionAsEnum);
    206                         iomodel->FetchDataToInput(elements,"md.friction.q",FrictionQEnum);
     204                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.C",FrictionCEnum);
     205                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.As",FrictionAsEnum);
     206                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.q",FrictionQEnum);
    207207                        if (FrictionCoupling==3){
    208                                 iomodel->FetchDataToInput(elements,"md.friction.effective_pressure",FrictionEffectivePressureEnum);}
     208                                iomodel->FetchDataToInput(inputs2,elements,"md.friction.effective_pressure",FrictionEffectivePressureEnum);}
    209209                        else if(FrictionCoupling==4){
    210                                 iomodel->FetchDataToInput(elements,"md.friction.effective_pressure",EffectivePressureEnum);
     210                                iomodel->FetchDataToInput(inputs2,elements,"md.friction.effective_pressure",EffectivePressureEnum);
    211211                        }
    212212                        break;
    213213                case 4:
    214                         iomodel->FetchDataToInput(elements,"md.friction.coefficient",FrictionCoefficientEnum);
    215                         iomodel->FetchDataToInput(elements,"md.friction.p",FrictionPEnum);
    216                         iomodel->FetchDataToInput(elements,"md.friction.q",FrictionQEnum);
    217                         iomodel->FetchDataToInput(elements,"md.initialization.pressure",PressureEnum);
    218                         iomodel->FetchDataToInput(elements,"md.initialization.temperature",TemperatureEnum);
     214                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.coefficient",FrictionCoefficientEnum);
     215                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.p",FrictionPEnum);
     216                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.q",FrictionQEnum);
     217                        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.pressure",PressureEnum);
     218                        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.temperature",TemperatureEnum);
    219219                        iomodel->FindConstant(&FrictionCoupling,"md.friction.coupling");
    220220                        break;
    221221                case 5:
    222                         iomodel->FetchDataToInput(elements,"md.friction.coefficient",FrictionCoefficientEnum);
    223                         iomodel->FetchDataToInput(elements,"md.friction.p",FrictionPEnum);
    224                         iomodel->FetchDataToInput(elements,"md.friction.q",FrictionQEnum);
    225                         iomodel->FetchDataToInput(elements,"md.friction.water_layer",FrictionWaterLayerEnum);
     222                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.coefficient",FrictionCoefficientEnum);
     223                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.p",FrictionPEnum);
     224                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.q",FrictionQEnum);
     225                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.water_layer",FrictionWaterLayerEnum);
    226226                        break;
    227227                case 6:
    228                         iomodel->FetchDataToInput(elements,"md.friction.C",FrictionCEnum);
    229                         iomodel->FetchDataToInput(elements,"md.friction.m",FrictionMEnum);
    230                         iomodel->FetchDataToInput(elements,"md.initialization.pressure",PressureEnum);
    231                         iomodel->FetchDataToInput(elements,"md.initialization.temperature",TemperatureEnum);
     228                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.C",FrictionCEnum);
     229                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.m",FrictionMEnum);
     230                        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.pressure",PressureEnum);
     231                        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.temperature",TemperatureEnum);
    232232                        break;
    233233                case 7:
    234234                        iomodel->FindConstant(&FrictionCoupling,"md.friction.coupling");
    235                         iomodel->FetchDataToInput(elements,"md.friction.coefficient",FrictionCoefficientEnum);
    236                         iomodel->FetchDataToInput(elements,"md.friction.coefficientcoulomb",FrictionCoefficientcoulombEnum);
    237                         iomodel->FetchDataToInput(elements,"md.friction.p",FrictionPEnum);
    238                         iomodel->FetchDataToInput(elements,"md.friction.q",FrictionQEnum);
     235                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.coefficient",FrictionCoefficientEnum);
     236                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.coefficientcoulomb",FrictionCoefficientcoulombEnum);
     237                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.p",FrictionPEnum);
     238                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.q",FrictionQEnum);
    239239                        if (FrictionCoupling==3){
    240                                 iomodel->FetchDataToInput(elements,"md.friction.effective_pressure",FrictionEffectivePressureEnum);}
     240                                iomodel->FetchDataToInput(inputs2,elements,"md.friction.effective_pressure",FrictionEffectivePressureEnum);}
    241241                        else if(FrictionCoupling==4){
    242                                 iomodel->FetchDataToInput(elements,"md.friction.effective_pressure",EffectivePressureEnum);
     242                                iomodel->FetchDataToInput(inputs2,elements,"md.friction.effective_pressure",EffectivePressureEnum);
    243243                        }
    244244                        break;
    245245                case 9:
    246                         iomodel->FetchDataToInput(elements,"md.friction.coefficient",FrictionCoefficientEnum);
    247                         iomodel->FetchDataToInput(elements,"md.friction.pressure_adjusted_temperature",FrictionPressureAdjustedTemperatureEnum);
    248                         InputUpdateFromConstantx(elements,1.,FrictionPEnum);
    249                         InputUpdateFromConstantx(elements,1.,FrictionQEnum);
     246                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.coefficient",FrictionCoefficientEnum);
     247                        iomodel->FetchDataToInput(inputs2,elements,"md.friction.pressure_adjusted_temperature",FrictionPressureAdjustedTemperatureEnum);
     248                        InputUpdateFromConstantx(inputs2,elements,1.,FrictionPEnum);
     249                        InputUpdateFromConstantx(inputs2,elements,1.,FrictionQEnum);
    250250                        break;
    251251                default:
    … …  
    338338        element->GetVerticesCoordinatesBase(&xyz_list_base);
    339339        element->FindParam(&dt,TimesteppingTimeStepEnum);
    340         IssmDouble  gravity             = element->FindParam(ConstantsGEnum);
    341         IssmDouble  rho_water           = element->FindParam(MaterialsRhoSeawaterEnum);
    342         IssmDouble  rho_ice             = element->FindParam(MaterialsRhoIceEnum);
    343         IssmDouble  heatcapacity        = element->FindParam(MaterialsHeatcapacityEnum);
    344         IssmDouble  mixed_layer_capacity= element->FindParam(MaterialsMixedLayerCapacityEnum);
    345         IssmDouble  thermal_exchange_vel= element->FindParam(MaterialsThermalExchangeVelocityEnum);
     340        IssmDouble gravity             = element->FindParam(ConstantsGEnum);
     341        IssmDouble rho_water           = element->FindParam(MaterialsRhoSeawaterEnum);
     342        IssmDouble rho_ice             = element->FindParam(MaterialsRhoIceEnum);
     343        IssmDouble heatcapacity        = element->FindParam(MaterialsHeatcapacityEnum);
     344        IssmDouble mixed_layer_capacity= element->FindParam(MaterialsMixedLayerCapacityEnum);
     345        IssmDouble thermal_exchange_vel= element->FindParam(MaterialsThermalExchangeVelocityEnum);
    346346
    347347        /* Start  looping on the number of gaussian points: */
    … …  
    401401        IssmDouble  thermalconductivity = element->FindParam(MaterialsThermalconductivityEnum);
    402402        IssmDouble  kappa = thermalconductivity/(rho_ice*heatcapacity);
    403         Input* vx_input  = element->GetInput(VxEnum);     _assert_(vx_input);
    404         Input* vy_input  = element->GetInput(VyEnum);     _assert_(vy_input);
    405         Input* vz_input  = element->GetInput(VzEnum);     _assert_(vz_input);
    406         Input* vxm_input = element->GetInput(VxMeshEnum); _assert_(vxm_input);
    407         Input* vym_input = element->GetInput(VyMeshEnum); _assert_(vym_input);
    408         Input* vzm_input = element->GetInput(VzMeshEnum); _assert_(vzm_input);
     403        Input2* vx_input  = element->GetInput2(VxEnum);     _assert_(vx_input);
     404        Input2* vy_input  = element->GetInput2(VyEnum);     _assert_(vy_input);
     405        Input2* vz_input  = element->GetInput2(VzEnum);     _assert_(vz_input);
     406        Input2* vxm_input = element->GetInput2(VxMeshEnum); _assert_(vxm_input);
     407        Input2* vym_input = element->GetInput2(VyMeshEnum); _assert_(vym_input);
     408        Input2* vzm_input = element->GetInput2(VzMeshEnum); _assert_(vzm_input);
    409409
    410410        /* Start  looping on the number of gaussian points: */
    … …  
    551551        element->GetVerticesCoordinatesBase(&xyz_list_base);
    552552        element->FindParam(&dt,TimesteppingTimeStepEnum);
    553         Input* vx_input             = element->GetInput(VxEnum);                          _assert_(vx_input);
    554         Input* vy_input             = element->GetInput(VyEnum);                          _assert_(vy_input);
    555         Input* vz_input             = element->GetInput(VzEnum);                          _assert_(vz_input);
    556         Input* geothermalflux_input = element->GetInput(BasalforcingsGeothermalfluxEnum); _assert_(geothermalflux_input);
     553        Input2* vx_input             = element->GetInput2(VxEnum);                          _assert_(vx_input);
     554        Input2* vy_input             = element->GetInput2(VyEnum);                          _assert_(vy_input);
     555        Input2* vz_input             = element->GetInput2(VzEnum);                          _assert_(vz_input);
     556        Input2* geothermalflux_input = element->GetInput2(BasalforcingsGeothermalfluxEnum); _assert_(geothermalflux_input);
    557557        IssmDouble  rho_ice             = element->FindParam(MaterialsRhoIceEnum);
    558558        IssmDouble  heatcapacity        = element->FindParam(MaterialsHeatcapacityEnum);
    … …  
    612612        element->GetVerticesCoordinatesBase(&xyz_list_base);
    613613        element->FindParam(&dt,TimesteppingTimeStepEnum);
    614         Input*      pressure_input=element->GetInput(PressureEnum); _assert_(pressure_input);
     614        Input2*      pressure_input=element->GetInput2(PressureEnum); _assert_(pressure_input);
    615615        IssmDouble  gravity             = element->FindParam(ConstantsGEnum);
    616616        IssmDouble  rho_water           = element->FindParam(MaterialsRhoSeawaterEnum);
    … …  
    674674        element->FindParam(&dt,TimesteppingTimeStepEnum);
    675675        element->FindParam(&stabilization,ThermalStabilizationEnum);
    676         Input* vx_input=element->GetInput(VxEnum); _assert_(vx_input);
    677         Input* vy_input=element->GetInput(VyEnum); _assert_(vy_input);
    678         Input* vz_input=element->GetInput(VzEnum); _assert_(vz_input);
    679         Input* temperature_input = NULL;
    680         if(reCast<bool,IssmDouble>(dt)){temperature_input = element->GetInput(TemperatureEnum); _assert_(temperature_input);}
     676        Input2* vx_input=element->GetInput2(VxEnum); _assert_(vx_input);
     677        Input2* vy_input=element->GetInput2(VyEnum); _assert_(vy_input);
     678        Input2* vz_input=element->GetInput2(VzEnum); _assert_(vz_input);
     679        Input2* temperature_input = NULL;
     680        if(reCast<bool,IssmDouble>(dt)){temperature_input = element->GetInput2(TemperatureEnum); _assert_(temperature_input);}
    681681
    682682        /* Start  looping on the number of gaussian points: */
    … …  
    873873        element->GetInputValue(&converged,ConvergedEnum);
    874874        if(converged){
    875                 element->AddInput(TemperatureEnum,values,element->GetElementType());
     875                element->AddInput2(TemperatureEnum,values,element->GetElementType());
    876876
    877877                IssmDouble* n = xNew<IssmDouble>(numnodes);
    … …  
    894894                        case BuddJackaEnum:
    895895                                for(i=0;i<numnodes;i++) B[i]=BuddJacka(values[i]);
    896                                 element->AddInput(MaterialsRheologyBEnum,&B[0],element->GetElementType());
     896                                element->AddInput2(MaterialsRheologyBEnum,&B[0],element->GetElementType());
    897897                                break;
    898898                        case CuffeyEnum:
    899899                                for(i=0;i<numnodes;i++) B[i]=Cuffey(values[i]);
    900                                 element->AddInput(MaterialsRheologyBEnum,&B[0],element->GetElementType());
     900                                element->AddInput2(MaterialsRheologyBEnum,&B[0],element->GetElementType());
    901901                                break;
    902902                        case PatersonEnum:
    903903                                for(i=0;i<numnodes;i++) B[i]=Paterson(values[i]);
    904                                 element->AddInput(MaterialsRheologyBEnum,&B[0],element->GetElementType());
     904                                element->AddInput2(MaterialsRheologyBEnum,&B[0],element->GetElementType());
    905905                                break;
    906906                        case NyeH2OEnum:
    907907                                for(i=0;i<numnodes;i++) B[i]=NyeH2O(values[i]);
    908                                 element->AddInput(MaterialsRheologyBEnum,&B[0],element->GetElementType());
     908                                element->AddInput2(MaterialsRheologyBEnum,&B[0],element->GetElementType());
    909909                                break;
    910910                        case NyeCO2Enum:
    911911                                for(i=0;i<numnodes;i++) B[i]=NyeCO2(values[i]);
    912                                 element->AddInput(MaterialsRheologyBEnum,&B[0],element->GetElementType());
     912                                element->AddInput2(MaterialsRheologyBEnum,&B[0],element->GetElementType());
    913913                                break;
    914914                        case ArrheniusEnum:{
    915915                                element->GetVerticesCoordinates(&xyz_list);
    916916                                for(i=0;i<numnodes;i++) B[i]=Arrhenius(values[i],surface[i]-xyz_list[i*3+2],n[i]);
    917                                 element->AddInput(MaterialsRheologyBEnum,&B[0],element->GetElementType());
     917                                element->AddInput2(MaterialsRheologyBEnum,&B[0],element->GetElementType());
    918918                                break;
    919919                                }
    … …  
    924924        }
    925925        else{
    926                 element->AddInput(TemperaturePicardEnum,values,element->GetElementType());
     926                element->AddInput2(TemperaturePicardEnum,values,element->GetElementType());
    927927        }
    928928

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

    r23585 r24335  
    1717                void CreateNodes(Nodes* nodes,IoModel* iomodel,bool isamr=false);
    1818                int  DofsPerNode(int** doflist,int domaintype,int approximation);
    19                 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
     19                void UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type);
    2020                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    2121

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

    r23629 r24335  
    2727        return 1;
    2828}/*}}}*/
    29 void UzawaPressureAnalysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
     29void UzawaPressureAnalysis::UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
    3030
    3131        /*Update elements: */
    … …  
    4242                if(iomodel->my_elements[i]){
    4343                        Element* element=(Element*)elements->GetObjectByOffset(counter);
    44                         element->Update(i,iomodel,analysis_counter,analysis_type,finiteelement);
     44                        element->Update(inputs2,i,iomodel,analysis_counter,analysis_type,finiteelement);
    4545                        counter++;
    4646                }
    4747        }
    4848
    49         iomodel->FetchDataToInput(elements,"md.initialization.vx",VxEnum,0.);
    50         iomodel->FetchDataToInput(elements,"md.initialization.vy",VyEnum,0.);
    51         if(iomodel->domaintype==Domain3DEnum) iomodel->FetchDataToInput(elements,"md.initialization.vz",VzEnum,0.);
    52         iomodel->FetchDataToInput(elements,"md.initialization.pressure",PressureEnum,0.);
    53         InputUpdateFromConstantx(elements,0.,SigmaNNEnum);
     49        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.vx",VxEnum,0.);
     50        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.vy",VyEnum,0.);
     51        if(iomodel->domaintype==Domain3DEnum) iomodel->FetchDataToInput(inputs2,elements,"md.initialization.vz",VzEnum,0.);
     52        iomodel->FetchDataToInput(inputs2,elements,"md.initialization.pressure",PressureEnum,0.);
     53        InputUpdateFromConstantx(inputs2,elements,0.,SigmaNNEnum);
    5454}/*}}}*/
    5555void UzawaPressureAnalysis::UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/
    … …  
    130130        IssmDouble*    dvz   = xNew<IssmDouble>(dim);
    131131
    132         Input* vx_input=element->GetInput(VxEnum);     _assert_(vx_input);
    133         Input* vy_input=element->GetInput(VyEnum);     _assert_(vy_input);
    134         Input* vz_input = NULL;
    135         if(dim==3){vz_input=element->GetInput(VzEnum); _assert_(vz_input);}
     132        Input2* vx_input=element->GetInput2(VxEnum);     _assert_(vx_input);
     133        Input2* vy_input=element->GetInput2(VyEnum);     _assert_(vy_input);
     134        Input2* vz_input = NULL;
     135        if(dim==3){vz_input=element->GetInput2(VzEnum); _assert_(vz_input);}
    136136
    137137        Gauss* gauss = element->NewGauss(5);
    … …  
    209209        IssmDouble* valueslambda  = xNewZeroInit<IssmDouble>(numnodessigma);
    210210        IssmDouble* pressure      = xNew<IssmDouble>(numnodes);
    211         Input* vx_input           = element->GetInput(VxEnum);      _assert_(vx_input);
    212         Input* vy_input           = element->GetInput(VyEnum);      _assert_(vy_input);
    213         Input* vz_input           = NULL;
    214         if(dim==3){vz_input       = element->GetInput(VzEnum);      _assert_(vz_input);}
     211        Input2* vx_input           = element->GetInput2(VxEnum);      _assert_(vx_input);
     212        Input2* vy_input           = element->GetInput2(VyEnum);      _assert_(vy_input);
     213        Input2* vz_input           = NULL;
     214        if(dim==3){vz_input       = element->GetInput2(VzEnum);      _assert_(vz_input);}
    215215        element->GetInputListOnNodes(&pressure[0],PressureEnum);
    216216
    … …  
    219219                values[i]  = pressure[i] + solution[doflist[i]];
    220220        }
    221         element->AddInput(PressureEnum,values,element->GetElementType());
     221        element->AddInput2(PressureEnum,values,element->GetElementType());
    222222
    223223        /*Now compute sigmann if on base*/
    224224        if(element->IsOnBase() && 0){
    225                 Input* sigmann_input      = element->GetInput(SigmaNNEnum); _assert_(sigmann_input);
     225                Input2* sigmann_input      = element->GetInput2(SigmaNNEnum); _assert_(sigmann_input);
    226226                if(dim==3) _error_("not implemented yet");
    227227
    … …  
    234234                IssmDouble  deltalambda[3] = {0.0};
    235235                IssmDouble* vertexonbase  = xNew<IssmDouble>(numnodessigma);
    236                 Input* vertexonbase_input = element->GetInput(MeshVertexonbaseEnum); _assert_(vertexonbase_input);
     236                Input2* vertexonbase_input = element->GetInput2(MeshVertexonbaseEnum); _assert_(vertexonbase_input);
    237237                Gauss* gauss = element->NewGauss();
    238238
    … …  
    288288                xDelete<IssmDouble>(basis);
    289289
    290                 element->AddInput(SigmaNNEnum,valueslambda,P2Enum);
     290                element->AddInput2(SigmaNNEnum,valueslambda,P2Enum);
    291291        }
    292292

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

    r23585 r24335  
    1717                void CreateNodes(Nodes* nodes,IoModel* iomodel,bool isamr=false);
    1818                int  DofsPerNode(int** doflist,int domaintype,int approximation);
    19                 void UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type);
     19                void UpdateElements(Elements* elements,Inputs2* inputs2,IoModel* iomodel,int analysis_counter,int analysis_type);
    2020                void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum);
    2121

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

    r23066 r24335  
    2222#include "../classes/Inputs/Input.h"
    2323#include "../classes/gauss/Gauss.h"
     24#include "./Inputs2/DatasetInput2.h"
    2425/*}}}*/
    2526
    … …  
    151152
    152153        /*Get input if it already exists*/
    153         Input*  tempinput = basalelement->GetInput(definitionenum);
    154         /*Cast it to a Datasetinput*/
    155         if(tempinput->ObjectEnum()!=DatasetInputEnum) _error_("don't know what to do! confused!");
    156         DatasetInput* datasetinput = (DatasetInput*)tempinput;
    157 
    158         /*Get the drag from the model*/
    159         Input* drag_input=basalelement->GetInput(FrictionCoefficientEnum);      _assert_(drag_input);
     154        DatasetInput2 *datasetinput = basalelement->GetDatasetInput2(definitionenum);  _assert_(datasetinput);
     155        Input2        *drag_input   = basalelement->GetInput2(FrictionCoefficientEnum); _assert_(drag_input);
    160156
    161157        /* Start  looping on the number of gaussian points: */

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

    r23066 r24335  
    2222#include "../classes/Inputs/Input.h"
    2323#include "../classes/gauss/Gauss.h"
     24#include "./Inputs2/DatasetInput2.h"
    2425/*}}}*/
    2526
    … …  
    162163
    163164        /*Get model values*/
    164         Input* vx_input     =topelement->GetInput(VxEnum);                                _assert_(vx_input);
    165         Input* vy_input   =NULL;
     165        Input2 *vx_input = topelement->GetInput2(VxEnum); _assert_(vx_input);
     166        Input2 *vy_input = NULL;
    166167        if(numcomponents==2){
    167               vy_input    =topelement->GetInput(VyEnum);                                                                      _assert_(vy_input);
     168              vy_input = topelement->GetInput2(VyEnum); _assert_(vy_input);
    168169        }
    169170
    170171        /*Retrieve all inputs we will be needing: */
    171         DatasetInput*    datasetinput = NULL;
    172         Input*  tempinput = topelement->GetInput(definitionenum);
    173         /*Cast it to a Datasetinput*/
    174         if(tempinput->ObjectEnum()!=DatasetInputEnum) _error_("don't know what to do");
    175         datasetinput = (DatasetInput*)tempinput;
     172        DatasetInput2 *datasetinput = topelement->GetDatasetInput2(definitionenum); _assert_(datasetinput);
    176173
    177174        /* Start  looping on the number of gaussian points: */

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

    r23066 r24335  
    2222#include "../classes/Inputs/Input.h"
    2323#include "../classes/gauss/Gauss.h"
     24#include "./Inputs2/DatasetInput2.h"
    2425/*}}}*/
    2526
    … …  
    167168
    168169        /*Retrieve all inputs we will be needing: */
    169 
    170         DatasetInput*    datasetinput = NULL;
    171 
    172         /*Get input if it already exists*/
    173         Input*  tempinput = topelement->GetInput(definitionenum);
    174 
    175         /*Cast it to a Datasetinput*/
    176         if(tempinput->ObjectEnum()!=DatasetInputEnum) _error_("don't know what to do");
    177         datasetinput = (DatasetInput*)tempinput;
    178 
    179         Input* model_input=topelement->GetInput(model_enum);                                                                                            _assert_(model_input);
    180         //Input* observation_input=topelement->GetInput(observation_enum);                                                              _assert_(observation_input);
    181         //Input* weights_input     =topelement->GetInput(weights_enum);                                                                 _assert_(weights_input);
     170        DatasetInput2 *datasetinput = topelement->GetDatasetInput2(definitionenum); _assert_(datasetinput);
     171        Input2        *model_input  = topelement->GetInput2(model_enum);            _assert_(model_input);
    182172
    183173        /* Start  looping on the number of gaussian points: */

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

    r24334 r24335  
    1515#include "../../shared/shared.h"
    1616#include "../../modules/SurfaceMassBalancex/SurfaceMassBalancex.h"
     17#include "../Inputs2/BoolInput2.h"
     18#include "../Inputs2/TransientInput2.h"
     19#include "../Inputs2/ElementInput2.h"
     20#include "../Inputs2/DatasetInput2.h"
     21#include "../Inputs2/ArrayInput2.h"
    1722/*}}}*/
    1823
    … …  
    2833        this->id  = -1;
    2934        this->sid = -1;
     35        this->lid = -1;
    3036        this->inputs     = NULL;
     37        this->inputs2    = NULL;
    3138        this->nodes      = NULL;
    3239        this->vertices   = NULL;
    … …  
    6067        this->GetVerticesCoordinates(&xyz_list);
    6168        parameters->FindParam(&dim,DomainDimensionEnum);
    62         Input* vx_input=this->GetInput(VxEnum); _assert_(vx_input);
    63         Input* vy_input=this->GetInput(VyEnum); _assert_(vy_input);
    64         Input* vz_input=NULL;
    65         if(dim==3){vz_input=this->GetInput(VzEnum); _assert_(vz_input);}
     69        Input2* vx_input=this->GetInput2(VxEnum); _assert_(vx_input);
     70        Input2* vy_input=this->GetInput2(VyEnum); _assert_(vy_input);
     71        Input2* vz_input=NULL;
     72        if(dim==3){vz_input=this->GetInput2(VzEnum); _assert_(vz_input);}
    6673
    6774        /*Allocate arrays*/
    … …  
    122129
    123130        /*Add Stress tensor components into inputs*/
    124         this->AddInput(LambdaSEnum,lambdas,P1Enum);
     131        this->AddInput2(LambdaSEnum,lambdas,P1Enum);
    125132
    126133        /*Clean up and return*/
    … …  
    148155
    149156        /* Retrieve inputs */
    150         Input* eps_xx_input=this->GetInput(StrainRatexxEnum); _assert_(eps_xx_input);
    151         Input* eps_yy_input=this->GetInput(StrainRateyyEnum); _assert_(eps_yy_input);
    152         Input* eps_xy_input=this->GetInput(StrainRatexyEnum); _assert_(eps_xy_input);
    153         Input* eps_xz_input=NULL;
    154         Input* eps_yz_input=NULL;
    155         Input* eps_zz_input=NULL;
     157        Input2* eps_xx_input=this->GetInput2(StrainRatexxEnum); _assert_(eps_xx_input);
     158        Input2* eps_yy_input=this->GetInput2(StrainRateyyEnum); _assert_(eps_yy_input);
     159        Input2* eps_xy_input=this->GetInput2(StrainRatexyEnum); _assert_(eps_xy_input);
     160        Input2* eps_xz_input=NULL;
     161        Input2* eps_yz_input=NULL;
     162        Input2* eps_zz_input=NULL;
    156163        if(dim==3){
    157                 eps_xz_input=this->GetInput(StrainRatexzEnum); _assert_(eps_xz_input);
    158                 eps_yz_input=this->GetInput(StrainRateyzEnum); _assert_(eps_yz_input);
    159                 eps_zz_input=this->GetInput(StrainRatezzEnum); _assert_(eps_zz_input);
     164                eps_xz_input=this->GetInput2(StrainRatexzEnum); _assert_(eps_xz_input);
     165                eps_yz_input=this->GetInput2(StrainRateyzEnum); _assert_(eps_yz_input);
     166                eps_zz_input=this->GetInput2(StrainRatezzEnum); _assert_(eps_zz_input);
    160167        }
    161168
    … …  
    165172
    166173        /* Retrieve domain-dependent inputs */
    167         Input* n_input=this->GetInput(MaterialsRheologyNEnum); _assert_(n_input);
    168         Input* damage_input = NULL;
    169         Input* B_input = NULL;
     174        Input2* n_input=this->GetInput2(MaterialsRheologyNEnum); _assert_(n_input);
     175        Input2* damage_input = NULL;
     176        Input2* B_input = NULL;
    170177        int domaintype;
    171178        parameters->FindParam(&domaintype,DomainTypeEnum);
    172179        if(domaintype==Domain2DhorizontalEnum){
    173                 damage_input = this->GetInput(DamageDbarEnum);  _assert_(damage_input);
    174                 B_input=this->GetInput(MaterialsRheologyBbarEnum); _assert_(B_input);
     180                damage_input = this->GetInput2(DamageDbarOldEnum);  _assert_(damage_input);
     181                B_input=this->GetInput2(MaterialsRheologyBbarEnum); _assert_(B_input);
    175182        }
    176183        else{
    177                 damage_input = this->GetInput(DamageDEnum);   _assert_(damage_input);
    178                 B_input=this->GetInput(MaterialsRheologyBEnum); _assert_(B_input);
     184                damage_input = this->GetInput2(DamageDOldEnum);   _assert_(damage_input);
     185                B_input=this->GetInput2(MaterialsRheologyBEnum); _assert_(B_input);
    179186        }
    180187
    … …  
    217224
    218225        /* Add new damage input to DamageEnum and NewDamageEnum */
    219         this->AddInput(NewDamageEnum,newD,this->GetElementType());
     226        this->AddInput2(NewDamageEnum,newD,P1DGEnum);
    220227        if(domaintype==Domain2DhorizontalEnum){
    221                 this->AddInput(DamageDbarEnum,newD,this->GetElementType());
     228                this->AddInput2(DamageDbarEnum,newD,this->GetElementType());
    222229        }
    223230        else{
    224                 this->AddInput(DamageDEnum,newD,this->GetElementType());
     231                this->AddInput2(DamageDEnum,newD,this->GetElementType());
    225232        }
    226233
    … …  
    240247        this->GetVerticesCoordinates(&xyz_list);
    241248        parameters->FindParam(&dim,DomainDimensionEnum);
    242         Input* vx_input=this->GetInput(VxEnum); _assert_(vx_input);
    243         Input* vy_input=this->GetInput(VyEnum); _assert_(vy_input);
    244         Input* vz_input=NULL;
    245         if(dim==3){vz_input=this->GetInput(VzEnum); _assert_(vz_input);}
     249        Input2* vx_input=this->GetInput2(VxEnum); _assert_(vx_input);
     250        Input2* vy_input=this->GetInput2(VyEnum); _assert_(vy_input);
     251        Input2* vz_input=NULL;
     252        if(dim==3){vz_input=this->GetInput2(VzEnum); _assert_(vz_input);}
    246253
    247254        /*Allocate arrays*/
    … …  
    289296
    290297        /*Add Stress tensor components into inputs*/
    291         this->AddInput(StrainRatexxEnum,eps_xx,P1Enum);
    292         this->AddInput(StrainRatexyEnum,eps_xy,P1Enum);
    293         this->AddInput(StrainRatexzEnum,eps_xz,P1Enum);
    294         this->AddInput(StrainRateyyEnum,eps_yy,P1Enum);
    295         this->AddInput(StrainRateyzEnum,eps_yz,P1Enum);
    296         this->AddInput(StrainRatezzEnum,eps_zz,P1Enum);
    297         this->AddInput(StrainRateeffectiveEnum,eps_ef,P1Enum);
     298        this->AddInput2(StrainRatexxEnum,eps_xx,P1Enum);
     299        this->AddInput2(StrainRatexyEnum,eps_xy,P1Enum);
     300        this->AddInput2(StrainRatexzEnum,eps_xz,P1Enum);
     301        this->AddInput2(StrainRateyyEnum,eps_yy,P1Enum);
     302        this->AddInput2(StrainRateyzEnum,eps_yz,P1Enum);
     303        this->AddInput2(StrainRatezzEnum,eps_zz,P1Enum);
     304        this->AddInput2(StrainRateeffectiveEnum,eps_ef,P1Enum);
    298305
    299306        /*Clean up and return*/
    … …  
    389396        _printf_("   id : "<<this->id <<"\n");
    390397        _printf_("   sid: "<<this->sid<<"\n");
     398        _printf_("   lid: "<<this->lid<<"\n");
    391399        if(vertices){
    392400                const int NUM_VERTICES = this->GetNumberOfVertices();
    … …  
    429437        if(!IsOnBase()) return;
    430438
    431         const int NUM_VERTICES                                  = this->GetNumberOfVertices();
     439        const int NUM_VERTICES = this->GetNumberOfVertices();
    432440        const int NUM_VERTICES_MONTHS_PER_YEAR  = NUM_VERTICES * 12;
    433441
    434442        int        i;
     443        int*        vertexlids=xNew<int>(NUM_VERTICES);
    435444        IssmDouble* monthlytemperatures=xNew<IssmDouble>(NUM_VERTICES_MONTHS_PER_YEAR);
    436445        IssmDouble* monthlyprec=xNew<IssmDouble>(NUM_VERTICES_MONTHS_PER_YEAR);
    … …  
    439448        IssmDouble* PrecipitationsPresentday=xNew<IssmDouble>(NUM_VERTICES_MONTHS_PER_YEAR);
    440449        IssmDouble* tmp=xNew<IssmDouble>(NUM_VERTICES);
    441         IssmDouble Delta18oPresent,Delta18oLgm,Delta18oTime;
    442         IssmDouble Delta18oSurfacePresent,Delta18oSurfaceLgm,Delta18oSurfaceTime;
    443         IssmDouble time,yts,finaltime,time_yr;
    444450
    445451        /*Recover parameters*/
     452        IssmDouble time,yts,finaltime;
    446453        this->parameters->FindParam(&time,TimeEnum);
    447454        this->parameters->FindParam(&yts,ConstantsYtsEnum);
    448455        this->parameters->FindParam(&finaltime,TimesteppingFinalTimeEnum);
    449         time_yr=floor(time/yts)*yts;
    450 
    451         /*Recover present day temperature and precipitation*/
    452         Input* input=this->inputs->GetInput(SmbTemperaturesPresentdayEnum);    _assert_(input);
    453         Input* input2=this->inputs->GetInput(SmbTemperaturesLgmEnum);          _assert_(input2);
    454         Input* input3=this->inputs->GetInput(SmbPrecipitationsPresentdayEnum); _assert_(input3);
     456        this->GetVerticesLidList(vertexlids);
     457        IssmDouble time_yr=floor(time/yts)*yts;
     458
    455459        /*loop over vertices: */
    456460        Gauss* gauss=this->NewGauss();
    457461        for(int month=0;month<12;month++){
     462
     463                /*Recover present day temperature and precipitation*/
     464                Input2* input1=this->GetInput2(SmbTemperaturesPresentdayEnum,month/12.*yts);   _assert_(input1);
     465                Input2* input2=this->GetInput2(SmbTemperaturesLgmEnum,month/12.*yts);          _assert_(input2);
     466                Input2* input3=this->GetInput2(SmbPrecipitationsPresentdayEnum,month/12.*yts); _assert_(input3);
     467
    458468                for(int iv=0;iv<NUM_VERTICES;iv++){
    459469                        gauss->GaussVertex(iv);
    460                         input->GetInputValue(&TemperaturesPresentday[iv*12+month],gauss,month/12.*yts);
    461                         input2->GetInputValue(&TemperaturesLgm[iv*12+month],gauss,month/12.*yts);
    462                         input3->GetInputValue(&PrecipitationsPresentday[iv*12+month],gauss,month/12.*yts);
     470                        input1->GetInputValue(&TemperaturesPresentday[iv*12+month],gauss);
     471                        input2->GetInputValue(&TemperaturesLgm[iv*12+month],gauss);
     472                        input3->GetInputValue(&PrecipitationsPresentday[iv*12+month],gauss);
    463473
    464474                        PrecipitationsPresentday[iv*12+month]=PrecipitationsPresentday[iv*12+month]*yts;
    … …  
    467477
    468478        /*Recover delta18o and Delta18oSurface at present day, lgm and at time t*/
     479        IssmDouble Delta18oPresent,Delta18oLgm,Delta18oTime;
     480        IssmDouble Delta18oSurfacePresent,Delta18oSurfaceLgm,Delta18oSurfaceTime;
    469481        this->parameters->FindParam(&Delta18oPresent,SmbDelta18oEnum,finaltime);
    470482        this->parameters->FindParam(&Delta18oLgm,SmbDelta18oEnum,(finaltime-(21000*yts)));
    … …  
    484496
    485497        /*Update inputs*/
    486         TransientInput* NewTemperatureInput = new TransientInput(SmbMonthlytemperaturesEnum);
    487         TransientInput* NewPrecipitationInput = new TransientInput(SmbPrecipitationEnum);
    488498        for (int imonth=0;imonth<12;imonth++) {
    489499                for(i=0;i<NUM_VERTICES;i++) tmp[i]=monthlytemperatures[i*12+imonth];
    490500                switch(this->ObjectEnum()){
    491                         case TriaEnum:  NewTemperatureInput->AddTimeInput(new TriaInput(SmbMonthlytemperaturesEnum,&tmp[0],P1Enum),time_yr+imonth/12.*yts); break;
    492                         case PentaEnum: NewTemperatureInput->AddTimeInput(new PentaInput(SmbMonthlytemperaturesEnum,&tmp[0],P1Enum),time_yr+imonth/12.*yts); break;
    493                         case TetraEnum: NewTemperatureInput->AddTimeInput(new TetraInput(SmbMonthlytemperaturesEnum,&tmp[0],P1Enum),time_yr+imonth/12.*yts); break;
     501                        case TriaEnum: this->inputs2->SetTriaDatasetInput(SmbMonthlytemperaturesEnum,imonth,P1Enum,NUM_VERTICES,vertexlids,tmp); break;
     502                        case PentaEnum: this->inputs2->SetPentaDatasetInput(SmbMonthlytemperaturesEnum,imonth,P1Enum,NUM_VERTICES,vertexlids,tmp); break;
    494503                        default: _error_("Not implemented yet");
    495504                }
    496505                for(i=0;i<NUM_VERTICES;i++) tmp[i]=monthlyprec[i*12+imonth]/yts;
    497506                switch(this->ObjectEnum()){
    498                         case TriaEnum:  NewPrecipitationInput->AddTimeInput(new TriaInput(SmbPrecipitationEnum,&tmp[0],P1Enum),time_yr+imonth/12.*yts); break;
    499                         case PentaEnum: NewPrecipitationInput->AddTimeInput(new PentaInput(SmbPrecipitationEnum,&tmp[0],P1Enum),time_yr+imonth/12.*yts); break;
    500                         case TetraEnum: NewPrecipitationInput->AddTimeInput(new TetraInput(SmbPrecipitationEnum,&tmp[0],P1Enum),time_yr+imonth/12.*yts); break;
     507                        case TriaEnum: this->inputs2->SetTriaDatasetInput(SmbPrecipitationEnum,imonth,P1Enum,NUM_VERTICES,vertexlids,tmp); break;
     508                        case PentaEnum: this->inputs2->SetPentaDatasetInput(SmbPrecipitationEnum,imonth,P1Enum,NUM_VERTICES,vertexlids,tmp); break;
    501509                        default: _error_("Not implemented yet");
    502510                }
    503511        }
    504         NewTemperatureInput->Configure(this->parameters);
    505         NewPrecipitationInput->Configure(this->parameters);
    506 
    507         this->inputs->AddInput(NewTemperatureInput);
    508         this->inputs->AddInput(NewPrecipitationInput);
    509512
    510513        switch(this->ObjectEnum()){
    … …  
    512515                case PentaEnum:
    513516                case TetraEnum:
    514          this->InputExtrude(SmbMonthlytemperaturesEnum,-1);
    515          this->InputExtrude(SmbPrecipitationEnum,-1);
     517         this->DatasetInputExtrude(SmbMonthlytemperaturesEnum,-1);
     518         this->DatasetInputExtrude(SmbPrecipitationEnum,-1);
    516519         break;
    517520                default: _error_("Not implemented yet");
    … …  
    526529        xDelete<IssmDouble>(PrecipitationsPresentday);
    527530        xDelete<IssmDouble>(tmp);
    528 
    529 }
    530 /*}}}*/
     531        xDelete<int>(vertexlids);
     532
     533} /*}}}*/
    531534void       Element::Delta18opdParameterization(void){/*{{{*/
    532535        /*Are we on the base? If not, return*/
    … …  
    537540
    538541        int             i;
     542        int*        vertexlids=xNew<int>(NUM_VERTICES);
    539543        IssmDouble* monthlytemperatures=xNew<IssmDouble>(NUM_VERTICES_MONTHS_PER_YEAR);
    540544        IssmDouble* monthlyprec=xNew<IssmDouble>(NUM_VERTICES_MONTHS_PER_YEAR);
    … …  
    552556        this->parameters->FindParam(&yts,ConstantsYtsEnum);
    553557        this->parameters->FindParam(&f,SmbFEnum);
     558        this->GetVerticesLidList(vertexlids);
    554559        time_yr=floor(time/yts)*yts;
    555         time_clim=ceil(time/yts + 1e-10)*yts;
     560        time_clim =ceil(time/yts + 1e-10)*yts;
    556561        time_climt=ceil(time/yts + 1e-10)*yts;
    557562        time_climp=ceil(time/yts + 1e-10)*yts;
    … …  
    563568        this->parameters->FindParam(&isPrecipScaled,SmbIsprecipscaledEnum);
    564569
    565         /*Recover present day temperature and precipitation*/
    566         Input*     input=this->inputs->GetInput(SmbTemperaturesPresentdayEnum);    _assert_(input);
    567         Input*     input2=this->inputs->GetInput(SmbPrecipitationsPresentdayEnum); _assert_(input2);
    568         Input*     input3=NULL;
    569         Input*     input4=NULL;
     570                /*Recover present day temperature and precipitation*/
     571        TransientInput2 *tinput  = this->inputs2->GetTransientInput(SmbTemperaturesPresentdayEnum);   _assert_(tinput);
     572        TransientInput2 *tinput2 = this->inputs2->GetTransientInput(SmbPrecipitationsPresentdayEnum); _assert_(tinput2);
     573        TransientInput2 *tinput3 = NULL;
     574        TransientInput2 *tinput4 = NULL;
    570575        int offset;
    571576
    572         offset=dynamic_cast<TransientInput*>(input)->GetTimeInputOffset(time_clim);
    573         time_clim=dynamic_cast<TransientInput*>(input)->GetTimeByOffset(offset-11-fmod(offset-11,12.));
     577        offset    = tinput->GetTimeInputOffset(time_clim);
     578        time_clim = tinput->GetTimeByOffset(offset-11-fmod(offset-11,12.));
    574579
    575580        if(!isTemperatureScaled){
    576                 input3=this->inputs->GetInput(SmbTemperaturesReconstructedEnum);           _assert_(input3);
    577                 offset=dynamic_cast<TransientInput*>(input3)->GetTimeInputOffset(time_climt);
    578                 time_climt=dynamic_cast<TransientInput*>(input3)->GetTimeByOffset(offset-11-fmod(offset-11,12.));
     581                tinput3=this->inputs2->GetTransientInput(SmbTemperaturesReconstructedEnum); _assert_(tinput3);
     582                offset     = tinput3->GetTimeInputOffset(time_climt);
     583                time_climt = tinput3->GetTimeByOffset(offset-11-fmod(offset-11,12.));
    579584        }
    580585        if(!isPrecipScaled){
    581                 input4=this->inputs->GetInput(SmbPrecipitationsReconstructedEnum);         _assert_(input4);
    582                 offset=dynamic_cast<TransientInput*>(input4)->GetTimeInputOffset(time_climp);
    583                 time_climp=dynamic_cast<TransientInput*>(input4)->GetTimeByOffset(offset-11-fmod(offset-11,12.));
     586                tinput4=this->inputs2->GetTransientInput(SmbPrecipitationsReconstructedEnum); _assert_(tinput4);
     587                offset     = tinput4->GetTimeInputOffset(time_climp);
     588                time_climp = tinput4->GetTimeByOffset(offset-11-fmod(offset-11,12.));
    584589        }
    585590
    … …  
    587592        Gauss* gauss=this->NewGauss();
    588593        for(int month=0;month<12;month++) {
     594                Input2 *input  = this->GetInput2(SmbTemperaturesPresentdayEnum,time_clim+month/12.*yts);   _assert_(input);
     595                Input2 *input2 = this->GetInput2(SmbPrecipitationsPresentdayEnum,time_clim+month/12.*yts); _assert_(input2);
     596                Input2 *input3 = NULL;
     597                Input2 *input4 = NULL;
     598                if(!isTemperatureScaled){
     599                        input3=this->GetInput2(SmbTemperaturesReconstructedEnum,time_climt+month/12.*yts); _assert_(input3);
     600                }
     601                if(!isPrecipScaled){
     602                        input4=this->GetInput2(SmbPrecipitationsReconstructedEnum,time_climp+month/12.*yts);
     603                }
    589604                for(int iv=0;iv<NUM_VERTICES;iv++) {
    590605                        gauss->GaussVertex(iv);
    591                         input->GetInputValue(&TemperaturesPresentday[iv*12+month],gauss,time_clim+month/12.*yts);
    592                         input2->GetInputValue(&PrecipitationsPresentday[iv*12+month],gauss,time_clim+month/12.*yts);
     606                        input->GetInputValue(&TemperaturesPresentday[iv*12+month],gauss);
     607                        input2->GetInputValue(&PrecipitationsPresentday[iv*12+month],gauss);
    593608                        PrecipitationsPresentday[iv*12+month]=PrecipitationsPresentday[iv*12+month]*yts;
    594609
    595610                        if(!isTemperatureScaled){
    596                                 input3->GetInputValue(&TemperaturesReconstructed[iv*12+month],gauss,time_climt+month/12.*yts);
     611                                input3->GetInputValue(&TemperaturesReconstructed[iv*12+month],gauss);
    597612                        }
    598613                        if(!isPrecipScaled){
    599                                 input4->GetInputValue(&PrecipitationsReconstructed[iv*12+month],gauss,time_climp+month/12.*yts);
     614                                input4->GetInputValue(&PrecipitationsReconstructed[iv*12+month],gauss);
    600615                                PrecipitationsReconstructed[iv*12+month]=PrecipitationsReconstructed[iv*12+month]*yts;
    601616                        }
    602 
    603617                }
    604618        }
    … …  
    616630
    617631        /*Update inputs*/
    618         TransientInput* NewTemperatureInput = new TransientInput(SmbMonthlytemperaturesEnum);
    619         TransientInput* NewPrecipitationInput = new TransientInput(SmbPrecipitationEnum);
    620632        for (int imonth=0;imonth<12;imonth++) {
    621633                for(i=0;i<NUM_VERTICES;i++) tmp[i]=monthlytemperatures[i*12+imonth];
    622634                switch(this->ObjectEnum()){
    623                         case TriaEnum:  NewTemperatureInput->AddTimeInput(new TriaInput(SmbMonthlytemperaturesEnum,&tmp[0],P1Enum),time_yr+imonth/12.*yts); break;
    624                         case PentaEnum: NewTemperatureInput->AddTimeInput(new PentaInput(SmbMonthlytemperaturesEnum,&tmp[0],P1Enum),time_yr+imonth/12.*yts); break;
    625                         case TetraEnum: NewTemperatureInput->AddTimeInput(new TetraInput(SmbMonthlytemperaturesEnum,&tmp[0],P1Enum),time_yr+imonth/12.*yts); break;
     635                        case TriaEnum:  this->inputs2->SetTriaDatasetInput(SmbMonthlytemperaturesEnum,imonth,P1Enum,NUM_VERTICES,vertexlids,tmp); break;
     636                        case PentaEnum: this->inputs2->SetPentaDatasetInput(SmbMonthlytemperaturesEnum,imonth,P1Enum,NUM_VERTICES,vertexlids,tmp); break;
    626637                        default: _error_("Not implemented yet");
    627638                }
    628639                for(i=0;i<NUM_VERTICES;i++) tmp[i]=monthlyprec[i*12+imonth]/yts;
    629640                switch(this->ObjectEnum()){
    630                         case TriaEnum:  NewPrecipitationInput->AddTimeInput(new TriaInput(SmbPrecipitationEnum,&tmp[0],P1Enum),time_yr+imonth/12.*yts); break;
    631                         case PentaEnum: NewPrecipitationInput->AddTimeInput(new PentaInput(SmbPrecipitationEnum,&tmp[0],P1Enum),time_yr+imonth/12.*yts); break;
    632                         case TetraEnum: NewPrecipitationInput->AddTimeInput(new TetraInput(SmbPrecipitationEnum,&tmp[0],P1Enum),time_yr+imonth/12.*yts); break;
     641                        case TriaEnum:  this->inputs2->SetTriaDatasetInput(SmbPrecipitationEnum,imonth,P1Enum,NUM_VERTICES,vertexlids,tmp); break;
     642                        case PentaEnum: this->inputs2->SetPentaDatasetInput(SmbPrecipitationEnum,imonth,P1Enum,NUM_VERTICES,vertexlids,tmp); break;
    633643                        default: _error_("Not implemented yet");
    634644                }
    635645        }
    636         NewTemperatureInput->Configure(this->parameters);
    637         NewPrecipitationInput->Configure(this->parameters);
    638 
    639         this->inputs->AddInput(NewTemperatureInput);
    640         this->inputs->AddInput(NewPrecipitationInput);
    641646
    642647        switch(this->ObjectEnum()){
    … …  
    644649                case PentaEnum:
    645650                case TetraEnum:
    646          this->InputExtrude(SmbMonthlytemperaturesEnum,-1);
    647          this->InputExtrude(SmbPrecipitationEnum,-1);
     651         this->DatasetInputExtrude(SmbMonthlytemperaturesEnum,-1);
     652         this->DatasetInputExtrude(SmbPrecipitationEnum,-1);
    648653         break;
    649654                default: _error_("Not implemented yet");
    … …  
    659664        xDelete<IssmDouble>(PrecipitationsReconstructed);
    660665        xDelete<IssmDouble>(tmp);
    661 
    662 }
    663 /*}}}*/
     666        xDelete<int>(vertexlids);
     667
     668} /*}}}*/
    664669void       Element::SmbGradCompParameterization(void){/*{{{*/
    665670
    … …  
    744749        /*Get inputs and parameters*/
    745750        this->FindParam(&dim,DomainDimensionEnum);
    746         Input* vx_input = this->GetInput(VxEnum); _assert_(vx_input);
    747         Input* vy_input = this->GetInput(VyEnum); _assert_(vy_input);
    748         Input* vz_input = NULL;
     751        Input2* vx_input = this->GetInput2(VxEnum); _assert_(vx_input);
     752        Input2* vy_input = this->GetInput2(VyEnum); _assert_(vy_input);
     753        Input2* vz_input = NULL;
    749754        if(dim==3){
    750                 vz_input = this->GetInput(VzEnum); _assert_(vz_input);
     755                vz_input = this->GetInput2(VzEnum); _assert_(vz_input);
    751756        }
    752757        this->GetVerticesCoordinates(&xyz_list);
    … …  
    775780        return divergence;
    776781}/*}}}*/
    777 void       Element::dViscositydBFS(IssmDouble* pdmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input){/*{{{*/
     782void       Element::dViscositydBFS(IssmDouble* pdmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input,Input2* vz_input){/*{{{*/
    778783
    779784        /*Intermediaries*/
    … …  
    812817}
    813818/*}}}*/
    814 void       Element::dViscositydBHO(IssmDouble* pdmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input){/*{{{*/
     819void       Element::dViscositydBHO(IssmDouble* pdmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input){/*{{{*/
    815820
    816821        /*Intermediaries*/
    … …  
    849854}
    850855/*}}}*/
    851 void       Element::dViscositydBSSA(IssmDouble* pdmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input){/*{{{*/
     856void       Element::dViscositydBSSA(IssmDouble* pdmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input){/*{{{*/
    852857
    853858        /*Intermediaries*/
    … …  
    886891}
    887892/*}}}*/
    888 void       Element::dViscositydDSSA(IssmDouble* pdmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input){/*{{{*/
     893void       Element::dViscositydDSSA(IssmDouble* pdmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input){/*{{{*/
    889894
    890895        /*Intermediaries*/
    … …  
    917922        _printf_("   id : "<<this->id <<"\n");
    918923        _printf_("   sid: "<<this->sid<<"\n");
     924        _printf_("   lid: "<<this->lid<<"\n");
    919925        if(vertices){
    920926                const int NUM_VERTICES = this->GetNumberOfVertices();
    … …  
    11191125        _assert_(pvalue);
    11201126
    1121         Input *input    = this->GetInput(enumtype);
     1127        Input2 *input    = this->GetInput2(enumtype);
    11221128        int    numnodes = this->GetNumberOfNodes();
    11231129
    … …  
    11401146        _assert_(pvalue);
    11411147
    1142         int    numnodes = this->GetNumberOfNodes();
    1143         Input *input    = this->GetInput(enumtype);
     1148        int     numnodes = this->GetNumberOfNodes();
     1149        Input2 *input    = this->GetInput2(enumtype);
    11441150        if(!input) _error_("Input " << EnumToStringx(enumtype) << " not found in element");
    11451151
    … …  
    11571163        _assert_(pvalue);
    11581164
    1159         int    numnodes = this->NumberofNodesVelocity();
    1160         Input *input    = this->GetInput(enumtype);
     1165        int     numnodes = this->NumberofNodesVelocity();
     1166        Input2 *input    = this->GetInput2(enumtype);
    11611167        if(!input) _error_("Input " << EnumToStringx(enumtype) << " not found in element");
    11621168
    … …  
    11701176}
    11711177/*}}}*/
    1172 void       Element::GetInputListOnVertices(IssmDouble* pvalue,int enumtype){/*{{{*/
    1173 
    1174         /*Recover input*/
    1175         Input* input=this->GetInput(enumtype);
    1176         if (!input) _error_("Input " << EnumToStringx(enumtype) << " not found in element");
     1178void       Element::GetInputListOnVertices(IssmDouble* pvalue,ElementInput2* input){/*{{{*/
     1179
    11771180        /*Fetch number vertices for this element*/
    11781181        const int NUM_VERTICES = this->GetNumberOfVertices();
    11791182
    11801183        /*Checks in debugging mode*/
     1184        _assert_(input);
    11811185        _assert_(pvalue);
    11821186
    … …  
    11871191                input->GetInputValue(&pvalue[iv],gauss);
    11881192        }
    1189 
    1190         /*clean-up*/
    11911193        delete gauss;
    11921194}
    11931195/*}}}*/
    1194 void       Element::GetInputListOnVerticesAtTime(IssmDouble* pvalue, int enumtype, IssmDouble time){/*{{{*/
    1195 
    1196         /*Recover input*/
    1197         Input* input=this->GetInput(enumtype);
    1198         if (!input) _error_("Input " << EnumToStringx(enumtype) << " not found in element");
     1196void       Element::GetInputListOnVertices(IssmDouble* pvalue,int enumtype){/*{{{*/
    11991197
    12001198        /*Fetch number vertices for this element*/
    … …  
    12041202        _assert_(pvalue);
    12051203
     1204        /*Recover input*/
     1205        Input2* input2=this->GetInput2(enumtype);
     1206        if(!input2) _error_("input "<<EnumToStringx(enumtype)<<" not found in element");
    12061207        /* Start looping on the number of vertices: */
    12071208        Gauss*gauss=this->NewGauss();
    12081209        for(int iv=0;iv<NUM_VERTICES;iv++){
    12091210                gauss->GaussVertex(iv);
    1210                 input->GetInputValue(&pvalue[iv],gauss,time);
     1211                input2->GetInputValue(&pvalue[iv],gauss);
     1212        }
     1213        delete gauss;
     1214}
     1215/*}}}*/
     1216void       Element::GetInputListOnVerticesAtTime(IssmDouble* pvalue, int enumtype, IssmDouble time){/*{{{*/
     1217
     1218        /*Recover input*/
     1219        Input2* input=this->GetInput2(enumtype,time);
     1220        if (!input) _error_("Input " << EnumToStringx(enumtype) << " not found in element");
     1221
     1222        /*Fetch number vertices for this element*/
     1223        const int NUM_VERTICES = this->GetNumberOfVertices();
     1224
     1225        /*Checks in debugging mode*/
     1226        _assert_(pvalue);
     1227
     1228        /* Start looping on the number of vertices: */
     1229        Gauss*gauss=this->NewGauss();
     1230        for(int iv=0;iv<NUM_VERTICES;iv++){
     1231                gauss->GaussVertex(iv);
     1232                input->GetInputValue(&pvalue[iv],gauss);
    12111233        }
    12121234
    … …  
    12181240
    12191241        /*Recover input*/
    1220         Input* input=this->GetInput(enumtype);
     1242        Input2* input=this->GetInput2(enumtype);
    12211243
    12221244        /*Checks in debugging mode*/
    … …  
    12671289void       Element::GetInputValue(bool* pvalue,int inputenum){/*{{{*/
    12681290
    1269         Input* input=inputs->GetInput(inputenum);
     1291        this->inputs2->GetInputValue(pvalue,inputenum,this->lid);
     1292
     1293}/*}}}*/
     1294void       Element::GetInputValue(int* pvalue,int inputenum){/*{{{*/
     1295        this->inputs2->GetInputValue(pvalue,inputenum,this->lid);
     1296}/*}}}*/
     1297void       Element::GetInput2Value(bool* pvalue,int inputenum){/*{{{*/
     1298
     1299        this->inputs2->GetInputValue(pvalue,inputenum,this->lid);
     1300
     1301}/*}}}*/
     1302void       Element::GetInput2Value(int* pvalue,int inputenum){/*{{{*/
     1303
     1304        this->inputs2->GetInputValue(pvalue,inputenum,this->lid);
     1305
     1306}/*}}}*/
     1307void       Element::GetInputValue(IssmDouble* pvalue,int inputenum){/*{{{*/
     1308
     1309        Input2* input=this->GetInput2(inputenum);
    12701310        if(!input) _error_("Input " << EnumToStringx(inputenum) << " not found in element");
    1271         input->GetInputValue(pvalue);
    1272 
    1273 }/*}}}*/
    1274 void       Element::GetInputValue(int* pvalue,int inputenum){/*{{{*/
    1275 
    1276         Input* input=inputs->GetInput(inputenum);
    1277         if(!input) _error_("Input " << EnumToStringx(inputenum) << " not found in element");
    1278         input->GetInputValue(pvalue);
    1279 
    1280 }/*}}}*/
    1281 void       Element::GetInputValue(IssmDouble* pvalue,int inputenum){/*{{{*/
    1282 
    1283         Input* input=inputs->GetInput(inputenum);
    1284         if(!input) _error_("Input " << EnumToStringx(inputenum) << " not found in element");
    1285         input->GetInputValue(pvalue);
     1311        //input->GetInputValue(pvalue);
     1312        _error_("not supported yet (Trying to fetch "<<EnumToStringx(inputenum)<<")");
    12861313
    12871314}/*}}}*/
    12881315void       Element::GetInputValue(IssmDouble* pvalue,Gauss* gauss,int inputenum){/*{{{*/
    12891316
    1290         Input* input=inputs->GetInput(inputenum);
     1317        Input2* input=this->GetInput2(inputenum);
    12911318        if(!input) _error_("Input " << EnumToStringx(inputenum) << " not found in element");
    12921319        input->GetInputValue(pvalue,gauss);
    … …  
    14041431
    14051432        /*Get inputs*/
    1406         Input* enum_input=inputs->GetInput(enum_type); _assert_(enum_input);
     1433        Input2* enum_input=this->GetInput2(enum_type); _assert_(enum_input);
    14071434
    14081435        /*Ok, we have the values, fill in the array: */
    … …  
    14501477        IssmDouble  value;
    14511478        IssmDouble* values      = NULL;
    1452         Input*      input       = NULL;
     1479        Input2*     input       = NULL;
    14531480
    14541481        switch(type){
    14551482                case ElementSIdEnum:
    1456                         input=inputs->GetInput(input_enum); _assert_(input);
     1483                        input=this->GetInput2(input_enum); _assert_(input);
    14571484                        input->GetInputAverage(&value);
    14581485                        vector->SetValue(this->sid,value,INS_VAL);
    … …  
    16721699/*}}}*/
    16731700bool       Element::HasNodeOnBase(){/*{{{*/
    1674         return (this->inputs->Max(MeshVertexonbaseEnum)>0.);
     1701        Input2* input=this->GetInput2(MeshVertexonbaseEnum); _assert_(input);
     1702        return (input->GetInputMax()>0.);
    16751703}/*}}}*/
    16761704bool       Element::HasNodeOnSurface(){/*{{{*/
    1677         return (this->inputs->Max(MeshVertexonsurfaceEnum)>0.);
     1705        Input2* input=this->GetInput2(MeshVertexonsurfaceEnum); _assert_(input);
     1706        return (input->GetInputMax()>0.);
    16781707}/*}}}*/
    16791708IssmDouble Element::IceMass(bool scaled){/*{{{*/
    … …  
    17381767}
    17391768/*}}}*/
    1740 void       Element::InputCreate(IssmDouble* vector,IoModel* iomodel,int M,int N,int vector_type,int vector_enum,int code){/*{{{*/
     1769void       Element::InputCreate(IssmDouble* vector,Inputs2* inputs2,IoModel* iomodel,int M,int N,int vector_type,int vector_enum,int code){/*{{{*/
    17411770
    17421771        /*Intermediaries*/
    … …  
    17481777                const int NUM_VERTICES = this->GetNumberOfVertices();
    17491778
    1750                 int        *vertexids   = xNew<int>(NUM_VERTICES);
    1751                 IssmDouble *values      = xNew<IssmDouble>(NUM_VERTICES);
     1779                int        *vertexids  = xNew<int>(NUM_VERTICES);
     1780                int        *vertexlids = xNew<int>(NUM_VERTICES);
     1781                IssmDouble *values     = xNew<IssmDouble>(NUM_VERTICES);
    17521782
    17531783                /*Recover vertices ids needed to initialize inputs*/
    17541784                _assert_(iomodel->elements);
    17551785                for(i=0;i<NUM_VERTICES;i++){
    1756                         vertexids[i]=reCast<int>(iomodel->elements[NUM_VERTICES*this->Sid()+i]); //ids for vertices are in the elements array from Matlab
     1786                        vertexids[i] =reCast<int>(iomodel->elements[NUM_VERTICES*this->Sid()+i]); //ids for vertices are in the elements array from Matlab
     1787                        vertexlids[i]=iomodel->my_vertices_lids[vertexids[i]-1];
    17571788                }
    17581789
    … …  
    17601791                if(M==1){
    17611792                        values[0]=vector[0];
    1762                         this->AddInput(vector_enum,values,P0Enum);
     1793                        this->SetElementInput(inputs2,vector_enum,vector[0]);
    17631794                }
    17641795                else if(M==iomodel->numberofvertices){
    17651796                        for(i=0;i<NUM_VERTICES;i++) values[i]=vector[vertexids[i]-1];
    1766                         this->AddInput(vector_enum,values,P1Enum);
     1797                        this->SetElementInput(inputs2,NUM_VERTICES,vertexlids,values,vector_enum);
    17671798                }
    17681799                else if(M==iomodel->numberofvertices+1){
    … …  
    17701801                        IssmDouble* times = xNew<IssmDouble>(N);
    17711802                        for(t=0;t<N;t++) times[t] = vector[(M-1)*N+t];
    1772                         TransientInput* transientinput=new TransientInput(vector_enum,times,N);
     1803                        inputs2->SetTransientInput(vector_enum,times,N);
     1804                        TransientInput2* transientinput = inputs2->GetTransientInput(vector_enum);
    17731805                        for(t=0;t<N;t++){
    17741806                                for(i=0;i<NUM_VERTICES;i++) values[i]=vector[N*(vertexids[i]-1)+t];
    17751807                                switch(this->ObjectEnum()){
    1776                                         case TriaEnum:  transientinput->AddTimeInput(new TriaInput( vector_enum,values,P1Enum)); break;
    1777                                         case PentaEnum: transientinput->AddTimeInput(new PentaInput(vector_enum,values,P1Enum)); break;
    1778                                         case TetraEnum: transientinput->AddTimeInput(new TetraInput(vector_enum,values,P1Enum)); break;
     1808                                        case TriaEnum:  transientinput->AddTriaTimeInput( t,NUM_VERTICES,vertexlids,values,P1Enum); break;
     1809                                        case PentaEnum: transientinput->AddPentaTimeInput(t,NUM_VERTICES,vertexlids,values,P1Enum); break;
    17791810                                        default: _error_("Not implemented yet");
    17801811                                }
    17811812                        }
    1782                         this->inputs->AddInput(transientinput);
    17831813                        xDelete<IssmDouble>(times);
    17841814                }
    … …  
    17901820                        for(int j=0;j<N;j++) values[j]=vector[this->Sid()*N+j];
    17911821
    1792                         if     (N==this->GetNumberOfNodes(P1Enum)   ) this->AddInput(vector_enum,values,P1Enum);
    1793                         else if(N==this->GetNumberOfNodes(P0Enum)   ) this->AddInput(vector_enum,values,P0Enum);
    1794                         else if(N==this->GetNumberOfNodes(P1xP2Enum)) this->AddInput(vector_enum,values,P1xP2Enum);
    1795                         else if(N==this->GetNumberOfNodes(P1xP3Enum)) this->AddInput(vector_enum,values,P1xP3Enum);
     1822                        if     (N==this->GetNumberOfNodes(P1Enum)   ) this->AddInput2(vector_enum,values,P1Enum);
     1823                        else if(N==this->GetNumberOfNodes(P0Enum)   ) this->AddInput2(vector_enum,values,P0Enum);
     1824                        else if(N==this->GetNumberOfNodes(P1xP2Enum)) this->AddInput2(vector_enum,values,P1xP2Enum);
     1825                        else if(N==this->GetNumberOfNodes(P1xP3Enum)) this->AddInput2(vector_enum,values,P1xP3Enum);
    17961826                        else _error_("Patch interpolation not supported yet");
    17971827
    … …  
    18031833                xDelete<IssmDouble>(values);
    18041834                xDelete<int>(vertexids);
     1835                xDelete<int>(vertexlids);
    18051836        }
    18061837        else if(vector_type==2){ //element vector
    … …  
    18111842                if(M==iomodel->numberofelements){
    18121843                        if (code==5){ //boolean
    1813                                 this->inputs->AddInput(new BoolInput(vector_enum,reCast<bool>(vector[this->Sid()])));
     1844                                this->SetBoolInput(inputs2,vector_enum,reCast<bool>(vector[this->Sid()]));
    18141845                        }
    18151846                        else if (code==6){ //integer
    1816                                 this->inputs->AddInput(new IntInput(vector_enum,reCast<int>(vector[this->Sid()])));
     1847                                this->SetIntInput(inputs2,vector_enum,reCast<int>(vector[this->Sid()]));
    18171848                        }
    18181849                        else if (code==7){ //IssmDouble
    1819                                 this->inputs->AddInput(new DoubleInput(vector_enum,vector[this->Sid()]));
     1850                                this->SetElementInput(inputs2,vector_enum,vector[this->Sid()]);
    18201851                        }
    18211852                        else _error_("could not recognize nature of vector from code " << code);
    … …  
    18251856                        IssmDouble* times = xNew<IssmDouble>(N);
    18261857                        for(t=0;t<N;t++) times[t] = vector[(M-1)*N+t];
    1827                         TransientInput* transientinput=new TransientInput(vector_enum,times,N);
    1828                         TriaInput* bof=NULL;
     1858                        inputs2->SetTransientInput(vector_enum,times,N);
     1859                        TransientInput2* transientinput = inputs2->GetTransientInput(vector_enum);
    18291860                        for(t=0;t<N;t++){
    18301861                                value=vector[N*this->Sid()+t];
    18311862                                switch(this->ObjectEnum()){
    1832                                         case TriaEnum:  transientinput->AddTimeInput(new TriaInput( vector_enum,&value,P0Enum)); break;
    1833                                         case PentaEnum: transientinput->AddTimeInput(new PentaInput(vector_enum,&value,P0Enum)); break;
    1834                                         case TetraEnum: transientinput->AddTimeInput(new TetraInput(vector_enum,&value,P0Enum)); break;
     1863                                        case TriaEnum:  transientinput->AddTriaTimeInput( t,1,&(this->lid),&value,P0Enum); break;
     1864                                        case PentaEnum: transientinput->AddPentaTimeInput(t,1,&(this->lid),&value,P0Enum); break;
    18351865                                        default: _error_("Not implemented yet");
    18361866                                }
    18371867                        }
    1838                         this->inputs->AddInput(transientinput);
    18391868                        xDelete<IssmDouble>(times);
    18401869                }
    18411870                else _error_("element vector is either numberofelements or numberofelements+1 long. Field provided (" << EnumToStringx(vector_enum) << ") is " << M << " long");
    18421871        }
    1843         else if(vector_type==3){ //element vector
     1872        else if(vector_type==3){ //Double array matrix
    18441873
    18451874                /*For right now we are static */
    18461875                if(M==iomodel->numberofelements){
    1847                         /*create transient input: */
    1848                         IssmDouble* layers = xNewZeroInit<IssmDouble>(N);;
     1876                        IssmDouble* layers = xNewZeroInit<IssmDouble>(N);
    18491877                        for(t=0;t<N;t++) layers[t] = vector[N*this->Sid()+t];
    1850                         DoubleArrayInput* arrayinput=new DoubleArrayInput(vector_enum,layers,N);
    1851                         this->inputs->AddInput(arrayinput);
     1878                        inputs2->SetArrayInput(vector_enum,this->lid,layers,N);
    18521879                        xDelete<IssmDouble>(layers);
    18531880                }
    … …  
    18571884}
    18581885/*}}}*/
    1859 void       Element::ControlInputCreate(IssmDouble* vector,IssmDouble* min_vector,IssmDouble* max_vector,IoModel* iomodel,int M,int N,int input_enum,int id){/*{{{*/
     1886void       Element::ControlInputCreate(IssmDouble* vector,IssmDouble* min_vector,IssmDouble* max_vector,Inputs2* inputs2,IoModel* iomodel,int M,int N,IssmDouble scale,int input_enum,int id){/*{{{*/
    18601887
    18611888        /*Intermediaries*/
    1862         const int NUM_VERTICES = this->GetNumberOfVertices();
    1863 
    1864         int        *vertexids   = xNew<int>(NUM_VERTICES);
    1865         IssmDouble *values      = xNew<IssmDouble>(NUM_VERTICES);
    1866         IssmDouble *values_min  = xNew<IssmDouble>(NUM_VERTICES);
    1867         IssmDouble *values_max  = xNew<IssmDouble>(NUM_VERTICES);
     1889        const int numvertices = this->GetNumberOfVertices();
     1890
     1891        int        *vertexids   = xNew<int>(numvertices);
     1892        IssmDouble *values      = xNew<IssmDouble>(numvertices);
     1893        IssmDouble *values_min  = xNew<IssmDouble>(numvertices);
     1894        IssmDouble *values_max  = xNew<IssmDouble>(numvertices);
    18681895
    18691896        /*Some sanity checks*/
    … …  
    18721899        _assert_(max_vector);
    18731900
    1874         /*For now we only support nodal vectors*/
    1875         //if(M!=iomodel->numberofvertices) _error_("not supported");
    1876         //if(N!=1) _error_("not supported");
    1877 
    18781901        /*Recover vertices ids needed to initialize inputs*/
    18791902        _assert_(iomodel->elements);
    1880         for(int i=0;i<NUM_VERTICES;i++){
    1881                 vertexids[i]=reCast<int>(iomodel->elements[NUM_VERTICES*this->Sid()+i]); //ids for vertices are in the elements array from Matlab
     1903        for(int i=0;i<numvertices;i++){
     1904                vertexids[i]=reCast<int>(iomodel->elements[numvertices*this->Sid()+i]); //ids for vertices are in the elements array from Matlab
    18821905        }
    18831906
    18841907        /*Are we in transient or static? */
    1885         if(M==iomodel->numberofvertices){
    1886                 for(int i=0;i<NUM_VERTICES;i++){
    1887                         values[i]=vector[vertexids[i]-1];
    1888                         values_min[i] = min_vector[vertexids[i]-1];
    1889                         values_max[i] = max_vector[vertexids[i]-1];
    1890                 }
    1891                 this->AddControlInput(input_enum,values,values_min,values_max,P1Enum,id);
    1892         }
    1893 
    1894         else if(M==iomodel->numberofvertices+1){
     1908        if(M==iomodel->numberofvertices && N==1){
     1909                for(int i=0;i<numvertices;i++){
     1910                        values[i]     = vector[vertexids[i]-1];
     1911                        values_min[i] = scale*min_vector[vertexids[i]-1];
     1912                        values_max[i] = scale*max_vector[vertexids[i]-1];
     1913                }
     1914                this->AddControlInput(input_enum,inputs2,iomodel,values,values_min,values_max,P1Enum,id);
     1915        }
     1916
     1917        else if(M==iomodel->numberofvertices+1 && N>1){
     1918                _error_("not supported tet");
    18951919                /*create transient input: */
    18961920                IssmDouble* times = xNew<IssmDouble>(N);
    … …  
    19021926                TransientInput* grad_input = new TransientInput(ControlInputGradEnum);
    19031927                for(int t=0;t<N;t++){
    1904                         for(int i=0;i<NUM_VERTICES;i++){
     1928                        for(int i=0;i<numvertices;i++){
    19051929                                values[i]=vector[N*(vertexids[i]-1)+t];
    19061930                                values_min[i] = min_vector[N*(vertexids[i]-1)+t];
    … …  
    19331957        /*clean up*/
    19341958        xDelete<IssmDouble>(values);
     1959        xDelete<IssmDouble>(values_min);
     1960        xDelete<IssmDouble>(values_max);
    19351961        xDelete<int>(vertexids);
    19361962}
    19371963/*}}}*/
    1938 void       Element::DatasetInputAdd(int enum_type,IssmDouble* vector,IoModel* iomodel,int M,int N,int vector_type,int input_enum,int code,int input_id){/*{{{*/
     1964void       Element::DatasetInputAdd(int enum_type,IssmDouble* vector,Inputs2* inputs2,IoModel* iomodel,int M,int N,int vector_type,int input_enum,int code,int input_id){/*{{{*/
    19391965        /*enum_type: the name of the DatasetInput (eg Outputdefinition1)
    19401966         * vector: information being stored (eg observations)
    … …  
    19451971
    19461972        /*Intermediaries*/
    1947         int                                     i,t;
    1948         DatasetInput*           datasetinput = NULL;
    1949 
    1950         /*Get input if it already exists*/
    1951         Input*  tempinput = GetInput(enum_type);
    1952         if(tempinput){
    1953                 /*Cast it to a Datasetinput*/
    1954                 if(tempinput->ObjectEnum()!=DatasetInputEnum) _error_("don't know what to do");
    1955                 datasetinput = (DatasetInput*)tempinput;
    1956         }
    1957         else{
    1958                 datasetinput=new DatasetInput(enum_type);
    1959                 this->inputs->AddInput(datasetinput);
    1960         }
     1973        int i,t;
    19611974
    19621975        /*Branch on type of vector: nodal or elementary: */
    … …  
    19651978                const int NUM_VERTICES = this->GetNumberOfVertices();
    19661979
    1967                 int        *vertexids   = xNew<int>(NUM_VERTICES);
    1968                 IssmDouble *values      = xNew<IssmDouble>(NUM_VERTICES);
     1980                int        *vertexids  = xNew<int>(NUM_VERTICES);
     1981                int        *vertexlids = xNew<int>(NUM_VERTICES);
     1982                IssmDouble *values     = xNew<IssmDouble>(NUM_VERTICES);
    19691983
    19701984                /*Recover vertices ids needed to initialize inputs*/
    19711985                _assert_(iomodel->elements);
    19721986                for(i=0;i<NUM_VERTICES;i++){
    1973                         vertexids[i]=reCast<int>(iomodel->elements[NUM_VERTICES*this->Sid()+i]); //ids for vertices are in the elements array from Matlab
     1987                        vertexids[i] =reCast<int>(iomodel->elements[NUM_VERTICES*this->Sid()+i]); //ids for vertices are in the elements array from Matlab
     1988                        vertexlids[i]=iomodel->my_vertices_lids[vertexids[i]-1];
    19741989                }
    19751990
    … …  
    19771992                if(M==1){
    19781993                        values[0]=vector[0];
    1979                         switch(this->ObjectEnum()){
    1980                                 case TriaEnum:  datasetinput->AddInput(new TriaInput(input_enum,values,P0Enum),input_id); break;
    1981                                 case PentaEnum: datasetinput->AddInput(new PentaInput(input_enum,values,P0Enum),input_id); break;
    1982                                 case TetraEnum: datasetinput->AddInput(new TetraInput(input_enum,values,P0Enum),input_id); break;
    1983                                 default: _error_("Not implemented yet");
    1984                         }
     1994                        //this->AddInput2(vector_enum,values,P0Enum);
     1995                        _error_("not implemented yet");
    19851996                }
    19861997                else if(M==iomodel->numberofvertices){
    19871998                        for(i=0;i<NUM_VERTICES;i++) values[i]=vector[vertexids[i]-1];
    19881999                        switch(this->ObjectEnum()){
    1989                                 case TriaEnum:  datasetinput->AddInput(new TriaInput(input_enum,values,P1Enum),input_id); break;
    1990                                 case PentaEnum: datasetinput->AddInput(new PentaInput(input_enum,values,P1Enum),input_id); break;
    1991                                 case TetraEnum: datasetinput->AddInput(new TetraInput(input_enum,values,P1Enum),input_id); break;
    1992                                 default: _error_("Not implemented yet");
    1993                         }  }
     2000                                case TriaEnum:  inputs2->SetTriaDatasetInput(enum_type,input_id,P1Enum,NUM_VERTICES,vertexlids,values); break;
     2001                                case PentaEnum: inputs2->SetPentaDatasetInput(enum_type,input_id,P1Enum,NUM_VERTICES,vertexlids,values); break;
     2002                                default: _error_("Not implemented yet for "<<this->ObjectEnum());
     2003                        }
     2004                }
    19942005                else if(M==iomodel->numberofvertices+1){
    19952006                        /*create transient input: */
    19962007                        IssmDouble* times = xNew<IssmDouble>(N);
    19972008                        for(t=0;t<N;t++) times[t] = vector[(M-1)*N+t];
    1998                         TransientInput* transientinput=new TransientInput(input_enum,times,N);
     2009                        TransientInput2* transientinput = inputs2->SetDatasetTransientInput(enum_type,input_id,times,N);
    19992010                        for(t=0;t<N;t++){
    20002011                                for(i=0;i<NUM_VERTICES;i++) values[i]=vector[N*(vertexids[i]-1)+t];
    20012012                                switch(this->ObjectEnum()){
    2002                                         case TriaEnum:  transientinput->AddTimeInput(new TriaInput( input_enum,values,P1Enum)); break;
    2003                                         case PentaEnum: transientinput->AddTimeInput(new PentaInput(input_enum,values,P1Enum)); break;
    2004                                         case TetraEnum: transientinput->AddTimeInput(new TetraInput(input_enum,values,P1Enum)); break;
     2013                                        case TriaEnum:  transientinput->AddTriaTimeInput( t,NUM_VERTICES,vertexlids,values,P1Enum); break;
     2014                                        case PentaEnum: transientinput->AddPentaTimeInput(t,NUM_VERTICES,vertexlids,values,P1Enum); break;
    20052015                                        default: _error_("Not implemented yet");
    20062016                                }
    20072017                        }
    2008                         datasetinput->AddInput(transientinput,input_id);
    20092018                        xDelete<IssmDouble>(times);
    20102019                }
    2011                 else if(M==iomodel->numberofelements){
    2012 
    2013                         /*This is a Patch!*/
    2014                         xDelete<IssmDouble>(values);
    2015                         values = xNew<IssmDouble>(N);
    2016                         for(int j=0;j<N;j++) values[j]=vector[this->Sid()*N+j];
    2017 
    2018                         if     (N==this->GetNumberOfNodes(P1Enum)   ){
    2019                                 switch(this->ObjectEnum()){
    2020                                         case TriaEnum:  datasetinput->AddInput(new TriaInput(input_enum,values,P1Enum),input_id); break;
    2021                                         case PentaEnum: datasetinput->AddInput(new PentaInput(input_enum,values,P1Enum),input_id); break;
    2022                                         case TetraEnum: datasetinput->AddInput(new TetraInput(input_enum,values,P1Enum),input_id); break;
    2023                                         default: _error_("Not implemented yet");
    2024                                 }
    2025                         }
    2026                         else if(N==this->GetNumberOfNodes(P0Enum)   ){
    2027                                 switch(this->ObjectEnum()){
    2028                                         case TriaEnum:  datasetinput->AddInput(new TriaInput(input_enum,values,P0Enum),input_id); break;
    2029                                         case PentaEnum: datasetinput->AddInput(new PentaInput(input_enum,values,P0Enum),input_id); break;
    2030                                         case TetraEnum: datasetinput->AddInput(new TetraInput(input_enum,values,P0Enum),input_id); break;
    2031                                         default: _error_("Not implemented yet");
    2032                                 }
    2033                         }
    2034                         else if(N==this->GetNumberOfNodes(P1xP2Enum)){
    2035                                 switch(this->ObjectEnum()){
    2036                                         case TriaEnum:  datasetinput->AddInput(new TriaInput(input_enum,values,P1xP2Enum),input_id); break;
    2037                                         case PentaEnum: datasetinput->AddInput(new PentaInput(input_enum,values,P1xP2Enum),input_id); break;
    2038                                         case TetraEnum: datasetinput->AddInput(new TetraInput(input_enum,values,P1xP2Enum),input_id); break;
    2039                                         default: _error_("Not implemented yet");
    2040                                 }
    2041                         }
    2042                         else if(N==this->GetNumberOfNodes(P1xP3Enum)) {
    2043                                 switch(this->ObjectEnum()){
    2044                                         case TriaEnum:  datasetinput->AddInput(new TriaInput(input_enum,values,P1xP3Enum),input_id); break;
    2045                                         case PentaEnum: datasetinput->AddInput(new PentaInput(input_enum,values,P1xP3Enum),input_id); break;
    2046                                         case TetraEnum: datasetinput->AddInput(new TetraInput(input_enum,values,P1xP3Enum),input_id); break;
    2047                                         default: _error_("Not implemented yet");
    2048                                 }
    2049                         }
    2050                         else _error_("Patch interpolation not supported yet");
    2051 
    2052                 }
    20532020                else{
    2054                         _error_("nodal vector is either numberofvertices or numberofvertices+1 long. Field provided (" << EnumToStringx(input_enum) << ") is " << M << " long");
     2021                        _error_("not implemented yet (M="<<M<<")");
    20552022                }
    20562023
    20572024                xDelete<IssmDouble>(values);
    20582025                xDelete<int>(vertexids);
     2026                xDelete<int>(vertexlids);
    20592027        }
    20602028        else if(vector_type==2){ //element vector
     2029                _error_("not supported");
    20612030
    20622031                IssmDouble value;
    … …  
    20652034                if(M==iomodel->numberofelements){
    20662035                        if (code==5){ //boolean
    2067                                 datasetinput->AddInput(new BoolInput(input_enum,reCast<bool>(vector[this->Sid()])),input_id);
     2036                                _error_("not implemented");
     2037                                //datasetinput->AddInput(new BoolInput(input_enum,reCast<bool>(vector[this->Sid()])),input_id);
    20682038                        }
    20692039                        else if (code==6){ //integer
    2070                                 datasetinput->AddInput(new IntInput(input_enum,reCast<int>(vector[this->Sid()])),input_id);
     2040                                _error_("not implemented");
     2041                                //datasetinput->AddInput(new IntInput(input_enum,reCast<int>(vector[this->Sid()])),input_id);
    20712042                        }
    20722043                        else if (code==7){ //IssmDouble
    2073                                 datasetinput->AddInput(new DoubleInput(input_enum,vector[this->Sid()]),input_id);
     2044                                _error_("not implemented");
     2045                                //datasetinput->AddInput(new DoubleInput(input_enum,vector[this->Sid()]),input_id);
    20742046                        }
    20752047                        else _error_("could not recognize nature of vector from code " << code);
    20762048                }
    20772049                else if(M==iomodel->numberofelements+1){
     2050                        _error_("not supported");
    20782051                        /*create transient input: */
    20792052                        IssmDouble* times = xNew<IssmDouble>(N);
    … …  
    20902063                                }
    20912064                        }
    2092                         datasetinput->AddInput(transientinput,input_id);
     2065                        //datasetinput->AddInput(transientinput,input_id);
    20932066                        xDelete<IssmDouble>(times);
    20942067                }
    … …  
    20962069        }
    20972070        else if(vector_type==3){ //element vector
     2071                _error_("not supported");
    20982072
    20992073                /*For right now we are static */
    … …  
    21032077                        for(t=0;t<N;t++) layers[t] = vector[N*this->Sid()+t];
    21042078                        DoubleArrayInput* arrayinput=new DoubleArrayInput(input_enum,layers,N);
    2105                         datasetinput->AddInput(arrayinput,input_id);
     2079                        //datasetinput->AddInput(arrayinput,input_id);
    21062080                        xDelete<IssmDouble>(layers);
    21072081                }
    21082082                else _error_("element vector is either numberofelements or numberofelements+1 long. Field provided (" << EnumToStringx(input_enum) << ") is " << M << " long");
    21092083        }
    2110         else _error_("Cannot add input for vector type " << vector_type << " (not supported)");
    2111 }
    2112 /*}}}*/
    2113 void       Element::InputDuplicate(int original_enum,int new_enum){/*{{{*/
    2114 
    2115         if(!IsInputEnum(original_enum)) _error_("Enum "<<EnumToStringx(original_enum)<<" is not in IsInput");
    2116 
    2117         /*Call inputs method*/
    2118         this->inputs->DuplicateInput(original_enum,new_enum);
    2119 
     2084        else{
     2085                _error_("Cannot add input for vector type " << vector_type << " (not supported)");
     2086        }
    21202087}
    21212088/*}}}*/
    … …  
    21262093
    21272094        /*update input*/
    2128         this->inputs->AddInput(new IntInput(name,constant));
     2095        this->SetBoolInput(this->inputs2,name,constant);
    21292096}
    21302097/*}}}*/
    … …  
    21352102
    21362103        /*update input*/
    2137         this->inputs->AddInput(new DoubleInput(name,constant));
     2104        this->SetElementInput(name,constant);
    21382105}
    21392106/*}}}*/
    … …  
    21442111
    21452112        /*update input*/
    2146         this->inputs->AddInput(new BoolInput(name,constant));
    2147 }
    2148 /*}}}*/
     2113        this->SetBoolInput(this->inputs2,name,constant);
     2114}
     2115/*}}}*/
     2116bool       Element::IsOnSurface(){/*{{{*/
     2117        return this->isonsurface;
     2118}/*}}}*/
     2119bool       Element::IsOnBase(){/*{{{*/
     2120        return this->isonbase;
     2121}/*}}}*/
    21492122bool       Element::IsFloating(){/*{{{*/
    21502123
    … …  
    21532126        parameters->FindParam(&migration_style,GroundinglineMigrationEnum);
    21542127
     2128        Input2* input = this->GetInput2(MaskGroundediceLevelsetEnum); _assert_(input);
     2129
    21552130        if(migration_style==SubelementMigrationEnum){ //Floating if all nodes are floating
    2156                 if(this->inputs->Max(MaskGroundediceLevelsetEnum) <= 0.) shelf=true;
     2131                if(input->GetInputMax() <= 0.) shelf=true;
    21572132                else shelf=false;
    21582133        }
    21592134        else if(migration_style==ContactEnum){
    2160                 if(this->inputs->Min(MaskGroundediceLevelsetEnum) < 0.) shelf=true;
     2135                if(input->GetInputMin() < 0.) shelf=true;
    21612136                else shelf=false;
    21622137        }
    21632138        else if(migration_style==NoneEnum || migration_style==AggressiveMigrationEnum || migration_style==SoftMigrationEnum || migration_style==GroundingOnlyEnum){ //Floating if all nodes are floating
    2164                 if(this->inputs->Min(MaskGroundediceLevelsetEnum) > 0.) shelf=false;
     2139                if(input->GetInputMin() > 0.) shelf=false;
    21652140                else shelf=true;
    21662141        }
    … …  
    21712146bool       Element::IsGrounded(){/*{{{*/
    21722147
    2173         if(this->inputs->Max(MaskGroundediceLevelsetEnum) > 0.){
     2148        Input2* input=this->GetInput2(MaskGroundediceLevelsetEnum); _assert_(input);
     2149        if(input->GetInputMax() > 0.){
    21742150                return true;
    21752151        }
    … …  
    21792155}/*}}}*/
    21802156bool       Element::IsIceInElement(){/*{{{*/
    2181         return (this->inputs->Min(MaskIceLevelsetEnum)<0.);
     2157        Input2* input=this->GetInput2(MaskIceLevelsetEnum); _assert_(input);
     2158        return (input->GetInputMin()<0.);
    21822159}
    21832160/*}}}*/
    21842161bool       Element::IsLandInElement(){/*{{{*/
    2185         return (this->inputs->Max(MaskLandLevelsetEnum)>0.);
     2162        Input2* input=this->GetInput2(MaskLandLevelsetEnum); _assert_(input);
     2163        return (input->GetInputMax()>0.);
    21862164}
    21872165/*}}}*/
    … …  
    22112189
    22122190        /* Get parameters and inputs */
    2213         this->inputs->GetInputValue(&basinid,BasalforcingsIsmip6BasinIdEnum);
     2191        this->GetInputValue(&basinid,BasalforcingsIsmip6BasinIdEnum);
    22142192        this->parameters->FindParam(&num_basins,BasalforcingsIsmip6NumBasinsEnum);
    22152193        this->parameters->FindParam(&gamma0,BasalforcingsIsmip6Gamma0Enum);
    … …  
    22192197                this->parameters->FindParam(&mean_tf,&N,BasalforcingsIsmip6AverageTfEnum); _assert_(N==num_basins);
    22202198        }
    2221         Input* tf_input = this->GetInput(BasalforcingsIsmip6TfShelfEnum);              _assert_(tf_input);
    2222         Input* meltanomaly_input = this->GetInput(BasalforcingsIsmip6MeltAnomalyEnum); _assert_(meltanomaly_input);
     2199        Input2* tf_input = this->GetInput2(BasalforcingsIsmip6TfShelfEnum);              _assert_(tf_input);
     2200        Input2* meltanomaly_input = this->GetInput2(BasalforcingsIsmip6MeltAnomalyEnum); _assert_(meltanomaly_input);
    22232201        delta_t_basin = delta_t[basinid];
    22242202        if(!islocal) mean_tf_basin = mean_tf[basinid];
    … …  
    22412219
    22422220        /*Return basal melt rate*/
    2243         this->AddInput(BasalforcingsFloatingiceMeltingRateEnum,basalmeltrate,P1Enum);
     2221        this->AddInput2(BasalforcingsFloatingiceMeltingRateEnum,basalmeltrate,P1DGEnum);
    22442222
    22452223        /*Cleanup and return*/
    … …  
    22522230}/*}}}*/
    22532231bool       Element::IsWaterInElement(){/*{{{*/
    2254         return (this->inputs->Max(MaskOceanLevelsetEnum)>0.);
     2232        Input2* input=this->GetInput2(MaskOceanLevelsetEnum); _assert_(input);
     2233        return (input->GetInputMax()>0.);
    22552234}
    22562235/*}}}*/
    … …  
    22852264        }
    22862265
    2287         this->AddInput(BasalforcingsFloatingiceMeltingRateEnum,values,P1Enum);
     2266        this->AddInput2(BasalforcingsFloatingiceMeltingRateEnum,values,P1Enum);
    22882267        xDelete<IssmDouble>(base);
    22892268        xDelete<IssmDouble>(values);
    … …  
    23112290        }
    23122291
    2313         this->AddInput(BasalforcingsFloatingiceMeltingRateEnum,values,P1Enum);
     2292        this->AddInput2(BasalforcingsFloatingiceMeltingRateEnum,values,P1Enum);
    23142293        xDelete<IssmDouble>(base);
    23152294        xDelete<IssmDouble>(deepwaterel);
    … …  
    23612340        }
    23622341
    2363         this->AddInput(BasalforcingsGeothermalfluxEnum,values,P1Enum);
     2342        this->AddInput2(BasalforcingsGeothermalfluxEnum,values,P1Enum);
    23642343        xDelete<IssmDouble>(xyz_list);
    23652344        xDelete<IssmDouble>(values);
    … …  
    23782357        MARSHALLING(id);
    23792358        MARSHALLING(sid);
     2359        MARSHALLING(lid);
    23802360        MARSHALLING(element_type);
    23812361        MARSHALLING_DYNAMIC(element_type_list,int,numanalyses);
    … …  
    24602440                }
    24612441        }
    2462         this->AddInput(MaskGroundediceLevelsetEnum,&phi[0],P1Enum);
     2442        this->AddInput2(MaskGroundediceLevelsetEnum,&phi[0],P1Enum);
    24632443
    24642444        /*Update inputs*/
    2465         this->AddInput(SurfaceEnum,&s[0],P1Enum);
    2466         this->AddInput(BaseEnum,&b[0],P1Enum);
     2445        this->AddInput2(SurfaceEnum,&s[0],P1Enum);
     2446        this->AddInput2(BaseEnum,&b[0],P1Enum);
    24672447
    24682448        /*Delete*/
    … …  
    25002480        }
    25012481
    2502         this->AddInput(BasalforcingsFloatingiceMeltingRateEnum,values,P1Enum);
     2482        this->AddInput2(BasalforcingsFloatingiceMeltingRateEnum,values,P1Enum);
    25032483        xDelete<IssmDouble>(base);
    25042484        xDelete<IssmDouble>(bed);
    … …  
    25392519        }
    25402520
    2541         this->AddInput(BasalforcingsFloatingiceMeltingRateEnum,values,P1Enum);
     2521        this->AddInput2(BasalforcingsFloatingiceMeltingRateEnum,values,P1Enum);
    25422522        xDelete<IssmDouble>(base);
    25432523        xDelete<IssmDouble>(values);
    … …  
    25542534
    25552535        int i;
     2536        int*        vertexlids=xNew<int>(NUM_VERTICES);
    25562537        IssmDouble* monthlytemperatures=xNew<IssmDouble>(NUM_VERTICES_MONTHS_PER_YEAR);
    25572538        IssmDouble* monthlyprec=xNew<IssmDouble>(NUM_VERTICES_MONTHS_PER_YEAR);
    … …  
    25622543        IssmDouble* tmp=xNew<IssmDouble>(NUM_VERTICES);
    25632544        IssmDouble TdiffTime,PfacTime;
     2545
     2546        /*Recover parameters*/
    25642547        IssmDouble time,yts,time_yr;
    25652548        this->parameters->FindParam(&time,TimeEnum);
    25662549        this->parameters->FindParam(&yts,ConstantsYtsEnum);
     2550        this->GetVerticesLidList(vertexlids);
    25672551        time_yr=floor(time/yts)*yts;
    25682552
    2569         /*Recover present day temperature and precipitation*/
    2570         Input*     input=this->inputs->GetInput(SmbTemperaturesPresentdayEnum);    _assert_(input);
    2571         Input*     input2=this->inputs->GetInput(SmbTemperaturesLgmEnum);          _assert_(input2);
    2572         Input*     input3=this->inputs->GetInput(SmbPrecipitationsPresentdayEnum); _assert_(input3);
    2573         Input*     input4=this->inputs->GetInput(SmbPrecipitationsLgmEnum);        _assert_(input4);
    25742553        /*loop over vertices: */
    25752554        Gauss* gauss=this->NewGauss();
    25762555        for(int month=0;month<12;month++) {
     2556                /*Recover present day temperature and precipitation*/
     2557                Input2* input =this->GetInput2(SmbTemperaturesPresentdayEnum,month/12.*yts);   _assert_(input);
     2558                Input2* input2=this->GetInput2(SmbTemperaturesLgmEnum,month/12.*yts);          _assert_(input2);
     2559                Input2* input3=this->GetInput2(SmbPrecipitationsPresentdayEnum,month/12.*yts); _assert_(input3);
     2560                Input2* input4=this->GetInput2(SmbPrecipitationsLgmEnum,month/12.*yts);        _assert_(input4);
    25772561                for(int iv=0;iv<NUM_VERTICES;iv++) {
    25782562                        gauss->GaussVertex(iv);
    2579                         input->GetInputValue(&TemperaturesPresentday[iv*12+month],gauss,month/12.*yts);
    2580                         input2->GetInputValue(&TemperaturesLgm[iv*12+month],gauss,month/12.*yts);
    2581                         input3->GetInputValue(&PrecipitationsPresentday[iv*12+month],gauss,month/12.*yts);
    2582                         input4->GetInputValue(&PrecipitationsLgm[iv*12+month],gauss,month/12.*yts);
     2563                        input->GetInputValue(&TemperaturesPresentday[iv*12+month],gauss);
     2564                        input2->GetInputValue(&TemperaturesLgm[iv*12+month],gauss);
     2565                        input3->GetInputValue(&PrecipitationsPresentday[iv*12+month],gauss);
     2566                        input4->GetInputValue(&PrecipitationsLgm[iv*12+month],gauss);
    25832567
    25842568                        PrecipitationsPresentday[iv*12+month]=PrecipitationsPresentday[iv*12+month]*yts;
    … …  
    26002584
    26012585        /*Update inputs*/
    2602         TransientInput* NewTemperatureInput = new TransientInput(SmbMonthlytemperaturesEnum);
    2603         TransientInput* NewPrecipitationInput = new TransientInput(SmbPrecipitationEnum);
    26042586        for (int imonth=0;imonth<12;imonth++) {
    26052587                for(i=0;i<NUM_VERTICES;i++) tmp[i]=monthlytemperatures[i*12+imonth];
    26062588                switch(this->ObjectEnum()){
    2607                         case TriaEnum:  NewTemperatureInput->AddTimeInput(new TriaInput(SmbMonthlytemperaturesEnum,&tmp[0],P1Enum),time_yr+imonth/12.*yts); break;
    2608                         case PentaEnum: NewTemperatureInput->AddTimeInput(new PentaInput(SmbMonthlytemperaturesEnum,&tmp[0],P1Enum),time_yr+imonth/12.*yts); break;
    2609                         case TetraEnum: NewTemperatureInput->AddTimeInput(new TetraInput(SmbMonthlytemperaturesEnum,&tmp[0],P1Enum),time_yr+imonth/12.*yts); break;
     2589                        case TriaEnum:  this->inputs2->SetTriaDatasetInput(SmbMonthlytemperaturesEnum,imonth,P1Enum,NUM_VERTICES,vertexlids,tmp); break;
     2590                        case PentaEnum: this->inputs2->SetPentaDatasetInput(SmbMonthlytemperaturesEnum,imonth,P1Enum,NUM_VERTICES,vertexlids,tmp); break;
    26102591                        default: _error_("Not implemented yet");
    26112592                }
    26122593                for(i=0;i<NUM_VERTICES;i++) tmp[i]=monthlyprec[i*12+imonth]/yts;
    26132594                switch(this->ObjectEnum()){
    2614                         case TriaEnum:  NewPrecipitationInput->AddTimeInput(new TriaInput(SmbPrecipitationEnum,&tmp[0],P1Enum),time_yr+imonth/12.*yts); break;
    2615                         case PentaEnum: NewPrecipitationInput->AddTimeInput(new PentaInput(SmbPrecipitationEnum,&tmp[0],P1Enum),time_yr+imonth/12.*yts); break;
    2616                         case TetraEnum: NewPrecipitationInput->AddTimeInput(new TetraInput(SmbPrecipitationEnum,&tmp[0],P1Enum),time_yr+imonth/12.*yts); break;
     2595                        case TriaEnum:  this->inputs2->SetTriaDatasetInput(SmbPrecipitationEnum,imonth,P1Enum,NUM_VERTICES,vertexlids,tmp); break;
     2596                        case PentaEnum: this->inputs2->SetPentaDatasetInput(SmbPrecipitationEnum,imonth,P1Enum,NUM_VERTICES,vertexlids,tmp); break;
    26172597                        default: _error_("Not implemented yet");
    26182598                }
    26192599        }
    2620         NewTemperatureInput->Configure(this->parameters);
    2621         NewPrecipitationInput->Configure(this->parameters);
    2622 
    2623         this->inputs->AddInput(NewTemperatureInput);
    2624         this->inputs->AddInput(NewPrecipitationInput);
    26252600
    26262601        switch(this->ObjectEnum()){
    … …  
    26282603                case PentaEnum:
    26292604                case TetraEnum:
    2630                                                         this->InputExtrude(SmbMonthlytemperaturesEnum,-1);
    2631                                                         this->InputExtrude(SmbPrecipitationEnum,-1);
     2605                                                        this->DatasetInputExtrude(SmbMonthlytemperaturesEnum,-1);
     2606                                                        this->DatasetInputExtrude(SmbPrecipitationEnum,-1);
    26322607                                                        break;
    26332608                default: _error_("Not implemented yet");
    … …  
    26432618        xDelete<IssmDouble>(PrecipitationsLgm);
    26442619        xDelete<IssmDouble>(tmp);
     2620        xDelete<int>(vertexlids);
    26452621
    26462622}
    … …  
    26652641        IssmDouble dist_gl,dist_cf;
    26662642
    2667         inputs->GetInputValue(&basin_id,BasalforcingsPicoBasinIdEnum);
     2643        this->GetInputValue(&basin_id,BasalforcingsPicoBasinIdEnum);
    26682644        IssmDouble boxid_max=reCast<IssmDouble>(max_boxid_basin_list[basin_id])+1.;
    26692645
    2670         Input* dist_gl_input=inputs->GetInput(DistanceToGroundinglineEnum); _assert_(dist_gl_input);
    2671         Input* dist_cf_input=inputs->GetInput(DistanceToCalvingfrontEnum);  _assert_(dist_cf_input);
     2646        Input2* dist_gl_input=this->GetInput2(DistanceToGroundinglineEnum); _assert_(dist_gl_input);
     2647        Input2* dist_cf_input=this->GetInput2(DistanceToCalvingfrontEnum);  _assert_(dist_cf_input);
    26722648
    26732649        /*Get dist_gl and dist_cf at center of element*/
    … …  
    26962672        if(boxid==-1) _error_("No boxid found for element " << this->Sid() << "!");
    26972673
    2698         this->inputs->AddInput(new IntInput(BasalforcingsPicoBoxIdEnum, boxid));
     2674        this->SetIntInput(this->inputs2,BasalforcingsPicoBoxIdEnum, boxid);
    26992675
    27002676}/*}}}*/
    … …  
    27042680
    27052681        int boxid;
    2706         this->inputs->GetInputValue(&boxid,BasalforcingsPicoBoxIdEnum);
     2682        this->GetInputValue(&boxid,BasalforcingsPicoBoxIdEnum);
    27072683        if(loopboxid!=boxid) return;
    27082684
    … …  
    27342710        this->parameters->FindParam(&overturning_coeff,BasalforcingsPicoOverturningCoeffEnum);
    27352711        this->parameters->FindParam(&maxbox,BasalforcingsPicoMaxboxcountEnum);
    2736         this->inputs->GetInputValue(&basinid,BasalforcingsPicoBasinIdEnum);
     2712        this->GetInputValue(&basinid,BasalforcingsPicoBasinIdEnum);
    27372713        this->parameters->FindParam(&isplume, BasalforcingsPicoIsplumeEnum);
    2738         Input* thickness_input=this->GetInput(ThicknessEnum); _assert_(thickness_input);
     2714        Input2* thickness_input=this->GetInput2(ThicknessEnum); _assert_(thickness_input);
    27392715        _assert_(basinid<=num_basins);
    27402716
    … …  
    27812757                }
    27822758
    2783                 if(!isplume) this->AddInput(BasalforcingsFloatingiceMeltingRateEnum,basalmeltrates_shelf,P1Enum);
    2784                 this->AddInput(BasalforcingsPicoSubShelfOceanTempEnum,Tocs,P1Enum);
    2785                 this->AddInput(BasalforcingsPicoSubShelfOceanSalinityEnum,Socs,P1Enum);
    2786                 this->AddInput(BasalforcingsPicoSubShelfOceanOverturningEnum,overturnings,P1Enum);
     2759                if(!isplume) this->AddInput2(BasalforcingsFloatingiceMeltingRateEnum,basalmeltrates_shelf,P1DGEnum);
     2760                this->AddInput2(BasalforcingsPicoSubShelfOceanTempEnum,Tocs,P1DGEnum);
     2761                this->AddInput2(BasalforcingsPicoSubShelfOceanSalinityEnum,Socs,P1DGEnum);
     2762                this->AddInput2(BasalforcingsPicoSubShelfOceanOverturningEnum,overturnings,P1DGEnum);
    27872763
    27882764                /*Cleanup and return*/
    … …  
    28172793                }
    28182794
    2819                 if(!isplume) this->AddInput(BasalforcingsFloatingiceMeltingRateEnum,basalmeltrates_shelf,P1Enum);
    2820                 this->AddInput(BasalforcingsPicoSubShelfOceanTempEnum,Tocs,P1Enum);
    2821                 this->AddInput(BasalforcingsPicoSubShelfOceanSalinityEnum,Socs,P1Enum);
     2795                if(!isplume) this->AddInput2(BasalforcingsFloatingiceMeltingRateEnum,basalmeltrates_shelf,P1DGEnum);
     2796                this->AddInput2(BasalforcingsPicoSubShelfOceanTempEnum,Tocs,P1DGEnum);
     2797                this->AddInput2(BasalforcingsPicoSubShelfOceanSalinityEnum,Socs,P1DGEnum);
    28222798
    28232799                /*Cleanup and return*/
    … …  
    28752851
    28762852        /*Get inputs*/
    2877         Input* zgl_input            = this->GetInput(GroundinglineHeightEnum);                     _assert_(zgl_input);
    2878         Input* toc_input            = this->GetInput(BasalforcingsPicoSubShelfOceanTempEnum);      _assert_(toc_input);
    2879         Input* soc_input            = this->GetInput(BasalforcingsPicoSubShelfOceanSalinityEnum);  _assert_(soc_input);
    2880         Input* base_input           = this->GetInput(BaseEnum);                                    _assert_(base_input);
    2881         Input* baseslopex_input     = this->GetInput(BaseSlopeXEnum);                              _assert_(baseslopex_input);
    2882         Input* baseslopey_input     = this->GetInput(BaseSlopeYEnum);                              _assert_(baseslopey_input);
     2853        Input2* zgl_input         = this->GetInput2(GroundinglineHeightEnum);                     _assert_(zgl_input);
     2854        Input2* toc_input         = this->GetInput2(BasalforcingsPicoSubShelfOceanTempEnum);      _assert_(toc_input);
     2855        Input2* soc_input         = this->GetInput2(BasalforcingsPicoSubShelfOceanSalinityEnum);  _assert_(soc_input);
     2856        Input2* base_input        = this->GetInput2(BaseEnum);                                    _assert_(base_input);
     2857        Input2* baseslopex_input  = this->GetInput2(BaseSlopeXEnum);                              _assert_(baseslopex_input);
     2858        Input2* baseslopey_input  = this->GetInput2(BaseSlopeYEnum);                              _assert_(baseslopey_input);
    28832859        this->FindParam(&yts, ConstantsYtsEnum);
    28842860
    … …  
    29302906
    29312907        /*Save computed melt-rate*/
    2932         this->AddInput(BasalforcingsFloatingiceMeltingRateEnum,basalmeltrates_shelf,P1Enum);
     2908        this->AddInput2(BasalforcingsFloatingiceMeltingRateEnum,basalmeltrates_shelf,P1DGEnum);
    29332909
    29342910        /*Cleanup and return*/
    … …  
    29682944        rlapslgm=this->FindParam(SmbRlapslgmEnum);
    29692945
    2970         /*Recover monthly temperatures and precipitation and compute the yearly mean temperatures*/
    2971         Input*     input=this->inputs->GetInput(SmbMonthlytemperaturesEnum); _assert_(input);
    2972         Input*     input2=this->inputs->GetInput(SmbPrecipitationEnum); _assert_(input2);
    29732946        IssmDouble time,yts,time_yr;
    29742947        this->parameters->FindParam(&time,TimeEnum);
    … …  
    29762949        time_yr=floor(time/yts)*yts;
    29772950
     2951        /*Get inputs*/
     2952        DatasetInput2* dinput =this->GetDatasetInput2(SmbMonthlytemperaturesEnum); _assert_(dinput);
     2953        DatasetInput2* dinput2=this->GetDatasetInput2(SmbPrecipitationEnum);       _assert_(dinput2);
     2954
    29782955        /*loop over vertices: */
    29792956        Gauss* gauss=this->NewGauss();
    29802957        for(int month=0;month<12;month++) {
     2958                /*Recover monthly temperatures and precipitation and compute the yearly mean temperatures*/
     2959
    29812960                for(int iv=0;iv<NUM_VERTICES;iv++) {
    29822961                        gauss->GaussVertex(iv);
    2983                         input->GetInputValue(&monthlytemperatures[iv*12+month],gauss,time_yr+month/12.*yts);
     2962                        dinput->GetInputValue(&monthlytemperatures[iv*12+month],gauss,month);
    29842963                        // yearlytemperatures[iv]=yearlytemperatures[iv]+monthlytemperatures[iv*12+month]*mavg; // Has to be in Kelvin
    29852964                        monthlytemperatures[iv*12+month]=monthlytemperatures[iv*12+month]-273.15; // conversion from Kelvin to celcius for PDD module
    2986                         input2->GetInputValue(&monthlyprec[iv*12+month],gauss,time_yr+month/12.*yts);
     2965                        dinput2->GetInputValue(&monthlyprec[iv*12+month],gauss,month);
    29872966                        monthlyprec[iv*12+month]=monthlyprec[iv*12+month]*yts;
    29882967                }
    … …  
    30042983         *     This parameter is set, if the user wants to define the
    30052984         *     pdd factors regionally, if issetpddfac==1 in the d18opdd method */
    3006         if (issetpddfac==1){
    3007                 input=this->GetInput(SmbPddfacSnowEnum); _assert_(input);
    3008                 input2=this->GetInput(SmbPddfacIceEnum); _assert_(input2);
     2985        Input2* input  = NULL;
     2986        Input2* input2 = NULL;
     2987        if(issetpddfac==1){
     2988                input  = this->GetInput2(SmbPddfacSnowEnum); _assert_(input);
     2989                input2 = this->GetInput2(SmbPddfacIceEnum); _assert_(input2);
    30092990        }
    30102991
    … …  
    30162997
    30172998        /*measure the surface mass balance*/
    3018         for (int iv = 0; iv<NUM_VERTICES; iv++){
     2999        for(int iv = 0; iv<NUM_VERTICES; iv++){
    30193000                gauss->GaussVertex(iv);
    30203001                pddsnowfac=0.;
    … …  
    30513032        switch(this->ObjectEnum()){
    30523033                case TriaEnum:
    3053                         // this->inputs->AddInput(new TriaInput(TemperatureEnum,&yearlytemperatures[0],P1Enum));
    3054                         this->inputs->AddInput(new TriaInput(TemperaturePDDEnum,&yearlytemperatures[0],P1Enum));
    3055                         this->inputs->AddInput(new TriaInput(SmbMassBalanceEnum,&agd[0],P1Enum));
    3056                         this->inputs->AddInput(new TriaInput(SmbAccumulationEnum,&accu[0],P1Enum));
    3057                         this->inputs->AddInput(new TriaInput(SmbMeltEnum,&melt[0],P1Enum));
     3034                        this->AddInput2(TemperaturePDDEnum,&yearlytemperatures[0],P1Enum);
     3035                        this->AddInput2(SmbMassBalanceEnum,&agd[0],P1Enum);
     3036                        this->AddInput2(SmbAccumulationEnum,&accu[0],P1Enum);
     3037                        this->AddInput2(SmbMeltEnum,&melt[0],P1Enum);
    30583038                        break;
    30593039                case PentaEnum:
    … …  
    30663046                                yearlytemperatures[1] = s[1];
    30673047                                yearlytemperatures[2] = s[2];
    3068                                 this->inputs->AddInput(new PentaInput(TemperatureEnum,&yearlytemperatures[0],P1Enum));
     3048                                this->AddInput2(TemperatureEnum,&yearlytemperatures[0],P1Enum);
    30693049
    30703050                                bool isenthalpy;
    … …  
    30773057                                        ThermalToEnthalpy(&enthalpy[4],yearlytemperatures[4],0.,0.);
    30783058                                        ThermalToEnthalpy(&enthalpy[5],yearlytemperatures[5],0.,0.);
    3079                                         this->inputs->AddInput(new PentaInput(EnthalpyEnum,&enthalpy[0],P1Enum));
     3059                                        this->AddInput2(EnthalpyEnum,&enthalpy[0],P1Enum);
    30803060                                }
    30813061                        }
    3082                         this->inputs->AddInput(new PentaInput(SmbMassBalanceEnum,&agd[0],P1Enum));
    3083                         this->inputs->AddInput(new PentaInput(TemperaturePDDEnum,&yearlytemperatures[0],P1Enum));
    3084                         this->InputExtrude(TemperaturePDDEnum,-1);
    3085                         this->InputExtrude(SmbMassBalanceEnum,-1);
    3086                         break;
    3087                 case TetraEnum:
    3088                         if(IsOnSurface()){
    3089                                 GetInputListOnVertices(&s[0],TemperatureEnum);
    3090                                 yearlytemperatures[0] = s[0];
    3091                                 yearlytemperatures[1] = s[1];
    3092                                 yearlytemperatures[2] = s[2];
    3093                                 this->inputs->AddInput(new TetraInput(TemperatureEnum,&yearlytemperatures[0],P1Enum));
    3094                         }
    3095                         this->inputs->AddInput(new TetraInput(SmbMassBalanceEnum,&agd[0],P1Enum));
    3096                         this->inputs->AddInput(new TetraInput(TemperaturePDDEnum,&yearlytemperatures[0],P1Enum));
     3062                        this->AddInput2(SmbMassBalanceEnum,&agd[0],P1Enum);
     3063                        this->AddInput2(TemperaturePDDEnum,&yearlytemperatures[0],P1Enum);
    30973064                        this->InputExtrude(TemperaturePDDEnum,-1);
    30983065                        this->InputExtrude(SmbMassBalanceEnum,-1);
    … …  
    31003067                default: _error_("Not implemented yet");
    31013068        }
    3102         // this->inputs->AddInput(NewTemperatureInput);
    3103         // this->inputs->AddInput(NewPrecipitationInput);
    3104         // this->inputs->AddInput(new TriaVertexInput(ThermalSpcTemperatureEnum,&Tsurf[0]));
    3105 
    3106         //this->InputExtrude(SmbMassBalanceEnum,-1);
    3107         // this->InputExtrude(SmbMonthlytemperaturesEnum,-1);
    3108         // this->InputExtrude(SmbPrecipitationEnum,-1);
    31093069
    31103070        /*clean-up*/
    … …  
    31573117        rlaps=this->FindParam(SmbRlapsEnum);
    31583118
    3159         /*Recover monthly temperatures and precipitation*/
    3160         Input*     input=this->inputs->GetInput(SmbMonthlytemperaturesEnum); _assert_(input);
    3161         Input*     input2=this->inputs->GetInput(SmbPrecipitationEnum); _assert_(input2);
    3162         /*Recover smb correction term */
    3163         Input*     input3=this->inputs->GetInput(SmbSmbCorrEnum); _assert_(input3);
    3164 
    31653119        /* Get time */
    31663120        this->parameters->FindParam(&time,TimeEnum);
    … …  
    31723126        IssmDouble mu           = MU_0*(1000.0*86400.0)*(rho_ice/rho_water);   // (d*deg C)/(mm WE) --> (s*deg C)/(m IE)
    31733127
     3128
    31743129        /*loop over vertices: */
    31753130        Gauss* gauss=this->NewGauss();
    31763131        for(int month=0;month<12;month++){
     3132
     3133                /*Recover monthly temperatures and precipitation*/
     3134                Input2* dinput =this->GetInput2(SmbMonthlytemperaturesEnum,reCast<IssmDouble>(month+1)/12.*yts); _assert_(dinput);
     3135                Input2* dinput2=this->GetInput2(SmbPrecipitationEnum,reCast<IssmDouble>(month+1)/12.*yts);       _assert_(dinput2);
     3136
    31773137                for(int iv=0;iv<NUM_VERTICES;iv++){
    31783138                        gauss->GaussVertex(iv);
    3179                         input->GetInputValue(&monthlytemperatures[iv*12+month],gauss,(month+1)/12.*yts);
     3139                        dinput->GetInputValue(&monthlytemperatures[iv*12+month],gauss);
    31803140                        monthlytemperatures[iv*12+month]=monthlytemperatures[iv*12+month]-273.15; // conversion from Kelvin to celcius for PDD module
    3181                         input2->GetInputValue(&monthlyprec[iv*12+month],gauss,(month+1)/12.*yts);
     3141                        dinput2->GetInputValue(&monthlyprec[iv*12+month],gauss);
    31823142                        monthlyprec[iv*12+month]=monthlyprec[iv*12+month]*yts;
    31833143                }
    … …  
    32163176        switch(this->ObjectEnum()){
    32173177                case TriaEnum:
    3218                         // this->inputs->AddInput(new TriaInput(TemperatureEnum,&yearlytemperatures[0],P1Enum));
    3219                         this->inputs->AddInput(new TriaInput(TemperaturePDDEnum,&yearlytemperatures[0],P1Enum));
    3220                         this->inputs->AddInput(new TriaInput(SmbMassBalanceEnum,&smb[0],P1Enum));
    3221                         this->inputs->AddInput(new TriaInput(SmbAccumulationEnum,&accu[0],P1Enum));
    3222                         this->inputs->AddInput(new TriaInput(SmbMeltEnum,&melt[0],P1Enum));
     3178                        //this->AddInput2(TemperatureEnum,&yearlytemperatures[0],P1Enum);
     3179                        this->AddInput2(TemperaturePDDEnum,&yearlytemperatures[0],P1Enum);
     3180                        this->AddInput2(SmbMassBalanceEnum,&smb[0],P1Enum);
     3181                        this->AddInput2(SmbAccumulationEnum,&accu[0],P1Enum);
     3182                        this->AddInput2(SmbMeltEnum,&melt[0],P1Enum);
    32233183                        break;
    32243184                case PentaEnum:
    … …  
    32363196                                        yearlytemperatures[1] = s[1];
    32373197                                        yearlytemperatures[2] = s[2];
    3238                                         this->inputs->AddInput(new PentaInput(TemperatureEnum,&yearlytemperatures[0],P1Enum));
     3198                                        this->AddInput2(TemperatureEnum,&yearlytemperatures[0],P1Enum);
    32393199                                        if(isenthalpy){
    32403200                                                /*Convert that to enthalpy for the enthalpy model*/
    … …  
    32443204                                                ThermalToEnthalpy(&enthalpy[4],yearlytemperatures[4],0.,0.);
    32453205                                                ThermalToEnthalpy(&enthalpy[5],yearlytemperatures[5],0.,0.);
    3246                                                 this->inputs->AddInput(new PentaInput(EnthalpyEnum,&enthalpy[0],P1Enum));
     3206                                                this->AddInput2(EnthalpyEnum,&enthalpy[0],P1Enum);
    32473207                                        }
    32483208                                }
    32493209                        }
    3250                         this->inputs->AddInput(new PentaInput(SmbMassBalanceEnum,&smb[0],P1Enum));
    3251                         this->inputs->AddInput(new PentaInput(TemperaturePDDEnum,&yearlytemperatures[0],P1Enum));
    3252                         this->inputs->AddInput(new PentaInput(SmbAccumulationEnum,&accu[0],P1Enum));
    3253                         this->inputs->AddInput(new PentaInput(SmbMeltEnum,&melt[0],P1Enum));
     3210                        this->AddInput2(SmbMassBalanceEnum,&smb[0],P1Enum);
     3211                        this->AddInput2(TemperaturePDDEnum,&yearlytemperatures[0],P1Enum);
     3212                        this->AddInput2(SmbAccumulationEnum,&accu[0],P1Enum);
     3213                        this->AddInput2(SmbMeltEnum,&melt[0],P1Enum);
    32543214                        this->InputExtrude(TemperaturePDDEnum,-1);
    32553215                        this->InputExtrude(SmbMassBalanceEnum,-1);
    32563216                        this->InputExtrude(SmbAccumulationEnum,-1);
    32573217                        this->InputExtrude(SmbMeltEnum,-1);
    3258                         break;
    3259                 case TetraEnum:
    3260                         if(IsOnSurface()){
    3261                                 GetInputListOnVertices(&s[0],TemperatureEnum);
    3262                                 yearlytemperatures[0] = s[0];
    3263                                 yearlytemperatures[1] = s[1];
    3264                                 yearlytemperatures[2] = s[2];
    3265                                 this->inputs->AddInput(new TetraInput(TemperatureEnum,&yearlytemperatures[0],P1Enum));
    3266                         }
    3267                         this->inputs->AddInput(new TetraInput(SmbMassBalanceEnum,&smb[0],P1Enum));
    3268                         this->inputs->AddInput(new TetraInput(TemperaturePDDEnum,&yearlytemperatures[0],P1Enum));
    3269                         this->InputExtrude(TemperaturePDDEnum,-1);
    3270                         this->InputExtrude(SmbMassBalanceEnum,-1);
    32713218                        break;
    32723219                default: _error_("Not implemented yet");
    … …  
    33243271                case SigmaNNEnum: this->ComputeSigmaNN(); break;
    33253272                case LambdaSEnum: this->ComputeLambdaS(); break;
    3326                 case NewDamageEnum: this->ComputeNewDamage(); break;
    33273273                case StressIntensityFactorEnum: this->StressIntensityFactor(); break;
    33283274                case CalvingratexEnum:
    … …  
    33593305        }
    33603306
    3361         /*Find input*/
    3362         Input* input=this->inputs->GetInput(output_enum);
    3363 
    33643307        /*If this input is not already in Inputs, maybe it needs to be computed?*/
     3308        Input2* input2 = this->GetInput2(output_enum);
     3309        if(!input2) _error_("input "<<EnumToStringx(output_enum)<<" not found in element");
     3310
     3311        /*Assign output pointer*/
     3312        *pinterpolation   = input2->GetResultInterpolation();
     3313        *pnodesperelement = input2->GetResultNumberOfNodes();
     3314        *parray_size      = input2->GetResultArraySize();
     3315        return;
     3316}/*}}}*/
     3317void       Element::ResultToPatch(IssmDouble* values,int nodesperelement,int output_enum){/*{{{*/
     3318
     3319        Input2* input=this->GetInput2(output_enum);
    33653320        if(!input) _error_("input "<<EnumToStringx(output_enum)<<" not found in element");
    33663321
    3367         /*Assign output pointer*/
    3368         *pinterpolation   = input->GetResultInterpolation();
    3369         *pnodesperelement = input->GetResultNumberOfNodes();
    3370         *parray_size      = input->GetResultArraySize();
    3371 }/*}}}*/
    3372 void       Element::ResultToPatch(IssmDouble* values,int nodesperelement,int output_enum){/*{{{*/
    3373 
    3374         Input* input=this->inputs->GetInput(output_enum);
    3375         if(!input) _error_("input "<<EnumToStringx(output_enum)<<" not found in element");
    3376 
    3377         input->ResultToPatch(values,nodesperelement,this->Sid());
     3322        _error_("not implemented yet ");
     3323        //input->ResultToPatch(values,nodesperelement,this->Sid());
    33783324
    33793325} /*}}}*/
    33803326void       Element::ResultToMatrix(IssmDouble* values,int ncols,int output_enum){/*{{{*/
    33813327
    3382         Input* input=this->inputs->GetInput(output_enum);
     3328        Input2* input=this->GetInput2(output_enum);
    33833329        if(!input) _error_("input "<<EnumToStringx(output_enum)<<" not found in element");
    33843330
    3385         input->ResultToMatrix(values,ncols,this->Sid());
     3331        _error_("not implemented yet");
     3332        //input->ResultToMatrix(values,ncols,this->Sid());
    33863333
    33873334} /*}}}*/
    33883335void       Element::ResultToVector(Vector<IssmDouble>* vector,int output_enum){/*{{{*/
    33893336
    3390         Input* input=this->inputs->GetInput(output_enum);
    3391         if(!input) _error_("input "<<EnumToStringx(output_enum)<<" not found in element");
    3392 
    3393         switch(input->GetResultInterpolation()){
    3394                 case P0Enum:{
    3395                                                         IssmDouble  value;
    3396                                                         bool        bvalue;
    3397                                                         Input*      input = this->GetInput(output_enum); _assert_(input);
    3398                                                         switch(input->ObjectEnum()){
    3399                                                                 case DoubleInputEnum:
    3400                                                                         input->GetInputValue(&value);
    3401                                                                         break;
    3402                                                                 case BoolInputEnum:
    3403                                                                         input->GetInputValue(&bvalue);
    3404                                                                         value=reCast<IssmDouble>(bvalue);
    3405                                                                         break;
    3406                                                                 default:
    3407                                                                         Gauss* gauss = this->NewGauss();
    3408                                                                         input->GetInputValue(&value,gauss);
    3409                                                                         delete gauss;
     3337
     3338                Input2* input2=this->GetInput2(output_enum);
     3339                if(!input2) _error_("input "<<EnumToStringx(output_enum)<<" not found in element");
     3340
     3341                switch(input2->GetResultInterpolation()){
     3342                        case P0Enum:{
     3343                                                                IssmDouble  value;
     3344                                                                bool        bvalue;
     3345                                                                switch(input2->ObjectEnum()){
     3346                                                                        case BoolInputEnum:
     3347                                                                                (xDynamicCast<BoolInput2*>(input2))->GetInput(&bvalue,this->lid);
     3348                                                                                value=reCast<IssmDouble>(bvalue);
     3349                                                                                break;
     3350                                                                        default:
     3351                                                                                Gauss* gauss = this->NewGauss();
     3352                                                                                input2->GetInputValue(&value,gauss);
     3353                                                                                delete gauss;
     3354                                                                }
     3355                                                                vector->SetValue(this->Sid(),value,INS_VAL);
     3356                                                                break;
    34103357                                                        }
    3411                                                         vector->SetValue(this->Sid(),value,INS_VAL);
    3412                                                         break;
    3413                                                 }
    3414                 case P1Enum:{
    3415                                                         const int NUM_VERTICES = this->GetNumberOfVertices();
    3416 
    3417                                                         IssmDouble *values      = xNew<IssmDouble>(NUM_VERTICES);
    3418                                                         int        *connectivity= xNew<int>(NUM_VERTICES);
    3419                                                         int        *sidlist     = xNew<int>(NUM_VERTICES);
    3420 
    3421                                                         this->GetVerticesSidList(sidlist);
    3422                                                         this->GetVerticesConnectivityList(connectivity);
    3423                                                         this->GetInputListOnVertices(values,output_enum);
    3424                                                         for(int i=0;i<NUM_VERTICES;i++) values[i] = values[i]/reCast<IssmDouble>(connectivity[i]);
    3425 
    3426                                                         vector->SetValues(NUM_VERTICES,sidlist,values,ADD_VAL);
    3427 
    3428                                                         xDelete<IssmDouble>(values);
    3429                                                         xDelete<int>(connectivity);
    3430                                                         xDelete<int>(sidlist);
    3431                                                         break;
    3432                                                 }
    3433                 default:
    3434                                          _error_("interpolation "<<EnumToStringx(input->GetResultInterpolation())<<" not supported yet");
    3435         }
     3358                        case P1Enum:{
     3359                                                                const int NUM_VERTICES = this->GetNumberOfVertices();
     3360
     3361                                                                IssmDouble *values      = xNew<IssmDouble>(NUM_VERTICES);
     3362                                                                int        *connectivity= xNew<int>(NUM_VERTICES);
     3363                                                                int        *sidlist     = xNew<int>(NUM_VERTICES);
     3364
     3365                                                                this->GetVerticesSidList(sidlist);
     3366                                                                this->GetVerticesConnectivityList(connectivity);
     3367                                                                this->GetInputListOnVertices(values,output_enum);
     3368                                                                for(int i=0;i<NUM_VERTICES;i++) values[i] = values[i]/reCast<IssmDouble>(connectivity[i]);
     3369
     3370                                                                vector->SetValues(NUM_VERTICES,sidlist,values,ADD_VAL);
     3371
     3372                                                                xDelete<IssmDouble>(values);
     3373                                                                xDelete<int>(connectivity);
     3374                                                                xDelete<int>(sidlist);
     3375                                                                break;
     3376                                                        }
     3377                        default:
     3378                                                 _error_("interpolation "<<EnumToStringx(input2->GetResultInterpolation())<<" not supported yet");
     3379                }
    34363380} /*}}}*/
     3381void       Element::SetBoolInput(Inputs2* inputs2,int enum_in,bool value){/*{{{*/
     3382
     3383        _assert_(inputs2);
     3384        inputs2->SetInput(enum_in,this->lid,value);
     3385
     3386}
     3387/*}}}*/
     3388void       Element::SetIntInput(Inputs2* inputs2,int enum_in,int value){/*{{{*/
     3389
     3390        _assert_(inputs2);
     3391        inputs2->SetInput(enum_in,this->lid,value);
     3392
     3393}
     3394/*}}}*/
    34373395void       Element::SetwiseNodeConnectivity(int* pd_nz,int* po_nz,Node* node,bool* flags,int* flagsindices,int set1_enum,int set2_enum){/*{{{*/
    34383396
    … …  
    34923450        parameters->FindParam(&analysis_type,AnalysisTypeEnum);
    34933451        if(analysis_type==StressbalanceAnalysisEnum){
    3494                 inputs->GetInputValue(&approximation,ApproximationEnum);
     3452                this->GetInput2Value(&approximation,ApproximationEnum);
    34953453                if(approximation==SSAHOApproximationEnum || approximation==SSAFSApproximationEnum){
    34963454                        parameters->FindParam(&numlayers,MeshNumberoflayersEnum);
    … …  
    35493507        rdl=this->FindParam(SmbRdlEnum);
    35503508
    3551         /* Retrieve inputs: */
    3552         Input* dailysnowfall_input=this->GetInput(SmbDailysnowfallEnum); _assert_(dailysnowfall_input);
    3553         Input* dailyrainfall_input=this->GetInput(SmbDailyrainfallEnum); _assert_(dailyrainfall_input);
    3554         Input* dailydlradiation_input=this->GetInput(SmbDailydlradiationEnum); _assert_(dailydlradiation_input);
    3555         Input* dailydsradiation_input=this->GetInput(SmbDailydsradiationEnum); _assert_(dailydsradiation_input);
    3556         Input* dailywindspeed_input=this->GetInput(SmbDailywindspeedEnum); _assert_(dailywindspeed_input);
    3557         Input* dailypressure_input=this->GetInput(SmbDailypressureEnum); _assert_(dailypressure_input);
    3558         Input* dailyairdensity_input=this->GetInput(SmbDailyairdensityEnum); _assert_(dailyairdensity_input);
    3559         Input* dailyairhumidity_input=this->GetInput(SmbDailyairhumidityEnum); _assert_(dailyairhumidity_input);
    3560         Input* dailytemperature_input=this->GetInput(SmbDailytemperatureEnum); _assert_(dailytemperature_input);
    3561 
    35623509        /* Recover info at the vertices: */
    35633510        GetInputListOnVertices(&s[0],SurfaceEnum);
    … …  
    35673514        Gauss* gauss=this->NewGauss();
    35683515        for (int iday = 0; iday < 365; iday++){
    3569                 for(int iv=0;iv<NUM_VERTICES;iv++) {
     3516                /* Retrieve inputs: */
     3517                Input2* dailysnowfall_input    = this->GetInput2(SmbDailysnowfallEnum,time_yr+(iday+1)/365.*yts); _assert_(dailysnowfall_input);
     3518                Input2* dailyrainfall_input    = this->GetInput2(SmbDailyrainfallEnum,time_yr+(iday+1)/365.*yts); _assert_(dailyrainfall_input);
     3519                Input2* dailydlradiation_input = this->GetInput2(SmbDailydlradiationEnum,time_yr+(iday+1)/365.*yts); _assert_(dailydlradiation_input);
     3520                Input2* dailydsradiation_input = this->GetInput2(SmbDailydsradiationEnum,time_yr+(iday+1)/365.*yts); _assert_(dailydsradiation_input);
     3521                Input2* dailywindspeed_input   = this->GetInput2(SmbDailywindspeedEnum,time_yr+(iday+1)/365.*yts); _assert_(dailywindspeed_input);
     3522                Input2* dailypressure_input    = this->GetInput2(SmbDailypressureEnum,time_yr+(iday+1)/365.*yts); _assert_(dailypressure_input);
     3523                Input2* dailyairdensity_input  = this->GetInput2(SmbDailyairdensityEnum,time_yr+(iday+1)/365.*yts); _assert_(dailyairdensity_input);
     3524                Input2* dailyairhumidity_input = this->GetInput2(SmbDailyairhumidityEnum,time_yr+(iday+1)/365.*yts); _assert_(dailyairhumidity_input);
     3525                Input2* dailytemperature_input = this->GetInput2(SmbDailytemperatureEnum,time_yr+(iday+1)/365.*yts); _assert_(dailytemperature_input);
     3526
     3527                for(int iv=0;iv<NUM_VERTICES;iv++){
    35703528                        gauss->GaussVertex(iv);
    35713529                        /* get forcing */
    3572                         dailyrainfall_input->GetInputValue(&dailyrainfall[iv*365+iday],gauss,time_yr+(iday+1)/365.*yts);
    3573                         dailysnowfall_input->GetInputValue(&dailysnowfall[iv*365+iday],gauss,time_yr+(iday+1)/365.*yts);
    3574                         dailydlradiation_input->GetInputValue(&dailydlradiation[iv*365+iday],gauss,time_yr+(iday+1)/365.*yts);
    3575                         dailydsradiation_input->GetInputValue(&dailydsradiation[iv*365+iday],gauss,time_yr+(iday+1)/365.*yts);
    3576                         dailywindspeed_input->GetInputValue(&dailywindspeed[iv*365+iday],gauss,time_yr+(iday+1)/365.*yts);
    3577                         dailypressure_input->GetInputValue(&dailypressure[iv*365+iday],gauss,time_yr+(iday+1)/365.*yts);
    3578                         dailyairdensity_input->GetInputValue(&dailyairdensity[iv*365+iday],gauss,time_yr+(iday+1)/365.*yts);
    3579                         dailyairhumidity_input->GetInputValue(&dailyairhumidity[iv*365+iday],gauss,time_yr+(iday+1)/365.*yts);
    3580                         dailytemperature_input->GetInputValue(&dailytemperature[iv*365+iday],gauss,time_yr+(iday+1)/365.*yts);
     3530                        dailyrainfall_input->GetInputValue(&dailyrainfall[iv*365+iday],gauss);
     3531                        dailysnowfall_input->GetInputValue(&dailysnowfall[iv*365+iday],gauss);
     3532                        dailydlradiation_input->GetInputValue(&dailydlradiation[iv*365+iday],gauss);
     3533                        dailydsradiation_input->GetInputValue(&dailydsradiation[iv*365+iday],gauss);
     3534                        dailywindspeed_input->GetInputValue(&dailywindspeed[iv*365+iday],gauss);
     3535                        dailypressure_input->GetInputValue(&dailypressure[iv*365+iday],gauss);
     3536                        dailyairdensity_input->GetInputValue(&dailyairdensity[iv*365+iday],gauss);
     3537                        dailyairhumidity_input->GetInputValue(&dailyairhumidity[iv*365+iday],gauss);
     3538                        dailytemperature_input->GetInputValue(&dailytemperature[iv*365+iday],gauss);
    35813539
    35823540                        /* Surface temperature correction */
    … …  
    36083566        switch(this->ObjectEnum()){
    36093567                case TriaEnum:
    3610                         this->inputs->AddInput(new TriaInput(TemperatureSEMICEnum,&tsurf_out[0],P1Enum)); // TODO add TemperatureSEMICEnum to EnumDefinitions
    3611                         this->inputs->AddInput(new TriaInput(SmbMassBalanceEnum,&smb_out[0],P1Enum));
    3612                         this->inputs->AddInput(new TriaInput(SmbAccumulationEnum,&saccu_out[0],P1Enum));
    3613                         this->inputs->AddInput(new TriaInput(SmbMeltEnum,&smelt_out[0],P1Enum));
     3568                        this->AddInput2(TemperatureSEMICEnum,&tsurf_out[0],P1Enum); // TODO add TemperatureSEMICEnum to EnumDefinitions
     3569                        this->AddInput2(SmbMassBalanceEnum,&smb_out[0],P1Enum);
     3570                        this->AddInput2(SmbAccumulationEnum,&saccu_out[0],P1Enum);
     3571                        this->AddInput2(SmbMeltEnum,&smelt_out[0],P1Enum);
    36143572                        break;
    36153573                case PentaEnum:
    … …  
    36523610void       Element::SmbGemb(){/*{{{*/
    36533611
     3612        /*only compute SMB at the surface: */
     3613        if (!IsOnSurface()) return;
     3614
    36543615        /*Intermediary variables: {{{*/
    36553616        IssmDouble isinitialized=0.0;
    … …  
    36643625        IssmDouble C=0.0;
    36653626        IssmDouble Tz,Vz=0.0;
    3666         IssmDouble rho_ice, rho_water,aSnow,aIce;
    36673627        IssmDouble time,dt,starttime,finaltime;
    36683628        IssmDouble timeclim=0.0;
    … …  
    37043664        int offsetend=-1;
    37053665        IssmDouble time0, timeend, delta;
    3706 
    37073666        /*}}}*/
    37083667        /*Output variables:{{{ */
    … …  
    37283687        IssmDouble  mAdd = 0.0;
    37293688        IssmDouble  dz_add = 0.0;
    3730 
    37313689        IssmDouble* dzini=NULL;
    37323690        IssmDouble* dini = NULL;
    … …  
    37373695        IssmDouble* aini = NULL;
    37383696        IssmDouble* Tini = NULL;
    3739 
    37403697        int         m=0;
    37413698        int         count=0;
    37423699        /*}}}*/
    37433700
    3744         /*only compute SMB at the surface: */
    3745         if (!IsOnSurface()) return;
    3746 
    37473701        /*Retrieve material properties and parameters:{{{ */
    3748         rho_ice = FindParam(MaterialsRhoIceEnum);
    3749         rho_water = FindParam(MaterialsRhoFreshwaterEnum);
    3750         parameters->FindParam(&aSnow,SmbASnowEnum);
    3751         parameters->FindParam(&aIce,SmbAIceEnum);
     3702        IssmDouble rho_ice  = FindParam(MaterialsRhoIceEnum);
     3703        IssmDouble rho_water = FindParam(MaterialsRhoFreshwaterEnum);
     3704        IssmDouble aSnow     = parameters->FindParam(SmbASnowEnum);
     3705        IssmDouble aIce      = parameters->FindParam(SmbAIceEnum);
    37523706        parameters->FindParam(&time,TimeEnum);                        /*transient core time at which we run the smb core*/
    37533707        parameters->FindParam(&dt,TimesteppingTimeStepEnum);          /*transient core time step*/
    … …  
    37763730        parameters->FindParam(&thermo_scaling,SmbThermoDeltaTScalingEnum);
    37773731        parameters->FindParam(&adThresh,SmbAdThreshEnum);
    3778 
    37793732        /*}}}*/
    37803733        /*Retrieve inputs: {{{*/
    3781         Input* zTop_input=this->GetInput(SmbZTopEnum); _assert_(zTop_input);
    3782         Input* dzTop_input=this->GetInput(SmbDzTopEnum); _assert_(dzTop_input);
    3783         Input* dzMin_input=this->GetInput(SmbDzMinEnum); _assert_(dzMin_input);
    3784         Input* zMax_input=this->GetInput(SmbZMaxEnum); _assert_(zMax_input);
    3785         Input* zMin_input=this->GetInput(SmbZMinEnum); _assert_(zMin_input);
    3786         Input* zY_input=this->GetInput(SmbZYEnum); _assert_(zY_input);
    3787         Input* Tmean_input=this->GetInput(SmbTmeanEnum); _assert_(Tmean_input);
    3788         Input* Vmean_input=this->GetInput(SmbVmeanEnum); _assert_(Vmean_input);
    3789         Input* C_input=this->GetInput(SmbCEnum); _assert_(C_input);
    3790         Input* Tz_input=this->GetInput(SmbTzEnum); _assert_(Tz_input);
    3791         Input* Vz_input=this->GetInput(SmbVzEnum); _assert_(Vz_input);
    3792         Input* Ta_input=this->GetInput(SmbTaEnum); _assert_(Ta_input);
    3793         Input* V_input=this->GetInput(SmbVEnum); _assert_(V_input);
    3794         Input* Dlwr_input=this->GetInput(SmbDlwrfEnum); _assert_(Dlwr_input);
    3795         Input* Dswr_input=this->GetInput(SmbDswrfEnum); _assert_(Dswr_input);
    3796         Input* P_input=this->GetInput(SmbPEnum); _assert_(P_input);
    3797         Input* eAir_input=this->GetInput(SmbEAirEnum); _assert_(eAir_input);
    3798         Input* pAir_input=this->GetInput(SmbPAirEnum); _assert_(pAir_input);
    3799         Input* teValue_input=this->GetInput(SmbTeValueEnum); _assert_(teValue_input);
    3800         Input* aValue_input=this->GetInput(SmbAValueEnum); _assert_(aValue_input);
    3801         Input* isinitialized_input=this->GetInput(SmbIsInitializedEnum); _assert_(isinitialized_input);
     3734        _error_("fix....");
     3735        Input2 *zTop_input          = this->GetInput2(SmbZTopEnum);         _assert_(zTop_input);
     3736        Input2 *dzTop_input         = this->GetInput2(SmbDzTopEnum);        _assert_(dzTop_input);
     3737        Input2 *dzMin_input         = this->GetInput2(SmbDzMinEnum);        _assert_(dzMin_input);
     3738        Input2 *zMax_input          = this->GetInput2(SmbZMaxEnum);         _assert_(zMax_input);
     3739        Input2 *zMin_input          = this->GetInput2(SmbZMinEnum);         _assert_(zMin_input);
     3740        Input2 *zY_input            = this->GetInput2(SmbZYEnum);           _assert_(zY_input);
     3741        Input2 *Tmean_input         = this->GetInput2(SmbTmeanEnum);        _assert_(Tmean_input);
     3742        Input2 *Vmean_input         = this->GetInput2(SmbVmeanEnum);        _assert_(Vmean_input);
     3743        Input2 *C_input             = this->GetInput2(SmbCEnum);            _assert_(C_input);
     3744        Input2 *Tz_input            = this->GetInput2(SmbTzEnum);           _assert_(Tz_input);
     3745        Input2 *Vz_input            = this->GetInput2(SmbVzEnum);           _assert_(Vz_input);
     3746        Input *Ta_input            = this->GetInput(SmbTaEnum);            _assert_(Ta_input);
     3747        Input  *V_input             = this->GetInput(SmbVEnum);             _assert_(V_input);
     3748        Input  *Dlwr_input          = this->GetInput(SmbDlwrfEnum);         _assert_(Dlwr_input);
     3749        Input  *Dswr_input          = this->GetInput(SmbDswrfEnum);         _assert_(Dswr_input);
     3750        Input  *P_input             = this->GetInput(SmbPEnum);             _assert_(P_input);
     3751        Input  *eAir_input          = this->GetInput(SmbEAirEnum);          _assert_(eAir_input);
     3752        Input  *pAir_input          = this->GetInput(SmbPAirEnum);          _assert_(pAir_input);
     3753        Input2 *teValue_input       = this->GetInput2(SmbTeValueEnum);      _assert_(teValue_input);
     3754        Input2 *aValue_input        = this->GetInput2(SmbAValueEnum);       _assert_(aValue_input);
     3755
    38023756        /*Retrieve input values:*/
    38033757        Gauss* gauss=this->NewGauss(1); gauss->GaussPoint(0);
    38043758
     3759        this->GetInputValue(&isinitialized,SmbIsInitializedEnum);
    38053760        zTop_input->GetInputValue(&zTop,gauss);
    38063761        dzTop_input->GetInputValue(&dzTop,gauss);
    … …  
    38163771        teValue_input->GetInputValue(&teValue,gauss);
    38173772        aValue_input->GetInputValue(&aValue,gauss);
    3818         isinitialized_input->GetInputValue(&isinitialized);
    38193773        /*}}}*/
    38203774
    … …  
    40594013
    40604014        /*Save generated inputs: */
     4015        _error_("Fix this mess");
    40614016        this->AddInput(new DoubleArrayInput(SmbDzEnum,dz,m));
    40624017        this->AddInput(new DoubleArrayInput(SmbDEnum,d,m));
    … …  
    42394194
    42404195}/*}}}*/
     4196void       Element::StrainRateESA(IssmDouble* epsilon,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input){/*{{{*/
     4197
     4198        /*Intermediaries*/
     4199        IssmDouble dvx[3];
     4200        IssmDouble dvy[3];
     4201
     4202        /*Check that both inputs have been found*/
     4203        if(!vx_input || !vy_input){
     4204                _error_("Input missing. Here are the input pointers we have for vx: " << vx_input << ", vy: " << vy_input << "\n");
     4205        }
     4206
     4207        /*Get strain rate assuming that epsilon has been allocated*/
     4208        vx_input->GetInputDerivativeValue(&dvx[0],xyz_list,gauss);
     4209        vy_input->GetInputDerivativeValue(&dvy[0],xyz_list,gauss);
     4210        epsilon[0] = dvx[0];    // normal strain rate x-direction
     4211        epsilon[1] = dvy[1]; // normal strain rate y-direction
     4212        epsilon[2] = 0.5*(dvx[1] + dvy[0]); // shear strain rate
     4213        epsilon[3] = 0.5*(dvx[1] - dvy[0]); // rotation rate
     4214
     4215}/*}}}*/
     4216void       Element::StrainRateFS(IssmDouble* epsilon,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input,Input2* vz_input){/*{{{*/
     4217        /*Compute the 3d Strain Rate (6 components):
     4218         *
     4219         * epsilon=[exx eyy ezz exy exz eyz]
     4220         */
     4221
     4222        /*Intermediaries*/
     4223        IssmDouble dvx[3];
     4224        IssmDouble dvy[3];
     4225        IssmDouble dvz[3];
     4226
     4227        /*Check that both inputs have been found*/
     4228        if (!vx_input || !vy_input || !vz_input){
     4229                _error_("Input missing. Here are the input pointers we have for vx: " << vx_input << ", vy: " << vy_input << ", vz: " << vz_input << "\n");
     4230        }
     4231
     4232        /*Get strain rate assuming that epsilon has been allocated*/
     4233        vx_input->GetInputDerivativeValue(&dvx[0],xyz_list,gauss);
     4234        vy_input->GetInputDerivativeValue(&dvy[0],xyz_list,gauss);
     4235        vz_input->GetInputDerivativeValue(&dvz[0],xyz_list,gauss);
     4236
     4237        epsilon[0] = dvx[0];
     4238        epsilon[1] = dvy[1];
     4239        epsilon[2] = dvz[2];
     4240        epsilon[3] = 0.5*(dvx[1] + dvy[0]);
     4241        epsilon[4] = 0.5*(dvx[2] + dvz[0]);
     4242        epsilon[5] = 0.5*(dvy[2] + dvz[1]);
     4243
     4244}/*}}}*/
     4245void       Element::StrainRateHO(IssmDouble* epsilon,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input){/*{{{*/
     4246        /*Compute the 3d Blatter/HOStrain Rate (5 components):
     4247         *
     4248         * epsilon=[exx eyy exy exz eyz]
     4249         *
     4250         * with exz=1/2 du/dz
     4251         *      eyz=1/2 dv/dz
     4252         *
     4253         * the contribution of vz is neglected
     4254         */
     4255
     4256        /*Intermediaries*/
     4257        IssmDouble dvx[3];
     4258        IssmDouble dvy[3];
     4259
     4260        /*Check that both inputs have been found*/
     4261        if (!vx_input || !vy_input){
     4262                _error_("Input missing. Here are the input pointers we have for vx: " << vx_input << ", vy: " << vy_input << "\n");
     4263        }
     4264
     4265        /*Get strain rate assuming that epsilon has been allocated*/
     4266        vx_input->GetInputDerivativeValue(&dvx[0],xyz_list,gauss);
     4267        vy_input->GetInputDerivativeValue(&dvy[0],xyz_list,gauss);
     4268        epsilon[0] = dvx[0];
     4269        epsilon[1] = dvy[1];
     4270        epsilon[2] = 0.5*(dvx[1] + dvy[0]);
     4271        epsilon[3] = 0.5*dvx[2];
     4272        epsilon[4] = 0.5*dvy[2];
     4273
     4274}/*}}}*/
     4275void       Element::StrainRateHO2dvertical(IssmDouble* epsilon,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input){/*{{{*/
     4276        /*Compute the 2d Blatter/HOStrain Rate (2 components):
     4277         *
     4278         * epsilon=[exx exz]
     4279         *
     4280         * with exz=1/2 du/dz
     4281         *
     4282         * the contribution of vz is neglected
     4283         */
     4284
     4285        /*Intermediaries*/
     4286        IssmDouble dvx[3];
     4287
     4288        /*Check that both inputs have been found*/
     4289        if (!vx_input){
     4290                _error_("Input missing. Here are the input pointers we have for vx: " << vx_input <<"\n");
     4291        }
     4292
     4293        /*Get strain rate assuming that epsilon has been allocated*/
     4294        vx_input->GetInputDerivativeValue(&dvx[0],xyz_list,gauss);
     4295        epsilon[0] = dvx[0];
     4296        epsilon[1] = 0.5*dvx[1];
     4297
     4298}/*}}}*/
     4299void       Element::StrainRateSSA(IssmDouble* epsilon,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input){/*{{{*/
     4300
     4301        /*Intermediaries*/
     4302        IssmDouble dvx[3];
     4303        IssmDouble dvy[3];
     4304
     4305        /*Check that both inputs have been found*/
     4306        if(!vx_input || !vy_input){
     4307                _error_("Input missing. Here are the input pointers we have for vx: " << vx_input << ", vy: " << vy_input << "\n");
     4308        }
     4309
     4310        /*Get strain rate assuming that epsilon has been allocated*/
     4311        vx_input->GetInputDerivativeValue(&dvx[0],xyz_list,gauss);
     4312        vy_input->GetInputDerivativeValue(&dvy[0],xyz_list,gauss);
     4313        epsilon[0] = dvx[0];
     4314        epsilon[1] = dvy[1];
     4315        epsilon[2] = 0.5*(dvx[1] + dvy[0]);
     4316
     4317}/*}}}*/
     4318void       Element::StrainRateSSA1d(IssmDouble* epsilon,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input){/*{{{*/
     4319
     4320        /*Intermediaries*/
     4321        IssmDouble dvx[3];
     4322
     4323        /*Check that both inputs have been found*/
     4324        if (!vx_input){
     4325                _error_("Input missing. Here are the input pointers we have for vx: " << vx_input << "\n");
     4326        }
     4327
     4328        /*Get strain rate assuming that epsilon has been allocated*/
     4329        vx_input->GetInputDerivativeValue(&dvx[0],xyz_list,gauss);
     4330        *epsilon = dvx[0];
     4331
     4332}/*}}}*/
    42414333void       Element::StressMaxPrincipalCreateInput(void){/*{{{*/
    42424334
    … …  
    42604352        /*Retrieve all inputs and parameters*/
    42614353        this->GetVerticesCoordinatesBase(&xyz_list);
    4262         Input* sigma_xx_input  = this->GetInput(StressTensorxxEnum); _assert_(sigma_xx_input);
    4263         Input* sigma_yy_input  = this->GetInput(StressTensoryyEnum); _assert_(sigma_yy_input);
    4264         Input* sigma_xy_input  = this->GetInput(StressTensorxyEnum); _assert_(sigma_xy_input);
    4265         Input* sigma_xz_input  = NULL;
    4266         Input* sigma_yz_input  = NULL;
    4267         Input* sigma_zz_input  = NULL;
     4354        Input2* sigma_xx_input  = this->GetInput2(StressTensorxxEnum); _assert_(sigma_xx_input);
     4355        Input2* sigma_yy_input  = this->GetInput2(StressTensoryyEnum); _assert_(sigma_yy_input);
     4356        Input2* sigma_xy_input  = this->GetInput2(StressTensorxyEnum); _assert_(sigma_xy_input);
     4357        Input2* sigma_xz_input  = NULL;
     4358        Input2* sigma_yz_input  = NULL;
     4359        Input2* sigma_zz_input  = NULL;
    42684360        if(dim==3){
    4269                 sigma_xz_input  = this->GetInput(StressTensorxzEnum); _assert_(sigma_xz_input);
    4270                 sigma_yz_input  = this->GetInput(StressTensoryzEnum); _assert_(sigma_yz_input);
    4271                 sigma_zz_input  = this->GetInput(StressTensorzzEnum); _assert_(sigma_zz_input);
     4361                sigma_xz_input  = this->GetInput2(StressTensorxzEnum); _assert_(sigma_xz_input);
     4362                sigma_yz_input  = this->GetInput2(StressTensoryzEnum); _assert_(sigma_yz_input);
     4363                sigma_zz_input  = this->GetInput2(StressTensorzzEnum); _assert_(sigma_zz_input);
    42724364        }
    42734365
    … …  
    43194411
    43204412        /*Create input*/
    4321         this->AddInput(StressMaxPrincipalEnum,maxprincipal,P1Enum);
     4413        this->AddInput2(StressMaxPrincipalEnum,maxprincipal,P1Enum);
    43224414
    43234415        /*Clean up and return*/
    … …  
    46034695        /*Retrieve all inputs and parameters*/
    46044696        this->GetVerticesCoordinates(&xyz_list);
    4605         Input* vx_input        = this->GetInput(VxEnum); _assert_(vx_input);
    4606         Input* vy_input        = this->GetInput(VyEnum); _assert_(vy_input);
    4607         Input* vz_input        = this->GetInput(VzEnum); _assert_(vz_input);
     4697        Input2* vx_input = this->GetInput2(VxEnum); _assert_(vx_input);
     4698        Input2* vy_input = this->GetInput2(VyEnum); _assert_(vy_input);
     4699        Input2* vz_input = this->GetInput2(VzEnum); _assert_(vz_input);
    46084700
    46094701        /*loop over vertices: */
    … …  
    46184710
    46194711        /*Create PentaVertex input, which will hold the basal friction:*/
    4620         this->AddInput(ViscousHeatingEnum,viscousheating,P1Enum);
     4712        this->AddInput2(ViscousHeatingEnum,viscousheating,P1Enum);
    46214713
    46224714        /*Clean up and return*/

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

    r24208 r24335  
    2323class Materials;
    2424class Material;
     25class Inputs2;
    2526class Inputs;
     27class Input2;
    2628class Input;
     29class ElementInput2;
     30class DatasetInput2;
    2731class IoModel;
    2832class Gauss;
    … …  
    3943                int          id;
    4044                int          sid;
     45                int          lid;
    4146                Inputs      *inputs;
     47                Inputs2     *inputs2;
    4248                Node       **nodes;
    4349                Vertex     **vertices;
    4450                Material    *material;
    4551                Parameters  *parameters;
     52                bool         isonsurface;
     53                bool         isonbase;
    4654
    4755                int* element_type_list;
    … …  
    6876                void               SmbGradCompParameterization(void);
    6977                IssmDouble         Divergence(void);
    70                 void               dViscositydBFS(IssmDouble* pdmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input);
    71                 void               dViscositydBHO(IssmDouble* pdmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input);
    72                 void               dViscositydBSSA(IssmDouble* pdmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input);
    73                 void               dViscositydDSSA(IssmDouble* pdmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input);
     78                void               dViscositydBFS(IssmDouble* pdmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input,Input2* vz_input);
     79                void               dViscositydBHO(IssmDouble* pdmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input);
     80                void               dViscositydBSSA(IssmDouble* pdmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input);
     81                void               dViscositydDSSA(IssmDouble* pdmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input);
    7482                void               Echo();
    7583                void               FindParam(bool* pvalue,int paramenum);
    … …  
    8997                void               GetInputListOnNodes(IssmDouble* pvalue,int enumtype,IssmDouble defaultvalue);
    9098                void               GetInputListOnNodesVelocity(IssmDouble* pvalue,int enumtype);
     99                void               GetInputListOnVertices(IssmDouble* pvalue,ElementInput2* input);
    91100                void               GetInputListOnVertices(IssmDouble* pvalue,int enumtype);
    92101                void               GetInputListOnVerticesAtTime(IssmDouble* pvalue,int enumtype,IssmDouble time);
    … …  
    95104                void               GetInputValue(bool* pvalue,int enum_type);
    96105                void               GetInputValue(int* pvalue,int enum_type);
     106                void               GetInput2Value(bool* pvalue,int enum_type);
     107                void               GetInput2Value(int* pvalue,int enum_type);
    97108                void               GetInputValue(IssmDouble* pvalue,int enum_type);
    98109                void               GetInputValue(IssmDouble* pvalue,Gauss* gauss,int enum_type);
    … …  
    124135                int                Id();
    125136                void               InputChangeName(int enum_type,int enum_type_old);
    126                 void               InputCreate(IssmDouble* vector,IoModel* iomodel,int M,int N,int vector_type,int vector_enum,int code);
    127                 void               ControlInputCreate(IssmDouble* doublearray,IssmDouble* independents_min,IssmDouble* independents_max,IoModel* iomodel,int M,int N,int input_enum,int id);
    128                 void                                     DatasetInputAdd(int enum_type,IssmDouble* vector,IoModel* iomodel,int M,int N,int vector_type,int vector_enum,int code,int input_enum);
    129                 void               InputDuplicate(int original_enum,int new_enum);
     137                void               InputCreate(IssmDouble* vector,Inputs2* inputs2,IoModel* iomodel,int M,int N,int vector_type,int vector_enum,int code);
     138                void               ControlInputCreate(IssmDouble* doublearray,IssmDouble* independents_min,IssmDouble* independents_max,Inputs2*inputs2,IoModel* iomodel,int M,int N,IssmDouble scale,int input_enum,int id);
     139                void                                     DatasetInputAdd(int enum_type,IssmDouble* vector,Inputs2* inputs2,IoModel* iomodel,int M,int N,int vector_type,int vector_enum,int code,int input_enum);
    130140                void               InputUpdateFromConstant(IssmDouble constant, int name);
    131141                void               InputUpdateFromConstant(int constant, int name);
    … …  
    134144                bool               IsFloating();
    135145                bool               IsGrounded();
     146                bool               IsOnBase();
     147                bool               IsOnSurface();
    136148                bool               IsIceInElement();
    137149                bool               IsLandInElement();
    … …  
    159171                void               ResultToVector(Vector<IssmDouble>* vector,int output_enum);
    160172                void               SetwiseNodeConnectivity(int* d_nz,int* o_nz,Node* node,bool* flags,int* flagsindices,int set1_enum,int set2_enum);
     173                void               SetBoolInput(Inputs2* inputs2,int enum_in,bool value);
     174
     175                void               SetIntInput(Inputs2* inputs2,int enum_in,int value);
    161176                void               SmbSemic();
    162177                int                Sid();
    … …  
    168183                void               StrainRateSSA(IssmDouble* epsilon,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input);
    169184                void               StrainRateSSA1d(IssmDouble* epsilon,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input);
     185                void               StrainRateESA(IssmDouble* epsilon,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input);
     186                void               StrainRateFS(IssmDouble* epsilon,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input,Input2* vz_input);
     187                void               StrainRateHO(IssmDouble* epsilon,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input);
     188                void               StrainRateHO2dvertical(IssmDouble* epsilon,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input);
     189                void               StrainRateSSA(IssmDouble* epsilon,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input);
     190                void               StrainRateSSA1d(IssmDouble* epsilon,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input);
    170191                void               StressMaxPrincipalCreateInput(void);
    171192                IssmDouble         TotalFloatingBmb(IssmDouble* mask, bool scaled);
    … …  
    204225                virtual void       AddBasalInput(int input_enum, IssmDouble* values, int interpolation_enum)=0;
    205226                virtual void       AddInput(int input_enum, IssmDouble* values, int interpolation_enum)=0;
    206                 virtual void       AddControlInput(int input_enum, IssmDouble* values,IssmDouble* values_min,IssmDouble* values_max, int interpolation_enum,int id){_error_("not supported yet");};
    207                 virtual void       DatasetInputCreate(IssmDouble* array,int M,int N,int* individual_enums,int num_inputs,IoModel* iomodel,int input_enum){_error_("not supported");};
     227                virtual void       AddBasalInput2(int input_enum, IssmDouble* values, int interpolation_enum){_error_("not implemented");};
     228                virtual void       AddInput2(int input_enum, IssmDouble* values, int interpolation_enum){_error_("not implemented");};
     229                virtual void       AddControlInput(int input_enum,Inputs2* inputs2,IoModel* iomodel,IssmDouble* values,IssmDouble* values_min,IssmDouble* values_max, int interpolation_enum,int id){_error_("not supported yet");};
     230                virtual void       DatasetInputCreate(IssmDouble* array,int M,int N,int* individual_enums,int num_inputs,Inputs2* inputs2,IoModel* iomodel,int input_enum){_error_("not supported");};
    208231                virtual void       AverageOntoPartition(Vector<IssmDouble>* partition_contributions,Vector<IssmDouble>* partition_areas,IssmDouble* vertex_response,IssmDouble* qmu_part)=0;
    209232                virtual void             BasalNodeIndices(int* pnumindices,int** pindices,int finiteelement){_error_("not implemented yet");};
    … …  
    219242                virtual void       ComputeStressTensor(void)=0;
    220243                virtual void       ComputeEsaStrainAndVorticity(void)=0;
    221                 virtual void       Configure(Elements* elements,Loads* loads,Nodes* nodes,Vertices* vertices,Materials* materials,Parameters* parameters)=0;
     244                virtual void       Configure(Elements* elements,Loads* loads,Nodes* nodes,Vertices* vertices,Materials* materials,Parameters* parameters,Inputs2* inputs2in)=0;
    222245                virtual void       ControlInputSetGradient(IssmDouble* gradient,int enum_type,int control_index,int offset,int N,int M)=0;
    223246                virtual void       ControlInputSetGradient(IssmDouble* gradient,int enum_type,int control_index)=0;
    … …  
    236259                virtual IssmDouble GetIcefrontArea(){_error_("not implemented");};
    237260                virtual void       GetIcefrontCoordinates(IssmDouble** pxyz_front,IssmDouble* xyz_list,int levelsetenum)=0;
     261                virtual DatasetInput2* GetDatasetInput2(int inputenum){_error_("not implemented");};
     262                virtual Input2*    GetInput2(int inputenum)=0;
     263                virtual Input2*    GetInput2(int inputenum,IssmDouble time)=0;
    238264                virtual void       GetInputValue(IssmDouble* pvalue,Vertex* vertex,int enumtype){_error_("not implemented yet");};
    239265                virtual void       GetInputValue(IssmDouble* pvalue,Node* node,int enumtype){_error_("not implemented yet");};
    … …  
    255281                virtual IssmDouble GroundinglineMassFlux(bool scaled){_error_("not implemented");};
    256282                virtual void       InputDepthAverageAtBase(int enum_type,int average_enum_type)=0;
     283                virtual void       DatasetInputExtrude(int input_enum,int start){_error_("not implemented yet");};
    257284                virtual void       InputExtrude(int input_enum,int start)=0;
    258285                virtual void       InputUpdateFromSolutionOneDofCollapsed(IssmDouble* solution,int inputenum)=0;
    … …  
    267294                virtual bool       IsIcefront(void)=0;
    268295                virtual bool       IsNodeOnShelfFromFlags(IssmDouble* flags)=0;
    269                 virtual bool       IsOnBase()=0;
    270                 virtual bool       IsOnSurface()=0;
     296
    271297                virtual bool       IsZeroLevelset(int levelset_enum)=0;
    272298                virtual void       JacobianDeterminant(IssmDouble*  Jdet, IssmDouble* xyz_list,Gauss* gauss)=0;
    … …  
    284310                virtual Gauss*     NewGauss(void)=0;
    285311                virtual Gauss*     NewGauss(int order)=0;
    286       virtual Gauss*     NewGauss(IssmDouble* xyz_list, IssmDouble* xyz_list_front,int order)=0;
    287       virtual Gauss*     NewGauss(IssmDouble* xyz_list, IssmDouble* xyz_list_front,int order_horiz,int order_vert)=0;
    288       virtual Gauss*     NewGauss(int point1,IssmDouble fraction1,IssmDouble fraction2,bool mainlyfloating,int order)=0;
    289       virtual Gauss*     NewGauss(int point1,IssmDouble fraction1,IssmDouble fraction2,int order)=0;
     312                virtual Gauss*     NewGauss(IssmDouble* xyz_list, IssmDouble* xyz_list_front,int order)=0;
     313                virtual Gauss*     NewGauss(IssmDouble* xyz_list, IssmDouble* xyz_list_front,int order_horiz,int order_vert)=0;
     314                virtual Gauss*     NewGauss(int point1,IssmDouble fraction1,IssmDouble fraction2,bool mainlyfloating,int order)=0;
     315                virtual Gauss*     NewGauss(int point1,IssmDouble fraction1,IssmDouble fraction2,int order)=0;
    290316                virtual Gauss*     NewGaussBase(int order)=0;
    291317                virtual Gauss*     NewGaussLine(int vertex1,int vertex2,int order)=0;
    … …  
    313339                virtual void       ResetHooks()=0;
    314340                virtual void       RignotMeltParameterization(void){_error_("not implemented yet");};
     341                virtual void       SetElementInput(int enum_in,IssmDouble values){_error_("not implemented yet");};
     342                virtual void       SetElementInput(Inputs2* inputs2,int enum_in,IssmDouble values){_error_("not implemented yet");};
     343                virtual void       SetElementInput(Inputs2* inputs2,int numindices,int* indices,IssmDouble* values,int enum_in){_error_("not implemented yet");};
    315344                virtual void       SetControlInputsFromVector(IssmDouble* vector,int control_enum,int control_index,int offset,int N,int M)=0;
    316345                virtual void       SetControlInputsFromVector(IssmDouble* vector,int control_enum,int control_index)=0;
    … …  
    332361                virtual IssmDouble TotalGroundedBmb(bool scaled)=0;
    333362                virtual IssmDouble TotalSmb(bool scaled)=0;
    334                 virtual void       Update(int index, IoModel* iomodel,int analysis_counter,int analysis_type,int finite_element)=0;
     363                virtual void       Update(Inputs2* inputs2,int index, IoModel* iomodel,int analysis_counter,int analysis_type,int finite_element)=0;
    335364                virtual void       UpdateConstraintsExtrudeFromBase(void)=0;
    336365                virtual void       UpdateConstraintsExtrudeFromTop(void)=0;
    … …  
    342371                virtual void       VerticalSegmentIndices(int** pindices,int* pnumseg)=0;
    343372                virtual void       VerticalSegmentIndicesBase(int** pindices,int* pnumseg)=0;
    344                 virtual void       ViscousHeating(IssmDouble* pphi,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input)=0;
     373                virtual void       ViscousHeating(IssmDouble* pphi,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input,Input2* vz_input){_error_("not implemented yet");};
    345374                virtual void       WriteFieldIsovalueSegment(DataSet* segments,int fieldenum,IssmDouble fieldvalue){_error_("not implemented yet");};
    346375

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

    r20810 r24335  
    3434
    3535/*Object management*/
    36 void Elements::Configure(Elements* elements,Loads* loads, Nodes* nodes, Vertices* vertices, Materials* materials,Parameters* parameters){/*{{{*/
     36void Elements::Configure(Elements* elements,Loads* loads, Nodes* nodes, Vertices* vertices, Materials* materials,Parameters* parameters,Inputs2* inputs2){/*{{{*/
    3737
    3838        vector<Object*>::iterator object;
    39         Element* element=NULL;
    4039
    41         for ( object=objects.begin() ; object < objects.end(); object++ ){
    42 
    43                 element=xDynamicCast<Element*>((*object));
    44                 element->Configure(elements,loads,nodes,vertices,materials,parameters);
    45 
     40        for(object=objects.begin() ; object < objects.end(); object++ ){
     41                Element* element=xDynamicCast<Element*>((*object));
     42                element->Configure(elements,loads,nodes,vertices,materials,parameters,inputs2);
    4643        }
    4744
    48 }
    49 /*}}}*/
    50 void Elements::InputDuplicate(int input_enum,int output_enum){/*{{{*/
    51 
    52         for(int i=0;i<this->Size();i++){
    53                 Element* element=xDynamicCast<Element*>(this->GetObjectByOffset(i));
    54                 element->InputDuplicate(input_enum,output_enum);
    55         }
    56 }
    57 /*}}}*/
     45}/*}}}*/
    5846int  Elements::MaxNumNodes(void){/*{{{*/
    5947

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

    r20810 r24335  
    2424
    2525                /*numerics*/
    26                 void   Configure(Elements* elements,Loads* loads, Nodes* nodes, Vertices* vertices, Materials* materials,Parameters* parameters);
    27                 void   InputDuplicate(int input_enum,int output_enum);
     26                void   Configure(Elements* elements,Loads* loads, Nodes* nodes, Vertices* vertices, Materials* materials,Parameters* parameters,Inputs2* inputs2);
    2827                int    MaxNumNodes(void);
    2928                int    NumberOfElements(void);

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

    r24240 r24335  
    1212
    1313#include "../classes.h"
     14#include "../Inputs2/PentaInput2.h"
     15#include "../Inputs2/ControlInput2.h"
     16#include "../Inputs2/TransientInput2.h"
     17#include "../Inputs2/DatasetInput2.h"
    1418#include "../../shared/shared.h"
    1519/*}}}*/
    … …  
    2428}
    2529/*}}}*/
    26 Penta::Penta(int penta_id, int penta_sid,IoModel* iomodel,int nummodels)/*{{{*/
     30Penta::Penta(int penta_id, int penta_sid,int penta_lid,IoModel* iomodel,int nummodels)/*{{{*/
    2731        :ElementHook(nummodels,penta_id,NUMVERTICES,iomodel){
    2832
    … …  
    3640        this->id  = penta_id;
    3741        this->sid = penta_sid;
     42        this->lid = penta_lid;
     43
     44        /*surface and base*/
     45        this->isonsurface = false;
     46        this->isonbase    = false;
    3847
    3948        /*Build neighbors list*/
    … …  
    5867        /*Only allocate pointer*/
    5968        this->element_type_list=xNew<int>(nummodels);
     69
     70        /*surface and base*/
     71        _assert_(iomodel->Data("md.mesh.vertexonsurface"));
     72        _assert_(iomodel->Data("md.mesh.vertexonbase"));
     73        this->isonsurface = false;
     74        this->isonbase    = false;
     75        IssmDouble sum = 0.;
     76        for(int i=0;i<NUMVERTICES;i++) sum += iomodel->Data("md.mesh.vertexonsurface")[reCast<int>(iomodel->elements[(penta_id-1)*NUMVERTICES+i])-1];
     77        _assert_(sum>=0 && sum<4);
     78        if(sum>2.5) this->isonsurface = true;
     79        sum = 0.;
     80        for(int i=0;i<NUMVERTICES;i++) sum += iomodel->Data("md.mesh.vertexonbase")[reCast<int>(iomodel->elements[(penta_id-1)*NUMVERTICES+i])-1];
     81        _assert_(sum>=0 && sum<4);
     82        if(sum>2.5) this->isonbase = true;
    6083}
    6184/*}}}*/
    … …  
    98121        penta->id  = this->id;
    99122        penta->sid = this->sid;
     123        penta->lid = this->lid;
    100124        if(this->inputs) penta->inputs = (Inputs*)(this->inputs->Copy());
    101125        else penta->inputs=new Inputs();
     126        penta->isonbase  = this->isonbase;
     127        penta->isonsurface  = this->isonsurface;
    102128
    103129        /*point parameters: */
    … …  
    123149
    124150        MARSHALLING_ENUM(PentaEnum);
     151        MARSHALLING(this->isonsurface);
     152        MARSHALLING(this->isonbase);
    125153
    126154        /*Call parent classes: */
    … …  
    137165
    138166/*Other*/
     167void       Penta::AddBasalInput2(int input_enum,IssmDouble* values, int interpolation_enum){/*{{{*/
     168
     169        _assert_(this->inputs2);
     170        if(!IsOnBase()) return;
     171        else{
     172                if(interpolation_enum==P1Enum){
     173                        IssmDouble extrudedvalues[NUMVERTICES];
     174                        for(int i=0;i<NUMVERTICES2D;i++){
     175                                extrudedvalues[i]=values[i];
     176                                extrudedvalues[i+NUMVERTICES2D]=values[i];
     177                        }
     178                        Penta* penta=this;
     179                        for(;;){
     180                                penta->AddInput2(input_enum,&extrudedvalues[0],P1Enum);
     181                                if (penta->IsOnSurface()) break;
     182                                penta=penta->GetUpperPenta(); _assert_(penta->Id()!=this->id);
     183                        }
     184                }
     185                else _error_("not implemented yet");
     186        }
     187
     188}
     189/*}}}*/
     190void       Penta::AddInput2(int input_enum,IssmDouble* values, int interpolation_enum){/*{{{*/
     191
     192        /**/
     193        int vertexlids[NUMVERTICES];
     194
     195        /*Call inputs method*/
     196        _assert_(this->inputs2);
     197        switch(interpolation_enum){
     198                case P1Enum:
     199                        for(int i=0;i<NUMVERTICES;i++) vertexlids[i]=this->vertices[i]->lid;
     200                        inputs2->SetPentaInput(input_enum,interpolation_enum,NUMVERTICES,vertexlids,values);
     201                        break;
     202                case P1DGEnum:
     203                        inputs2->SetPentaInput(input_enum,interpolation_enum,this->lid,NUMVERTICES,values);
     204                        break;
     205                default:
     206                        inputs2->SetPentaInput(input_enum,interpolation_enum,this->lid,this->GetNumberOfNodes(interpolation_enum),values);
     207        }
     208
     209}
     210/*}}}*/
    139211void       Penta::AddBasalInput(int input_enum,IssmDouble* values, int interpolation_enum){/*{{{*/
    140212
    … …  
    165237
    166238        _assert_(this->inputs);
     239        printf("-------------- file: Penta.cpp line: %i\n",__LINE__);
    167240        this->inputs->AddInput(new PentaInput(input_enum,values,interpolation_enum));
     241}
     242/*}}}*/
     243void       Penta::AddControlInput(int input_enum,Inputs2* inputs2,IoModel* iomodel,IssmDouble* values,IssmDouble* values_min,IssmDouble* values_max, int interpolation_enum,int id){/*{{{*/
     244
     245        /*Intermediaries*/
     246        int vertexlids[NUMVERTICES];
     247
     248        _assert_(iomodel->elements);
     249        for(int i=0;i<NUMVERTICES;i++){
     250                int vertexid =reCast<int>(iomodel->elements[NUMVERTICES*this->Sid()+i]); //ids for vertices are in the elements array from Matlab
     251                vertexlids[i]=iomodel->my_vertices_lids[vertexid-1];
     252        }
     253
     254        /*Call inputs method*/
     255        switch(interpolation_enum){
     256                case P1Enum:
     257                        inputs2->SetPentaControlInput(input_enum,PentaInput2Enum,interpolation_enum,id,NUMVERTICES,vertexlids,values,values_min,values_max);
     258                        break;
     259                default:
     260                        _error_("Cannot add \""<<EnumToStringx(input_enum)<<"\" interpolation "<<EnumToStringx(interpolation_enum)<<" not supported");
     261        }
     262
     263}
     264/*}}}*/
     265void       Penta::DatasetInputCreate(IssmDouble* array,int M,int N,int* individual_enums,int num_inputs,Inputs2* inputs2,IoModel* iomodel,int input_enum){/*{{{*/
     266
     267        _error_("not implemeted");
     268        IssmDouble nodeinputs[NUMVERTICES];
     269        if(num_inputs<1) _error_("Cannot create a DatasetInput of size <1");
     270        if(M!=iomodel->numberofvertices) _error_("not supported yet");
     271        if(N!=num_inputs) _error_("sizes are not consistent");
     272
     273        int penta_vertex_ids[NUMVERTICES];
     274
     275        for(int k=0;k<6;k++){
     276                penta_vertex_ids[k]=reCast<int>(iomodel->elements[6*this->Sid()+k]); //ids for vertices are in the elements array from Matlab
     277        }
     278        /*Create inputs and add to DataSetInput*/
     279        DatasetInput* datasetinput=new DatasetInput(input_enum);
     280        for(int i=0;i<num_inputs;i++){
     281                for(int j=0;j<NUMVERTICES;j++)nodeinputs[j]=array[(penta_vertex_ids[j]-1)*N+i];
     282                datasetinput->AddInput(new PentaInput(input_enum,nodeinputs,P1Enum),individual_enums[i]);
     283        }
     284
     285        /*Add datasetinput to element inputs*/
     286        this->inputs->AddInput(datasetinput);
    168287}
    169288/*}}}*/
    … …  
    201320
    202321        /*Retrieve all inputs and parameters we will need*/
    203         Input* vx_input = inputs->GetInput(VxAverageEnum); _assert_(vx_input);
    204         Input* vy_input = inputs->GetInput(VyAverageEnum); _assert_(vy_input);
    205         Input* gr_input = inputs->GetInput(MaskGroundediceLevelsetEnum); _assert_(gr_input);
    206         Input* bs_input = inputs->GetInput(BaseEnum);                    _assert_(bs_input);
    207         Input* B_input  = inputs->GetInput(MaterialsRheologyBbarEnum);   _assert_(B_input);
    208         Input* n_input  = inputs->GetInput(MaterialsRheologyNEnum);   _assert_(n_input);
    209         Input* smax_fl_input = inputs->GetInput(CalvingStressThresholdFloatingiceEnum); _assert_(smax_fl_input);
    210         Input* smax_gr_input = inputs->GetInput(CalvingStressThresholdGroundediceEnum); _assert_(smax_gr_input);
    211         Input* sl_input  = inputs->GetInput(SealevelEnum); _assert_(sl_input);
     322        Input2* vx_input = this->GetInput2(VxAverageEnum); _assert_(vx_input);
     323        Input2* vy_input = this->GetInput2(VyAverageEnum); _assert_(vy_input);
     324        Input2* gr_input = this->GetInput2(MaskGroundediceLevelsetEnum); _assert_(gr_input);
     325        Input2* bs_input = this->GetInput2(BaseEnum);                    _assert_(bs_input);
     326        Input2* B_input  = this->GetInput2(MaterialsRheologyBbarEnum);   _assert_(B_input);
     327        Input2* n_input  = this->GetInput2(MaterialsRheologyNEnum);   _assert_(n_input);
     328        Input2* smax_fl_input = this->GetInput2(CalvingStressThresholdFloatingiceEnum); _assert_(smax_fl_input);
     329        Input2* smax_gr_input = this->GetInput2(CalvingStressThresholdGroundediceEnum); _assert_(smax_gr_input);
     330        Input2* sl_input  = this->GetInput2(SealevelEnum); _assert_(sl_input);
    212331
    213332        /* Start looping on the number of vertices: */
    … …  
    263382
    264383        /*Add input*/
    265         this->inputs->AddInput(new PentaInput(CalvingratexEnum,&calvingratex[0],P1Enum));
    266         this->inputs->AddInput(new PentaInput(CalvingrateyEnum,&calvingratey[0],P1Enum));
    267         this->inputs->AddInput(new PentaInput(CalvingCalvingrateEnum,&calvingrate[0],P1Enum));
    268         this->inputs->AddInput(new PentaInput(SigmaVMEnum,&sigma_vm[0],P1Enum));
     384        this->AddInput2(CalvingratexEnum,&calvingratex[0],P1DGEnum);
     385        this->AddInput2(CalvingrateyEnum,&calvingratey[0],P1DGEnum);
     386        this->AddInput2(CalvingCalvingrateEnum,&calvingrate[0],P1DGEnum);
     387        this->AddInput2(SigmaVMEnum,&sigma_vm[0],P1DGEnum);
    269388
    270389        this->InputExtrude(CalvingratexEnum,-1);
    … …  
    293412
    294413        /*Retrieve all inputs and parameters we will need*/
    295         Input* vx_input=inputs->GetInput(VxEnum);                                                                                                                                               _assert_(vx_input);
    296         Input* vy_input=inputs->GetInput(VyEnum);                                                                                                                                               _assert_(vy_input);
    297         Input* strainparallel_input=inputs->GetInput(StrainRateparallelEnum);                                                           _assert_(strainparallel_input);
    298         Input* strainperpendicular_input=inputs->GetInput(StrainRateperpendicularEnum);              _assert_(strainperpendicular_input);
    299         Input* levermanncoeff_input=inputs->GetInput(CalvinglevermannCoeffEnum);                     _assert_(levermanncoeff_input);
     414        Input2* vx_input=this->GetInput2(VxEnum);                                                                                                                                               _assert_(vx_input);
     415        Input2* vy_input=this->GetInput2(VyEnum);                                                                                                                                               _assert_(vy_input);
     416        Input2* strainparallel_input=this->GetInput2(StrainRateparallelEnum);                                                           _assert_(strainparallel_input);
     417        Input2* strainperpendicular_input=this->GetInput2(StrainRateperpendicularEnum);              _assert_(strainperpendicular_input);
     418        Input2* levermanncoeff_input=this->GetInput2(CalvinglevermannCoeffEnum);                     _assert_(levermanncoeff_input);
    300419
    301420        /* Start looping on the number of vertices: */
    … …  
    322441
    323442        /*Add input*/
    324         this->inputs->AddInput(new PentaInput(CalvingratexEnum,&calvingratex[0],P1Enum));
    325         this->inputs->AddInput(new PentaInput(CalvingrateyEnum,&calvingratey[0],P1Enum));
    326         this->inputs->AddInput(new PentaInput(CalvingCalvingrateEnum,&calvingrate[0],P1Enum));
     443        this->AddInput2(CalvingratexEnum,&calvingratex[0],P1DGEnum);
     444        this->AddInput2(CalvingrateyEnum,&calvingratey[0],P1DGEnum);
     445        this->AddInput2(CalvingCalvingrateEnum,&calvingrate[0],P1DGEnum);
    327446
    328447        /*Clean up and return*/
    … …  
    336455        if(!IsIceInElement() || !IsZeroLevelset(MaskIceLevelsetEnum)){
    337456                IssmDouble flux_per_area=0;
    338                 this->inputs->AddInput(new PentaInput(CalvingFluxLevelsetEnum,&flux_per_area,P0Enum));
     457                this->AddInput2(CalvingFluxLevelsetEnum,&flux_per_area,P0Enum);
    339458        }
    340459        else{
    … …  
    424543                IssmDouble calvingratex,calvingratey,thickness,Jdet,flux_per_area;
    425544                IssmDouble rho_ice=FindParam(MaterialsRhoIceEnum);
    426                 Input* thickness_input=inputs->GetInput(ThicknessEnum); _assert_(thickness_input);
    427                 Input* calvingratex_input=NULL;
    428                 Input* calvingratey_input=NULL;
    429                 calvingratex_input=inputs->GetInput(CalvingratexEnum); _assert_(calvingratex_input);
    430                 calvingratey_input=inputs->GetInput(CalvingrateyEnum); _assert_(calvingratey_input);
     545                Input2* thickness_input=this->GetInput2(ThicknessEnum); _assert_(thickness_input);
     546                Input2* calvingratex_input=NULL;
     547                Input2* calvingratey_input=NULL;
     548                calvingratex_input=this->GetInput2(CalvingratexEnum); _assert_(calvingratex_input);
     549                calvingratey_input=this->GetInput2(CalvingrateyEnum); _assert_(calvingratey_input);
    431550
    432551                /*Start looping on Gaussian points*/
    … …  
    446565                }
    447566
    448                 this->inputs->AddInput(new PentaInput(CalvingFluxLevelsetEnum,&flux_per_area,P0Enum));
     567                this->AddInput2(CalvingFluxLevelsetEnum,&flux_per_area,P0Enum);
    449568
    450569                /*Clean up and return*/
    … …  
    458577        if(!IsIceInElement() || !IsZeroLevelset(MaskIceLevelsetEnum)){
    459578                IssmDouble flux_per_area=0;
    460                 this->inputs->AddInput(new PentaInput(CalvingMeltingFluxLevelsetEnum,&flux_per_area,P0Enum));
     579                this->AddInput2(CalvingMeltingFluxLevelsetEnum,&flux_per_area,P0Enum);
    461580        }
    462581        else{
    … …  
    546665                IssmDouble calvingratex,calvingratey,vx,vy,vel,meltingrate,meltingratex,meltingratey,thickness,Jdet,flux_per_area;
    547666                IssmDouble rho_ice=FindParam(MaterialsRhoIceEnum);
    548                 Input* thickness_input=inputs->GetInput(ThicknessEnum); _assert_(thickness_input);
    549                 Input* calvingratex_input=NULL;
    550                 Input* calvingratey_input=NULL;
    551                 Input* vx_input=NULL;
    552                 Input* vy_input=NULL;
    553                 Input* meltingrate_input=NULL;
    554                 calvingratex_input=inputs->GetInput(CalvingratexEnum); _assert_(calvingratex_input);
    555                 calvingratey_input=inputs->GetInput(CalvingrateyEnum); _assert_(calvingratey_input);
    556                 vx_input=inputs->GetInput(VxEnum); _assert_(vx_input);
    557                 vy_input=inputs->GetInput(VyEnum); _assert_(vy_input);
    558                 meltingrate_input=inputs->GetInput(CalvingMeltingrateEnum); _assert_(meltingrate_input);
     667                Input2* thickness_input=this->GetInput2(ThicknessEnum); _assert_(thickness_input);
     668                Input2* calvingratex_input=NULL;
     669                Input2* calvingratey_input=NULL;
     670                Input2* vx_input=NULL;
     671                Input2* vy_input=NULL;
     672                Input2* meltingrate_input=NULL;
     673                calvingratex_input=this->GetInput2(CalvingratexEnum); _assert_(calvingratex_input);
     674                calvingratey_input=this->GetInput2(CalvingrateyEnum); _assert_(calvingratey_input);
     675                vx_input=this->GetInput2(VxEnum); _assert_(vx_input);
     676                vy_input=this->GetInput2(VyEnum); _assert_(vy_input);
     677                meltingrate_input=this->GetInput2(CalvingMeltingrateEnum); _assert_(meltingrate_input);
    559678
    560679                /*Start looping on Gaussian points*/
    … …  
    580699                }
    581700
    582                 this->inputs->AddInput(new PentaInput(CalvingMeltingFluxLevelsetEnum,&flux_per_area,P0Enum));
     701                this->AddInput2(CalvingMeltingFluxLevelsetEnum,&flux_per_area,P0Enum);
    583702
    584703                /*Clean up and return*/
    … …  
    609728        /*retrive parameters: */
    610729        parameters->FindParam(&analysis_type,AnalysisTypeEnum);
    611         inputs->GetInputValue(&approximation,ApproximationEnum);
     730        this->GetInput2Value(&approximation,ApproximationEnum);
    612731
    613732        /*Check analysis_types*/
    … …  
    633752
    634753        /*Retrieve all inputs we will be needing: */
    635         Input* pressure_input=inputs->GetInput(PressureEnum); _assert_(pressure_input);
    636         Input* vx_input=inputs->GetInput(VxEnum);             _assert_(vx_input);
    637         Input* vy_input=inputs->GetInput(VyEnum);             _assert_(vy_input);
    638         Input* vz_input=inputs->GetInput(VzEnum);             _assert_(vz_input);
     754        Input2* pressure_input=this->GetInput2(PressureEnum); _assert_(pressure_input);
     755        Input2* vx_input=this->GetInput2(VxEnum);             _assert_(vx_input);
     756        Input2* vy_input=this->GetInput2(VyEnum);             _assert_(vy_input);
     757        Input2* vz_input=this->GetInput2(VzEnum);             _assert_(vz_input);
    639758
    640759        /* Start  looping on the number of gaussian points: */
    … …  
    693812
    694813        /*Retrieve all inputs we will be needing: */
    695         Input* vx_input=inputs->GetInput(VxEnum);             _assert_(vx_input);
    696         Input* vy_input=inputs->GetInput(VyEnum);             _assert_(vy_input);
    697         Input* vz_input=inputs->GetInput(VzEnum);             _assert_(vz_input);
     814        Input2* vx_input=this->GetInput2(VxEnum);             _assert_(vx_input);
     815        Input2* vy_input=this->GetInput2(VyEnum);             _assert_(vy_input);
     816        Input2* vz_input=this->GetInput2(VzEnum);             _assert_(vz_input);
    698817
    699818        /* Start looping on the number of vertices: */
    … …  
    721840
    722841        /*Add Stress tensor components into inputs*/
    723         this->inputs->AddInput(new PentaInput(DeviatoricStressxxEnum,&tau_xx[0],P1Enum));
    724         this->inputs->AddInput(new PentaInput(DeviatoricStressxyEnum,&tau_xy[0],P1Enum));
    725         this->inputs->AddInput(new PentaInput(DeviatoricStressxzEnum,&tau_xz[0],P1Enum));
    726         this->inputs->AddInput(new PentaInput(DeviatoricStressyyEnum,&tau_yy[0],P1Enum));
    727         this->inputs->AddInput(new PentaInput(DeviatoricStressyzEnum,&tau_yz[0],P1Enum));
    728         this->inputs->AddInput(new PentaInput(DeviatoricStresszzEnum,&tau_zz[0],P1Enum));
    729         this->inputs->AddInput(new PentaInput(DeviatoricStresseffectiveEnum,&tau_eff[0],P1Enum));
     842        this->AddInput2(DeviatoricStressxxEnum,&tau_xx[0],P1DGEnum);
     843        this->AddInput2(DeviatoricStressxyEnum,&tau_xy[0],P1DGEnum);
     844        this->AddInput2(DeviatoricStressxzEnum,&tau_xz[0],P1DGEnum);
     845        this->AddInput2(DeviatoricStressyyEnum,&tau_yy[0],P1DGEnum);
     846        this->AddInput2(DeviatoricStressyzEnum,&tau_yz[0],P1DGEnum);
     847        this->AddInput2(DeviatoricStresszzEnum,&tau_zz[0],P1DGEnum);
     848        this->AddInput2(DeviatoricStresseffectiveEnum,&tau_eff[0],P1DGEnum);
    730849
    731850        /*Clean up and return*/
    … …  
    750869
    751870        /*Retrieve all inputs we will be needing: */
    752         Input* pressure_input=inputs->GetInput(PressureEnum); _assert_(pressure_input);
    753         Input* vx_input=inputs->GetInput(VxEnum);             _assert_(vx_input);
    754         Input* vy_input=inputs->GetInput(VyEnum);             _assert_(vy_input);
    755         Input* vz_input=inputs->GetInput(VzEnum);             _assert_(vz_input);
     871        Input2* pressure_input=this->GetInput2(PressureEnum); _assert_(pressure_input);
     872        Input2* vx_input=this->GetInput2(VxEnum);             _assert_(vx_input);
     873        Input2* vy_input=this->GetInput2(VyEnum);             _assert_(vy_input);
     874        Input2* vz_input=this->GetInput2(VzEnum);             _assert_(vz_input);
    756875
    757876        /* Start looping on the number of vertices: */
    … …  
    775894
    776895        /*Add Stress tensor components into inputs*/
    777         this->inputs->AddInput(new PentaInput(StressTensorxxEnum,&sigma_xx[0],P1Enum));
    778         this->inputs->AddInput(new PentaInput(StressTensorxyEnum,&sigma_xy[0],P1Enum));
    779         this->inputs->AddInput(new PentaInput(StressTensorxzEnum,&sigma_xz[0],P1Enum));
    780         this->inputs->AddInput(new PentaInput(StressTensoryyEnum,&sigma_yy[0],P1Enum));
    781         this->inputs->AddInput(new PentaInput(StressTensoryzEnum,&sigma_yz[0],P1Enum));
    782         this->inputs->AddInput(new PentaInput(StressTensorzzEnum,&sigma_zz[0],P1Enum));
     896        this->AddInput2(StressTensorxxEnum,&sigma_xx[0],P1DGEnum);
     897        this->AddInput2(StressTensorxyEnum,&sigma_xy[0],P1DGEnum);
     898        this->AddInput2(StressTensorxzEnum,&sigma_xz[0],P1DGEnum);
     899        this->AddInput2(StressTensoryyEnum,&sigma_yy[0],P1DGEnum);
     900        this->AddInput2(StressTensoryzEnum,&sigma_yz[0],P1DGEnum);
     901        this->AddInput2(StressTensorzzEnum,&sigma_zz[0],P1DGEnum);
    783902
    784903        /*Clean up and return*/
    … …  
    786905}
    787906/*}}}*/
    788 void       Penta::Configure(Elements* elementsin, Loads* loadsin, Nodes* nodesin,Vertices* verticesin, Materials* materialsin, Parameters* parametersin){/*{{{*/
     907void       Penta::Configure(Elements* elementsin, Loads* loadsin, Nodes* nodesin,Vertices* verticesin, Materials* materialsin, Parameters* parametersin,Inputs2* inputs2in){/*{{{*/
    789908
    790909        int analysis_counter;
    … …  
    812931        /*point parameters to real dataset: */
    813932        this->parameters=parametersin;
     933        this->inputs2=inputs2in;
    814934
    815935        /*get inputs configured too: */
    … …  
    819939void       Penta::ControlInputSetGradient(IssmDouble* gradient,int enum_type,int control_index,int offset,int N,int M){/*{{{*/
    820940
     941        if(enum_type==MaterialsRheologyBbarEnum) enum_type = MaterialsRheologyBEnum;
     942        if(enum_type==DamageDbarEnum)            enum_type = DamageDEnum;
     943
     944        _error_("not implemented");
    821945        int    vertexpidlist[NUMVERTICES];
    822946        IssmDouble grad_list[NUMVERTICES];
    823         Input* grad_input=NULL;
    824         Input* input=NULL;
     947        Input2* grad_input=NULL;
     948        Input2* input=NULL;
    825949
    826950        if(enum_type==MaterialsRheologyBbarEnum){
    827                 input=(Input*)inputs->GetInput(MaterialsRheologyBEnum);
     951                input=this->GetInput2(MaterialsRheologyBEnum);
    828952        }
    829953        else if(enum_type==DamageDbarEnum){
    830                 input=(Input*)inputs->GetInput(DamageDEnum);
     954                input=this->GetInput2(DamageDEnum);
    831955        }
    832956        else{
    833                 input=inputs->GetInput(enum_type);
     957                input=this->GetInput2(enum_type);
    834958        }
    835959        if (!input) _error_("Input " << EnumToStringx(enum_type) << " not found");
    836         if (input->ObjectEnum()!=ControlInputEnum) _error_("Input " << EnumToStringx(enum_type) << " is not a ControlInput");
     960        if(input->ObjectEnum()!=ControlInput2Enum) _error_("Input " << EnumToStringx(enum_type) << " is not a ControlInput");
    837961
    838962        GradientIndexing(&vertexpidlist[0],control_index);
    839         for(int i=0;i<NUMVERTICES;i++) grad_list[i]=gradient[vertexpidlist[i]];
    840         grad_input=new PentaInput(GradientEnum,grad_list,P1Enum);
    841         ((ControlInput*)input)->SetGradient(grad_input);
     963
     964        //for(int i=0;i<NUMVERTICES;i++) grad_list[i]=gradient[vertexpidlist[i]];
     965        //grad_input=new PentaInput(GradientEnum,grad_list,P1Enum);
     966        //((ControlInput*)input)->SetGradient(grad_input);
     967        _error_("not implemented");
    842968
    843969}
    … …  
    845971void       Penta::ControlInputSetGradient(IssmDouble* gradient,int enum_type,int control_index){/*{{{*/
    846972
    847         int    vertexpidlist[NUMVERTICES];
     973        int        idlist[NUMVERTICES];
     974        int        vertexlids[NUMVERTICES];
    848975        IssmDouble grad_list[NUMVERTICES];
    849         Input* grad_input=NULL;
    850         Input* input=NULL;
    851 
    852         if(enum_type==MaterialsRheologyBbarEnum){
    853                 input=(Input*)inputs->GetInput(MaterialsRheologyBEnum);
    854         }
    855         else if(enum_type==DamageDbarEnum){
    856                 input=(Input*)inputs->GetInput(DamageDEnum);
    857         }
    858         else{
    859                 input=inputs->GetInput(enum_type);
    860         }
    861         if (!input) _error_("Input " << EnumToStringx(enum_type) << " not found");
    862         if (input->ObjectEnum()!=ControlInputEnum) _error_("Input " << EnumToStringx(enum_type) << " is not a ControlInput");
    863 
    864         GradientIndexing(&vertexpidlist[0],control_index);
    865         for(int i=0;i<NUMVERTICES;i++) grad_list[i]=gradient[vertexpidlist[i]];
    866         grad_input=new PentaInput(GradientEnum,grad_list,P1Enum);
    867         ((ControlInput*)input)->SetGradient(grad_input);
    868 
     976
     977        if(enum_type==MaterialsRheologyBbarEnum) enum_type = MaterialsRheologyBEnum;
     978        if(enum_type==DamageDbarEnum)            enum_type = DamageDEnum;
     979
     980        GradientIndexing(&idlist[0],control_index);
     981        for(int i=0;i<NUMVERTICES;i++) grad_list[i]=gradient[idlist[i]];
     982        for(int i=0;i<NUMVERTICES;i++) vertexlids[i]=this->vertices[i]->lid;
     983
     984        this->inputs2->SetTriaControlInputGradient(enum_type,P1Enum,NUMVERTICES,&vertexlids[0],&grad_list[0]);
    869985}/*}}}*/
    870986void       Penta::ControlToVectors(Vector<IssmPDouble>* vector_control, Vector<IssmPDouble>* vector_gradient,int control_enum){/*{{{*/
    871987
    872         Input* input=NULL;
    873 
    874         if(control_enum==MaterialsRheologyBbarEnum){
    875                 input=(Input*)inputs->GetInput(MaterialsRheologyBEnum);
    876         }
    877         else if(control_enum==DamageDbarEnum){
    878                 input=(Input*)inputs->GetInput(DamageDEnum);
    879         }
    880         else{
    881                 input=inputs->GetInput(control_enum);
    882         }
    883         if (!input) _error_("Input " << EnumToStringx(control_enum) << " not found");
    884         if (input->ObjectEnum()!=ControlInputEnum) _error_("Input " << EnumToStringx(control_enum) << " is not a ControlInput");
    885 
    886988        int         sidlist[NUMVERTICES];
     989        int         lidlist[NUMVERTICES];
    887990        int         connectivity[NUMVERTICES];
    888991        IssmPDouble values[NUMVERTICES];
    … …  
    890993        IssmDouble  value,gradient;
    891994
     995        if(control_enum==MaterialsRheologyBbarEnum) control_enum = MaterialsRheologyBEnum;
     996        if(control_enum==DamageDbarEnum)            control_enum = DamageDEnum;
     997
    892998        this->GetVerticesConnectivityList(&connectivity[0]);
    893999        this->GetVerticesSidList(&sidlist[0]);
     1000        this->GetVerticesLidList(&lidlist[0]);
     1001
     1002        ElementInput2* control_value    = this->inputs2->GetControlInput2Data(control_enum,"value");    _assert_(control_value);
     1003        ElementInput2* control_gradient = this->inputs2->GetControlInput2Data(control_enum,"gradient"); _assert_(control_gradient);
     1004        control_value->Serve(NUMVERTICES,&lidlist[0]);
     1005        control_gradient->Serve(NUMVERTICES,&lidlist[0]);
    8941006
    8951007        GaussPenta* gauss=new GaussPenta();
    … …  
    8971009                gauss->GaussVertex(iv);
    8981010
    899                 ((ControlInput*)input)->GetInputValue(&value,gauss);
    900                 ((ControlInput*)input)->GetGradientValue(&gradient,gauss);
     1011                control_value->GetInputValue(&value,gauss);
     1012                control_gradient->GetInputValue(&gradient,gauss);
    9011013
    9021014                values[iv]    = reCast<IssmPDouble>(value)/reCast<IssmPDouble>(connectivity[iv]);
    … …  
    9071019        vector_control->SetValues(NUMVERTICES,&sidlist[0],&values[0],ADD_VAL);
    9081020        vector_gradient->SetValues(NUMVERTICES,&sidlist[0],&gradients[0],ADD_VAL);
    909 
    9101021}/*}}}*/
    9111022void       Penta::CreateDistanceInputFromSegmentlist(IssmDouble* distances,int distanceenum){/*{{{*/
    … …  
    9321043
    9331044        /*Update Levelset*/
    934         this->inputs->AddInput(new PentaInput(distanceenum,&ls[0],P1Enum));
     1045        this->AddInput2(distanceenum,&ls[0],P1Enum);
    9351046}
    9361047/*}}}*/
    … …  
    9491060                                /*Get input:*/
    9501061                                IssmDouble vel;
    951                                 Input* vel_input;
    952 
    953                                 vel_input=this->inputs->GetInput(VelEnum); _assert_(vel_input);
     1062                                Input2* vel_input=this->GetInput2(VelEnum); _assert_(vel_input);
    9541063                                vel_input->GetInputAverage(&vel);
    9551064
    … …  
    10141123
    10151124        if(scaled==true){
    1016                 Input* scalefactor_input = inputs->GetInput(MeshScaleFactorEnum); _assert_(scalefactor_input);
     1125                Input2* scalefactor_input = this->GetInput2(MeshScaleFactorEnum); _assert_(scalefactor_input);
    10171126                scalefactor_input->GetInputAverage(&scalefactor);
    10181127                floatingarea=floatingarea*scalefactor;
    … …  
    10281137
    10291138        int approximation;
    1030         inputs->GetInputValue(&approximation,ApproximationEnum);
     1139        this->GetInput2Value(&approximation,ApproximationEnum);
    10311140        if(approximation==HOApproximationEnum || approximation==SSAApproximationEnum || approximation==SSAHOApproximationEnum || approximation==HOFSApproximationEnum){
    10321141                _error_("Cannot compute contact condition for non FS elements");
    … …  
    10531162
    10541163        /*Retrieve all inputs we will be needing: */
    1055         Input* vx_input = inputs->GetInput(VxEnum); _assert_(vx_input);
    1056         Input* vy_input = inputs->GetInput(VyEnum); _assert_(vy_input);
    1057         Input* vz_input = inputs->GetInput(VzEnum); _assert_(vz_input);
     1164        Input2* vx_input = this->GetInput2(VxEnum); _assert_(vx_input);
     1165        Input2* vy_input = this->GetInput2(VyEnum); _assert_(vy_input);
     1166        Input2* vz_input = this->GetInput2(VzEnum); _assert_(vz_input);
    10581167
    10591168        /*1. Recover stresses at the base*/
    … …  
    14721581        xDelete<int>(indicesfront);
    14731582}/*}}}*/
     1583Input2*    Penta::GetInput2(int inputenum){/*{{{*/
     1584
     1585        /*Get Input from dataset*/
     1586        PentaInput2* input = this->inputs2->GetPentaInput(inputenum);
     1587        if(!input) return input;
     1588
     1589        /*Intermediaries*/
     1590        int numindices;
     1591        int indices[30]; /*Max numnodes*/
     1592
     1593        /*Check interpolation*/
     1594        int interpolation = input->GetInterpolation();
     1595        if(interpolation==P1Enum){
     1596                numindices = 6;
     1597                for(int i=0;i<6;i++) indices[i] = vertices[i]->lid;
     1598                input->Serve(numindices,&indices[0]);
     1599        }
     1600        else{
     1601                input->Serve(this->lid,this->GetNumberOfNodes(interpolation));
     1602        }
     1603
     1604        /*Tell input it is NOT collapsed*/
     1605        //input->SetServeCollapsed(0); FIXME: not needed?
     1606
     1607        /*Return*/
     1608        return input;
     1609}/*}}}*/
     1610Input2*    Penta::GetInput2(int inputenum,IssmDouble time){/*{{{*/
     1611
     1612        /*Get Input from dataset*/
     1613        PentaInput2* input = this->inputs2->GetPentaInput(inputenum,time);
     1614        if(!input) return input;
     1615
     1616        /*Intermediaries*/
     1617        int numindices;
     1618        int indices[30]; /*Max numnodes*/
     1619
     1620        /*Check interpolation*/
     1621        int interpolation = input->GetInterpolation();
     1622        if(interpolation==P1Enum){
     1623                numindices = 6;
     1624                for(int i=0;i<6;i++) indices[i] = vertices[i]->lid;
     1625                input->Serve(numindices,&indices[0]);
     1626        }
     1627        else{
     1628                input->Serve(this->lid,this->GetNumberOfNodes(interpolation));
     1629        }
     1630
     1631        /*Tell input it is NOT collapsed*/
     1632        //input->SetServeCollapsed(0); FIXME: not needed?
     1633
     1634        /*Return*/
     1635        return input;
     1636}/*}}}*/
     1637DatasetInput2* Penta::GetDatasetInput2(int inputenum){/*{{{*/
     1638
     1639        DatasetInput2* datasetinput = this->inputs2->GetDatasetInput2(inputenum);
     1640        if(!datasetinput) return NULL;
     1641
     1642        for(int i=0;i<datasetinput->GetNumIds();i++){
     1643
     1644                PentaInput2* input = datasetinput->GetPentaInputByOffset(i); _assert_(input);
     1645
     1646                /*Intermediaries*/
     1647                int numindices;
     1648                int indices[30]; /*Max numnodes*/
     1649
     1650                /*Check interpolation*/
     1651                int interpolation = input->GetInterpolation();
     1652                if(interpolation==P1Enum){
     1653                        numindices = 6;
     1654                        for(int i=0;i<6;i++) indices[i] = vertices[i]->lid;
     1655                        input->Serve(numindices,&indices[0]);
     1656                }
     1657                else{
     1658                        input->Serve(this->lid,this->GetNumberOfNodes(interpolation));
     1659                }
     1660
     1661        }
     1662
     1663        return datasetinput;
     1664}/*}}}*/
    14741665void       Penta::GetInputValue(IssmDouble* pvalue,Node* node,int enumtype){/*{{{*/
    14751666
    1476         Input* input=inputs->GetInput(enumtype);
     1667        Input2* input=this->GetInput2(enumtype);
    14771668        if(!input) _error_("No input of type " << EnumToStringx(enumtype) << " found in tria");
    14781669
    … …  
    14881679void       Penta::GetInputValue(IssmDouble* pvalue,Vertex* vertex,int enumtype){/*{{{*/
    14891680
    1490         Input* input=inputs->GetInput(enumtype);
     1681        Input2* input=this->GetInput2(enumtype);
    14911682        if(!input) _error_("No input of type " << EnumToStringx(enumtype) << " found in tria");
    14921683
    … …  
    16171808void       Penta::GetVectorFromControlInputs(Vector<IssmDouble>* vector,int control_enum,int control_index,const char* data){/*{{{*/
    16181809
    1619         int vertexidlist[NUMVERTICES];
    1620 
    16211810        /*Get out if this is not an element input*/
    16221811        if(!IsInputEnum(control_enum)) _error_("Enum "<<EnumToStringx(control_enum)<<" is not in IsInput");
    16231812
    16241813        /*Prepare index list*/
    1625         GradientIndexing(&vertexidlist[0],control_index);
     1814        int idlist[NUMVERTICES];
     1815        GradientIndexing(&idlist[0],control_index);
    16261816
    16271817        /*Get input (either in element or material)*/
    16281818        if(control_enum==MaterialsRheologyBbarEnum) control_enum=MaterialsRheologyBEnum;
    1629         Input* input=inputs->GetInput(control_enum);
    1630         if(!input) _error_("Input " << EnumToStringx(control_enum) << " not found in element");
    1631 
    1632         /*Check that it is a ControlInput*/
    1633         if (input->ObjectEnum()!=ControlInputEnum){
    1634                 _error_("input " << EnumToStringx(control_enum) << " is not a ControlInput");
    1635         }
    1636 
    1637         ((ControlInput*)input)->GetVectorFromInputs(vector,&vertexidlist[0],data);
     1819        ElementInput2* input=this->inputs2->GetControlInput2Data(control_enum,data);   _assert_(input);
     1820
     1821        /*Intermediaries*/
     1822        int numindices;
     1823        int indices[NUMVERTICES];
     1824
     1825        /*Check interpolation*/
     1826        int interpolation = input->GetInterpolation();
     1827        switch(interpolation){
     1828                case P1Enum:
     1829                        numindices = NUMVERTICES;
     1830                        for(int i=0;i<NUMVERTICES;i++) indices[i] = vertices[i]->lid;
     1831                        input->Serve(numindices,&indices[0]);
     1832                        break;
     1833                default: _error_("interpolation "<<EnumToStringx(interpolation)<<" not supported");
     1834        }
     1835
     1836        /* Start looping on the number of vertices: */
     1837        IssmDouble values[NUMVERTICES];
     1838        Gauss*gauss=this->NewGauss();
     1839        for(int iv=0;iv<NUMVERTICES;iv++){
     1840                gauss->GaussVertex(iv);
     1841                input->GetInputValue(&values[iv],gauss);
     1842        }
     1843        delete gauss;
     1844
     1845        vector->SetValues(NUMVERTICES,idlist,&values[0],INS_VAL);
    16381846}
    16391847/*}}}*/
    … …  
    16421850        int* idlist = NULL;
    16431851        IssmDouble* values = NULL;
    1644         int* M = NULL;
    1645 
    1646         /*Get out if this is not an element input*/
    1647         if(!IsInputEnum(control_enum)) _error_("Enum "<<EnumToStringx(control_enum)<<" is not in IsInput");
    1648         Input* input=(Input*)this->inputs->GetInput(control_enum);   _assert_(input);
    1649 
    1650         /*Cast to Controlinput*/
    1651         if(input->ObjectEnum()!=ControlInputEnum) _error_("input " << EnumToStringx(control_enum) << " is not a ControlInput");
    1652         ControlInput* controlinput = xDynamicCast<ControlInput*>(input);
    1653 
    1654         if(strcmp(data,"value")==0){
    1655                 input  = controlinput->values;
    1656         }
    1657         else if (strcmp(data,"lowerbound")==0){
    1658                 input = controlinput->minvalues;
    1659         }
    1660         else if (strcmp(data,"upperbound")==0){
    1661                 input = controlinput->maxvalues;
    1662         }
    1663         else if (strcmp(data,"gradient")==0){
    1664                 input = controlinput->gradient;
    1665         }
    1666         else{
    1667                 _error_("Data " << data << " not supported yet");
    1668         }
     1852
     1853        /*Get input*/
     1854        ElementInput2* input=this->inputs2->GetControlInput2Data(control_enum,data);   _assert_(input);
     1855
    16691856        /*Check what input we are dealing with*/
    1670 
    16711857        switch(input->ObjectEnum()){
    1672                 case PentaInputEnum:
     1858                case PentaInput2Enum:
    16731859                                  {
    1674                                         PentaInput* pentainput = xDynamicCast<PentaInput*>(input);
    1675                                         if(pentainput->interpolation_type!=P1Enum) _error_("not supported yet");
     1860                                        PentaInput2* pentainput = xDynamicCast<PentaInput2*>(input);
     1861                                        if(pentainput->GetInputInterpolationType()!=P1Enum) _error_("not supported yet");
    16761862
    16771863                                        /*Create list of indices and values for global vector*/
    … …  
    16801866                                        GradientIndexing(&idlist[0],control_index);
    16811867                                        for(int i=0;i<NUMVERTICES;i++){
    1682                                                 values[i] = pentainput->values[i];
     1868                                                values[i] = pentainput->element_values[i];
    16831869                                        }
    16841870                                        vector->SetValues(NUMVERTICES,idlist,values,INS_VAL);
    … …  
    16881874                                case TransientInputEnum:
    16891875                                  {
    1690                                         parameters->FindParam(&M,NULL,ControlInputSizeMEnum);
    1691                                         TransientInput* transientinput = xDynamicCast<TransientInput*>(input);
    1692                                         int N = transientinput->numtimesteps;
    1693                                         idlist = xNew<int>(NUMVERTICES*N);
    1694                                         values = xNew<IssmDouble>(NUMVERTICES*N);
    1695                                         for(int t=0;t<transientinput->numtimesteps;t++) {
    1696                                                 IssmDouble time = transientinput->GetTimeByOffset(t);
    1697                                                 input = transientinput->GetTimeInput(time);
    1698                                                 TriaInput* timeinput = xDynamicCast<TriaInput*>(input);
    1699                                                 if(timeinput->interpolation_type!=P1Enum) _error_("not supported yet");
    1700                                                 /*Create list of indices and values for global vector*/
    1701                                                 for(int i=0;i<NUMVERTICES;i++){
    1702                                                         idlist[N*i+t] = offset + this->vertices[i]->Sid()+t*M[control_index];
    1703                                                         values[N*i+t] = timeinput->values[i];
    1704                                                 }
    1705                                         }
    1706 
    1707                                         vector->SetValues(NUMVERTICES*transientinput->numtimesteps,idlist,values,INS_VAL);
     1876                                        _error_("not implemented (see Tria)");
    17081877                                        break;
    17091878                                  }
    … …  
    17531922
    17541923        if(scaled==true){
    1755                 Input* scalefactor_input = inputs->GetInput(MeshScaleFactorEnum); _assert_(scalefactor_input);
     1924                Input2* scalefactor_input = this->GetInput2(MeshScaleFactorEnum); _assert_(scalefactor_input);
    17561925                scalefactor_input->GetInputAverage(&scalefactor);
    17571926                groundedarea=groundedarea*scalefactor;
    … …  
    18572026        IssmDouble vx,vy,thickness,Jdet;
    18582027        IssmDouble rho_ice=FindParam(MaterialsRhoIceEnum);
    1859         Input* thickness_input=inputs->GetInput(ThicknessEnum); _assert_(thickness_input);
    1860         Input* vx_input=NULL;
    1861         Input* vy_input=NULL;
    1862         vx_input=inputs->GetInput(VxAverageEnum); _assert_(vx_input);
    1863         vy_input=inputs->GetInput(VyAverageEnum); _assert_(vy_input);
     2028        Input2* thickness_input=this->GetInput2(ThicknessEnum); _assert_(thickness_input);
     2029        Input2* vx_input=NULL;
     2030        Input2* vy_input=NULL;
     2031        vx_input=this->GetInput2(VxAverageEnum); _assert_(vx_input);
     2032        vy_input=this->GetInput2(VyAverageEnum); _assert_(vy_input);
    18642033
    18652034        /*Start looping on Gaussian points*/
    … …  
    18952064
    18962065        if(scaled==true){ //scale for area projection correction
    1897                 Input* scalefactor_input = inputs->GetInput(MeshScaleFactorEnum); _assert_(scalefactor_input);
     2066                Input2* scalefactor_input = this->GetInput2(MeshScaleFactorEnum); _assert_(scalefactor_input);
    18982067                scalefactor_input->GetInputAverage(&scalefactor);
    18992068                base=base*scalefactor;
    … …  
    19252094        base = 1./2.*fabs((xyz_list[0][0]-xyz_list[2][0])*(xyz_list[1][1]-xyz_list[0][1]) - (xyz_list[0][0]-xyz_list[1][0])*(xyz_list[2][1]-xyz_list[0][1]));
    19262095        if(scaled==true){
    1927                 Input* scalefactor_input = inputs->GetInput(MeshScaleFactorEnum); _assert_(scalefactor_input);
     2096                Input2* scalefactor_input = this->GetInput2(MeshScaleFactorEnum); _assert_(scalefactor_input);
    19282097                scalefactor_input->GetInputAverage(&scalefactor);
    19292098                base=base*scalefactor;
    … …  
    19312100
    19322101        /*Now get the average height above floatation*/
    1933         Input* surface_input    = inputs->GetInput(SurfaceEnum);    _assert_(surface_input);
    1934         Input* base_input        = inputs->GetInput(BaseEnum);        _assert_(base_input);
    1935         Input* bed_input = inputs->GetInput(BedEnum); _assert_(bed_input);
     2102        Input2* surface_input    = this->GetInput2(SurfaceEnum);    _assert_(surface_input);
     2103        Input2* base_input        = this->GetInput2(BaseEnum);        _assert_(base_input);
     2104        Input2* bed_input = this->GetInput2(BedEnum); _assert_(bed_input);
    19362105        if(!bed_input) _error_("Could not find bed");
    19372106        surface_input->GetInputAverage(&surface);
    … …  
    19492118        IssmDouble  xyz_list_line[2][3];
    19502119        IssmDouble  total[NUMVERTICES]       = {0.};
     2120        int         lidlist[NUMVERTICES];
    19512121        IssmDouble  intz[NUMVERTICES]        = {0.};
    1952         Input      *original_input           = NULL;
    1953         Input      *depth_averaged_input     = NULL;
     2122        Input2     *original_input           = NULL;
     2123        Input2     *depth_averaged_input     = NULL;
    19542124
    19552125        /*Are we on the base? If not, return*/
    … …  
    19622132
    19632133                /*Step1: Get original input (to be depth-avegaged): */
    1964                 original_input=(Input*)penta->inputs->GetInput(original_enum);
     2134                original_input=penta->GetInput2(original_enum);
    19652135                if(!original_input) _error_("could not find input with enum " << EnumToStringx(original_enum));
    19662136
    … …  
    19982168                total[iv+3] = total[iv];
    19992169        }
     2170        GetVerticesLidList(&lidlist[0]);
    20002171        switch(original_input->ObjectEnum()){
    20012172                case PentaInputEnum:
     2173                case PentaInput2Enum:
    20022174                case ControlInputEnum:
    2003                         depth_averaged_input=new PentaInput(average_enum,&total[0],P1Enum);
     2175                        this->inputs2->SetPentaInput(average_enum,P1Enum,NUMVERTICES,lidlist,&total[0]);
    20042176                        break;
    20052177                default:
    20062178                        _error_("Interpolation " << EnumToStringx(original_input->ObjectEnum()) << " not supported yet");
    20072179        }
    2008 
    2009         /*Finally, add to inputs*/
    2010         this->inputs->AddInput((Input*)depth_averaged_input);
    2011 }
    2012 /*}}}*/
    2013 void       Penta::InputExtrude(int enum_type,int start){/*{{{*/
     2180}
     2181/*}}}*/
     2182void       Penta::DatasetInputExtrude(int enum_type,int start){/*{{{*/
    20142183
    20152184        _assert_(start==-1 || start==+1);
     2185        _assert_(this->inputs2);
    20162186
    20172187        /*Are we on the the boundary we want to be?*/
    … …  
    20192189        if(start==+1 && !IsOnSurface()) return;
    20202190
    2021         /*Step1: Get and Extrude original input: */
    2022         Input* base_input=(Input*)this->inputs->GetInput(enum_type);
    2023         if(!base_input) _error_("could not find input with enum " << EnumToStringx(enum_type));
    2024         base_input->Extrude(start);
    2025 
    2026         /*Stop if there is only one layer of element*/
    2027         if(start==-1 && this->IsOnSurface()) return;
    2028         if(start==+1 && this->IsOnBase())    return;
    2029 
    2030         /*Step 2: this input has been extruded for this element, now follow the upper element*/
    2031         Penta* penta=this;
    2032         for(;;){
    2033                 /*get upper/lower Penta*/
    2034                 if(start==-1) penta=penta->GetUpperPenta();
    2035                 else          penta=penta->GetLowerPenta();
    2036                 _assert_(penta->Id()!=this->id);
    2037 
    2038                 /*Add input of the basal element to penta->inputs*/
    2039                 Input* copy=(Input*)base_input->copy();
    2040                 penta->inputs->AddInput((Input*)copy);
    2041 
    2042                 /*Stop if we have reached the surface/base*/
    2043                 if(start==-1 && penta->IsOnSurface()) break;
    2044                 if(start==+1 && penta->IsOnBase())    break;
     2191        /*Get original input*/
     2192        DatasetInput2* dinput = this->inputs2->GetDatasetInput2(enum_type);
     2193
     2194        int lidlist[NUMVERTICES];
     2195        this->GetVerticesLidList(&lidlist[0]);
     2196
     2197        for(int id=0;id<dinput->GetNumIds();id++){
     2198
     2199                PentaInput2* pentainput = dinput->GetPentaInputByOffset(id);
     2200                pentainput->Serve(NUMVERTICES,&lidlist[0]);
     2201
     2202                if(pentainput->GetInterpolation()==P1Enum){
     2203
     2204                        /*Extrude values first*/
     2205                        IssmDouble extrudedvalues[NUMVERTICES];
     2206                        this->GetInputListOnVertices(&extrudedvalues[0],pentainput);
     2207
     2208                        if(start==-1){
     2209                                for(int i=0;i<NUMVERTICES2D;i++) extrudedvalues[i+NUMVERTICES2D]=extrudedvalues[i];
     2210                        }
     2211                        else{
     2212                                for(int i=0;i<NUMVERTICES2D;i++) extrudedvalues[i]=extrudedvalues[i+NUMVERTICES2D];
     2213                        }
     2214
     2215                        /*Propagate to other Pentas*/
     2216                        Penta* penta=this;
     2217                        for(;;){
     2218
     2219                                /*Add input of the basal element to penta->inputs*/
     2220                                int vertexlids[NUMVERTICES];
     2221                                penta->GetVerticesLidList(&vertexlids[0]);
     2222                                pentainput->SetInput(P1Enum,NUMVERTICES,&vertexlids[0],&extrudedvalues[0]);
     2223
     2224                                /*Stop if we have reached the surface/base*/
     2225                                if(start==-1 && penta->IsOnSurface()) break;
     2226                                if(start==+1 && penta->IsOnBase())    break;
     2227
     2228                                /*get upper/lower Penta*/
     2229                                if(start==-1) penta=penta->GetUpperPenta();
     2230                                else          penta=penta->GetLowerPenta();
     2231                                _assert_(penta->Id()!=this->id);
     2232                        }
     2233                }
     2234                else{
     2235                        _error_("not implemented yet");
     2236                }
     2237        }
     2238}
     2239/*}}}*/
     2240void       Penta::ControlInputExtrude(int enum_type,int start){/*{{{*/
     2241
     2242        _assert_(start==-1 || start==+1);
     2243        _assert_(this->inputs2);
     2244
     2245        /*Are we on the the boundary we want to be?*/
     2246        if(start==-1 && !IsOnBase())    return;
     2247        if(start==+1 && !IsOnSurface()) return;
     2248
     2249        /*Get original input*/
     2250        ElementInput2* input  = this->inputs2->GetControlInput2Data(enum_type,"value");
     2251        if(input->ObjectEnum()!=PentaInput2Enum) _error_("not supported yet");
     2252        PentaInput2* pentainput = xDynamicCast<PentaInput2*>(input);
     2253        ElementInput2* input2 = this->inputs2->GetControlInput2Data(enum_type,"savedvalues");
     2254        if(input->ObjectEnum()!=PentaInput2Enum) _error_("not supported yet");
     2255        PentaInput2* pentainput2= xDynamicCast<PentaInput2*>(input2);
     2256        /*FIXME: this should not be necessary*/
     2257        ElementInput2* input3 = this->inputs2->GetControlInput2Data(enum_type,"gradient");
     2258        if(input->ObjectEnum()!=PentaInput2Enum) _error_("not supported yet");
     2259        PentaInput2* pentainput3= xDynamicCast<PentaInput2*>(input3);
     2260
     2261        int lidlist[NUMVERTICES];
     2262        this->GetVerticesLidList(&lidlist[0]);
     2263        pentainput->Serve(NUMVERTICES,&lidlist[0]);
     2264        pentainput2->Serve(NUMVERTICES,&lidlist[0]);
     2265        pentainput3->Serve(NUMVERTICES,&lidlist[0]);
     2266
     2267        if(pentainput->GetInterpolation()==P1Enum){
     2268
     2269                /*Extrude values first*/
     2270                IssmDouble extrudedvalues[NUMVERTICES];
     2271                IssmDouble extrudedvalues2[NUMVERTICES];
     2272                IssmDouble extrudedvalues3[NUMVERTICES];
     2273
     2274                this->GetInputListOnVertices(&extrudedvalues[0],pentainput);
     2275                this->GetInputListOnVertices(&extrudedvalues2[0],pentainput2);
     2276                this->GetInputListOnVertices(&extrudedvalues3[0],pentainput3);
     2277
     2278                if(start==-1){
     2279                        for(int i=0;i<NUMVERTICES2D;i++) extrudedvalues[i+NUMVERTICES2D]=extrudedvalues[i];
     2280                        for(int i=0;i<NUMVERTICES2D;i++) extrudedvalues2[i+NUMVERTICES2D]=extrudedvalues2[i];
     2281                        for(int i=0;i<NUMVERTICES2D;i++) extrudedvalues3[i+NUMVERTICES2D]=extrudedvalues3[i]/2.; /*FIXME: this is just for NR*/
     2282                        for(int i=0;i<NUMVERTICES2D;i++) extrudedvalues3[i]=extrudedvalues3[i]/2.; /*FIXME: this is just for NR*/
     2283                }
     2284                else{
     2285                        for(int i=0;i<NUMVERTICES2D;i++) extrudedvalues[i]=extrudedvalues[i+NUMVERTICES2D];
     2286                        for(int i=0;i<NUMVERTICES2D;i++) extrudedvalues2[i]=extrudedvalues2[i+NUMVERTICES2D];
     2287                }
     2288
     2289                /*Propagate to other Pentas*/
     2290                Penta* penta=this;
     2291                for(;;){
     2292
     2293                        if(penta->IsOnSurface() && start==-1){ /*FIXME: this is just for NR*/
     2294                                for(int i=0;i<NUMVERTICES2D;i++) extrudedvalues3[i+NUMVERTICES2D]=0.;
     2295                        }
     2296
     2297                        /*Add input of the basal element to penta->inputs*/
     2298                        int vertexlids[NUMVERTICES];
     2299                        penta->GetVerticesLidList(&vertexlids[0]);
     2300                        pentainput->SetInput(P1Enum,NUMVERTICES,&vertexlids[0],&extrudedvalues[0]);
     2301                        pentainput2->SetInput(P1Enum,NUMVERTICES,&vertexlids[0],&extrudedvalues2[0]);
     2302                        if(start==-1 && !penta->IsOnBase()){
     2303                                pentainput3->SetInput(P1Enum,NUMVERTICES,&vertexlids[0],&extrudedvalues3[0]);
     2304                        }
     2305
     2306                        /*Stop if we have reached the surface/base*/
     2307                        if(start==-1 && penta->IsOnSurface()) break;
     2308                        if(start==+1 && penta->IsOnBase())    break;
     2309
     2310                        /*get upper/lower Penta*/
     2311                        if(start==-1) penta=penta->GetUpperPenta();
     2312                        else          penta=penta->GetLowerPenta();
     2313                        _assert_(penta->Id()!=this->id);
     2314                }
     2315        }
     2316        else{
     2317                _error_("not implemented yet");
     2318        }
     2319}
     2320/*}}}*/
     2321void       Penta::InputExtrude(int enum_type,int start){/*{{{*/
     2322
     2323        _assert_(start==-1 || start==+1);
     2324        _assert_(this->inputs2);
     2325
     2326        /*Are we on the the boundary we want to be?*/
     2327        if(start==-1 && !IsOnBase())    return;
     2328        if(start==+1 && !IsOnSurface()) return;
     2329
     2330
     2331        /*Get original input*/
     2332        Input2* input = this->GetInput2(enum_type);
     2333        if(input->ObjectEnum()!=PentaInput2Enum) _error_("not supported yet");
     2334        PentaInput2* pentainput = xDynamicCast<PentaInput2*>(input);
     2335
     2336        if(pentainput->GetInterpolation()==P1Enum || pentainput->GetInterpolation()==P1DGEnum){
     2337                /*Extrude values first*/
     2338                IssmDouble extrudedvalues[NUMVERTICES];
     2339
     2340                this->GetInputListOnVertices(&extrudedvalues[0],enum_type);
     2341                if(start==-1){
     2342                        for(int i=0;i<NUMVERTICES2D;i++) extrudedvalues[i+NUMVERTICES2D]=extrudedvalues[i];
     2343                }
     2344                else{
     2345                        for(int i=0;i<NUMVERTICES2D;i++) extrudedvalues[i]=extrudedvalues[i+NUMVERTICES2D];
     2346                }
     2347
     2348                /*Propagate to other Pentas*/
     2349                Penta* penta=this;
     2350                for(;;){
     2351
     2352                        /*Add input of the basal element to penta->inputs*/
     2353                        penta->AddInput2(enum_type,&extrudedvalues[0],pentainput->GetInterpolation());
     2354
     2355                        /*Stop if we have reached the surface/base*/
     2356                        if(start==-1 && penta->IsOnSurface()) break;
     2357                        if(start==+1 && penta->IsOnBase())    break;
     2358
     2359                        /*get upper/lower Penta*/
     2360                        if(start==-1) penta=penta->GetUpperPenta();
     2361                        else          penta=penta->GetLowerPenta();
     2362                        _assert_(penta->Id()!=this->id);
     2363                }
     2364        }
     2365        else{
     2366                _error_("interpolation "<<EnumToStringx(pentainput->GetInterpolation())<<" not implemented yet");
    20452367        }
    20462368}
    … …  
    20712393                penta_vertex_ids[i]=iomodel->elements[NUMVERTICES*index+i]; //ids for vertices are in the elements array from Matlab
    20722394        }
    2073 
    2074         /*Control Inputs*/
    2075         if (control_analysis){
    2076                 iomodel->FindConstant(&controls,NULL,"md.inversion.control_parameters");
    2077                 for(i=0;i<num_control_type;i++){
    2078                         _assert_(controls[i]);
    2079                         int control = StringToEnumx(controls[i]);
    2080                         switch(control){
    2081                                 case BalancethicknessThickeningRateEnum:
    2082                                         if (iomodel->Data("md.balancethickness.thickening_rate")){
    2083                                                 for(j=0;j<NUMVERTICES;j++)nodeinputs[j]=iomodel->Data("md.balancethickness.thickening_rate")[penta_vertex_ids[j]-1];
    2084                                                 for(j=0;j<NUMVERTICES;j++)cmmininputs[j]=iomodel->Data("md.inversion.min_parameters")[(penta_vertex_ids[j]-1)*num_control_type+i]/yts;
    2085                                                 for(j=0;j<NUMVERTICES;j++)cmmaxinputs[j]=iomodel->Data("md.inversion.max_parameters")[(penta_vertex_ids[j]-1)*num_control_type+i]/yts;
    2086                                                 this->inputs->AddInput(new ControlInput(BalancethicknessThickeningRateEnum,PentaInputEnum,nodeinputs,cmmininputs,cmmaxinputs,P1Enum,i+1));
    2087                                         }
    2088                                         break;
    2089                                 case VxEnum:
    2090                                         if (iomodel->Data("md.initialization.vx")){
    2091                                                 for(j=0;j<NUMVERTICES;j++)nodeinputs[j]=iomodel->Data("md.initialization.vx")[penta_vertex_ids[j]-1];
    2092                                                 for(j=0;j<NUMVERTICES;j++)cmmininputs[j]=iomodel->Data("md.inversion.min_parameters")[(penta_vertex_ids[j]-1)*num_control_type+i]/yts;
    2093                                                 for(j=0;j<NUMVERTICES;j++)cmmaxinputs[j]=iomodel->Data("md.inversion.max_parameters")[(penta_vertex_ids[j]-1)*num_control_type+i]/yts;
    2094                                                 this->inputs->AddInput(new ControlInput(VxEnum,PentaInputEnum,nodeinputs,cmmininputs,cmmaxinputs,P1Enum,i+1));
    2095                                         }
    2096                                         break;
    2097                                 case VyEnum:
    2098                                         if (iomodel->Data("md.initialization.vy")){
    2099                                                 for(j=0;j<NUMVERTICES;j++)nodeinputs[j]=iomodel->Data("md.initialization.vy")[penta_vertex_ids[j]-1];
    2100                                                 for(j=0;j<NUMVERTICES;j++)cmmininputs[j]=iomodel->Data("md.inversion.min_parameters")[(penta_vertex_ids[j]-1)*num_control_type+i]/yts;
    2101                                                 for(j=0;j<NUMVERTICES;j++)cmmaxinputs[j]=iomodel->Data("md.inversion.max_parameters")[(penta_vertex_ids[j]-1)*num_control_type+i]/yts;
    2102                                                 this->inputs->AddInput(new ControlInput(VyEnum,PentaInputEnum,nodeinputs,cmmininputs,cmmaxinputs,P1Enum,i+1));
    2103                                         }
    2104                                         break;
    2105                                 case FrictionCoefficientEnum:
    2106                                         if (iomodel->Data("md.friction.coefficient")){
    2107                                                 for(j=0;j<NUMVERTICES;j++)nodeinputs[j]=iomodel->Data("md.friction.coefficient")[penta_vertex_ids[j]-1];
    2108                                                 for(j=0;j<NUMVERTICES;j++)cmmininputs[j]=iomodel->Data("md.inversion.min_parameters")[(penta_vertex_ids[j]-1)*num_control_type+i];
    2109                                                 for(j=0;j<NUMVERTICES;j++)cmmaxinputs[j]=iomodel->Data("md.inversion.max_parameters")[(penta_vertex_ids[j]-1)*num_control_type+i];
    2110                                                 this->inputs->AddInput(new ControlInput(FrictionCoefficientEnum,PentaInputEnum,nodeinputs,cmmininputs,cmmaxinputs,P1Enum,i+1));
    2111                                         }
    2112                                         break;
    2113                                 case MaterialsRheologyBbarEnum:
    2114                                         if(iomodel->Data("md.materials.rheology_B")){
    2115                                                 for(j=0;j<NUMVERTICES;j++) nodeinputs[j]=iomodel->Data("md.materials.rheology_B")[penta_vertex_ids[j]-1];
    2116                                                 for(j=0;j<NUMVERTICES;j++)cmmininputs[j]=iomodel->Data("md.inversion.min_parameters")[(penta_vertex_ids[j]-1)*num_control_type+i];
    2117                                                 for(j=0;j<NUMVERTICES;j++)cmmaxinputs[j]=iomodel->Data("md.inversion.max_parameters")[(penta_vertex_ids[j]-1)*num_control_type+i];
    2118                                                 this->inputs->AddInput(new ControlInput(MaterialsRheologyBEnum,PentaInputEnum,nodeinputs,cmmininputs,cmmaxinputs,P1Enum,i+1));
    2119                                         }
    2120                                         break;
    2121                                 case DamageDbarEnum:
    2122                                         if(iomodel->Data("md.damage.D")){
    2123                                                 for(j=0;j<NUMVERTICES;j++) nodeinputs[j]=iomodel->Data("md.damage.D")[penta_vertex_ids[j]-1];
    2124                                                 for(j=0;j<NUMVERTICES;j++)cmmininputs[j]=iomodel->Data("md.inversion.min_parameters")[(penta_vertex_ids[j]-1)*num_control_type+i];
    2125                                                 for(j=0;j<NUMVERTICES;j++)cmmaxinputs[j]=iomodel->Data("md.inversion.max_parameters")[(penta_vertex_ids[j]-1)*num_control_type+i];
    2126                                                 this->inputs->AddInput(new ControlInput(DamageDEnum,PentaInputEnum,nodeinputs,cmmininputs,cmmaxinputs,P1Enum,i+1));
    2127                                         }
    2128                                         break;
    2129                                 default:
    2130                                         _error_("Control " << EnumToStringx(control) << " not implemented yet");
    2131                         }
    2132                 }
    2133                 for(i=0;i<num_control_type;i++) xDelete<char>(controls[i]);
    2134                 xDelete<char*>(controls);
    2135         }
    2136 
    2137         /*Need to know the type of approximation for this element*/
    2138         if(iomodel->Data("md.flowequation.element_equation")){
    2139                 this->inputs->AddInput(new IntInput(ApproximationEnum,IoCodeToEnumElementEquation(reCast<int>(iomodel->Data("md.flowequation.element_equation")[index]))));
    2140         }
    2141 
    2142         /*DatasetInputs*/
    2143         if(control_analysis && iomodel->Data("md.inversion.cost_functions_coefficients")) {
    2144 
    2145                 /*Generate cost functions associated with the iomodel*/
    2146                 char**  cost_functions                  = NULL;
    2147                 int*            cost_functions_enums = NULL;
    2148                 int             num_cost_functions;
    2149 
    2150                 iomodel->FindConstant(&num_cost_functions,"md.inversion.num_cost_functions");
    2151                 iomodel->FindConstant(&cost_functions,&num_cost_functions,"md.inversion.cost_functions");
    2152                 if(num_cost_functions<1) _error_("No cost functions found");
    2153                 cost_functions_enums=xNew<int>(num_cost_functions);
    2154                 for(j=0;j<num_cost_functions;j++){ cost_functions_enums[j]=StringToEnumx(cost_functions[j]); }
    2155 
    2156                 /*Create inputs and add to DataSetInput*/
    2157                 DatasetInput* datasetinput=new DatasetInput(InversionCostFunctionsCoefficientsEnum);
    2158                 for(i=0;i<num_responses;i++){
    2159                         for(j=0;j<NUMVERTICES;j++)nodeinputs[j]=iomodel->Data("md.inversion.cost_functions_coefficients")[(penta_vertex_ids[j]-1)*num_responses+i];
    2160                         datasetinput->AddInput(new PentaInput(InversionCostFunctionsCoefficientsEnum,nodeinputs,P1Enum),cost_functions_enums[i]);
    2161                 }
    2162 
    2163                 /*Add datasetinput to element inputs*/
    2164                 this->inputs->AddInput(datasetinput);
    2165 
    2166                 /*Free resources*/
    2167                 for(int j=0;j<num_cost_functions;j++) xDelete<char>(cost_functions[j]);
    2168                 xDelete<char*>(cost_functions);
    2169                 xDelete<int>(cost_functions_enums);
    2170         }
    21712395}
    21722396/*}}}*/
    … …  
    21912415
    21922416        /*Add input to the element: */
    2193         this->inputs->AddInput(new PentaInput(enum_type,values,this->element_type));
     2417        this->AddInput2(enum_type,values,this->element_type);
    21942418
    21952419        /*Free ressources:*/
    … …  
    22252449        for(;;){
    22262450                /*Add input to the element: */
    2227                 penta->inputs->AddInput(new PentaInput(enum_type,values,P1Enum));
     2451                penta->AddInput2(enum_type,values,P1Enum);
    22282452
    22292453                /*Stop if we have reached the surface*/
    … …  
    22432467        int        *doflist        = NULL;
    22442468        IssmDouble  values[numdof];
     2469        int         lidlist[NUMVERTICES];
     2470
     2471        GetVerticesLidList(&lidlist[0]);
    22452472
    22462473        /*Check that name is an element input*/
    … …  
    22532480                        }
    22542481                        /*update input*/
    2255                         this->inputs->AddInput(new PentaInput(name,values,P1Enum));
     2482                        inputs2->SetPentaInput(name,P1Enum,NUMVERTICES,lidlist,values);
    22562483                        return;
    22572484
    … …  
    22612488                        }
    22622489                        /*update input*/
    2263                         this->inputs->AddInput(new PentaInput(name,values,P1Enum));
     2490                        inputs2->SetPentaInput(name,P1Enum,NUMVERTICES,lidlist,values);
    22642491                        return;
    22652492
    … …  
    22692496                        }
    22702497                        /*update input*/
    2271                         this->inputs->AddInput(new PentaInput(name,values,P1Enum));
     2498                        inputs2->SetPentaInput(name,P1Enum,NUMVERTICES,lidlist,values);
    22722499                        return;
    22732500
    … …  
    22832510                        }
    22842511                        /*Add input to the element: */
    2285                         this->inputs->AddInput(new PentaInput(name,values,P1Enum));
     2512                        inputs2->SetPentaInput(name,P1Enum,NUMVERTICES,lidlist,values);
    22862513
    22872514                        /*Free ressources:*/
    … …  
    22962523                        }
    22972524                        /*Add input to the element: */
    2298                         this->inputs->AddInput(new PentaInput(name,values,P1Enum));
     2525                        inputs2->SetPentaInput(name,P1Enum,NUMVERTICES,lidlist,values);
    22992526
    23002527                        /*Free ressources:*/
    … …  
    23402567}
    23412568/*}}}*/
    2342 bool       Penta::IsOnBase(void){/*{{{*/
    2343 
    2344         IssmDouble values[NUMVERTICES];
    2345         IssmDouble sum;
    2346 
    2347         /*Retrieve all inputs and parameters*/
    2348         GetInputListOnVertices(&values[0],MeshVertexonbaseEnum);
    2349         sum = values[0]+values[1]+values[2]+values[3]+values[4]+values[5];
    2350         _assert_(sum==0. || sum==3.);
    2351 
    2352         if(sum==3){
    2353                 return true;
    2354         }
    2355         else{
    2356                 return false;
    2357         }
    2358 }
    2359 /*}}}*/
    2360 bool       Penta::IsOnSurface(void){/*{{{*/
    2361 
    2362         IssmDouble values[NUMVERTICES];
    2363         IssmDouble sum;
    2364 
    2365         /*Retrieve all inputs and parameters*/
    2366         GetInputListOnVertices(&values[0],MeshVertexonsurfaceEnum);
    2367         sum = values[0]+values[1]+values[2]+values[3]+values[4]+values[5];
    2368         _assert_(sum==0. || sum==3.);
    2369 
    2370         if(sum==3){
    2371                 return true;
    2372         }
    2373         else{
    2374                 return false;
    2375         }
    2376 }
    2377 /*}}}*/
    23782569bool       Penta::IsZeroLevelset(int levelset_enum){/*{{{*/
    23792570
    … …  
    26132804        int found=0;
    26142805        IssmDouble value;
    2615         Input* data=NULL;
    26162806        GaussPenta* gauss=NULL;
    26172807
    26182808        /*First, serarch the input: */
    2619         data=inputs->GetInput(natureofdataenum);
     2809        Input2* data=this->GetInput2(natureofdataenum);
    26202810
    26212811        /*figure out if we have the vertex id: */
    … …  
    27722962                        if(this->element_type==MINIcondensedEnum){
    27732963                                int approximation;
    2774                                 inputs->GetInputValue(&approximation,ApproximationEnum);
     2964                                this->GetInput2Value(&approximation,ApproximationEnum);
    27752965                                if(approximation==HOFSApproximationEnum || approximation==SSAFSApproximationEnum){
    27762966                                        //Do nothing, condensation already done in PVectorCoupling
    … …  
    27962986                if(analysis_type==StressbalanceAnalysisEnum){
    27972987                        int approximation;
    2798                         inputs->GetInputValue(&approximation,ApproximationEnum);
     2988                        this->GetInput2Value(&approximation,ApproximationEnum);
    27992989                        if(approximation==HOFSApproximationEnum || approximation==SSAFSApproximationEnum){
    28002990                                //Do nothing condensatino already done for Stokes part
    … …  
    28293019
    28303020        /*For FS only: we want the CS to be tangential to the bedrock*/
    2831         inputs->GetInputValue(&approximation,ApproximationEnum);
     3021        this->GetInput2Value(&approximation,ApproximationEnum);
    28323022        if(!IsOnBase() || (approximation!=FSApproximationEnum && approximation!=SSAFSApproximationEnum &&  approximation!=HOFSApproximationEnum)) return;
    28333023
    … …  
    28363026
    28373027        /*Get inputs*/
    2838         Input* slopex_input=inputs->GetInput(BedSlopeXEnum); _assert_(slopex_input);
    2839         Input* slopey_input=inputs->GetInput(BedSlopeYEnum); _assert_(slopey_input);
    2840         Input* groundedicelevelset_input=inputs->GetInput(MaskGroundediceLevelsetEnum); _assert_(groundedicelevelset_input);
     3028        Input2* slopex_input=this->GetInput2(BedSlopeXEnum); _assert_(slopex_input);
     3029        Input2* slopey_input=this->GetInput2(BedSlopeYEnum); _assert_(slopey_input);
     3030        Input2* groundedicelevelset_input=this->GetInput2(MaskGroundediceLevelsetEnum); _assert_(groundedicelevelset_input);
    28413031
    28423032        /*Loop over basal nodes and update their CS*/
    … …  
    29153105
    29163106        /*Get inputs*/
    2917         Input* bed_input = this->GetInput(BedEnum);                     _assert_(bed_input);
    2918         Input* qsg_input = this->GetInput(FrontalForcingsSubglacialDischargeEnum);               _assert_(qsg_input);
    2919         Input* TF_input  = this->GetInput(FrontalForcingsThermalForcingEnum);          _assert_(TF_input);
     3107        Input2* bed_input = this->GetInput2(BedEnum);                     _assert_(bed_input);
     3108        Input2* qsg_input = this->GetInput2(FrontalForcingsSubglacialDischargeEnum);             _assert_(qsg_input);
     3109        Input2* TF_input  = this->GetInput2(FrontalForcingsThermalForcingEnum);          _assert_(TF_input);
    29203110        GetInputListOnVertices(&basinid[0],FrontalForcingsBasinIdEnum);
    29213111
    … …  
    29503140
    29513141        /*Add input*/
    2952         this->inputs->AddInput(new PentaInput(CalvingMeltingrateEnum,&meltrates[0],P1Enum));
     3142        this->AddInput2(CalvingMeltingrateEnum,&meltrates[0],P1Enum);
    29533143
    29543144        this->InputExtrude(CalvingMeltingrateEnum,-1);
    … …  
    29573147        xDelete<IssmDouble>(basin_icefront_area);
    29583148        delete gauss;
     3149}
     3150/*}}}*/
     3151void       Penta::SetElementInput(int enum_in,IssmDouble value){/*{{{*/
     3152
     3153        this->SetElementInput(this->inputs2,enum_in,value);
     3154
     3155}
     3156/*}}}*/
     3157void       Penta::SetElementInput(Inputs2* inputs2,int enum_in,IssmDouble value){/*{{{*/
     3158
     3159        _assert_(inputs2);
     3160        inputs2->SetPentaInput(enum_in,P0Enum,this->lid,value);
     3161
     3162}
     3163/*}}}*/
     3164void       Penta::SetElementInput(Inputs2* inputs2,int numindices,int* indices,IssmDouble* values,int enum_in){/*{{{*/
     3165
     3166        _assert_(inputs2);
     3167        inputs2->SetPentaInput(enum_in,P1Enum,numindices,indices,values);
     3168
    29593169}
    29603170/*}}}*/
    … …  
    29853195                values[i]=vector[vertexpidlist[i]];
    29863196        }
    2987         Input* new_input = new PentaInput(control_enum,values,P1Enum);
    2988         Input* input=(Input*)this->inputs->GetInput(control_enum);   _assert_(input);
     3197        _error_("not implemented");
     3198        //Input* new_input = new PentaInput(control_enum,values,P1Enum);
     3199        Input2* input=(Input2*)this->GetInput2(control_enum);   _assert_(input);
    29893200        if(input->ObjectEnum()!=ControlInputEnum){
    29903201                _error_("input " << EnumToStringx(control_enum) << " is not a ControlInput");
    29913202        }
    29923203
    2993         ((ControlInput*)input)->SetInput(new_input);
     3204        //((ControlInput*)input)->SetInput(new_input);
    29943205
    29953206        if(control_init==MaterialsRheologyBbarEnum){
    … …  
    30043215
    30053216        IssmDouble  values[NUMVERTICES];
    3006         int         vertexpidlist[NUMVERTICES],control_init;
     3217        int         lidlist[NUMVERTICES];
     3218        int         idlist[NUMVERTICES],control_init;
    30073219
    30083220        /*Specific case for depth averaged quantities*/
    … …  
    30173229        }
    30183230
     3231        /*Get Domain type*/
     3232        int domaintype;
     3233        parameters->FindParam(&domaintype,DomainTypeEnum);
     3234
     3235        /*Specific case for depth averaged quantities*/
     3236        if(domaintype==Domain2DverticalEnum){
     3237                if(control_enum==MaterialsRheologyBbarEnum){
     3238                        control_enum=MaterialsRheologyBEnum;
     3239                        if(!IsOnBase()) return;
     3240                }
     3241                if(control_enum==DamageDbarEnum){
     3242                        control_enum=DamageDEnum;
     3243                        if(!IsOnBase()) return;
     3244                }
     3245        }
     3246
    30193247        /*Get out if this is not an element input*/
    30203248        if(!IsInputEnum(control_enum)) return;
    30213249
    3022         /*Prepare index list*/
    3023         GradientIndexing(&vertexpidlist[0],control_index);
     3250        /*prepare index list*/
     3251        this->GetVerticesLidList(&lidlist[0]);
     3252        GradientIndexing(&idlist[0],control_index);
    30243253
    30253254        /*Get values on vertices*/
    30263255        for(int i=0;i<NUMVERTICES;i++){
    3027                 values[i]=vector[vertexpidlist[i]];
    3028         }
    3029         Input* new_input = new PentaInput(control_enum,values,P1Enum);
    3030         Input* input=(Input*)this->inputs->GetInput(control_enum);   _assert_(input);
    3031         if(input->ObjectEnum()!=ControlInputEnum){
    3032                 _error_("input " << EnumToStringx(control_enum) << " is not a ControlInput");
    3033         }
    3034 
    3035         ((ControlInput*)input)->SetInput(new_input);
    3036 
     3256                values[i]=vector[idlist[i]];
     3257        }
     3258
     3259        /*Set Input*/
     3260        ElementInput2* input=this->inputs2->GetControlInput2Data(control_enum,"value");   _assert_(input);
     3261        input->SetInput(P1Enum,NUMVERTICES,&lidlist[0],&values[0]);
    30373262        if(control_init==MaterialsRheologyBbarEnum){
    3038                 this->InputExtrude(control_enum,-1);
     3263                this->ControlInputExtrude(control_enum,-1);
    30393264        }
    30403265        if(control_init==DamageDbarEnum){
    3041                 this->InputExtrude(control_enum,-1);
     3266                this->ControlInputExtrude(control_enum,-1);
    30423267        }
    30433268}
    … …  
    30803305                        _error_("not supported yet");
    30813306        }
    3082         if(this->inputs->GetInput(VxEnum)) this->InputDepthAverageAtBase(VxEnum,VxAverageEnum);
    3083         if(this->inputs->GetInput(VyEnum)) this->InputDepthAverageAtBase(VyEnum,VyAverageEnum);
    3084         if(this->inputs->GetInput(CalvingratexEnum)) this->InputDepthAverageAtBase(CalvingratexEnum,CalvingratexAverageEnum);
    3085         if(this->inputs->GetInput(CalvingrateyEnum)) this->InputDepthAverageAtBase(CalvingrateyEnum,CalvingrateyAverageEnum);
     3307        if(this->GetInput2(VxEnum)) this->InputDepthAverageAtBase(VxEnum,VxAverageEnum);
     3308        if(this->GetInput2(VyEnum)) this->InputDepthAverageAtBase(VyEnum,VyAverageEnum);
     3309        if(this->GetInput2(CalvingratexEnum)) this->InputDepthAverageAtBase(CalvingratexEnum,CalvingratexAverageEnum);
     3310        if(this->GetInput2(CalvingrateyEnum)) this->InputDepthAverageAtBase(CalvingrateyEnum,CalvingrateyAverageEnum);
    30863311
    30873312        Tria* tria=(Tria*)SpawnTria(0,1,2);
    … …  
    31233348        Tria* tria=new Tria();
    31243349        tria->id=this->id;
    3125         tria->inputs=(Inputs*)this->inputs->SpawnTriaInputs(index1,index2,index3);
     3350        tria->sid=this->sid;
     3351        tria->lid=this->lid;
     3352        tria->inputs=NULL;//(Inputs*)this->inputs->SpawnTriaInputs(index1,index2,index3);
    31263353        tria->parameters=this->parameters;
     3354        tria->inputs2=this->inputs2;
    31273355        tria->element_type=P1Enum; //Only P1 CG for now (TO BE CHANGED)
    31283356        this->SpawnTriaHook(xDynamicCast<ElementHook*>(tria),index1,index2,index3);
     3357
     3358        if(index1==0 && index2==1 && index3==2){
     3359                tria->iscollapsed = 1;
     3360        }
     3361        else if(index1==3 && index2==4 && index3==5){
     3362                tria->iscollapsed = 2;
     3363        }
    31293364
    31303365        /*Spawn material*/
    … …  
    31973432
    31983433        /*Retrieve all inputs we will need*/
    3199         Input* vx_input=inputs->GetInput(VxEnum);                                  _assert_(vx_input);
    3200         Input* vy_input=inputs->GetInput(VyEnum);                                  _assert_(vy_input);
    3201         Input* vz_input=inputs->GetInput(VzEnum);                                                                                               _assert_(vz_input);
     3434        Input2* vx_input=this->GetInput2(VxEnum);                                  _assert_(vx_input);
     3435        Input2* vy_input=this->GetInput2(VyEnum);                                  _assert_(vy_input);
     3436        Input2* vz_input=this->GetInput2(VzEnum);                                                                                               _assert_(vz_input);
    32023437
    32033438        /* Start looping on the number of vertices: */
    … …  
    32223457
    32233458        /*Add input*/
    3224         this->inputs->AddInput(new PentaInput(StrainRateparallelEnum,&strainparallel[0],P1Enum));
     3459        this->AddInput2(StrainRateparallelEnum,&strainparallel[0],P1DGEnum);
    32253460
    32263461        /*Clean up and return*/
    … …  
    32443479
    32453480        /*Retrieve all inputs we will need*/
    3246         Input* vx_input=inputs->GetInput(VxEnum);                                  _assert_(vx_input);
    3247         Input* vy_input=inputs->GetInput(VyEnum);                                  _assert_(vy_input);
    3248         Input* vz_input=inputs->GetInput(VzEnum);                                                                                               _assert_(vz_input);
     3481        Input2* vx_input=this->GetInput2(VxEnum);                                  _assert_(vx_input);
     3482        Input2* vy_input=this->GetInput2(VyEnum);                                  _assert_(vy_input);
     3483        Input2* vz_input=this->GetInput2(VzEnum);                                                                                               _assert_(vz_input);
    32493484
    32503485        /* Start looping on the number of vertices: */
    … …  
    32693504
    32703505        /*Add input*/
    3271         this->inputs->AddInput(new PentaInput(StrainRateperpendicularEnum,&strainperpendicular[0],P1Enum));
     3506        this->AddInput2(StrainRateperpendicularEnum,&strainperpendicular[0],P1DGEnum);
    32723507
    32733508        /*Clean up and return*/
    … …  
    33013536
    33023537                /*Retrieve all inputs we will need*/
    3303                 Input* vx_input=inputs->GetInput(VxEnum);                                  _assert_(vx_input);
    3304                 Input* vy_input=inputs->GetInput(VyEnum);                                  _assert_(vy_input);
    3305                 Input* vel_input=inputs->GetInput(VelEnum);                                _assert_(vel_input);
    3306                 Input* pressure_input=inputs->GetInput(PressureEnum);                      _assert_(pressure_input);
    3307                 Input* deviaxx_input=inputs->GetInput(DeviatoricStressxxEnum);             _assert_(deviaxx_input);
    3308                 Input* deviaxy_input=inputs->GetInput(DeviatoricStressxyEnum);             _assert_(deviaxy_input);
    3309                 Input* deviayy_input=inputs->GetInput(DeviatoricStressyyEnum);             _assert_(deviayy_input);
    3310                 Input* surface_input=inputs->GetInput(SurfaceEnum);                                                             _assert_(surface_input);
    3311                 Input* thickness_input=inputs->GetInput(ThicknessEnum);                                                 _assert_(thickness_input);
     3538                Input2* vx_input=this->GetInput2(VxEnum);                                  _assert_(vx_input);
     3539                Input2* vy_input=this->GetInput2(VyEnum);                                  _assert_(vy_input);
     3540                Input2* vel_input=this->GetInput2(VelEnum);                                _assert_(vel_input);
     3541                Input2* pressure_input=this->GetInput2(PressureEnum);                      _assert_(pressure_input);
     3542                Input2* deviaxx_input=this->GetInput2(DeviatoricStressxxEnum);             _assert_(deviaxx_input);
     3543                Input2* deviaxy_input=this->GetInput2(DeviatoricStressxyEnum);             _assert_(deviaxy_input);
     3544                Input2* deviayy_input=this->GetInput2(DeviatoricStressyyEnum);             _assert_(deviayy_input);
     3545                Input2* surface_input=this->GetInput2(SurfaceEnum);                                                             _assert_(surface_input);
     3546                Input2* thickness_input=this->GetInput2(ThicknessEnum);                                                 _assert_(thickness_input);
    33123547
    33133548                /* Start looping on the number of 2D vertices: */
    … …  
    33493584
    33503585        /*Add input*/
    3351         this->inputs->AddInput(new PentaInput(StressIntensityFactorEnum,&ki[0],P1Enum));
     3586        this->AddInput2(StressIntensityFactorEnum,&ki[0],P1Enum);
    33523587        this->InputExtrude(StressIntensityFactorEnum,-1);
    33533588}
    … …  
    33603595
    33613596        /*retrieve inputs :*/
    3362         inputs->GetInputValue(&approximation,ApproximationEnum);
     3597        this->GetInput2Value(&approximation,ApproximationEnum);
    33633598
    33643599        /*If on water, return 0: */
    … …  
    33913626IssmDouble Penta::TimeAdapt(void){/*{{{*/
    33923627
    3393         int    i;
    3394         IssmDouble C,dx,dy,dz,dt;
    3395         IssmDouble maxabsvx,maxabsvy,maxabsvz;
    3396         IssmDouble maxx,minx,maxy,miny,maxz,minz;
     3628        /*intermediary: */
     3629        IssmDouble C;
    33973630        IssmDouble xyz_list[NUMVERTICES][3];
    33983631
    … …  
    34013634
    34023635        /*Get for Vx and Vy, the max of abs value: */
    3403         maxabsvx = this->inputs->MaxAbs(VxEnum);
    3404         maxabsvy = this->inputs->MaxAbs(VyEnum);
    3405         maxabsvz = this->inputs->MaxAbs(VzEnum);
     3636        Input2* vx_input = this->GetInput2(VxEnum); _assert_(vx_input);
     3637        Input2* vy_input = this->GetInput2(VyEnum); _assert_(vy_input);
     3638        Input2* vz_input = this->GetInput2(VzEnum); _assert_(vz_input);
     3639        IssmDouble maxabsvx = vx_input->GetInputMaxAbs();
     3640        IssmDouble maxabsvy = vy_input->GetInputMaxAbs();
     3641        IssmDouble maxabsvz = vz_input->GetInputMaxAbs();
    34063642
    34073643        /* Get node coordinates and dof list: */
    34083644        ::GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
    34093645
    3410         minx=xyz_list[0][0];
    3411         maxx=xyz_list[0][0];
    3412         miny=xyz_list[0][1];
    3413         maxy=xyz_list[0][1];
    3414         minz=xyz_list[0][2];
    3415         maxz=xyz_list[0][2];
    3416 
    3417         for(i=1;i<NUMVERTICES;i++){
    3418                 if (xyz_list[i][0]<minx)minx=xyz_list[i][0];
    3419                 if (xyz_list[i][0]>maxx)maxx=xyz_list[i][0];
    3420                 if (xyz_list[i][1]<miny)miny=xyz_list[i][1];
    3421                 if (xyz_list[i][1]>maxy)maxy=xyz_list[i][1];
    3422                 if (xyz_list[i][2]<minz)minz=xyz_list[i][2];
    3423                 if (xyz_list[i][2]>maxz)maxz=xyz_list[i][2];
    3424         }
    3425         dx=maxx-minx;
    3426         dy=maxy-miny;
    3427         dz=maxz-minz;
     3646        IssmDouble minx=xyz_list[0][0];
     3647        IssmDouble maxx=xyz_list[0][0];
     3648        IssmDouble miny=xyz_list[0][1];
     3649        IssmDouble maxy=xyz_list[0][1];
     3650        IssmDouble minz=xyz_list[0][2];
     3651        IssmDouble maxz=xyz_list[0][2];
     3652
     3653        for(int i=1;i<NUMVERTICES;i++){
     3654                if(xyz_list[i][0]<minx) minx=xyz_list[i][0];
     3655                if(xyz_list[i][0]>maxx) maxx=xyz_list[i][0];
     3656                if(xyz_list[i][1]<miny) miny=xyz_list[i][1];
     3657                if(xyz_list[i][1]>maxy) maxy=xyz_list[i][1];
     3658                if(xyz_list[i][2]<minz) minz=xyz_list[i][2];
     3659                if(xyz_list[i][2]>maxz) maxz=xyz_list[i][2];
     3660        }
     3661        IssmDouble dx=maxx-minx;
     3662        IssmDouble dy=maxy-miny;
     3663        IssmDouble dz=maxz-minz;
    34283664
    34293665        /*CFL criterion: */
    3430         dt=C/(maxabsvx/dx+maxabsvy/dy+maxabsvz/dz);
     3666        IssmDouble dt = C/(maxabsvx/dx+maxabsvy/dy+maxabsvz/dz);
    34313667
    34323668        return dt;
    … …  
    35253761        IssmDouble calvingratex,calvingratey,thickness,Jdet;
    35263762        IssmDouble rho_ice=FindParam(MaterialsRhoIceEnum);
    3527         Input* thickness_input=inputs->GetInput(ThicknessEnum); _assert_(thickness_input);
    3528         Input* calvingratex_input=NULL;
    3529         Input* calvingratey_input=NULL;
    3530         calvingratex_input=inputs->GetInput(CalvingratexEnum); _assert_(calvingratex_input);
    3531         calvingratey_input=inputs->GetInput(CalvingrateyEnum); _assert_(calvingratey_input);
     3763        Input2* thickness_input=this->GetInput2(ThicknessEnum); _assert_(thickness_input);
     3764        Input2* calvingratex_input=NULL;
     3765        Input2* calvingratey_input=NULL;
     3766        calvingratex_input=this->GetInput2(CalvingratexEnum); _assert_(calvingratex_input);
     3767        calvingratey_input=this->GetInput2(CalvingrateyEnum); _assert_(calvingratey_input);
    35323768
    35333769        /*Start looping on Gaussian points*/
    … …  
    36463882        IssmDouble calvingratex,calvingratey,vx,vy,vel,meltingrate,meltingratex,meltingratey,thickness,Jdet;
    36473883        IssmDouble rho_ice=FindParam(MaterialsRhoIceEnum);
    3648         Input* thickness_input=inputs->GetInput(ThicknessEnum); _assert_(thickness_input);
    3649         Input* calvingratex_input=NULL;
    3650         Input* calvingratey_input=NULL;
    3651         Input* vx_input=NULL;
    3652         Input* vy_input=NULL;
    3653         Input* meltingrate_input=NULL;
    3654         calvingratex_input=inputs->GetInput(CalvingratexEnum); _assert_(calvingratex_input);
    3655         calvingratey_input=inputs->GetInput(CalvingrateyEnum); _assert_(calvingratey_input);
    3656         vx_input=inputs->GetInput(VxAverageEnum); _assert_(vx_input);
    3657         vy_input=inputs->GetInput(VyAverageEnum); _assert_(vy_input);
    3658         meltingrate_input=inputs->GetInput(CalvingMeltingrateEnum); _assert_(meltingrate_input);
     3884        Input2* thickness_input=this->GetInput2(ThicknessEnum); _assert_(thickness_input);
     3885        Input2* calvingratex_input=NULL;
     3886        Input2* calvingratey_input=NULL;
     3887        Input2* vx_input=NULL;
     3888        Input2* vy_input=NULL;
     3889        Input2* meltingrate_input=NULL;
     3890        calvingratex_input=this->GetInput2(CalvingratexEnum); _assert_(calvingratex_input);
     3891        calvingratey_input=this->GetInput2(CalvingrateyEnum); _assert_(calvingratey_input);
     3892        vx_input=this->GetInput2(VxAverageEnum); _assert_(vx_input);
     3893        vy_input=this->GetInput2(VyAverageEnum); _assert_(vy_input);
     3894        meltingrate_input=this->GetInput2(CalvingMeltingrateEnum); _assert_(meltingrate_input);
    36593895
    36603896        /*Start looping on Gaussian points*/
    … …  
    36983934        /*Get material parameters :*/
    36993935        rho_ice=FindParam(MaterialsRhoIceEnum);
    3700         Input* floatingmelt_input = this->GetInput(BasalforcingsFloatingiceMeltingRateEnum); _assert_(floatingmelt_input);
    3701         Input* gllevelset_input = this->GetInput(MaskGroundediceLevelsetEnum); _assert_(gllevelset_input);
    3702         Input* scalefactor_input = NULL;
     3936        Input2* floatingmelt_input = this->GetInput2(BasalforcingsFloatingiceMeltingRateEnum); _assert_(floatingmelt_input);
     3937        Input2* gllevelset_input = this->GetInput2(MaskGroundediceLevelsetEnum); _assert_(gllevelset_input);
     3938        Input2* scalefactor_input = NULL;
    37033939        if(scaled==true){
    3704                 scalefactor_input = this->GetInput(MeshScaleFactorEnum); _assert_(scalefactor_input);
     3940                scalefactor_input = this->GetInput2(MeshScaleFactorEnum); _assert_(scalefactor_input);
    37053941        }
    37063942        ::GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
    … …  
    37433979        /*Get material parameters :*/
    37443980        rho_ice=FindParam(MaterialsRhoIceEnum);
    3745         Input* groundedmelt_input = this->GetInput(BasalforcingsGroundediceMeltingRateEnum); _assert_(groundedmelt_input);
    3746         Input* gllevelset_input = this->GetInput(MaskGroundediceLevelsetEnum); _assert_(gllevelset_input);
    3747         Input* scalefactor_input = NULL;
     3981        Input2* groundedmelt_input = this->GetInput2(BasalforcingsGroundediceMeltingRateEnum); _assert_(groundedmelt_input);
     3982        Input2* gllevelset_input   = this->GetInput2(MaskGroundediceLevelsetEnum); _assert_(gllevelset_input);
     3983        Input2* scalefactor_input = NULL;
    37483984        if(scaled==true){
    3749                 scalefactor_input = this->GetInput(MeshScaleFactorEnum); _assert_(scalefactor_input);
     3985                scalefactor_input = this->GetInput2(MeshScaleFactorEnum); _assert_(scalefactor_input);
    37503986        }
    37513987        ::GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
    … …  
    37934029
    37944030        /*Now get the average SMB over the element*/
    3795         Input* smb_input = inputs->GetInput(SmbMassBalanceEnum); _assert_(smb_input);
     4031        Input2* smb_input = this->GetInput2(SmbMassBalanceEnum); _assert_(smb_input);
    37964032
    37974033        smb_input->GetInputAverage(&smb);
    37984034        if(scaled==true){
    3799                 Input* scalefactor_input = inputs->GetInput(MeshScaleFactorEnum); _assert_(scalefactor_input);
     4035                Input2* scalefactor_input = this->GetInput2(MeshScaleFactorEnum); _assert_(scalefactor_input);
    38004036                scalefactor_input->GetInputAverage(&scalefactor);// average scalefactor on element
    38014037        }
    … …  
    38094045}
    38104046/*}}}*/
    3811 void       Penta::Update(int index,IoModel* iomodel,int analysis_counter,int analysis_type,int finiteelement_type){ /*{{{*/
     4047void       Penta::Update(Inputs2* inputs2,int index,IoModel* iomodel,int analysis_counter,int analysis_type,int finiteelement_type){ /*{{{*/
    38124048
    38134049        /*Intermediaries*/
    … …  
    41884424        xDelete<int>(penta_node_ids);
    41894425
    4190         /*Fill with IoModel*/
    4191         this->InputUpdateFromIoModel(index,iomodel);
    4192 
    41934426        /*Defaults if not provided in iomodel*/
    41944427        switch(analysis_type){
    … …  
    41984431
    41994432                        if((IoCodeToEnumElementEquation(reCast<int>(iomodel->Data("md.flowequation.element_equation")[index])))==HOFSApproximationEnum){
     4433                                int vertexlids[NUMVERTICES];
     4434                                for(i=0;i<NUMVERTICES;i++) vertexlids[i]=iomodel->my_vertices_lids[penta_vertex_ids[i]-1];
    42004435                                /*Create VzHO and VzFS Enums*/
    42014436                                if(iomodel->Data("md.initialization.vz") && iomodel->Data("md.flowequation.borderFS")){
    42024437                                        for(i=0;i<6;i++) nodeinputs[i]=iomodel->Data("md.initialization.vz")[penta_vertex_ids[i]-1]*iomodel->Data("md.flowequation.borderFS")[penta_vertex_ids[i]-1];
    4203                                         this->inputs->AddInput(new PentaInput(VzFSEnum,nodeinputs,P1Enum));
     4438                                        this->SetElementInput(inputs2,NUMVERTICES,vertexlids,nodeinputs,VzFSEnum);
    42044439                                        for(i=0;i<6;i++) nodeinputs[i]=iomodel->Data("md.initialization.vz")[penta_vertex_ids[i]-1]*(1-iomodel->Data("md.flowequation.borderFS")[penta_vertex_ids[i]-1]);
    4205                                         this->inputs->AddInput(new PentaInput(VzHOEnum,nodeinputs,P1Enum));
     4440                                        this->SetElementInput(inputs2,NUMVERTICES,vertexlids,nodeinputs,VzHOEnum);
    42064441                                }
    42074442                                else{
    42084443                                        for(i=0;i<6;i++)nodeinputs[i]=0;
    4209                                         this->inputs->AddInput(new PentaInput(VzFSEnum,nodeinputs,P1Enum));
    4210                                         this->inputs->AddInput(new PentaInput(VzHOEnum,nodeinputs,P1Enum));
     4444                                        this->SetElementInput(inputs2,NUMVERTICES,vertexlids,nodeinputs,VzFSEnum);
     4445                                        this->SetElementInput(inputs2,NUMVERTICES,vertexlids,nodeinputs,VzHOEnum);
    42114446                                }
    42124447                        }
    42134448                        if((IoCodeToEnumElementEquation(reCast<int>(iomodel->Data("md.flowequation.element_equation")[index])))==SSAFSApproximationEnum){
     4449                                int vertexlids[NUMVERTICES];
     4450                                for(i=0;i<NUMVERTICES;i++) vertexlids[i]=iomodel->my_vertices_lids[penta_vertex_ids[i]-1];
    42144451                                /*Create VzSSA and VzFS Enums*/
    42154452                                if(iomodel->Data("md.initialization.vz") && iomodel->Data("md.flowequation.borderFS")){
    42164453                                        for(i=0;i<6;i++) nodeinputs[i]=iomodel->Data("md.initialization.vz")[penta_vertex_ids[i]-1]*iomodel->Data("md.flowequation.borderFS")[penta_vertex_ids[i]-1];
    4217                                         this->inputs->AddInput(new PentaInput(VzFSEnum,nodeinputs,P1Enum));
     4454                                        this->SetElementInput(inputs2,NUMVERTICES,vertexlids,nodeinputs,VzFSEnum);
    42184455                                        for(i=0;i<6;i++) nodeinputs[i]=iomodel->Data("md.initialization.vz")[penta_vertex_ids[i]-1]*(1-iomodel->Data("md.flowequation.borderFS")[penta_vertex_ids[i]-1]);
    4219                                         this->inputs->AddInput(new PentaInput(VzSSAEnum,nodeinputs,P1Enum));
     4456                                        this->SetElementInput(inputs2,NUMVERTICES,vertexlids,nodeinputs,VzSSAEnum);
    42204457                                }
    42214458                                else{
    42224459                                        for(i=0;i<6;i++)nodeinputs[i]=0;
    4223                                         this->inputs->AddInput(new PentaInput(VzFSEnum,nodeinputs,P1Enum));
    4224                                         this->inputs->AddInput(new PentaInput(VzSSAEnum,nodeinputs,P1Enum));
     4460                                        this->SetElementInput(inputs2,NUMVERTICES,vertexlids,nodeinputs,VzFSEnum);
     4461                                        this->SetElementInput(inputs2,NUMVERTICES,vertexlids,nodeinputs,VzSSAEnum);
    42254462                                }
    42264463                        }
    … …  
    42404477
    42414478        this->parameters->FindParam(&extrusioninput,InputToExtrudeEnum);
    4242         Input* input = inputs->GetInput(extrusioninput);      _assert_(extrusioninput);
    4243         Input* onbase = inputs->GetInput(MeshVertexonbaseEnum); _assert_(onbase);
     4479        Input2* input = this->GetInput2(extrusioninput);      _assert_(extrusioninput);
     4480        Input2* onbase = this->GetInput2(MeshVertexonbaseEnum); _assert_(onbase);
    42444481
    42454482        GaussPenta* gauss=new GaussPenta();
    … …  
    42654502
    42664503        this->parameters->FindParam(&extrusioninput,InputToExtrudeEnum);
    4267         Input* input = inputs->GetInput(extrusioninput); _assert_(extrusioninput);
     4504        Input2* input = this->GetInput2(extrusioninput); _assert_(extrusioninput);
    42684505
    42694506        GaussPenta* gauss=new GaussPenta();
    … …  
    43334570}
    43344571/*}}}*/
    4335 void       Penta::ViscousHeating(IssmDouble* pphi,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input){/*{{{*/
     4572void       Penta::ViscousHeating(IssmDouble* pphi,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input,Input2* vz_input){/*{{{*/
    43364573
    43374574        /*Intermediaries*/
    … …  
    43604597void       Penta::InputUpdateFromMatrixDakota(IssmDouble* matrix, int nrows, int ncols, int name, int type){/*{{{*/
    43614598
    4362         int             i,t,row;
    4363         IssmDouble      time;
    4364         TransientInput *transientinput = NULL;
    4365         IssmDouble      values[6];
    4366         IssmDouble      value;
    4367 
    43684599        /*Check that name is an element input*/
    43694600        if(!IsInputEnum(name)) _error_("Enum "<<EnumToStringx(name)<<" is not in IsInput");
     4601        TransientInput2* transientinput = inputs2->GetTransientInput(name);
    43704602
    43714603        switch(type){
    43724604
    43734605                case VertexEnum:
     4606
     4607                        /*Get LID lists once for all*/
     4608                        IssmDouble  values[NUMVERTICES];
     4609                        int         lidlist[NUMVERTICES];
     4610                        this->GetVerticesLidList(&lidlist[0]);
     4611
    43744612                        /*Create transient input: */
    4375                         for(t=0;t<ncols;t++){ //ncols is the number of times
     4613                        for(int t=0;t<ncols;t++){ //ncols is the number of times
    43764614
    43774615                                /*create input values: */
    4378                                 for(i=0;i<6;i++){
    4379                                         row=this->vertices[i]->Sid();
     4616                                for(int i=0;i<6;i++){
     4617                                        int row=this->vertices[i]->Sid();
    43804618                                        values[i]=matrix[ncols*row+t];
    43814619                                }
    43824620
    43834621                                /*time:*/
    4384                                 time=matrix[(nrows-1)*ncols+t];
    4385 
    4386                                 if(t==0) transientinput=new TransientInput(name);
    4387                                 transientinput->AddTimeInput(new PentaInput(name,values,P1Enum),time);
    4388                                 transientinput->Configure(parameters);
     4622                                IssmDouble time=matrix[(nrows-1)*ncols+t];
     4623
     4624                                transientinput->AddPentaTimeInput(t,NUMVERTICES,&lidlist[0],&values[0],P1Enum);
    43894625                        }
    4390                         this->inputs->AddInput(transientinput);
    43914626                        break;
    43924627
    43934628                case ElementEnum:
    43944629                        /*Get value for the element: */
    4395                         for(t=0;t<ncols;t++){ //ncols is the number of times
    4396                                 value=matrix[ncols*(this->Sid())+t];
    4397 
    4398                                 /*time:*/
    4399                                 time=matrix[(nrows-1)*ncols+t];
    4400 
    4401                                 if(t==0) transientinput=new TransientInput(name);
    4402                                 transientinput->AddTimeInput(new PentaInput(name,&value,P0Enum),time);
    4403                                 transientinput->Configure(parameters);
     4630                        for(int t=0;t<ncols;t++){ //ncols is the number of times
     4631                                IssmDouble value=matrix[ncols*(this->Sid())+t];
     4632                                IssmDouble time=matrix[(nrows-1)*ncols+t];
     4633                                transientinput->AddPentaTimeInput(t,1,&(this->lid),&value,P0Enum);
    44044634                        }
    4405                         this->inputs->AddInput(transientinput);
    44064635                        break;
    44074636
    … …  
    44964725
    44974726                                        /*Add new inputs: */
    4498                                         this->inputs->AddInput(new PentaInput(ThicknessEnum,thickness,P1Enum));
    4499                                         this->inputs->AddInput(new PentaInput(BaseEnum,bed,P1Enum));
    4500                                         this->inputs->AddInput(new PentaInput(SurfaceEnum,surface,P1Enum));
     4727                                        this->AddInput2(ThicknessEnum,thickness,P1Enum);
     4728                                        this->AddInput2(BaseEnum,bed,P1Enum);
     4729                                        this->AddInput2(SurfaceEnum,surface,P1Enum);
    45014730                                        break;
    45024731
    45034732                                default:
    4504                                         this->inputs->AddInput(new PentaInput(name,values,P1Enum));
     4733                                        this->AddInput2(name,values,P1Enum);
    45054734                        }
    45064735                        break;
    … …  
    45104739                        /*Get value for the element: */
    45114740                        value=vector[this->Sid()]; //careful, vector of values here is not parallel distributed, but serial distributed (from a serial Dakota core!)
    4512                         this->inputs->AddInput(new PentaInput(name,&value,P0Enum));
     4741                        this->AddInput2(name,&value,P0Enum);
    45134742                        break;
    45144743

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

    r24208 r24335  
    3535                /*Penta constructors and destructor: {{{*/
    3636                Penta(){};
    37                 Penta(int penta_id,int penta_sid,IoModel* iomodel,int nummodels);
     37                Penta(int penta_id,int penta_sid,int penta_lid,IoModel* iomodel,int nummodels);
    3838                ~Penta();
    3939                /*}}}*/
    … …  
    4545                /*Penta routines:{{{*/
    4646                void           AddBasalInput(int input_enum, IssmDouble* values, int interpolation_enum);
     47                void           AddBasalInput2(int input_enum, IssmDouble* values, int interpolation_enum);
    4748                void           AddInput(int input_enum, IssmDouble* values, int interpolation_enum);
     49                void           AddInput2(int input_enum, IssmDouble* values, int interpolation_enum);
     50                void           AddControlInput(int input_enum,Inputs2* inputs2,IoModel* iomodel,IssmDouble* values,IssmDouble* values_min,IssmDouble* values_max, int interpolation_enum,int id);
     51                void           ControlInputExtrude(int enum_type,int start);
     52                void           DatasetInputExtrude(int enum_type,int start);
     53                void           DatasetInputCreate(IssmDouble* array,int M,int N,int* individual_enums,int num_inputs,Inputs2* inputs2,IoModel* iomodel,int input_enum);
    4854                void           AverageOntoPartition(Vector<IssmDouble>* partition_contributions,Vector<IssmDouble>* partition_areas,IssmDouble* vertex_response,IssmDouble* qmu_part);
    4955                void           BasalNodeIndices(int* pnumindices,int** pindices,int finiteelement);
    … …  
    5864                void           ComputeSigmaNN(){_error_("not implemented yet");};
    5965                void           ComputeStressTensor();
    60                 void           Configure(Elements* elements,Loads* loads,Nodes* nodes,Vertices* vertices,Materials* materials,Parameters* parameters);
     66                void           Configure(Elements* elements,Loads* loads,Nodes* nodes,Vertices* vertices,Materials* materials,Parameters* parameters,Inputs2* inputs2in);
    6167                void           ControlInputSetGradient(IssmDouble* gradient,int enum_type,int control_index,int offset,int N,int M);
    6268                void           ControlInputSetGradient(IssmDouble* gradient,int enum_type,int control_index);
    … …  
    7985                IssmDouble              GetIcefrontArea();
    8086                void           GetIcefrontCoordinates(IssmDouble** pxyz_front,IssmDouble* xyz_list,int levelsetenum);
     87                Input2*        GetInput2(int enumtype);
     88                Input2*        GetInput2(int enumtype,IssmDouble time);
     89                DatasetInput2* GetDatasetInput2(int inputenum);
    8190                void           GetInputValue(IssmDouble* pvalue,Vertex* vertex,int enumtype);
    8291                void           GetInputValue(IssmDouble* pvalue,Node* node,int enumtype);
    … …  
    107116                bool           IsIcefront(void);
    108117                bool           IsNodeOnShelfFromFlags(IssmDouble* flags);
    109                 bool             IsOnBase(void);
    110                 bool             IsOnSurface(void);
    111118                bool           IsZeroLevelset(int levelset_enum);
    112119                void           JacobianDeterminant(IssmDouble*  Jdet, IssmDouble* xyz_list,Gauss* gauss);
    … …  
    154161                void           ResetHooks();
    155162                void                            RignotMeltParameterization();
     163                void           SetElementInput(int enum_in,IssmDouble values);
     164                void           SetElementInput(Inputs2* inputs2,int enum_in,IssmDouble values);
     165                void           SetElementInput(Inputs2* inputs2,int numindices,int* indices,IssmDouble* values,int enum_in);
    156166                void           SetControlInputsFromVector(IssmDouble* vector,int control_enum,int control_index,int offset, int N,int M);
    157167                void           SetControlInputsFromVector(IssmDouble* vector,int control_enum,int control_index);
    … …  
    174184                IssmDouble     TotalGroundedBmb(bool scaled);
    175185                IssmDouble     TotalSmb(bool scaled);
    176                 void           Update(int index, IoModel* iomodel,int analysis_counter,int analysis_type,int finitelement);
     186                void           Update(Inputs2* inputs,int index, IoModel* iomodel,int analysis_counter,int analysis_type,int finitelement);
    177187                void           UpdateConstraintsExtrudeFromBase(void);
    178188                void           UpdateConstraintsExtrudeFromTop(void);
    … …  
    184194                void           VerticalSegmentIndices(int** pindices,int* pnumseg);
    185195                void           VerticalSegmentIndicesBase(int** pindices,int* pnumseg);
    186                 void           ViscousHeating(IssmDouble* pphi,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input);
     196                void           ViscousHeating(IssmDouble* pphi,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input,Input2* vz_input);
    187197
    188198                #ifdef _HAVE_DAKOTA_

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

    r23644 r24335  
    1313#include <string.h>
    1414#include "../classes.h"
     15#include "../Inputs2/SegInput2.h"
     16#include "../Inputs2/TriaInput2.h"
    1517#include "../../shared/shared.h"
    1618/*}}}*/
    … …  
    1921#define NUMVERTICES 2
    2022/*Constructors/destructor/copy*/
    21 Seg::Seg(int seg_id, int seg_sid,IoModel* iomodel,int nummodels)/*{{{*/
     23Seg::Seg(int seg_id, int seg_sid,int seg_lid,IoModel* iomodel,int nummodels)/*{{{*/
    2224                :ElementHook(nummodels,seg_id,NUMVERTICES,iomodel){
     25
     26                        this->iscollapsed = 0;
     27                        this->collapsed_ids[0] = -1;
     28                        this->collapsed_ids[1] = -1;
    2329
    2430                        /*id: */
    2531                        this->id  = seg_id;
    2632                        this->sid = seg_sid;
     33                        this->lid = seg_lid;
     34
     35                        /*surface and base*/
     36                        this->isonsurface = false;
     37                        this->isonbase    = false;
    2738
    2839                        //this->parameters: we still can't point to it, it may not even exist. Configure will handle this.
    … …  
    3950                        /*Only allocate pointer*/
    4051                        this->element_type_list=xNew<int>(nummodels);
     52
     53                        /*surface and base*/
     54                        this->isonsurface = true;
     55                        this->isonbase    = true;
    4156                }
    4257/*}}}*/
    … …  
    5166
    5267        seg=new Seg();
     68
     69        seg->iscollapsed=this->iscollapsed;
     70        seg->collapsed_ids[0]=this->collapsed_ids[0];
     71        seg->collapsed_ids[1]=this->collapsed_ids[1];
    5372
    5473        //deal with TriaRef mother class
    … …  
    82101        seg->id  = this->id;
    83102        seg->sid = this->sid;
     103        seg->lid = this->lid;
    84104        if(this->inputs) seg->inputs = (Inputs*)(this->inputs->Copy());
    85105        else seg->inputs=new Inputs();
     106        seg->isonbase  = this->isonbase;
     107        seg->isonsurface  = this->isonsurface;
    86108
    87109        /*point parameters: */
    … …  
    106128
    107129        MARSHALLING_ENUM(SegEnum);
     130        MARSHALLING(this->iscollapsed);
     131        MARSHALLING(this->isonsurface);
     132        MARSHALLING(this->isonbase);
     133        MARSHALLING(this->collapsed_ids[0]);
     134        MARSHALLING(this->collapsed_ids[1]);
    108135
    109136        /*Call parent classes: */
    … …  
    163190        *pxyz_front=xyz_front;
    164191}/*}}}*/
     192Input2*    Seg::GetInput2(int inputenum){/*{{{*/
     193
     194        if(this->iscollapsed){
     195                TriaInput2* input = this->inputs2->GetTriaInput(inputenum);
     196                if(!input) return input;
     197
     198                /*Intermediaries*/
     199                int numindices;
     200                int indices[7];
     201
     202                /*Check interpolation*/
     203                int interpolation = input->GetInterpolation();
     204                switch(interpolation){
     205                        case P0Enum:
     206                                numindices = 1;
     207                                indices[0] = this->lid;
     208                                input->Serve(numindices,&indices[0]);
     209                                break;
     210                        case P1Enum:
     211                                numindices = 2;
     212                                for(int i=0;i<numindices;i++) indices[i] = vertices[i]->lid;
     213                                input->Serve(numindices,&indices[0]);
     214                                break;
     215                        case P1DGEnum:
     216                        case P1bubbleEnum:
     217                        default:
     218                                input->ServeCollapsed(this->lid,this->collapsed_ids[0],this->collapsed_ids[1]);
     219                                break;
     220                        //default: _error_("interpolation "<<EnumToStringx(interpolation)<<" not supported");
     221                }
     222                /*Flag as collapsed for later use*/
     223                input->SetServeCollapsed(true);
     224
     225                return input;
     226        }
     227        else{
     228                SegInput2* input = this->inputs2->GetSegInput(inputenum);
     229                if(!input) return input;
     230
     231                /*Intermediaries*/
     232                int numindices;
     233                int indices[7];
     234
     235                /*Check interpolation*/
     236                int interpolation = input->GetInterpolation();
     237                switch(interpolation){
     238                        case P0Enum:
     239                                numindices = 1;
     240                                indices[0] = this->lid;
     241                                input->Serve(numindices,&indices[0]);
     242                                break;
     243                        case P1Enum:
     244                                numindices = 3;
     245                                for(int i=0;i<3;i++) indices[i] = vertices[i]->lid;
     246                                input->Serve(numindices,&indices[0]);
     247                                break;
     248                        case P1DGEnum:
     249                                numindices = 3;
     250                                input->Serve(this->lid,numindices);
     251                                break;
     252                        default:
     253                                input->Serve(this->lid,this->GetNumberOfNodes(interpolation));
     254                }
     255
     256                return input;
     257        }
     258}/*}}}*/
     259Input2*    Seg::GetInput2(int inputenum,IssmDouble time){/*{{{*/
     260        _error_("not implemented yet");
     261}/*}}}*/
    165262IssmDouble Seg::GetGroundedPortion(IssmDouble* xyz_list){/*{{{*/
    166263        /*Computeportion of the element that is grounded*/

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

    r24208 r24335  
    2828
    2929        public:
     30                int iscollapsed;
     31                int collapsed_ids[2];
    3032
    3133                /*Seg constructors, destructors {{{*/
    3234                Seg(){};
    33                 Seg(int seg_id,int seg_sid,IoModel* iomodel,int nummodels);
     35                Seg(int seg_id,int seg_sid,int seg_lid,IoModel* iomodel,int nummodels);
    3436                ~Seg();
    3537                /*}}}*/
    … …  
    4951                void        ComputeSigmaNN(){_error_("not implemented yet");};
    5052                void        ComputeStressTensor(){_error_("not implemented yet");};
    51                 void        Configure(Elements* elements,Loads* loads,Nodes* nodesin,Vertices* verticesin,Materials* materials,Parameters* parameters){_error_("not implemented yet");};
     53                void        Configure(Elements* elements,Loads* loads,Nodes* nodesin,Vertices* verticesin,Materials* materials,Parameters* parameters,Inputs2* inputs2in){_error_("not implemented yet");};
    5254                void        ControlInputSetGradient(IssmDouble* gradient,int enum_type,int control_index,int offset,int N,int M){_error_("not implemented yet");};
    5355                void        ControlInputSetGradient(IssmDouble* gradient,int enum_type,int control_index){_error_("not implemented yet");};
    … …  
    6365                IssmDouble  GetGroundedPortion(IssmDouble* xyz_list);
    6466                void               GetIcefrontCoordinates(IssmDouble** pxyz_front,IssmDouble* xyz_list,int levelsetenum);
     67                Input2*     GetInput2(int enumtype);
     68                Input2*     GetInput2(int enumtype,IssmDouble time);
    6569                void        GetInputValue(IssmDouble* pvalue,Vertex* vertex,int enumtype){_error_("not implemented yet");};
    6670                void               GetLevelCoordinates(IssmDouble** pxyz_front,IssmDouble* xyz_list,int levelsetenum,IssmDouble level){_error_("not implemented");};
    … …  
    8690                bool               IsIcefront(void);
    8791                bool        IsNodeOnShelfFromFlags(IssmDouble* flags){_error_("not implemented yet");};
    88                 bool        IsOnBase(){_error_("not implemented yet");};
    89                 bool        IsOnSurface(){_error_("not implemented yet");};
    9092                bool        IsZeroLevelset(int levelset_enum){_error_("not implemented");};
    9193                void        JacobianDeterminant(IssmDouble*  Jdet, IssmDouble* xyz_list,Gauss* gauss);
    … …  
    148150                IssmDouble  TotalGroundedBmb(bool scaled){_error_("not implemented yet");};
    149151                IssmDouble  TotalSmb(bool scaled){_error_("not implemented yet");};
    150                 void        Update(int index, IoModel* iomodel,int analysis_counter,int analysis_type,int finitelement){_error_("not implemented yet");};
     152                void        Update(Inputs2* inputs2,int index, IoModel* iomodel,int analysis_counter,int analysis_type,int finitelement){_error_("not implemented yet");};
    151153                void        UpdateConstraintsExtrudeFromBase(){_error_("not implemented");};
    152154                void        UpdateConstraintsExtrudeFromTop(){_error_("not implemented");};
    … …  
    158160                void        VerticalSegmentIndices(int** pindices,int* pnumseg){_error_("not implemented yet");};
    159161                void        VerticalSegmentIndicesBase(int** pindices,int* pnumseg){_error_("not implemented yet");};
    160                 void        ViscousHeating(IssmDouble* pphi,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input){_error_("not implemented yet");};
    161162                IssmDouble     GetArea3D(void){_error_("not implemented yet!");};
    162163                IssmDouble     GetAreaSpherical(void){_error_("not implemented yet!");};

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

    r24089 r24335  
    1313#include <string.h>
    1414#include "../classes.h"
     15#include "../Inputs2/ElementInput2.h"
    1516#include "../../shared/shared.h"
    1617/*}}}*/
    … …  
    2021
    2122/*Constructors/destructor/copy*/
    22 Tetra::Tetra(int tet_id, int tet_sid,IoModel* iomodel,int nummodels)/*{{{*/
     23Tetra::Tetra(int tet_id, int tet_sid,int tet_lid,IoModel* iomodel,int nummodels)/*{{{*/
    2324                :ElementHook(nummodels,tet_id,NUMVERTICES,iomodel){
    2425
    … …  
    2627                        this->id  = tet_id;
    2728                        this->sid = tet_sid;
     29                        this->lid = tet_lid;
     30
     31                        /*surface and base*/
     32                        this->isonsurface = false;
     33                        this->isonbase    = false;
    2834
    2935                        //this->parameters: we still can't point to it, it may not even exist. Configure will handle this.
    … …  
    4046                        /*Only allocate pointer*/
    4147                        this->element_type_list=xNew<int>(nummodels);
     48
     49                        /*surface and base*/
     50                        _assert_(iomodel->Data("md.mesh.vertexonsurface"));
     51                        _assert_(iomodel->Data("md.mesh.vertexonbase"));
     52                        this->isonsurface = false;
     53                        this->isonbase    = false;
     54                        IssmDouble sum = 0.;
     55                        for(int i=0;i<NUMVERTICES;i++) sum += iomodel->Data("md.mesh.vertexonsurface")[reCast<int>(iomodel->elements[(tet_id-1)*NUMVERTICES+i])-1];
     56                        _assert_(sum>=0 && sum<4);
     57                        if(sum>2.5) this->isonsurface = true;
     58                        sum = 0.;
     59                        for(int i=0;i<NUMVERTICES;i++) sum += iomodel->Data("md.mesh.vertexonbase")[reCast<int>(iomodel->elements[(tet_id-1)*NUMVERTICES+i])-1];
     60                        _assert_(sum>=0 && sum<4);
     61                        if(sum>2.5) this->isonbase = true;
    4262                }
    4363/*}}}*/
    … …  
    83103        tetra->id  = this->id;
    84104        tetra->sid = this->sid;
     105        tetra->lid = this->lid;
    85106        if(this->inputs) tetra->inputs = (Inputs*)(this->inputs->Copy());
    86107        else tetra->inputs=new Inputs();
     108        tetra->isonbase  = this->isonbase;
     109        tetra->isonsurface  = this->isonsurface;
    87110
    88111        /*point parameters: */
    … …  
    103126
    104127        MARSHALLING_ENUM(TetraEnum);
     128        MARSHALLING(this->isonsurface);
     129        MARSHALLING(this->isonbase);
    105130
    106131        /*Call parent classes: */
    … …  
    122147}
    123148/*}}}*/
    124 void     Tetra::Configure(Elements* elementsin, Loads* loadsin, Nodes* nodesin,Vertices* verticesin, Materials* materialsin, Parameters* parametersin){/*{{{*/
     149void     Tetra::Configure(Elements* elementsin, Loads* loadsin, Nodes* nodesin,Vertices* verticesin, Materials* materialsin, Parameters* parametersin,Inputs2* inputs2in){/*{{{*/
    125150
    126151        int analysis_counter;
    … …  
    146171        /*point parameters to real dataset: */
    147172        this->parameters=parametersin;
     173        this->inputs2=inputs2in;
    148174
    149175        /*get inputs configured too: */
    … …  
    246272}
    247273/*}}}*/
     274Input2*    Tetra::GetInput2(int inputenum){/*{{{*/
     275        _error_("not implemented yet");
     276}/*}}}*/
     277Input2*    Tetra::GetInput2(int inputenum,IssmDouble time){/*{{{*/
     278        _error_("not implemented yet");
     279}/*}}}*/
    248280void     Tetra::GetInputValue(IssmDouble* pvalue,Node* node,int enumtype){/*{{{*/
    249281
    250         Input* input=inputs->GetInput(enumtype);
     282        Input2* input=this->GetInput2(enumtype);
    251283        if(!input) _error_("No input of type " << EnumToStringx(enumtype) << " found in tria");
    252284
    … …  
    363395                tetra_vertex_ids[i]=iomodel->elements[NUMVERTICES*index+i]; //ids for vertices are in the elements array from Matlab
    364396        }
    365 
    366         /*Control Inputs*/
    367         if (control_analysis){
    368                 iomodel->FindConstant(&controls,NULL,"md.inversion.control_parameters");
    369                 for(i=0;i<num_control_type;i++){
    370                         _assert_(controls[i]);
    371                         int control = StringToEnumx(controls[i]);
    372                         switch(control){
    373                                 case BalancethicknessThickeningRateEnum:
    374                                         if (iomodel->Data("md.balancethickness.thickening_rate")){
    375                                                 for(j=0;j<NUMVERTICES;j++)nodeinputs[j]=iomodel->Data("md.balancethickness.thickening_rate")[tetra_vertex_ids[j]-1];
    376                                                 for(j=0;j<NUMVERTICES;j++)cmmininputs[j]=iomodel->Data("md.inversion.min_parameters")[(tetra_vertex_ids[j]-1)*num_control_type+i]/yts;
    377                                                 for(j=0;j<NUMVERTICES;j++)cmmaxinputs[j]=iomodel->Data("md.inversion.max_parameters")[(tetra_vertex_ids[j]-1)*num_control_type+i]/yts;
    378                                                 this->inputs->AddInput(new ControlInput(BalancethicknessThickeningRateEnum,TetraInputEnum,nodeinputs,cmmininputs,cmmaxinputs,P1Enum,i+1));
    379                                         }
    380                                         break;
    381                                 case VxEnum:
    382                                         if (iomodel->Data("md.initialization.vx")){
    383                                                 for(j=0;j<NUMVERTICES;j++)nodeinputs[j]=iomodel->Data("md.initialization.vx")[tetra_vertex_ids[j]-1];
    384                                                 for(j=0;j<NUMVERTICES;j++)cmmininputs[j]=iomodel->Data("md.inversion.min_parameters")[(tetra_vertex_ids[j]-1)*num_control_type+i]/yts;
    385                                                 for(j=0;j<NUMVERTICES;j++)cmmaxinputs[j]=iomodel->Data("md.inversion.max_parameters")[(tetra_vertex_ids[j]-1)*num_control_type+i]/yts;
    386                                                 this->inputs->AddInput(new ControlInput(VxEnum,TetraInputEnum,nodeinputs,cmmininputs,cmmaxinputs,P1Enum,i+1));
    387                                         }
    388                                         break;
    389                                 case VyEnum:
    390                                         if (iomodel->Data("md.initialization.vy")){
    391                                                 for(j=0;j<NUMVERTICES;j++)nodeinputs[j]=iomodel->Data("md.initialization.vy")[tetra_vertex_ids[j]-1];
    392                                                 for(j=0;j<NUMVERTICES;j++)cmmininputs[j]=iomodel->Data("md.inversion.min_parameters")[(tetra_vertex_ids[j]-1)*num_control_type+i]/yts;
    393                                                 for(j=0;j<NUMVERTICES;j++)cmmaxinputs[j]=iomodel->Data("md.inversion.max_parameters")[(tetra_vertex_ids[j]-1)*num_control_type+i]/yts;
    394                                                 this->inputs->AddInput(new ControlInput(VyEnum,TetraInputEnum,nodeinputs,cmmininputs,cmmaxinputs,P1Enum,i+1));
    395                                         }
    396                                         break;
    397                                 case FrictionCoefficientEnum:
    398                                         if (iomodel->Data("md.friction.coefficient")){
    399                                                 for(j=0;j<NUMVERTICES;j++)nodeinputs[j]=iomodel->Data("md.friction.coefficient")[tetra_vertex_ids[j]-1];
    400                                                 for(j=0;j<NUMVERTICES;j++)cmmininputs[j]=iomodel->Data("md.inversion.min_parameters")[(tetra_vertex_ids[j]-1)*num_control_type+i];
    401                                                 for(j=0;j<NUMVERTICES;j++)cmmaxinputs[j]=iomodel->Data("md.inversion.max_parameters")[(tetra_vertex_ids[j]-1)*num_control_type+i];
    402                                                 this->inputs->AddInput(new ControlInput(FrictionCoefficientEnum,TetraInputEnum,nodeinputs,cmmininputs,cmmaxinputs,P1Enum,i+1));
    403                                         }
    404                                         break;
    405                                 case MaterialsRheologyBbarEnum:
    406                                         if(iomodel->Data("md.materials.rheology_B")){
    407                                                 for(j=0;j<NUMVERTICES;j++) nodeinputs[j]=iomodel->Data("md.materials.rheology_B")[tetra_vertex_ids[j]-1];
    408                                                 for(j=0;j<NUMVERTICES;j++)cmmininputs[j]=iomodel->Data("md.inversion.min_parameters")[(tetra_vertex_ids[j]-1)*num_control_type+i];
    409                                                 for(j=0;j<NUMVERTICES;j++)cmmaxinputs[j]=iomodel->Data("md.inversion.max_parameters")[(tetra_vertex_ids[j]-1)*num_control_type+i];
    410                                                 this->inputs->AddInput(new ControlInput(MaterialsRheologyBEnum,TetraInputEnum,nodeinputs,cmmininputs,cmmaxinputs,P1Enum,i+1));
    411                                         }
    412                                         break;
    413                                 case DamageDbarEnum:
    414                                         if(iomodel->Data("md.damage.D")){
    415                                                 for(j=0;j<NUMVERTICES;j++) nodeinputs[j]=iomodel->Data("md.damage.D")[tetra_vertex_ids[j]-1];
    416                                                 for(j=0;j<NUMVERTICES;j++)cmmininputs[j]=iomodel->Data("md.inversion.min_parameters")[(tetra_vertex_ids[j]-1)*num_control_type+i];
    417                                                 for(j=0;j<NUMVERTICES;j++)cmmaxinputs[j]=iomodel->Data("md.inversion.max_parameters")[(tetra_vertex_ids[j]-1)*num_control_type+i];
    418                                                 this->inputs->AddInput(new ControlInput(DamageDEnum,TetraInputEnum,nodeinputs,cmmininputs,cmmaxinputs,P1Enum,i+1));
    419                                         }
    420                                         break;
    421                                 default:
    422                                         _error_("Control " << EnumToStringx(control) << " not implemented yet");
    423                         }
    424                 }
    425                 for(i=0;i<num_control_type;i++) xDelete<char>(controls[i]);
    426                 xDelete<char*>(controls);
    427         }
    428 
    429         /*Need to know the type of approximation for this element*/
    430         if(iomodel->Data("md.flowequation.element_equation")){
    431                 this->inputs->AddInput(new IntInput(ApproximationEnum,IoCodeToEnumElementEquation(reCast<int>(iomodel->Data("md.flowequation.element_equation")[index]))));
    432         }
    433 
    434         /*DatasetInputs*/
    435         if (control_analysis && iomodel->Data("md.inversion.cost_functions_coefficients")) {
    436 
    437                 /*Generate cost functions associated with the iomodel*/
    438                 char**  cost_functions                  = NULL;
    439                 int*            cost_functions_enums = NULL;
    440                 int             num_cost_functions;
    441 
    442                 iomodel->FindConstant(&num_cost_functions,"md.inversion.num_cost_functions");
    443                 iomodel->FindConstant(&cost_functions,&num_cost_functions,"md.inversion.cost_functions");
    444                 if(num_cost_functions<1) _error_("No cost functions found");
    445                 cost_functions_enums=xNew<int>(num_cost_functions);
    446                 for(j=0;j<num_cost_functions;j++){ cost_functions_enums[j]=StringToEnumx(cost_functions[j]); }
    447 
    448                 /*Create inputs and add to DataSetInput*/
    449                 DatasetInput* datasetinput=new DatasetInput(InversionCostFunctionsCoefficientsEnum);
    450                 for(i=0;i<num_responses;i++){
    451                         for(j=0;j<NUMVERTICES;j++)nodeinputs[j]=iomodel->Data("md.inversion.cost_functions_coefficients")[(tetra_vertex_ids[j]-1)*num_responses+i];
    452                         datasetinput->AddInput(new TetraInput(InversionCostFunctionsCoefficientsEnum,nodeinputs,P1Enum),cost_functions_enums[i]);
    453                 }
    454 
    455                 /*Add datasetinput to element inputs*/
    456                 this->inputs->AddInput(datasetinput);
    457 
    458                 /*Clean up cost functions*/
    459                 xDelete<int>(cost_functions_enums);
    460                 for(int j=0;j<num_cost_functions;j++) xDelete<char>(cost_functions[j]);
    461                 xDelete<char*>(cost_functions);
    462         }
    463397}
    464398/*}}}*/
    … …  
    504438        return false;
    505439}/*}}}*/
    506 bool     Tetra::IsOnBase(){/*{{{*/
    507         return HasFaceOnBase();
    508 }
    509 /*}}}*/
    510 bool     Tetra::IsOnSurface(){/*{{{*/
    511         return HasFaceOnSurface();
    512 }
    513 /*}}}*/
    514440void     Tetra::JacobianDeterminant(IssmDouble* pJdet,IssmDouble* xyz_list,Gauss* gauss){/*{{{*/
    515441
    … …  
    744670        //printf("element number %i \n",this->id);
    745671        /*Get inputs*/
    746         Input* slopex_input=inputs->GetInput(BedSlopeXEnum); _assert_(slopex_input);
    747         Input* slopey_input=inputs->GetInput(BedSlopeYEnum); _assert_(slopey_input);
    748         Input* groundedicelevelset_input=inputs->GetInput(MaskGroundediceLevelsetEnum); _assert_(groundedicelevelset_input);
     672        Input2* slopex_input=this->GetInput2(BedSlopeXEnum); _assert_(slopex_input);
     673        Input2* slopey_input=this->GetInput2(BedSlopeYEnum); _assert_(slopey_input);
     674        Input2* groundedicelevelset_input=this->GetInput2(MaskGroundediceLevelsetEnum); _assert_(groundedicelevelset_input);
    749675        vertexonbase = xNew<IssmDouble>(numnodes);
    750676        this->GetInputListOnNodesVelocity(&vertexonbase[0],MeshVertexonbaseEnum);
    … …  
    864790}
    865791/*}}}*/
    866 void     Tetra::Update(int index,IoModel* iomodel,int analysis_counter,int analysis_type,int finiteelement_type){ /*{{{*/
     792void     Tetra::Update(Inputs2* inputs2,int index,IoModel* iomodel,int analysis_counter,int analysis_type,int finiteelement_type){ /*{{{*/
    867793
    868794        /*Intermediaries*/
    … …  
    992918}
    993919/*}}}*/
    994 void     Tetra::ViscousHeating(IssmDouble* pphi,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input){/*{{{*/
     920void     Tetra::ViscousHeating(IssmDouble* pphi,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input,Input2* vz_input){/*{{{*/
    995921
    996922        /*Intermediaries*/

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

    r24208 r24335  
    3131                /*Tetra constructors, destructors {{{*/
    3232                Tetra(){};
    33                 Tetra(int tet_id,int tet_sid,IoModel* iomodel,int nummodels);
     33                Tetra(int tet_id,int tet_sid,int tet_lid,IoModel* iomodel,int nummodels);
    3434                ~Tetra();
    3535                /*}}}*/
    … …  
    4949                void        ComputeDeviatoricStressTensor(){_error_("not implemented yet");};
    5050                void        ComputeEsaStrainAndVorticity(){_error_("not implemented yet!");};
    51                 void        Configure(Elements* elements,Loads* loads,Nodes* nodesin,Vertices* verticesin,Materials* materials,Parameters* parameters);
     51                void        Configure(Elements* elements,Loads* loads,Nodes* nodesin,Vertices* verticesin,Materials* materials,Parameters* parameters,Inputs2* inputs2in);
    5252                void        ControlInputSetGradient(IssmDouble* gradient,int enum_type,int control_index,int offset,int N,int M){_error_("not implemented yet");};
    5353                void        ControlInputSetGradient(IssmDouble* gradient,int enum_type,int control_index){_error_("not implemented yet");};
    … …  
    6262                IssmDouble  FloatingArea(bool scaled){_error_("not implemented yet");};
    6363                void        FSContactMigration(Vector<IssmDouble>* vertexgrounded,Vector<IssmDouble>* vertexfloating){_error_("not implemented yet");};
    64                 IssmDouble     GetArea3D(void){_error_("not implemented yet!");};
    65                 IssmDouble     GetAreaSpherical(void){_error_("not implemented yet!");};
     64                IssmDouble  GetArea3D(void){_error_("not implemented yet!");};
     65                IssmDouble  GetAreaSpherical(void){_error_("not implemented yet!");};
    6666                Element*    GetBasalElement(void){_error_("not implemented yet");};
    6767                int         GetElementType(void);
    … …  
    6969                IssmDouble  GetGroundedPortion(IssmDouble* xyz_list){_error_("not implemented yet");};
    7070                void               GetIcefrontCoordinates(IssmDouble** pxyz_front,IssmDouble* xyz_list,int levelsetenum){_error_("not implemented yet");};
     71                Input2*     GetInput2(int enumtype);
     72                Input2*     GetInput2(int enumtype,IssmDouble time);
    7173                void        GetInputValue(IssmDouble* pvalue,Node* node,int enumtype);
    7274                void               GetLevelCoordinates(IssmDouble** pxyz_front,IssmDouble* xyz_list,int levelsetenum,IssmDouble level){_error_("not implemented yet");};
    … …  
    8890                bool               IsIcefront(void);
    8991                bool        IsNodeOnShelfFromFlags(IssmDouble* flags){_error_("not implemented yet");};
    90                 bool        IsOnBase();
    91                 bool        IsOnSurface();
    9292                bool        IsZeroLevelset(int levelset_enum){_error_("not implemented");};
    9393                void        InputDepthAverageAtBase(int enum_type,int average_enum_type){_error_("not implemented yet");};
    … …  
    157157                IssmDouble  TotalGroundedBmb(bool scaled){_error_("not implemented yet");};
    158158                IssmDouble  TotalSmb(bool scaled){_error_("not implemented yet");};
    159                 void        Update(int index, IoModel* iomodel,int analysis_counter,int analysis_type,int finitelement);
     159                void        Update(Inputs2* inputs2,int index, IoModel* iomodel,int analysis_counter,int analysis_type,int finitelement);
    160160                void        UpdateConstraintsExtrudeFromBase(){_error_("not implemented");};
    161161                void        UpdateConstraintsExtrudeFromTop(){_error_("not implemented");};
    … …  
    167167                void        VerticalSegmentIndices(int** pindices,int* pnumseg){_error_("not implemented yet");};
    168168                void        VerticalSegmentIndicesBase(int** pindices,int* pnumseg){_error_("not implemented yet");};
    169                 void        ViscousHeating(IssmDouble* pphi,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input);
     169                void        ViscousHeating(IssmDouble* pphi,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input,Input2* vz_input);
    170170
    171171#ifdef _HAVE_GIAIVINS_

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

    r24240 r24335  
    1414#include <math.h>
    1515#include "../classes.h"
     16#include "../Inputs2/TriaInput2.h"
     17#include "../Inputs2/PentaInput2.h"
     18#include "../Inputs2/ControlInput2.h"
     19#include "../Inputs2/DatasetInput2.h"
     20#include "../Inputs2/TransientInput2.h"
    1621#include "../../shared/shared.h"
    1722#ifdef _HAVE_GIAIVINS_
    … …  
    2530
    2631/*Constructors/destructor/copy*/
    27 Tria::Tria(int tria_id, int tria_sid, IoModel* iomodel,int nummodels)/*{{{*/
     32Tria::Tria(int tria_id,int tria_sid,int tria_lid,IoModel* iomodel,int nummodels)/*{{{*/
    2833        :ElementHook(nummodels,tria_id,NUMVERTICES,iomodel){
     34
     35                this->iscollapsed = 0;
    2936
    3037                /*id: */
    3138                this->id  = tria_id;
    3239                this->sid = tria_sid;
    33 
    34                 //this->parameters: we still can't point to it, it may not even exist. Configure will handle this.
     40                this->lid = tria_lid;
     41
     42                /*this->parameters: we still can't point to it, it may not even exist. Configure will handle this.*/
    3543                this->parameters = NULL;
    3644
    … …  
    4856                else this->element_type_list = NULL;
    4957
    50 }
    51 /*}}}*/
     58                /*surface and base*/
     59                IssmDouble sum;
     60                this->isonsurface = false;
     61                this->isonbase    = false;
     62                switch(iomodel->domaintype){
     63                        case Domain2DverticalEnum:
     64                                _assert_(iomodel->Data("md.mesh.vertexonsurface"));
     65                                _assert_(iomodel->Data("md.mesh.vertexonbase"));
     66                                sum = 0.;
     67                                for(int i=0;i<NUMVERTICES;i++) sum += iomodel->Data("md.mesh.vertexonsurface")[reCast<int>(iomodel->elements[(tria_id-1)*NUMVERTICES+i])-1];
     68                                _assert_(sum>=0 && sum<3);
     69                                if(sum>1.) this->isonsurface = true;
     70                                sum = 0.;
     71                                for(int i=0;i<NUMVERTICES;i++) sum += iomodel->Data("md.mesh.vertexonbase")[reCast<int>(iomodel->elements[(tria_id-1)*NUMVERTICES+i])-1];
     72                                _assert_(sum>=0 && sum<3);
     73                                if(sum>1.) this->isonbase = true;
     74                                break;
     75                        case Domain2DhorizontalEnum:
     76                                this->isonsurface = true;
     77                                this->isonbase    = true;
     78                                break;
     79                        default: _error_("mesh "<<EnumToStringx(iomodel->domaintype)<<" not supported yet");
     80                }
     81
     82}/*}}}*/
    5283Tria::~Tria(){/*{{{*/
    5384        this->parameters=NULL;
    … …  
    6091
    6192        tria=new Tria();
     93
     94        tria->iscollapsed=this->iscollapsed;
    6295
    6396        //deal with TriaRef mother class
    … …  
    91124        tria->id  = this->id;
    92125        tria->sid = this->sid;
     126        tria->lid = this->lid;
    93127        if(this->inputs) tria->inputs = (Inputs*)(this->inputs->Copy());
    94128        else tria->inputs=new Inputs();
     129        tria->isonbase  = this->isonbase;
     130        tria->isonsurface  = this->isonsurface;
    95131
    96132        /*point parameters: */
    … …  
    114150
    115151        MARSHALLING_ENUM(TriaEnum);
     152        MARSHALLING(this->iscollapsed);
     153        MARSHALLING(this->isonsurface);
     154        MARSHALLING(this->isonbase);
    116155
    117156        /*Call parent classes: */
    … …  
    127166
    128167/*Other*/
     168void       Tria::AddBasalInput2(int input_enum,IssmDouble* values, int interpolation_enum){/*{{{*/
     169
     170        /*Call inputs method*/
     171        _assert_(this->inputs2);
     172
     173        int domaintype;
     174        parameters->FindParam(&domaintype,DomainTypeEnum);
     175        switch(domaintype){
     176                case Domain2DhorizontalEnum:
     177                        this->AddInput2(input_enum,values,interpolation_enum);
     178                        break;
     179                case Domain2DverticalEnum:{
     180                        _error_("not implemented yet");
     181                                                                                  }
     182                        break;
     183                default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
     184        }
     185
     186}
     187/*}}}*/
     188void       Tria::AddInput2(int input_enum,IssmDouble* values, int interpolation_enum){/*{{{*/
     189
     190        /*Intermediaries*/
     191        int vertexlids[NUMVERTICES];
     192
     193        /*Call inputs method*/
     194        if(!this->inputs2){
     195                int* temp = xNew<int>(3);
     196        }
     197        _assert_(this->inputs2);
     198        switch(interpolation_enum){
     199                case P1Enum:
     200                        for(int i=0;i<NUMVERTICES;i++) vertexlids[i]=this->vertices[i]->lid;
     201                        inputs2->SetTriaInput(input_enum,interpolation_enum,NUMVERTICES,vertexlids,values);
     202                        break;
     203                case P1DGEnum:
     204                        for(int i=0;i<NUMVERTICES;i++) vertexlids[i]=this->vertices[i]->lid;
     205                        inputs2->SetTriaInput(input_enum,interpolation_enum,this->lid,NUMVERTICES,values);
     206                        break;
     207                default:
     208                        inputs2->SetTriaInput(input_enum,interpolation_enum,this->lid,this->GetNumberOfNodes(interpolation_enum),values);
     209        }
     210
     211}
     212/*}}}*/
    129213void       Tria::AddBasalInput(int input_enum,IssmDouble* values, int interpolation_enum){/*{{{*/
    130214
    … …  
    166250}
    167251/*}}}*/
    168 void       Tria::AddControlInput(int input_enum,IssmDouble* values,IssmDouble* values_min,IssmDouble* values_max, int interpolation_enum,int id){/*{{{*/
     252void       Tria::AddControlInput(int input_enum,Inputs2* inputs2,IoModel* iomodel,IssmDouble* values,IssmDouble* values_min,IssmDouble* values_max, int interpolation_enum,int id){/*{{{*/
     253
     254        /*Intermediaries*/
     255        int vertexlids[NUMVERTICES];
     256
     257        _assert_(iomodel->elements);
     258        for(int i=0;i<NUMVERTICES;i++){
     259                int vertexid =reCast<int>(iomodel->elements[NUMVERTICES*this->Sid()+i]); //ids for vertices are in the elements array from Matlab
     260                vertexlids[i]=iomodel->my_vertices_lids[vertexid-1];
     261        }
    169262
    170263        /*Call inputs method*/
    171         _assert_(this->inputs);
    172         this->inputs->AddInput(new ControlInput(input_enum,TriaInputEnum,values,values_min,values_max,interpolation_enum,id));
    173 }
    174 /*}}}*/
    175 void       Tria::DatasetInputCreate(IssmDouble* array,int M,int N,int* individual_enums,int num_inputs,IoModel* iomodel,int input_enum){/*{{{*/
     264        switch(interpolation_enum){
     265                case P1Enum:
     266                        inputs2->SetTriaControlInput(input_enum,TriaInput2Enum,interpolation_enum,id,NUMVERTICES,vertexlids,values,values_min,values_max);
     267                        break;
     268                default:
     269                        _error_("Cannot add \""<<EnumToStringx(input_enum)<<"\" interpolation "<<EnumToStringx(interpolation_enum)<<" not supported");
     270        }
     271
     272}
     273/*}}}*/
     274void       Tria::DatasetInputCreate(IssmDouble* array,int M,int N,int* individual_enums,int num_inputs,Inputs2* inputs2,IoModel* iomodel,int input_enum){/*{{{*/
    176275
    177276        IssmDouble nodeinputs[NUMVERTICES];
    … …  
    179278        if(M!=iomodel->numberofvertices) _error_("not supported yet");
    180279        if(N!=num_inputs) _error_("sizes are not consistent");
     280       
    181281
    182282        int        tria_vertex_ids[3];
    … …  
    251351
    252352        /*Retrieve all inputs and parameters we will need*/
    253         Input* vx_input = inputs->GetInput(VxEnum); _assert_(vx_input);
    254         Input* vy_input = inputs->GetInput(VyEnum); _assert_(vy_input);
    255         Input* B_input  = inputs->GetInput(MaterialsRheologyBbarEnum);   _assert_(B_input);
    256         Input* gr_input = inputs->GetInput(MaskGroundediceLevelsetEnum); _assert_(gr_input);
    257         Input* bs_input = inputs->GetInput(BaseEnum);                    _assert_(bs_input);
    258         Input* smax_fl_input = inputs->GetInput(CalvingStressThresholdFloatingiceEnum); _assert_(smax_fl_input);
    259         Input* smax_gr_input = inputs->GetInput(CalvingStressThresholdGroundediceEnum); _assert_(smax_gr_input);
    260         Input* n_input  = inputs->GetInput(MaterialsRheologyNEnum); _assert_(n_input);
    261         Input* sl_input  = inputs->GetInput(SealevelEnum); _assert_(sl_input);
     353        Input2* vx_input = this->GetInput2(VxEnum); _assert_(vx_input);
     354        Input2* vy_input = this->GetInput2(VyEnum); _assert_(vy_input);
     355        Input2* B_input  = this->GetInput2(MaterialsRheologyBbarEnum);   _assert_(B_input);
     356        Input2* gr_input = this->GetInput2(MaskGroundediceLevelsetEnum); _assert_(gr_input);
     357        Input2* bs_input = this->GetInput2(BaseEnum);                    _assert_(bs_input);
     358        Input2* smax_fl_input = this->GetInput2(CalvingStressThresholdFloatingiceEnum); _assert_(smax_fl_input);
     359        Input2* smax_gr_input = this->GetInput2(CalvingStressThresholdGroundediceEnum); _assert_(smax_gr_input);
     360        Input2* n_input  = this->GetInput2(MaterialsRheologyNEnum); _assert_(n_input);
     361        Input2* sl_input  = this->GetInput2(SealevelEnum); _assert_(sl_input);
    262362
    263363
    … …  
    320420
    321421        /*Add input*/
    322         this->inputs->AddInput(new TriaInput(CalvingratexEnum,&calvingratex[0],P1Enum));
    323         this->inputs->AddInput(new TriaInput(CalvingrateyEnum,&calvingratey[0],P1Enum));
    324         this->inputs->AddInput(new TriaInput(CalvingCalvingrateEnum,&calvingrate[0],P1Enum));
    325         this->inputs->AddInput(new TriaInput(SigmaVMEnum,&sigma_vm[0],P1Enum));
     422        this->AddInput2(CalvingratexEnum,&calvingratex[0],P1DGEnum);
     423        this->AddInput2(CalvingrateyEnum,&calvingratey[0],P1DGEnum);
     424        this->AddInput2(CalvingCalvingrateEnum,&calvingrate[0],P1DGEnum);
     425        this->AddInput2(SigmaVMEnum,&sigma_vm[0],P1DGEnum);
    326426
    327427        /*Clean up and return*/
    … …  
    351451        IssmDouble constant_g     = this->FindParam(ConstantsGEnum);
    352452
    353         Input*   H_input                 = inputs->GetInput(ThicknessEnum); _assert_(H_input);
    354         Input*   bed_input               = inputs->GetInput(BedEnum); _assert_(bed_input);
    355         Input*   surface_input           = inputs->GetInput(SurfaceEnum); _assert_(surface_input);
    356         Input*  strainrateparallel_input  = inputs->GetInput(StrainRateparallelEnum);  _assert_(strainrateparallel_input);
    357         Input*  strainrateeffective_input = inputs->GetInput(StrainRateeffectiveEnum); _assert_(strainrateeffective_input);
    358         Input*  vx_input                  = inputs->GetInput(VxEnum); _assert_(vx_input);
    359         Input*  vy_input                  = inputs->GetInput(VxEnum); _assert_(vy_input);
    360         Input*   waterheight_input       = inputs->GetInput(WaterheightEnum); _assert_(waterheight_input);
    361         Input*   s_xx_input              = inputs->GetInput(DeviatoricStressxxEnum);     _assert_(s_xx_input);
    362         Input*   s_xy_input              = inputs->GetInput(DeviatoricStressxyEnum);     _assert_(s_xy_input);
    363         Input*   s_yy_input              = inputs->GetInput(DeviatoricStressyyEnum);     _assert_(s_yy_input);
    364         Input*  B_input  = inputs->GetInput(MaterialsRheologyBbarEnum);   _assert_(B_input);
    365         Input*  n_input  = inputs->GetInput(MaterialsRheologyNEnum);   _assert_(n_input);
     453        Input2*   H_input                 = this->GetInput2(ThicknessEnum); _assert_(H_input);
     454        Input2*   bed_input               = this->GetInput2(BedEnum); _assert_(bed_input);
     455        Input2*   surface_input           = this->GetInput2(SurfaceEnum); _assert_(surface_input);
     456        Input2* strainrateparallel_input  = this->GetInput2(StrainRateparallelEnum);  _assert_(strainrateparallel_input);
     457        Input2* strainrateeffective_input = this->GetInput2(StrainRateeffectiveEnum); _assert_(strainrateeffective_input);
     458        Input2* vx_input                  = this->GetInput2(VxEnum); _assert_(vx_input);
     459        Input2* vy_input                  = this->GetInput2(VxEnum); _assert_(vy_input);
     460        Input2*   waterheight_input       = this->GetInput2(WaterheightEnum); _assert_(waterheight_input);
     461        Input2*   s_xx_input              = this->GetInput2(DeviatoricStressxxEnum);     _assert_(s_xx_input);
     462        Input2*   s_xy_input              = this->GetInput2(DeviatoricStressxyEnum);     _assert_(s_xy_input);
     463        Input2*   s_yy_input              = this->GetInput2(DeviatoricStressyyEnum);     _assert_(s_yy_input);
     464        Input2* B_input  = this->GetInput2(MaterialsRheologyBbarEnum);   _assert_(B_input);
     465        Input2* n_input  = this->GetInput2(MaterialsRheologyNEnum);   _assert_(n_input);
    366466
    367467        /*Loop over all elements of this partition*/
    … …  
    420520        }
    421521
    422         this->inputs->AddInput(new TriaInput(SurfaceCrevasseEnum,&surface_crevasse[0],P1Enum));
    423         this->inputs->AddInput(new TriaInput(BasalCrevasseEnum,&basal_crevasse[0],P1Enum));
    424         this->inputs->AddInput(new TriaInput(CrevasseDepthEnum,&crevasse_depth[0],P1Enum));
     522        this->AddInput2(SurfaceCrevasseEnum,&surface_crevasse[0],P1DGEnum);
     523        this->AddInput2(BasalCrevasseEnum,&basal_crevasse[0],P1DGEnum);
     524        this->AddInput2(CrevasseDepthEnum,&crevasse_depth[0],P1DGEnum);
    425525
    426526        delete gauss;
    … …  
    442542
    443543        /*Retrieve all inputs and parameters we will need*/
    444         Input* vx_input=inputs->GetInput(VxEnum);                                                                                                       _assert_(vx_input);
    445         Input* vy_input=inputs->GetInput(VyEnum);                                                                                                       _assert_(vy_input);
    446         Input* bs_input = inputs->GetInput(BaseEnum);                                 _assert_(bs_input);
    447         Input* strainparallel_input=inputs->GetInput(StrainRateparallelEnum);                   _assert_(strainparallel_input);
    448         Input* strainperpendicular_input=inputs->GetInput(StrainRateperpendicularEnum);_assert_(strainperpendicular_input);
    449         Input* levermanncoeff_input=inputs->GetInput(CalvinglevermannCoeffEnum);      _assert_(levermanncoeff_input);
     544        Input2* vx_input=this->GetInput2(VxEnum);                                                                                                       _assert_(vx_input);
     545        Input2* vy_input=this->GetInput2(VyEnum);                                                                                                       _assert_(vy_input);
     546        Input2* bs_input = this->GetInput2(BaseEnum);                                 _assert_(bs_input);
     547        Input2* strainparallel_input=this->GetInput2(StrainRateparallelEnum);                   _assert_(strainparallel_input);
     548        Input2* strainperpendicular_input=this->GetInput2(StrainRateperpendicularEnum);_assert_(strainperpendicular_input);
     549        Input2* levermanncoeff_input=this->GetInput2(CalvinglevermannCoeffEnum);      _assert_(levermanncoeff_input);
    450550
    451551        /* Start looping on the number of vertices: */
    … …  
    475575
    476576        /*Add input*/
    477         this->inputs->AddInput(new TriaInput(CalvingratexEnum,&calvingratex[0],P1Enum));
    478         this->inputs->AddInput(new TriaInput(CalvingrateyEnum,&calvingratey[0],P1Enum));
    479         this->inputs->AddInput(new TriaInput(CalvingCalvingrateEnum,&calvingrate[0],P1Enum));
     577        this->AddInput2(CalvingratexEnum,&calvingratex[0],P1DGEnum);
     578        this->AddInput2(CalvingrateyEnum,&calvingratey[0],P1DGEnum);
     579        this->AddInput2(CalvingCalvingrateEnum,&calvingrate[0],P1DGEnum);
    480580
    481581        /*Clean up and return*/
    … …  
    489589        if(!IsIceInElement() || !IsZeroLevelset(MaskIceLevelsetEnum)){
    490590                IssmDouble flux_per_area=0;
    491                 this->inputs->AddInput(new TriaInput(CalvingFluxLevelsetEnum,&flux_per_area,P0Enum));
     591                this->AddInput2(CalvingFluxLevelsetEnum,&flux_per_area,P0Enum);
    492592        }
    493593        else{
    … …  
    585685                IssmDouble calvingratex,calvingratey,thickness,Jdet,flux_per_area;
    586686                IssmDouble rho_ice=FindParam(MaterialsRhoIceEnum);
    587                 Input* thickness_input=inputs->GetInput(ThicknessEnum); _assert_(thickness_input);
    588                 Input* calvingratex_input=NULL;
    589                 Input* calvingratey_input=NULL;
     687                Input2* thickness_input=this->GetInput2(ThicknessEnum); _assert_(thickness_input);
     688                Input2* calvingratex_input=NULL;
     689                Input2* calvingratey_input=NULL;
    590690                if(domaintype==Domain2DhorizontalEnum){
    591                         calvingratex_input=inputs->GetInput(CalvingratexEnum); _assert_(calvingratex_input);
    592                         calvingratey_input=inputs->GetInput(CalvingrateyEnum); _assert_(calvingratey_input);
     691                        calvingratex_input=this->GetInput2(CalvingratexEnum); _assert_(calvingratex_input);
     692                        calvingratey_input=this->GetInput2(CalvingrateyEnum); _assert_(calvingratey_input);
    593693                }
    594694                else{
    595                         calvingratex_input=inputs->GetInput(CalvingratexAverageEnum); _assert_(calvingratex_input);
    596                         calvingratey_input=inputs->GetInput(CalvingrateyAverageEnum); _assert_(calvingratey_input);
     695                        calvingratex_input=this->GetInput2(CalvingratexAverageEnum); _assert_(calvingratex_input);
     696                        calvingratey_input=this->GetInput2(CalvingrateyAverageEnum); _assert_(calvingratey_input);
    597697                }
    598698
    … …  
    613713                }
    614714
    615                 this->inputs->AddInput(new TriaInput(CalvingFluxLevelsetEnum,&flux_per_area,P0Enum));
     715                this->AddInput2(CalvingFluxLevelsetEnum,&flux_per_area,P0Enum);
    616716
    617717                /*Clean up and return*/
    … …  
    625725        if(!IsIceInElement() || !IsZeroLevelset(MaskIceLevelsetEnum)){
    626726                IssmDouble flux_per_area=0;
    627                 this->inputs->AddInput(new TriaInput(CalvingMeltingFluxLevelsetEnum,&flux_per_area,P0Enum));
     727                this->AddInput2(CalvingMeltingFluxLevelsetEnum,&flux_per_area,P0Enum);
    628728        }
    629729        else{
    … …  
    722822                IssmDouble calvingratex,calvingratey,vx,vy,vel,meltingrate,meltingratex,meltingratey,thickness,Jdet,flux_per_area;
    723823                IssmDouble rho_ice=FindParam(MaterialsRhoIceEnum);
    724                 Input* thickness_input=inputs->GetInput(ThicknessEnum); _assert_(thickness_input);
    725                 Input* calvingratex_input=NULL;
    726                 Input* calvingratey_input=NULL;
    727                 Input* vx_input=NULL;
    728                 Input* vy_input=NULL;
    729                 Input* meltingrate_input=NULL;
     824                Input2* thickness_input=this->GetInput2(ThicknessEnum); _assert_(thickness_input);
     825                Input2* calvingratex_input=NULL;
     826                Input2* calvingratey_input=NULL;
     827                Input2* vx_input=NULL;
     828                Input2* vy_input=NULL;
     829                Input2* meltingrate_input=NULL;
    730830                if(domaintype==Domain2DhorizontalEnum){
    731                         calvingratex_input=inputs->GetInput(CalvingratexEnum); _assert_(calvingratex_input);
    732                         calvingratey_input=inputs->GetInput(CalvingrateyEnum); _assert_(calvingratey_input);
    733                         vx_input=inputs->GetInput(VxEnum); _assert_(vx_input);
    734                         vy_input=inputs->GetInput(VyEnum); _assert_(vy_input);
    735                         meltingrate_input=inputs->GetInput(CalvingMeltingrateEnum); _assert_(meltingrate_input);
     831                        calvingratex_input=this->GetInput2(CalvingratexEnum); _assert_(calvingratex_input);
     832                        calvingratey_input=this->GetInput2(CalvingrateyEnum); _assert_(calvingratey_input);
     833                        vx_input=this->GetInput2(VxEnum); _assert_(vx_input);
     834                        vy_input=this->GetInput2(VyEnum); _assert_(vy_input);
     835                        meltingrate_input=this->GetInput2(CalvingMeltingrateEnum); _assert_(meltingrate_input);
    736836                }
    737837                else{
    738                         calvingratex_input=inputs->GetInput(CalvingratexAverageEnum); _assert_(calvingratex_input);
    739                         calvingratey_input=inputs->GetInput(CalvingrateyAverageEnum); _assert_(calvingratey_input);
     838                        calvingratex_input=this->GetInput2(CalvingratexAverageEnum); _assert_(calvingratex_input);
     839                        calvingratey_input=this->GetInput2(CalvingrateyAverageEnum); _assert_(calvingratey_input);
    740840                }
    741841
    … …  
    762862                }
    763863
    764                 this->inputs->AddInput(new TriaInput(CalvingMeltingFluxLevelsetEnum,&flux_per_area,P0Enum));
     864                this->AddInput2(CalvingMeltingFluxLevelsetEnum,&flux_per_area,P0Enum);
    765865
    766866                /*Clean up and return*/
    … …  
    797897        /*Get approximation*/
    798898        int approximation;
    799         inputs->GetInputValue(&approximation,ApproximationEnum);
     899        this->GetInput2Value(&approximation,ApproximationEnum);
    800900
    801901        /* Get node coordinates and dof list: */
    … …  
    804904        /*Retrieve all inputs we will be needing: */
    805905        this->FindParam(&domaintype,DomainTypeEnum);
    806         Input* vx_input=inputs->GetInput(VxEnum);            _assert_(vx_input);
    807         Input* vy_input=inputs->GetInput(VyEnum);            _assert_(vy_input);
     906        Input2* vx_input=this->GetInput2(VxEnum); _assert_(vx_input);
     907        Input2* vy_input=this->GetInput2(VyEnum); _assert_(vy_input);
    808908
    809909        /* Start looping on the number of vertices: */
    … …  
    839939
    840940        /*Add Stress tensor components into inputs*/
    841         this->inputs->AddInput(new TriaInput(DeviatoricStressxxEnum,&tau_xx[0],P1Enum));
    842         this->inputs->AddInput(new TriaInput(DeviatoricStressxyEnum,&tau_xy[0],P1Enum));
    843         this->inputs->AddInput(new TriaInput(DeviatoricStressxzEnum,&tau_xz[0],P1Enum));
    844         this->inputs->AddInput(new TriaInput(DeviatoricStressyyEnum,&tau_yy[0],P1Enum));
    845         this->inputs->AddInput(new TriaInput(DeviatoricStressyzEnum,&tau_yz[0],P1Enum));
    846         this->inputs->AddInput(new TriaInput(DeviatoricStresszzEnum,&tau_zz[0],P1Enum));
    847         this->inputs->AddInput(new TriaInput(DeviatoricStresseffectiveEnum,&tau_e[0],P1Enum));
    848         this->inputs->AddInput(new TriaInput(DeviatoricStress1Enum,&tau_1[0],P1Enum));
    849         this->inputs->AddInput(new TriaInput(DeviatoricStress2Enum,&tau_2[0],P1Enum));
     941        this->AddInput2(DeviatoricStressxxEnum,&tau_xx[0],P1DGEnum);
     942        this->AddInput2(DeviatoricStressxyEnum,&tau_xy[0],P1DGEnum);
     943        this->AddInput2(DeviatoricStressxzEnum,&tau_xz[0],P1DGEnum);
     944        this->AddInput2(DeviatoricStressyyEnum,&tau_yy[0],P1DGEnum);
     945        this->AddInput2(DeviatoricStressyzEnum,&tau_yz[0],P1DGEnum);
     946        this->AddInput2(DeviatoricStresszzEnum,&tau_zz[0],P1DGEnum);
     947        this->AddInput2(DeviatoricStresseffectiveEnum,&tau_e[0],P1DGEnum);
     948        this->AddInput2(DeviatoricStress1Enum,&tau_1[0],P1DGEnum);
     949        this->AddInput2(DeviatoricStress2Enum,&tau_2[0],P1DGEnum);
    850950
    851951        /*Clean up and return*/
    … …  
    867967
    868968        /*Retrieve all inputs we will be needing: */
    869         Input* vx_input=this->GetInput(EsaXmotionEnum); _assert_(vx_input);
    870         Input* vy_input=this->GetInput(EsaYmotionEnum); _assert_(vy_input);
     969        Input2* vx_input=this->GetInput2(EsaXmotionEnum); _assert_(vx_input);
     970        Input2* vy_input=this->GetInput2(EsaYmotionEnum); _assert_(vy_input);
    871971
    872972        /* Start looping on the number of vertices: */
    … …  
    886986
    887987        /*Add Stress tensor components into inputs*/
    888         this->inputs->AddInput(new TriaInput(EsaStrainratexxEnum,&strain_xx[0],P1Enum));
    889         this->inputs->AddInput(new TriaInput(EsaStrainrateyyEnum,&strain_yy[0],P1Enum));
    890         this->inputs->AddInput(new TriaInput(EsaStrainratexyEnum,&strain_xy[0],P1Enum));
    891         this->inputs->AddInput(new TriaInput(EsaRotationrateEnum,&vorticity_xy[0],P1Enum));
     988        this->AddInput2(EsaStrainratexxEnum,&strain_xx[0],P1DGEnum);
     989        this->AddInput2(EsaStrainrateyyEnum,&strain_yy[0],P1DGEnum);
     990        this->AddInput2(EsaStrainratexyEnum,&strain_xy[0],P1DGEnum);
     991        this->AddInput2(EsaRotationrateEnum,&vorticity_xy[0],P1DGEnum);
    892992
    893993        /*Clean up and return*/
    … …  
    899999        if(!IsOnBase()){
    9001000                IssmDouble sigma_nn[3]={0.};
    901                 this->inputs->AddInput(new TriaInput(SigmaNNEnum,&sigma_nn[0],P1Enum));
     1001                this->AddInput2(SigmaNNEnum,&sigma_nn[0],P1Enum);
    9021002                return;
    9031003        }
    … …  
    9191019                this->FindParam(&domaintype,DomainTypeEnum);
    9201020                if(domaintype==Domain2DhorizontalEnum) _error_("stress tensor calculation not supported for mesh of type " <<EnumToStringx(domaintype)<<", extrude mesh or call ComputeDeviatoricStressTensor");
    921                 Input* pressure_input=inputs->GetInput(PressureEnum); _assert_(pressure_input);
    922                 Input* vx_input=inputs->GetInput(VxEnum);             _assert_(vx_input);
    923                 Input* vy_input=inputs->GetInput(VyEnum);             _assert_(vy_input);
     1021                Input2* pressure_input=this->GetInput2(PressureEnum); _assert_(pressure_input);
     1022                Input2* vx_input=this->GetInput2(VxEnum);             _assert_(vx_input);
     1023                Input2* vy_input=this->GetInput2(VyEnum);             _assert_(vy_input);
    9241024
    9251025                /* Start looping on the number of vertices: */
    … …  
    9461046
    9471047                /*Add Stress tensor components into inputs*/
    948                 this->inputs->AddInput(new TriaInput(SigmaNNEnum,&sigma_nn[0],P1Enum));
     1048                this->AddInput2(SigmaNNEnum,&sigma_nn[0],P1Enum);
    9491049
    9501050                /*Clean up and return*/
    … …  
    9751075        this->FindParam(&domaintype,DomainTypeEnum);
    9761076        if(domaintype==Domain2DhorizontalEnum) _error_("stress tensor calculation not supported for mesh of type " <<EnumToStringx(domaintype)<<", extrude mesh or call ComputeDeviatoricStressTensor");
    977         Input* pressure_input=inputs->GetInput(PressureEnum); _assert_(pressure_input);
    978         Input* vx_input=inputs->GetInput(VxEnum);             _assert_(vx_input);
    979         Input* vy_input=inputs->GetInput(VyEnum);             _assert_(vy_input);
     1077        Input2* pressure_input=this->GetInput2(PressureEnum); _assert_(pressure_input);
     1078        Input2* vx_input=this->GetInput2(VxEnum);             _assert_(vx_input);
     1079        Input2* vy_input=this->GetInput2(VyEnum);             _assert_(vy_input);
    9801080
    9811081        /* Start looping on the number of vertices: */
    … …  
    9961096
    9971097        /*Add Stress tensor components into inputs*/
    998         this->inputs->AddInput(new TriaInput(StressTensorxxEnum,&sigma_xx[0],P1Enum));
    999         this->inputs->AddInput(new TriaInput(StressTensorxyEnum,&sigma_xy[0],P1Enum));
    1000         this->inputs->AddInput(new TriaInput(StressTensorxzEnum,&sigma_xz[0],P1Enum));
    1001         this->inputs->AddInput(new TriaInput(StressTensoryyEnum,&sigma_yy[0],P1Enum));
    1002         this->inputs->AddInput(new TriaInput(StressTensoryzEnum,&sigma_yz[0],P1Enum));
    1003         this->inputs->AddInput(new TriaInput(StressTensorzzEnum,&sigma_zz[0],P1Enum));
     1098        this->AddInput2(StressTensorxxEnum,&sigma_xx[0],P1DGEnum);
     1099        this->AddInput2(StressTensorxyEnum,&sigma_xy[0],P1DGEnum);
     1100        this->AddInput2(StressTensorxzEnum,&sigma_xz[0],P1DGEnum);
     1101        this->AddInput2(StressTensoryyEnum,&sigma_yy[0],P1DGEnum);
     1102        this->AddInput2(StressTensoryzEnum,&sigma_yz[0],P1DGEnum);
     1103        this->AddInput2(StressTensorzzEnum,&sigma_zz[0],P1DGEnum);
    10041104
    10051105        /*Clean up and return*/
    … …  
    10071107}
    10081108/*}}}*/
    1009 void       Tria::Configure(Elements* elementsin, Loads* loadsin,Nodes* nodesin,Vertices *verticesin,Materials* materialsin, Parameters* parametersin){/*{{{*/
     1109void       Tria::Configure(Elements* elementsin, Loads* loadsin,Nodes* nodesin,Vertices *verticesin,Materials* materialsin, Parameters* parametersin,Inputs2* inputs2in){/*{{{*/
    10101110
    10111111        /*go into parameters and get the analysis_counter: */
    … …  
    10341134        /*point parameters to real dataset: */
    10351135        this->parameters=parametersin;
     1136        this->inputs2=inputs2in;
    10361137
    10371138        /*get inputs configured too: */
    10381139        this->inputs->Configure(this->parameters);
    10391140
    1040 }
    1041 /*}}}*/
     1141}/*}}}*/
    10421142void       Tria::ControlInputSetGradient(IssmDouble* gradient,int enum_type,int control_index,int offset,int N, int M){/*{{{*/
    10431143
    1044         int    idlist[NUMVERTICES];
    1045         int     gradidlist[NUMVERTICES];
    1046         IssmDouble grad_list[NUMVERTICES];
    1047         Input* grad_input=NULL;
    1048 
    1049         Input* input=inputs->GetInput(enum_type);
    1050         if (!input) _error_("Input " << EnumToStringx(enum_type) << " not found");
    1051         if (input->ObjectEnum()!=ControlInputEnum) _error_("Input " << EnumToStringx(enum_type) << " is not a ControlInput");
     1144        int         idlist[NUMVERTICES];
     1145        int         vertexlids[NUMVERTICES];
     1146        int         gradidlist[NUMVERTICES];
     1147        IssmDouble  grad_list[NUMVERTICES];
    10521148
    10531149        GradientIndexing(&gradidlist[0],control_index);
    1054 
    1055         for(int n=0;n<N;n++){
    1056                 for(int i=0;i<NUMVERTICES;i++){
    1057                         idlist[i] = offset + this->vertices[i]->Sid()+n*M;
    1058                         grad_list[i]=gradient[idlist[i]];
    1059                 }
    1060 
    1061                 ControlInput* controlinput = xDynamicCast<ControlInput*>(input);
    1062                 if(controlinput->layout_enum!=TransientInputEnum){
    1063                         grad_input=new TriaInput(GradientEnum,grad_list,P1Enum);
    1064                         controlinput->SetGradient(grad_input);
    1065                 }
    1066                 else{
    1067                         grad_input = new TriaInput(GradientEnum,grad_list,P1Enum);
    1068                         controlinput->SetGradient(grad_input,n);
    1069                         controlinput->Configure(parameters);
     1150        for(int i=0;i<NUMVERTICES;i++) vertexlids[i]=this->vertices[i]->lid;
     1151
     1152        if(N==1){
     1153                this->inputs2->SetTriaControlInputGradient(enum_type,P1Enum,NUMVERTICES,&vertexlids[0],&grad_list[0]);
     1154        }
     1155        else{
     1156                for(int n=0;n<N;n++){
     1157                        for(int i=0;i<NUMVERTICES;i++){
     1158                                idlist[i] = offset + this->vertices[i]->Sid()+n*M;
     1159                                grad_list[i]=gradient[idlist[i]];
     1160                        }
     1161                        this->inputs2->SetTriaControlInputGradient(enum_type,P1Enum,NUMVERTICES,&vertexlids[0],&grad_list[0],n);
    10701162                }
    10711163        }
    … …  
    10741166void       Tria::ControlInputSetGradient(IssmDouble* gradient,int enum_type,int control_index){/*{{{*/
    10751167
    1076         int    vertexpidlist[NUMVERTICES];
     1168        int        idlist[NUMVERTICES];
     1169        int        vertexlids[NUMVERTICES];
    10771170        IssmDouble grad_list[NUMVERTICES];
    1078         Input* grad_input=NULL;
    1079 
    1080         Input* input=inputs->GetInput(enum_type);
    1081         if (!input) _error_("Input " << EnumToStringx(enum_type) << " not found");
    1082         if (input->ObjectEnum()!=ControlInputEnum) _error_("Input " << EnumToStringx(enum_type) << " is not a ControlInput");
    1083 
    1084         GradientIndexing(&vertexpidlist[0],control_index);
    1085         for(int i=0;i<NUMVERTICES;i++) grad_list[i]=gradient[vertexpidlist[i]];
    1086         grad_input=new TriaInput(GradientEnum,grad_list,P1Enum);
    1087 
    1088         ((ControlInput*)input)->SetGradient(grad_input);
     1171
     1172        GradientIndexing(&idlist[0],control_index);
     1173        for(int i=0;i<NUMVERTICES;i++) grad_list[i]=gradient[idlist[i]];
     1174        for(int i=0;i<NUMVERTICES;i++) vertexlids[i]=this->vertices[i]->lid;
     1175
     1176        this->inputs2->SetTriaControlInputGradient(enum_type,P1Enum,NUMVERTICES,&vertexlids[0],&grad_list[0]);
    10891177
    10901178}/*}}}*/
    10911179void       Tria::ControlToVectors(Vector<IssmPDouble>* vector_control, Vector<IssmPDouble>* vector_gradient,int control_enum){/*{{{*/
    10921180
    1093         Input* input=inputs->GetInput(control_enum);
    1094         if (!input) _error_("Input " << EnumToStringx(control_enum) << " not found");
    1095         if (input->ObjectEnum()!=ControlInputEnum) _error_("Input " << EnumToStringx(control_enum) << " is not a ControlInput");
    1096 
    10971181        int         sidlist[NUMVERTICES];
     1182        int         lidlist[NUMVERTICES];
    10981183        int         connectivity[NUMVERTICES];
    10991184        IssmPDouble values[NUMVERTICES];
    … …  
    11031188        this->GetVerticesConnectivityList(&connectivity[0]);
    11041189        this->GetVerticesSidList(&sidlist[0]);
     1190        this->GetVerticesLidList(&lidlist[0]);
     1191
     1192        ElementInput2* control_value    = this->inputs2->GetControlInput2Data(control_enum,"value");    _assert_(control_value);
     1193        ElementInput2* control_gradient = this->inputs2->GetControlInput2Data(control_enum,"gradient"); _assert_(control_gradient);
     1194        control_value->Serve(NUMVERTICES,&lidlist[0]);
     1195        control_gradient->Serve(NUMVERTICES,&lidlist[0]);
    11051196
    11061197        GaussTria* gauss=new GaussTria();
    … …  
    11081199                gauss->GaussVertex(iv);
    11091200
    1110                 ((ControlInput*)input)->GetInputValue(&value,gauss);
    1111                 ((ControlInput*)input)->GetGradientValue(&gradient,gauss);
     1201                control_value->GetInputValue(&value,gauss);
     1202                control_gradient->GetInputValue(&gradient,gauss);
    11121203
    11131204                values[iv]    = reCast<IssmPDouble>(value)/reCast<IssmPDouble>(connectivity[iv]);
    … …  
    11431234
    11441235        /*Update Levelset*/
    1145         this->inputs->AddInput(new TriaInput(distanceenum,&ls[0],P1Enum));
     1236        this->AddInput2(distanceenum,&ls[0],P1Enum);
    11461237}
    11471238/*}}}*/
    … …  
    12331324                        /*Get input:*/
    12341325                        IssmDouble vel;
    1235                         Input* vel_input;
    1236 
    1237                         vel_input=this->inputs->GetInput(VelEnum); _assert_(vel_input);
     1326                        Input2* vel_input=this->GetInput2(VelEnum); _assert_(vel_input);
    12381327                        vel_input->GetInputAverage(&vel);
    12391328
    … …  
    12911380        floatingarea=(1-phi)*this->GetArea();
    12921381        if(scaled==true){
    1293                 Input* scalefactor_input = inputs->GetInput(MeshScaleFactorEnum); _assert_(scalefactor_input);
     1382                Input2* scalefactor_input = this->GetInput2(MeshScaleFactorEnum); _assert_(scalefactor_input);
    12941383                scalefactor_input->GetInputAverage(&scalefactor);
    12951384                floatingarea=floatingarea*scalefactor;
    … …  
    13061395
    13071396        int approximation;
    1308         inputs->GetInputValue(&approximation,ApproximationEnum);
     1397        this->GetInput2Value(&approximation,ApproximationEnum);
    13091398
    13101399        if(approximation==HOApproximationEnum || approximation==SSAApproximationEnum || approximation==SSAHOApproximationEnum){
    … …  
    13291418        GetVerticesCoordinates(&xyz_list);
    13301419        /*Retrieve all inputs we will be needing: */
    1331         Input* vx_input       = inputs->GetInput(VxEnum);       _assert_(vx_input);
    1332         Input* vy_input       = inputs->GetInput(VyEnum);       _assert_(vy_input);
     1420        Input2* vx_input       = this->GetInput2(VxEnum);       _assert_(vx_input);
     1421        Input2* vy_input       = this->GetInput2(VyEnum);       _assert_(vy_input);
    13331422
    13341423        /*1. Recover stresses at the base*/
    … …  
    18321921        *pxyz_front=xyz_front;
    18331922}/*}}}*/
     1923Input2*    Tria::GetInput2(int inputenum){/*{{{*/
     1924
     1925        /*Get Input from dataset*/
     1926        if(this->iscollapsed){
     1927                PentaInput2* input = this->inputs2->GetPentaInput(inputenum);
     1928                if(!input) return input;
     1929
     1930                /*Intermediaries*/
     1931                int numindices;
     1932                int indices[7];
     1933
     1934                /*Check interpolation*/
     1935                int interpolation = input->GetInterpolation();
     1936                switch(interpolation){
     1937                        case P0Enum:
     1938                                numindices = 1;
     1939                                indices[0] = this->lid;
     1940                                input->Serve(numindices,&indices[0]);
     1941                                break;
     1942                        case P1Enum:
     1943                                numindices = 3;
     1944                                for(int i=0;i<3;i++) indices[i] = vertices[i]->lid;
     1945                                input->Serve(numindices,&indices[0]);
     1946                                break;
     1947                        case P1DGEnum:
     1948                        case P1bubbleEnum:
     1949                                input->ServeCollapsed(this->lid,this->iscollapsed);
     1950                                break;
     1951                        default: _error_("interpolation "<<EnumToStringx(interpolation)<<" not supported");
     1952                }
     1953
     1954                /*Flag as collapsed for later use*/
     1955                input->SetServeCollapsed(true);
     1956
     1957                return input;
     1958        }
     1959        else{
     1960                TriaInput2* input = this->inputs2->GetTriaInput(inputenum);
     1961                if(!input) return input;
     1962
     1963                /*Intermediaries*/
     1964                int numindices;
     1965                int indices[7];
     1966
     1967                /*Check interpolation*/
     1968                int interpolation = input->GetInterpolation();
     1969                switch(interpolation){
     1970                        case P0Enum:
     1971                                numindices = 1;
     1972                                indices[0] = this->lid;
     1973                                input->Serve(numindices,&indices[0]);
     1974                                break;
     1975                        case P1Enum:
     1976                                numindices = 3;
     1977                                for(int i=0;i<3;i++) indices[i] = vertices[i]->lid;
     1978                                input->Serve(numindices,&indices[0]);
     1979                                break;
     1980                        case P1DGEnum:
     1981                                numindices = 3;
     1982                                input->Serve(this->lid,numindices);
     1983                                break;
     1984                        default:
     1985                                input->Serve(this->lid,this->GetNumberOfNodes(interpolation));
     1986                }
     1987
     1988                return input;
     1989        }
     1990}/*}}}*/
     1991Input2*    Tria::GetInput2(int inputenum,IssmDouble time){/*{{{*/
     1992
     1993        /*Get Input from dataset*/
     1994        if(this->iscollapsed){
     1995                PentaInput2* input = this->inputs2->GetPentaInput(inputenum,time);
     1996                if(!input) return input;
     1997
     1998                /*Intermediaries*/
     1999                int numindices;
     2000                int indices[3];
     2001
     2002                /*Check interpolation*/
     2003                int interpolation = input->GetInterpolation();
     2004                switch(interpolation){
     2005                        case P0Enum:
     2006                                numindices = 1;
     2007                                indices[0] = this->lid;
     2008                                input->Serve(numindices,&indices[0]);
     2009                                break;
     2010                        case P1Enum:
     2011                                numindices = 3;
     2012                                for(int i=0;i<3;i++) indices[i] = vertices[i]->lid;
     2013                                input->Serve(numindices,&indices[0]);
     2014                                break;
     2015                        case P1DGEnum:
     2016                        case P1bubbleEnum:
     2017                                input->ServeCollapsed(this->lid,this->iscollapsed);
     2018                                break;
     2019                        default: _error_("interpolation "<<EnumToStringx(interpolation)<<" not supported");
     2020                }
     2021
     2022                /*Flag as collapsed for later use*/
     2023                input->SetServeCollapsed(true);
     2024
     2025                return input;
     2026        }
     2027        else{
     2028                TriaInput2* input = this->inputs2->GetTriaInput(inputenum,time);
     2029                if(!input) return input;
     2030
     2031                /*Intermediaries*/
     2032                int numindices;
     2033                int indices[7];
     2034
     2035                /*Check interpolation*/
     2036                int interpolation = input->GetInterpolation();
     2037                switch(interpolation){
     2038                        case P0Enum:
     2039                                numindices = 1;
     2040                                indices[0] = this->lid;
     2041                                input->Serve(numindices,&indices[0]);
     2042                                break;
     2043                        case P1Enum:
     2044                                numindices = 3;
     2045                                for(int i=0;i<3;i++) indices[i] = vertices[i]->lid;
     2046                                input->Serve(numindices,&indices[0]);
     2047                                break;
     2048                        case P1DGEnum:
     2049                                numindices = 3;
     2050                                input->Serve(this->lid,numindices);
     2051                                break;
     2052                        default: _error_("interpolation "<<EnumToStringx(interpolation)<<" not supported");
     2053                }
     2054
     2055                return input;
     2056        }
     2057}/*}}}*/
     2058DatasetInput2* Tria::GetDatasetInput2(int inputenum){/*{{{*/
     2059
     2060        DatasetInput2* datasetinput = this->inputs2->GetDatasetInput2(inputenum);
     2061        if(!datasetinput) return NULL;
     2062
     2063        for(int i=0;i<datasetinput->GetNumIds();i++){
     2064
     2065                /*Get Input from dataset*/
     2066                if(this->iscollapsed){
     2067
     2068                        PentaInput2* input = datasetinput->GetPentaInputByOffset(i); _assert_(input);
     2069
     2070                        /*Intermediaries*/
     2071                        int numindices;
     2072                        int indices[3];
     2073
     2074                        /*Check interpolation*/
     2075                        int interpolation = input->GetInterpolation();
     2076                        switch(interpolation){
     2077                                case P0Enum:
     2078                                        numindices = 1;
     2079                                        indices[0] = this->lid;
     2080                                        input->Serve(numindices,&indices[0]);
     2081                                        break;
     2082                                case P1Enum:
     2083                                        numindices = 3;
     2084                                        for(int i=0;i<3;i++) indices[i] = vertices[i]->lid;
     2085                                        input->Serve(numindices,&indices[0]);
     2086                                        break;
     2087                                case P1DGEnum:
     2088                                case P1bubbleEnum:
     2089                                        input->ServeCollapsed(this->lid,this->iscollapsed);
     2090                                        break;
     2091                                default: _error_("interpolation "<<EnumToStringx(interpolation)<<" not supported");
     2092                        }
     2093
     2094                        /*Flag as collapsed for later use*/
     2095                        input->SetServeCollapsed(true);
     2096                }
     2097                else{
     2098
     2099                        TriaInput2* input = datasetinput->GetTriaInputByOffset(i); _assert_(input);
     2100
     2101                        /*Intermediaries*/
     2102                        int numindices;
     2103                        int indices[7];
     2104
     2105                        /*Check interpolation*/
     2106                        int interpolation = input->GetInterpolation();
     2107                        switch(interpolation){
     2108                                case P0Enum:
     2109                                        numindices = 1;
     2110                                        indices[0] = this->lid;
     2111                                        input->Serve(numindices,&indices[0]);
     2112                                        break;
     2113                                case P1Enum:
     2114                                        numindices = 3;
     2115                                        for(int i=0;i<3;i++) indices[i] = vertices[i]->lid;
     2116                                        input->Serve(numindices,&indices[0]);
     2117                                        break;
     2118                                case P1DGEnum:
     2119                                        numindices = 3;
     2120                                        input->Serve(this->lid,numindices);
     2121                                        break;
     2122                                default: _error_("interpolation "<<EnumToStringx(interpolation)<<" not supported");
     2123                        }
     2124
     2125                }
     2126        }
     2127
     2128        return datasetinput;
     2129}/*}}}*/
    18342130void       Tria::GetInputValue(IssmDouble* pvalue,Node* node,int enumtype){/*{{{*/
    18352131
    1836         Input* input=inputs->GetInput(enumtype);
     2132        Input2* input=this->GetInput2(enumtype);
    18372133        if(!input) _error_("No input of type " << EnumToStringx(enumtype) << " found in tria");
    18382134
    … …  
    18482144void       Tria::GetInputValue(IssmDouble* pvalue,Vertex* vertex,int enumtype){/*{{{*/
    18492145
    1850         Input* input=inputs->GetInput(enumtype);
     2146        Input2* input=this->GetInput2(enumtype);
    18512147        if(!input) _error_("No input of type " << EnumToStringx(enumtype) << " found in tria");
    18522148
    … …  
    20522348void       Tria::GetVectorFromControlInputs(Vector<IssmDouble>* vector,int control_enum,int control_index,const char* data){/*{{{*/
    20532349
    2054         int vertexidlist[NUMVERTICES];
    2055         Input *input=NULL;
    2056 
    20572350        /*Get out if this is not an element input*/
    20582351        if(!IsInputEnum(control_enum)) _error_("Enum "<<EnumToStringx(control_enum)<<" is not in IsInput");
    20592352
    20602353        /*Prepare index list*/
    2061         GradientIndexing(&vertexidlist[0],control_index);
     2354        int idlist[NUMVERTICES];
     2355        GradientIndexing(&idlist[0],control_index);
    20622356
    20632357        /*Get input (either in element or material)*/
    2064         input=(Input*)this->inputs->GetInput(control_enum);   _assert_(input);
    2065 
    2066         /*Check that it is a ControlInput*/
    2067         if (input->ObjectEnum()!=ControlInputEnum){
    2068                 _error_("input " << EnumToStringx(control_enum) << " is not a ControlInput");
    2069         }
    2070 
    2071         ((ControlInput*)input)->GetVectorFromInputs(vector,&vertexidlist[0],data);
     2358        ElementInput2* input=this->inputs2->GetControlInput2Data(control_enum,data);   _assert_(input);
     2359
     2360        /*Intermediaries*/
     2361        int numindices;
     2362        int indices[NUMVERTICES];
     2363
     2364        /*Check interpolation*/
     2365        int interpolation = input->GetInterpolation();
     2366        switch(interpolation){
     2367                case P1Enum:
     2368                        numindices = NUMVERTICES;
     2369                        for(int i=0;i<NUMVERTICES;i++) indices[i] = vertices[i]->lid;
     2370                        input->Serve(numindices,&indices[0]);
     2371                        break;
     2372                default: _error_("interpolation "<<EnumToStringx(interpolation)<<" not supported");
     2373        }
     2374
     2375        /*Flag as collapsed for later use*/
     2376        if(this->iscollapsed){
     2377                xDynamicCast<PentaInput2*>(input)->SetServeCollapsed(true);
     2378        }
     2379
     2380        /* Start looping on the number of vertices: */
     2381        IssmDouble values[NUMVERTICES];
     2382        Gauss*gauss=this->NewGauss();
     2383        for(int iv=0;iv<NUMVERTICES;iv++){
     2384                gauss->GaussVertex(iv);
     2385                input->GetInputValue(&values[iv],gauss);
     2386        }
     2387        delete gauss;
     2388
     2389        vector->SetValues(NUMVERTICES,idlist,&values[0],INS_VAL);
    20722390}
    20732391/*}}}*/
    20742392void       Tria::GetVectorFromControlInputs(Vector<IssmDouble>* vector,int control_enum,int control_index,const char* data,int offset){/*{{{*/
    20752393
    2076         int* idlist = NULL;
    2077         IssmDouble* values = NULL;
    2078         int* M = NULL;
    2079 
    2080         /*Get out if this is not an element input*/
    2081         if(!IsInputEnum(control_enum)) _error_("Enum "<<EnumToStringx(control_enum)<<" is not in IsInput");
    2082         Input* input=(Input*)this->inputs->GetInput(control_enum);   _assert_(input);
    2083 
    2084         parameters->FindParam(&M,NULL,ControlInputSizeMEnum);
    2085 
    2086         /*Cast to Controlinput*/
    2087         if(input->ObjectEnum()!=ControlInputEnum) _error_("input " << EnumToStringx(control_enum) << " is not a ControlInput");
    2088         ControlInput* controlinput = xDynamicCast<ControlInput*>(input);
    2089 
    2090         if(strcmp(data,"value")==0){
    2091                 input  = controlinput->values;
    2092         }
    2093         else if (strcmp(data,"lowerbound")==0){
    2094                 input = controlinput->minvalues;
    2095         }
    2096         else if (strcmp(data,"upperbound")==0){
    2097                 input = controlinput->maxvalues;
    2098         }
    2099         else if (strcmp(data,"gradient")==0){
    2100                 input = controlinput->gradient;
    2101         }
    2102         else{
    2103                 _error_("Data " << data << " not supported yet");
    2104         }
     2394        /*Get input*/
     2395        ElementInput2* input=this->inputs2->GetControlInput2Data(control_enum,data);   _assert_(input);
     2396
     2397        /*Lid list once for all*/
     2398        int lidlist[NUMVERTICES];
     2399        for(int i=0;i<NUMVERTICES;i++) lidlist[i] = vertices[i]->lid;
     2400
    21052401        /*Check what input we are dealing with*/
    2106 
    21072402        switch(input->ObjectEnum()){
    2108                 case TriaInputEnum:
     2403                case TriaInput2Enum:
    21092404                          {
    2110                                 TriaInput* triainput = xDynamicCast<TriaInput*>(input);
    2111                                 if(triainput->interpolation_type!=P1Enum) _error_("not supported yet");
     2405                                IssmDouble values[NUMVERTICES];
     2406                                int        idlist[NUMVERTICES];
     2407
     2408                                TriaInput2* triainput = xDynamicCast<TriaInput2*>(input);
     2409                                if(triainput->GetInputInterpolationType()!=P1Enum) _error_("not supported yet");
     2410                                input->Serve(NUMVERTICES,&lidlist[0]);
    21122411
    21132412                                /*Create list of indices and values for global vector*/
    2114                                 idlist = xNew<int>(NUMVERTICES);
    2115                                 values = xNew<IssmDouble>(NUMVERTICES);
    21162413                                GradientIndexing(&idlist[0],control_index);
    2117                                 for(int i=0;i<NUMVERTICES;i++){
    2118                                         values[i] = triainput->values[i];
    2119                                 }
     2414                                for(int i=0;i<NUMVERTICES;i++) values[i] = triainput->element_values[i];
    21202415                                vector->SetValues(NUMVERTICES,idlist,values,INS_VAL);
    21212416                                break;
    … …  
    21242419                case TransientInputEnum:
    21252420                                {
    2126                                         TransientInput* transientinput = xDynamicCast<TransientInput*>(input);
     2421                                        TransientInput2* transientinput = xDynamicCast<TransientInput2*>(input);
    21272422                                        int N = transientinput->numtimesteps;
    2128                                         idlist = xNew<int>(NUMVERTICES*N);
    2129                                         values = xNew<IssmDouble>(NUMVERTICES*N);
     2423                                        int* M=NULL;
     2424                                        parameters->FindParam(&M,NULL,ControlInputSizeMEnum);
     2425                                        int* idlist = xNew<int>(NUMVERTICES*N);
     2426                                        IssmDouble* values = xNew<IssmDouble>(NUMVERTICES*N);
    21302427                                        for(int t=0;t<transientinput->numtimesteps;t++) {
    21312428                                                IssmDouble time = transientinput->GetTimeByOffset(t);
    2132                                                 input = transientinput->GetTimeInput(time);
    2133                                                 TriaInput* timeinput = xDynamicCast<TriaInput*>(input);
     2429                                                TriaInput* timeinput = xDynamicCast<TriaInput*>(transientinput->GetTimeInput(time));
    21342430                                                if(timeinput->interpolation_type!=P1Enum) _error_("not supported yet");
     2431                                                input->Serve(NUMVERTICES,&lidlist[0]);
    21352432                                                /*Create list of indices and values for global vector*/
    21362433                                                for(int i=0;i<NUMVERTICES;i++){
    … …  
    21402437                                        }
    21412438                                        vector->SetValues(NUMVERTICES*transientinput->numtimesteps,idlist,values,INS_VAL);
     2439                                        xDelete<int>(M);
     2440                                        xDelete<int>(idlist);
     2441                                        xDelete<IssmDouble>(values);
    21422442                                        break;
    21432443                                }
    2144                 default: _error_("input "<<input->ObjectEnum()<<" not supported yet");
    2145         }
    2146         xDelete<int>(idlist);
    2147         xDelete<IssmDouble>(values);
     2444                default: _error_("input "<<EnumToStringx(input->ObjectEnum())<<" not supported yet");
     2445        }
    21482446}
    21492447/*}}}*/
    … …  
    21992497        groundedarea=phi*this->GetArea();
    22002498        if(scaled==true){
    2201                 Input* scalefactor_input = inputs->GetInput(MeshScaleFactorEnum); _assert_(scalefactor_input);
     2499                Input2* scalefactor_input = this->GetInput2(MeshScaleFactorEnum); _assert_(scalefactor_input);
    22022500                scalefactor_input->GetInputAverage(&scalefactor);
    22032501                groundedarea=groundedarea*scalefactor;
    … …  
    22792577        IssmDouble vx,vy,thickness,Jdet;
    22802578        IssmDouble rho_ice=FindParam(MaterialsRhoIceEnum);
    2281         Input* thickness_input=inputs->GetInput(ThicknessEnum); _assert_(thickness_input);
    2282         Input* vx_input=NULL;
    2283         Input* vy_input=NULL;
     2579        Input2* thickness_input=this->GetInput2(ThicknessEnum); _assert_(thickness_input);
     2580        Input2* vx_input=NULL;
     2581        Input2* vy_input=NULL;
    22842582        if(domaintype==Domain2DhorizontalEnum){
    2285                 vx_input=inputs->GetInput(VxEnum); _assert_(vx_input);
    2286                 vy_input=inputs->GetInput(VyEnum); _assert_(vy_input);
     2583                vx_input=this->GetInput2(VxEnum); _assert_(vx_input);
     2584                vy_input=this->GetInput2(VyEnum); _assert_(vy_input);
    22872585        }
    22882586        else{
    2289                 vx_input=inputs->GetInput(VxAverageEnum); _assert_(vx_input);
    2290                 vy_input=inputs->GetInput(VyAverageEnum); _assert_(vy_input);
     2587                vx_input=this->GetInput2(VxAverageEnum); _assert_(vx_input);
     2588                vy_input=this->GetInput2(VyAverageEnum); _assert_(vy_input);
    22912589        }
    22922590
    … …  
    24082706        IssmDouble vx,vy,thickness,Jdet;
    24092707        IssmDouble rho_ice=FindParam(MaterialsRhoIceEnum);
    2410         Input* thickness_input=inputs->GetInput(ThicknessEnum); _assert_(thickness_input);
    2411         Input* vx_input=NULL;
    2412         Input* vy_input=NULL;
     2708        Input2* thickness_input=this->GetInput2(ThicknessEnum); _assert_(thickness_input);
     2709        Input2* vx_input=NULL;
     2710        Input2* vy_input=NULL;
    24132711        if(domaintype==Domain2DhorizontalEnum){
    2414                 vx_input=inputs->GetInput(VxEnum); _assert_(vx_input);
    2415                 vy_input=inputs->GetInput(VyEnum); _assert_(vy_input);
     2712                vx_input=this->GetInput2(VxEnum); _assert_(vx_input);
     2713                vy_input=this->GetInput2(VyEnum); _assert_(vy_input);
    24162714        }
    24172715        else{
    2418                 vx_input=inputs->GetInput(VxAverageEnum); _assert_(vx_input);
    2419                 vy_input=inputs->GetInput(VyAverageEnum); _assert_(vy_input);
     2716                vx_input=this->GetInput2(VxAverageEnum); _assert_(vx_input);
     2717                vy_input=this->GetInput2(VyAverageEnum); _assert_(vy_input);
    24202718        }
    24212719
    … …  
    25352833        IssmDouble vx,vy,thickness,Jdet;
    25362834        IssmDouble rho_ice=FindParam(MaterialsRhoIceEnum);
    2537         Input* thickness_input=inputs->GetInput(ThicknessEnum); _assert_(thickness_input);
    2538         Input* vx_input=NULL;
    2539         Input* vy_input=NULL;
     2835        Input2* thickness_input=this->GetInput2(ThicknessEnum); _assert_(thickness_input);
     2836        Input2* vx_input=NULL;
     2837        Input2* vy_input=NULL;
    25402838        if(domaintype==Domain2DhorizontalEnum){
    2541                 vx_input=inputs->GetInput(VxEnum); _assert_(vx_input);
    2542                 vy_input=inputs->GetInput(VyEnum); _assert_(vy_input);
     2839                vx_input=this->GetInput2(VxEnum); _assert_(vx_input);
     2840                vy_input=this->GetInput2(VyEnum); _assert_(vy_input);
    25432841        }
    25442842        else{
    2545                 vx_input=inputs->GetInput(VxAverageEnum); _assert_(vx_input);
    2546                 vy_input=inputs->GetInput(VyAverageEnum); _assert_(vy_input);
     2843                vx_input=this->GetInput2(VxAverageEnum); _assert_(vx_input);
     2844                vy_input=this->GetInput2(VyAverageEnum); _assert_(vy_input);
    25472845        }
    25482846
    … …  
    26422940                area_base=this->GetArea();
    26432941                if(scaled==true){
    2644                         Input* scalefactor_input = inputs->GetInput(MeshScaleFactorEnum); _assert_(scalefactor_input);
     2942                        Input2* scalefactor_input = this->GetInput2(MeshScaleFactorEnum); _assert_(scalefactor_input);
    26452943                        scalefactor_input->GetInputAverage(&scalefactor);
    26462944                        area_base=area_base*scalefactor;
    … …  
    26482946
    26492947                /*Now get the average height*/
    2650                 Input* surface_input = inputs->GetInput(SurfaceEnum); _assert_(surface_input);
    2651                 Input* base_input     = inputs->GetInput(BaseEnum);     _assert_(base_input);
     2948                Input2* surface_input = this->GetInput2(SurfaceEnum); _assert_(surface_input);
     2949                Input2* base_input    = this->GetInput2(BaseEnum);    _assert_(base_input);
    26522950                surface_input->GetInputAverage(&surface);
    26532951                base_input->GetInputAverage(&base);
    … …  
    26862984        base = 1./2. * fabs((xyz_list[0][0]-xyz_list[2][0])*(xyz_list[1][1]-xyz_list[0][1]) - (xyz_list[0][0]-xyz_list[1][0])*(xyz_list[2][1]-xyz_list[0][1]));
    26872985        if(scaled==true){
    2688                 Input* scalefactor_input = inputs->GetInput(MeshScaleFactorEnum); _assert_(scalefactor_input);
     2986                Input2* scalefactor_input = this->GetInput2(MeshScaleFactorEnum); _assert_(scalefactor_input);
    26892987                scalefactor_input->GetInputAverage(&scalefactor);
    26902988                base=base*scalefactor;
    … …  
    26922990
    26932991        /*Now get the average height and bathymetry*/
    2694         Input* surface_input    = inputs->GetInput(SurfaceEnum);    _assert_(surface_input);
    2695         Input* base_input        = inputs->GetInput(BaseEnum);        _assert_(base_input);
    2696         Input* bed_input = inputs->GetInput(BedEnum); _assert_(bed_input);
     2992        Input2* surface_input = this->GetInput2(SurfaceEnum); _assert_(surface_input);
     2993        Input2* base_input    = this->GetInput2(BaseEnum);    _assert_(base_input);
     2994        Input2* bed_input     = this->GetInput2(BedEnum);    _assert_(bed_input);
    26972995        if(!bed_input) _error_("Could not find bed");
    26982996        surface_input->GetInputAverage(&surface);
    … …  
    27073005
    27083006        /*New input*/
    2709         Input* oldinput=NULL;
    2710         Input* newinput=NULL;
     3007        Input2* oldinput=NULL;
     3008        Input2* newinput=NULL;
    27113009
    27123010        /*copy input of enum_type*/
    2713         oldinput=(Input*)this->inputs->GetInput(enum_type);
     3011        oldinput=this->GetInput2(enum_type);
    27143012        if(!oldinput)_error_("could not find old input with enum: " << EnumToStringx(enum_type));
    2715         newinput=(Input*)oldinput->copy();
     3013        newinput=oldinput->copy();
    27163014
    27173015        /*Assign new name (average)*/
    … …  
    27193017
    27203018        /*Add new input to current element*/
     3019        _error_("not implemented");
    27213020        this->inputs->AddInput((Input*)newinput);
    27223021}
    … …  
    27493048        }
    27503049
    2751         /*Need to know the type of approximation for this element*/
    2752         if(iomodel->Data("md.flowequation.element_equation")){
    2753                 this->inputs->AddInput(new IntInput(ApproximationEnum,IoCodeToEnumElementEquation(reCast<int>(iomodel->Data("md.flowequation.element_equation")[index]))));
    2754         }
    2755 
    2756         /*Control Inputs*/
    2757         if (control_analysis && !ad_analysis){
    2758                 if(!ad_analysis)iomodel->FindConstant(&controls,NULL,"md.inversion.control_parameters");
    2759                 if(ad_analysis)iomodel->FindConstant(&controls,NULL,"md.autodiff.independent_object_names");
    2760 
    2761                 for(i=0;i<num_control_type;i++){
    2762                         _assert_(controls[i]);
    2763                         int control = StringToEnumx(controls[i]);
    2764                         switch(control){
    2765                                 case BalancethicknessThickeningRateEnum:
    2766                                         if (iomodel->Data("md.balancethickness.thickening_rate")){
    2767                                                 for(j=0;j<NUMVERTICES;j++)nodeinputs[j]=iomodel->Data("md.balancethickness.thickening_rate")[tria_vertex_ids[j]-1];
    2768                                                 for(j=0;j<NUMVERTICES;j++)cmmininputs[j]=iomodel->Data("md.inversion.min_parameters")[(tria_vertex_ids[j]-1)*num_control_type+i]/yts;
    2769                                                 for(j=0;j<NUMVERTICES;j++)cmmaxinputs[j]=iomodel->Data("md.inversion.max_parameters")[(tria_vertex_ids[j]-1)*num_control_type+i]/yts;
    2770                                                 this->inputs->AddInput(new ControlInput(BalancethicknessThickeningRateEnum,TriaInputEnum,nodeinputs,cmmininputs,cmmaxinputs,P1Enum,i+1));
    2771                                         }
    2772                                         break;
    2773                                 case VxEnum:
    2774                                         if (iomodel->Data("md.initialization.vx")){
    2775                                                 for(j=0;j<NUMVERTICES;j++)nodeinputs[j]=iomodel->Data("md.initialization.vx")[tria_vertex_ids[j]-1];
    2776                                                 for(j=0;j<NUMVERTICES;j++)cmmininputs[j]=iomodel->Data("md.inversion.min_parameters")[(tria_vertex_ids[j]-1)*num_control_type+i]/yts;
    2777                                                 for(j=0;j<NUMVERTICES;j++)cmmaxinputs[j]=iomodel->Data("md.inversion.max_parameters")[(tria_vertex_ids[j]-1)*num_control_type+i]/yts;
    2778                                                 this->inputs->AddInput(new ControlInput(VxEnum,TriaInputEnum,nodeinputs,cmmininputs,cmmaxinputs,P1Enum,i+1));
    2779                                         }
    2780                                         break;
    2781                                 case VyEnum:
    2782                                         if (iomodel->Data("md.initialization.vy")){
    2783                                                 for(j=0;j<NUMVERTICES;j++)nodeinputs[j]=iomodel->Data("md.initialization.vy")[tria_vertex_ids[j]-1];
    2784                                                 for(j=0;j<NUMVERTICES;j++)cmmininputs[j]=iomodel->Data("md.inversion.min_parameters")[(tria_vertex_ids[j]-1)*num_control_type+i]/yts;
    2785                                                 for(j=0;j<NUMVERTICES;j++)cmmaxinputs[j]=iomodel->Data("md.inversion.max_parameters")[(tria_vertex_ids[j]-1)*num_control_type+i]/yts;
    2786                                                 this->inputs->AddInput(new ControlInput(VyEnum,TriaInputEnum,nodeinputs,cmmininputs,cmmaxinputs,P1Enum,i+1));
    2787                                         }
    2788                                         break;
    2789                                 case ThicknessEnum:
    2790                                         if(iomodel->Data("md.geometry.thickness")){
    2791                                                 for(j=0;j<NUMVERTICES;j++) nodeinputs[j]=iomodel->Data("md.geometry.thickness")[tria_vertex_ids[j]-1];
    2792                                                 for(j=0;j<NUMVERTICES;j++)cmmininputs[j]=iomodel->Data("md.inversion.min_parameters")[(tria_vertex_ids[j]-1)*num_control_type+i];
    2793                                                 for(j=0;j<NUMVERTICES;j++)cmmaxinputs[j]=iomodel->Data("md.inversion.max_parameters")[(tria_vertex_ids[j]-1)*num_control_type+i];
    2794                                                 this->inputs->AddInput(new ControlInput(ThicknessEnum,TriaInputEnum,nodeinputs,cmmininputs,cmmaxinputs,P1Enum,i+1));
    2795                                         }
    2796                                         break;
    2797                                 case BalancethicknessSpcthicknessEnum:
    2798                                         if(iomodel->Data("md.balancethickness.spcthickness")){
    2799                                                 for(j=0;j<NUMVERTICES;j++) nodeinputs[j]=iomodel->Data("md.balancethickness.spcthickness")[tria_vertex_ids[j]-1];
    2800                                                 for(j=0;j<NUMVERTICES;j++)cmmininputs[j]=iomodel->Data("md.inversion.min_parameters")[(tria_vertex_ids[j]-1)*num_control_type+i];
    2801                                                 for(j=0;j<NUMVERTICES;j++)cmmaxinputs[j]=iomodel->Data("md.inversion.max_parameters")[(tria_vertex_ids[j]-1)*num_control_type+i];
    2802                                                 this->inputs->AddInput(new ControlInput(BalancethicknessSpcthicknessEnum,TriaInputEnum,nodeinputs,cmmininputs,cmmaxinputs,P1Enum,i+1));
    2803                                         }
    2804                                         break;
    2805                                 case BalancethicknessOmegaEnum:
    2806                                         if(iomodel->Data("md.balancethickness.omega")){
    2807                                                 for(j=0;j<NUMVERTICES;j++) nodeinputs[j]=iomodel->Data("md.balancethickness.omega")[tria_vertex_ids[j]-1];
    2808                                                 for(j=0;j<NUMVERTICES;j++)cmmininputs[j]=iomodel->Data("md.inversion.min_parameters")[(tria_vertex_ids[j]-1)*num_control_type+i];
    2809                                                 for(j=0;j<NUMVERTICES;j++)cmmaxinputs[j]=iomodel->Data("md.inversion.max_parameters")[(tria_vertex_ids[j]-1)*num_control_type+i];
    2810                                                 this->inputs->AddInput(new ControlInput(BalancethicknessOmegaEnum,TriaInputEnum,nodeinputs,cmmininputs,cmmaxinputs,P1Enum,i+1));
    2811                                         }
    2812                                         break;
    2813                                 case FrictionCoefficientEnum:
    2814                                         if (iomodel->Data("md.friction.coefficient")){
    2815                                                 for(j=0;j<NUMVERTICES;j++)nodeinputs[j]=iomodel->Data("md.friction.coefficient")[tria_vertex_ids[j]-1];
    2816                                                 for(j=0;j<NUMVERTICES;j++)cmmininputs[j]=iomodel->Data("md.inversion.min_parameters")[(tria_vertex_ids[j]-1)*num_control_type+i];
    2817                                                 for(j=0;j<NUMVERTICES;j++)cmmaxinputs[j]=iomodel->Data("md.inversion.max_parameters")[(tria_vertex_ids[j]-1)*num_control_type+i];
    2818                                                 this->inputs->AddInput(new ControlInput(FrictionCoefficientEnum,TriaInputEnum,nodeinputs,cmmininputs,cmmaxinputs,P1Enum,i+1));
    2819                                         }
    2820                                         break;
    2821                                 case MaterialsRheologyBbarEnum:
    2822                                         if(iomodel->Data("md.materials.rheology_B")){
    2823                                                 for(j=0;j<NUMVERTICES;j++) nodeinputs[j]=iomodel->Data("md.materials.rheology_B")[tria_vertex_ids[j]-1];
    2824                                                 for(j=0;j<NUMVERTICES;j++)cmmininputs[j]=iomodel->Data("md.inversion.min_parameters")[(tria_vertex_ids[j]-1)*num_control_type+i];
    2825                                                 for(j=0;j<NUMVERTICES;j++)cmmaxinputs[j]=iomodel->Data("md.inversion.max_parameters")[(tria_vertex_ids[j]-1)*num_control_type+i];
    2826                                                 this->inputs->AddInput(new ControlInput(MaterialsRheologyBbarEnum,TriaInputEnum,nodeinputs,cmmininputs,cmmaxinputs,P1Enum,i+1));
    2827                                         }
    2828                                         break;
    2829                                 case DamageDbarEnum:
    2830                                         if(iomodel->Data("md.damage.D")){
    2831                                                 for(j=0;j<NUMVERTICES;j++) nodeinputs[j]=iomodel->Data("md.damage.D")[tria_vertex_ids[j]-1];
    2832                                                 for(j=0;j<NUMVERTICES;j++)cmmininputs[j]=iomodel->Data("md.inversion.min_parameters")[(tria_vertex_ids[j]-1)*num_control_type+i];
    2833                                                 for(j=0;j<NUMVERTICES;j++)cmmaxinputs[j]=iomodel->Data("md.inversion.max_parameters")[(tria_vertex_ids[j]-1)*num_control_type+i];
    2834                                                 this->inputs->AddInput(new ControlInput(DamageDbarEnum,TriaInputEnum,nodeinputs,cmmininputs,cmmaxinputs,P1Enum,i+1));
    2835                                         }
    2836                                         break;
    2837                                 default:
    2838                                         _error_("Control " << EnumToStringx(control) << " not implemented yet");
    2839                         }
    2840                 }
    2841                 for(i=0;i<num_control_type;i++) xDelete<char>(controls[i]);
    2842                 xDelete<char*>(controls);
    2843         }
    2844 
    2845         /*DatasetInputs*/
    2846         if (control_analysis && iomodel->Data("md.inversion.cost_functions_coefficients")){
    2847 
    2848                 /*Generate cost functions associated with the iomodel*/
    2849                 char**   cost_functions       = NULL;
    2850                 int*     cost_functions_enums = NULL;
    2851                 int      num_cost_functions;
    2852 
    2853                 iomodel->FindConstant(&num_cost_functions,"md.inversion.num_cost_functions");
    2854                 iomodel->FindConstant(&cost_functions,&num_cost_functions,"md.inversion.cost_functions");
    2855                 if(num_cost_functions<1) _error_("No cost functions found");
    2856                 cost_functions_enums=xNew<int>(num_cost_functions);
    2857                 for(j=0;j<num_cost_functions;j++){ cost_functions_enums[j]=StringToEnumx(cost_functions[j]); }
    2858 
    2859                 /*Create inputs and add to DataSetInput*/
    2860                 DatasetInput* datasetinput=new DatasetInput(InversionCostFunctionsCoefficientsEnum);
    2861                 for(i=0;i<num_responses;i++){
    2862                         for(j=0;j<3;j++)nodeinputs[j]=iomodel->Data("md.inversion.cost_functions_coefficients")[(tria_vertex_ids[j]-1)*num_responses+i];
    2863                         datasetinput->AddInput(new TriaInput(InversionCostFunctionsCoefficientsEnum,nodeinputs,P1Enum),cost_functions_enums[i]);
    2864                 }
    2865 
    2866                 /*Add datasetinput to element inputs*/
    2867                 this->inputs->AddInput(datasetinput);
    2868 
    2869                 /*Clean up cost functions*/
    2870                 xDelete<int>(cost_functions_enums);
    2871                 for(int j=0;j<num_cost_functions;j++) xDelete<char>(cost_functions[j]);
    2872                 xDelete<char*>(cost_functions);
    2873         }
     3050//      /*Control Inputs*/
     3051//      if (control_analysis && !ad_analysis){
     3052//              if(!ad_analysis)iomodel->FindConstant(&controls,NULL,"md.inversion.control_parameters");
     3053//              if(ad_analysis)iomodel->FindConstant(&controls,NULL,"md.autodiff.independent_object_names");
     3054//
     3055//              for(i=0;i<num_control_type;i++){
     3056//                      _assert_(controls[i]);
     3057//                      int control = StringToEnumx(controls[i]);
     3058//                      switch(control){
     3059//                              case BalancethicknessThickeningRateEnum:
     3060//                                      if (iomodel->Data("md.balancethickness.thickening_rate")){
     3061//                                              for(j=0;j<NUMVERTICES;j++)nodeinputs[j]=iomodel->Data("md.balancethickness.thickening_rate")[tria_vertex_ids[j]-1];
     3062//                                              for(j=0;j<NUMVERTICES;j++)cmmininputs[j]=iomodel->Data("md.inversion.min_parameters")[(tria_vertex_ids[j]-1)*num_control_type+i]/yts;
     3063//                                              for(j=0;j<NUMVERTICES;j++)cmmaxinputs[j]=iomodel->Data("md.inversion.max_parameters")[(tria_vertex_ids[j]-1)*num_control_type+i]/yts;
     3064//                                              this->inputs->AddInput(new ControlInput(BalancethicknessThickeningRateEnum,TriaInputEnum,nodeinputs,cmmininputs,cmmaxinputs,P1Enum,i+1));
     3065//                                      }
     3066//                                      break;
     3067//                              case VxEnum:
     3068//                                      if (iomodel->Data("md.initialization.vx")){
     3069//                                              for(j=0;j<NUMVERTICES;j++)nodeinputs[j]=iomodel->Data("md.initialization.vx")[tria_vertex_ids[j]-1];
     3070//                                              for(j=0;j<NUMVERTICES;j++)cmmininputs[j]=iomodel->Data("md.inversion.min_parameters")[(tria_vertex_ids[j]-1)*num_control_type+i]/yts;
     3071//                                              for(j=0;j<NUMVERTICES;j++)cmmaxinputs[j]=iomodel->Data("md.inversion.max_parameters")[(tria_vertex_ids[j]-1)*num_control_type+i]/yts;
     3072//                                              this->inputs->AddInput(new ControlInput(VxEnum,TriaInputEnum,nodeinputs,cmmininputs,cmmaxinputs,P1Enum,i+1));
     3073//                                      }
     3074//                                      break;
     3075//                              case VyEnum:
     3076//                                      if (iomodel->Data("md.initialization.vy")){
     3077//                                              for(j=0;j<NUMVERTICES;j++)nodeinputs[j]=iomodel->Data("md.initialization.vy")[tria_vertex_ids[j]-1];
     3078//                                              for(j=0;j<NUMVERTICES;j++)cmmininputs[j]=iomodel->Data("md.inversion.min_parameters")[(tria_vertex_ids[j]-1)*num_control_type+i]/yts;
     3079//                                              for(j=0;j<NUMVERTICES;j++)cmmaxinputs[j]=iomodel->Data("md.inversion.max_parameters")[(tria_vertex_ids[j]-1)*num_control_type+i]/yts;
     3080//                                              this->inputs->AddInput(new ControlInput(VyEnum,TriaInputEnum,nodeinputs,cmmininputs,cmmaxinputs,P1Enum,i+1));
     3081//                                      }
     3082//                                      break;
     3083//                              case ThicknessEnum:
     3084//                                      if(iomodel->Data("md.geometry.thickness")){
     3085//                                              for(j=0;j<NUMVERTICES;j++) nodeinputs[j]=iomodel->Data("md.geometry.thickness")[tria_vertex_ids[j]-1];
     3086//                                              for(j=0;j<NUMVERTICES;j++)cmmininputs[j]=iomodel->Data("md.inversion.min_parameters")[(tria_vertex_ids[j]-1)*num_control_type+i];
     3087//                                              for(j=0;j<NUMVERTICES;j++)cmmaxinputs[j]=iomodel->Data("md.inversion.max_parameters")[(tria_vertex_ids[j]-1)*num_control_type+i];
     3088//                                              this->inputs->AddInput(new ControlInput(ThicknessEnum,TriaInputEnum,nodeinputs,cmmininputs,cmmaxinputs,P1Enum,i+1));
     3089//                                      }
     3090//                                      break;
     3091//                              case BalancethicknessSpcthicknessEnum:
     3092//                                      if(iomodel->Data("md.balancethickness.spcthickness")){
     3093//                                              for(j=0;j<NUMVERTICES;j++) nodeinputs[j]=iomodel->Data("md.balancethickness.spcthickness")[tria_vertex_ids[j]-1];
     3094//                                              for(j=0;j<NUMVERTICES;j++)cmmininputs[j]=iomodel->Data("md.inversion.min_parameters")[(tria_vertex_ids[j]-1)*num_control_type+i];
     3095//                                              for(j=0;j<NUMVERTICES;j++)cmmaxinputs[j]=iomodel->Data("md.inversion.max_parameters")[(tria_vertex_ids[j]-1)*num_control_type+i];
     3096//                                              this->inputs->AddInput(new ControlInput(BalancethicknessSpcthicknessEnum,TriaInputEnum,nodeinputs,cmmininputs,cmmaxinputs,P1Enum,i+1));
     3097//                                      }
     3098//                                      break;
     3099//                              case BalancethicknessOmegaEnum:
     3100//                                      if(iomodel->Data("md.balancethickness.omega")){
     3101//                                              for(j=0;j<NUMVERTICES;j++) nodeinputs[j]=iomodel->Data("md.balancethickness.omega")[tria_vertex_ids[j]-1];
     3102//                                              for(j=0;j<NUMVERTICES;j++)cmmininputs[j]=iomodel->Data("md.inversion.min_parameters")[(tria_vertex_ids[j]-1)*num_control_type+i];
     3103//                                              for(j=0;j<NUMVERTICES;j++)cmmaxinputs[j]=iomodel->Data("md.inversion.max_parameters")[(tria_vertex_ids[j]-1)*num_control_type+i];
     3104//                                              this->inputs->AddInput(new ControlInput(BalancethicknessOmegaEnum,TriaInputEnum,nodeinputs,cmmininputs,cmmaxinputs,P1Enum,i+1));
     3105//                                      }
     3106//                                      break;
     3107//                              case FrictionCoefficientEnum:
     3108//                                      if (iomodel->Data("md.friction.coefficient")){
     3109//                                              for(j=0;j<NUMVERTICES;j++)nodeinputs[j]=iomodel->Data("md.friction.coefficient")[tria_vertex_ids[j]-1];
     3110//                                              for(j=0;j<NUMVERTICES;j++)cmmininputs[j]=iomodel->Data("md.inversion.min_parameters")[(tria_vertex_ids[j]-1)*num_control_type+i];
     3111//                                              for(j=0;j<NUMVERTICES;j++)cmmaxinputs[j]=iomodel->Data("md.inversion.max_parameters")[(tria_vertex_ids[j]-1)*num_control_type+i];
     3112//                                              this->inputs->AddInput(new ControlInput(FrictionCoefficientEnum,TriaInputEnum,nodeinputs,cmmininputs,cmmaxinputs,P1Enum,i+1));
     3113//                                      }
     3114//                                      break;
     3115//                              case MaterialsRheologyBbarEnum:
     3116//                                      if(iomodel->Data("md.materials.rheology_B")){
     3117//                                              for(j=0;j<NUMVERTICES;j++) nodeinputs[j]=iomodel->Data("md.materials.rheology_B")[tria_vertex_ids[j]-1];
     3118//                                              for(j=0;j<NUMVERTICES;j++)cmmininputs[j]=iomodel->Data("md.inversion.min_parameters")[(tria_vertex_ids[j]-1)*num_control_type+i];
     3119//                                              for(j=0;j<NUMVERTICES;j++)cmmaxinputs[j]=iomodel->Data("md.inversion.max_parameters")[(tria_vertex_ids[j]-1)*num_control_type+i];
     3120//                                              this->inputs->AddInput(new ControlInput(MaterialsRheologyBbarEnum,TriaInputEnum,nodeinputs,cmmininputs,cmmaxinputs,P1Enum,i+1));
     3121//                                      }
     3122//                                      break;
     3123//                              case DamageDbarEnum:
     3124//                                      if(iomodel->Data("md.damage.D")){
     3125//                                              for(j=0;j<NUMVERTICES;j++) nodeinputs[j]=iomodel->Data("md.damage.D")[tria_vertex_ids[j]-1];
     3126//                                              for(j=0;j<NUMVERTICES;j++)cmmininputs[j]=iomodel->Data("md.inversion.min_parameters")[(tria_vertex_ids[j]-1)*num_control_type+i];
     3127//                                              for(j=0;j<NUMVERTICES;j++)cmmaxinputs[j]=iomodel->Data("md.inversion.max_parameters")[(tria_vertex_ids[j]-1)*num_control_type+i];
     3128//                                              this->inputs->AddInput(new ControlInput(DamageDbarEnum,TriaInputEnum,nodeinputs,cmmininputs,cmmaxinputs,P1Enum,i+1));
     3129//                                      }
     3130//                                      break;
     3131//                              default:
     3132//                                      _error_("Control " << EnumToStringx(control) << " not implemented yet");
     3133//                      }
     3134//              }
     3135//              for(i=0;i<num_control_type;i++) xDelete<char>(controls[i]);
     3136//              xDelete<char*>(controls);
     3137//      }
     3138//
     3139//      /*DatasetInputs*/
     3140//      if (control_analysis && iomodel->Data("md.inversion.cost_functions_coefficients")){
     3141//
     3142//              /*Generate cost functions associated with the iomodel*/
     3143//              char**   cost_functions       = NULL;
     3144//              int*     cost_functions_enums = NULL;
     3145//              int      num_cost_functions;
     3146//
     3147//              iomodel->FindConstant(&num_cost_functions,"md.inversion.num_cost_functions");
     3148//              iomodel->FindConstant(&cost_functions,&num_cost_functions,"md.inversion.cost_functions");
     3149//              if(num_cost_functions<1) _error_("No cost functions found");
     3150//              cost_functions_enums=xNew<int>(num_cost_functions);
     3151//              for(j=0;j<num_cost_functions;j++){ cost_functions_enums[j]=StringToEnumx(cost_functions[j]); }
     3152//
     3153//              /*Create inputs and add to DataSetInput*/
     3154//              DatasetInput* datasetinput=new DatasetInput(InversionCostFunctionsCoefficientsEnum);
     3155//              for(i=0;i<num_responses;i++){
     3156//                      for(j=0;j<3;j++)nodeinputs[j]=iomodel->Data("md.inversion.cost_functions_coefficients")[(tria_vertex_ids[j]-1)*num_responses+i];
     3157//                      datasetinput->AddInput(new TriaInput(InversionCostFunctionsCoefficientsEnum,nodeinputs,P1Enum),cost_functions_enums[i]);
     3158//              }
     3159//
     3160//              /*Add datasetinput to element inputs*/
     3161//              this->inputs->AddInput(datasetinput);
     3162//
     3163//              /*Clean up cost functions*/
     3164//              xDelete<int>(cost_functions_enums);
     3165//              for(int j=0;j<num_cost_functions;j++) xDelete<char>(cost_functions[j]);
     3166//              xDelete<char*>(cost_functions);
     3167//      }
    28743168}
    28753169/*}}}*/
    … …  
    28943188
    28953189        /*Add input to the element: */
    2896         this->inputs->AddInput(new TriaInput(enum_type,values,this->element_type));
     3190        this->AddInput2(enum_type,values,this->element_type);
    28973191
    28983192        /*Free ressources:*/
    … …  
    29083202        int         numnodes;
    29093203        IssmDouble  value;
     3204        int         lidlist[NUMVERTICES];
    29103205        int        *doflist = NULL;
    29113206        IssmDouble *values  = NULL;
     3207
     3208        GetVerticesLidList(&lidlist[0]);
    29123209
    29133210        switch(type){
    … …  
    29203217                        }
    29213218                        /*update input*/
    2922                         this->inputs->AddInput(new TriaInput(name,values,P1Enum));
     3219                        inputs2->SetTriaInput(name,P1Enum,NUMVERTICES,lidlist,values);
    29233220                        break;
    29243221
    … …  
    29313228                        }
    29323229                        /*update input*/
    2933                         this->inputs->AddInput(new TriaInput(name,values,P1Enum));
     3230                        inputs2->SetTriaInput(name,P1Enum,NUMVERTICES,lidlist,values);
    29343231                        break;
    29353232
    … …  
    29423239                        }
    29433240                        /*update input*/
    2944                         this->inputs->AddInput(new TriaInput(name,values,P1Enum));
     3241                        inputs2->SetTriaInput(name,P1Enum,NUMVERTICES,lidlist,values);
    29453242                        break;
    29463243
    … …  
    29563253                                if(xIsInf<IssmDouble>(values[i])) _error_("Inf found in vector");
    29573254                        }
    2958                         this->inputs->AddInput(new TriaInput(name,values,this->element_type));
     3255                        //this->inputs->AddInput(new TriaInput(name,values,this->element_type));
     3256                        _error_("not implemented");
    29593257                        break;
    29603258
    … …  
    29693267                                if(xIsInf<IssmDouble>(values[i])) _error_("Inf found in vector");
    29703268                        }
    2971                         this->inputs->AddInput(new TriaInput(name,values,this->element_type));
     3269                        //this->inputs->AddInput(new TriaInput(name,values,this->element_type));
     3270                        _error_("not implemented");
    29723271                        break;
    29733272
    … …  
    29773276                        if(xIsInf<IssmDouble>(value)) _error_("Inf found in vector");
    29783277                        /*update input*/
    2979                         this->inputs->AddInput(new DoubleInput(name,value));
     3278                        //this->inputs->AddInput(new DoubleInput(name,value));
     3279                        //inputs2->SetTriaInput(name,P1Enum,NUMVERTICES,lidlist,values);
     3280                        _error_("not implemented");
    29803281                        break;
    29813282
    … …  
    30433344}
    30443345/*}}}*/
    3045 bool       Tria::IsOnBase(){/*{{{*/
    3046 
    3047         int domaintype;
    3048         this->parameters->FindParam(&domaintype,DomainTypeEnum);
    3049         switch(domaintype){
    3050                 case Domain2DverticalEnum:
    3051                         return HasEdgeOnBase();
    3052                 case Domain2DhorizontalEnum:
    3053                         return true;
    3054                 default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
    3055         }
    3056 }
    3057 /*}}}*/
    3058 bool       Tria::IsOnSurface(){/*{{{*/
    3059 
    3060         int domaintype;
    3061         this->parameters->FindParam(&domaintype,DomainTypeEnum);
    3062         switch(domaintype){
    3063                 case Domain2DverticalEnum:
    3064                         return HasEdgeOnSurface();
    3065                 case Domain2DhorizontalEnum:
    3066                         return true;
    3067                 default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
    3068         }
    3069 }
    3070 /*}}}*/
    30713346bool       Tria::IsZeroLevelset(int levelset_enum){/*{{{*/
    30723347
    … …  
    31203395        /*intermediary: */
    31213396        IssmDouble* values=NULL;
    3122         Input*      thickness_input=NULL;
     3397        Input2*     thickness_input=NULL;
    31233398        IssmDouble  thickness;
    31243399        IssmDouble  weight;
    … …  
    31383413
    31393414        /*Retrieve inputs required:*/
    3140         thickness_input=this->GetInput(ThicknessEnum); _assert_(thickness_input);
     3415        thickness_input=this->GetInput2(ThicknessEnum); _assert_(thickness_input);
    31413416
    31423417        /*Retrieve material parameters: */
    … …  
    32003475        /*Get velocity and thickness*/
    32013476        this->parameters->FindParam(&domaintype,DomainTypeEnum);
    3202         Input* thickness_input=inputs->GetInput(ThicknessEnum); _assert_(thickness_input);
    3203         Input* vx_input=NULL;
    3204         Input* vy_input=NULL;
     3477        Input2* thickness_input=this->GetInput2(ThicknessEnum); _assert_(thickness_input);
     3478        Input2* vx_input=NULL;
     3479        Input2* vy_input=NULL;
    32053480        if(domaintype==Domain2DhorizontalEnum){
    3206                 vx_input=inputs->GetInput(VxEnum); _assert_(vx_input);
    3207                 vy_input=inputs->GetInput(VyEnum); _assert_(vy_input);
     3481                vx_input=this->GetInput2(VxEnum); _assert_(vx_input);
     3482                vy_input=this->GetInput2(VyEnum); _assert_(vy_input);
    32083483        }
    32093484        else{
    3210                 vx_input=inputs->GetInput(VxAverageEnum); _assert_(vx_input);
    3211                 vy_input=inputs->GetInput(VyAverageEnum); _assert_(vy_input);
     3485                vx_input=this->GetInput2(VxAverageEnum); _assert_(vx_input);
     3486                vy_input=this->GetInput2(VyAverageEnum); _assert_(vy_input);
    32123487        }
    32133488
    … …  
    32483523        /*Retrieve all inputs we will be needing: */
    32493524        ::GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
    3250         Input* model_input=inputs->GetInput(modelenum);   _assert_(model_input);
    3251         Input* observation_input=inputs->GetInput(observationenum);_assert_(observation_input);
    3252         Input* weights_input     =inputs->GetInput(weightsenum);     _assert_(weights_input);
     3525        Input2* model_input=this->GetInput2(modelenum);   _assert_(model_input);
     3526        Input2* observation_input=this->GetInput2(observationenum);_assert_(observation_input);
     3527        Input2* weights_input     =this->GetInput2(weightsenum);     _assert_(weights_input);
    32533528
    32543529        /* Start  looping on the number of gaussian points: */
    … …  
    32893564        /*Retrieve all inputs we will be needing: */
    32903565        ::GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
    3291         Input* weights_input     =inputs->GetInput(weightsenum);     _assert_(weights_input);
     3566        Input2* weights_input     =this->GetInput2(weightsenum);     _assert_(weights_input);
    32923567
    32933568        /* Start  looping on the number of gaussian points: */
    … …  
    34253700        int         found = 0;
    34263701        IssmDouble  value;
    3427         Input      *data  = NULL;
    34283702        GaussTria  *gauss = NULL;
    34293703
    34303704        /*First, serarch the input: */
    3431         data=inputs->GetInput(natureofdataenum);
     3705        Input2* data=this->GetInput2(natureofdataenum);
    34323706
    34333707        /*figure out if we have the vertex id: */
    … …  
    35943868
    35953869        /*For FS only: we want the CS to be tangential to the bedrock*/
    3596         inputs->GetInputValue(&approximation,ApproximationEnum);
     3870        this->GetInput2Value(&approximation,ApproximationEnum);
    35973871        if(!HasNodeOnBase() ||  approximation!=FSApproximationEnum) return;
    35983872
    35993873        /*Get inputs*/
    3600         Input* slope_input=inputs->GetInput(BedSlopeXEnum);                             _assert_(slope_input);
    3601         Input* groundedicelevelset_input=inputs->GetInput(MaskGroundediceLevelsetEnum); _assert_(groundedicelevelset_input);
     3874        Input2* slope_input=this->GetInput2(BedSlopeXEnum);                             _assert_(slope_input);
     3875        Input2* groundedicelevelset_input=this->GetInput2(MaskGroundediceLevelsetEnum); _assert_(groundedicelevelset_input);
    36023876        vertexonbase = xNew<IssmDouble>(numnodes);
    36033877        this->GetInputListOnNodesVelocity(&vertexonbase[0],MeshVertexonbaseEnum);
    … …  
    36653939
    36663940        /*Get inputs*/
    3667         Input* bed_input = this->GetInput(BedEnum);                     _assert_(bed_input);
    3668         Input* qsg_input = this->GetInput(FrontalForcingsSubglacialDischargeEnum);               _assert_(qsg_input);
    3669         Input* TF_input  = this->GetInput(FrontalForcingsThermalForcingEnum);          _assert_(TF_input);
     3941        Input2* bed_input = this->GetInput2(BedEnum);                     _assert_(bed_input);
     3942        Input2* qsg_input = this->GetInput2(FrontalForcingsSubglacialDischargeEnum);             _assert_(qsg_input);
     3943        Input2* TF_input  = this->GetInput2(FrontalForcingsThermalForcingEnum);          _assert_(TF_input);
    36703944        GetInputListOnVertices(&basinid[0],FrontalForcingsBasinIdEnum);
    36713945
    … …  
    37103984
    37113985        IssmDouble  values[NUMVERTICES];
     3986        int         lidlist[NUMVERTICES];
    37123987        int         idlist[NUMVERTICES],control_init;
    37133988
    … …  
    37324007        if(!IsInputEnum(control_enum)) return;
    37334008
    3734         Input* input     = (Input*)this->inputs->GetInput(control_enum);   _assert_(input);
    3735         if(input->ObjectEnum()!=ControlInputEnum){
    3736                 _error_("input " << EnumToStringx(control_enum) << " is not a ControlInput");
    3737         }
    3738 
    3739         ControlInput* controlinput = xDynamicCast<ControlInput*>(input);
    3740         input = controlinput->values;
     4009        this->GetVerticesLidList(&lidlist[0]);
     4010        ElementInput2* input=this->inputs2->GetControlInput2Data(control_enum,"value");   _assert_(input);
    37414011
    37424012        /*Get values on vertices*/
    … …  
    37464016                        values[i]=vector[idlist[i]];
    37474017                }
    3748                 if(input->ObjectEnum()==TriaInputEnum){
    3749                         Input* new_input = new TriaInput(control_enum,values,P1Enum);
    3750                         controlinput->SetInput(new_input);
    3751                 }
    3752                 else if(input->ObjectEnum()==TransientInputEnum){
    3753                         Input* new_input = new TriaInput(control_enum,values,P1Enum);
    3754                         controlinput->SetInput(new_input,n);
    3755                         controlinput->Configure(parameters);
     4018                if(input->ObjectEnum()==TriaInput2Enum){
     4019                        input->SetInput(P1Enum,NUMVERTICES,&lidlist[0],&values[0]);
     4020                }
     4021                else if(input->ObjectEnum()==TransientInput2Enum){
     4022                        _error_("not implemented");
     4023                        //Input* new_input = new TriaInput(control_enum,values,P1Enum);
     4024                        //controlinput->SetInput(new_input,n);
     4025                        //controlinput->Configure(parameters);
    37564026                }
    37574027                else _error_("Type not supported");
    … …  
    37624032
    37634033        IssmDouble  values[NUMVERTICES];
    3764         int         vertexpidlist[NUMVERTICES],control_init;
     4034        int         idlist[NUMVERTICES];
     4035        int         lidlist[NUMVERTICES];
    37654036
    37664037        /*Get Domain type*/
    … …  
    37694040
    37704041        /*Specific case for depth averaged quantities*/
    3771         control_init=control_enum;
    37724042        if(domaintype==Domain2DverticalEnum){
    37734043                if(control_enum==MaterialsRheologyBbarEnum){
    … …  
    37844054        if(!IsInputEnum(control_enum)) return;
    37854055
    3786         /*hrepare index list*/
    3787         GradientIndexing(&vertexpidlist[0],control_index);
     4056        /*prepare index list*/
     4057        this->GetVerticesLidList(&lidlist[0]);
     4058        GradientIndexing(&idlist[0],control_index);
    37884059
    37894060        /*Get values on vertices*/
    37904061        for(int i=0;i<NUMVERTICES;i++){
    3791                 values[i]=vector[vertexpidlist[i]];
    3792         }
    3793         Input* new_input = new TriaInput(control_enum,values,P1Enum);
    3794         Input* input     = (Input*)this->inputs->GetInput(control_enum);   _assert_(input);
    3795         if(input->ObjectEnum()!=ControlInputEnum){
    3796                 _error_("input " << EnumToStringx(control_enum) << " is not a ControlInput");
    3797         }
    3798 
    3799         ((ControlInput*)input)->SetInput(new_input);
     4062                values[i]=vector[idlist[i]];
     4063        }
     4064
     4065        /*Set Input*/
     4066        ElementInput2* input=this->inputs2->GetControlInput2Data(control_enum,"value");   _assert_(input);
     4067        input->SetInput(P1Enum,NUMVERTICES,&lidlist[0],&values[0]);
    38004068}
    38014069/*}}}*/
    … …  
    38134081                this->nodes=(Node**)this->hnodes[analysis_counter]->deliverp();
    38144082        }
     4083
     4084}
     4085/*}}}*/
     4086void       Tria::SetElementInput(int enum_in,IssmDouble value){/*{{{*/
     4087
     4088        this->SetElementInput(this->inputs2,enum_in,value);
     4089
     4090}
     4091/*}}}*/
     4092void       Tria::SetElementInput(Inputs2* inputs2,int enum_in,IssmDouble value){/*{{{*/
     4093
     4094        _assert_(inputs2);
     4095        inputs2->SetTriaInput(enum_in,P0Enum,this->lid,value);
     4096
     4097}
     4098/*}}}*/
     4099void       Tria::SetElementInput(Inputs2* inputs2,int numindices,int* indices,IssmDouble* values,int enum_in){/*{{{*/
     4100
     4101        _assert_(inputs2);
     4102        inputs2->SetTriaInput(enum_in,P1Enum,numindices,indices,values);
    38154103
    38164104}
    … …  
    38444132        Seg* seg=new Seg();
    38454133        seg->id=this->id;
    3846         seg->inputs=(Inputs*)this->inputs->SpawnSegInputs(index1,index2);
     4134        seg->inputs=NULL;//(Inputs*)this->inputs->SpawnSegInputs(index1,index2);
     4135        seg->inputs2=this->inputs2;
    38474136        seg->parameters=this->parameters;
    38484137        seg->element_type=P1Enum; //Only P1 CG for now (TO BE CHANGED)
    38494138        this->SpawnSegHook(xDynamicCast<ElementHook*>(seg),index1,index2);
     4139
     4140        seg->iscollapsed = 1;
     4141        seg->collapsed_ids[0] = index1;
     4142        seg->collapsed_ids[1] = index2;
    38504143
    38514144        /*Spawn material*/
    … …  
    38934186
    38944187        /*Retrieve all inputs we will need*/
    3895         Input* vx_input=inputs->GetInput(VxEnum);                                  _assert_(vx_input);
    3896         Input* vy_input=inputs->GetInput(VyEnum);                                  _assert_(vy_input);
     4188        Input2* vx_input=this->GetInput2(VxEnum);                                  _assert_(vx_input);
     4189        Input2* vy_input=this->GetInput2(VyEnum);                                  _assert_(vy_input);
    38974190
    38984191        /* Start looping on the number of vertices: */
    … …  
    39174210
    39184211        /*Add input*/
    3919         this->inputs->AddInput(new TriaInput(StrainRateparallelEnum,&strainparallel[0],P1Enum));
     4212        this->AddInput2(StrainRateparallelEnum,&strainparallel[0],P1DGEnum);
    39204213
    39214214        /*Clean up and return*/
    … …  
    39394232
    39404233        /*Retrieve all inputs we will need*/
    3941         Input* vx_input=inputs->GetInput(VxEnum);                                  _assert_(vx_input);
    3942         Input* vy_input=inputs->GetInput(VyEnum);                                  _assert_(vy_input);
     4234        Input2* vx_input=this->GetInput2(VxEnum);                                  _assert_(vx_input);
     4235        Input2* vy_input=this->GetInput2(VyEnum);                                  _assert_(vy_input);
    39434236
    39444237        /* Start looping on the number of vertices: */
    … …  
    39634256
    39644257        /*Add input*/
    3965         this->inputs->AddInput(new TriaInput(StrainRateperpendicularEnum,&strainperpendicular[0],P1Enum));
     4258        this->AddInput2(StrainRateperpendicularEnum,&strainperpendicular[0],P1DGEnum);
    39664259
    39674260        /*Clean up and return*/
    … …  
    40044297
    40054298        /*intermediary: */
    4006         int    i;
    4007         IssmDouble C,dt;
    4008         IssmDouble dx,dy;
    4009         IssmDouble maxx,minx;
    4010         IssmDouble maxy,miny;
    4011         IssmDouble maxabsvx,maxabsvy;
     4299        IssmDouble C;
    40124300        IssmDouble xyz_list[NUMVERTICES][3];
    40134301
    … …  
    40164304
    40174305        /*Get for Vx and Vy, the max of abs value: */
    4018         maxabsvx = this->inputs->MaxAbs(VxEnum);
    4019         maxabsvy = this->inputs->MaxAbs(VyEnum);
     4306        Input2* vx_input = this->GetInput2(VxEnum); _assert_(vx_input);
     4307        Input2* vy_input = this->GetInput2(VyEnum); _assert_(vy_input);
     4308        IssmDouble maxabsvx = vx_input->GetInputMaxAbs();
     4309        IssmDouble maxabsvy = vy_input->GetInputMaxAbs();
    40204310
    40214311        /* Get node coordinates and dof list: */
    40224312        ::GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
    40234313
    4024         minx=xyz_list[0][0];
    4025         maxx=xyz_list[0][0];
    4026         miny=xyz_list[0][1];
    4027         maxy=xyz_list[0][1];
    4028 
    4029         for(i=1;i<NUMVERTICES;i++){
    4030                 if (xyz_list[i][0]<minx)minx=xyz_list[i][0];
    4031                 if (xyz_list[i][0]>maxx)maxx=xyz_list[i][0];
    4032                 if (xyz_list[i][1]<miny)miny=xyz_list[i][1];
    4033                 if (xyz_list[i][1]>maxy)maxy=xyz_list[i][1];
    4034         }
    4035         dx=maxx-minx;
    4036         dy=maxy-miny;
     4314        IssmDouble minx=xyz_list[0][0];
     4315        IssmDouble maxx=xyz_list[0][0];
     4316        IssmDouble miny=xyz_list[0][1];
     4317        IssmDouble maxy=xyz_list[0][1];
     4318
     4319        for(int i=1;i<NUMVERTICES;i++){
     4320                if(xyz_list[i][0]<minx) minx=xyz_list[i][0];
     4321                if(xyz_list[i][0]>maxx) maxx=xyz_list[i][0];
     4322                if(xyz_list[i][1]<miny) miny=xyz_list[i][1];
     4323                if(xyz_list[i][1]>maxy) maxy=xyz_list[i][1];
     4324        }
     4325        IssmDouble dx=maxx-minx;
     4326        IssmDouble dy=maxy-miny;
    40374327
    40384328        /*CFL criterion: */
    4039         dt=C/(maxabsvx/dx+maxabsvy/dy);
     4329        IssmDouble dt = C/(maxabsvx/dx+maxabsvy/dy);
    40404330
    40414331        return dt;
    … …  
    41434433        IssmDouble calvingratex,calvingratey,thickness,Jdet;
    41444434        IssmDouble rho_ice=FindParam(MaterialsRhoIceEnum);
    4145         Input* thickness_input=inputs->GetInput(ThicknessEnum); _assert_(thickness_input);
    4146         Input* calvingratex_input=NULL;
    4147         Input* calvingratey_input=NULL;
     4435        Input2* thickness_input=this->GetInput2(ThicknessEnum); _assert_(thickness_input);
     4436        Input2* calvingratex_input=NULL;
     4437        Input2* calvingratey_input=NULL;
    41484438        if(domaintype==Domain2DhorizontalEnum){
    4149                 calvingratex_input=inputs->GetInput(CalvingratexEnum); _assert_(calvingratex_input);
    4150                 calvingratey_input=inputs->GetInput(CalvingrateyEnum); _assert_(calvingratey_input);
     4439                calvingratex_input=this->GetInput2(CalvingratexEnum); _assert_(calvingratex_input);
     4440                calvingratey_input=this->GetInput2(CalvingrateyEnum); _assert_(calvingratey_input);
    41514441        }
    41524442        else{
    4153                 calvingratex_input=inputs->GetInput(CalvingratexAverageEnum); _assert_(calvingratex_input);
    4154                 calvingratey_input=inputs->GetInput(CalvingrateyAverageEnum); _assert_(calvingratey_input);
     4443                calvingratex_input=this->GetInput2(CalvingratexAverageEnum); _assert_(calvingratex_input);
     4444                calvingratey_input=this->GetInput2(CalvingrateyAverageEnum); _assert_(calvingratey_input);
    41554445        }
    41564446
    … …  
    42724562        IssmDouble calvingratex,calvingratey,vx,vy,vel,meltingrate,meltingratex,meltingratey,thickness,Jdet;
    42734563        IssmDouble rho_ice=FindParam(MaterialsRhoIceEnum);
    4274         Input* thickness_input=inputs->GetInput(ThicknessEnum); _assert_(thickness_input);
    4275         Input* calvingratex_input=NULL;
    4276         Input* calvingratey_input=NULL;
    4277         Input* vx_input=NULL;
    4278         Input* vy_input=NULL;
    4279         Input* meltingrate_input=NULL;
     4564        Input2* thickness_input=this->GetInput2(ThicknessEnum); _assert_(thickness_input);
     4565        Input2* calvingratex_input=NULL;
     4566        Input2* calvingratey_input=NULL;
     4567        Input2* vx_input=NULL;
     4568        Input2* vy_input=NULL;
     4569        Input2* meltingrate_input=NULL;
    42804570        if(domaintype==Domain2DhorizontalEnum){
    4281                 calvingratex_input=inputs->GetInput(CalvingratexEnum); _assert_(calvingratex_input);
    4282                 calvingratey_input=inputs->GetInput(CalvingrateyEnum); _assert_(calvingratey_input);
    4283                 vx_input=inputs->GetInput(VxEnum); _assert_(vx_input);
    4284                 vy_input=inputs->GetInput(VyEnum); _assert_(vy_input);
    4285                 meltingrate_input=inputs->GetInput(CalvingMeltingrateEnum); _assert_(meltingrate_input);
     4571                calvingratex_input=this->GetInput2(CalvingratexEnum); _assert_(calvingratex_input);
     4572                calvingratey_input=this->GetInput2(CalvingrateyEnum); _assert_(calvingratey_input);
     4573                vx_input=this->GetInput2(VxEnum); _assert_(vx_input);
     4574                vy_input=this->GetInput2(VyEnum); _assert_(vy_input);
     4575                meltingrate_input=this->GetInput2(CalvingMeltingrateEnum); _assert_(meltingrate_input);
    42864576        }
    42874577        else{
    4288                 calvingratex_input=inputs->GetInput(CalvingratexAverageEnum); _assert_(calvingratex_input);
    4289                 calvingratey_input=inputs->GetInput(CalvingrateyAverageEnum); _assert_(calvingratey_input);
     4578                calvingratex_input=this->GetInput2(CalvingratexAverageEnum); _assert_(calvingratex_input);
     4579                calvingratey_input=this->GetInput2(CalvingrateyAverageEnum); _assert_(calvingratey_input);
    42904580        }
    42914581
    … …  
    43274617        /*Get material parameters :*/
    43284618        rho_ice=FindParam(MaterialsRhoIceEnum);
    4329         Input* floatingmelt_input = this->GetInput(BasalforcingsFloatingiceMeltingRateEnum); _assert_(floatingmelt_input);
    4330         Input* gllevelset_input = this->GetInput(MaskGroundediceLevelsetEnum); _assert_(gllevelset_input);
    4331         Input* scalefactor_input = NULL;
     4619        Input2* floatingmelt_input = this->GetInput2(BasalforcingsFloatingiceMeltingRateEnum); _assert_(floatingmelt_input);
     4620        Input2* gllevelset_input   = this->GetInput2(MaskGroundediceLevelsetEnum); _assert_(gllevelset_input);
     4621        Input2* scalefactor_input = NULL;
    43324622        if(scaled==true){
    4333                 scalefactor_input = this->GetInput(MeshScaleFactorEnum); _assert_(scalefactor_input);
     4623                scalefactor_input = this->GetInput2(MeshScaleFactorEnum); _assert_(scalefactor_input);
    43344624        }
    43354625        ::GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
    … …  
    43724662        /*Get material parameters :*/
    43734663        rho_ice=FindParam(MaterialsRhoIceEnum);
    4374         Input* groundedmelt_input = this->GetInput(BasalforcingsGroundediceMeltingRateEnum); _assert_(groundedmelt_input);
    4375         Input* gllevelset_input = this->GetInput(MaskGroundediceLevelsetEnum); _assert_(gllevelset_input);
    4376         Input* scalefactor_input = NULL;
     4664        Input2* groundedmelt_input = this->GetInput2(BasalforcingsGroundediceMeltingRateEnum); _assert_(groundedmelt_input);
     4665        Input2* gllevelset_input = this->GetInput2(MaskGroundediceLevelsetEnum); _assert_(gllevelset_input);
     4666        Input2* scalefactor_input = NULL;
    43774667        if(scaled==true){
    4378                 scalefactor_input = this->GetInput(MeshScaleFactorEnum); _assert_(scalefactor_input);
     4668                scalefactor_input = this->GetInput2(MeshScaleFactorEnum); _assert_(scalefactor_input);
    43794669        }
    43804670        ::GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
    … …  
    44224712
    44234713        /*Now get the average SMB over the element*/
    4424         Input* smb_input = inputs->GetInput(SmbMassBalanceEnum); _assert_(smb_input);
     4714        Input2* smb_input = this->GetInput2(SmbMassBalanceEnum); _assert_(smb_input);
    44254715        smb_input->GetInputAverage(&smb);       // average smb on element in m ice s-1
    44264716        if(scaled==true){
    4427                 Input* scalefactor_input = inputs->GetInput(MeshScaleFactorEnum); _assert_(scalefactor_input);
     4717                Input2* scalefactor_input = this->GetInput2(MeshScaleFactorEnum); _assert_(scalefactor_input);
    44284718                scalefactor_input->GetInputAverage(&scalefactor);// average scalefactor on element
    44294719        }
    … …  
    44374727}
    44384728/*}}}*/
    4439 void       Tria::Update(int index, IoModel* iomodel,int analysis_counter,int analysis_type,int finiteelement_type){/*{{{*/
     4729void       Tria::Update(Inputs2* inputs2,int index, IoModel* iomodel,int analysis_counter,int analysis_type,int finiteelement_type){/*{{{*/
    44404730
    44414731        /*Intermediaries*/
    … …  
    45814871        this->SetHookNodes(tria_node_ids,numnodes,analysis_counter); this->nodes=NULL;
    45824872        xDelete<int>(tria_node_ids);
    4583 
    4584         /*Fill with IoModel*/
    4585         this->InputUpdateFromIoModel(index,iomodel);
    45864873}
    45874874/*}}}*/
    … …  
    45944881
    45954882        this->parameters->FindParam(&extrusioninput,InputToExtrudeEnum);
    4596         Input* input = inputs->GetInput(extrusioninput);      _assert_(input);
    4597         Input* onbase = inputs->GetInput(MeshVertexonbaseEnum); _assert_(onbase);
     4883        Input2* input = this->GetInput2(extrusioninput);      _assert_(input);
     4884        Input2* onbase = this->GetInput2(MeshVertexonbaseEnum); _assert_(onbase);
    45984885
    45994886        GaussTria* gauss=new GaussTria();
    … …  
    46184905
    46194906        this->parameters->FindParam(&extrusioninput,InputToExtrudeEnum);
    4620         Input* input = inputs->GetInput(extrusioninput); _assert_(input);
    4621         Input* onsurf = inputs->GetInput(MeshVertexonsurfaceEnum); _assert_(onsurf);
     4907        Input2* input = this->GetInput2(extrusioninput); _assert_(input);
     4908        Input2* onsurf = this->GetInput2(MeshVertexonsurfaceEnum); _assert_(onsurf);
    46224909
    46234910        GaussTria* gauss=new GaussTria();
    … …  
    47515038        IssmDouble  currenttime;
    47525039        int         numtimes;
    4753         Input* thickness_input=NULL;
     5040        Input2* thickness_input=NULL;
    47545041
    47555042        /*gia solution parameters:*/
    … …  
    47615048        IssmDouble mantle_shear_modulus;
    47625049        IssmDouble mantle_density;
    4763         Input* mantle_viscosity_input=NULL;
     5050        Input2* mantle_viscosity_input=NULL;
    47645051        IssmDouble mantle_viscosity;
    4765         Input* lithosphere_thickness_input=NULL;
     5052        Input2* lithosphere_thickness_input=NULL;
    47665053        IssmDouble lithosphere_thickness;
    47675054
    … …  
    47975084
    47985085        /*pull thickness averages: */
    4799         thickness_input=inputs->GetInput(ThicknessEnum);
     5086        thickness_input=this->GetInput2(ThicknessEnum);
    48005087        if (!thickness_input)_error_("thickness input needed to compute gia deflection!");
    48015088        thickness_input->GetInputAveragesUpToCurrentTime(&hes,&times,&numtimes,currenttime);
    48025089
    48035090        /*recover mantle viscosity: */
    4804         mantle_viscosity_input=inputs->GetInput(GiaMantleViscosityEnum);
     5091        mantle_viscosity_input=this->GetInput2(GiaMantleViscosityEnum);
    48055092        if (!mantle_viscosity_input)_error_("mantle viscosity input needed to compute gia deflection!");
    48065093        mantle_viscosity_input->GetInputAverage(&mantle_viscosity);
    48075094
    48085095        /*recover lithosphere thickness: */
    4809         lithosphere_thickness_input=inputs->GetInput(GiaLithosphereThicknessEnum);
     5096        lithosphere_thickness_input=this->GetInput2(GiaLithosphereThicknessEnum);
    48105097        if (!lithosphere_thickness_input)_error_("lithosphere thickness input needed to compute gia deflection!");
    48115098        lithosphere_thickness_input->GetInputAverage(&lithosphere_thickness);
    … …  
    48915178
    48925179        /*Compute ice thickness change: */
    4893         Input*  deltathickness_input=inputs->GetInput(EsaDeltathicknessEnum);
     5180        Input2* deltathickness_input=this->GetInput2(EsaDeltathicknessEnum);
    48945181        if (!deltathickness_input)_error_("delta thickness input needed to compute elastic adjustment!");
    48955182        deltathickness_input->GetInputAverage(&I);
    … …  
    50295316
    50305317        /*Compute ice thickness change: */
    5031         Input*  deltathickness_input=inputs->GetInput(EsaDeltathicknessEnum);
     5318        Input2* deltathickness_input=this->GetInput2(EsaDeltathicknessEnum);
    50325319        if (!deltathickness_input)_error_("delta thickness input needed to compute elastic adjustment!");
    50335320        deltathickness_input->GetInputAverage(&I);
    … …  
    52635550
    52645551                /*Compute ice thickness change: */
    5265                 Input*  deltathickness_input=inputs->GetInput(SealevelriseDeltathicknessEnum);
     5552                Input2* deltathickness_input=this->GetInput2(SealevelriseDeltathicknessEnum);
    52665553                if (!deltathickness_input)_error_("delta thickness input needed to compute sea level rise!");
    52675554                deltathickness_input->GetInputAverage(&I);
    … …  
    53985685
    53995686        /*Compute ice thickness change: */
    5400         Input*  deltathickness_input=inputs->GetInput(SealevelriseDeltathicknessEnum);
     5687        Input2* deltathickness_input=this->GetInput2(SealevelriseDeltathicknessEnum);
    54015688        if (!deltathickness_input)_error_("delta thickness input needed to compute sea level rise!");
    54025689
    … …  
    57406027
    57416028        /*Compute ice thickness change: */
    5742         Input*  deltathickness_input=inputs->GetInput(SealevelriseDeltathicknessEnum);
     6029        Input2* deltathickness_input=this->GetInput2(SealevelriseDeltathicknessEnum);
    57436030        if (!deltathickness_input)_error_("delta thickness input needed to compute sea level rise!");
    57446031        deltathickness_input->GetInputAverage(&I);
    … …  
    58336120void       Tria::InputUpdateFromMatrixDakota(IssmDouble* matrix, int nrows, int ncols, int name, int type){/*{{{*/
    58346121
    5835         int             i,t,row;
    5836         IssmDouble      time;
    5837         TransientInput *transientinput = NULL;
    5838         IssmDouble      values[3];
    5839         IssmDouble      value;
    5840 
    58416122        /*Check that name is an element input*/
    58426123        if(!IsInputEnum(name)) _error_("Enum "<<EnumToStringx(name)<<" is not in IsInput");
     6124        TransientInput2* transientinput = inputs2->GetTransientInput(name);
    58436125
    58446126        switch(type){
    58456127
    58466128                case VertexEnum:
     6129
     6130                        /*Get LID lists once for all*/
     6131                        IssmDouble  values[NUMVERTICES];
     6132                        int         lidlist[NUMVERTICES];
     6133                        this->GetVerticesLidList(&lidlist[0]);
     6134
    58476135                        /*Create transient input: */
    5848                         for(t=0;t<ncols;t++){ //ncols is the number of times
    5849 
    5850                                 /*create input values: */
    5851                                 for(i=0;i<3;i++){
    5852                                         row=this->vertices[i]->Sid();
     6136                        for(int t=0;t<ncols;t++){ //ncols is the number of times
     6137                                for(int i=0;i<3;i++){
     6138                                        int row=this->vertices[i]->Sid();
    58536139                                        values[i]=matrix[ncols*row+t];
    58546140                                }
    58556141
    58566142                                /*time:*/
    5857                                 time=matrix[(nrows-1)*ncols+t];
    5858 
    5859                                 if(t==0) transientinput=new TransientInput(name);
    5860                                 transientinput->AddTimeInput(new TriaInput(name,values,P1Enum),time);
    5861                                 transientinput->Configure(parameters);
     6143                                IssmDouble time=matrix[(nrows-1)*ncols+t];
     6144
     6145                                transientinput->AddTriaTimeInput(t,NUMVERTICES,&lidlist[0],&values[0],P1Enum);
    58626146                        }
    5863                         this->inputs->AddInput(transientinput);
    58646147                        break;
    58656148
    58666149                case ElementEnum:
    58676150                        /*Get value for the element: */
    5868                         for(t=0;t<ncols;t++){ //ncols is the number of times
    5869                                 value=matrix[ncols*(this->Sid())+t];
    5870 
    5871                                 /*time:*/
    5872                                 time=matrix[(nrows-1)*ncols+t];
    5873 
    5874                                 if(t==0) transientinput=new TransientInput(name);
    5875                                 transientinput->AddTimeInput(new TriaInput(name,&value,P0Enum),time);
    5876                                 transientinput->Configure(parameters);
     6151                        for(int t=0;t<ncols;t++){ //ncols is the number of times
     6152                                IssmDouble value=matrix[ncols*(this->Sid())+t];
     6153                                IssmDouble time=matrix[(nrows-1)*ncols+t];
     6154                                transientinput->AddTriaTimeInput(t,1,&(this->lid),&value,P0Enum);
    58776155                        }
    5878                         this->inputs->AddInput(transientinput);
    58796156                        break;
    58806157
    … …  
    58826159                        _error_("type " << type << " (" << EnumToStringx(type) << ") not implemented yet");
    58836160        }
    5884 
    58856161}
    58866162/*}}}*/
    … …  
    59576233
    59586234                                        /*Add new inputs: */
    5959                                         this->inputs->AddInput(new TriaInput(ThicknessEnum,thickness,P1Enum));
    5960                                         this->inputs->AddInput(new TriaInput(BaseEnum,bed,P1Enum));
    5961                                         this->inputs->AddInput(new TriaInput(SurfaceEnum,surface,P1Enum));
     6235                                        this->AddInput2(ThicknessEnum,thickness,P1Enum);
     6236                                        this->AddInput2(BaseEnum,bed,P1Enum);
     6237                                        this->AddInput2(SurfaceEnum,surface,P1Enum);
    59626238
    59636239                                        break;
    59646240                                case MaterialsRheologyBEnum:
    5965                                         this->inputs->AddInput(new TriaInput(MaterialsRheologyBbarEnum,values,P1Enum));
     6241                                        this->AddInput2(MaterialsRheologyBbarEnum,values,P1Enum);
    59666242                                        break;
    59676243                                default:
    5968                                         this->inputs->AddInput(new TriaInput(name,values,P1Enum));
     6244                                        this->AddInput2(name,values,P1Enum);
    59696245                        }
    59706246                        break;
    … …  
    59746250                        /*Get value for the element: */
    59756251                        value=vector[this->Sid()]; //careful, vector of values here is not parallel distributed, but serial distributed (from a serial Dakota core!)
    5976                         this->inputs->AddInput(new TriaInput(name,&value,P0Enum));
     6252                        this->AddInput2(name,&value,P0Enum);
    59776253                        break;
    59786254                default:

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

    r24208 r24335  
    3030
    3131        public:
     32                int iscollapsed;
    3233
    3334                /*Tria constructors, destructors {{{*/
    3435                Tria(){};
    35                 Tria(int tria_id,int tria_sid,IoModel* iomodel,int nummodels);
     36                Tria(int tria_id,int tria_sid,int tria_lid,IoModel* iomodel,int nummodels);
    3637                ~Tria();
    3738                /*}}}*/
    … …  
    6364                void        ComputeStressTensor();
    6465                void        ComputeSurfaceNormalVelocity();
    65                 void        Configure(Elements* elements,Loads* loads,Nodes* nodesin,Vertices* verticesin,Materials* materials,Parameters* parameters);
     66                void        Configure(Elements* elements,Loads* loads,Nodes* nodesin,Vertices* verticesin,Materials* materials,Parameters* parameters,Inputs2* inputs2in);
    6667                void        ControlInputSetGradient(IssmDouble* gradient,int enum_type,int control_index,int offset,int N, int M);
    6768                void        ControlInputSetGradient(IssmDouble* gradient,int enum_type,int control_index);
    … …  
    102103                void        InputDepthAverageAtBase(int enum_type,int average_enum_type);
    103104                void        InputExtrude(int enum_type,int start){_error_("not implemented"); /*For penta only*/};
     105                void        ControlInputExtrude(int enum_type,int start){/*For penta only*/};
    104106                bool            IsFaceOnBoundary(void);
    105107                bool            IsIcefront(void);
    106108                bool        IsNodeOnShelfFromFlags(IssmDouble* flags);
    107                 bool        IsOnBase();
    108                 bool        IsOnSurface();
    109109                bool        IsZeroLevelset(int levelset_enum);
    110110                IssmDouble  Masscon(IssmDouble* levelset);
    … …  
    124124                void        ResetLevelsetFromSegmentlist(IssmDouble* segments,int numsegments);
    125125                void        RignotMeltParameterization();
     126                void        SetElementInput(int enum_in,IssmDouble values);
     127                void        SetElementInput(Inputs2* inputs2,int enum_in,IssmDouble values);
     128                void        SetElementInput(Inputs2* inputs2,int numindices,int* indices,IssmDouble* values,int enum_in);
    126129                void        SetControlInputsFromVector(IssmDouble* vector,int control_enum,int control_index,int offset,int N,int M);
    127130                void        SetControlInputsFromVector(IssmDouble* vector,int control_enum,int control_index);
    … …  
    140143                IssmDouble  TotalGroundedBmb(bool scaled);
    141144                IssmDouble  TotalSmb(bool scaled);
    142                 void        Update(int index, IoModel* iomodel,int analysis_counter,int analysis_type,int finitelement);
     145                void        Update(Inputs2* inputs2,int index, IoModel* iomodel,int analysis_counter,int analysis_type,int finitelement);
    143146                int         UpdatePotentialUngrounding(IssmDouble* vertices_potentially_ungrounding,Vector<IssmDouble>* vec_nodes_on_iceshelf,IssmDouble* nodes_on_iceshelf);
    144147                void        ValueP1DerivativesOnGauss(IssmDouble* dvalue,IssmDouble* values,IssmDouble* xyz_list,Gauss* gauss);
    … …  
    169172                void           AddBasalInput(int input_enum, IssmDouble* values, int interpolation_enum);
    170173                void           AddInput(int input_enum, IssmDouble* values, int interpolation_enum);
    171                 void           AddControlInput(int input_enum, IssmDouble* values,IssmDouble* values_min,IssmDouble* values_max, int interpolation_enum,int id);
    172                 void           DatasetInputCreate(IssmDouble* array,int M,int N,int* individual_enums,int num_inputs,IoModel* iomodel,int input_enum);
     174                void           AddBasalInput2(int input_enum, IssmDouble* values, int interpolation_enum);
     175                void           AddInput2(int input_enum, IssmDouble* values, int interpolation_enum);
     176                void           AddControlInput(int input_enum,Inputs2* inputs2,IoModel* iomodel,IssmDouble* values,IssmDouble* values_min,IssmDouble* values_max, int interpolation_enum,int id);
     177                void           DatasetInputCreate(IssmDouble* array,int M,int N,int* individual_enums,int num_inputs,Inputs2* inputs2,IoModel* iomodel,int input_enum);
    173178                IssmDouble     GetArea(void);
    174179                IssmDouble     GetHorizontalSurfaceArea(void);
    … …  
    178183                void           GetAreaCoordinates(IssmDouble *area_coordinates,IssmDouble* xyz_zero,IssmDouble* xyz_list,int numpoints);
    179184                int            GetElementType(void);
     185                Input2*        GetInput2(int enumtype);
     186                Input2*        GetInput2(int enumtype,IssmDouble time);
     187                DatasetInput2* GetDatasetInput2(int inputenum);
    180188                void           GetInputValue(IssmDouble* pvalue,Node* node,int enumtype);
    181189                void           GetInputValue(IssmDouble* pvalue,Vertex* vertex,int enumtype);
    … …  
    218226                void           UpdateConstraintsExtrudeFromBase(void);
    219227                void           UpdateConstraintsExtrudeFromTop(void);
    220                 void           ViscousHeating(IssmDouble* pphi,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input){_error_("not implemented yet");};
    221228                /*}}}*/
    222229

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

    r24282 r24335  
    1717#include "../shared/Enum/Enum.h"
    1818#include "../analyses/analyses.h"
     19#include "./Inputs2/DatasetInput2.h"
    1920
    2021#if _HAVE_CODIPACK_
    … …  
    161162        /*Save communicator in the parameters dataset: */
    162163        this->parameters->AddObject(new GenericParam<ISSM_MPI_Comm>(incomm,FemModelCommEnum));
    163 
    164164}
    165165/*}}}*/
    … …  
    196196        if(materials)delete materials;
    197197        if(parameters)delete parameters;
     198        if(inputs2)delete inputs2;
    198199        if(results)delete results;
    199200
    … …  
    336337        output->materials=static_cast<Materials*>(this->materials->Copy());
    337338        output->parameters=static_cast<Parameters*>(this->parameters->Copy());
     339        output->inputs2=static_cast<Inputs2*>(this->inputs2->Copy());
    338340        output->results=static_cast<Results*>(this->results->Copy());
    339341        output->vertices=static_cast<Vertices*>(this->vertices->Copy());
    … …  
    354356                SpcNodesx(output->nodes_list[i],output->constraints_list[i],output->parameters);
    355357                NodesDofx(output->nodes_list[i],output->parameters);
    356                 ConfigureObjectsx(output->elements,output->loads_list[i],output->nodes_list[i],output->vertices,output->materials,output->parameters);
     358                ConfigureObjectsx(output->elements,output->loads_list[i],output->nodes_list[i],output->vertices,output->materials,output->parameters,output->inputs2);
    357359        }
    358360
    … …  
    428430
    429431        /*create datasets for all analyses*/
    430         ModelProcessorx(&this->elements,&this->nodes_list,&this->vertices,&this->materials,&this->constraints_list,&this->loads_list,&this->parameters,iomodel,toolkitsoptionsfid,rootpath,this->solution_type,this->nummodels,this->analysis_type_list);
     432        ModelProcessorx(&this->elements,&this->nodes_list,&this->vertices,&this->materials,&this->constraints_list,&this->loads_list,&this->parameters,&this->inputs2,iomodel,toolkitsoptionsfid,rootpath,this->solution_type,this->nummodels,this->analysis_type_list);
    431433
    432434        /*do the post-processing of the datasets to get an FemModel that can actually run analyses: */
    … …  
    437439
    438440                if(VerboseMProcessor()) _printf0_("      configuring element and loads\n");
    439                 ConfigureObjectsx(this->elements,this->loads,this->nodes,this->vertices,this->materials,this->parameters);
     441                ConfigureObjectsx(this->elements,this->loads,this->nodes,this->vertices,this->materials,this->parameters,this->inputs2);
    440442
    441443                if(i==0){
    … …  
    462464                delete this->materials;
    463465                delete this->parameters;
     466                delete this->inputs2;
    464467                if(this->constraints_list && this->nummodels){
    465468                        for(i=0;i<this->nummodels;i++) delete this->constraints_list[i];
    … …  
    481484                this->materials   = new Materials();
    482485                this->parameters  = new Parameters();
     486                this->inputs2     = new Inputs2();
    483487                this->results     = new Results();
    484488                this->nodes       = new Nodes();
    … …  
    496500        this->materials->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    497501        this->parameters->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
     502        this->inputs2->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    498503        this->results->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    499504        this->vertices->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    … …  
    527532                        SpcNodesx(this->nodes_list[i],this->constraints_list[i],this->parameters);
    528533                        NodesDofx(this->nodes_list[i],this->parameters);
    529                         ConfigureObjectsx(this->elements,this->loads_list[i],this->nodes_list[i],this->vertices,this->materials,this->parameters);
     534                        ConfigureObjectsx(this->elements,this->loads_list[i],this->nodes_list[i],this->vertices,this->materials,this->parameters,this->inputs2);
    530535                }
    531536
    … …  
    942947                #endif
    943948                _printf0_("\n");
    944 
    945949        }
    946950}
    … …  
    968972                /* Get node coordinates*/
    969973                element->GetVerticesCoordinates(&xyz_list);
    970                 Input* weights_input                   = element->GetInput(InversionCostFunctionsCoefficientsEnum);   _assert_(weights_input);
    971                 Input* thickness_input                 = element->GetInput(ThicknessEnum); _assert_(thickness_input);
    972                 Input* vx_input                        = element->GetInput(VxEnum);                                  _assert_(vx_input);
    973                 Input* vy_input                        = element->GetInput(VyEnum);                                  _assert_(vy_input);
    974                 Input* surface_mass_balance_input      = element->GetInput(SmbMassBalanceEnum);          _assert_(surface_mass_balance_input);
    975                 Input* groundedice_melting_input       = element->GetInput(BasalforcingsGroundediceMeltingRateEnum); _assert_(groundedice_melting_input);
    976                 Input* dhdt_input                      = element->GetInput(BalancethicknessThickeningRateEnum);      _assert_(dhdt_input);
     974                DatasetInput2* weights_input                   = element->GetDatasetInput2(InversionCostFunctionsCoefficientsEnum);   _assert_(weights_input);
     975                Input2* thickness_input                 = element->GetInput2(ThicknessEnum); _assert_(thickness_input);
     976                Input2* vx_input                        = element->GetInput2(VxEnum);                                  _assert_(vx_input);
     977                Input2* vy_input                        = element->GetInput2(VyEnum);                                  _assert_(vy_input);
     978                Input2* surface_mass_balance_input      = element->GetInput2(SmbMassBalanceEnum);          _assert_(surface_mass_balance_input);
     979                Input2* groundedice_melting_input       = element->GetInput2(BasalforcingsGroundediceMeltingRateEnum); _assert_(groundedice_melting_input);
     980                Input2* dhdt_input                      = element->GetInput2(BalancethicknessThickeningRateEnum);      _assert_(dhdt_input);
    977981
    978982                /* Start  looping on the number of gaussian points: */
    … …  
    15971601
    15981602}/*}}}*/
     1603void FemModel::InputMakeDiscontinuous(int enum_in){/*{{{*/
     1604
     1605        int numvertices  = 6;
     1606        IssmDouble* P1DGlist = xNew<IssmDouble>(numvertices);
     1607
     1608        for(int i=0;i<this->elements->Size();i++){
     1609                Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
     1610                element->GetInputListOnVertices(P1DGlist,enum_in);
     1611                element->AddInput2(DummyEnum,P1DGlist,P1DGEnum);
     1612        }
     1613        xDelete<IssmDouble>(P1DGlist);
     1614
     1615        this->inputs2->ChangeEnum(DummyEnum,enum_in);
     1616        this->inputs2->DeleteInput(DummyEnum);
     1617
     1618}/*}}}*/
    15991619void FemModel::GroundinglineMassFluxx(IssmDouble* pM, bool scaled){/*{{{*/
    16001620
    … …  
    18211841        for(i=0;i<this->elements->Size();i++){
    18221842                Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
    1823                 element_maxvel = element->inputs->Max(VelEnum);
     1843                Input2* vel_input = element->GetInput2(VelEnum); _assert_(vel_input);
     1844                element_maxvel = vel_input->GetInputMax();
    18241845                if(element_maxvel>maxvel) maxvel=element_maxvel;
    18251846        }
    … …  
    18451866        for(i=0;i<this->elements->Size();i++){
    18461867                Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
    1847                 element_maxvx = element->inputs->Max(VxEnum);
     1868                Input2* vx_input = element->GetInput2(VxEnum); _assert_(vx_input);
     1869                element_maxvx = vx_input->GetInputMax();
    18481870                if(element_maxvx>maxvx) maxvx=element_maxvx;
    18491871        }
    … …  
    18691891        for(i=0;i<this->elements->Size();i++){
    18701892                Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
    1871                 element_maxvy = element->inputs->Max(VyEnum);
     1893                Input2* vy_input = element->GetInput2(VyEnum); _assert_(vy_input);
     1894                element_maxvy = vy_input->GetInputMax();
    18721895                if(element_maxvy>maxvy) maxvy=element_maxvy;
    18731896        }
    … …  
    18931916        for(i=0;i<this->elements->Size();i++){
    18941917                Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
    1895                 element_maxvz = element->inputs->Max(VzEnum);
     1918                Input2* vz_input = element->GetInput2(VzEnum); _assert_(vz_input);
     1919                element_maxvz = vz_input->GetInputMax();
    18961920                if(element_maxvz>maxvz) maxvz=element_maxvz;
    18971921        }
    … …  
    20242048
    20252049                /*Retrieve all inputs we will be needing: */
    2026                 Input* weights_input   =element->GetInput(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
    2027                 Input* omega_input =element->GetInput(BalancethicknessOmegaEnum);                   _assert_(omega_input);
     2050                DatasetInput2* weights_input = element->GetDatasetInput2(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
     2051                Input2* omega_input   = element->GetInput2(BalancethicknessOmegaEnum);              _assert_(omega_input);
    20282052
    20292053                /* Start  looping on the number of gaussian points: */
    … …  
    20812105
    20822106                /*Retrieve all inputs we will be needing: */
    2083                 Input* weights_input =element->GetInput(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
    2084                 Input* omega_input   =element->GetInput(BalancethicknessOmegaEnum);              _assert_(omega_input);
    2085                 Input* omega0_input  =element->GetInput(BalancethicknessOmega0Enum);             _assert_(omega0_input);
     2107                DatasetInput2* weights_input =element->GetDatasetInput2(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
     2108                Input2* omega_input   =element->GetInput2(BalancethicknessOmegaEnum);              _assert_(omega_input);
     2109                Input2* omega0_input  =element->GetInput2(BalancethicknessOmega0Enum);             _assert_(omega0_input);
    20862110
    20872111                /* Start  looping on the number of gaussian points: */
    … …  
    23562380                                        default:
    23572381
     2382                                        /*Some preliminary calculation may be required (use similar syntax for other inputs)*/
     2383                                                if(output_enum==NewDamageEnum){
     2384                                                        InputDuplicatex(this,DamageDEnum,DamageDOldEnum);
     2385                                                        InputDuplicatex(this,DamageDbarEnum,DamageDbarOldEnum);
     2386                                                        this->ElementOperationx(&Element::ComputeNewDamage);
     2387                                                }
     2388
    23582389                                                /*Vector layout*/
    23592390                                                if(!IsInputEnum(output_enum)) _error_("Cannot output \""<<EnumToStringx(output_enum)<<"\" because it is not an input");
    … …  
    23662397                                                        Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(j));
    23672398                                                        element->ResultInterpolation(&rank_interpolation,&rank_nodesperelement,&rank_arraysize,output_enum);
    2368                                                         if (rank_arraysize>max_rank_arraysize)max_rank_arraysize=rank_arraysize;
     2399                                                        if(rank_arraysize>max_rank_arraysize)max_rank_arraysize=rank_arraysize;
    23692400                                                }
    2370                                                 rank_arraysize=max_rank_arraysize;
    23712401
    23722402                                                /*Broadcast for cpus that do not have any elements*/
    … …  
    26202650
    26212651                 /*Retrieve all inputs we will be needing: */
    2622                  Input* weights_input   =element->GetInput(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
    2623                  Input* surface_input   =element->GetInput(SurfaceEnum);                            _assert_(surface_input);
    2624                  Input* surfaceobs_input=element->GetInput(InversionSurfaceObsEnum);                _assert_(surfaceobs_input);
     2652                 DatasetInput2* weights_input   =element->GetDatasetInput2(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
     2653                 Input2* surface_input   =element->GetInput2(SurfaceEnum);                            _assert_(surface_input);
     2654                 Input2* surfaceobs_input=element->GetInput2(InversionSurfaceObsEnum);                _assert_(surfaceobs_input);
    26252655
    26262656                 /* Start  looping on the number of gaussian points: */
    … …  
    26762706
    26772707                /*Retrieve all inputs we will be needing: */
    2678                 Input* weights_input   =element->GetInput(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
    2679                 Input* thickness_input =element->GetInput(ThicknessEnum);                          _assert_(thickness_input);
     2708                DatasetInput2* weights_input   =element->GetDatasetInput2(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
     2709                Input2* thickness_input =element->GetInput2(ThicknessEnum);                          _assert_(thickness_input);
    26802710
    26812711                /* Start  looping on the number of gaussian points: */
    … …  
    27322762
    27332763                /*Retrieve all inputs we will be needing: */
    2734                 Input* weights_input   =element->GetInput(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
    2735                 Input* thickness_input =element->GetInput(ThicknessEnum);                          _assert_(thickness_input);
     2764                DatasetInput2* weights_input   =element->GetDatasetInput2(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
     2765                Input2* thickness_input =element->GetInput2(ThicknessEnum);                          _assert_(thickness_input);
    27362766
    27372767                /* Start  looping on the number of gaussian points: */
    … …  
    31043134                }
    31053135
    3106                 ConfigureObjectsx(new_elements,this->loads,new_nodes_list[i],new_vertices,new_materials,this->parameters);
     3136                ConfigureObjectsx(new_elements,this->loads,new_nodes_list[i],new_vertices,new_materials,this->parameters,this->inputs2);
    31073137                SpcNodesx(new_nodes_list[i],new_constraints_list[i],this->parameters);
    31083138                NodesDofx(new_nodes_list[i],this->parameters);
    … …  
    31743204                }
    31753205                /*insert new bedrock*/
    3176                 element->AddInput(BedEnum,&r[0],P1Enum);
     3206                element->AddInput2(BedEnum,&r[0],P1Enum);
    31773207                /*Cleanup*/
    31783208                xDelete<IssmDouble>(xyz_list);
    … …  
    32223252
    32233253                /*Update inputs*/
    3224                 element->AddInput(MaskGroundediceLevelsetEnum,&phi[0],P1Enum);
    3225                 element->AddInput(ThicknessEnum,&h[0],P1Enum);
    3226                 element->AddInput(BaseEnum,&b[0],P1Enum);
     3254                element->AddInput2(MaskGroundediceLevelsetEnum,&phi[0],P1Enum);
     3255                element->AddInput2(ThicknessEnum,&h[0],P1Enum);
     3256                element->AddInput2(BaseEnum,&b[0],P1Enum);
    32273257        }
    32283258
    … …  
    34223452        for(int i=0;i<newfemmodel_elements->Size();i++){//just on the new partition
    34233453                Element* element=xDynamicCast<Element*>(newfemmodel_elements->GetObjectByOffset(i));
     3454                _error_("not supported");
    34243455                /*newP0inputs is just on the new partition*/
    34253456                for(int j=0;j<numP0inputs;j++){
    … …  
    34303461                                        break;
    34313462                                case IntInputEnum:
     3463                                        element->SetIntInput(this->inputs2,P0input_enums[j],reCast<int>(newP0inputs[i*numP0inputs+j]));
    34323464                                        element->AddInput(new IntInput(P0input_enums[j],reCast<int>(newP0inputs[i*numP0inputs+j])));
    34333465                                        break;
    34343466                                case BoolInputEnum:
     3467                                        element->SetBoolInput(this->inputs2,P0input_enums[j],reCast<bool>(newP0inputs[i*numP0inputs+j]));
    34353468                                        element->AddInput(new BoolInput(P0input_enums[j],reCast<bool>(newP0inputs[i*numP0inputs+j])));
    34363469                                        break;
    … …  
    50955128                }
    50965129                else{
     5130                        _error_("not implemented with inputs2");
    50975131                        for(int j=0;j<elements->Size();j++){
    50985132                                /*Intermediaries*/
    … …  
    51335167                                default: _error_("Not implemented yet");
    51345168                                }
    5135                                 stacking_input->Configure(parameters);
    51365169                                xDelete<IssmDouble>(N);
    51375170                        }
    … …  
    51605193                                        transient_input->GetInputAverageOverTimeSlice(&time_averaged[iv],gauss,init_time,end_time);
    51615194                                }
    5162                                 element->AddInput(averagedinput_enum[i],&time_averaged[0],element->GetElementType());
     5195
     5196                                element->AddInput2(averagedinput_enum[i],&time_averaged[0],element->GetElementType());
     5197                                xDelete<IssmDouble>(time_averaged);
    51635198                                delete gauss;
    51645199                                xDelete<IssmDouble>(time_averaged);

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

    r24240 r24335  
    1111class DataSet;
    1212class Parameters;
     13class Inputs2;
    1314class Nodes;
    1415class Vertices;
    … …  
    4344                Materials   *materials;            //one set of materials, for each element
    4445                Parameters  *parameters;           //one set of parameters, independent of the analysis_type
     46                Inputs2     *inputs2;              //one set of inputs, independent of the analysis_type
    4547                Results     *results;              //results that cannot be fit into the elements
    4648                Vertices    *vertices;             //one set of vertices
    … …  
    110112                void IceVolumex(IssmDouble* pV, bool scaled);
    111113                void IceVolumeAboveFloatationx(IssmDouble* pV, bool scaled);
     114                void InputMakeDiscontinuous(int enum_in);
    112115                void MassFluxx(IssmDouble* presponse);
    113116                void MaxAbsVxx(IssmDouble* presponse);

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

    r24106 r24335  
    3131int  Inputs::AddInput(Input* in_input){/*{{{*/
    3232
     33        printf("-------------- file: Inputs.cpp line: %i\n",__LINE__);
    3334        _assert_(in_input);
    3435        int enum_name = in_input->InstanceEnum();
     36        printf("Adding %s to inputs\n",EnumToStringx(enum_name));
    3537        #ifdef _ISSM_DEBUG_
    3638        if(!IsInputEnum(enum_name)) _error_("Enum \""<<EnumToStringx(enum_name)<<"\" is not placed properly in EnumDefinitions.h");
    … …  
    5759/*}}}*/
    5860void  Inputs::ChangeEnum(int oldenumtype,int newenumtype){/*{{{*/
     61        printf("-------------- file: Inputs.cpp line: %i\n",__LINE__);
    5962
    6063        /*Delete input if it already exists*/
    … …  
    9194int  Inputs::DeleteInput(int enum_type){/*{{{*/
    9295
    93         Input* input=this->GetInput(enum_type);
    94         if(input) this->DeleteObject(input);
     96        vector<Object*>::iterator object;
     97        Input* input=NULL;
     98        bool found = false;
     99
     100        for ( object=objects.begin() ; object < objects.end(); object++ ){
     101                input=xDynamicCast<Input*>(*object);
     102                if (input->InstanceEnum()==enum_type){
     103                        found = true;
     104                        break;
     105                }
     106        }
     107        if(found) this->DeleteObject(input);
    95108        return 1;
    96109
    … …  
    98111/*}}}*/
    99112void  Inputs::DuplicateInput(int original_enum,int new_enum){/*{{{*/
     113        printf("-------------- file: Inputs.cpp line: %i\n",__LINE__);
    100114
    101115        /*Make a copy of the original input: */
    … …  
    112126/*}}}*/
    113127Input* Inputs::GetInput(int enum_name){/*{{{*/
     128        printf("-------------- file: Inputs.cpp line: %i\n",__LINE__);
    114129
    115130        vector<Object*>::iterator object;
    … …  
    125140/*}}}*/
    126141void Inputs::GetInputAverage(IssmDouble* pvalue,int enum_type){/*{{{*/
     142        printf("-------------- file: Inputs.cpp line: %i\n",__LINE__);
    127143
    128144        /*Find input in current dataset*/
    … …  
    136152/*}}}*/
    137153void Inputs::GetInputValue(bool* pvalue,int enum_type){/*{{{*/
     154        printf("-------------- file: Inputs.cpp line: %i\n",__LINE__);
    138155
    139156        /*Find input in current dataset*/
    … …  
    147164/*}}}*/
    148165void Inputs::GetInputValue(int* pvalue,int enum_type){/*{{{*/
     166        printf("-------------- file: Inputs.cpp line: %i\n",__LINE__);
    149167
    150168        /*Find input in current dataset*/
    … …  
    157175}/*}}}*/
    158176void Inputs::GetInputValue(IssmDouble* pvalue,int enum_type){/*{{{*/
     177        printf("-------------- file: Inputs.cpp line: %i\n",__LINE__);
    159178
    160179        /*Find input in current dataset*/
    … …  
    167186}/*}}}*/
    168187IssmDouble Inputs::Max(int enumtype){/*{{{*/
     188        printf("-------------- file: Inputs.cpp line: %i\n",__LINE__);
    169189
    170190        /*Find input in current dataset*/
    … …  
    177197}/*}}}*/
    178198IssmDouble Inputs::MaxAbs(int enumtype){/*{{{*/
     199        printf("-------------- file: Inputs.cpp line: %i\n",__LINE__);
    179200
    180201        /*Find input in current dataset*/
    … …  
    187208}/*}}}*/
    188209IssmDouble Inputs::Min(int enumtype){/*{{{*/
     210        printf("-------------- file: Inputs.cpp line: %i\n",__LINE__);
    189211
    190212        /*Find input in current dataset*/
    … …  
    197219}/*}}}*/
    198220IssmDouble Inputs::MinAbs(int enumtype){/*{{{*/
     221        printf("-------------- file: Inputs.cpp line: %i\n",__LINE__);
    199222
    200223        /*Find input in current dataset*/
    … …  
    207230}/*}}}*/
    208231Inputs* Inputs::SpawnSegInputs(int index1,int index2){/*{{{*/
     232        printf("-------------- file: Inputs.cpp line: %i\n",__LINE__);
    209233
    210234        /*Intermediary*/
    … …  
    232256/*}}}*/
    233257Inputs* Inputs::SpawnTriaInputs(int index1,int index2,int index3){/*{{{*/
     258        printf("-------------- file: Inputs.cpp line: %i\n",__LINE__);
    234259
    235260        /*Intermediary*/

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

    r24240 r24335  
    141141        this->my_hedges=NULL;
    142142        this->my_vertices=NULL;
     143        this->my_vertices_lids=NULL;
    143144        this->epart=NULL;
    144145
    … …  
    206207
    207208        /*Initialize permanent data: */
    208         this->my_elements = NULL;
    209         this->my_faces    = NULL;
    210         this->my_vfaces   = NULL;
    211         this->my_edges    = NULL;
    212         this->my_vedges   = NULL;
    213         this->my_hedges   = NULL;
    214         this->my_vertices = NULL;
    215         this->epart       = NULL;
     209        this->my_elements      = NULL;
     210        this->my_faces         = NULL;
     211        this->my_vfaces        = NULL;
     212        this->my_edges         = NULL;
     213        this->my_vedges        = NULL;
     214        this->my_hedges        = NULL;
     215        this->my_vertices      = NULL;
     216        this->my_vertices_lids = NULL;
     217        this->epart            = NULL;
    216218
    217219        FindConstant(&this->domaintype,"md.mesh.domain_type");
    … …  
    264266        xDelete<bool>(this->my_hedges);
    265267        xDelete<bool>(this->my_vertices);
     268        xDelete<int>(this->my_vertices_lids);
    266269        xDelete<int>(this->epart);
    267270
    … …  
    15941597}
    15951598/*}}}*/
    1596 void  IoModel::FetchDataToInput(Elements* elements,const char* vector_name,int input_enum,IssmDouble default_value){/*{{{*/
     1599void  IoModel::FetchDataToInput(Inputs2* inputs2,Elements* elements,const char* vector_name,int input_enum,IssmDouble default_value){/*{{{*/
    15971600
    15981601        /*First, look whether it is not already loaded in this->data*/
    … …  
    16041607                        for(int i=0;i<elements->Size();i++){
    16051608                                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    1606                                 element->InputCreate(iodata->data,this,iodata->M,iodata->N,iodata->layout,input_enum,iodata->code);//we need i to index into elements.
     1609                                element->InputCreate(iodata->data,inputs2,this,iodata->M,iodata->N,iodata->layout,input_enum,iodata->code);//we need i to index into elements.
    16071610                        }
    16081611                        return;
    … …  
    16251628        for(int i=0;i<elements->Size();i++){
    16261629                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    1627                 if(!doublearray) element->AddInput(input_enum,&default_value,P0Enum);
    1628                 else             element->InputCreate(doublearray,this,M,N,vector_layout,input_enum,code);//we need i to index into elements.
     1630                if(!doublearray){
     1631                        element->SetElementInput(inputs2,input_enum,default_value);
     1632                }
     1633                else{
     1634                        element->InputCreate(doublearray,inputs2,this,M,N,vector_layout,input_enum,code);//we need i to index into elements.
     1635                }
    16291636        }
    16301637
    … …  
    16331640}
    16341641/*}}}*/
    1635 void  IoModel::FetchDataToInput(Elements* elements,const char* vector_name,int input_enum){/*{{{*/
     1642void  IoModel::FetchDataToInput(Inputs2* inputs2,Elements* elements,const char* vector_name,int input_enum){/*{{{*/
    16361643
    16371644        /*First, look whether it is not already loaded in this->data*/
    … …  
    16421649                        for(int i=0;i<elements->Size();i++){
    16431650                                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    1644                                 element->InputCreate(iodata->data,this,iodata->M,iodata->N,iodata->layout,input_enum,iodata->code);//we need i to index into elements.
     1651                                element->InputCreate(iodata->data,inputs2,this,iodata->M,iodata->N,iodata->layout,input_enum,iodata->code);//we need i to index into elements.
    16451652                        }
    16461653                        return;
    … …  
    16681675                        for(i=0;i<elements->Size();i++){
    16691676                                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    1670                                 element->InputUpdateFromConstant(boolean,input_enum);
     1677                                element->SetBoolInput(inputs2,input_enum,boolean);
    16711678                        }
    16721679                        break;
    … …  
    16751682                        for(i=0;i<elements->Size();i++){
    16761683                                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    1677                                 element->InputUpdateFromConstant(integer,input_enum);
     1684                                element->SetIntInput(inputs2,input_enum,integer);
    16781685                        }
    16791686                        break;
    … …  
    16821689                        for(i=0;i<elements->Size();i++){
    16831690                                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    1684                                 element->InputUpdateFromConstant(scalar,input_enum);
     1691                                element->SetElementInput(inputs2,input_enum,scalar);
    16851692                        }
    16861693                        break;
    … …  
    16901697                        for(i=0;i<elements->Size();i++){
    16911698                                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    1692                                 element->InputCreate(doublearray,this,M,N,vector_layout,input_enum,code);//we need i to index into elements.
     1699                                element->InputCreate(doublearray,inputs2,this,M,N,vector_layout,input_enum,code);//we need i to index into elements.
    16931700                        }
    16941701                        break;
    … …  
    16981705                        for(i=0;i<elements->Size();i++){
    16991706                                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    1700                                 element->InputCreate(doublearray,this,M,N,vector_layout,input_enum,code);//we need i to index into elements.
     1707                                element->InputCreate(doublearray,inputs2,this,M,N,vector_layout,input_enum,code);//we need i to index into elements.
    17011708                        }
    17021709                        break;
    … …  
    17071714                        for(i=0;i<elements->Size();i++){
    17081715                                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    1709                                 element->InputCreate(doublearray,this,M,N,vector_layout,input_enum,code);//we need i to index into elements.
     1716                                element->InputCreate(doublearray,inputs2,this,M,N,vector_layout,input_enum,code);//we need i to index into elements.
    17101717                        }
    17111718                        break;
    … …  
    25922599        }
    25932600        ISSM_MPI_Bcast(&found,1,ISSM_MPI_INT,0,IssmComm::GetComm());
    2594         if(!found)_error_("could not find data with name \"" << data_name << "\" in binary file");
     2601        if(!found) _error_("could not find data with name \"" << data_name << "\" in binary file");
    25952602
    25962603        /*Broadcast code and vector type: */

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

    r23570 r24335  
    1313class Parameters;
    1414class Elements;
     15class Inputs2;
    1516class Param;
    1617class Option;
    … …  
    7071                bool *my_hedges;
    7172                bool *my_vertices;
     73                int  *my_vertices_lids;
    7274                int  *epart;
    7375
    … …  
    137139                void        FetchData(Options *options,const char* data_name);
    138140                void        FetchData(int num,...);
    139                 void        FetchDataToInput(Elements* elements,const char* vector_name,int input_enum);
    140                 void        FetchDataToInput(Elements* elements,const char* vector_name,int input_enum,IssmDouble default_value);
     141                void        FetchDataToInput(Inputs2* inputs2,Elements* elements,const char* vector_name,int input_enum);
     142                void        FetchDataToInput(Inputs2* inputs2,Elements* elements,const char* vector_name,int input_enum,IssmDouble default_value);
    141143                void        FetchIndependent(const char* dependent_name);
    142144                void        FetchMultipleData(char***   pstringarray,int* pnumstrings,const char* data_name);

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

    r24132 r24335  
    387387        IssmDouble c_t       = element->FindParam(HydrologyPressureMeltCoefficientEnum);
    388388
    389         Input* h_input      = element->GetInput(HydrologySheetThicknessEnum);_assert_(h_input);
    390         Input* H_input      = element->GetInput(ThicknessEnum); _assert_(H_input);
    391         Input* b_input      = element->GetInput(BedEnum); _assert_(b_input);
    392         Input* B_input      = element->GetInput(MaterialsRheologyBEnum);         _assert_(B_input);
    393         Input* n_input      = element->GetInput(MaterialsRheologyNEnum);         _assert_(n_input);
    394         Input* ks_input     = element->GetInput(HydrologySheetConductivityEnum); _assert_(ks_input);
    395         Input* phi_input    = element->GetInput(HydraulicPotentialEnum);         _assert_(phi_input);
     389        Input2* h_input      = element->GetInput2(HydrologySheetThicknessEnum);_assert_(h_input);
     390        Input2* H_input      = element->GetInput2(ThicknessEnum); _assert_(H_input);
     391        Input2* b_input      = element->GetInput2(BedEnum); _assert_(b_input);
     392        Input2* B_input      = element->GetInput2(MaterialsRheologyBEnum);         _assert_(B_input);
     393        Input2* n_input      = element->GetInput2(MaterialsRheologyNEnum);         _assert_(n_input);
     394        Input2* ks_input     = element->GetInput2(HydrologySheetConductivityEnum); _assert_(ks_input);
     395        Input2* phi_input    = element->GetInput2(HydraulicPotentialEnum);         _assert_(phi_input);
    396396
    397397        /*Get tangent vector*/
    … …  
    518518        IssmDouble c_t       = element->FindParam(HydrologyPressureMeltCoefficientEnum);
    519519
    520         Input* h_input      = element->GetInput(HydrologySheetThicknessEnum);_assert_(h_input);
    521         Input* H_input      = element->GetInput(ThicknessEnum); _assert_(H_input);
    522         Input* b_input      = element->GetInput(BedEnum); _assert_(b_input);
    523         Input* B_input      = element->GetInput(MaterialsRheologyBEnum);         _assert_(B_input);
    524         Input* n_input      = element->GetInput(MaterialsRheologyNEnum);         _assert_(n_input);
    525         Input* ks_input     = element->GetInput(HydrologySheetConductivityEnum); _assert_(ks_input);
    526         Input* phi_input    = element->GetInput(HydraulicPotentialEnum);         _assert_(phi_input);
     520        Input2* h_input      = element->GetInput2(HydrologySheetThicknessEnum);_assert_(h_input);
     521        Input2* H_input      = element->GetInput2(ThicknessEnum); _assert_(H_input);
     522        Input2* b_input      = element->GetInput2(BedEnum); _assert_(b_input);
     523        Input2* B_input      = element->GetInput2(MaterialsRheologyBEnum);         _assert_(B_input);
     524        Input2* n_input      = element->GetInput2(MaterialsRheologyNEnum);         _assert_(n_input);
     525        Input2* ks_input     = element->GetInput2(HydrologySheetConductivityEnum); _assert_(ks_input);
     526        Input2* phi_input    = element->GetInput2(HydraulicPotentialEnum);         _assert_(phi_input);
    527527
    528528        /*Get tangent vector*/
    … …  
    630630        IssmDouble dt        = element->FindParam(TimesteppingTimeStepEnum);
    631631
    632         Input* h_input      = element->GetInput(HydrologySheetThicknessEnum);_assert_(h_input);
    633         Input* H_input      = element->GetInput(ThicknessEnum); _assert_(H_input);
    634         Input* b_input      = element->GetInput(BedEnum); _assert_(b_input);
    635         Input* B_input      = element->GetInput(MaterialsRheologyBEnum);         _assert_(B_input);
    636         Input* n_input      = element->GetInput(MaterialsRheologyNEnum);         _assert_(n_input);
    637         Input* ks_input     = element->GetInput(HydrologySheetConductivityEnum); _assert_(ks_input);
    638         Input* phi_input    = element->GetInput(HydraulicPotentialEnum);         _assert_(phi_input);
     632        Input2* h_input      = element->GetInput2(HydrologySheetThicknessEnum);_assert_(h_input);
     633        Input2* H_input      = element->GetInput2(ThicknessEnum); _assert_(H_input);
     634        Input2* b_input      = element->GetInput2(BedEnum); _assert_(b_input);
     635        Input2* B_input      = element->GetInput2(MaterialsRheologyBEnum);         _assert_(B_input);
     636        Input2* n_input      = element->GetInput2(MaterialsRheologyNEnum);         _assert_(n_input);
     637        Input2* ks_input     = element->GetInput2(HydrologySheetConductivityEnum); _assert_(ks_input);
     638        Input2* phi_input    = element->GetInput2(HydraulicPotentialEnum);         _assert_(phi_input);
    639639
    640640        /*Get tangent vector*/

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

    r23897 r24335  
    7474
    7575        /*Recover parameters: */
    76         element->GetInputValue(&q_exp,FrictionQEnum);
    77         element->GetInputValue(&C_param,FrictionCEnum);
     76        element->GetInputValue(&q_exp,gauss,FrictionQEnum);
     77        element->GetInputValue(&C_param,gauss,FrictionCEnum);
    7878        element->GetInputValue(&As,gauss,FrictionAsEnum);
    7979        element->GetInputValue(&n,gauss,MaterialsRheologyNEnum);
    … …  
    142142
    143143        /*Recover parameters: */
    144         element->GetInputValue(&drag_p,FrictionPEnum);
    145         element->GetInputValue(&drag_q,FrictionQEnum);
     144        element->GetInputValue(&drag_p,gauss,FrictionPEnum);
     145        element->GetInputValue(&drag_q,gauss,FrictionQEnum);
    146146        element->GetInputValue(&drag_coefficient, gauss,FrictionCoefficientEnum);
    147147
    … …  
    224224
    225225        /*Recover parameters: */
    226         element->GetInputValue(&drag_p,FrictionPEnum);
    227         element->GetInputValue(&drag_q,FrictionQEnum);
     226        element->GetInputValue(&drag_p,gauss,FrictionPEnum);
     227        element->GetInputValue(&drag_q,gauss,FrictionQEnum);
    228228        element->GetInputValue(&thickness, gauss,ThicknessEnum);
    229229        element->GetInputValue(&base, gauss,BaseEnum);
    … …  
    284284
    285285        /*Recover parameters: */
    286         element->GetInputValue(&q_exp,FrictionQEnum);
    287         element->GetInputValue(&C_param,FrictionCEnum);
     286        element->GetInputValue(&q_exp,gauss,FrictionQEnum);
     287        element->GetInputValue(&C_param,gauss,FrictionCEnum);
    288288        element->GetInputValue(&As,gauss,FrictionAsEnum);
    289289        element->GetInputValue(&n,gauss,MaterialsRheologyNEnum);
    … …  
    424424
    425425        /*Recover parameters: */
    426         element->GetInputValue(&drag_p,FrictionPEnum);
    427         element->GetInputValue(&drag_q,FrictionQEnum);
     426        element->GetInputValue(&drag_p,gauss,FrictionPEnum);
     427        element->GetInputValue(&drag_q,gauss,FrictionQEnum);
    428428        element->GetInputValue(&drag_coefficient, gauss,FrictionCoefficientEnum);
     429        if(element->Id()==1) _printf_(drag_coefficient<<"\n");
    429430
    430431        /*compute r and q coefficients: */
    … …  
    458459        /*Recover parameters: */
    459460        element->parameters->FindParam(&F,FrictionFEnum);
    460         element->GetInputValue(&drag_p,FrictionPEnum);
    461         element->GetInputValue(&drag_q,FrictionQEnum);
     461        element->GetInputValue(&drag_p,gauss,FrictionPEnum);
     462        element->GetInputValue(&drag_q,gauss,FrictionQEnum);
    462463        element->GetInputValue(&thickness, gauss,ThicknessEnum);
    463464        element->GetInputValue(&base, gauss,BaseEnum);

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

    r24089 r24335  
    361361        /*Retrieve all inputs and parameters*/
    362362        GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
    363         Input* flux_input = tria->inputs->GetInput(HydrologyNeumannfluxEnum);  _assert_(flux_input);
     363        Input2* flux_input = tria->GetInput2(HydrologyNeumannfluxEnum);  _assert_(flux_input);
    364364
    365365        /*Check wether it is an inflow or outflow BC (0 is the middle of the segment)*/
    … …  
    405405        /*Retrieve all inputs and parameters*/
    406406        GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
    407         Input* flux_input = tria->inputs->GetInput(HydrologyNeumannfluxEnum);  _assert_(flux_input);
     407        Input2* flux_input = tria->GetInput2(HydrologyNeumannfluxEnum);  _assert_(flux_input);
    408408
    409409        /*Check wether it is an inflow or outflow BC (0 is the middle of the segment)*/

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

    r24131 r24335  
    516516        /*Retrieve all inputs and parameters*/
    517517        GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
    518         Input* vxaverage_input=tria->inputs->GetInput(VxEnum);
    519         Input* vyaverage_input=tria->inputs->GetInput(VyEnum);
     518        Input2* vxaverage_input=tria->GetInput2(VxEnum); _assert_(vxaverage_input);
     519        Input2* vyaverage_input=tria->GetInput2(VyEnum); _assert_(vyaverage_input);
    520520        GetNormal(&normal[0],xyz_list);
    521521
    … …  
    591591        /*Retrieve all inputs and parameters*/
    592592        GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
    593         Input* vxaverage_input=tria->inputs->GetInput(VxEnum);
    594         Input* vyaverage_input=tria->inputs->GetInput(VyEnum);
     593        Input2* vxaverage_input=tria->GetInput2(VxEnum); _assert_(vxaverage_input);
     594        Input2* vyaverage_input=tria->GetInput2(VyEnum); _assert_(vyaverage_input);
    595595        GetNormal(&normal[0],xyz_list);
    596596
    … …  
    688688        GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
    689689        IssmDouble dt = parameters->FindParam(TimesteppingTimeStepEnum);
    690         Input* vxaverage_input=tria->inputs->GetInput(VxEnum); _assert_(vxaverage_input);
    691         Input* vyaverage_input=tria->inputs->GetInput(VyEnum); _assert_(vyaverage_input);
     690        Input2* vxaverage_input=tria->GetInput2(VxEnum); _assert_(vxaverage_input);
     691        Input2* vyaverage_input=tria->GetInput2(VyEnum); _assert_(vyaverage_input);
    692692        GetNormal(&normal[0],xyz_list);
    693693
    … …  
    764764        GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
    765765        IssmDouble dt = parameters->FindParam(TimesteppingTimeStepEnum);
    766         Input* vxaverage_input=tria->inputs->GetInput(VxEnum);
    767         Input* vyaverage_input=tria->inputs->GetInput(VyEnum);
     766        Input2* vxaverage_input=tria->GetInput2(VxEnum); _assert_(vxaverage_input);
     767        Input2* vyaverage_input=tria->GetInput2(VyEnum); _assert_(vyaverage_input);
    768768        GetNormal(&normal[0],xyz_list);
    769769
    … …  
    866866        /*Retrieve all inputs and parameters*/
    867867        GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
    868         Input* vxaverage_input = tria->inputs->GetInput(VxEnum);        _assert_(vxaverage_input);
    869         Input* vyaverage_input = tria->inputs->GetInput(VyEnum);        _assert_(vyaverage_input);
    870         Input* thickness_input = tria->inputs->GetInput(ThicknessEnum); _assert_(thickness_input);
     868        Input2* vxaverage_input = tria->GetInput2(VxEnum);        _assert_(vxaverage_input);
     869        Input2* vyaverage_input = tria->GetInput2(VyEnum);        _assert_(vyaverage_input);
     870        Input2* thickness_input = tria->GetInput2(ThicknessEnum); _assert_(thickness_input);
    871871        GetNormal(&normal[0],xyz_list);
    872872
    … …  
    947947        GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
    948948        IssmDouble dt = parameters->FindParam(TimesteppingTimeStepEnum);
    949         Input* vxaverage_input    = tria->inputs->GetInput(VxEnum);                        _assert_(vxaverage_input);
    950         Input* vyaverage_input    = tria->inputs->GetInput(VyEnum);                        _assert_(vyaverage_input);
    951         Input* spcthickness_input = tria->inputs->GetInput(MasstransportSpcthicknessEnum); _assert_(spcthickness_input);
     949        Input2* vxaverage_input    = tria->GetInput2(VxEnum);                        _assert_(vxaverage_input);
     950        Input2* vyaverage_input    = tria->GetInput2(VyEnum);                        _assert_(vyaverage_input);
     951        Input2* spcthickness_input = tria->GetInput2(MasstransportSpcthicknessEnum); _assert_(spcthickness_input);
    952952        GetNormal(&normal[0],xyz_list);
    953953

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

    r23524 r24335  
    1616class Gauss;
    1717class Input;
     18class Input2;
    1819/*}}}*/
    1920
    … …  
    5657                virtual void       ViscosityBSSA(IssmDouble* pmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,IssmDouble epseff)=0;
    5758
     59                virtual void       ViscosityFS(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input,Input2* vz_input)=0;
     60                virtual void       ViscosityHO(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input)=0;
     61                virtual void       ViscosityL1L2(IssmDouble* pviscosity,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input,Input2* surf)=0;
     62                virtual void       ViscositySSA(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input)=0;
     63                virtual void       ViscosityBFS(IssmDouble* pmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input,Input2* vz_input,IssmDouble epseff)=0;
     64                virtual void       ViscosityBHO(IssmDouble* pmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input,IssmDouble epseff)=0;
     65                virtual void       ViscosityBSSA(IssmDouble* pmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input,IssmDouble epseff)=0;
     66
    5867};
    5968#endif

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

    r23524 r24335  
    160160        IssmDouble B;
    161161
    162         Input* B_input = element->GetInput(MaterialsRheologyBEnum); _assert_(B_input);
     162        Input2* B_input = element->GetInput2(MaterialsRheologyBEnum); _assert_(B_input);
    163163        B_input->GetInputValue(&B,gauss);
    164164        return B;
    … …  
    170170        IssmDouble Bbar;
    171171
    172         Input* B_input = element->GetInput(MaterialsRheologyBbarEnum); _assert_(B_input);
     172        Input2* B_input = element->GetInput2(MaterialsRheologyBbarEnum); _assert_(B_input);
    173173        B_input->GetInputValue(&Bbar,gauss);
    174174        return Bbar;
    … …  
    189189        IssmDouble Ec;
    190190
    191         Input* Ec_input = element->GetInput(MaterialsRheologyEcEnum); _assert_(Ec_input);
     191        Input2* Ec_input = element->GetInput2(MaterialsRheologyEcEnum); _assert_(Ec_input);
    192192        Ec_input->GetInputValue(&Ec,gauss);
    193193        return Ec;
    … …  
    199199        IssmDouble Ecbar;
    200200
    201         Input* Ecbar_input = element->GetInput(MaterialsRheologyEcbarEnum); _assert_(Ecbar_input);
     201        Input2* Ecbar_input = element->GetInput2(MaterialsRheologyEcbarEnum); _assert_(Ecbar_input);
    202202        Ecbar_input->GetInputValue(&Ecbar,gauss);
    203203        return Ecbar;
    … …  
    209209        IssmDouble Es;
    210210
    211         Input* Es_input = element->GetInput(MaterialsRheologyEsEnum); _assert_(Es_input);
     211        Input2* Es_input = element->GetInput2(MaterialsRheologyEsEnum); _assert_(Es_input);
    212212        Es_input->GetInputValue(&Es,gauss);
    213213        return Es;
    … …  
    219219        IssmDouble Esbar;
    220220
    221         Input* Esbar_input = element->GetInput(MaterialsRheologyEsbarEnum); _assert_(Esbar_input);
     221        Input2* Esbar_input = element->GetInput2(MaterialsRheologyEsbarEnum); _assert_(Esbar_input);
    222222        Esbar_input->GetInputValue(&Esbar,gauss);
    223223        return Esbar;
    … …  
    617617        _error_("not implemented yet");
    618618}/*}}}*/
     619
     620void  Matestar::ViscosityBFS(IssmDouble* pdmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input,Input2* vz_input,IssmDouble eps_eff){/*{{{*/
     621
     622        /*Intermediaries*/
     623        IssmDouble vx,vy,vz;
     624        IssmDouble dvx[3],dvy[3],dvz[3];
     625        bool isdepthaveraged=0.;
     626
     627        /*Get velocity derivatives in all directions*/
     628        _assert_(dim>1);
     629        _assert_(vx_input);
     630        vx_input->GetInputValue(&vx,gauss);
     631        vx_input->GetInputDerivativeValue(&dvx[0],xyz_list,gauss);
     632        _assert_(vy_input);
     633        vy_input->GetInputValue(&vy,gauss);
     634        vy_input->GetInputDerivativeValue(&dvy[0],xyz_list,gauss);
     635        if(dim==3){
     636                _assert_(vz_input);
     637                vz_input->GetInputValue(&vz,gauss);
     638                vz_input->GetInputDerivativeValue(&dvz[0],xyz_list,gauss);
     639        }
     640        else{
     641                vz = 0.;
     642                dvz[0] = 0.; dvz[1] = 0.; dvz[2] = 0.;
     643        }
     644
     645        /*Compute dmudB*/
     646        *pdmudB=GetViscosity_BGeneral(vx,vy,vz,&dvx[0],&dvy[0],&dvz[0],eps_eff,isdepthaveraged,gauss);
     647}
     648/*}}}*/
     649void  Matestar::ViscosityBHO(IssmDouble* pdmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input,IssmDouble eps_eff){/*{{{*/
     650
     651        /*Intermediaries*/
     652        IssmDouble vx,vy,vz;
     653        IssmDouble dvx[3],dvy[3],dvz[3];
     654        bool isdepthaveraged=0.;
     655
     656        /*Get velocity derivatives in all directions*/
     657        _assert_(dim==2 || dim==3);
     658        _assert_(vx_input);
     659        vx_input->GetInputValue(&vx,gauss);
     660        vx_input->GetInputDerivativeValue(&dvx[0],xyz_list,gauss);
     661        if(dim==3){
     662                _assert_(vy_input);
     663                vy_input->GetInputValue(&vy,gauss);
     664                vy_input->GetInputDerivativeValue(&dvy[0],xyz_list,gauss);
     665        }
     666        else{
     667                dvx[2] = 0.;
     668                vy = 0.;
     669                dvy[0] = 0.; dvy[1] = 0.; dvy[2] = 0.;
     670        }
     671        vz = 0.;
     672        dvz[0] = 0.; dvz[1] = 0.; dvz[2] = -dvx[0]-dvy[1];
     673
     674        /*Compute viscosity*/
     675        *pdmudB=GetViscosity_BGeneral(vx,vy,vz,&dvx[0],&dvy[0],&dvz[0],eps_eff,isdepthaveraged,gauss);
     676}/*}}}*/
     677void  Matestar::ViscosityBSSA(IssmDouble* pdmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input,IssmDouble eps_eff){/*{{{*/
     678        /*Intermediaries*/
     679        IssmDouble vx,vy,vz;
     680        IssmDouble dvx[3],dvy[3],dvz[3];
     681        bool isdepthaveraged=1.;
     682
     683        /*Get velocity derivatives in all directions*/
     684        _assert_(dim==1 || dim==2);
     685        _assert_(vx_input);
     686        vx_input->GetInputValue(&vx,gauss);
     687        vx_input->GetInputDerivativeValue(&dvx[0],xyz_list,gauss);
     688        if(dim==2){
     689                _assert_(vy_input);
     690                vy_input->GetInputValue(&vy,gauss);
     691                vy_input->GetInputDerivativeValue(&dvy[0],xyz_list,gauss);
     692        }
     693        else{
     694                dvx[1] = 0.;
     695                dvx[2] = 0.;
     696                vy = 0.;
     697                dvy[0] = 0.; dvy[1] = 0.; dvy[2] = 0.;
     698        }
     699        dvx[2] = 0.;
     700        dvy[2] = 0.;
     701        vz = 0.;
     702        dvz[0] = 0.; dvz[1] = 0.; dvz[2] = -dvx[0]-dvy[1];
     703
     704        /*Compute viscosity*/
     705        *pdmudB=GetViscosity_BGeneral(vx,vy,vz,&dvx[0],&dvy[0],&dvz[0],eps_eff,isdepthaveraged,gauss);
     706}/*}}}*/
     707void  Matestar::ViscosityFS(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input,Input2* vz_input){/*{{{*/
     708
     709        /*Intermediaries*/
     710        IssmDouble vx,vy,vz;
     711        IssmDouble dvx[3],dvy[3],dvz[3];
     712        IssmDouble epsilon3d[6]; /* epsilon=[exx,eyy,ezz,exy,exz,eyz];*/
     713        IssmDouble epsilon2d[3]; /* epsilon=[exx,eyy,exy];*/
     714        IssmDouble eps_eff,eps0=1.e-27;
     715        bool isdepthaveraged=0.;
     716
     717        /*Get velocity derivatives in all directions*/
     718        _assert_(dim>1);
     719        _assert_(vx_input);
     720        vx_input->GetInputValue(&vx,gauss);
     721        vx_input->GetInputDerivativeValue(&dvx[0],xyz_list,gauss);
     722        _assert_(vy_input);
     723        vy_input->GetInputValue(&vy,gauss);
     724        vy_input->GetInputDerivativeValue(&dvy[0],xyz_list,gauss);
     725        if(dim==3){
     726                _assert_(vz_input);
     727                vz_input->GetInputValue(&vz,gauss);
     728                vz_input->GetInputDerivativeValue(&dvz[0],xyz_list,gauss);
     729        }
     730        else{
     731                vz = 0.;
     732                dvz[0] = 0.; dvz[1] = 0.; dvz[2] = 0.;
     733        }
     734
     735        if(dim==3){
     736      /* eps_eff^2 = exx^2 + eyy^2 + exy^2 + exz^2 + eyz^2 + exx*eyy */
     737                element->StrainRateFS(&epsilon3d[0],xyz_list,gauss,vx_input,vy_input,vz_input);
     738                eps_eff = sqrt(epsilon3d[0]*epsilon3d[0] + epsilon3d[1]*epsilon3d[1] + epsilon3d[3]*epsilon3d[3] +  epsilon3d[4]*epsilon3d[4] + epsilon3d[5]*epsilon3d[5] + epsilon3d[0]*epsilon3d[1]+eps0*eps0);
     739        }
     740        else{
     741                /* eps_eff^2 = 1/2 ( exx^2 + eyy^2 + 2*exy^2 )*/
     742                element->StrainRateSSA(&epsilon2d[0],xyz_list,gauss,vx_input,vy_input);
     743                eps_eff = 1./sqrt(2.)*sqrt(epsilon2d[0]*epsilon2d[0] + epsilon2d[1]*epsilon2d[1] + 2.*epsilon2d[2]*epsilon2d[2]);
     744        }
     745
     746        /*Compute viscosity*/
     747        *pviscosity=GetViscosityGeneral(vx,vy,vz,&dvx[0],&dvy[0],&dvz[0],eps_eff,isdepthaveraged,gauss);
     748}
     749/*}}}*/
     750void  Matestar::ViscosityHO(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input){/*{{{*/
     751
     752        /*Intermediaries*/
     753        IssmDouble vx,vy,vz;
     754        IssmDouble dvx[3],dvy[3],dvz[3];
     755        IssmDouble epsilon3d[5]; /* epsilon=[exx,eyy,exy,exz,eyz];*/
     756        IssmDouble epsilon2d[5]; /* epsilon=[exx,exy];*/
     757        IssmDouble eps_eff;
     758        bool isdepthaveraged=0.;
     759
     760   if(dim==3){
     761                /* eps_eff^2 = exx^2 + eyy^2 + exy^2 + exz^2 + eyz^2 + exx*eyy */
     762                element->StrainRateHO(&epsilon3d[0],xyz_list,gauss,vx_input,vy_input);
     763                eps_eff = sqrt(epsilon3d[0]*epsilon3d[0] + epsilon3d[1]*epsilon3d[1] + epsilon3d[2]*epsilon3d[2] +  epsilon3d[3]*epsilon3d[3] + epsilon3d[4]*epsilon3d[4] + epsilon3d[0]*epsilon3d[1]);
     764        }
     765        else{
     766                /* eps_eff^2 = 1/2 (2*exx^2 + 2*exy^2 ) (since eps_zz = - eps_xx)*/
     767                element->StrainRateHO2dvertical(&epsilon2d[0],xyz_list,gauss,vx_input,vy_input);
     768                eps_eff = 1./sqrt(2.)*sqrt(2*epsilon2d[0]*epsilon2d[0] + 2*epsilon2d[1]*epsilon2d[1]);
     769        }
     770
     771        /*Get velocity derivatives in all directions*/
     772        _assert_(dim==2 || dim==3);
     773        _assert_(vx_input);
     774        vx_input->GetInputValue(&vx,gauss);
     775        vx_input->GetInputDerivativeValue(&dvx[0],xyz_list,gauss);
     776        if(dim==3){
     777                _assert_(vy_input);
     778                vy_input->GetInputValue(&vy,gauss);
     779                vy_input->GetInputDerivativeValue(&dvy[0],xyz_list,gauss);
     780        }
     781        else{
     782                dvx[2] = 0.;
     783                vy = 0.;
     784                dvy[0] = 0.; dvy[1] = 0.; dvy[2] = 0.;
     785        }
     786        vz = 0.;
     787        dvz[0] = 0.; dvz[1] = 0.; dvz[2] = -dvx[0]-dvy[1];
     788
     789        /*Compute viscosity*/
     790        *pviscosity=GetViscosityGeneral(vx,vy,vz,&dvx[0],&dvy[0],&dvz[0],eps_eff,isdepthaveraged,gauss);
     791}/*}}}*/
     792void  Matestar::ViscosityL1L2(IssmDouble* pviscosity,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input,Input2* surface_input){/*{{{*/
     793        _error_("not implemented yet");
     794}/*}}}*/
     795void  Matestar::ViscositySSA(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input){/*{{{*/
     796
     797        /*Intermediaries*/
     798        IssmDouble vx,vy,vz;
     799        IssmDouble dvx[3],dvy[3],dvz[3];
     800        IssmDouble epsilon2d[3];/* epsilon=[exx,eyy,exy]; */
     801        IssmDouble epsilon1d;   /* epsilon=[exx];         */
     802        IssmDouble eps_eff;
     803        bool isdepthaveraged=1.;
     804
     805        /*Get velocity derivatives in all directions*/
     806        _assert_(dim==1 || dim==2);
     807        _assert_(vx_input);
     808        vx_input->GetInputValue(&vx,gauss);
     809        vx_input->GetInputDerivativeValue(&dvx[0],xyz_list,gauss);
     810        if(dim==2){
     811                _assert_(vy_input);
     812                vy_input->GetInputValue(&vy,gauss);
     813                vy_input->GetInputDerivativeValue(&dvy[0],xyz_list,gauss);
     814        }
     815        else{
     816                dvx[1] = 0.;
     817                dvx[2] = 0.;
     818                vy = 0.;
     819                dvy[0] = 0.; dvy[1] = 0.; dvy[2] = 0.;
     820        }
     821        dvx[2] = 0.;
     822        dvy[2] = 0.;
     823        vz = 0.;
     824        dvz[0] = 0.; dvz[1] = 0.; dvz[2] = -dvx[0]-dvy[1];
     825
     826   if(dim==2){
     827                /* eps_eff^2 = exx^2 + eyy^2 + exy^2 + exx*eyy*/
     828                element->StrainRateSSA(&epsilon2d[0],xyz_list,gauss,vx_input,vy_input);
     829                eps_eff = sqrt(epsilon2d[0]*epsilon2d[0] + epsilon2d[1]*epsilon2d[1] + epsilon2d[2]*epsilon2d[2] + epsilon2d[0]*epsilon2d[1]);
     830        }
     831        else{
     832                /* eps_eff^2 = exx^2*/
     833                element->StrainRateSSA1d(&epsilon1d,xyz_list,gauss,vx_input);
     834                eps_eff = fabs(epsilon1d);
     835        }
     836
     837        /*Compute viscosity*/
     838        *pviscosity=GetViscosityGeneral(vx,vy,vz,&dvx[0],&dvy[0],&dvz[0],eps_eff,isdepthaveraged,gauss);
     839}/*}}}*/

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

    r23524 r24335  
    8181                void       ViscosityBHO(IssmDouble* pmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,IssmDouble eps_eff);
    8282                void       ViscosityBSSA(IssmDouble* pmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,IssmDouble eps_eff);
     83
     84                void       ViscosityFS(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input,Input2* vz_input);
     85                void       ViscosityHO(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input);
     86                void       ViscosityL1L2(IssmDouble* pviscosity,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input,Input2* surf);
     87                void       ViscositySSA(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input);
     88                void       ViscosityBFS(IssmDouble* pmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input,Input2* vz_input,IssmDouble eps_eff);
     89                void       ViscosityBHO(IssmDouble* pmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input,IssmDouble eps_eff);
     90                void       ViscosityBSSA(IssmDouble* pmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input,IssmDouble eps_eff);
    8391                /*}}}*/
    8492                IssmDouble GetViscosityGeneral(IssmDouble vx,IssmDouble vy,IssmDouble vz,IssmDouble* dvx,IssmDouble* dvy,IssmDouble* dvz,IssmDouble eps_eff,bool isdepthaveraged,Gauss* gauss);

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

    r23644 r24335  
    221221        /*Output*/
    222222        IssmDouble B;
    223 
    224         Input* B_input = element->GetInput(MaterialsRheologyBEnum); _assert_(B_input);
     223        Input2* B_input = element->GetInput2(MaterialsRheologyBEnum); _assert_(B_input);
    225224        B_input->GetInputValue(&B,gauss);
    226225        return B;
    … …  
    234233        IssmDouble Bbar;
    235234
    236         Input* B_input = element->GetInput(MaterialsRheologyBbarEnum); _assert_(B_input);
     235        Input2* B_input = element->GetInput2(MaterialsRheologyBbarEnum); _assert_(B_input);
    237236        B_input->GetInputValue(&Bbar,gauss);
    238237        return Bbar;
    … …  
    245244        IssmDouble D;
    246245        if(this->isdamaged){
    247                 Input* D_input = element->GetInput(DamageDEnum); _assert_(D_input);
     246                Input2* D_input = element->GetInput2(DamageDEnum); _assert_(D_input);
    248247                D_input->GetInputValue(&D,gauss);
    249248        }
    … …  
    260259        IssmDouble Dbar;
    261260        if(this->isdamaged){
    262                 Input* D_input = element->GetInput(DamageDbarEnum); _assert_(D_input);
     261                Input2* D_input = element->GetInput2(DamageDbarEnum); _assert_(D_input);
    263262                D_input->GetInputValue(&Dbar,gauss);
    264263        }
    … …  
    274273        /*Output*/
    275274        IssmDouble E;
    276         Input* E_input = element->GetInput(MaterialsRheologyEEnum); _assert_(E_input);
     275        Input2* E_input = element->GetInput2(MaterialsRheologyEEnum); _assert_(E_input);
    277276        E_input->GetInputValue(&E,gauss);
    278277        return E;
    … …  
    284283        /*Output*/
    285284        IssmDouble Ebar;
    286         Input* E_input = element->GetInput(MaterialsRheologyEbarEnum); _assert_(E_input);
     285        Input2* E_input = element->GetInput2(MaterialsRheologyEbarEnum); _assert_(E_input);
    287286        E_input->GetInputValue(&Ebar,gauss);
    288287        return Ebar;
    … …  
    293292        /*Output*/
    294293        IssmDouble n;
    295 
    296         element->inputs->GetInputAverage(&n,MaterialsRheologyNEnum);
     294        Input2* n_input = element->GetInput2(MaterialsRheologyNEnum); _assert_(n_input);
     295        n_input->GetInputAverage(&n);
    297296        return n;
    298297}
    … …  
    825824        this->GetViscosity2dDerivativeEpsSquare(pmu_prime,epsilon,gauss);
    826825}/*}}}*/
     826
     827void  Matice::ViscosityFS(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input,Input2* vz_input){/*{{{*/
     828        /*The effective strain rate is defined in Paterson 3d Ed p 91 eq 9,
     829         * and Cuffey p 303 eq 8.18:
     830         *
     831         *  2 eps_eff^2 = eps_xx^2 + eps_yy^2 + eps_zz^2 + 2(eps_xy^2 + eps_xz^2 + eps_yz^2)
     832         *
     833         *  or
     834         *
     835         *  eps_eff = 1/sqrt(2) sqrt( \sum_ij eps_ij^2 )
     836         *
     837         *          = 1/sqrt(2) ||eps||_F
     838         *
     839         *  where ||.||_F is the Frobenius norm */
     840
     841        /*Intermediaries*/
     842        IssmDouble viscosity;
     843        IssmDouble epsilon3d[6]; /* epsilon=[exx,eyy,ezz,exy,exz,eyz];*/
     844        IssmDouble epsilon2d[3]; /* epsilon=[exx,eyy,exy];            */
     845        IssmDouble eps_eff;
     846        IssmDouble eps0=1.e-27;
     847
     848        if(dim==3){
     849                /* eps_eff^2 = exx^2 + eyy^2 + exy^2 + exz^2 + eyz^2 + exx*eyy */
     850                element->StrainRateFS(&epsilon3d[0],xyz_list,gauss,vx_input,vy_input,vz_input);
     851                eps_eff = sqrt(epsilon3d[0]*epsilon3d[0] + epsilon3d[1]*epsilon3d[1] + epsilon3d[3]*epsilon3d[3] +  epsilon3d[4]*epsilon3d[4] + epsilon3d[5]*epsilon3d[5] + epsilon3d[0]*epsilon3d[1]+eps0*eps0);
     852        }
     853        else{
     854                /* eps_eff^2 = 1/2 ( exx^2 + eyy^2 + 2*exy^2 )*/
     855                element->StrainRateSSA(&epsilon2d[0],xyz_list,gauss,vx_input,vy_input);
     856                eps_eff = 1./sqrt(2.)*sqrt(epsilon2d[0]*epsilon2d[0] + epsilon2d[1]*epsilon2d[1] + 2.*epsilon2d[2]*epsilon2d[2]);
     857        }
     858
     859        /*Get viscosity*/
     860        this->GetViscosity(&viscosity,eps_eff,gauss);
     861
     862        /*Assign output pointer*/
     863        *pviscosity=viscosity;
     864}
     865/*}}}*/
     866void  Matice::ViscosityHO(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input){/*{{{*/
     867
     868        /*Intermediaries*/
     869        IssmDouble viscosity;
     870        IssmDouble epsilon3d[5];/* epsilon=[exx,eyy,exy,exz,eyz];*/
     871        IssmDouble epsilon2d[2];/* epsilon=[exx,exy];            */
     872        IssmDouble eps_eff;
     873
     874        if(dim==3){
     875                /* eps_eff^2 = exx^2 + eyy^2 + exy^2 + exz^2 + eyz^2 + exx*eyy */
     876                element->StrainRateHO(&epsilon3d[0],xyz_list,gauss,vx_input,vy_input);
     877                eps_eff = sqrt(epsilon3d[0]*epsilon3d[0] + epsilon3d[1]*epsilon3d[1] + epsilon3d[2]*epsilon3d[2] +  epsilon3d[3]*epsilon3d[3] + epsilon3d[4]*epsilon3d[4] + epsilon3d[0]*epsilon3d[1]);
     878        }
     879        else{
     880                /* eps_eff^2 = 1/2 (2*exx^2 + 2*exy^2 ) (since eps_zz = - eps_xx)*/
     881                element->StrainRateHO2dvertical(&epsilon2d[0],xyz_list,gauss,vx_input,vy_input);
     882                eps_eff = 1./sqrt(2.)*sqrt(2*epsilon2d[0]*epsilon2d[0] + 2*epsilon2d[1]*epsilon2d[1]);
     883        }
     884
     885        /*Get viscosity*/
     886        this->GetViscosity(&viscosity,eps_eff,gauss);
     887        _assert_(!xIsNan<IssmDouble>(viscosity));
     888
     889        /*Assign output pointer*/
     890        *pviscosity=viscosity;
     891}/*}}}*/
     892void  Matice::ViscosityL1L2(IssmDouble* pviscosity,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input,Input2* surface_input){/*{{{*/
     893        /*Compute the L1L2 viscosity
     894         *
     895         *      1
     896         * mu = - A^-1 (sigma'_e)^(1-n)
     897         *      2
     898         *
     899         * sigma'_e^2 = |sigma'_//|^2 + |sigma'_perp|^2 (see Perego 2012 eq. 17,18)
     900         *
     901         * L1L2 assumptions:
     902         *
     903         * (1) |eps_b|_// = A (|sigma'_//|^2 + |sigma'_perp|^2)^((n-1)/2) |sigma'_//|
     904         * (2) |sigma'_perp|^2 = |rho g (s-z) grad(s)|^2
     905         *
     906         * Assuming that n = 3, we have a polynom of degree 3 to solve (the only unkown is X=|sigma'_//|)
     907         *
     908         * A X^3 + A |rho g (s-z) grad(s)|^2 X - |eps_b|_// = 0     */
     909
     910        IssmDouble z,s,viscosity,p,q,delta;
     911        IssmDouble tau_perp,tau_par,eps_b,A;
     912        IssmDouble epsilon[5];   /*exx eyy exy exz eyz*/
     913        IssmDouble slope[3];
     914
     915        /*Check that both inputs have been found*/
     916        if (!vx_input || !vy_input || !surface_input) _error_("Input missing");
     917
     918        /*Get tau_perp*/
     919        surface_input->GetInputValue(&s,gauss);
     920        surface_input->GetInputDerivativeValue(&slope[0],xyz_list,gauss);
     921        z=this->element->GetZcoord(xyz_list,gauss);
     922        tau_perp = element->FindParam(MaterialsRhoIceEnum) * element->FindParam(ConstantsGEnum) * fabs(s-z)*sqrt(slope[0]*slope[0]+slope[1]*slope[1]);
     923
     924        /* Get eps_b*/
     925        element->StrainRateHO(&epsilon[0],xyz_list,gauss,vx_input,vy_input);
     926        eps_b = sqrt(epsilon[0]*epsilon[0] + epsilon[1]*epsilon[1] + epsilon[0]*epsilon[1] + epsilon[2]*epsilon[2]);
     927        if(eps_b==0.){
     928                *pviscosity = 2.5e+17;
     929                return;
     930        }
     931
     932        /*Get A*/
     933        _assert_(this->GetN()==3.0);
     934        A=this->GetA(gauss);
     935
     936        /*Solve for tau_perp (http://fr.wikipedia.org/wiki/Méthode_de_Cardan)*/
     937        p     = tau_perp *tau_perp;
     938        q     = - eps_b/A;
     939        delta = q *q + p*p*p*4./27.;
     940        _assert_(delta>0);
     941        tau_par = pow(0.5*(-q+sqrt(delta)),1./3.) - pow(0.5*(q+sqrt(delta)),1./3.);
     942
     943        /*Viscosity*/
     944        viscosity = 1./(2.*A*(tau_par*tau_par + tau_perp*tau_perp));
     945        _assert_(!xIsNan(viscosity));
     946        _assert_(viscosity > 0.);
     947
     948        /*Assign output pointer*/
     949        *pviscosity = viscosity;
     950}/*}}}*/
     951void  Matice::ViscositySSA(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input){/*{{{*/
     952
     953        /*Intermediaries*/
     954        IssmDouble viscosity;
     955        IssmDouble epsilon2d[3];/* epsilon=[exx,eyy,exy];    */
     956        IssmDouble epsilon1d;   /* epsilon=[exx];    */
     957        IssmDouble eps_eff;
     958
     959        if(dim==2){
     960                /* eps_eff^2 = exx^2 + eyy^2 + exy^2 + exx*eyy*/
     961                element->StrainRateSSA(&epsilon2d[0],xyz_list,gauss,vx_input,vy_input);
     962                eps_eff = sqrt(epsilon2d[0]*epsilon2d[0] + epsilon2d[1]*epsilon2d[1] + epsilon2d[2]*epsilon2d[2] + epsilon2d[0]*epsilon2d[1]);
     963        }
     964        else{
     965                /* eps_eff^2 = exx^2*/
     966                element->StrainRateSSA1d(&epsilon1d,xyz_list,gauss,vx_input);
     967                eps_eff = fabs(epsilon1d);
     968        }
     969
     970        /*Get viscosity*/
     971        this->GetViscosityBar(&viscosity,eps_eff,gauss);
     972
     973        /*Assign output pointer*/
     974        *pviscosity=viscosity;
     975}/*}}}*/

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

    r23524 r24335  
    8383                void       ViscosityBHO(IssmDouble* pmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,IssmDouble eps_eff){_error_("not supported");};
    8484                void       ViscosityBSSA(IssmDouble* pmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,IssmDouble eps_eff){_error_("not supported");};
     85
     86                void       ViscosityFS(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input,Input2* vz_input);
     87                void       ViscosityHO(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input);
     88                void       ViscosityL1L2(IssmDouble* pviscosity,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input,Input2* surf);
     89                void       ViscositySSA(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input);
     90                void       ViscosityBFS(IssmDouble* pmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input,Input2* vz_input,IssmDouble eps_eff){_error_("not supported");};
     91                void       ViscosityBHO(IssmDouble* pmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input,IssmDouble eps_eff){_error_("not supported");};
     92                void       ViscosityBSSA(IssmDouble* pmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input,IssmDouble eps_eff){_error_("not supported");};
    8593                /*}}}*/
    8694};

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

    r23644 r24335  
    7373                void       ViscosityBSSA(IssmDouble* pmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,IssmDouble epseff){_error_("not supported");};
    7474
     75
     76                void       ViscosityFS(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input,Input2* vz_input){_error_("not supported");};
     77                void       ViscosityHO(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input){_error_("not supported");};
     78                void       ViscosityL1L2(IssmDouble* pviscosity,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input,Input2* surf){_error_("not supported");};
     79                void       ViscositySSA(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input){_error_("not supported");};
     80                void       ViscosityBFS(IssmDouble* pmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input,Input2* vz_input,IssmDouble epseff){_error_("not supported");};
     81                void       ViscosityBHO(IssmDouble* pmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input,IssmDouble epseff){_error_("not supported");};
     82                void       ViscosityBSSA(IssmDouble* pmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input2* vx_input,Input2* vy_input,IssmDouble epseff){_error_("not supported");};
     83
    7584                /*}}}*/
    7685

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

    r23066 r24335  
    235235                 model=OutputDefinitionsResponsex(femmodel,this->model_enum);
    236236                 /*Now, the observation is buried inside the elements, go fish it in the first element (cludgy, needs fixing): */
    237                  Element* element=(Element*)femmodel->elements->GetObjectByOffset(0); _assert_(element);
    238                  Input* input = element->GetInput(observation_enum); _assert_(input);
     237                 Element* element = (Element*)femmodel->elements->GetObjectByOffset(0); _assert_(element);
     238                 Input2*  input   = element->GetInput2(observation_enum); _assert_(input);
    239239                 input->GetInputAverage(&observation);
    240240

  • issm/trunk-jpl/src/c/classes/Params/Parameters.cpp

    r24240 r24335  
    233233                        }
    234234                        else if(obj_enum==GenericParamEnum){
    235                                 /*Skip for now (we don't want to Marhsall Comms*/
     235                                /*Skip for now (we don't want to Marhsall Comms)*/
    236236                        }
    237237                }

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

    r23640 r24335  
    171171/*}}}*/
    172172
    173 void Vertices::Finalize(){/*{{{*/
     173void Vertices::Finalize(IoModel* iomodel){/*{{{*/
    174174
    175175        /*Here we do 3 things:
    … …  
    195195
    196196        /*2. Distribute lids (First: masters, then clones)*/
     197        iomodel->my_vertices_lids=xNew<int>(this->numberofvertices);
     198        for(int i=0;i<this->numberofvertices;i++) iomodel->my_vertices_lids[i] = -1;
     199
    197200        int lid = 0;
    198201        for(int i=0;i<this->Size();i++){
    199202                Vertex* vertex=xDynamicCast<Vertex*>(this->GetObjectByOffset(i));
    200                 if(!vertex->clone) vertex->lid=lid++;
    201         }
    202         for(int i=0;i<this->Size();i++){
    203                 Vertex* vertex=xDynamicCast<Vertex*>(this->GetObjectByOffset(i));
    204                 if(vertex->clone) vertex->lid=lid++;
     203                if(!vertex->clone){
     204                        vertex->lid=lid;
     205                        iomodel->my_vertices_lids[vertex->sid] = lid;
     206                        lid++;
     207                }
     208        }
     209        for(int i=0;i<this->Size();i++){
     210                Vertex* vertex=xDynamicCast<Vertex*>(this->GetObjectByOffset(i));
     211                if(vertex->clone){
     212                        vertex->lid=lid;
     213                        iomodel->my_vertices_lids[vertex->sid] = lid;
     214                        lid++;
     215                }
    205216        }
    206217

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

    r23638 r24335  
    55#include "../datastructures/datastructures.h"
    66#include "../shared/shared.h"
     7class IoModel;
    78
    89/*!\brief Declaration of Vertices class.
    … …  
    3334
    3435                /*numerics:*/
    35                 void  Finalize(void);
     36                void  Finalize(IoModel* iomodel);
    3637                int   NumberOfVertices(void);
    3738                int   NumberOfVerticesLocal(void);

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

    r24205 r24335  
    8181#include "./Inputs/TransientInput.h"
    8282
     83/*Inputs2*/
     84#include "./Inputs2/Inputs2.h"
     85#include "./Inputs2/Input2.h"
     86
    8387/*ExternalResults: */
    8488#include "./ExternalResults/Results.h"

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

    r23311 r24335  
    143143        /*Update control input*/
    144144        SetControlInputsFromVectorx(femmodel,X);
    145        
    146145       
    147146        /*solve forward: */

  • issm/trunk-jpl/src/c/cores/hydrology_core.cpp

    r24240 r24335  
    178178                if(VerboseSolution()) _printf0_("   updating water column\n");
    179179                HydrologyPismAnalysis* analysis = new HydrologyPismAnalysis();
     180                InputDuplicatex(femmodel,WatercolumnEnum,WaterColumnOldEnum);
    180181                analysis->UpdateWaterColumn(femmodel);
    181182                delete analysis;

  • issm/trunk-jpl/src/c/cores/masstransport_core.cpp

    r24097 r24335  
    6262                femmodel->SetCurrentConfiguration(MasstransportAnalysisEnum);
    6363                InputDuplicatex(femmodel,ThicknessEnum,ThicknessOldEnum);
     64                InputDuplicatex(femmodel,BaseEnum,BaseOldEnum);
     65                InputDuplicatex(femmodel,SurfaceEnum,SurfaceOldEnum);
     66                InputDuplicatex(femmodel,SealevelriseCumDeltathicknessEnum,SealevelriseCumDeltathicknessOldEnum);
    6467                if(stabilization==4){
    6568                        solutionsequence_fct(femmodel);

  • issm/trunk-jpl/src/c/cores/sealevelrise_core.cpp

    r24259 r24335  
    192192
    193193                //reset cumdeltathickness  to 0:
    194                 InputUpdateFromConstantx(femmodel->elements,0.,SealevelriseCumDeltathicknessEnum);
     194                InputUpdateFromConstantx(femmodel->inputs2,femmodel->elements,0.,SealevelriseCumDeltathicknessEnum);
    195195        }
    196196

  • issm/trunk-jpl/src/c/cores/thermal_core.cpp

    r24240 r24335  
    1414
    1515        /*Start profiler*/
    16         femmodel->profiler->Start(THERMALCORE);
     16        femmodel->profiler->Start(THERMALCORE);
    1717
    1818        /*intermediary*/
    … …  
    3434
    3535        if(isenthalpy){
     36                femmodel->InputMakeDiscontinuous(BasalforcingsGroundediceMeltingRateEnum);
    3637                enthalpy_analysis = new EnthalpyAnalysis();
    3738                enthalpy_analysis->Core(femmodel);

  • issm/trunk-jpl/src/c/main/esmfbinders.cpp

    r23644 r24335  
    114114
    115115                                                /*Recover surface from the ISSM element: */
    116                                                 Input* surface_input = element->GetInput(SurfaceEnum); _assert_(surface_input);
     116                                                Input2* surface_input = element->GetInput2(SurfaceEnum); _assert_(surface_input);
    117117                                                surface_input->GetInputAverage(&surface);
    118118

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

    r23588 r24335  
    99#include "../../classes/classes.h"
    1010
    11 int     ConfigureObjectsx( Elements* elements, Loads* loads, Nodes* nodes, Vertices* vertices, Materials* materials,Parameters* parameters){
    12 
    13         /*Intermediary*/
    14         int       i;
    15         int       noerr = 1;
    16         int       configuration_type;
    17         Element  *element            = NULL;
    18         Load     *load               = NULL;
    19         Material *material           = NULL;
     11int     ConfigureObjectsx( Elements* elements, Loads* loads, Nodes* nodes, Vertices* vertices, Materials* materials,Parameters* parameters,Inputs2* inputs2){
    2012
    2113        /*Get analysis type: */
     14        int configuration_type;
    2215        parameters->FindParam(&configuration_type,ConfigurationTypeEnum);
    2316
    2417        if(VerboseMProcessor()) _printf0_("      Configuring elements...\n");
    25         for(i=0;i<elements->Size();i++){
    26                 element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    27                 element->Configure(elements,loads,nodes,vertices,materials,parameters);
     18        for(int i=0;i<elements->Size();i++){
     19                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     20                element->Configure(elements,loads,nodes,vertices,materials,parameters,inputs2);
    2821        }
    2922        if(VerboseMProcessor()) _printf0_("      Configuring loads...\n");
    30         for(i=0;i<loads->Size();i++){
    31                 load=(Load*)loads->GetObjectByOffset(i);
     23        for(int i=0;i<loads->Size();i++){
     24                Load* load=(Load*)loads->GetObjectByOffset(i);
    3225                load->Configure(elements,loads,nodes,vertices,materials,parameters);
    3326        }
    3427        if(VerboseMProcessor()) _printf0_("      Configuring materials...\n");
    35         for(i=0;i<materials->Size();i++){
    36                 material=(Material*)materials->GetObjectByOffset(i);
     28        for(int i=0;i<materials->Size();i++){
     29                Material* material=(Material*)materials->GetObjectByOffset(i);
    3730                material->Configure(elements);
    3831        }
    39         return noerr;
     32        if(VerboseMProcessor()) _printf0_("      Configuring inputs...\n");
     33        inputs2->Configure(parameters);
     34
     35        return 1;
    4036}

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

    r14996 r24335  
    99
    1010/* local prototypes: */
    11 int ConfigureObjectsx( Elements* elements, Loads* loads, Nodes* nodes, Vertices* vertices, Materials* materials, Parameters* parameters);
     11int ConfigureObjectsx( Elements* elements, Loads* loads, Nodes* nodes, Vertices* vertices, Materials* materials, Parameters* parameters,Inputs2* inputs2);
    1212
    1313#endif  /* _CONFIGUREOBJECTSX_H */

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

    r24146 r24335  
    44
    55#include "./Damagex.h"
     6#include "../InputDuplicatex/InputDuplicatex.h"
    67#include "../../shared/shared.h"
    78#include "../../toolkits/toolkits.h"
    … …  
    1718                case 0:
    1819                        if(VerboseModule()) _printf0_("   computing damage analytically\n");
     20                        InputDuplicatex(femmodel,DamageDEnum,DamageDOldEnum);
     21                        InputDuplicatex(femmodel,DamageDbarEnum,DamageDbarOldEnum);
    1922                        femmodel->ElementOperationx(&Element::ComputeNewDamage);
    2023                        break;

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

    r18521 r24335  
    77#include "../../shared/shared.h"
    88#include "../../toolkits/toolkits.h"
     9#include "../../classes/Inputs2/DatasetInput2.h"
    910
    1011void DragCoefficientAbsGradientx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters){
    … …  
    5960
    6061        /*Retrieve all inputs we will be needing: */
    61         Input* weights_input=basalelement->GetInput(InversionCostFunctionsCoefficientsEnum);   _assert_(weights_input);
    62         Input* drag_input   =basalelement->GetInput(FrictionCoefficientEnum); _assert_(drag_input);
     62        DatasetInput2* weights_input=basalelement->GetDatasetInput2(InversionCostFunctionsCoefficientsEnum);   _assert_(weights_input);
     63        Input2* drag_input   =basalelement->GetInput2(FrictionCoefficientEnum); _assert_(drag_input);
    6364
    6465        /* Start  looping on the number of gaussian points: */

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

    r24010 r24335  
    44
    55#include "./FloatingiceMeltingRatePicox.h"
     6#include "../InputDuplicatex/InputDuplicatex.h"
    67#include "../../shared/shared.h"
    78#include "../../toolkits/toolkits.h"
    … …  
    1718                int numvertices = element->GetNumberOfVertices();
    1819                IssmDouble* values = xNewZeroInit<IssmDouble>(numvertices);
    19                 element->AddInput(BasalforcingsFloatingiceMeltingRateEnum,values,P1Enum);
     20                element->AddInput2(BasalforcingsFloatingiceMeltingRateEnum,values,P1Enum);
    2021                xDelete<IssmDouble>(values);
    2122        }
    … …  
    4546        IssmDouble* dmax_basin_cpu=xNew<IssmDouble>(num_basins);
    4647
    47         femmodel->elements->InputDuplicate(MaskGroundediceLevelsetEnum,DistanceToGroundinglineEnum);
     48        InputDuplicatex(femmodel,MaskGroundediceLevelsetEnum,DistanceToGroundinglineEnum);
    4849        femmodel->DistanceToFieldValue(MaskGroundediceLevelsetEnum,0.,DistanceToGroundinglineEnum);
    4950
    50         femmodel->elements->InputDuplicate(MaskIceLevelsetEnum,DistanceToCalvingfrontEnum);
     51        InputDuplicatex(femmodel,MaskIceLevelsetEnum,DistanceToCalvingfrontEnum);
    5152        femmodel->DistanceToFieldValue(MaskIceLevelsetEnum,0.,DistanceToCalvingfrontEnum);
    5253
    … …  
    6061                distances=xNew<IssmDouble>(numvertices);
    6162                element->GetInputListOnVertices(&distances[0],DistanceToGroundinglineEnum);
    62                 element->inputs->GetInputValue(&basinid,BasalforcingsPicoBasinIdEnum);
     63                element->GetInputValue(&basinid,BasalforcingsPicoBasinIdEnum);
    6364                for(int k=0; k<numvertices; k++){
    6465                        if(fabs(distances[k])>maxdist_cpu){maxdist_cpu=fabs(distances[k]);}
    … …  
    116117                Element* basalelement = element->SpawnBasalElement();
    117118                if(!basalelement->IsIceInElement() || !basalelement->IsFloating()) continue;
    118                 basalelement->inputs->GetInputValue(&boxid,BasalforcingsPicoBoxIdEnum);
    119                 basalelement->inputs->GetInputValue(&basinid,BasalforcingsPicoBasinIdEnum);
     119                basalelement->GetInputValue(&boxid,BasalforcingsPicoBoxIdEnum);
     120                basalelement->GetInputValue(&basinid,BasalforcingsPicoBasinIdEnum);
    120121                boxareas[basinid*maxbox+boxid]+=basalelement->GetHorizontalSurfaceArea();
    121122                basalelement->FindParam(&domaintype,DomainTypeEnum);
    … …  
    165166                if(!basalelement->IsIceInElement() || !basalelement->IsFloating()) continue;
    166167                int el_boxid;
    167                 basalelement->inputs->GetInputValue(&el_boxid,BasalforcingsPicoBoxIdEnum);
     168                basalelement->GetInputValue(&el_boxid,BasalforcingsPicoBoxIdEnum);
    168169                if(el_boxid!=boxid) continue;
    169170
    170                 Input* tocs_input=basalelement->GetInput(BasalforcingsPicoSubShelfOceanTempEnum); _assert_(tocs_input);
    171                 Input* socs_input=basalelement->GetInput(BasalforcingsPicoSubShelfOceanSalinityEnum); _assert_(socs_input);
    172 
    173                 basalelement->inputs->GetInputValue(&basinid,BasalforcingsPicoBasinIdEnum);
     171                Input2* tocs_input=basalelement->GetInput2(BasalforcingsPicoSubShelfOceanTempEnum); _assert_(tocs_input);
     172                Input2* socs_input=basalelement->GetInput2(BasalforcingsPicoSubShelfOceanSalinityEnum); _assert_(socs_input);
     173
     174                basalelement->GetInputValue(&basinid,BasalforcingsPicoBasinIdEnum);
    174175                Gauss* gauss=basalelement->NewGauss(1); gauss->GaussPoint(0);
    175176                tocs_input->GetInputValue(&toc,gauss);
    … …  
    206207                        if(!basalelement->IsIceInElement() || !basalelement->IsFloating()) continue;
    207208                        int el_boxid;
    208                         basalelement->inputs->GetInputValue(&el_boxid,BasalforcingsPicoBoxIdEnum);
     209                        basalelement->GetInputValue(&el_boxid,BasalforcingsPicoBoxIdEnum);
    209210                        if(el_boxid!=boxid) continue;
    210211
    211                 Input* overturnings_input=basalelement->GetInput(BasalforcingsPicoSubShelfOceanOverturningEnum); _assert_(overturnings_input);
    212 
    213                         basalelement->inputs->GetInputValue(&basinid,BasalforcingsPicoBasinIdEnum);
     212                Input2* overturnings_input=basalelement->GetInput2(BasalforcingsPicoSubShelfOceanOverturningEnum); _assert_(overturnings_input);
     213
     214                        basalelement->GetInputValue(&basinid,BasalforcingsPicoBasinIdEnum);
    214215                        Gauss* gauss=basalelement->NewGauss(1); gauss->GaussPoint(0);
    215216                        overturnings_input->GetInputValue(&overturning,gauss);

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

    r24145 r24335  
    66#include "../../shared/shared.h"
    77#include "../../toolkits/toolkits.h"
     8#include "./../../classes/Inputs2/DatasetInput2.h"
    89
    910void FloatingiceMeltingRatex(FemModel* femmodel){/*{{{*/
    … …  
    102103                if(!element->IsIceInElement() || !element->IsFloating() || !element->IsOnBase()){
    103104                        IssmDouble* values = xNewZeroInit<IssmDouble>(numvertices);
    104                         element->AddInput(BasalforcingsFloatingiceMeltingRateEnum,values,P1Enum);
    105                         element->AddInput(BasalforcingsIsmip6TfShelfEnum,values,P1Enum);
     105                        element->AddInput2(BasalforcingsFloatingiceMeltingRateEnum,values,P1DGEnum);
     106                        element->AddInput2(BasalforcingsIsmip6TfShelfEnum,values,P1DGEnum);
    106107                        xDelete<IssmDouble>(values);
    107108                        continue;
    … …  
    109110
    110111                /*Get TF on all vertices*/
    111                 IssmDouble* tf_test        = xNew<IssmDouble>(numvertices);
    112                 IssmDouble* depth_vertices = xNew<IssmDouble>(numvertices);
    113                 Input*      tf_input = element->GetInput(BasalforcingsIsmip6TfEnum); _assert_(tf_input);
     112                IssmDouble*    tf_test        = xNew<IssmDouble>(numvertices);
     113                IssmDouble*    depth_vertices = xNew<IssmDouble>(numvertices);
     114                DatasetInput2* tf_input = element->GetDatasetInput2(BasalforcingsIsmip6TfEnum); _assert_(tf_input);
    114115
    115116                element->GetInputListOnVertices(&depth_vertices[0],BaseEnum);
    … …  
    148149                }
    149150
    150                 element->AddInput(BasalforcingsIsmip6TfShelfEnum,tf_test,P1Enum);
     151                element->AddInput2(BasalforcingsIsmip6TfShelfEnum,tf_test,P1DGEnum);
    151152                xDelete<IssmDouble>(tf_test);
    152153                xDelete<IssmDouble>(depth_vertices);
    … …  
    161162                        /*Spawn basal element if on base to compute element area*/
    162163                        Element* basalelement = element->SpawnBasalElement();
    163                         Input* tf_input=basalelement->GetInput(BasalforcingsIsmip6TfShelfEnum); _assert_(tf_input);
    164                         basalelement->inputs->GetInputValue(&basinid,BasalforcingsIsmip6BasinIdEnum);
     164                        Input2* tf_input=basalelement->GetInput2(BasalforcingsIsmip6TfShelfEnum); _assert_(tf_input);
     165                        basalelement->GetInputValue(&basinid,BasalforcingsIsmip6BasinIdEnum);
    165166                        Gauss* gauss=basalelement->NewGauss(1); gauss->GaussPoint(0);
    166167                        tf_input->GetInputValue(&tf,gauss);

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

    r23311 r24335  
    102102
    103103        /*Get active vector first*/
    104         Vector<IssmDouble>*   activevector=NULL;
    105         IssmPDouble*          vector=NULL;
    106         int                   size;
     104        Vector<IssmDouble> *activevector = NULL;
     105        IssmPDouble        *vector       = NULL;
     106        int                size;
    107107
    108108        /*Retrieve some parameters*/

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

    r23066 r24335  
    8787        /*We go find the input of the first element, and query its interpolation type: */
    8888        Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(0));
    89         Input* input=element->GetInput(name);
     89        Input2* input=element->GetInput2(name);
    9090        if (!input) _error_("could not find input: " << name);
    9191

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

    r18521 r24335  
    99
    1010void InputDuplicatex(FemModel* femmodel,int original_enum, int new_enum){
    11         /*Go through elemnets, and ask to reinitialie the input: */
    12         for(int i=0;i<femmodel->elements->Size();i++){
    13                 Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
    14                 element->InputDuplicate(original_enum,new_enum);
    15         }
     11        femmodel->inputs2->DuplicateInput(original_enum,new_enum);
    1612}

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

    r23648 r24335  
    66#include "../../shared/shared.h"
    77#include "../../toolkits/toolkits.h"
     8#include "../../classes/Inputs2/Inputs2.h"
    89
    910void InputUpdateFromConstantx(FemModel* femmodel,bool constant, int name){
    … …  
    4950        }
    5051}
    51 void InputUpdateFromConstantx(Elements* elements,IssmDouble constant, int name){
     52void InputUpdateFromConstantx(Inputs2* inputs2,Elements* elements,IssmDouble constant, int name){
    5253
    5354        if(VerboseModule()) _printf0_("   Input updates from constant\n");
    … …  
    5657        for(int i=0;i<elements->Size();i++){
    5758                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    58                 element->InputUpdateFromConstant(constant,name);
     59                element->SetElementInput(inputs2,name,constant);
     60                //element->InputUpdateFromConstant(constant,name);
    5961        }
    6062}

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

    r16218 r24335  
    77
    88#include "../../classes/classes.h"
     9class Inputs2;
    910
    1011/* local prototypes: */
    … …  
    1213void InputUpdateFromConstantx(FemModel* femmodel,int        constant,int name);
    1314void InputUpdateFromConstantx(FemModel* femmodel,IssmDouble constant,int name);
    14 void InputUpdateFromConstantx(Elements* elements,IssmDouble constant,int name);
     15void InputUpdateFromConstantx(Inputs2* inputs2,Elements* elements,IssmDouble constant,int name);
    1516
    1617#endif  /* _UPDATEINPUTSFROMCONSTANTXX_H */

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

    r23867 r24335  
    99#include "../ModelProcessorx.h"
    1010
    11 void    UpdateElementsAndMaterialsControl(Elements* elements,Parameters* parameters,Materials* materials, IoModel* iomodel){
     11void    UpdateElementsAndMaterialsControl(Elements* elements,Parameters* parameters,Inputs2* inputs2,Materials* materials, IoModel* iomodel){
    1212        /*Intermediary*/
    1313        bool       control_analysis;
     14        int        M,N;
    1415        int        control,cost_function,domaintype;
    1516        int        num_controls,num_cost_functions;
    16         Element   *element          = NULL;
    17         Material  *material         = NULL;
    18         int       *control_enums    = NULL;
    19         char     **controls         = NULL;
    20         char     **cost_functions   = NULL;
     17        IssmDouble yts,scale;
     18        Element     *element          = NULL;
     19        Material    *material         = NULL;
     20        int         *control_enums    = NULL;
     21        char       **controls         = NULL;
     22        char       **cost_functions   = NULL;
     23        IssmDouble  *independent      = NULL;
     24        IssmDouble  *independents_min = NULL;
     25        IssmDouble  *independents_max = NULL;
     26        IssmDouble  *weights          = NULL;
     27
     28        /*Fetch parameters: */
     29        iomodel->FindConstant(&control_analysis,"md.inversion.iscontrol");
     30        if(!control_analysis) return;
    2131
    2232        /*Fetch parameters: */
    … …  
    2434        iomodel->FindConstant(&isautodiff,"md.autodiff.isautodiff");
    2535        if(isautodiff){
    26                 UpdateElementsAndMaterialsControlAD(elements,parameters,materials,iomodel);
     36                UpdateElementsAndMaterialsControlAD(elements,parameters,inputs2,materials,iomodel);
    2737                return;
    2838        }
    2939
    30         /*Fetch parameters: */
    31         iomodel->FindConstant(&control_analysis,"md.inversion.iscontrol");
    32         if(control_analysis) iomodel->FindConstant(&num_controls,"md.inversion.num_control_parameters");
    33 
    34         /*Now, return if no control*/
    35         if(!control_analysis) return;
    36 
    3740        /*Process controls and convert from string to enums*/
     41        iomodel->FindConstant(&num_controls,"md.inversion.num_control_parameters");
    3842        iomodel->FindConstant(&controls,&num_controls,"md.inversion.control_parameters");
    3943        if(num_controls<1) _error_("no controls found");
    … …  
    5256        }
    5357
    54         iomodel->FetchData(3,"md.inversion.cost_functions_coefficients","md.inversion.min_parameters","md.inversion.max_parameters");
    55 
    56         /*Fetch Observations */
     58        /*Fetch Observations and add to inputs*/
    5759        iomodel->FindConstant(&domaintype,"md.mesh.domain_type");
     60        iomodel->FindConstant(&yts,"md.constants.yts");
     61        iomodel->FetchData(&weights,&M,&N,"md.inversion.cost_functions_coefficients");
     62
     63        /*Transpose weights for simplicity!*/
     64        if(M*N && N>1){
     65                IssmDouble* weights_transp = xNew<IssmDouble>(M*N);
     66                for(int i=0;i<M;i++) for(int j=0;j<N;j++) weights_transp[j*M+i] = weights[i*N+j];
     67                xDelete<IssmDouble>(weights);
     68                weights = weights_transp;
     69        }
     70
     71        if(M!=iomodel->numberofvertices && N!=num_cost_functions) _error_("not supported");
    5872        for(int i=0;i<num_cost_functions;i++){
    5973                cost_function=cost_function_enums[i];
    60                 if(     cost_function==ThicknessAbsMisfitEnum) iomodel->FetchDataToInput(elements,"md.inversion.thickness_obs",InversionThicknessObsEnum);
    61                 else if(cost_function==SurfaceAbsMisfitEnum)   iomodel->FetchDataToInput(elements,"md.inversion.surface_obs",InversionSurfaceObsEnum);
    62                 else if(cost_function==RheologyBInitialguessMisfitEnum) iomodel->FetchDataToInput(elements,"md.materials.rheology_B",RheologyBInitialguessEnum);
     74                if(     cost_function==ThicknessAbsMisfitEnum) iomodel->FetchDataToInput(inputs2,elements,"md.inversion.thickness_obs",InversionThicknessObsEnum);
     75                else if(cost_function==SurfaceAbsMisfitEnum)   iomodel->FetchDataToInput(inputs2,elements,"md.inversion.surface_obs",InversionSurfaceObsEnum);
     76                else if(cost_function==RheologyBInitialguessMisfitEnum) iomodel->FetchDataToInput(inputs2,elements,"md.materials.rheology_B",RheologyBInitialguessEnum);
    6377                else if(cost_function==SurfaceAbsVelMisfitEnum
    6478                          || cost_function==SurfaceRelVelMisfitEnum
    … …  
    6680                          || cost_function==SurfaceLogVxVyMisfitEnum
    6781                          || cost_function==SurfaceAverageVelMisfitEnum){
    68                         iomodel->FetchDataToInput(elements,"md.inversion.vx_obs",InversionVxObsEnum);
    69                         if(domaintype!=Domain2DverticalEnum) iomodel->FetchDataToInput(elements,"md.inversion.vy_obs",InversionVyObsEnum);
     82                        iomodel->FetchDataToInput(inputs2,elements,"md.inversion.vx_obs",InversionVxObsEnum);
     83                        if(domaintype!=Domain2DverticalEnum) iomodel->FetchDataToInput(inputs2,elements,"md.inversion.vy_obs",InversionVyObsEnum);
     84                }
     85                for(int j=0;j<elements->Size();j++){
     86                        Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(j));
     87                        element->DatasetInputAdd(InversionCostFunctionsCoefficientsEnum,&weights[i*iomodel->numberofvertices],inputs2,iomodel,M,1,1,cost_function,7,cost_function);
    7088                }
    7189        }
    7290        parameters->AddObject(new IntParam(ControlInputSizeMEnum,iomodel->numberofvertices));
     91        xDelete<IssmDouble>(weights);
     92
     93        /*Get controls*/
     94        iomodel->FetchData(&independents_min,&M,&N,"md.inversion.min_parameters");
     95        if(M!=iomodel->numberofvertices && N!=num_controls) _error_("not supported");
     96        iomodel->FetchData(&independents_max,&M,&N,"md.inversion.max_parameters");
     97        if(M!=iomodel->numberofvertices && N!=num_controls) _error_("not supported");
     98
     99        /*Transpose weights for simplicity!*/
     100        if(M*N && N>1){
     101                IssmDouble* independents_min_transp = xNew<IssmDouble>(M*N);
     102                for(int i=0;i<M;i++) for(int j=0;j<N;j++) independents_min_transp[j*M+i] = independents_min[i*N+j];
     103                xDelete<IssmDouble>(independents_min);
     104                independents_min = independents_min_transp;
     105
     106                IssmDouble* independents_max_transp = xNew<IssmDouble>(M*N);
     107                for(int i=0;i<M;i++) for(int j=0;j<N;j++) independents_max_transp[j*M+i] = independents_max[i*N+j];
     108                xDelete<IssmDouble>(independents_max);
     109                independents_max = independents_max_transp;
     110        }
    73111
    74112        for(int i=0;i<num_controls;i++){
    75113                control = control_enums[i];
     114                scale   = 1.;
     115
    76116                switch(control){
    77117                        /*List of supported controls*/
    78                         case BalancethicknessThickeningRateEnum:      iomodel->FetchData(1,"md.balancethickness.thickening_rate"); break;
    79                         case BalancethicknessSpcthicknessEnum:        iomodel->FetchData(1,"md.balancethickness.spcthickness"); break;
    80                         case VxEnum:                                  iomodel->FetchData(1,"md.initialization.vx"); break;
    81                         case VyEnum:                                  iomodel->FetchData(1,"md.initialization.vy"); break;
    82                         case ThicknessEnum:                           iomodel->FetchData(1,"md.geometry.thickness"); break;
    83                         case FrictionCoefficientEnum:                 iomodel->FetchData(1,"md.friction.coefficient"); break;
    84                         case FrictionAsEnum:                          iomodel->FetchData(1,"md.friction.As"); break;
    85                         case BalancethicknessApparentMassbalanceEnum: iomodel->FetchData(1,"md.balancethickness.apparent_massbalance"); break;
    86                         case BalancethicknessOmegaEnum:               iomodel->FetchData(1,"md.balancethickness.omega"); break;
    87                         case MaterialsRheologyBEnum:                  iomodel->FetchData(1,"md.materials.rheology_B"); break;
     118                        case BalancethicknessThickeningRateEnum:      iomodel->FetchData(&independent,&M,&N,"md.balancethickness.thickening_rate");scale = 1./yts; break;
     119                        case BalancethicknessSpcthicknessEnum:        iomodel->FetchData(&independent,&M,&N,"md.balancethickness.spcthickness");                   break;
     120                        case VxEnum:                                  iomodel->FetchData(&independent,&M,&N,"md.initialization.vx");scale = 1./yts;                break;
     121                        case VyEnum:                                  iomodel->FetchData(&independent,&M,&N,"md.initialization.vy");scale = 1./yts;                break;
     122                        case ThicknessEnum:                           iomodel->FetchData(&independent,&M,&N,"md.geometry.thickness");                              break;
     123                        case FrictionCoefficientEnum:                 iomodel->FetchData(&independent,&M,&N,"md.friction.coefficient");                            break;
     124                        case FrictionAsEnum:                          iomodel->FetchData(&independent,&M,&N,"md.friction.As");                                     break;
     125                        case BalancethicknessApparentMassbalanceEnum: iomodel->FetchData(&independent,&M,&N,"md.balancethickness.apparent_massbalance");           break;
     126                        case BalancethicknessOmegaEnum:               iomodel->FetchData(&independent,&M,&N,"md.balancethickness.omega");                          break;
     127                        case MaterialsRheologyBEnum:                  iomodel->FetchData(&independent,&M,&N,"md.materials.rheology_B");                            break;
    88128                        /*Special cases*/
    89                         case MaterialsRheologyBbarEnum: iomodel->FetchData(1,"md.materials.rheology_B"); break;
    90                         case DamageDbarEnum:            iomodel->FetchData(1,"md.damage.D");            break;
     129                        case MaterialsRheologyBbarEnum:               iomodel->FetchData(&independent,&M,&N,"md.materials.rheology_B");                            break;
     130                        case DamageDbarEnum:                          iomodel->FetchData(&independent,&M,&N,"md.damage.D");                                        break;
    91131                        default:
    92132                                _error_("Control " << EnumToStringx(control) << " not implemented yet");
    93133                }
    94         }
    95 
    96         /*Update elements: */
    97         int counter=0;
    98         for(int i=0;i<iomodel->numberofelements;i++){
    99                 if(iomodel->my_elements[i]){
    100                         element=(Element*)elements->GetObjectByOffset(counter);
    101                         element->InputUpdateFromIoModel(i,iomodel); //we need i to index into elements.
    102                         counter++;
    103                 }
    104         }
     134                if(M!=iomodel->numberofvertices && N!=1) _error_("not supported yet");
     135
     136                /*Special case if 3d*/
     137                if(iomodel->domaintype==Domain3DEnum){
     138                        if(control==MaterialsRheologyBbarEnum) control=MaterialsRheologyBEnum;
     139                        if(control==DamageDbarEnum)            control=DamageDEnum;
     140                }
     141
     142                for(int j=0;j<elements->Size();j++){
     143                        Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(j));
     144                        element->ControlInputCreate(independent,&independents_min[i*iomodel->numberofvertices],&independents_max[i*iomodel->numberofvertices],inputs2,iomodel,M,N,scale,control,i+1);
     145                }
     146                xDelete<IssmDouble>(independent);
     147        }
     148        xDelete<IssmDouble>(independents_min);
     149        xDelete<IssmDouble>(independents_max);
     150
    105151
    106152        /*Free data: */
    … …  
    126172        }
    127173
    128         iomodel->DeleteData(3,"md.inversion.cost_functions_coefficients","md.inversion.min_parameters","md.inversion.max_parameters");
    129174        xDelete<int>(control_enums);
    130175        xDelete<int>(cost_function_enums);
    … …  
    134179        xDelete<char*>(controls);
    135180}
    136 void UpdateElementsAndMaterialsControlAD(Elements* elements,Parameters* parameters,Materials* materials, IoModel* iomodel){
     181void UpdateElementsAndMaterialsControlAD(Elements* elements,Parameters* parameters,Inputs2* inputs2,Materials* materials, IoModel* iomodel){
    137182
    138183        #if defined(_HAVE_AD_)
    … …  
    206251                        for(int j=0;j<elements->Size();j++){
    207252                                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(j));
    208                                 element->ControlInputCreate(independent,independents_min,independents_max,iomodel,M,N,input_enum,i+1);
     253                                element->ControlInputCreate(independent,independents_min,independents_max,inputs2,iomodel,M,N,1.,input_enum,i+1);
    209254                        }
    210255                        xDelete<IssmDouble>(independent);

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

    r24066 r24335  
    4848        /*Create elements*/
    4949        if(control_analysis && !adolc_analysis)iomodel->FetchData(2,"md.inversion.min_parameters","md.inversion.max_parameters");
    50 
     50        if(iomodel->domaintype==Domain2DverticalEnum || iomodel->domaindim==3)  iomodel->FetchData(2,"md.mesh.vertexonbase","md.mesh.vertexonsurface");
     51
     52        int count = 0;
    5153        switch(iomodel->meshelementtype){
    5254                case TriaEnum:
    5355                        for(int i=0;i<iomodel->numberofelements;i++){
    54                                 if(iomodel->my_elements[i]) elements->AddObject(new Tria(i+1,i,iomodel,nummodels));
     56                                if(iomodel->my_elements[i]){
     57                                        elements->AddObject(new Tria(i+1,i,count,iomodel,nummodels));
     58                                        count++;
     59                                }
    5560                        }
    5661                        break;
    5762                case TetraEnum:
    5863                        for(int i=0;i<iomodel->numberofelements;i++){
    59                                 if(iomodel->my_elements[i]) elements->AddObject(new Tetra(i+1,i,iomodel,nummodels));
     64                                if(iomodel->my_elements[i]){
     65                                        elements->AddObject(new Tetra(i+1,i,count,iomodel,nummodels));
     66                                        count++;
     67                                }
    6068                        }
    6169                        break;
    … …  
    6371                        iomodel->FetchData(2,"md.mesh.upperelements","md.mesh.lowerelements");
    6472                        for(int i=0;i<iomodel->numberofelements;i++){
    65                                 if(iomodel->my_elements[i]) elements->AddObject(new Penta(i+1,i,iomodel,nummodels));
     73                                if(iomodel->my_elements[i]){
     74                                        elements->AddObject(new Penta(i+1,i,count,iomodel,nummodels));
     75                                        count++;
     76                                }
    6677                        }
    6778                        break;
    … …  
    7182
    7283        /*Free data: */
    73         iomodel->DeleteData(4,"md.mesh.upperelements","md.mesh.lowerelements","md.inversion.min_parameters","md.inversion.max_parameters");
    74 }/*}}}*/
    75 void CreateMaterials(Elements* elements,Materials* materials,IoModel* iomodel,const int nummodels){/*{{{*/
     84        iomodel->DeleteData(6,"md.mesh.upperelements","md.mesh.lowerelements","md.inversion.min_parameters","md.inversion.max_parameters","md.mesh.vertexonbase","md.mesh.vertexonsurface");
     85
     86}/*}}}*/
     87void CreateMaterials(Elements* elements,Inputs2* inputs2,Materials* materials,IoModel* iomodel,const int nummodels){/*{{{*/
    7688
    7789        /*Intermediary*/
    … …  
    8496        iomodel->FindConstant(&materials_type,"md.materials.type");
    8597
    86         /*Did we already create the materiaas? : */
     98        /*Did we already create the materials? : */
    8799        _assert_(materials->Size()==0);
    88100
    … …  
    90102        switch(materials_type){
    91103                case MaticeEnum:
    92                         iomodel->FetchDataToInput(elements,"md.materials.rheology_B",MaterialsRheologyBEnum);
    93                         iomodel->FetchDataToInput(elements,"md.materials.rheology_n",MaterialsRheologyNEnum);
     104                        iomodel->FetchDataToInput(inputs2,elements,"md.materials.rheology_B",MaterialsRheologyBEnum);
     105                        iomodel->FetchDataToInput(inputs2,elements,"md.materials.rheology_n",MaterialsRheologyNEnum);
    94106                        for (i=0;i<iomodel->numberofelements;i++) if(iomodel->my_elements[i]) materials->AddObject(new Matice(i+1,i,iomodel));
    95107                        switch(iomodel->domaindim){
    96108                                case 2:
    97                                         elements->InputDuplicate(MaterialsRheologyBEnum,MaterialsRheologyBbarEnum);
     109                                        inputs2->DuplicateInput(MaterialsRheologyBEnum,MaterialsRheologyBbarEnum);
    98110                                        break;
    99111                                case 3:
    … …  
    104116                        break;
    105117                case MatenhancediceEnum:
    106                         iomodel->FetchDataToInput(elements,"md.materials.rheology_B",MaterialsRheologyBEnum);
    107                         iomodel->FetchDataToInput(elements,"md.materials.rheology_n",MaterialsRheologyNEnum);
    108                         iomodel->FetchDataToInput(elements,"md.materials.rheology_E",MaterialsRheologyEEnum);
     118                        iomodel->FetchDataToInput(inputs2,elements,"md.materials.rheology_B",MaterialsRheologyBEnum);
     119                        iomodel->FetchDataToInput(inputs2,elements,"md.materials.rheology_n",MaterialsRheologyNEnum);
     120                        iomodel->FetchDataToInput(inputs2,elements,"md.materials.rheology_E",MaterialsRheologyEEnum);
    109121                        for (i=0;i<iomodel->numberofelements;i++) if(iomodel->my_elements[i]) materials->AddObject(new Matice(i+1,i,iomodel));
    110122                        switch(iomodel->domaindim){
    111123                                case 2:
    112                                         elements->InputDuplicate(MaterialsRheologyBEnum,MaterialsRheologyBbarEnum);
    113                                         elements->InputDuplicate(MaterialsRheologyEEnum,MaterialsRheologyEbarEnum);
     124                                        inputs2->DuplicateInput(MaterialsRheologyBEnum,MaterialsRheologyBbarEnum);
     125                                        inputs2->DuplicateInput(MaterialsRheologyEEnum,MaterialsRheologyEbarEnum);
    114126                                        break;
    115127                                case 3:
    … …  
    120132                        break;
    121133                case MatdamageiceEnum:
    122                         iomodel->FetchDataToInput(elements,"md.materials.rheology_B",MaterialsRheologyBEnum);
    123                         iomodel->FetchDataToInput(elements,"md.materials.rheology_n",MaterialsRheologyNEnum);
    124                         iomodel->FetchDataToInput(elements,"md.damage.D",DamageDEnum);
     134                        iomodel->FetchDataToInput(inputs2,elements,"md.materials.rheology_B",MaterialsRheologyBEnum);
     135                        iomodel->FetchDataToInput(inputs2,elements,"md.materials.rheology_n",MaterialsRheologyNEnum);
     136                        iomodel->FetchDataToInput(inputs2,elements,"md.damage.D",DamageDEnum);
    125137                        for (i=0;i<iomodel->numberofelements;i++) if(iomodel->my_elements[i]) materials->AddObject(new Matice(i+1,i,iomodel));
    126138                        switch(iomodel->domaindim){
    127139                                case 2:
    128                                         elements->InputDuplicate(MaterialsRheologyBEnum,MaterialsRheologyBbarEnum);
    129                                         elements->InputDuplicate(DamageDEnum,DamageDbarEnum);
     140                                        inputs2->DuplicateInput(MaterialsRheologyBEnum,MaterialsRheologyBbarEnum);
     141                                        inputs2->DuplicateInput(DamageDEnum,DamageDbarEnum);
    130142                                        break;
    131143                                case 3:
    … …  
    136148                        break;
    137149                case MatestarEnum:
    138                         iomodel->FetchDataToInput(elements,"md.materials.rheology_B",MaterialsRheologyBEnum);
    139                         iomodel->FetchDataToInput(elements,"md.materials.rheology_Ec",MaterialsRheologyEcEnum);
    140                         iomodel->FetchDataToInput(elements,"md.materials.rheology_Es",MaterialsRheologyEsEnum);
     150                        iomodel->FetchDataToInput(inputs2,elements,"md.materials.rheology_B",MaterialsRheologyBEnum);
     151                        iomodel->FetchDataToInput(inputs2,elements,"md.materials.rheology_Ec",MaterialsRheologyEcEnum);
     152                        iomodel->FetchDataToInput(inputs2,elements,"md.materials.rheology_Es",MaterialsRheologyEsEnum);
    141153                        for(i=0;i<iomodel->numberofelements;i++) if(iomodel->my_elements[i]) materials->AddObject(new Matestar(i+1,i,iomodel));
    142154                        switch(iomodel->domaindim){
    143155                                case 2:
    144                                         elements->InputDuplicate(MaterialsRheologyBEnum,MaterialsRheologyBbarEnum);
    145                                         elements->InputDuplicate(MaterialsRheologyEcEnum,MaterialsRheologyEcbarEnum);
    146                                         elements->InputDuplicate(MaterialsRheologyEsEnum,MaterialsRheologyEsbarEnum);
     156                                        inputs2->DuplicateInput(MaterialsRheologyBEnum,MaterialsRheologyBbarEnum);
     157                                        inputs2->DuplicateInput(MaterialsRheologyEcEnum,MaterialsRheologyEcbarEnum);
     158                                        inputs2->DuplicateInput(MaterialsRheologyEsEnum,MaterialsRheologyEsbarEnum);
    147159                                        break;
    148160                                case 3:
    … …  
    170182                                switch(IoCodeToEnumMaterials(nature[i])){ //{{{
    171183                                        case MaticeEnum:
    172                                                 iomodel->FetchDataToInput(elements,"md.materials.rheology_B",MaterialsRheologyBEnum);
    173                                                 iomodel->FetchDataToInput(elements,"md.materials.rheology_n",MaterialsRheologyNEnum);
     184                                                iomodel->FetchDataToInput(inputs2,elements,"md.materials.rheology_B",MaterialsRheologyBEnum);
     185                                                iomodel->FetchDataToInput(inputs2,elements,"md.materials.rheology_n",MaterialsRheologyNEnum);
    174186                                                for (i=0;i<iomodel->numberofelements;i++) if(iomodel->my_elements[i]) materials->AddObject(new Matice(i+1,i,iomodel));
    175187                                                switch(iomodel->domaindim){
    176188                                                        case 2:
    177                                                                 elements->InputDuplicate(MaterialsRheologyBEnum,MaterialsRheologyBbarEnum);
     189                                                                inputs2->DuplicateInput(MaterialsRheologyBEnum,MaterialsRheologyBbarEnum);
    178190                                                                break;
    179191                                                        case 3:
    … …  
    190202
    191203                                        case MatenhancediceEnum:
    192                                                 iomodel->FetchDataToInput(elements,"md.materials.rheology_B",MaterialsRheologyBEnum);
    193                                                 iomodel->FetchDataToInput(elements,"md.materials.rheology_n",MaterialsRheologyNEnum);
    194                                                 iomodel->FetchDataToInput(elements,"md.materials.rheology_E",MaterialsRheologyEEnum);
     204                                                iomodel->FetchDataToInput(inputs2,elements,"md.materials.rheology_B",MaterialsRheologyBEnum);
     205                                                iomodel->FetchDataToInput(inputs2,elements,"md.materials.rheology_n",MaterialsRheologyNEnum);
     206                                                iomodel->FetchDataToInput(inputs2,elements,"md.materials.rheology_E",MaterialsRheologyEEnum);
    195207                                                for (i=0;i<iomodel->numberofelements;i++) if(iomodel->my_elements[i]) materials->AddObject(new Matice(i+1,i,iomodel));
    196208                                                switch(iomodel->domaindim){
    197209                                                        case 2:
    198                                                                 elements->InputDuplicate(MaterialsRheologyBEnum,MaterialsRheologyBbarEnum);
    199                                                                 elements->InputDuplicate(MaterialsRheologyEEnum,MaterialsRheologyEbarEnum);
     210                                                                inputs2->DuplicateInput(MaterialsRheologyBEnum,MaterialsRheologyBbarEnum);
     211                                                                inputs2->DuplicateInput(MaterialsRheologyEEnum,MaterialsRheologyEbarEnum);
    200212                                                                break;
    201213                                                        case 3:
    … …  
    206218                                                break;
    207219                                        case MatdamageiceEnum:
    208                                                 iomodel->FetchDataToInput(elements,"md.materials.rheology_B",MaterialsRheologyBEnum);
    209                                                 iomodel->FetchDataToInput(elements,"md.materials.rheology_n",MaterialsRheologyNEnum);
    210                                                 iomodel->FetchDataToInput(elements,"md.damage.D",DamageDEnum);
     220                                                iomodel->FetchDataToInput(inputs2,elements,"md.materials.rheology_B",MaterialsRheologyBEnum);
     221                                                iomodel->FetchDataToInput(inputs2,elements,"md.materials.rheology_n",MaterialsRheologyNEnum);
     222                                                iomodel->FetchDataToInput(inputs2,elements,"md.damage.D",DamageDEnum);
    211223                                                for (i=0;i<iomodel->numberofelements;i++) if(iomodel->my_elements[i]) materials->AddObject(new Matice(i+1,i,iomodel));
    212224                                                switch(iomodel->domaindim){
    213225                                                        case 2:
    214                                                                 elements->InputDuplicate(MaterialsRheologyBEnum,MaterialsRheologyBbarEnum);
    215                                                                 elements->InputDuplicate(DamageDEnum,DamageDbarEnum);
     226                                                                inputs2->DuplicateInput(MaterialsRheologyBEnum,MaterialsRheologyBbarEnum);
     227                                                                inputs2->DuplicateInput(DamageDEnum,DamageDbarEnum);
    216228                                                                break;
    217229                                                        case 3:
    … …  
    222234                                                break;
    223235                                        case MatestarEnum:
    224                                                 iomodel->FetchDataToInput(elements,"md.materials.rheology_B",MaterialsRheologyBEnum);
    225                                                 iomodel->FetchDataToInput(elements,"md.materials.rheology_Ec",MaterialsRheologyEcEnum);
    226                                                 iomodel->FetchDataToInput(elements,"md.materials.rheology_Es",MaterialsRheologyEsEnum);
     236                                                iomodel->FetchDataToInput(inputs2,elements,"md.materials.rheology_B",MaterialsRheologyBEnum);
     237                                                iomodel->FetchDataToInput(inputs2,elements,"md.materials.rheology_Ec",MaterialsRheologyEcEnum);
     238                                                iomodel->FetchDataToInput(inputs2,elements,"md.materials.rheology_Es",MaterialsRheologyEsEnum);
    227239                                                for(i=0;i<iomodel->numberofelements;i++) if(iomodel->my_elements[i]) materials->AddObject(new Matestar(i+1,i,iomodel));
    228240                                                switch(iomodel->domaindim){
    229241                                                        case 2:
    230                                                                 elements->InputDuplicate(MaterialsRheologyBEnum,MaterialsRheologyBbarEnum);
    231                                                                 elements->InputDuplicate(MaterialsRheologyEcEnum,MaterialsRheologyEcbarEnum);
    232                                                                 elements->InputDuplicate(MaterialsRheologyEsEnum,MaterialsRheologyEsbarEnum);
     242                                                                inputs2->DuplicateInput(MaterialsRheologyBEnum,MaterialsRheologyBbarEnum);
     243                                                                inputs2->DuplicateInput(MaterialsRheologyEcEnum,MaterialsRheologyEcbarEnum);
     244                                                                inputs2->DuplicateInput(MaterialsRheologyEsEnum,MaterialsRheologyEsbarEnum);
    233245                                                                break;
    234246                                                        case 3:
    … …  
    405417                iomodel->FetchData(6,"md.mesh.x","md.mesh.y","md.mesh.z","md.geometry.base","md.geometry.thickness","md.mask.ice_levelset");
    406418                if (iomodel->domaintype == Domain3DsurfaceEnum) iomodel->FetchData(3,"md.mesh.lat","md.mesh.long","md.mesh.r");
    407                 else iomodel->FetchDataToInput(elements,"md.mesh.scale_factor",MeshScaleFactorEnum,1.);
    408419                if (isoceancoupling) iomodel->FetchData(2,"md.mesh.lat","md.mesh.long");
    409420
    … …  
    453464
    454465        /*Finalize Initialization*/
    455         vertices->Finalize();
    456 }/*}}}*/
     466        vertices->Finalize(iomodel);
     467}/*}}}*/

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

    r24205 r24335  
    88#include "./ModelProcessorx.h"
    99
    10 void CreateOutputDefinitions(Elements* elements, Parameters* parameters,IoModel* iomodel){
     10void CreateOutputDefinitions(Elements* elements,Parameters* parameters,Inputs2* inputs2,IoModel* iomodel){
    1111
    1212        int i,j;
    … …  
    120120                                        for(int k=0;k<elements->Size();k++){
    121121                                                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(k));
    122                                                 element->InputCreate(misfit_observation_s[j], iomodel,misfit_observation_M_s[j],misfit_observation_N_s[j],obs_vector_type,StringToEnumx(misfit_observation_string_s[j]),7);
    123                                                 element->InputCreate(misfit_weights_s[j], iomodel,misfit_weights_M_s[j],misfit_weights_N_s[j],weight_vector_type,StringToEnumx(misfit_weights_string_s[j]),7);
     122                                                element->InputCreate(misfit_observation_s[j],inputs2,iomodel,misfit_observation_M_s[j],misfit_observation_N_s[j],obs_vector_type,StringToEnumx(misfit_observation_string_s[j]),7);
     123                                                element->InputCreate(misfit_weights_s[j],inputs2,iomodel,misfit_weights_M_s[j],misfit_weights_N_s[j],weight_vector_type,StringToEnumx(misfit_weights_string_s[j]),7);
    124124                                        }
    125125
    … …  
    130130                                        char* string=NULL;
    131131                                        IssmDouble* matrix = NULL;
    132 
    133132                                        string = misfit_definitionstring_s[j];          xDelete<char>(string);
    134133                                        string = misfit_observation_string_s[j];        xDelete<char>(string);
    … …  
    210209                                        /*Now, for this particular cfsurfacesquare object, make sure we plug into the elements: the observation, and the weights.*/
    211210                                        for(int k=0;k<elements->Size();k++){
    212 
    213211                                                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(k));
    214 
    215                                                 element->DatasetInputAdd(StringToEnumx(cfsurfacesquare_definitionstring_s[j]),cfsurfacesquare_observation_s[j], iomodel,cfsurfacesquare_observation_M_s[j],cfsurfacesquare_observation_N_s[j],obs_vector_type,StringToEnumx(cfsurfacesquare_observation_string_s[j]),7,SurfaceObservationEnum);
    216                                                 element->DatasetInputAdd(StringToEnumx(cfsurfacesquare_definitionstring_s[j]),cfsurfacesquare_weights_s[j], iomodel,cfsurfacesquare_weights_M_s[j],cfsurfacesquare_weights_N_s[j],weight_vector_type,StringToEnumx(cfsurfacesquare_weights_string_s[j]),7,WeightsSurfaceObservationEnum);
     212                                                element->DatasetInputAdd(StringToEnumx(cfsurfacesquare_definitionstring_s[j]),cfsurfacesquare_observation_s[j],inputs2,iomodel,cfsurfacesquare_observation_M_s[j],cfsurfacesquare_observation_N_s[j],obs_vector_type,StringToEnumx(cfsurfacesquare_observation_string_s[j]),7,SurfaceObservationEnum);
     213                                                element->DatasetInputAdd(StringToEnumx(cfsurfacesquare_definitionstring_s[j]),cfsurfacesquare_weights_s[j],inputs2,iomodel,cfsurfacesquare_weights_M_s[j],cfsurfacesquare_weights_N_s[j],weight_vector_type,StringToEnumx(cfsurfacesquare_weights_string_s[j]),7,WeightsSurfaceObservationEnum);
    217214
    218215                                        }
    … …  
    285282                                                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(k));
    286283
    287                                                 element->DatasetInputAdd(StringToEnumx(cfdragcoeffabsgrad_definitionstring_s[j]),cfdragcoeffabsgrad_weights_s[j], iomodel,cfdragcoeffabsgrad_weights_M_s[j],cfdragcoeffabsgrad_weights_N_s[j],weight_vector_type,StringToEnumx(cfdragcoeffabsgrad_weights_string_s[j]),7,WeightsSurfaceObservationEnum);
     284                                                element->DatasetInputAdd(StringToEnumx(cfdragcoeffabsgrad_definitionstring_s[j]),cfdragcoeffabsgrad_weights_s[j],inputs2,iomodel,cfdragcoeffabsgrad_weights_M_s[j],cfdragcoeffabsgrad_weights_N_s[j],weight_vector_type,StringToEnumx(cfdragcoeffabsgrad_weights_string_s[j]),7,WeightsSurfaceObservationEnum);
    288285
    289286                                        }
    … …  
    368365                                                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(k));
    369366
    370                                                 element->DatasetInputAdd(StringToEnumx(cfsurfacelogvel_definitionstring[j]),cfsurfacelogvel_vxobs[j], iomodel,cfsurfacelogvel_observation_M[j],cfsurfacelogvel_observation_N[j],obs_vector_type,StringToEnumx(cfsurfacelogvel_vxobs_string[j]),7,VxObsEnum);
    371                                                         element->DatasetInputAdd(StringToEnumx(cfsurfacelogvel_definitionstring[j]),cfsurfacelogvel_vyobs[j], iomodel,cfsurfacelogvel_observation_M[j],cfsurfacelogvel_observation_N[j],obs_vector_type,StringToEnumx(cfsurfacelogvel_vyobs_string[j]),7,VyObsEnum);
    372                                                 element->DatasetInputAdd(StringToEnumx(cfsurfacelogvel_definitionstring[j]),cfsurfacelogvel_weights[j], iomodel,cfsurfacelogvel_weights_M[j],cfsurfacelogvel_weights_N[j],weight_vector_type,StringToEnumx(cfsurfacelogvel_weightstring[j]),7,WeightsSurfaceObservationEnum);
     367                                                element->DatasetInputAdd(StringToEnumx(cfsurfacelogvel_definitionstring[j]),cfsurfacelogvel_vxobs[j],inputs2,iomodel,cfsurfacelogvel_observation_M[j],cfsurfacelogvel_observation_N[j],obs_vector_type,StringToEnumx(cfsurfacelogvel_vxobs_string[j]),7,VxObsEnum);
     368                                                        element->DatasetInputAdd(StringToEnumx(cfsurfacelogvel_definitionstring[j]),cfsurfacelogvel_vyobs[j],inputs2,iomodel,cfsurfacelogvel_observation_M[j],cfsurfacelogvel_observation_N[j],obs_vector_type,StringToEnumx(cfsurfacelogvel_vyobs_string[j]),7,VyObsEnum);
     369                                                element->DatasetInputAdd(StringToEnumx(cfsurfacelogvel_definitionstring[j]),cfsurfacelogvel_weights[j],inputs2,iomodel,cfsurfacelogvel_weights_M[j],cfsurfacelogvel_weights_N[j],weight_vector_type,StringToEnumx(cfsurfacelogvel_weightstring[j]),7,WeightsSurfaceObservationEnum);
    373370
    374371                                        }
    … …  
    594591                                for(int i=0;i<num_cost_functions;i++){
    595592                                        cost_function=cost_function_enums[i];
    596                                         if(     cost_function==ThicknessAbsMisfitEnum) iomodel->FetchDataToInput(elements,"md.numberedcostfunction.thickness_obs",InversionThicknessObsEnum);
    597                                         else if(cost_function==SurfaceAbsMisfitEnum)   iomodel->FetchDataToInput(elements,"md.numberedcostfunction.surface_obs",InversionSurfaceObsEnum);
     593                                        if(     cost_function==ThicknessAbsMisfitEnum) iomodel->FetchDataToInput(inputs2,elements,"md.numberedcostfunction.thickness_obs",InversionThicknessObsEnum);
     594                                        else if(cost_function==SurfaceAbsMisfitEnum)   iomodel->FetchDataToInput(inputs2,elements,"md.numberedcostfunction.surface_obs",InversionSurfaceObsEnum);
    598595                                        else if(cost_function==SurfaceAbsVelMisfitEnum
    599596                                                        || cost_function==SurfaceRelVelMisfitEnum
    … …  
    601598                                                        || cost_function==SurfaceLogVxVyMisfitEnum
    602599                                                        || cost_function==SurfaceAverageVelMisfitEnum){
    603                                                 iomodel->FetchDataToInput(elements,"md.numberedcostfunction.vx_obs",InversionVxObsEnum);
    604                                                 if(domaintype!=Domain2DverticalEnum) iomodel->FetchDataToInput(elements,"md.numberedcostfunction.vy_obs",InversionVyObsEnum);
     600                                                iomodel->FetchDataToInput(inputs2,elements,"md.numberedcostfunction.vx_obs",InversionVxObsEnum);
     601                                                if(domaintype!=Domain2DverticalEnum) iomodel->FetchDataToInput(inputs2,elements,"md.numberedcostfunction.vy_obs",InversionVyObsEnum);
    605602                                        }
    606603                                }
    … …  
    611608                                        for(int k=0;k<elements->Size();k++){
    612609                                                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(k));
    613                                                 element->DatasetInputCreate(cost_functions_weights[j],cost_functions_weights_M[j],cost_functions_weights_N[j],cost_function_enums,num_cost_functions,iomodel,InversionCostFunctionsCoefficientsEnum);
     610                                                element->DatasetInputCreate(cost_functions_weights[j],cost_functions_weights_M[j],cost_functions_weights_N[j],cost_function_enums,num_cost_functions,inputs2,iomodel,InversionCostFunctionsCoefficientsEnum);
    614611                                        }
    615612                                        output_definitions->AddObject(new Numberedcostfunction(ncf_name_s[j],StringToEnumx(ncf_definitionstring_s[j]),num_cost_functions,cost_function_enums));

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

    r20696 r24335  
    99#include "../ModelProcessorx.h"
    1010
    11 void    UpdateElementsAndMaterialsDakota(Elements* elements,Materials* materials, IoModel* iomodel){
     11void    UpdateElementsAndMaterialsDakota(Elements* elements,Inputs2* inputs2,Materials* materials, IoModel* iomodel){
    1212
    1313        /*recover parameters: */
    … …  
    1515        iomodel->FindConstant(&dakota_analysis,"md.qmu.isdakota");
    1616
    17         if(dakota_analysis) iomodel->FetchDataToInput(elements,"md.geometry.hydrostatic_ratio",GeometryHydrostaticRatioEnum,0.);
     17        if(dakota_analysis) iomodel->FetchDataToInput(inputs2,elements,"md.geometry.hydrostatic_ratio",GeometryHydrostaticRatioEnum,0.);
    1818}

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

    r23582 r24335  
    1313#include "./ModelProcessorx.h"
    1414
    15 void ModelProcessorx(Elements** pelements, Nodes*** pnodes, Vertices** pvertices, Materials** pmaterials, Constraints*** pconstraints, Loads*** ploads, Parameters** pparameters,IoModel* iomodel,FILE* toolkitfile, char* rootpath,const int solution_enum,const int nummodels,const int* analysis_enum_list){
     15void ModelProcessorx(Elements** pelements, Nodes*** pnodes, Vertices** pvertices, Materials** pmaterials, Constraints*** pconstraints, Loads*** ploads, Parameters** pparameters,Inputs2** pinputs2,IoModel* iomodel,FILE* toolkitfile, char* rootpath,const int solution_enum,const int nummodels,const int* analysis_enum_list){
    1616        _assert_(nummodels>0);
    1717
    … …  
    4040        /*Create elements, vertices and materials, independent of analysis_enum: */
    4141        CreateElements(elements,iomodel,nummodels);
    42         CreateMaterials(elements,materials,iomodel,nummodels);
    4342        CreateVertices(elements,vertices,iomodel,solution_enum);
    4443        CreateParameters(parameters,iomodel,rootpath,toolkitfile,solution_enum);
     44
     45        /*Should move to CreateInputs2*/
     46        Inputs2 *inputs2 = new Inputs2(elements->Size(),vertices->Size());
     47        if (iomodel->domaintype != Domain3DsurfaceEnum) iomodel->FetchDataToInput(inputs2,elements,"md.mesh.scale_factor",MeshScaleFactorEnum,1.);
     48
     49        /*Can now do Materials since we have created Inputs*/
     50        CreateMaterials(elements,inputs2,materials,iomodel,nummodels);
    4551
    4652        /*Update datasets based on each analysis (and add nodes, constrains and loads)*/
    … …  
    5460                analysis->UpdateParameters(parameters,iomodel,solution_enum,analysis_enum);
    5561                analysis->CreateNodes(nodes[i],iomodel);
    56                 analysis->UpdateElements(elements,iomodel,i,analysis_enum);
     62                analysis->UpdateElements(elements,inputs2,iomodel,i,analysis_enum);
    5763                analysis->CreateConstraints(constraints[i],iomodel);
    5864                analysis->CreateLoads(loads[i],iomodel);
    … …  
    6773        /*Solution specific updates*/
    6874        if(VerboseMProcessor()) _printf0_("   updating elements and materials for control parameters" << "\n");
    69         UpdateElementsAndMaterialsControl(elements,parameters,materials,iomodel);
     75        UpdateElementsAndMaterialsControl(elements,parameters,inputs2,materials,iomodel);
    7076        #ifdef _HAVE_DAKOTA_
    7177        if(VerboseMProcessor()) _printf0_("   updating elements and materials for uncertainty quantification" << "\n");
    72         UpdateElementsAndMaterialsDakota(elements,materials,iomodel);
     78        UpdateElementsAndMaterialsDakota(elements,inputs2,materials,iomodel);
    7379        #endif
    74         if(solution_enum==TransientSolutionEnum) UpdateElementsTransient(elements,parameters,iomodel);
     80        if(solution_enum==TransientSolutionEnum) UpdateElementsTransient(elements,parameters,inputs2,iomodel);
    7581
    7682        /*Output definitions dataset: */
    7783        if(VerboseMProcessor()) _printf0_("   creating output definitions" << "\n");
    78         CreateOutputDefinitions(elements,parameters,iomodel);
     84        CreateOutputDefinitions(elements,parameters,inputs2,iomodel);
    7985
    8086        /* Sort datasets:
    … …  
    94100        *ploads       = loads;
    95101        *pparameters  = parameters;
     102        *pinputs2     = inputs2;
    96103
    97104        if(VerboseMProcessor()) _printf0_("   done with model processor \n");

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

    r23585 r24335  
    99#include "../../analyses/analyses.h"
    1010
    11 void ModelProcessorx(Elements** pelements, Nodes*** pnodes, Vertices** pvertices, Materials** pmaterials, Constraints*** pconstraints, Loads*** ploads, Parameters** pparameters,IoModel* iomodel,FILE* toolkitfile, char* rootpath,const int solution_type,const int nummodels,const int* analysis_type_listh);
     11void ModelProcessorx(Elements** pelements, Nodes*** pnodes, Vertices** pvertices, Materials** pmaterials, Constraints*** pconstraints, Loads*** ploads, Parameters** pparameters,Inputs2** pinputs2,IoModel* iomodel,FILE* toolkitfile, char* rootpath,const int solution_type,const int nummodels,const int* analysis_type_listh);
    1212
    1313/*Creation of fem datasets: general drivers*/
    1414void CreateElements(Elements* elements,IoModel* iomodel,int nummodels);
    15 void CreateMaterials(Elements* elements,Materials* materials,IoModel* iomodel,int nummodels);
     15void CreateMaterials(Elements* elements,Inputs2* inputs2,Materials* materials,IoModel* iomodel,int nummodels);
    1616void CreateVertices(Elements* elements,Vertices* vertices,IoModel* iomodel,int solution_type,bool isamr=false);
    1717void CreateParameters(Parameters*parameters,IoModel* iomodel,char* rootpath,FILE* toolkitfile,const int solution_type);
    … …  
    1919void CreateParametersControl(Parameters* parameters,IoModel* iomodel,int solution_type);
    2020void CreateParametersDakota(Parameters* parameters,IoModel* iomodel,char* rootpath);
    21 void CreateOutputDefinitions(Elements* elements, Parameters* parameters,IoModel* iomodel);
    22 void UpdateElementsAndMaterialsControl(Elements* elements,Parameters* parameters,Materials* materials, IoModel* iomodel);
    23 void UpdateElementsAndMaterialsControlAD(Elements* elements,Parameters* parameters,Materials* materials, IoModel* iomodel);
    24 void UpdateElementsAndMaterialsDakota(Elements* elements,Materials* materials, IoModel* iomodel);
    25 void UpdateElementsTransient(Elements* elements,Parameters* parameters,IoModel* iomodel);
     21void CreateOutputDefinitions(Elements* elements, Parameters* parameters,Inputs2* inputs2,IoModel* iomodel);
     22void UpdateElementsAndMaterialsControl(Elements* elements,Parameters* parameters,Inputs2* inputs2,Materials* materials, IoModel* iomodel);
     23void UpdateElementsAndMaterialsControlAD(Elements* elements,Parameters* parameters,Inputs2* inputs2,Materials* materials, IoModel* iomodel);
     24void UpdateElementsAndMaterialsDakota(Elements* elements,Inputs2* inputs2,Materials* materials, IoModel* iomodel);
     25void UpdateElementsTransient(Elements* elements,Parameters* parameters,Inputs2* inputs2,IoModel* iomodel);
    2626void CreateNodes(Nodes*nodes, IoModel* iomodel,int analysis,int finite_element,bool isamr=false,int approximation=NoneApproximationEnum,int* approximations=NULL);
    2727

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

    r23399 r24335  
    99#include "../ModelProcessorx.h"
    1010
    11 void    UpdateElementsTransient(Elements* elements, Parameters* parameters,IoModel* iomodel){
     11void    UpdateElementsTransient(Elements* elements, Parameters* parameters,Inputs2* inputs2,IoModel* iomodel){
    1212
    1313        /*FIXME: this should go into parameterization update*/
    … …  
    1717
    1818        if(isgroundingline){
    19                 iomodel->FetchDataToInput(elements,"md.geometry.bed",BedEnum);
     19                iomodel->FetchDataToInput(inputs2,elements,"md.geometry.bed",BedEnum);
    2020        }
    2121}

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

    r23867 r24335  
    77#include "../../shared/shared.h"
    88#include "../../toolkits/toolkits.h"
     9#include "../../classes/Inputs2/DatasetInput2.h"
    910
    1011void RheologyBAbsGradientx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters){
    … …  
    5354
    5455        /*Retrieve all inputs we will be needing: */
    55         Input* weights_input=element->GetInput(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
    56         Input* rheologyb_input=element->GetInput(MaterialsRheologyBEnum);                  _assert_(rheologyb_input);
     56        DatasetInput2* weights_input=element->GetDatasetInput2(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
     57        Input2* rheologyb_input=element->GetInput2(MaterialsRheologyBEnum);                  _assert_(rheologyb_input);
    5758
    5859        /* Start  looping on the number of gaussian points: */
    … …  
    124125
    125126        /*Retrieve all inputs we will be needing: */
    126         Input* weights_input=element->GetInput(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
    127         Input* rheologyb_input=element->GetInput(MaterialsRheologyBbarEnum);            _assert_(rheologyb_input);
    128         Input* rheologyb0_input=element->GetInput(RheologyBInitialguessEnum);           _assert_(rheologyb0_input);
     127        DatasetInput2* weights_input=element->GetDatasetInput2(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
     128        Input2* rheologyb_input=element->GetInput2(MaterialsRheologyBbarEnum);            _assert_(rheologyb_input);
     129        Input2* rheologyb0_input=element->GetInput2(RheologyBInitialguessEnum);           _assert_(rheologyb0_input);
    129130
    130131        /* Start  looping on the number of gaussian points: */

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

    r18521 r24335  
    77#include "../../shared/shared.h"
    88#include "../../toolkits/toolkits.h"
     9#include "../../classes/Inputs2/DatasetInput2.h"
    910
    1011void RheologyBbarAbsGradientx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters){
    … …  
    5960
    6061        /*Retrieve all inputs we will be needing: */
    61         Input* weights_input=basalelement->GetInput(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
    62         Input* rheologyb_input=basalelement->GetInput(MaterialsRheologyBbarEnum);                  _assert_(rheologyb_input);
     62        DatasetInput2* weights_input=basalelement->GetDatasetInput2(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
     63        Input2* rheologyb_input=basalelement->GetInput2(MaterialsRheologyBbarEnum);                  _assert_(rheologyb_input);
    6364
    6465        /* Start  looping on the number of gaussian points: */

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

    r23636 r24335  
    2727                        case TaylorHoodEnum:case XTaylorHoodEnum:case LATaylorHoodEnum:
    2828                        case CrouzeixRaviartEnum:case LACrouzeixRaviartEnum:case OneLayerP4zEnum:{
    29                                 Input* input=element->GetInput(IceMaskNodeActivationEnum);
     29                                Input2* input=element->GetInput2(IceMaskNodeActivationEnum);
    3030                                if(!input) _error_("Input " << EnumToStringx(IceMaskNodeActivationEnum) << " not found in element");
    3131

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

    r22438 r24335  
    77#include "../../shared/shared.h"
    88#include "../../toolkits/toolkits.h"
     9#include "../../classes/Inputs2/DatasetInput2.h"
    910
    1011void SurfaceAbsVelMisfitx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters){
    … …  
    5960
    6061        /*Retrieve all inputs we will be needing: */
    61         Input* weights_input=topelement->GetInput(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
    62         Input* vx_input     =topelement->GetInput(VxEnum);                                 _assert_(vx_input);
    63         Input* vxobs_input  =topelement->GetInput(InversionVxObsEnum);                     _assert_(vxobs_input);
    64         Input* vy_input     = NULL;
    65         Input* vyobs_input  = NULL;
     62        DatasetInput2* weights_input=topelement->GetDatasetInput2(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
     63        Input2* vx_input     =topelement->GetInput2(VxEnum);                                 _assert_(vx_input);
     64        Input2* vxobs_input  =topelement->GetInput2(InversionVxObsEnum);                     _assert_(vxobs_input);
     65        Input2* vy_input     = NULL;
     66        Input2* vyobs_input  = NULL;
    6667        if(numcomponents==2){
    67                 vy_input    =topelement->GetInput(VyEnum);              _assert_(vy_input);
    68                 vyobs_input =topelement->GetInput(InversionVyObsEnum);  _assert_(vyobs_input);
     68                vy_input    =topelement->GetInput2(VyEnum);              _assert_(vy_input);
     69                vyobs_input =topelement->GetInput2(InversionVyObsEnum);  _assert_(vyobs_input);
    6970        }
    7071

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

    r18521 r24335  
    88#include "../../toolkits/toolkits.h"
    99#include "../SurfaceAreax/SurfaceAreax.h"
     10#include "../../classes/Inputs2/DatasetInput2.h"
    1011
    1112void SurfaceAverageVelMisfitx(IssmDouble* pJ,FemModel* femmodel){
    … …  
    6768        /*Retrieve all inputs we will be needing: */
    6869        topelement->GetInputValue(&S,SurfaceAreaEnum);
    69         Input* weights_input=topelement->GetInput(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
    70         Input* vx_input     =topelement->GetInput(VxEnum);                                 _assert_(vx_input);
    71         Input* vxobs_input  =topelement->GetInput(InversionVxObsEnum);                     _assert_(vxobs_input);
    72         Input* vy_input     = NULL;
    73         Input* vyobs_input  = NULL;
     70        DatasetInput2* weights_input=topelement->GetDatasetInput2(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
     71        Input2* vx_input     =topelement->GetInput2(VxEnum);                                 _assert_(vx_input);
     72        Input2* vxobs_input  =topelement->GetInput2(InversionVxObsEnum);                     _assert_(vxobs_input);
     73        Input2* vy_input     = NULL;
     74        Input2* vyobs_input  = NULL;
    7475        if(numcomponents==2){
    75                 vy_input    =topelement->GetInput(VyEnum);              _assert_(vy_input);
    76                 vyobs_input =topelement->GetInput(InversionVyObsEnum);  _assert_(vyobs_input);
     76                vy_input    =topelement->GetInput2(VyEnum);              _assert_(vy_input);
     77                vyobs_input =topelement->GetInput2(InversionVyObsEnum);  _assert_(vyobs_input);
    7778        }
    7879

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

    r22438 r24335  
    44
    55#include "./SurfaceLogVelMisfitx.h"
    6 
    76#include "../../shared/shared.h"
    87#include "../../toolkits/toolkits.h"
     8#include "../../classes/Inputs2/DatasetInput2.h"
    99
    1010void SurfaceLogVelMisfitx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters){
    … …  
    6262
    6363        /*Retrieve all inputs we will be needing: */
    64         Input* weights_input=topelement->GetInput(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
    65         Input* vx_input     =topelement->GetInput(VxEnum);                                 _assert_(vx_input);
    66         Input* vxobs_input  =topelement->GetInput(InversionVxObsEnum);                     _assert_(vxobs_input);
    67         Input* vy_input     = NULL;
    68         Input* vyobs_input  = NULL;
     64        DatasetInput2* weights_input=topelement->GetDatasetInput2(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
     65        Input2* vx_input     =topelement->GetInput2(VxEnum);                                 _assert_(vx_input);
     66        Input2* vxobs_input  =topelement->GetInput2(InversionVxObsEnum);                     _assert_(vxobs_input);
     67        Input2* vy_input     = NULL;
     68        Input2* vyobs_input  = NULL;
    6969        if(numcomponents==2){
    70                 vy_input    =topelement->GetInput(VyEnum);              _assert_(vy_input);
    71                 vyobs_input =topelement->GetInput(InversionVyObsEnum);  _assert_(vyobs_input);
     70                vy_input    =topelement->GetInput2(VyEnum);              _assert_(vy_input);
     71                vyobs_input =topelement->GetInput2(InversionVyObsEnum);  _assert_(vyobs_input);
    7272        }
    7373

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

    r18521 r24335  
    77#include "../../shared/shared.h"
    88#include "../../toolkits/toolkits.h"
     9#include "../../classes/Inputs2/DatasetInput2.h"
    910
    1011void SurfaceLogVxVyMisfitx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters){
    … …  
    6162
    6263        /*Retrieve all inputs we will be needing: */
    63         Input* weights_input=topelement->GetInput(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
    64         Input* vx_input     =topelement->GetInput(VxEnum);                                 _assert_(vx_input);
    65         Input* vxobs_input  =topelement->GetInput(InversionVxObsEnum);                     _assert_(vxobs_input);
    66         Input* vy_input     = NULL;
    67         Input* vyobs_input  = NULL;
     64        DatasetInput2* weights_input=topelement->GetDatasetInput2(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
     65        Input2* vx_input     =topelement->GetInput2(VxEnum);                                 _assert_(vx_input);
     66        Input2* vxobs_input  =topelement->GetInput2(InversionVxObsEnum);                     _assert_(vxobs_input);
     67        Input2* vy_input     = NULL;
     68        Input2* vyobs_input  = NULL;
    6869        if(numcomponents==2){
    69                 vy_input    =topelement->GetInput(VyEnum);              _assert_(vy_input);
    70                 vyobs_input =topelement->GetInput(InversionVyObsEnum);  _assert_(vyobs_input);
     70                vy_input    =topelement->GetInput2(VyEnum);              _assert_(vy_input);
     71                vyobs_input =topelement->GetInput2(InversionVyObsEnum);  _assert_(vyobs_input);
    7172        }
    7273

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

    r23819 r24335  
    77#include "../../toolkits/toolkits.h"
    88#include "../modules.h"
     9#include "../../classes/Inputs2/TransientInput2.h"
    910
    1011void SmbForcingx(FemModel* femmodel){/*{{{*/
    … …  
    1314        //    INPUT parameters: ni: working size of arrays
    1415        //    OUTPUT: mass-balance (m/yr ice): agd(NA)
    15         bool isclimatology=false;
     16        bool isclimatology;
    1617        femmodel->parameters->FindParam(&isclimatology,SmbIsclimatologyEnum);
    1718
    1819        if (isclimatology){
    19                 int v;
    20                 IssmDouble time,dt,delta,starttime,finaltime;
    21                 int offsetend=-1;
    22                 IssmDouble time0, timeend, timeclim;
    23 
     20
     21                /*Get time parameters*/
     22                IssmDouble time,dt,starttime,finaltime;
    2423                femmodel->parameters->FindParam(&time,TimeEnum);
    2524                femmodel->parameters->FindParam(&dt,TimesteppingTimeStepEnum);
    … …  
    2726                femmodel->parameters->FindParam(&starttime,TimesteppingStartTimeEnum);
    2827               
    29                 if (time<=starttime+dt){
     28                if(time<=starttime+dt){
     29                        /*FIXME: this is wrong, should be done at the ElementUpdate step of analysis, not here!*/
    3030                        InputDuplicatex(femmodel,SmbMassBalanceEnum,SmbMassBalanceClimateEnum);
     31                        femmodel->inputs2->DeleteInput(SmbMassBalanceEnum);
     32                }
     33
     34                /*If this is a climatology, we need to repeat the forcing after the final time*/
     35                TransientInput2* smb_input=femmodel->inputs2->GetTransientInput(SmbMassBalanceClimateEnum); _assert_(smb_input);
     36
     37                /*Get accumulation climatology value*/
     38                int offsetend = smb_input->GetTimeInputOffset(finaltime);
     39                IssmDouble time0     = smb_input->GetTimeByOffset(-1);
     40                IssmDouble timeend   = smb_input->GetTimeByOffset(offsetend);
     41
     42                _assert_(timeend>time0);
     43                IssmDouble timeclim  = time;
     44
     45                if(time>time0 && timeend>time0){
     46                        IssmDouble delta=(time-time0) - (timeend-time0)*(reCast<int,IssmDouble>((time-time0)/(timeend-time0)));
     47                        if(delta==0.){
     48                                timeclim=timeend;
     49                        }
     50                        else{
     51                                timeclim=time0+delta;
     52                        }
    3153                }
    3254
    … …  
    3759                        int         numvertices = element->GetNumberOfVertices();
    3860                        IssmDouble* smb         = xNew<IssmDouble>(numvertices);
    39 
    40                         /*Recover Smb*/
    41                         //If this is a climatology, we need to repeat the forcing after the final time
    42                         Input* smb_input=element->GetInput(SmbMassBalanceClimateEnum); _assert_(smb_input);
    43 
    44                         //Get accumulation climatology value
    45                         offsetend=dynamic_cast<TransientInput*>(smb_input)->GetTimeInputOffset(finaltime);
    46                         time0=dynamic_cast<TransientInput*>(smb_input)->GetTimeByOffset(-1);
    47                         timeend=dynamic_cast<TransientInput*>(smb_input)->GetTimeByOffset(offsetend);
    48                         timeclim=time;
    49                         if (time>time0 & timeend>time0){
    50                                 delta=(time-time0) - (timeend-time0)*(reCast<int,IssmDouble>((time-time0)/(timeend-time0)));
    51                                 if (delta==0){ timeclim=timeend;}
    52                                 else{ timeclim=time0+delta;}
    53                         }
    54 
    5561                        element->GetInputListOnVerticesAtTime(smb,SmbMassBalanceClimateEnum,timeclim);
    5662
    5763                        /*Add input to element and Free memory*/
    58                         element->AddInput(SmbMassBalanceEnum,smb,P1Enum);
     64                        element->AddInput2(SmbMassBalanceEnum,smb,P1Enum);
    5965                        xDelete<IssmDouble>(smb);
    6066                }
    … …  
    115121
    116122                /*Add input to element and Free memory*/
    117                 element->AddInput(SmbMassBalanceEnum,smb,P1Enum);
     123                element->AddInput2(SmbMassBalanceEnum,smb,P1Enum);
    118124                xDelete<IssmDouble>(Href);
    119125                xDelete<IssmDouble>(Smbref);
    … …  
    179185
    180186                /*Add input to element and Free memory*/
    181                 element->AddInput(SmbMassBalanceEnum,smb,P1Enum);
     187                element->AddInput2(SmbMassBalanceEnum,smb,P1Enum);
    182188                xDelete<IssmDouble>(ela);
    183189                xDelete<IssmDouble>(b_pos);
    … …  
    389395
    390396                /*Add input to element and Free memory*/
    391                 element->AddInput(SmbMassBalanceEnum,smblist,P1Enum);
     397                element->AddInput2(SmbMassBalanceEnum,smblist,P1Enum);
    392398                xDelete<IssmDouble>(surfacelist);
    393399                xDelete<IssmDouble>(smblistref);
    … …  
    404410        //    surface runoff (m/yr water equivalent): runoff
    405411        //    OUTPUT: mass-balance (m/yr ice): agd(NA)
    406         int v;
    407         bool isclimatology=false;
    408         IssmDouble time,delta,starttime,finaltime;
    409         int offsetend=-1;
    410         IssmDouble time0, timeend, timeclim;
    411 
     412        bool isclimatology;
    412413        femmodel->parameters->FindParam(&isclimatology,SmbIsclimatologyEnum);
    413         femmodel->parameters->FindParam(&time,TimeEnum);
    414         femmodel->parameters->FindParam(&finaltime,TimesteppingFinalTimeEnum);
    415         femmodel->parameters->FindParam(&starttime,TimesteppingStartTimeEnum);
    416414
    417415        /*Loop over all the elements of this partition*/
    … …  
    427425
    428426                /*Recover Smb Components*/
    429                 if (isclimatology){
     427                if(isclimatology){
     428
     429                        int offsetend;
     430                        IssmDouble time0,timeend,timeclim;
     431                        IssmDouble time,starttime,finaltime;
     432
     433                        /*Get time parameters*/
     434                        femmodel->parameters->FindParam(&time,TimeEnum);
     435                        femmodel->parameters->FindParam(&finaltime,TimesteppingFinalTimeEnum);
     436                        femmodel->parameters->FindParam(&starttime,TimesteppingStartTimeEnum);
    430437
    431438                        //If this is a climatology, we need to repeat the forcing after the final time
    432                         Input* acc_input=element->GetInput(SmbAccumulationEnum); _assert_(acc_input);
    433                         Input* evap_input=element->GetInput(SmbEvaporationEnum); _assert_(evap_input);
    434                         Input* runoff_input=element->GetInput(SmbRunoffEnum); _assert_(runoff_input);
     439                        TransientInput2* acc_input    = element->inputs2->GetTransientInput(SmbAccumulationEnum); _assert_(acc_input);
     440                        TransientInput2* evap_input   = element->inputs2->GetTransientInput(SmbEvaporationEnum); _assert_(evap_input);
     441                        TransientInput2* runoff_input = element->inputs2->GetTransientInput(SmbRunoffEnum);      _assert_(runoff_input);
    435442
    436443                        //Get accumulation climatology value
    437                         offsetend=dynamic_cast<TransientInput*>(acc_input)->GetTimeInputOffset(finaltime);
    438                         time0=dynamic_cast<TransientInput*>(acc_input)->GetTimeByOffset(-1);
    439                         timeend=dynamic_cast<TransientInput*>(acc_input)->GetTimeByOffset(offsetend);
    440                         timeclim=time;
    441                         if (time>time0 & timeend>time0){
    442                                 delta=(time-time0) - (timeend-time0)*(reCast<int,IssmDouble>((time-time0)/(timeend-time0)));
    443                                 if (delta==0){ timeclim=timeend;}
    444                                 else{ timeclim=time0+delta;}
    445                         }
    446 
     444                        offsetend = acc_input->GetTimeInputOffset(finaltime);
     445                        time0     = acc_input->GetTimeByOffset(-1);
     446                        timeend   = acc_input->GetTimeByOffset(offsetend);
     447                        timeclim  = time;
     448                        if(time>time0 & timeend>time0){
     449                                IssmDouble delta=(time-time0) - (timeend-time0)*(reCast<int,IssmDouble>((time-time0)/(timeend-time0)));
     450                                if(delta==0.)
     451                                 timeclim=timeend;
     452                                else
     453                                 timeclim=time0+delta;
     454                        }
    447455                        element->GetInputListOnVerticesAtTime(acc,SmbAccumulationEnum,timeclim);
    448456
    449457                        //Get evaporation climatology value
    450                         offsetend=dynamic_cast<TransientInput*>(evap_input)->GetTimeInputOffset(finaltime);
    451                         time0=dynamic_cast<TransientInput*>(evap_input)->GetTimeByOffset(-1);
    452                         timeend=dynamic_cast<TransientInput*>(evap_input)->GetTimeByOffset(offsetend);
    453                         timeclim=time;
    454                         if (time>time0 & timeend>time0){
    455                                 delta=(time-time0) - (timeend-time0)*(reCast<int,IssmDouble>((time-time0)/(timeend-time0)));
    456                                 if (delta==0){ timeclim=timeend;}
    457                                 else{ timeclim=time0+delta;}
    458                         }
    459 
     458                        offsetend = evap_input->GetTimeInputOffset(finaltime);
     459                        time0     = evap_input->GetTimeByOffset(-1);
     460                        timeend   = evap_input->GetTimeByOffset(offsetend);
     461                        timeclim  = time;
     462                        if(time>time0 & timeend>time0){
     463                                IssmDouble delta=(time-time0) - (timeend-time0)*(reCast<int,IssmDouble>((time-time0)/(timeend-time0)));
     464                                if(delta==0.)
     465                                 timeclim=timeend;
     466                                else
     467                                 timeclim=time0+delta;
     468                        }
    460469                        element->GetInputListOnVerticesAtTime(evap,SmbEvaporationEnum,timeclim);
    461470
    462471                        //Get runoff climatology value
    463                         offsetend=dynamic_cast<TransientInput*>(runoff_input)->GetTimeInputOffset(finaltime);
    464                         time0=dynamic_cast<TransientInput*>(runoff_input)->GetTimeByOffset(-1);
    465                         timeend=dynamic_cast<TransientInput*>(runoff_input)->GetTimeByOffset(offsetend);
    466                         timeclim=time;
    467                         if (time>time0 & timeend>time0){
    468                                 delta=(time-time0) - (timeend-time0)*(reCast<int,IssmDouble>((time-time0)/(timeend-time0)));
    469                                 if (delta==0){ timeclim=timeend;}
    470                                 else{ timeclim=time0+delta;}
    471                         }
    472 
     472                        offsetend = runoff_input->GetTimeInputOffset(finaltime);
     473                        time0     = runoff_input->GetTimeByOffset(-1);
     474                        timeend   = runoff_input->GetTimeByOffset(offsetend);
     475                        timeclim  = time;
     476                        if(time>time0 & timeend>time0){
     477                                IssmDouble delta=(time-time0) - (timeend-time0)*(reCast<int,IssmDouble>((time-time0)/(timeend-time0)));
     478                                if(delta==0.)
     479                                 timeclim=timeend;
     480                                else
     481                                 timeclim=time0+delta;
     482                        }
    473483                        element->GetInputListOnVerticesAtTime(runoff,SmbRunoffEnum,timeclim);
    474484                }
    … …  
    480490
    481491                // loop over all vertices
    482                 for(v=0;v<numvertices;v++){
    483                         smb[v]=acc[v]-evap[v]-runoff[v];
    484                 }  //end of the loop over the vertices
     492                for(int v=0;v<numvertices;v++) smb[v]=acc[v]-evap[v]-runoff[v];
    485493
    486494                /*Add input to element and Free memory*/
    487                 element->AddInput(SmbMassBalanceEnum,smb,P1Enum);
     495                element->AddInput2(SmbMassBalanceEnum,smb,P1Enum);
    488496                xDelete<IssmDouble>(acc);
    489497                xDelete<IssmDouble>(evap);
    … …  
    502510        //    refreeze of surface melt (m/yr water equivalent): refreeze
    503511        //    OUTPUT: mass-balance (m/yr ice): agd(NA)
    504         int v;
    505         bool isclimatology=false;
    506         IssmDouble time,delta,starttime,finaltime;
    507         int offsetend=-1;
    508         IssmDouble time0, timeend, timeclim;
    509 
     512        bool isclimatology;
    510513        femmodel->parameters->FindParam(&isclimatology,SmbIsclimatologyEnum);
    511         femmodel->parameters->FindParam(&time,TimeEnum);
    512         femmodel->parameters->FindParam(&finaltime,TimesteppingFinalTimeEnum);
    513         femmodel->parameters->FindParam(&starttime,TimesteppingStartTimeEnum);
    514514
    515515        /*Loop over all the elements of this partition*/
    … …  
    528528                if (isclimatology){
    529529
     530                        int offsetend;
     531                        IssmDouble time0,timeend,timeclim;
     532                        IssmDouble time,starttime,finaltime;
     533                        femmodel->parameters->FindParam(&time,TimeEnum);
     534                        femmodel->parameters->FindParam(&finaltime,TimesteppingFinalTimeEnum);
     535                        femmodel->parameters->FindParam(&starttime,TimesteppingStartTimeEnum);
     536
     537
    530538                        //If this is a climatology, we need to repeat the forcing after the final time
    531                         Input* acc_input=element->GetInput(SmbAccumulationEnum); _assert_(acc_input);
    532                         Input* evap_input=element->GetInput(SmbEvaporationEnum); _assert_(evap_input);
    533                         Input* melt_input=element->GetInput(SmbMeltEnum); _assert_(melt_input);
    534                         Input* refreeze_input=element->GetInput(SmbRefreezeEnum); _assert_(refreeze_input);
     539                        TransientInput2* acc_input      = element->inputs2->GetTransientInput(SmbAccumulationEnum); _assert_(acc_input);
     540                        TransientInput2* evap_input     = element->inputs2->GetTransientInput(SmbEvaporationEnum); _assert_(evap_input);
     541                        TransientInput2* melt_input     = element->inputs2->GetTransientInput(SmbMeltEnum);        _assert_(melt_input);
     542                        TransientInput2* refreeze_input = element->inputs2->GetTransientInput(SmbRefreezeEnum);    _assert_(refreeze_input);
    535543
    536544                        //Get accumulation climatology value
    537                         offsetend=dynamic_cast<TransientInput*>(acc_input)->GetTimeInputOffset(finaltime);
    538                         time0=dynamic_cast<TransientInput*>(acc_input)->GetTimeByOffset(-1);
    539                         timeend=dynamic_cast<TransientInput*>(acc_input)->GetTimeByOffset(offsetend);
    540                         timeclim=time;
    541                         if (time>time0 & timeend>time0){
    542                                 delta=(time-time0) - (timeend-time0)*(reCast<int,IssmDouble>((time-time0)/(timeend-time0)));
    543                                 if (delta==0){ timeclim=timeend;}
    544                                 else{ timeclim=time0+delta;}
    545                         }
    546 
     545                        offsetend = acc_input->GetTimeInputOffset(finaltime);
     546                        time0     = acc_input->GetTimeByOffset(-1);
     547                        timeend   = acc_input->GetTimeByOffset(offsetend);
     548                        timeclim  = time;
     549                        if(time>time0 & timeend>time0){
     550                                IssmDouble delta=(time-time0) - (timeend-time0)*(reCast<int,IssmDouble>((time-time0)/(timeend-time0)));
     551                                if(delta==0.)
     552                                 timeclim=timeend;
     553                                else
     554                                 timeclim=time0+delta;
     555                        }
    547556                        element->GetInputListOnVerticesAtTime(acc,SmbAccumulationEnum,timeclim);
    548557
    549558                        //Get evaporation climatology value
    550                         offsetend=dynamic_cast<TransientInput*>(evap_input)->GetTimeInputOffset(finaltime);
    551                         time0=dynamic_cast<TransientInput*>(evap_input)->GetTimeByOffset(-1);
    552                         timeend=dynamic_cast<TransientInput*>(evap_input)->GetTimeByOffset(offsetend);
    553                         timeclim=time;
    554                         if (time>time0){
    555                                 delta=(time-time0) - (timeend-time0)*(reCast<int,IssmDouble>((time-time0)/(timeend-time0)));
    556                                 if (delta==0){ timeclim=timeend;}
    557                                 else{ timeclim=time0+delta;}
    558                         }
    559 
     559                        offsetend = evap_input->GetTimeInputOffset(finaltime);
     560                        time0     = evap_input->GetTimeByOffset(-1);
     561                        timeend   = evap_input->GetTimeByOffset(offsetend);
     562                        timeclim  = time;
     563                        if(time>time0 & timeend>time0){
     564                                IssmDouble delta=(time-time0) - (timeend-time0)*(reCast<int,IssmDouble>((time-time0)/(timeend-time0)));
     565                                if(delta==0.)
     566                                 timeclim=timeend;
     567                                else
     568                                 timeclim=time0+delta;
     569                        }
    560570                        element->GetInputListOnVerticesAtTime(evap,SmbEvaporationEnum,timeclim);
    561571
    562572                        //Get melt climatology value
    563                         offsetend=dynamic_cast<TransientInput*>(melt_input)->GetTimeInputOffset(finaltime);
    564                         time0=dynamic_cast<TransientInput*>(melt_input)->GetTimeByOffset(-1);
    565                         timeend=dynamic_cast<TransientInput*>(melt_input)->GetTimeByOffset(offsetend);
    566                         timeclim=time;
    567                         if (time>time0){
    568                                 delta=(time-time0) - (timeend-time0)*(reCast<int,IssmDouble>((time-time0)/(timeend-time0)));
    569                                 if (delta==0){ timeclim=timeend;}
    570                                 else{ timeclim=time0+delta;}
    571                         }
    572 
     573                        offsetend = melt_input->GetTimeInputOffset(finaltime);
     574                        time0     = melt_input->GetTimeByOffset(-1);
     575                        timeend   = melt_input->GetTimeByOffset(offsetend);
     576                        timeclim  = time;
     577                        if(time>time0 & timeend>time0){
     578                                IssmDouble delta=(time-time0) - (timeend-time0)*(reCast<int,IssmDouble>((time-time0)/(timeend-time0)));
     579                                if(delta==0.)
     580                                 timeclim=timeend;
     581                                else
     582                                 timeclim=time0+delta;
     583                        }
    573584                        element->GetInputListOnVerticesAtTime(melt,SmbMeltEnum,timeclim);
    574585
    575586                        //Get refreeze climatology value
    576                         offsetend=dynamic_cast<TransientInput*>(refreeze_input)->GetTimeInputOffset(finaltime);
    577                         time0=dynamic_cast<TransientInput*>(refreeze_input)->GetTimeByOffset(-1);
    578                         timeend=dynamic_cast<TransientInput*>(refreeze_input)->GetTimeByOffset(offsetend);
    579                         timeclim=time;
    580                         if (time>time0){
    581                                 delta=(time-time0) - (timeend-time0)*(reCast<int,IssmDouble>((time-time0)/(timeend-time0)));
    582                                 if (delta==0){ timeclim=timeend;}
    583                                 else{ timeclim=time0+delta;}
    584                         }
    585 
     587                        offsetend = refreeze_input->GetTimeInputOffset(finaltime);
     588                        time0     = refreeze_input->GetTimeByOffset(-1);
     589                        timeend   = refreeze_input->GetTimeByOffset(offsetend);
     590                        timeclim  = time;
     591                        if(time>time0 & timeend>time0){
     592                                IssmDouble delta=(time-time0) - (timeend-time0)*(reCast<int,IssmDouble>((time-time0)/(timeend-time0)));
     593                                if(delta==0.)
     594                                 timeclim=timeend;
     595                                else
     596                                 timeclim=time0+delta;
     597                        }
    586598                        element->GetInputListOnVerticesAtTime(refreeze,SmbRefreezeEnum,timeclim);
    587599                }
    … …  
    594606
    595607                // loop over all vertices
    596                 for(v=0;v<numvertices;v++){
    597                         smb[v]=acc[v]-evap[v]-melt[v]+refreeze[v];
    598                 }  //end of the loop over the vertices
     608                for(int v=0;v<numvertices;v++) smb[v]=acc[v]-evap[v]-melt[v]+refreeze[v];
    599609
    600610                /*Add input to element and Free memory*/
    601                 element->AddInput(SmbMassBalanceEnum,smb,P1Enum);
     611                element->AddInput2(SmbMassBalanceEnum,smb,P1Enum);
    602612                xDelete<IssmDouble>(acc);
    603613                xDelete<IssmDouble>(evap);

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

    r22438 r24335  
    77#include "../../shared/shared.h"
    88#include "../../toolkits/toolkits.h"
     9#include "../../classes/Inputs2/DatasetInput2.h"
    910
    1011void SurfaceRelVelMisfitx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters){
    … …  
    6162
    6263        /*Retrieve all inputs we will be needing: */
    63         Input* weights_input=topelement->GetInput(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
    64         Input* vx_input     =topelement->GetInput(VxEnum);                                 _assert_(vx_input);
    65         Input* vxobs_input  =topelement->GetInput(InversionVxObsEnum);                     _assert_(vxobs_input);
    66         Input* vy_input     = NULL;
    67         Input* vyobs_input  = NULL;
     64        DatasetInput2* weights_input=topelement->GetDatasetInput2(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
     65        Input2* vx_input     =topelement->GetInput2(VxEnum);                                 _assert_(vx_input);
     66        Input2* vxobs_input  =topelement->GetInput2(InversionVxObsEnum);                     _assert_(vxobs_input);
     67        Input2* vy_input     = NULL;
     68        Input2* vyobs_input  = NULL;
    6869        if(numcomponents==2){
    69                 vy_input    =topelement->GetInput(VyEnum);              _assert_(vy_input);
    70                 vyobs_input =topelement->GetInput(InversionVyObsEnum);  _assert_(vyobs_input);
     70                vy_input    =topelement->GetInput2(VyEnum);              _assert_(vy_input);
     71                vyobs_input =topelement->GetInput2(InversionVyObsEnum);  _assert_(vyobs_input);
    7172        }
    7273

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

    r18521 r24335  
    77#include "../../shared/shared.h"
    88#include "../../toolkits/toolkits.h"
     9#include "../../classes/Inputs2/DatasetInput2.h"
    910
    1011void ThicknessAbsMisfitx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters){
    … …  
    4344
    4445        /*Retrieve all inputs we will be needing: */
    45         Input* weights_input     =element->GetInput(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
    46         Input* thickness_input   =element->GetInput(ThicknessEnum);                          _assert_(thickness_input);
    47         Input* thicknessobs_input=element->GetInput(InversionThicknessObsEnum);              _assert_(thicknessobs_input);
     46        DatasetInput2* weights_input     =element->GetDatasetInput2(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
     47        Input2* thickness_input   =element->GetInput2(ThicknessEnum);                          _assert_(thickness_input);
     48        Input2* thicknessobs_input=element->GetInput2(InversionThicknessObsEnum);              _assert_(thicknessobs_input);
    4849
    4950        /* Start  looping on the number of gaussian points: */

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

    r18521 r24335  
    77#include "../../shared/shared.h"
    88#include "../../toolkits/toolkits.h"
     9#include "../../classes/Inputs2/DatasetInput2.h"
    910
    1011void ThicknessAcrossGradientx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters){
    … …  
    4546
    4647        /*Retrieve all inputs we will be needing: */
    47         Input* weights_input   =element->GetInput(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
    48         Input* thickness_input =element->GetInput(ThicknessEnum);                          _assert_(thickness_input);
    49         Input* vx_input        =element->GetInput(VxEnum);                                 _assert_(vx_input);
    50         Input* vy_input        =element->GetInput(VyEnum);                                 _assert_(vy_input);
     48        DatasetInput2* weights_input   =element->GetDatasetInput2(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
     49        Input2* thickness_input =element->GetInput2(ThicknessEnum);                          _assert_(thickness_input);
     50        Input2* vx_input        =element->GetInput2(VxEnum);                                 _assert_(vx_input);
     51        Input2* vy_input        =element->GetInput2(VyEnum);                                 _assert_(vy_input);
    5152
    5253        /* Start  looping on the number of gaussian points: */

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

    r18521 r24335  
    77#include "../../shared/shared.h"
    88#include "../../toolkits/toolkits.h"
     9#include "../../classes/Inputs2/DatasetInput2.h"
    910
    1011void ThicknessAlongGradientx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters){
    … …  
    4546
    4647        /*Retrieve all inputs we will be needing: */
    47         Input* weights_input   =element->GetInput(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
    48         Input* thickness_input =element->GetInput(ThicknessEnum);                          _assert_(thickness_input);
    49         Input* vx_input        =element->GetInput(VxEnum);                                 _assert_(vx_input);
    50         Input* vy_input        =element->GetInput(VyEnum);                                 _assert_(vy_input);
     48        DatasetInput2* weights_input   =element->GetDatasetInput2(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
     49        Input2* thickness_input =element->GetInput2(ThicknessEnum);                          _assert_(thickness_input);
     50        Input2* vx_input        =element->GetInput2(VxEnum);                                 _assert_(vx_input);
     51        Input2* vy_input        =element->GetInput2(VyEnum);                                 _assert_(vy_input);
    5152
    5253        /* Start  looping on the number of gaussian points: */

  • issm/trunk-jpl/src/c/shared/Enum/Enum.vim

    r24259 r24335  
    282282syn keyword cConstant OutputFilePointerEnum
    283283syn keyword cConstant OutputdefinitionEnum
    284 syn keyword cConstant ParamEnum
    285 syn keyword cConstant ParametersEnum
    286284syn keyword cConstant QmuErrNameEnum
    287285syn keyword cConstant QmuInNameEnum
    … …  
    475473syn keyword cConstant BasalStressEnum
    476474syn keyword cConstant BaseEnum
     475syn keyword cConstant BaseOldEnum
    477476syn keyword cConstant BaseSlopeXEnum
    478477syn keyword cConstant BaseSlopeYEnum
    … …  
    495494syn keyword cConstant CrevasseDepthEnum
    496495syn keyword cConstant DamageDEnum
     496syn keyword cConstant DamageDOldEnum
    497497syn keyword cConstant DamageDbarEnum
     498syn keyword cConstant DamageDbarOldEnum
    498499syn keyword cConstant DamageFEnum
    499500syn keyword cConstant DegreeOfChannelizationEnum
    … …  
    516517syn keyword cConstant DrivingStressXEnum
    517518syn keyword cConstant DrivingStressYEnum
     519syn keyword cConstant DummyEnum
    518520syn keyword cConstant EffectivePressureEnum
    519521syn keyword cConstant EffectivePressureSubstepEnum
    … …  
    660662syn keyword cConstant SealevelUNorthEsaEnum
    661663syn keyword cConstant SealevelriseCumDeltathicknessEnum
     664syn keyword cConstant SealevelriseCumDeltathicknessOldEnum
    662665syn keyword cConstant SealevelriseDeltathicknessEnum
    663666syn keyword cConstant SealevelriseSpcthicknessEnum
    … …  
    785788syn keyword cConstant SurfaceCrevasseEnum
    786789syn keyword cConstant SurfaceEnum
     790syn keyword cConstant SurfaceOldEnum
    787791syn keyword cConstant SurfaceLogVelMisfitEnum
    788792syn keyword cConstant SurfaceLogVxVyMisfitEnum
    … …  
    953957syn keyword cConstant BoolExternalResultEnum
    954958syn keyword cConstant BoolInputEnum
     959syn keyword cConstant BoolInput2Enum
     960syn keyword cConstant IntInput2Enum
    955961syn keyword cConstant BoolParamEnum
    956962syn keyword cConstant BoundaryEnum
    … …  
    973979syn keyword cConstant ContoursEnum
    974980syn keyword cConstant ControlInputEnum
     981syn keyword cConstant ControlInput2Enum
    975982syn keyword cConstant ControlInputGradEnum
    976983syn keyword cConstant ControlInputMaxsEnum
    … …  
    985992syn keyword cConstant DataSetParamEnum
    986993syn keyword cConstant DatasetInputEnum
     994syn keyword cConstant DatasetInput2Enum
    987995syn keyword cConstant DefaultAnalysisEnum
    988996syn keyword cConstant DefaultCalvingEnum
    … …  
    9941002syn keyword cConstant Domain3DsurfaceEnum
    9951003syn keyword cConstant DoubleArrayInputEnum
     1004syn keyword cConstant ArrayInput2Enum
    9961005syn keyword cConstant DoubleExternalResultEnum
    9971006syn keyword cConstant DoubleInputEnum
    … …  
    10741083syn keyword cConstant IntExternalResultEnum
    10751084syn keyword cConstant IntInputEnum
     1085syn keyword cConstant ElementInput2Enum
     1086syn keyword cConstant SegInput2Enum
     1087syn keyword cConstant TriaInput2Enum
     1088syn keyword cConstant PentaInput2Enum
    10761089syn keyword cConstant IntMatExternalResultEnum
    10771090syn keyword cConstant IntMatParamEnum
    10781091syn keyword cConstant IntParamEnum
    10791092syn keyword cConstant IntVecParamEnum
     1093syn keyword cConstant Inputs2Enum
    10801094syn keyword cConstant InternalEnum
    10811095syn keyword cConstant IntersectEnum
    … …  
    11571171syn keyword cConstant OpenEnum
    11581172syn keyword cConstant OptionEnum
     1173syn keyword cConstant ParamEnum
     1174syn keyword cConstant ParametersEnum
    11591175syn keyword cConstant P0ArrayEnum
    11601176syn keyword cConstant P0DGEnum
    … …  
    12591275syn keyword cConstant TransientArrayParamEnum
    12601276syn keyword cConstant TransientInputEnum
     1277syn keyword cConstant TransientInput2Enum
    12611278syn keyword cConstant TransientParamEnum
    12621279syn keyword cConstant TransientSolutionEnum
    … …  
    12981315syn keyword cType AdaptiveMeshRefinement
    12991316syn keyword cType AmrBamg
     1317syn keyword cType ArrayInput2
    13001318syn keyword cType BoolInput
     1319syn keyword cType BoolInput2
    13011320syn keyword cType BoolParam
    13021321syn keyword cType Cfdragcoeffabsgrad
    … …  
    13041323syn keyword cType Cfsurfacesquare
    13051324syn keyword cType Channel
     1325syn keyword cType classes
    13061326syn keyword cType Constraint
    13071327syn keyword cType Constraints
    … …  
    13091329syn keyword cType Contours
    13101330syn keyword cType ControlInput
     1331syn keyword cType ControlInput2
    13111332syn keyword cType Covertree
     1333syn keyword cType DatasetInput
     1334syn keyword cType DatasetInput2
    13121335syn keyword cType DataSetParam
    1313 syn keyword cType DatasetInput
    13141336syn keyword cType Definition
    13151337syn keyword cType DependentObject
    … …  
    13231345syn keyword cType Element
    13241346syn keyword cType ElementHook
     1347syn keyword cType ElementInput2
    13251348syn keyword cType ElementMatrix
     1349syn keyword cType Elements
    13261350syn keyword cType ElementVector
    1327 syn keyword cType Elements
    13281351syn keyword cType ExponentialVariogram
    13291352syn keyword cType ExternalResult
    … …  
    13321355syn keyword cType Friction
    13331356syn keyword cType Gauss
     1357syn keyword cType GaussianVariogram
     1358syn keyword cType gaussobjects
    13341359syn keyword cType GaussPenta
    13351360syn keyword cType GaussSeg
    13361361syn keyword cType GaussTetra
    13371362syn keyword cType GaussTria
    1338 syn keyword cType GaussianVariogram
    13391363syn keyword cType GenericExternalResult
    13401364syn keyword cType GenericOption
    … …  
    13431367syn keyword cType Hook
    13441368syn keyword cType Input
     1369syn keyword cType Input2
    13451370syn keyword cType Inputs
     1371syn keyword cType Inputs2
    13461372syn keyword cType IntInput
     1373syn keyword cType IntInput2
    13471374syn keyword cType IntMatParam
    13481375syn keyword cType IntParam
    … …  
    13511378syn keyword cType IssmDirectApplicInterface
    13521379syn keyword cType IssmParallelDirectApplicInterface
     1380syn keyword cType krigingobjects
    13531381syn keyword cType Load
    13541382syn keyword cType Loads
    … …  
    13611389syn keyword cType Matice
    13621390syn keyword cType Matlitho
     1391syn keyword cType matrixobjects
    13631392syn keyword cType MatrixParam
    13641393syn keyword cType Misfit
    … …  
    13731402syn keyword cType Observations
    13741403syn keyword cType Option
     1404syn keyword cType Options
    13751405syn keyword cType OptionUtilities
    1376 syn keyword cType Options
    13771406syn keyword cType Param
    13781407syn keyword cType Parameters
    … …  
    13811410syn keyword cType Penta
    13821411syn keyword cType PentaInput
     1412syn keyword cType PentaInput2
    13831413syn keyword cType PentaRef
    13841414syn keyword cType PowerVariogram
    … …  
    13881418syn keyword cType Regionaloutput
    13891419syn keyword cType Results
     1420syn keyword cType Riftfront
    13901421syn keyword cType RiftStruct
    1391 syn keyword cType Riftfront
    13921422syn keyword cType Seg
    13931423syn keyword cType SegInput
     1424syn keyword cType SegInput2
     1425syn keyword cType Segment
    13941426syn keyword cType SegRef
    1395 syn keyword cType Segment
    13961427syn keyword cType SpcDynamic
    13971428syn keyword cType SpcStatic
    … …  
    14051436syn keyword cType TransientArrayParam
    14061437syn keyword cType TransientInput
     1438syn keyword cType TransientInput2
    14071439syn keyword cType TransientParam
    14081440syn keyword cType Tria
    14091441syn keyword cType TriaInput
     1442syn keyword cType TriaInput2
    14101443syn keyword cType TriaRef
    14111444syn keyword cType Variogram
    … …  
    14131446syn keyword cType Vertex
    14141447syn keyword cType Vertices
    1415 syn keyword cType classes
    1416 syn keyword cType gaussobjects
    1417 syn keyword cType krigingobjects
    1418 syn keyword cType matrixobjects
    14191448syn keyword cType AdjointBalancethickness2Analysis
    14201449syn keyword cType AdjointBalancethicknessAnalysis
    … …  
    14351464syn keyword cType FreeSurfaceBaseAnalysis
    14361465syn keyword cType FreeSurfaceTopAnalysis
     1466syn keyword cType GiaIvinsAnalysis
    14371467syn keyword cType GLheightadvectionAnalysis
    1438 syn keyword cType GiaIvinsAnalysis
    14391468syn keyword cType HydrologyDCEfficientAnalysis
    14401469syn keyword cType HydrologyDCInefficientAnalysis

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

    r24259 r24335  
    276276        OutputFilePointerEnum,
    277277        OutputdefinitionEnum,
    278         ParamEnum,
    279         ParametersEnum,
    280278        QmuErrNameEnum,
    281279        QmuInNameEnum,
    … …  
    471469        BasalStressEnum,
    472470        BaseEnum,
     471        BaseOldEnum,
    473472        BaseSlopeXEnum,
    474473        BaseSlopeYEnum,
    … …  
    491490        CrevasseDepthEnum,
    492491        DamageDEnum,
     492        DamageDOldEnum,
    493493        DamageDbarEnum,
     494        DamageDbarOldEnum,
    494495        DamageFEnum,
    495496        DegreeOfChannelizationEnum,
    … …  
    512513        DrivingStressXEnum,
    513514        DrivingStressYEnum,
     515        DummyEnum,
    514516   EffectivePressureEnum,
    515517        EffectivePressureSubstepEnum,
    … …  
    656658        SealevelUNorthEsaEnum,
    657659        SealevelriseCumDeltathicknessEnum,
     660        SealevelriseCumDeltathicknessOldEnum,
    658661        SealevelriseDeltathicknessEnum,
    659662        SealevelriseSpcthicknessEnum,
    … …  
    781784        SurfaceCrevasseEnum,
    782785        SurfaceEnum,
     786        SurfaceOldEnum,
    783787        SurfaceLogVelMisfitEnum,
    784788        SurfaceLogVxVyMisfitEnum,
    … …  
    951955        BoolExternalResultEnum,
    952956        BoolInputEnum,
     957        BoolInput2Enum,
     958        IntInput2Enum,
    953959        BoolParamEnum,
    954960        BoundaryEnum,
    … …  
    971977        ContoursEnum,
    972978        ControlInputEnum,
     979        ControlInput2Enum,
    973980        ControlInputGradEnum,
    974981        ControlInputMaxsEnum,
    … …  
    983990        DataSetParamEnum,
    984991        DatasetInputEnum,
     992        DatasetInput2Enum,
    985993        DefaultAnalysisEnum,
    986994        DefaultCalvingEnum,
    … …  
    9921000        Domain3DsurfaceEnum,
    9931001        DoubleArrayInputEnum,
     1002        ArrayInput2Enum,
    9941003        DoubleExternalResultEnum,
    9951004        DoubleInputEnum,
    … …  
    10721081        IntExternalResultEnum,
    10731082        IntInputEnum,
     1083        ElementInput2Enum,
     1084        SegInput2Enum,
     1085        TriaInput2Enum,
     1086        PentaInput2Enum,
    10741087        IntMatExternalResultEnum,
    10751088        IntMatParamEnum,
    10761089        IntParamEnum,
    10771090        IntVecParamEnum,
     1091        Inputs2Enum,
    10781092        InternalEnum,
    10791093        IntersectEnum,
    … …  
    11551169        OpenEnum,
    11561170        OptionEnum,
     1171        ParamEnum,
     1172        ParametersEnum,
    11571173        P0ArrayEnum,
    11581174        P0DGEnum,
    … …  
    12571273        TransientArrayParamEnum,
    12581274        TransientInputEnum,
     1275        TransientInput2Enum,
    12591276        TransientParamEnum,
    12601277        TransientSolutionEnum,

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

    r24259 r24335  
    284284                case OutputFilePointerEnum : return "OutputFilePointer";
    285285                case OutputdefinitionEnum : return "Outputdefinition";
    286                 case ParamEnum : return "Param";
    287                 case ParametersEnum : return "Parameters";
    288286                case QmuErrNameEnum : return "QmuErrName";
    289287                case QmuInNameEnum : return "QmuInName";
    … …  
    477475                case BasalStressEnum : return "BasalStress";
    478476                case BaseEnum : return "Base";
     477                case BaseOldEnum : return "BaseOld";
    479478                case BaseSlopeXEnum : return "BaseSlopeX";
    480479                case BaseSlopeYEnum : return "BaseSlopeY";
    … …  
    497496                case CrevasseDepthEnum : return "CrevasseDepth";
    498497                case DamageDEnum : return "DamageD";
     498                case DamageDOldEnum : return "DamageDOld";
    499499                case DamageDbarEnum : return "DamageDbar";
     500                case DamageDbarOldEnum : return "DamageDbarOld";
    500501                case DamageFEnum : return "DamageF";
    501502                case DegreeOfChannelizationEnum : return "DegreeOfChannelization";
    … …  
    518519                case DrivingStressXEnum : return "DrivingStressX";
    519520                case DrivingStressYEnum : return "DrivingStressY";
     521                case DummyEnum : return "Dummy";
    520522                case EffectivePressureEnum : return "EffectivePressure";
    521523                case EffectivePressureSubstepEnum : return "EffectivePressureSubstep";
    … …  
    662664                case SealevelUNorthEsaEnum : return "SealevelUNorthEsa";
    663665                case SealevelriseCumDeltathicknessEnum : return "SealevelriseCumDeltathickness";
     666                case SealevelriseCumDeltathicknessOldEnum : return "SealevelriseCumDeltathicknessOld";
    664667                case SealevelriseDeltathicknessEnum : return "SealevelriseDeltathickness";
    665668                case SealevelriseSpcthicknessEnum : return "SealevelriseSpcthickness";
    … …  
    787790                case SurfaceCrevasseEnum : return "SurfaceCrevasse";
    788791                case SurfaceEnum : return "Surface";
     792                case SurfaceOldEnum : return "SurfaceOld";
    789793                case SurfaceLogVelMisfitEnum : return "SurfaceLogVelMisfit";
    790794                case SurfaceLogVxVyMisfitEnum : return "SurfaceLogVxVyMisfit";
    … …  
    955959                case BoolExternalResultEnum : return "BoolExternalResult";
    956960                case BoolInputEnum : return "BoolInput";
     961                case BoolInput2Enum : return "BoolInput2";
     962                case IntInput2Enum : return "IntInput2";
    957963                case BoolParamEnum : return "BoolParam";
    958964                case BoundaryEnum : return "Boundary";
    … …  
    975981                case ContoursEnum : return "Contours";
    976982                case ControlInputEnum : return "ControlInput";
     983                case ControlInput2Enum : return "ControlInput2";
    977984                case ControlInputGradEnum : return "ControlInputGrad";
    978985                case ControlInputMaxsEnum : return "ControlInputMaxs";
    … …  
    987994                case DataSetParamEnum : return "DataSetParam";
    988995                case DatasetInputEnum : return "DatasetInput";
     996                case DatasetInput2Enum : return "DatasetInput2";
    989997                case DefaultAnalysisEnum : return "DefaultAnalysis";
    990998                case DefaultCalvingEnum : return "DefaultCalving";
    … …  
    9961004                case Domain3DsurfaceEnum : return "Domain3Dsurface";
    9971005                case DoubleArrayInputEnum : return "DoubleArrayInput";
     1006                case ArrayInput2Enum : return "ArrayInput2";
    9981007                case DoubleExternalResultEnum : return "DoubleExternalResult";
    9991008                case DoubleInputEnum : return "DoubleInput";
    … …  
    10761085                case IntExternalResultEnum : return "IntExternalResult";
    10771086                case IntInputEnum : return "IntInput";
     1087                case ElementInput2Enum : return "ElementInput2";
     1088                case SegInput2Enum : return "SegInput2";
     1089                case TriaInput2Enum : return "TriaInput2";
     1090                case PentaInput2Enum : return "PentaInput2";
    10781091                case IntMatExternalResultEnum : return "IntMatExternalResult";
    10791092                case IntMatParamEnum : return "IntMatParam";
    10801093                case IntParamEnum : return "IntParam";
    10811094                case IntVecParamEnum : return "IntVecParam";
     1095                case Inputs2Enum : return "Inputs2";
    10821096                case InternalEnum : return "Internal";
    10831097                case IntersectEnum : return "Intersect";
    … …  
    11591173                case OpenEnum : return "Open";
    11601174                case OptionEnum : return "Option";
     1175                case ParamEnum : return "Param";
     1176                case ParametersEnum : return "Parameters";
    11611177                case P0ArrayEnum : return "P0Array";
    11621178                case P0DGEnum : return "P0DG";
    … …  
    12611277                case TransientArrayParamEnum : return "TransientArrayParam";
    12621278                case TransientInputEnum : return "TransientInput";
     1279                case TransientInput2Enum : return "TransientInput2";
    12631280                case TransientParamEnum : return "TransientParam";
    12641281                case TransientSolutionEnum : return "TransientSolution";

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

    r24259 r24335  
    290290              else if (strcmp(name,"OutputFilePointer")==0) return OutputFilePointerEnum;
    291291              else if (strcmp(name,"Outputdefinition")==0) return OutputdefinitionEnum;
    292               else if (strcmp(name,"Param")==0) return ParamEnum;
    293               else if (strcmp(name,"Parameters")==0) return ParametersEnum;
    294292              else if (strcmp(name,"QmuErrName")==0) return QmuErrNameEnum;
    295293              else if (strcmp(name,"QmuInName")==0) return QmuInNameEnum;
    … …  
    383381              else if (strcmp(name,"SmbSealev")==0) return SmbSealevEnum;
    384382              else if (strcmp(name,"SmbStepsPerStep")==0) return SmbStepsPerStepEnum;
     383              else if (strcmp(name,"SmbSwIdx")==0) return SmbSwIdxEnum;
     384              else if (strcmp(name,"SmbT0dry")==0) return SmbT0dryEnum;
    385385         else stage=4;
    386386   }
    387387   if(stage==4){
    388               if (strcmp(name,"SmbSwIdx")==0) return SmbSwIdxEnum;
    389               else if (strcmp(name,"SmbT0dry")==0) return SmbT0dryEnum;
    390               else if (strcmp(name,"SmbT0wet")==0) return SmbT0wetEnum;
     388              if (strcmp(name,"SmbT0wet")==0) return SmbT0wetEnum;
    391389              else if (strcmp(name,"SmbTdiff")==0) return SmbTdiffEnum;
    392390              else if (strcmp(name,"SmbThermoDeltaTScaling")==0) return SmbThermoDeltaTScalingEnum;
    … …  
    486484              else if (strcmp(name,"BasalStress")==0) return BasalStressEnum;
    487485              else if (strcmp(name,"Base")==0) return BaseEnum;
     486              else if (strcmp(name,"BaseOld")==0) return BaseOldEnum;
    488487              else if (strcmp(name,"BaseSlopeX")==0) return BaseSlopeXEnum;
    489488              else if (strcmp(name,"BaseSlopeY")==0) return BaseSlopeYEnum;
    … …  
    506505              else if (strcmp(name,"CrevasseDepth")==0) return CrevasseDepthEnum;
    507506              else if (strcmp(name,"DamageD")==0) return DamageDEnum;
     507              else if (strcmp(name,"DamageDOld")==0) return DamageDOldEnum;
    508508         else stage=5;
    509509   }
    510510   if(stage==5){
    511511              if (strcmp(name,"DamageDbar")==0) return DamageDbarEnum;
     512              else if (strcmp(name,"DamageDbarOld")==0) return DamageDbarOldEnum;
    512513              else if (strcmp(name,"DamageF")==0) return DamageFEnum;
    513514              else if (strcmp(name,"DegreeOfChannelization")==0) return DegreeOfChannelizationEnum;
    … …  
    530531              else if (strcmp(name,"DrivingStressX")==0) return DrivingStressXEnum;
    531532              else if (strcmp(name,"DrivingStressY")==0) return DrivingStressYEnum;
     533              else if (strcmp(name,"Dummy")==0) return DummyEnum;
    532534              else if (strcmp(name,"EffectivePressure")==0) return EffectivePressureEnum;
    533535              else if (strcmp(name,"EffectivePressureSubstep")==0) return EffectivePressureSubstepEnum;
    … …  
    627629              else if (strcmp(name,"MaterialsRheologyB")==0) return MaterialsRheologyBEnum;
    628630              else if (strcmp(name,"MaterialsRheologyBbar")==0) return MaterialsRheologyBbarEnum;
    629               else if (strcmp(name,"MaterialsRheologyE")==0) return MaterialsRheologyEEnum;
    630               else if (strcmp(name,"MaterialsRheologyEbar")==0) return MaterialsRheologyEbarEnum;
    631631         else stage=6;
    632632   }
    633633   if(stage==6){
    634               if (strcmp(name,"MaterialsRheologyEc")==0) return MaterialsRheologyEcEnum;
     634              if (strcmp(name,"MaterialsRheologyE")==0) return MaterialsRheologyEEnum;
     635              else if (strcmp(name,"MaterialsRheologyEbar")==0) return MaterialsRheologyEbarEnum;
     636              else if (strcmp(name,"MaterialsRheologyEc")==0) return MaterialsRheologyEcEnum;
    635637              else if (strcmp(name,"MaterialsRheologyEcbar")==0) return MaterialsRheologyEcbarEnum;
    636638              else if (strcmp(name,"MaterialsRheologyEs")==0) return MaterialsRheologyEsEnum;
    … …  
    677679              else if (strcmp(name,"SealevelUNorthEsa")==0) return SealevelUNorthEsaEnum;
    678680              else if (strcmp(name,"SealevelriseCumDeltathickness")==0) return SealevelriseCumDeltathicknessEnum;
     681              else if (strcmp(name,"SealevelriseCumDeltathicknessOld")==0) return SealevelriseCumDeltathicknessOldEnum;
    679682              else if (strcmp(name,"SealevelriseDeltathickness")==0) return SealevelriseDeltathicknessEnum;
    680683              else if (strcmp(name,"SealevelriseSpcthickness")==0) return SealevelriseSpcthicknessEnum;
    … …  
    749752              else if (strcmp(name,"SmbPrecipitationsPresentday")==0) return SmbPrecipitationsPresentdayEnum;
    750753              else if (strcmp(name,"SmbPrecipitationsReconstructed")==0) return SmbPrecipitationsReconstructedEnum;
    751               else if (strcmp(name,"SmbRe")==0) return SmbReEnum;
    752               else if (strcmp(name,"SmbRefreeze")==0) return SmbRefreezeEnum;
    753               else if (strcmp(name,"SmbReini")==0) return SmbReiniEnum;
    754754         else stage=7;
    755755   }
    756756   if(stage==7){
    757               if (strcmp(name,"SmbRunoff")==0) return SmbRunoffEnum;
     757              if (strcmp(name,"SmbRe")==0) return SmbReEnum;
     758              else if (strcmp(name,"SmbRefreeze")==0) return SmbRefreezeEnum;
     759              else if (strcmp(name,"SmbReini")==0) return SmbReiniEnum;
     760              else if (strcmp(name,"SmbRunoff")==0) return SmbRunoffEnum;
    758761              else if (strcmp(name,"SmbRunoffSubstep")==0) return SmbRunoffSubstepEnum;
    759762              else if (strcmp(name,"SmbRunoffTransient")==0) return SmbRunoffTransientEnum;
    … …  
    805808              else if (strcmp(name,"SurfaceCrevasse")==0) return SurfaceCrevasseEnum;
    806809              else if (strcmp(name,"Surface")==0) return SurfaceEnum;
     810              else if (strcmp(name,"SurfaceOld")==0) return SurfaceOldEnum;
    807811              else if (strcmp(name,"SurfaceLogVelMisfit")==0) return SurfaceLogVelMisfitEnum;
    808812              else if (strcmp(name,"SurfaceLogVxVyMisfit")==0) return SurfaceLogVxVyMisfitEnum;
    … …  
    871875              else if (strcmp(name,"Outputdefinition32")==0) return Outputdefinition32Enum;
    872876              else if (strcmp(name,"Outputdefinition33")==0) return Outputdefinition33Enum;
    873               else if (strcmp(name,"Outputdefinition34")==0) return Outputdefinition34Enum;
     877         else stage=8;
     878   }
     879   if(stage==8){
     880              if (strcmp(name,"Outputdefinition34")==0) return Outputdefinition34Enum;
    874881              else if (strcmp(name,"Outputdefinition35")==0) return Outputdefinition35Enum;
    875882              else if (strcmp(name,"Outputdefinition36")==0) return Outputdefinition36Enum;
    876883              else if (strcmp(name,"Outputdefinition37")==0) return Outputdefinition37Enum;
    877          else stage=8;
    878    }
    879    if(stage==8){
    880               if (strcmp(name,"Outputdefinition38")==0) return Outputdefinition38Enum;
     884              else if (strcmp(name,"Outputdefinition38")==0) return Outputdefinition38Enum;
    881885              else if (strcmp(name,"Outputdefinition39")==0) return Outputdefinition39Enum;
    882886              else if (strcmp(name,"Outputdefinition3")==0) return Outputdefinition3Enum;
    … …  
    976980              else if (strcmp(name,"BoolExternalResult")==0) return BoolExternalResultEnum;
    977981              else if (strcmp(name,"BoolInput")==0) return BoolInputEnum;
     982              else if (strcmp(name,"BoolInput2")==0) return BoolInput2Enum;
     983              else if (strcmp(name,"IntInput2")==0) return IntInput2Enum;
    978984              else if (strcmp(name,"BoolParam")==0) return BoolParamEnum;
    979985              else if (strcmp(name,"Boundary")==0) return BoundaryEnum;
    … …  
    992998              else if (strcmp(name,"Colinear")==0) return ColinearEnum;
    993999              else if (strcmp(name,"Constraints")==0) return ConstraintsEnum;
    994               else if (strcmp(name,"Contact")==0) return ContactEnum;
     1000         else stage=9;
     1001   }
     1002   if(stage==9){
     1003              if (strcmp(name,"Contact")==0) return ContactEnum;
    9951004              else if (strcmp(name,"Contour")==0) return ContourEnum;
    9961005              else if (strcmp(name,"Contours")==0) return ContoursEnum;
    9971006              else if (strcmp(name,"ControlInput")==0) return ControlInputEnum;
     1007              else if (strcmp(name,"ControlInput2")==0) return ControlInput2Enum;
    9981008              else if (strcmp(name,"ControlInputGrad")==0) return ControlInputGradEnum;
    9991009              else if (strcmp(name,"ControlInputMaxs")==0) return ControlInputMaxsEnum;
    1000          else stage=9;
    1001    }
    1002    if(stage==9){
    1003               if (strcmp(name,"ControlInputMins")==0) return ControlInputMinsEnum;
     1010              else if (strcmp(name,"ControlInputMins")==0) return ControlInputMinsEnum;
    10041011              else if (strcmp(name,"ControlInputValues")==0) return ControlInputValuesEnum;
    10051012              else if (strcmp(name,"CrouzeixRaviart")==0) return CrouzeixRaviartEnum;
    … …  
    10111018              else if (strcmp(name,"DataSetParam")==0) return DataSetParamEnum;
    10121019              else if (strcmp(name,"DatasetInput")==0) return DatasetInputEnum;
     1020              else if (strcmp(name,"DatasetInput2")==0) return DatasetInput2Enum;
    10131021              else if (strcmp(name,"DefaultAnalysis")==0) return DefaultAnalysisEnum;
    10141022              else if (strcmp(name,"DefaultCalving")==0) return DefaultCalvingEnum;
    … …  
    10201028              else if (strcmp(name,"Domain3Dsurface")==0) return Domain3DsurfaceEnum;
    10211029              else if (strcmp(name,"DoubleArrayInput")==0) return DoubleArrayInputEnum;
     1030              else if (strcmp(name,"ArrayInput2")==0) return ArrayInput2Enum;
    10221031              else if (strcmp(name,"DoubleExternalResult")==0) return DoubleExternalResultEnum;
    10231032              else if (strcmp(name,"DoubleInput")==0) return DoubleInputEnum;
    … …  
    11001109              else if (strcmp(name,"IntExternalResult")==0) return IntExternalResultEnum;
    11011110              else if (strcmp(name,"IntInput")==0) return IntInputEnum;
     1111              else if (strcmp(name,"ElementInput2")==0) return ElementInput2Enum;
     1112              else if (strcmp(name,"SegInput2")==0) return SegInput2Enum;
     1113              else if (strcmp(name,"TriaInput2")==0) return TriaInput2Enum;
     1114              else if (strcmp(name,"PentaInput2")==0) return PentaInput2Enum;
    11021115              else if (strcmp(name,"IntMatExternalResult")==0) return IntMatExternalResultEnum;
    11031116              else if (strcmp(name,"IntMatParam")==0) return IntMatParamEnum;
    11041117              else if (strcmp(name,"IntParam")==0) return IntParamEnum;
    11051118              else if (strcmp(name,"IntVecParam")==0) return IntVecParamEnum;
     1119              else if (strcmp(name,"Inputs2")==0) return Inputs2Enum;
    11061120              else if (strcmp(name,"Internal")==0) return InternalEnum;
    11071121              else if (strcmp(name,"Intersect")==0) return IntersectEnum;
    11081122              else if (strcmp(name,"InversionVzObs")==0) return InversionVzObsEnum;
    1109               else if (strcmp(name,"J")==0) return JEnum;
     1123         else stage=10;
     1124   }
     1125   if(stage==10){
     1126              if (strcmp(name,"J")==0) return JEnum;
    11101127              else if (strcmp(name,"L1L2Approximation")==0) return L1L2ApproximationEnum;
    11111128              else if (strcmp(name,"L2ProjectionBaseAnalysis")==0) return L2ProjectionBaseAnalysisEnum;
    … …  
    11211138              else if (strcmp(name,"LoveAnalysis")==0) return LoveAnalysisEnum;
    11221139              else if (strcmp(name,"LoveHi")==0) return LoveHiEnum;
    1123          else stage=10;
    1124    }
    1125    if(stage==10){
    1126               if (strcmp(name,"LoveHr")==0) return LoveHrEnum;
     1140              else if (strcmp(name,"LoveHr")==0) return LoveHrEnum;
    11271141              else if (strcmp(name,"LoveKernelsImag")==0) return LoveKernelsImagEnum;
    11281142              else if (strcmp(name,"LoveKernelsReal")==0) return LoveKernelsRealEnum;
    … …  
    11861200              else if (strcmp(name,"Open")==0) return OpenEnum;
    11871201              else if (strcmp(name,"Option")==0) return OptionEnum;
     1202              else if (strcmp(name,"Param")==0) return ParamEnum;
     1203              else if (strcmp(name,"Parameters")==0) return ParametersEnum;
    11881204              else if (strcmp(name,"P0Array")==0) return P0ArrayEnum;
    11891205              else if (strcmp(name,"P0DG")==0) return P0DGEnum;
    … …  
    12281244              else if (strcmp(name,"SMBpddSicopolis")==0) return SMBpddSicopolisEnum;
    12291245              else if (strcmp(name,"SMBsemic")==0) return SMBsemicEnum;
    1230               else if (strcmp(name,"SSAApproximation")==0) return SSAApproximationEnum;
     1246         else stage=11;
     1247   }
     1248   if(stage==11){
     1249              if (strcmp(name,"SSAApproximation")==0) return SSAApproximationEnum;
    12311250              else if (strcmp(name,"SSAFSApproximation")==0) return SSAFSApproximationEnum;
    12321251              else if (strcmp(name,"SSAHOApproximation")==0) return SSAHOApproximationEnum;
    … …  
    12441263              else if (strcmp(name,"SegInput")==0) return SegInputEnum;
    12451264              else if (strcmp(name,"Segment")==0) return SegmentEnum;
    1246          else stage=11;
    1247    }
    1248    if(stage==11){
    1249               if (strcmp(name,"SegmentRiftfront")==0) return SegmentRiftfrontEnum;
     1265              else if (strcmp(name,"SegmentRiftfront")==0) return SegmentRiftfrontEnum;
    12501266              else if (strcmp(name,"Separate")==0) return SeparateEnum;
    12511267              else if (strcmp(name,"Seq")==0) return SeqEnum;
    … …  
    12911307              else if (strcmp(name,"TransientArrayParam")==0) return TransientArrayParamEnum;
    12921308              else if (strcmp(name,"TransientInput")==0) return TransientInputEnum;
     1309              else if (strcmp(name,"TransientInput2")==0) return TransientInput2Enum;
    12931310              else if (strcmp(name,"TransientParam")==0) return TransientParamEnum;
    12941311              else if (strcmp(name,"TransientSolution")==0) return TransientSolutionEnum;
Note: See TracChangeset for help on using the changeset viewer.