Changeset 10135


Ignore:
Timestamp:
10/07/11 08:25:24 (13 years ago)
Author:
Mathieu Morlighem
Message:

Changed GetParameterValue to GetInputValue because it is actually a method of inputs not parameters which is confusing

Location:
issm/trunk/src/c
Files:
36 edited

Legend:

Unmodified
Added
Removed

  • issm/trunk/src/c/Container/Inputs.cpp

    r9883 r10135  
    4343
    4444/*Object management*/
    45 /*FUNCTION Inputs::GetParameterValue(bool* pvalue,int enum-type){{{1*/
    46 void Inputs::GetParameterValue(bool* pvalue,int enum_type){
     45/*FUNCTION Inputs::GetInputValue(bool* pvalue,int enum-type){{{1*/
     46void Inputs::GetInputValue(bool* pvalue,int enum_type){
    4747
    4848        vector<Object*>::iterator object;
    … …  
    6767
    6868        /*Ok, we have an input if we made it here, request the input to return the value: */
    69         input->GetParameterValue(pvalue);
    70 
    71 }
    72 /*}}}*/
    73 /*FUNCTION Inputs::GetParameterValue(int* pvalue,int enum-type){{{1*/
    74 void Inputs::GetParameterValue(int* pvalue,int enum_type){
     69        input->GetInputValue(pvalue);
     70
     71}
     72/*}}}*/
     73/*FUNCTION Inputs::GetInputValue(int* pvalue,int enum-type){{{1*/
     74void Inputs::GetInputValue(int* pvalue,int enum_type){
    7575
    7676        vector<Object*>::iterator object;
    … …  
    9595
    9696        /*Ok, we have an input if we made it here, request the input to return the value: */
    97         input->GetParameterValue(pvalue);
    98 
    99 }
    100 /*}}}*/
    101 /*FUNCTION Inputs::GetParameterValue(double* pvalue,int enum-type){{{1*/
    102 void Inputs::GetParameterValue(double* pvalue,int enum_type){
     97        input->GetInputValue(pvalue);
     98
     99}
     100/*}}}*/
     101/*FUNCTION Inputs::GetInputValue(double* pvalue,int enum-type){{{1*/
     102void Inputs::GetInputValue(double* pvalue,int enum_type){
    103103
    104104        vector<Object*>::iterator object;
    … …  
    123123
    124124        /*Ok, we have an input if we made it here, request the input to return the value: */
    125         input->GetParameterValue(pvalue);
    126 
    127 }
    128 /*}}}*/
    129 /*FUNCTION Inputs::GetParameterAverage{{{1*/
    130 void Inputs::GetParameterAverage(double* pvalue,int enum_type){
     125        input->GetInputValue(pvalue);
     126
     127}
     128/*}}}*/
     129/*FUNCTION Inputs::GetInputAverage{{{1*/
     130void Inputs::GetInputAverage(double* pvalue,int enum_type){
    131131
    132132        vector<Object*>::iterator object;
    … …  
    151151
    152152        /*Ok, we have an input if we made it here, request the input to return the value: */
    153         input->GetParameterAverage(pvalue);
     153        input->GetInputAverage(pvalue);
    154154
    155155}

  • issm/trunk/src/c/Container/Inputs.h

    r9734 r10135  
    4444                double  MinAbs(int enumtype);
    4545               
    46                 void GetParameterAverage(double* pvalue, int enum_type);
    47                 void GetParameterValue(bool* pvalue,int enum_type);
    48                 void GetParameterValue(int* pvalue,int enum_type);
    49                 void GetParameterValue(double* pvalue,int enum_type);
     46                void GetInputAverage(double* pvalue, int enum_type);
     47                void GetInputValue(bool* pvalue,int enum_type);
     48                void GetInputValue(int* pvalue,int enum_type);
     49                void GetInputValue(double* pvalue,int enum_type);
    5050
    5151                void Configure(Parameters* parameters);

  • issm/trunk/src/c/objects/Elements/Element.h

    r9880 r10135  
    3737                virtual bool   IsNodeOnShelfFromFlags(double* flags)=0;
    3838                virtual bool   IsOnBed()=0;
    39                 virtual void   GetParameterListOnVertices(double* pvalue,int enumtype)=0;
    40                 virtual void   GetParameterListOnVertices(double* pvalue,int enumtype,double defaultvalue)=0;
    41                 virtual void   GetParameterValue(double* pvalue,Node* node,int enumtype)=0;
     39                virtual void   GetInputListOnVertices(double* pvalue,int enumtype)=0;
     40                virtual void   GetInputListOnVertices(double* pvalue,int enumtype,double defaultvalue)=0;
     41                virtual void   GetInputValue(double* pvalue,Node* node,int enumtype)=0;
    4242               
    4343                virtual double SurfaceArea(void)=0;

  • issm/trunk/src/c/objects/Elements/Penta.cpp

    r9883 r10135  
    383383
    384384                friction->GetAlpha2(&alpha2,gauss,VxEnum,VyEnum,VzEnum);
    385                 vx_input->GetParameterValue(&vx,gauss);
    386                 vy_input->GetParameterValue(&vy,gauss);
     385                vx_input->GetInputValue(&vx,gauss);
     386                vy_input->GetInputValue(&vy,gauss);
    387387                basalfriction[count]=alpha2*(pow(vx,2.0)+pow(vy,2.0));
    388388                count++;
    … …  
    421421        /*retrive parameters: */
    422422        parameters->FindParam(&analysis_type,AnalysisTypeEnum);
    423         inputs->GetParameterValue(&approximation,ApproximationEnum);
     423        inputs->GetInputValue(&approximation,ApproximationEnum);
    424424
    425425        /*Check analysis_types*/
    … …  
    459459                this->GetStrainRate3d(&epsilon[0],&xyz_list[0][0],gauss,vx_input,vy_input,vz_input);
    460460                matice->GetViscosity3dStokes(&viscosity,&epsilon[0]);
    461                 pressure_input->GetParameterValue(&pressure,gauss);
     461                pressure_input->GetInputValue(&pressure,gauss);
    462462
    463463                /*Compute Stress*/
    … …  
    869869}
    870870/*}}}*/
    871 /*FUNCTION Penta::GetParameterListOnVertices(double* pvalue,int enumtype) {{{1*/
    872 void Penta::GetParameterListOnVertices(double* pvalue,int enumtype){
     871/*FUNCTION Penta::GetInputListOnVertices(double* pvalue,int enumtype) {{{1*/
     872void Penta::GetInputListOnVertices(double* pvalue,int enumtype){
    873873
    874874        /*Intermediaries*/
    … …  
    887887        for (int iv=0;iv<NUMVERTICES;iv++){
    888888                gauss->GaussVertex(iv);
    889                 input->GetParameterValue(&pvalue[iv],gauss);
     889                input->GetInputValue(&pvalue[iv],gauss);
    890890        }
    891891
    … …  
    894894}
    895895/*}}}*/
    896 /*FUNCTION Penta::GetParameterListOnVertices(double* pvalue,int enumtype,double defaultvalue) {{{1*/
    897 void Penta::GetParameterListOnVertices(double* pvalue,int enumtype,double defaultvalue){
     896/*FUNCTION Penta::GetInputListOnVertices(double* pvalue,int enumtype,double defaultvalue) {{{1*/
     897void Penta::GetInputListOnVertices(double* pvalue,int enumtype,double defaultvalue){
    898898
    899899        /*Intermediaries*/
    … …  
    912912                for (int iv=0;iv<NUMVERTICES;iv++){
    913913                        gauss->GaussVertex(iv);
    914                         input->GetParameterValue(&pvalue[iv],gauss);
     914                        input->GetInputValue(&pvalue[iv],gauss);
    915915                }
    916916        }
    … …  
    923923}
    924924/*}}}*/
    925 /*FUNCTION Penta::GetParameterValue(double* pvalue,Node* node,int enumtype) {{{1*/
    926 void Penta::GetParameterValue(double* pvalue,Node* node,int enumtype){
     925/*FUNCTION Penta::GetInputValue(double* pvalue,Node* node,int enumtype) {{{1*/
     926void Penta::GetInputValue(double* pvalue,Node* node,int enumtype){
    927927
    928928        Input* input=inputs->GetInput(enumtype);
    … …  
    932932        gauss->GaussVertex(this->GetNodeIndex(node));
    933933
    934         input->GetParameterValue(pvalue,gauss);
     934        input->GetInputValue(pvalue,gauss);
    935935        delete gauss;
    936936}
    … …  
    995995        case DiagnosticHorizAnalysisEnum:
    996996                int approximation;
    997                 inputs->GetParameterValue(&approximation,ApproximationEnum);
     997                inputs->GetInputValue(&approximation,ApproximationEnum);
    998998                if(approximation==StokesApproximationEnum || approximation==NoneApproximationEnum){
    999999                        GetSolutionFromInputsDiagnosticStokes(solution);
    … …  
    11551155        GetVerticesCoordinates(&xyz_list[0][0], nodes, NUMVERTICES);
    11561156        for(i=0;i<NUMVERTICES;i++) z_list[i]=xyz_list[i][2];
    1157         PentaRef::GetParameterValue(&z,z_list,gauss);
     1157        PentaRef::GetInputValue(&z,z_list,gauss);
    11581158
    11591159        return z;
    … …  
    16941694        case AdjointHorizAnalysisEnum:
    16951695                int approximation;
    1696                 inputs->GetParameterValue(&approximation,ApproximationEnum);
     1696                inputs->GetInputValue(&approximation,ApproximationEnum);
    16971697                if(approximation==StokesApproximationEnum || approximation==NoneApproximationEnum){
    16981698                        InputUpdateFromSolutionAdjointStokes( solution);
    … …  
    19321932
    19331933        bool onbed;
    1934         inputs->GetParameterValue(&onbed,MeshElementonbedEnum);
     1934        inputs->GetInputValue(&onbed,MeshElementonbedEnum);
    19351935        return onbed;
    19361936}
    … …  
    19701970
    19711971        bool onshelf;
    1972         inputs->GetParameterValue(&onshelf,MaskElementonfloatingiceEnum);
     1972        inputs->GetInputValue(&onshelf,MaskElementonfloatingiceEnum);
    19731973        return onshelf;
    19741974}
    … …  
    20082008
    20092009        bool onsurface;
    2010         inputs->GetParameterValue(&onsurface,MeshElementonsurfaceEnum);
     2010        inputs->GetInputValue(&onsurface,MeshElementonsurfaceEnum);
    20112011        return onsurface;
    20122012}
    … …  
    20162016
    20172017        bool onwater;
    2018         inputs->GetParameterValue(&onwater,MaskElementonwaterEnum);
     2018        inputs->GetInputValue(&onwater,MaskElementonwaterEnum);
    20192019        return onwater;
    20202020}
    … …  
    23452345
    23462346        /*retrieve inputs :*/
    2347         inputs->GetParameterValue(&approximation,ApproximationEnum);
     2347        inputs->GetInputValue(&approximation,ApproximationEnum);
    23482348
    23492349        /*If on water, return 0: */
    … …  
    26482648                gauss->GaussVertex(iv);
    26492649               
    2650                 thickness_input->GetParameterValue(&thickness,gauss);
     2650                thickness_input->GetInputValue(&thickness,gauss);
    26512651
    26522652                this->GetStrainRate3d(&epsilon[0],&xyz_list[0][0],gauss,vx_input,vy_input,vz_input);
    … …  
    27382738                                /*ok, we are good. retrieve value of input at vertex :*/
    27392739                                gauss=new GaussPenta(); gauss->GaussVertex(i);
    2740                                 data->GetParameterValue(&value,gauss);
     2740                                data->GetInputValue(&value,gauss);
    27412741                                found=1;
    27422742                                break;
    … …  
    29832983                GetBConduct(&B_conduct[0][0],&xyz_list[0][0],gauss);
    29842984
    2985                 enthalpy_input->GetParameterValue(&enthalpy, gauss);
    2986                 pressure_input->GetParameterValue(&pressure, gauss);
     2985                enthalpy_input->GetInputValue(&enthalpy, gauss);
     2986                pressure_input->GetInputValue(&pressure, gauss);
    29872987                kappa=matpar->GetEnthalpyDiffusionParameter(enthalpy,pressure);
    29882988                D_scalar_conduct=gauss->weight*Jdet*kappa;
    … …  
    30033003                GetBprimeAdvec(&Bprime_advec[0][0],&xyz_list[0][0],gauss);
    30043004
    3005                 vx_input->GetParameterValue(&u, gauss);
    3006                 vy_input->GetParameterValue(&v, gauss);
    3007                 vz_input->GetParameterValue(&w, gauss);
    3008                 vxm_input->GetParameterValue(&um,gauss);
    3009                 vym_input->GetParameterValue(&vm,gauss);
    3010                 vzm_input->GetParameterValue(&wm,gauss);
     3005                vx_input->GetInputValue(&u, gauss);
     3006                vy_input->GetInputValue(&v, gauss);
     3007                vz_input->GetInputValue(&w, gauss);
     3008                vxm_input->GetInputValue(&um,gauss);
     3009                vym_input->GetInputValue(&vm,gauss);
     3010                vzm_input->GetInputValue(&wm,gauss);
    30113011
    30123012                D_scalar_advec=gauss->weight*Jdet;
    … …  
    32373237                GetBprimeAdvec(&Bprime_advec[0][0],&xyz_list[0][0],gauss);
    32383238
    3239                 vx_input->GetParameterValue(&u, gauss);
    3240                 vy_input->GetParameterValue(&v, gauss);
    3241                 vz_input->GetParameterValue(&w, gauss);
    3242                 vxm_input->GetParameterValue(&um,gauss);
    3243                 vym_input->GetParameterValue(&vm,gauss);
    3244                 vzm_input->GetParameterValue(&wm,gauss);
     3239                vx_input->GetInputValue(&u, gauss);
     3240                vy_input->GetInputValue(&v, gauss);
     3241                vz_input->GetInputValue(&w, gauss);
     3242                vxm_input->GetInputValue(&um,gauss);
     3243                vym_input->GetInputValue(&vm,gauss);
     3244                vzm_input->GetInputValue(&wm,gauss);
    32453245
    32463246                D_scalar_advec=gauss->weight*Jdet;
    … …  
    34433443                /* Build transient now */
    34443444                if(dt){
    3445                         temperature_input->GetParameterValue(&temperature, gauss);
     3445                        temperature_input->GetInputValue(&temperature, gauss);
    34463446                        scalar_transient=temperature*Jdet*gauss->weight;
    34473447                        for(i=0;i<NUMVERTICES;i++)  pe->values[i]+=scalar_transient*L[i];
    … …  
    34513451                        GetNodalFunctionsP1Derivatives(&dbasis[0][0],&xyz_list[0][0], gauss);
    34523452
    3453                         vx_input->GetParameterValue(&u, gauss);
    3454                         vy_input->GetParameterValue(&v, gauss);
    3455                         vz_input->GetParameterValue(&w, gauss);
     3453                        vx_input->GetInputValue(&u, gauss);
     3454                        vy_input->GetInputValue(&v, gauss);
     3455                        vz_input->GetInputValue(&w, gauss);
    34563456
    34573457                        tau_parameter=GetStabilizationParameter(u,v,w,diameter,rho_ice,heatcapacity,thermalconductivity);
    … …  
    35123512                GetNodalFunctionsP1(&basis[0], gauss);
    35133513
    3514                 pressure_input->GetParameterValue(&pressure,gauss);
     3514                pressure_input->GetInputValue(&pressure,gauss);
    35153515                h_pmp=matpar->PureIceEnthalpy(pressure);
    35163516
    … …  
    35753575                GetNodalFunctionsP1(&basis[0], gauss);
    35763576
    3577                 geothermalflux_input->GetParameterValue(&geothermalflux_value,gauss);
     3577                geothermalflux_input->GetInputValue(&geothermalflux_value,gauss);
    35783578                friction->GetAlpha2(&alpha2,gauss,VxEnum,VyEnum,VzEnum);
    3579                 vx_input->GetParameterValue(&vx,gauss);
    3580                 vy_input->GetParameterValue(&vy,gauss);
     3579                vx_input->GetInputValue(&vx,gauss);
     3580                vy_input->GetInputValue(&vy,gauss);
    35813581                basalfriction=alpha2*(pow(vx,2.0)+pow(vy,2.0));
    35823582               
    … …  
    36743674                /* Build transient now */
    36753675                if(dt){
    3676                         temperature_input->GetParameterValue(&temperature, gauss);
     3676                        temperature_input->GetInputValue(&temperature, gauss);
    36773677                        scalar_transient=temperature*Jdet*gauss->weight;
    36783678                        for(i=0;i<NUMVERTICES;i++)  pe->values[i]+=scalar_transient*L[i];
    … …  
    36823682                        GetNodalFunctionsP1Derivatives(&dbasis[0][0],&xyz_list[0][0], gauss);
    36833683
    3684                         vx_input->GetParameterValue(&u, gauss);
    3685                         vy_input->GetParameterValue(&v, gauss);
    3686                         vz_input->GetParameterValue(&w, gauss);
     3684                        vx_input->GetInputValue(&u, gauss);
     3685                        vy_input->GetInputValue(&v, gauss);
     3686                        vz_input->GetInputValue(&w, gauss);
    36873687
    36883688                        tau_parameter=GetStabilizationParameter(u,v,w,diameter,rho_ice,heatcapacity,thermalconductivity);
    … …  
    37433743                GetNodalFunctionsP1(&basis[0], gauss);
    37443744
    3745                 pressure_input->GetParameterValue(&pressure,gauss);
     3745                pressure_input->GetInputValue(&pressure,gauss);
    37463746                t_pmp=matpar->TMeltingPoint(pressure);
    37473747
    … …  
    38063806                GetNodalFunctionsP1(&basis[0], gauss);
    38073807
    3808                 geothermalflux_input->GetParameterValue(&geothermalflux_value,gauss);
     3808                geothermalflux_input->GetInputValue(&geothermalflux_value,gauss);
    38093809                friction->GetAlpha2(&alpha2,gauss,VxEnum,VyEnum,VzEnum);
    3810                 vx_input->GetParameterValue(&vx,gauss);
    3811                 vy_input->GetParameterValue(&vy,gauss);
     3810                vx_input->GetInputValue(&vx,gauss);
     3811                vy_input->GetInputValue(&vy,gauss);
    38123812                basalfriction=alpha2*(pow(vx,2.0)+pow(vy,2.0));
    38133813               
    … …  
    38433843                /*Recover temperature*/
    38443844                gauss->GaussVertex(i);
    3845                 t_input->GetParameterValue(&temp,gauss);
     3845                t_input->GetInputValue(&temp,gauss);
    38463846                values[i]=temp;
    38473847        }
    … …  
    38743874                /*Recover temperature*/
    38753875                gauss->GaussVertex(i);
    3876                 h_input->GetParameterValue(&enthalpy,gauss);
     3876                h_input->GetInputValue(&enthalpy,gauss);
    38773877                values[i]=enthalpy;
    38783878        }
    … …  
    39163916        Input* surface_input=inputs->GetInput(SurfaceEnum); _assert_(surface_input);
    39173917
    3918         this->inputs->GetParameterValue(&converged,ConvergedEnum);
     3918        this->inputs->GetInputValue(&converged,ConvergedEnum);
    39193919        if(converged){
    39203920                this->inputs->AddInput(new PentaVertexInput(TemperatureEnum,values));
    … …  
    39333933                                break;
    39343934                        case ArrheniusEnum:
    3935                                 surface_input->GetParameterAverage(&s_average);
     3935                                surface_input->GetInputAverage(&s_average);
    39363936                                B_average=Arrhenius((values[0]+values[1]+values[2]+values[3]+values[4]+values[5])/6.0,
    39373937                                                        s_average-((xyz_list[0][2]+xyz_list[1][2]+xyz_list[2][2]+xyz_list[3][2]+xyz_list[4][2]+xyz_list[5][2])/6.0),
    … …  
    39823982        /*Get all inputs and parameters*/
    39833983        GetVerticesCoordinates(&xyz_list[0][0], nodes, NUMVERTICES);
    3984         GetParameterListOnVertices(&pressure[0],PressureEnum);
     3984        GetInputListOnVertices(&pressure[0],PressureEnum);
    39853985        Input* surface_input=inputs->GetInput(SurfaceEnum); _assert_(surface_input);
    39863986       
    39873987
    3988 //      this->inputs->GetParameterValue(&converged,ConvergedEnum);
     3988//      this->inputs->GetInputValue(&converged,ConvergedEnum);
    39893989//      if(converged){
    39903990                /*Convert enthalpy into temperature and water fraction*/
    … …  
    40084008                                break;
    40094009                        case ArrheniusEnum:
    4010                                 surface_input->GetParameterAverage(&s_average);
     4010                                surface_input->GetInputAverage(&s_average);
    40114011                                B_average=Arrhenius((temperatures[0]+temperatures[1]+temperatures[2]+temperatures[3]+temperatures[4]+temperatures[5])/6.0,
    40124012                                                        s_average-((xyz_list[0][2]+xyz_list[1][2]+xyz_list[2][2]+xyz_list[3][2]+xyz_list[4][2]+xyz_list[5][2])/6.0),
    … …  
    40944094
    40954095        int approximation;
    4096         inputs->GetParameterValue(&approximation,ApproximationEnum);
     4096        inputs->GetInputValue(&approximation,ApproximationEnum);
    40974097
    40984098        switch(approximation){
    … …  
    41664166
    41674167                case FrictionCoefficientEnum:
    4168                         inputs->GetParameterValue(&approximation,ApproximationEnum);
     4168                        inputs->GetInputValue(&approximation,ApproximationEnum);
    41694169                        switch(approximation){
    41704170                                case MacAyealApproximationEnum:
    … …  
    41864186
    41874187                case MaterialsRheologyBbarEnum:
    4188                         inputs->GetParameterValue(&approximation,ApproximationEnum);
     4188                        inputs->GetInputValue(&approximation,ApproximationEnum);
    41894189                        switch(approximation){
    41904190                                case MacAyealApproximationEnum:
    … …  
    43014301                friction->GetAlphaComplement(&alpha_complement, gauss,VxEnum,VyEnum,VzEnum);
    43024302
    4303                 dragcoefficient_input->GetParameterValue(&drag, gauss);
    4304                 adjointx_input->GetParameterValue(&lambda, gauss);
    4305                 adjointy_input->GetParameterValue(&mu, gauss);
    4306                 vx_input->GetParameterValue(&vx,gauss);
    4307                 vy_input->GetParameterValue(&vy,gauss);
    4308                 dragcoefficient_input->GetParameterDerivativeValue(&dk[0],&xyz_list[0][0],gauss);
     4303                dragcoefficient_input->GetInputValue(&drag, gauss);
     4304                adjointx_input->GetInputValue(&lambda, gauss);
     4305                adjointy_input->GetInputValue(&mu, gauss);
     4306                vx_input->GetInputValue(&vx,gauss);
     4307                vy_input->GetInputValue(&vy,gauss);
     4308                dragcoefficient_input->GetInputDerivativeValue(&dk[0],&xyz_list[0][0],gauss);
    43094309
    43104310                /*Build gradje_g_gaussian vector (actually -dJ/ddrag): */
    … …  
    43724372                /*Recover alpha_complement and drag: */
    43734373                friction->GetAlphaComplement(&alpha_complement, gauss,VxEnum,VyEnum,VzEnum);
    4374                 drag_input->GetParameterValue(&drag,gauss);
     4374                drag_input->GetInputValue(&drag,gauss);
    43754375
    43764376                /*recover lambda mu and xi: */
    4377                 adjointx_input->GetParameterValue(&lambda,gauss);
    4378                 adjointy_input->GetParameterValue(&mu    ,gauss);
    4379                 adjointz_input->GetParameterValue(&xi    ,gauss);
     4377                adjointx_input->GetInputValue(&lambda,gauss);
     4378                adjointy_input->GetInputValue(&mu    ,gauss);
     4379                adjointz_input->GetInputValue(&xi    ,gauss);
    43804380
    43814381                /*recover vx vy and vz: */
    4382                 vx_input->GetParameterValue(&vx, gauss);
    4383                 vy_input->GetParameterValue(&vy, gauss);
    4384                 vz_input->GetParameterValue(&vz, gauss);
     4382                vx_input->GetInputValue(&vx, gauss);
     4383                vy_input->GetInputValue(&vy, gauss);
     4384                vz_input->GetInputValue(&vz, gauss);
    43854385
    43864386                /*Get normal vector to the bed */
    … …  
    43964396
    43974397                /*Get k derivative: dk/dx */
    4398                 drag_input->GetParameterDerivativeValue(&dk[0],&xyz_list[0][0],gauss);
     4398                drag_input->GetInputDerivativeValue(&dk[0],&xyz_list[0][0],gauss);
    43994399
    44004400                /*Build gradje_g_gaussian vector (actually -dJ/ddrag): */
    … …  
    45944594
    45954595        /*retrieve inputs :*/
    4596         inputs->GetParameterValue(&approximation,ApproximationEnum);
     4596        inputs->GetInputValue(&approximation,ApproximationEnum);
    45974597
    45984598        /*If on water, return 0: */
    … …  
    46314631
    46324632        /*retrieve inputs :*/
    4633         inputs->GetParameterValue(&approximation,ApproximationEnum);
     4633        inputs->GetInputValue(&approximation,ApproximationEnum);
    46344634
    46354635        /*If on water, return 0: */
    … …  
    46684668
    46694669        /*retrieve inputs :*/
    4670         inputs->GetParameterValue(&approximation,ApproximationEnum);
     4670        inputs->GetInputValue(&approximation,ApproximationEnum);
    46714671
    46724672        /*If on water, return 0: */
    … …  
    47074707
    47084708        /*retrieve inputs :*/
    4709         inputs->GetParameterValue(&approximation,ApproximationEnum);
     4709        inputs->GetInputValue(&approximation,ApproximationEnum);
    47104710
    47114711        /*If on water, return 0: */
    … …  
    47444744
    47454745        /*retrieve inputs :*/
    4746         inputs->GetParameterValue(&approximation,ApproximationEnum);
     4746        inputs->GetInputValue(&approximation,ApproximationEnum);
    47474747
    47484748        /*If on water, return 0: */
    … …  
    47874787
    47884788        /*retrieve inputs :*/
    4789         inputs->GetParameterValue(&approximation,ApproximationEnum);
     4789        inputs->GetInputValue(&approximation,ApproximationEnum);
    47904790
    47914791        /*If on water, return 0: */
    … …  
    48644864                                       
    48654865                                        /*retrieve inputs: */
    4866                                         GetParameterListOnVertices(&thickness_init[0],ThicknessEnum);
    4867                                         GetParameterListOnVertices(&hydrostatic_ratio[0],GeometryHydrostaticRatioEnum);
    4868                                         GetParameterListOnVertices(&bed[0],BedEnum);
    4869                                         GetParameterListOnVertices(&surface[0],SurfaceEnum);
     4866                                        GetInputListOnVertices(&thickness_init[0],ThicknessEnum);
     4867                                        GetInputListOnVertices(&hydrostatic_ratio[0],GeometryHydrostaticRatioEnum);
     4868                                        GetInputListOnVertices(&bed[0],BedEnum);
     4869                                        GetInputListOnVertices(&surface[0],SurfaceEnum);
    48704870
    48714871                                        /*build new thickness: */
    … …  
    49524952
    49534953        int approximation;
    4954         inputs->GetParameterValue(&approximation,ApproximationEnum);
     4954        inputs->GetInputValue(&approximation,ApproximationEnum);
    49554955
    49564956        switch(approximation){
    … …  
    49724972
    49734973        /*Initialize Element vector and return if necessary*/
    4974         inputs->GetParameterValue(&approximation,ApproximationEnum);
     4974        inputs->GetInputValue(&approximation,ApproximationEnum);
    49754975        if(approximation!=StokesApproximationEnum) return NULL;
    49764976
    … …  
    51335133                // If we have a slope > 6% for this element,  it means  we are on a mountain. In this particular case,
    51345134                //velocity should be = 0. To achieve this result, we set alpha2_list to a very high value: */
    5135                 surface_input->GetParameterDerivativeValue(&slope[0],&xyz_list[0][0],gauss);
     5135                surface_input->GetInputDerivativeValue(&slope[0],&xyz_list[0][0],gauss);
    51365136                slope_magnitude=sqrt(pow(slope[0],2)+pow(slope[1],2));
    51375137
    … …  
    52995299
    53005300        /*If on water or not Stokes, skip stiffness: */
    5301         inputs->GetParameterValue(&approximation,ApproximationEnum);
     5301        inputs->GetInputValue(&approximation,ApproximationEnum);
    53025302        if(IsOnShelf() || !IsOnBed()) return NULL;
    53035303        ElementMatrix* Ke1=new ElementMatrix(this->nodes,NUMVERTICES,this->parameters,MacAyealApproximationEnum);
    … …  
    54075407
    54085408        int approximation;
    5409         inputs->GetParameterValue(&approximation,ApproximationEnum);
     5409        inputs->GetInputValue(&approximation,ApproximationEnum);
    54105410
    54115411        switch(approximation){
    … …  
    55605560        /*Initialize Element matrix*/
    55615561        ElementMatrix* Ke=new ElementMatrix(tria->nodes,NUMVERTICES2D,this->parameters,MacAyealApproximationEnum);
    5562         inputs->GetParameterValue(&approximation,ApproximationEnum);
     5562        inputs->GetInputValue(&approximation,ApproximationEnum);
    55635563
    55645564        /*Retrieve all inputs and parameters*/
    … …  
    57045704
    57055705        /*Retrieve all inputs and parameters*/
    5706         inputs->GetParameterValue(&approximation,ApproximationEnum);
     5706        inputs->GetInputValue(&approximation,ApproximationEnum);
    57075707        GetVerticesCoordinates(&xyz_list[0][0], nodes, NUMVERTICES);
    57085708        this->parameters->FindParam(&viscosity_overshoot,DiagnosticViscosityOvershootEnum);
    … …  
    57895789                GetL(&L[0][0], gauss,NDOF2);
    57905790
    5791                 surface_input->GetParameterDerivativeValue(&slope[0],&xyz_list[0][0],gauss);
     5791                surface_input->GetInputDerivativeValue(&slope[0],&xyz_list[0][0],gauss);
    57925792                friction->GetAlpha2(&alpha2, gauss,VxEnum,VyEnum,VzEnum);
    57935793                slope_magnitude=sqrt(pow(slope[0],2)+pow(slope[1],2));
    … …  
    58615861
    58625862        /*If on water or not Stokes, skip stiffness: */
    5863         inputs->GetParameterValue(&approximation,ApproximationEnum);
     5863        inputs->GetInputValue(&approximation,ApproximationEnum);
    58645864        if(approximation!=StokesApproximationEnum && approximation!=MacAyealStokesApproximationEnum && approximation!=PattynStokesApproximationEnum) return NULL;
    58655865        ElementMatrix* Ke=new ElementMatrix(nodes,NUMVERTICES,this->parameters,StokesApproximationEnum);
    … …  
    59295929
    59305930        /*If on water or not Stokes, skip stiffness: */
    5931         inputs->GetParameterValue(&approximation,ApproximationEnum);
     5931        inputs->GetInputValue(&approximation,ApproximationEnum);
    59325932        if(IsOnShelf() || !IsOnBed() || (approximation!=StokesApproximationEnum && approximation!=MacAyealStokesApproximationEnum &&  approximation!=PattynStokesApproximationEnum)) return NULL;
    59335933        ElementMatrix* Ke=new ElementMatrix(nodes,NUMVERTICES,this->parameters,StokesApproximationEnum);
    … …  
    61296129
    61306130        /*Initialize Element vector and return if necessary*/
    6131         inputs->GetParameterValue(&approximation,ApproximationEnum);
     6131        inputs->GetInputValue(&approximation,ApproximationEnum);
    61326132        if(approximation!=MacAyealStokesApproximationEnum) return NULL;
    61336133        ElementVector* pe=new ElementVector(nodes,NUMVERTICES,this->parameters,StokesApproximationEnum);
    … …  
    61516151                GetNodalFunctionsP1Derivatives(&dbasis[0][0],&xyz_list[0][0], gauss);
    61526152
    6153                 vzmacayeal_input->GetParameterDerivativeValue(&dw[0],&xyz_list[0][0],gauss);
     6153                vzmacayeal_input->GetInputDerivativeValue(&dw[0],&xyz_list[0][0],gauss);
    61546154
    61556155                this->GetStrainRate3d(&epsilon[0],&xyz_list[0][0],gauss,vx_input,vy_input,vz_input);
    … …  
    61936193        /*Initialize Element vector and return if necessary*/
    61946194        if(!IsOnBed() || IsOnShelf()) return NULL;
    6195         inputs->GetParameterValue(&approximation,ApproximationEnum);
     6195        inputs->GetInputValue(&approximation,ApproximationEnum);
    61966196        if(approximation!=MacAyealStokesApproximationEnum) return NULL;
    61976197        ElementVector* pe=new ElementVector(nodes,NUMVERTICES,this->parameters,StokesApproximationEnum);
    … …  
    62206220                GetNodalFunctionsP1(basis, gauss);
    62216221
    6222                 vzmacayeal_input->GetParameterValue(&w, gauss);
    6223                 vzmacayeal_input->GetParameterDerivativeValue(&dw[0],&xyz_list[0][0],gauss);
     6222                vzmacayeal_input->GetInputValue(&w, gauss);
     6223                vzmacayeal_input->GetInputDerivativeValue(&dw[0],&xyz_list[0][0],gauss);
    62246224
    62256225                BedNormal(&bed_normal[0],xyz_list_tria);
    … …  
    62746274
    62756275        /*Initialize Element vector and return if necessary*/
    6276         inputs->GetParameterValue(&approximation,ApproximationEnum);
     6276        inputs->GetInputValue(&approximation,ApproximationEnum);
    62776277        if(approximation!=PattynStokesApproximationEnum) return NULL;
    62786278        ElementVector* pe=new ElementVector(nodes,NUMVERTICES,this->parameters,StokesApproximationEnum);
    … …  
    62966296                GetNodalFunctionsP1Derivatives(&dbasis[0][0],&xyz_list[0][0], gauss);
    62976297
    6298                 vzpattyn_input->GetParameterDerivativeValue(&dw[0],&xyz_list[0][0],gauss);
     6298                vzpattyn_input->GetInputDerivativeValue(&dw[0],&xyz_list[0][0],gauss);
    62996299
    63006300                this->GetStrainRate3d(&epsilon[0],&xyz_list[0][0],gauss,vx_input,vy_input,vz_input);
    … …  
    63386338        /*Initialize Element vector and return if necessary*/
    63396339        if(!IsOnBed() || IsOnShelf()) return NULL;
    6340         inputs->GetParameterValue(&approximation,ApproximationEnum);
     6340        inputs->GetInputValue(&approximation,ApproximationEnum);
    63416341        if(approximation!=PattynStokesApproximationEnum) return NULL;
    63426342        ElementVector* pe=new ElementVector(nodes,NUMVERTICES,this->parameters,StokesApproximationEnum);
    … …  
    63656365                GetNodalFunctionsP1(basis, gauss);
    63666366
    6367                 vzpattyn_input->GetParameterValue(&w, gauss);
    6368                 vzpattyn_input->GetParameterDerivativeValue(&dw[0],&xyz_list[0][0],gauss);
     6367                vzpattyn_input->GetInputValue(&w, gauss);
     6368                vzpattyn_input->GetInputDerivativeValue(&dw[0],&xyz_list[0][0],gauss);
    63696369
    63706370                BedNormal(&bed_normal[0],xyz_list_tria);
    … …  
    63906390
    63916391        int approximation;
    6392         inputs->GetParameterValue(&approximation,ApproximationEnum);
     6392        inputs->GetInputValue(&approximation,ApproximationEnum);
    63936393
    63946394        switch(approximation){
    … …  
    65136513                        gauss->GaussPoint(ig);
    65146514
    6515                         slopex_input->GetParameterValue(&slope[0],gauss);
    6516                         slopey_input->GetParameterValue(&slope[1],gauss);
    6517                         surface_input->GetParameterValue(&surface,gauss);
    6518                         thickness_input->GetParameterValue(&thickness,gauss);
     6515                        slopex_input->GetInputValue(&slope[0],gauss);
     6516                        slopey_input->GetInputValue(&slope[1],gauss);
     6517                        surface_input->GetInputValue(&surface,gauss);
     6518                        thickness_input->GetInputValue(&thickness,gauss);
    65196519
    65206520                        slope2=pow(slope[0],2)+pow(slope[1],2);
    65216521                        constant_part=-2*pow(rho_ice*gravity,n)*pow(slope2,((n-1)/2));
    65226522
    6523                         PentaRef::GetParameterValue(&z_g,&z_list[0],gauss);
     6523                        PentaRef::GetInputValue(&z_g,&z_list[0],gauss);
    65246524                        GetSegmentJacobianDeterminant(&Jdet,&xyz_list_segment[0][0],gauss);
    65256525
    … …  
    65716571        int         i,j,ig;
    65726572        double      Jdet;
    6573         double      slope[3]; //do not put 2! this goes into GetParameterDerivativeValue, which addresses slope[3] also!
     6573        double      slope[3]; //do not put 2! this goes into GetInputDerivativeValue, which addresses slope[3] also!
    65746574        double      driving_stress_baseline,thickness;
    65756575        double      xyz_list[NUMVERTICES][3];
    … …  
    65946594                GetNodalFunctionsP1(basis, gauss);
    65956595
    6596                 thickness_input->GetParameterValue(&thickness, gauss);
    6597                 surface_input->GetParameterDerivativeValue(&slope[0],&xyz_list[0][0],gauss);
     6596                thickness_input->GetInputValue(&thickness, gauss);
     6597                surface_input->GetInputDerivativeValue(&slope[0],&xyz_list[0][0],gauss);
    65986598
    65996599                driving_stress_baseline=matpar->GetRhoIce()*matpar->GetG();
    … …  
    66466646
    66476647        /*Initialize Element vector and return if necessary*/
    6648         inputs->GetParameterValue(&approximation,ApproximationEnum);
     6648        inputs->GetInputValue(&approximation,ApproximationEnum);
    66496649        if(approximation!=StokesApproximationEnum && approximation!=MacAyealStokesApproximationEnum && approximation!=PattynStokesApproximationEnum) return NULL;
    66506650        ElementVector* pe=new ElementVector(nodes,NUMVERTICES,this->parameters,StokesApproximationEnum);
    … …  
    67186718        /*Initialize Element vector and return if necessary*/
    67196719        if(!IsOnBed() || !IsOnShelf()) return NULL;
    6720         inputs->GetParameterValue(&approximation,ApproximationEnum);
     6720        inputs->GetInputValue(&approximation,ApproximationEnum);
    67216721        this->parameters->FindParam(&shelf_dampening,DiagnosticShelfDampeningEnum);
    67226722        if(approximation!=StokesApproximationEnum && approximation!=MacAyealStokesApproximationEnum && approximation!=PattynStokesApproximationEnum) return NULL;
    … …  
    67446744
    67456745                BedNormal(&bed_normal[0],xyz_list_tria);
    6746                 bed_input->GetParameterValue(&bed, gauss);
     6746                bed_input->GetInputValue(&bed, gauss);
    67476747                if(shelf_dampening){ //add dampening to avoid too high vertical velocities when not in hydrostatic equilibrium
    6748                         bed_input->GetParameterDerivativeValue(&dz[0],&xyz_list[0][0],gauss);
    6749                         vx_input->GetParameterValue(&vx, gauss);
    6750                         vy_input->GetParameterValue(&vy, gauss);
    6751                         vz_input->GetParameterValue(&vz, gauss);
     6748                        bed_input->GetInputDerivativeValue(&dz[0],&xyz_list[0][0],gauss);
     6749                        vx_input->GetInputValue(&vx, gauss);
     6750                        vy_input->GetInputValue(&vy, gauss);
     6751                        vz_input->GetInputValue(&vz, gauss);
    67526752                        dt=0;
    67536753                        normal_vel=bed_normal[0]*vx+bed_normal[1]*vy+bed_normal[2]*vz;
    … …  
    68006800        /*Retrieve all inputs and parameters*/
    68016801        GetVerticesCoordinates(&xyz_list[0][0], nodes, NUMVERTICES);
    6802         inputs->GetParameterValue(&approximation,ApproximationEnum);
     6802        inputs->GetInputValue(&approximation,ApproximationEnum);
    68036803        Input* vx_input=inputs->GetInput(VxEnum); _assert_(vx_input);
    68046804        Input* vy_input=inputs->GetInput(VyEnum); _assert_(vy_input);
    … …  
    68176817                GetNodalFunctionsP1(basis, gauss);
    68186818
    6819                 vx_input->GetParameterDerivativeValue(&du[0],&xyz_list[0][0],gauss);
    6820                 vy_input->GetParameterDerivativeValue(&dv[0],&xyz_list[0][0],gauss);
     6819                vx_input->GetInputDerivativeValue(&du[0],&xyz_list[0][0],gauss);
     6820                vy_input->GetInputDerivativeValue(&dv[0],&xyz_list[0][0],gauss);
    68216821                if(approximation==PattynStokesApproximationEnum || approximation==MacAyealStokesApproximationEnum){
    6822                         vzstokes_input->GetParameterDerivativeValue(&dw[0],&xyz_list[0][0],gauss);
     6822                        vzstokes_input->GetInputDerivativeValue(&dw[0],&xyz_list[0][0],gauss);
    68236823                        dwdz=dw[2];
    68246824                }
    … …  
    68616861        GetVerticesCoordinates(&xyz_list[0][0], nodes, NUMVERTICES);
    68626862        for(i=0;i<NUMVERTICES2D;i++) for(j=0;j<3;j++) xyz_list_tria[i][j]=xyz_list[i][j];
    6863         inputs->GetParameterValue(&approximation,ApproximationEnum);
     6863        inputs->GetInputValue(&approximation,ApproximationEnum);
    68646864        Input* bed_input=inputs->GetInput(BedEnum);                                _assert_(bed_input);
    68656865        Input* basal_melting_input=inputs->GetInput(BasalforcingsMeltingRateEnum); _assert_(basal_melting_input);
    … …  
    68776877                gauss->GaussPoint(ig);
    68786878
    6879                 basal_melting_input->GetParameterValue(&basalmeltingvalue, gauss);
    6880                 bed_input->GetParameterDerivativeValue(&slope[0],&xyz_list[0][0],gauss);
    6881                 vx_input->GetParameterValue(&vx, gauss);
    6882                 vy_input->GetParameterValue(&vy, gauss);
     6879                basal_melting_input->GetInputValue(&basalmeltingvalue, gauss);
     6880                bed_input->GetInputDerivativeValue(&slope[0],&xyz_list[0][0],gauss);
     6881                vx_input->GetInputValue(&vx, gauss);
     6882                vy_input->GetInputValue(&vy, gauss);
    68836883                if(approximation==PattynStokesApproximationEnum || approximation==MacAyealStokesApproximationEnum){
    6884                         vzstokes_input->GetParameterValue(&vz, gauss);
     6884                        vzstokes_input->GetInputValue(&vz, gauss);
    68856885                }
    68866886                else vz=0;
    … …  
    69136913
    69146914        /*Get approximation enum and dof list: */
    6915         inputs->GetParameterValue(&approximation,ApproximationEnum);
     6915        inputs->GetInputValue(&approximation,ApproximationEnum);
    69166916        Input* vx_input=inputs->GetInput(VxEnum); _assert_(vx_input);
    69176917        Input* vy_input=inputs->GetInput(VyEnum); _assert_(vy_input);
    … …  
    69286928                /*Recover vx and vy*/
    69296929                gauss->GaussVertex(i);
    6930                 vx_input->GetParameterValue(&vx,gauss);
    6931                 vy_input->GetParameterValue(&vy,gauss);
     6930                vx_input->GetInputValue(&vx,gauss);
     6931                vy_input->GetInputValue(&vy,gauss);
    69326932                values[i*NDOF2+0]=vx;
    69336933                values[i*NDOF2+1]=vy;
    … …  
    69646964                /*Recover vx and vy*/
    69656965                gauss->GaussVertex(i);
    6966                 vx_input->GetParameterValue(&vx,gauss);
    6967                 vy_input->GetParameterValue(&vy,gauss);
     6966                vx_input->GetInputValue(&vx,gauss);
     6967                vy_input->GetInputValue(&vy,gauss);
    69686968                values[i*NDOF2+0]=vx;
    69696969                values[i*NDOF2+1]=vy;
    … …  
    69996999                /*Recover vz */
    70007000                gauss->GaussVertex(i);
    7001                 vz_input->GetParameterValue(&vz,gauss);
     7001                vz_input->GetInputValue(&vz,gauss);
    70027002                values[i]=vz;
    70037003        }
    … …  
    70387038        for(i=0;i<NUMVERTICES;i++){
    70397039                gauss->GaussVertex(i);
    7040                 vx_input->GetParameterValue(&vx,gauss);
    7041                 vy_input->GetParameterValue(&vy,gauss);
    7042                 vz_input->GetParameterValue(&vz,gauss);
    7043                 p_input ->GetParameterValue(&p ,gauss);
     7040                vx_input->GetInputValue(&vx,gauss);
     7041                vy_input->GetInputValue(&vy,gauss);
     7042                vz_input->GetInputValue(&vz,gauss);
     7043                p_input ->GetInputValue(&p ,gauss);
    70447044                values[i*NDOF4+0]=vx;
    70457045                values[i*NDOF4+1]=vy;
    … …  
    70627062
    70637063        /*Recover inputs*/
    7064         inputs->GetParameterValue(&approximation,ApproximationEnum);
     7064        inputs->GetInputValue(&approximation,ApproximationEnum);
    70657065
    70667066        /*MacAyeal, everything is done by the element on bed*/
    … …  
    71517151
    71527152                /*Now compute pressure*/
    7153                 GetParameterListOnVertices(&surface[0],SurfaceEnum);
     7153                GetInputListOnVertices(&surface[0],SurfaceEnum);
    71547154                for(i=0;i<NUMVERTICES;i++) pressure[i]=rho_ice*g*(surface[i]-xyz_list[i][2]);
    71557155
    … …  
    72507250        rho_ice=matpar->GetRhoIce();
    72517251        g=matpar->GetG();
    7252         GetParameterListOnVertices(&surface[0],SurfaceEnum);
     7252        GetInputListOnVertices(&surface[0],SurfaceEnum);
    72537253        for(i=0;i<NUMVERTICES;i++) pressure[i]=rho_ice*g*(surface[i]-xyz_list[i][2]);
    72547254
    … …  
    74077407        Input* vz_input=inputs->GetInput(VzEnum);
    74087408        if (vz_input){
    7409                 GetParameterListOnVertices(&vz[0],VzEnum);
     7409                GetInputListOnVertices(&vz[0],VzEnum);
    74107410        }
    74117411        else{
    … …  
    74207420        rho_ice=matpar->GetRhoIce();
    74217421        g=matpar->GetG();
    7422         GetParameterListOnVertices(&surface[0],SurfaceEnum);
     7422        GetInputListOnVertices(&surface[0],SurfaceEnum);
    74237423        for(i=0;i<NUMVERTICES;i++) pressure[i]=rho_ice*g*(surface[i]-xyz_list[i][2]);
    74247424
    … …  
    75887588        rho_ice=matpar->GetRhoIce();
    75897589        g=matpar->GetG();
    7590         GetParameterListOnVertices(&surface[0],SurfaceEnum);
     7590        GetInputListOnVertices(&surface[0],SurfaceEnum);
    75917591        for(i=0;i<NUMVERTICES;i++) pressure[i]=rho_ice*g*(surface[i]-xyz_list[i][2]);
    75927592
    … …  
    76337633
    76347634        /*Get the approximation and do nothing if the element in Stokes or None*/
    7635         inputs->GetParameterValue(&approximation,ApproximationEnum);
     7635        inputs->GetInputValue(&approximation,ApproximationEnum);
    76367636        if(approximation==StokesApproximationEnum || approximation==NoneApproximationEnum){
    76377637                return;
    … …  
    77047704                rho_ice=matpar->GetRhoIce();
    77057705                g=matpar->GetG();
    7706                 GetParameterListOnVertices(&surface[0],SurfaceEnum);
     7706                GetInputListOnVertices(&surface[0],SurfaceEnum);
    77077707                for(i=0;i<NUMVERTICES;i++) pressure[i]=rho_ice*g*(surface[i]-xyz_list[i][2]);
    77087708        }

  • issm/trunk/src/c/objects/Elements/Penta.h

    r9883 r10135  
    171171                void      GetDofList(int** pdoflist,int approximation_enum,int setenum);
    172172                void      GetDofList1(int* doflist);
    173                 void      GetSidList(int* sidlist);
     173                void    GetSidList(int* sidlist);
    174174                int     GetElementType(void);
    175                 void    GetParameterListOnVertices(double* pvalue,int enumtype);
    176                 void    GetParameterListOnVertices(double* pvalue,int enumtype,double defaultvalue);
    177                 void    GetParameterValue(double* pvalue,Node* node,int enumtype);
     175                void    GetInputListOnVertices(double* pvalue,int enumtype);
     176                void    GetInputListOnVertices(double* pvalue,int enumtype,double defaultvalue);
     177                void    GetInputValue(double* pvalue,Node* node,int enumtype);
    178178                void      GetPhi(double* phi, double*  epsilon, double viscosity);
    179179                void      GetSolutionFromInputsEnthalpy(Vec solutiong);
    180                 double GetStabilizationParameter(double u, double v, double w, double diameter, double rho_ice, double heatcapacity, double thermalconductivity);
     180                double  GetStabilizationParameter(double u, double v, double w, double diameter, double rho_ice, double heatcapacity, double thermalconductivity);
    181181                void    GetStrainRate3dPattyn(double* epsilon,double* xyz_list, GaussPenta* gauss, Input* vx_input, Input* vy_input);
    182182                void    GetStrainRate3d(double* epsilon,double* xyz_list, GaussPenta* gauss, Input* vx_input, Input* vy_input, Input* vz_input);

  • issm/trunk/src/c/objects/Elements/PentaRef.cpp

    r9642 r10135  
    13011301}
    13021302/*}}}*/
    1303 /*FUNCTION PentaRef::GetParameterValue{{{1*/
    1304 void PentaRef::GetParameterValue(double* pvalue,double* plist,GaussPenta* gauss){
     1303/*FUNCTION PentaRef::GetInputValue{{{1*/
     1304void PentaRef::GetInputValue(double* pvalue,double* plist,GaussPenta* gauss){
    13051305        /*P1 interpolation on Gauss point*/
    13061306
    … …  
    13161316}
    13171317/*}}}*/
    1318 /*FUNCTION PentaRef::GetParameterDerivativeValue{{{1*/
    1319 void PentaRef::GetParameterDerivativeValue(double* p, double* plist,double* xyz_list, GaussPenta* gauss){
     1318/*FUNCTION PentaRef::GetInputDerivativeValue{{{1*/
     1319void PentaRef::GetInputDerivativeValue(double* p, double* plist,double* xyz_list, GaussPenta* gauss){
    13201320        /*From node values of parameter p (p_list[0], p_list[1], p_list[2], p_list[3], p_list[4] and p_list[4]), return parameter derivative value at gaussian point specified by gauss_coord:
    13211321         *   dp/dx=p_list[0]*dh1/dx+p_list[1]*dh2/dx+p_list[2]*dh3/dx+p_list[3]*dh4/dx+p_list[4]*dh5/dx+p_list[5]*dh6/dx;

  • issm/trunk/src/c/objects/Elements/PentaRef.h

    r9642 r10135  
    5656                void GetLStokesMacAyeal(double* LStokesMacAyeal, GaussPenta* gauss);
    5757                void GetLprimeStokesMacAyeal(double* LprimeStokesMacAyeal, double* xyz_list, GaussPenta* gauss);
    58                 void GetParameterValue(double* pvalue,double* plist, GaussPenta* gauss);
    59                 void GetParameterValue(double* pvalue,double* plist,GaussTria* gauss){_error_("only PentaGauss are supported");};
    60                 void GetParameterDerivativeValue(double* pvalues, double* plist,double* xyz_list, GaussPenta* gauss);
    61                 void GetParameterDerivativeValue(double* pvalues, double* plist,double* xyz_list, GaussTria* gauss){_error_("only PentaGauss are supported");};
     58                void GetInputValue(double* pvalue,double* plist, GaussPenta* gauss);
     59                void GetInputValue(double* pvalue,double* plist,GaussTria* gauss){_error_("only PentaGauss are supported");};
     60                void GetInputDerivativeValue(double* pvalues, double* plist,double* xyz_list, GaussPenta* gauss);
     61                void GetInputDerivativeValue(double* pvalues, double* plist,double* xyz_list, GaussTria* gauss){_error_("only PentaGauss are supported");};
    6262
    6363};

  • issm/trunk/src/c/objects/Elements/Tria.cpp

    r9883 r10135  
    294294        if((surface_input->ObjectEnum()!=TriaVertexInputEnum) | (bed_input->ObjectEnum()!=TriaVertexInputEnum))_error_(" not supported yet for bed and surface interpolations not P1!");
    295295
    296         GetParameterListOnVertices(&h[0],ThicknessEnum);
    297         GetParameterListOnVertices(&s[0],SurfaceEnum);
    298         GetParameterListOnVertices(&b[0],BedEnum);
    299         GetParameterListOnVertices(&ba[0],BathymetryEnum);
     296        GetInputListOnVertices(&h[0],ThicknessEnum);
     297        GetInputListOnVertices(&s[0],SurfaceEnum);
     298        GetInputListOnVertices(&b[0],BedEnum);
     299        GetInputListOnVertices(&ba[0],BathymetryEnum);
    300300
    301301        /*material parameters: */
    … …  
    542542                delete gauss;
    543543
    544                 vxaverage_input->GetParameterAverage(&v_gauss[0]);
    545                 vyaverage_input->GetParameterAverage(&v_gauss[1]);
     544                vxaverage_input->GetInputAverage(&v_gauss[0]);
     545                vyaverage_input->GetInputAverage(&v_gauss[1]);
    546546
    547547                K[0][0]=pow(Jdettria,(double).5)/2.0*fabs(v_gauss[0]);
    … …  
    558558                GetL(&L[0], &xyz_list[0][0], gauss,NDOF1);
    559559
    560                 vxaverage_input->GetParameterValue(&vx,gauss);
    561                 vyaverage_input->GetParameterValue(&vy,gauss);
    562                 vxaverage_input->GetParameterDerivativeValue(&dvx[0],&xyz_list[0][0],gauss);
    563                 vyaverage_input->GetParameterDerivativeValue(&dvy[0],&xyz_list[0][0],gauss);
     560                vxaverage_input->GetInputValue(&vx,gauss);
     561                vyaverage_input->GetInputValue(&vy,gauss);
     562                vxaverage_input->GetInputDerivativeValue(&dvx[0],&xyz_list[0][0],gauss);
     563                vyaverage_input->GetInputDerivativeValue(&dvy[0],&xyz_list[0][0],gauss);
    564564
    565565                DL_scalar=gauss->weight*Jdettria;
    … …  
    650650                gauss->GaussPoint(ig);
    651651
    652                 vxaverage_input->GetParameterValue(&vx,gauss);
    653                 vyaverage_input->GetParameterValue(&vy,gauss);
     652                vxaverage_input->GetInputValue(&vx,gauss);
     653                vyaverage_input->GetInputValue(&vy,gauss);
    654654
    655655                GetJacobianDeterminant2d(&Jdettria, &xyz_list[0][0],gauss);
    … …  
    832832                GetL(&L[0], &xyz_list[0][0], gauss,NDOF1);
    833833
    834                 surface_mass_balance_input->GetParameterValue(&surface_mass_balance_g,gauss);
    835                 basal_melting_input->GetParameterValue(&basal_melting_g,gauss);
    836                 thickness_input->GetParameterValue(&thickness_g,gauss);
    837                 if(basal_melting_correction_input) basal_melting_correction_input->GetParameterValue(&basal_melting_correction_g,gauss);
     834                surface_mass_balance_input->GetInputValue(&surface_mass_balance_g,gauss);
     835                basal_melting_input->GetInputValue(&basal_melting_g,gauss);
     836                thickness_input->GetInputValue(&thickness_g,gauss);
     837                if(basal_melting_correction_input) basal_melting_correction_input->GetInputValue(&basal_melting_correction_g,gauss);
    838838
    839839                for(i=0;i<numdof;i++) pe->values[i]+=Jdettria*gauss->weight*(thickness_g+dt*(surface_mass_balance_g-basal_melting_g-basal_melting_correction_g))*L[i];
    … …  
    878878                GetL(&L[0], &xyz_list[0][0], gauss,NDOF1);
    879879
    880                 surface_mass_balance_input->GetParameterValue(&surface_mass_balance_g,gauss);
    881                 basal_melting_input->GetParameterValue(&basal_melting_g,gauss);
    882                 thickness_input->GetParameterValue(&thickness_g,gauss);
     880                surface_mass_balance_input->GetInputValue(&surface_mass_balance_g,gauss);
     881                basal_melting_input->GetInputValue(&basal_melting_g,gauss);
     882                thickness_input->GetInputValue(&thickness_g,gauss);
    883883
    884884                for(i=0;i<numdof;i++) pe->values[i]+=Jdettria*gauss->weight*(thickness_g+dt*(surface_mass_balance_g-basal_melting_g))*L[i];
    … …  
    928928                GetNodalFunctions(basis, gauss);
    929929
    930                 slope_input->GetParameterDerivativeValue(&slope[0],&xyz_list[0][0],gauss);
     930                slope_input->GetInputDerivativeValue(&slope[0],&xyz_list[0][0],gauss);
    931931
    932932                if ( (analysis_type==SurfaceSlopeXAnalysisEnum) || (analysis_type==BedSlopeXAnalysisEnum)){
    … …  
    11401140}
    11411141/*}}}*/
    1142 /*FUNCTION Tria::GetParameterListOnVertices(double* pvalue,int enumtype) {{{1*/
    1143 void Tria::GetParameterListOnVertices(double* pvalue,int enumtype){
     1142/*FUNCTION Tria::GetInputListOnVertices(double* pvalue,int enumtype) {{{1*/
     1143void Tria::GetInputListOnVertices(double* pvalue,int enumtype){
    11441144
    11451145        /*Intermediaries*/
    … …  
    11581158        for (int iv=0;iv<NUMVERTICES;iv++){
    11591159                gauss->GaussVertex(iv);
    1160                 input->GetParameterValue(&pvalue[iv],gauss);
     1160                input->GetInputValue(&pvalue[iv],gauss);
    11611161        }
    11621162
    … …  
    11651165}
    11661166/*}}}*/
    1167 /*FUNCTION Tria::GetParameterListOnVertices(double* pvalue,int enumtype,double defaultvalue) {{{1*/
    1168 void Tria::GetParameterListOnVertices(double* pvalue,int enumtype,double defaultvalue){
     1167/*FUNCTION Tria::GetInputListOnVertices(double* pvalue,int enumtype,double defaultvalue) {{{1*/
     1168void Tria::GetInputListOnVertices(double* pvalue,int enumtype,double defaultvalue){
    11691169
    11701170        double     value[NUMVERTICES];
    … …  
    11801180                for (int iv=0;iv<NUMVERTICES;iv++){
    11811181                        gauss->GaussVertex(iv);
    1182                         input->GetParameterValue(&pvalue[iv],gauss);
     1182                        input->GetInputValue(&pvalue[iv],gauss);
    11831183                }
    11841184        }
    … …  
    11911191}
    11921192/*}}}*/
    1193 /*FUNCTION Tria::GetParameterListOnVertices(double* pvalue,int enumtype,double defaultvalue,int index) TO BE REMOVED{{{1*/
    1194 void Tria::GetParameterListOnVertices(double* pvalue,int enumtype,double defaultvalue,int index){
     1193/*FUNCTION Tria::GetInputListOnVertices(double* pvalue,int enumtype,double defaultvalue,int index) TO BE REMOVED{{{1*/
     1194void Tria::GetInputListOnVertices(double* pvalue,int enumtype,double defaultvalue,int index){
    11951195
    11961196        double     value[NUMVERTICES];
    … …  
    12061206                for (int iv=0;iv<NUMVERTICES;iv++){
    12071207                        gauss->GaussVertex(iv);
    1208                         input->GetParameterValue(&pvalue[iv],gauss,index);
     1208                        input->GetInputValue(&pvalue[iv],gauss,index);
    12091209                }
    12101210        }
    … …  
    12171217}
    12181218/*}}}*/
    1219 /*FUNCTION Tria::GetParameterValue(double* pvalue,Node* node,int enumtype) {{{1*/
    1220 void Tria::GetParameterValue(double* pvalue,Node* node,int enumtype){
     1219/*FUNCTION Tria::GetInputValue(double* pvalue,Node* node,int enumtype) {{{1*/
     1220void Tria::GetInputValue(double* pvalue,Node* node,int enumtype){
    12211221
    12221222        Input* input=inputs->GetInput(enumtype);
    … …  
    12261226        gauss->GaussVertex(this->GetNodeIndex(node));
    12271227
    1228         input->GetParameterValue(pvalue,gauss);
     1228        input->GetInputValue(pvalue,gauss);
    12291229        delete gauss;
    12301230}
    … …  
    18961896       
    18971897        bool onbed;
    1898         inputs->GetParameterValue(&onbed,MeshElementonbedEnum);
     1898        inputs->GetInputValue(&onbed,MeshElementonbedEnum);
    18991899        return onbed;
    19001900}
    … …  
    19041904
    19051905        bool shelf;
    1906         inputs->GetParameterValue(&shelf,MaskElementonfloatingiceEnum);
     1906        inputs->GetInputValue(&shelf,MaskElementonfloatingiceEnum);
    19071907        return shelf;
    19081908}
    … …  
    19421942
    19431943        bool water;
    1944         inputs->GetParameterValue(&water,MaskElementonwaterEnum);
     1944        inputs->GetInputValue(&water,MaskElementonwaterEnum);
    19451945        return water;
    19461946}
    … …  
    19981998        if((surface_input->ObjectEnum()!=TriaVertexInputEnum) | (bed_input->ObjectEnum()!=TriaVertexInputEnum))_error_(" not supported yet for bed and surface interpolations not P1!");
    19991999
    2000         GetParameterListOnVertices(&h[0],ThicknessEnum);
    2001         GetParameterListOnVertices(&s[0],SurfaceEnum);
    2002         GetParameterListOnVertices(&b[0],BedEnum);
    2003         GetParameterListOnVertices(&ba[0],BathymetryEnum);
     2000        GetInputListOnVertices(&h[0],ThicknessEnum);
     2001        GetInputListOnVertices(&s[0],SurfaceEnum);
     2002        GetInputListOnVertices(&b[0],BedEnum);
     2003        GetInputListOnVertices(&ba[0],BathymetryEnum);
    20042004        for(i=0;i<3;i++){
    20052005                isonshelf[i]=nodes[i]->IsOnShelf();
    … …  
    21282128        if((surface_input->ObjectEnum()!=TriaVertexInputEnum) | (bed_input->ObjectEnum()!=TriaVertexInputEnum))_error_(" not supported yet for bed and surface interpolations not P1!");
    21292129
    2130         GetParameterListOnVertices(&h[0],ThicknessEnum);
    2131         GetParameterListOnVertices(&s[0],SurfaceEnum);
    2132         GetParameterListOnVertices(&b[0],BedEnum);
    2133         GetParameterListOnVertices(&ba[0],BathymetryEnum);
     2130        GetInputListOnVertices(&h[0],ThicknessEnum);
     2131        GetInputListOnVertices(&s[0],SurfaceEnum);
     2132        GetInputListOnVertices(&b[0],BedEnum);
     2133        GetInputListOnVertices(&ba[0],BathymetryEnum);
    21342134
    21352135        /*material parameters: */
    … …  
    22292229        if((surface_input->ObjectEnum()!=TriaVertexInputEnum) | (bed_input->ObjectEnum()!=TriaVertexInputEnum))_error_(" not supported yet for bed and surface interpolations not P1!");
    22302230
    2231         GetParameterListOnVertices(&h[0],ThicknessEnum);
    2232         GetParameterListOnVertices(&s[0],SurfaceEnum);
    2233         GetParameterListOnVertices(&b[0],BedEnum);
    2234         GetParameterListOnVertices(&ba[0],BathymetryEnum);
     2231        GetInputListOnVertices(&h[0],ThicknessEnum);
     2232        GetInputListOnVertices(&s[0],SurfaceEnum);
     2233        GetInputListOnVertices(&b[0],BedEnum);
     2234        GetInputListOnVertices(&ba[0],BathymetryEnum);
    22352235
    22362236        /*material parameters: */
    … …  
    22902290        if((surface_input->ObjectEnum()!=TriaVertexInputEnum) | (bed_input->ObjectEnum()!=TriaVertexInputEnum))_error_(" not supported yet for bed and surface interpolations not P1!");
    22912291
    2292         GetParameterListOnVertices(&h[0],ThicknessEnum);
    2293         GetParameterListOnVertices(&s[0],SurfaceEnum);
    2294         GetParameterListOnVertices(&b[0],BedEnum);
    2295         GetParameterListOnVertices(&ba[0],BathymetryEnum);
     2292        GetInputListOnVertices(&h[0],ThicknessEnum);
     2293        GetInputListOnVertices(&s[0],SurfaceEnum);
     2294        GetInputListOnVertices(&b[0],BedEnum);
     2295        GetInputListOnVertices(&ba[0],BathymetryEnum);
    22962296
    22972297        /*material parameters: */
    … …  
    25672567        if((surface_input->ObjectEnum()!=TriaVertexInputEnum) | (bed_input->ObjectEnum()!=TriaVertexInputEnum))_error_(" not supported yet for bed and surface interpolations not P1!");
    25682568
    2569         GetParameterListOnVertices(&h[0],ThicknessEnum);
    2570         GetParameterListOnVertices(&s[0],SurfaceEnum);
    2571         GetParameterListOnVertices(&b[0],BedEnum);
    2572         GetParameterListOnVertices(&ba[0],BathymetryEnum);
     2569        GetInputListOnVertices(&h[0],ThicknessEnum);
     2570        GetInputListOnVertices(&s[0],SurfaceEnum);
     2571        GetInputListOnVertices(&b[0],BedEnum);
     2572        GetInputListOnVertices(&ba[0],BathymetryEnum);
    25732573
    25742574        /*material parameters: */
    … …  
    26302630        double  ba[3];
    26312631
    2632         GetParameterListOnVertices(&h[0],ThicknessEnum);
    2633         GetParameterListOnVertices(&s[0],SurfaceEnum);
    2634         GetParameterListOnVertices(&b[0],BedEnum);
    2635         GetParameterListOnVertices(&ba[0],BathymetryEnum);
     2632        GetInputListOnVertices(&h[0],ThicknessEnum);
     2633        GetInputListOnVertices(&s[0],SurfaceEnum);
     2634        GetInputListOnVertices(&b[0],BedEnum);
     2635        GetInputListOnVertices(&ba[0],BathymetryEnum);
    26362636
    26372637        for(i=0;i<3;i++){
    … …  
    26822682        Input* surface_input = inputs->GetInput(SurfaceEnum); _assert_(surface_input);
    26832683        Input* bed_input     = inputs->GetInput(BedEnum);     _assert_(bed_input);
    2684         surface_input->GetParameterAverage(&surface);
    2685         bed_input->GetParameterAverage(&bed);
     2684        surface_input->GetInputAverage(&surface);
     2685        bed_input->GetInputAverage(&bed);
    26862686
    26872687        /*Return: */
    … …  
    27312731        Input* vy_input=inputs->GetInput(VyEnum); _assert_(vy_input);
    27322732
    2733         thickness_input->GetParameterValue(&h1, gauss_1);
    2734         thickness_input->GetParameterValue(&h2, gauss_2);
    2735         vx_input->GetParameterValue(&vx1,gauss_1);
    2736         vx_input->GetParameterValue(&vx2,gauss_2);
    2737         vy_input->GetParameterValue(&vy1,gauss_1);
    2738         vy_input->GetParameterValue(&vy2,gauss_2);
     2733        thickness_input->GetInputValue(&h1, gauss_1);
     2734        thickness_input->GetInputValue(&h2, gauss_2);
     2735        vx_input->GetInputValue(&vx1,gauss_1);
     2736        vx_input->GetInputValue(&vx2,gauss_2);
     2737        vy_input->GetInputValue(&vy1,gauss_1);
     2738        vy_input->GetInputValue(&vy2,gauss_2);
    27392739
    27402740        mass_flux= rho_ice*length*( 
    … …  
    29162916                                /*ok, we are good. retrieve value of input at vertex :*/
    29172917                                gauss=new GaussTria(); gauss->GaussVertex(i);
    2918                                 data->GetParameterValue(&value,gauss);
     2918                                data->GetInputValue(&value,gauss);
    29192919                                found=1;
    29202920                                break;
    … …  
    29952995                matice->GetViscosity2d(&viscosity, &epsilon[0]);
    29962996                matice->GetViscosity2d(&oldviscosity, &oldepsilon[0]);
    2997                 thickness_input->GetParameterValue(&thickness, gauss);
     2997                thickness_input->GetInputValue(&thickness, gauss);
    29982998
    29992999                newviscosity=viscosity+viscosity_overshoot*(viscosity-oldviscosity);
    … …  
    30563056                // If we have a slope > 6% for this element,  it means  we are on a mountain. In this particular case,
    30573057                //velocity should be = 0. To achieve this result, we set alpha2_list to a very high value: */
    3058                 surface_input->GetParameterDerivativeValue(&slope[0],&xyz_list[0][0],gauss);
     3058                surface_input->GetInputDerivativeValue(&slope[0],&xyz_list[0][0],gauss);
    30593059                slope_magnitude=sqrt(pow(slope[0],2)+pow(slope[1],2));
    30603060                if(slope_magnitude>MAXSLOPE) alpha2=pow((double)10,MOUNTAINKEXPONENT);
    … …  
    31333133                GetNodalFunctions(basis, gauss);
    31343134
    3135                 thickness_input->GetParameterValue(&thickness,gauss);
    3136                 surface_input->GetParameterDerivativeValue(&slope[0],&xyz_list[0][0],gauss);
     3135                thickness_input->GetInputValue(&thickness,gauss);
     3136                surface_input->GetInputDerivativeValue(&slope[0],&xyz_list[0][0],gauss);
    31373137                driving_stress_baseline=matpar->GetRhoIce()*matpar->GetG()*thickness;
    31383138
    … …  
    31813181                connectivity=nodes[i]->GetConnectivity();
    31823182
    3183                 thickness_input->GetParameterValue(&thickness,gauss);
    3184                 slopex_input->GetParameterValue(&slope[0],gauss);
    3185                 slopey_input->GetParameterValue(&slope[1],gauss);
     3183                thickness_input->GetInputValue(&thickness,gauss);
     3184                slopex_input->GetInputValue(&slope[0],gauss);
     3185                slopey_input->GetInputValue(&slope[1],gauss);
    31863186                slope2=pow(slope[0],2)+pow(slope[1],2);
    31873187
    … …  
    32263226
    32273227                /*Recover vx and vy*/
    3228                 vx_input->GetParameterValue(&vx,gauss);
    3229                 vy_input->GetParameterValue(&vy,gauss);
     3228                vx_input->GetInputValue(&vx,gauss);
     3229                vy_input->GetInputValue(&vy,gauss);
    32303230                values[i*NDOF2+0]=vx;
    32313231                values[i*NDOF2+1]=vy;
    … …  
    32653265
    32663266                /*Recover vx and vy*/
    3267                 vx_input->GetParameterValue(&vx,gauss);
    3268                 vy_input->GetParameterValue(&vy,gauss);
     3267                vx_input->GetInputValue(&vx,gauss);
     3268                vy_input->GetInputValue(&vy,gauss);
    32693269                values[i*NDOF2+0]=vx;
    32703270                values[i*NDOF2+1]=vy;
    … …  
    33123312
    33133313        /*Get Vz and compute vel*/
    3314         GetParameterListOnVertices(&vz[0],VzEnum,0);
     3314        GetInputListOnVertices(&vz[0],VzEnum,0);
    33153315        for(i=0;i<NUMVERTICES;i++) vel[i]=pow( pow(vx[i],2.0) + pow(vy[i],2.0) + pow(vz[i],2.0) , 0.5);
    33163316
    … …  
    33193319        rho_ice=matpar->GetRhoIce();
    33203320        g=matpar->GetG();
    3321         GetParameterListOnVertices(&thickness[0],ThicknessEnum);
     3321        GetInputListOnVertices(&thickness[0],ThicknessEnum);
    33223322        for(i=0;i<NUMVERTICES;i++) pressure[i]=rho_ice*g*thickness[i];
    33233323
    … …  
    33943394        rho_ice=matpar->GetRhoIce();
    33953395        g=matpar->GetG();
    3396         GetParameterListOnVertices(&thickness[0],ThicknessEnum);
     3396        GetInputListOnVertices(&thickness[0],ThicknessEnum);
    33973397        for(i=0;i<NUMVERTICES;i++) pressure[i]=rho_ice*g*thickness[i];
    33983398
    … …  
    35963596                GetJacobianDeterminant2d(&Jdet, &xyz_list[0][0],gauss);
    35973597                GetNodalFunctionsDerivatives(&dbasis[0][0],&xyz_list[0][0],gauss);
    3598                 weights_input->GetParameterValue(&weight,gauss,weight_index);
     3598                weights_input->GetInputValue(&weight,gauss,weight_index);
    35993599
    36003600                /*Build alpha_complement_list: */
    3601                 rheologyb_input->GetParameterDerivativeValue(&dk[0],&xyz_list[0][0],gauss);
     3601                rheologyb_input->GetInputDerivativeValue(&dk[0],&xyz_list[0][0],gauss);
    36023602
    36033603                /*Build gradje_g_gaussian vector (actually -dJ/ddrag): */
    … …  
    36423642                gauss->GaussPoint(ig);
    36433643
    3644                 thickness_input->GetParameterValue(&thickness,gauss);
    3645                 rheologyb_input->GetParameterDerivativeValue(&dB[0],&xyz_list[0][0],gauss);
    3646                 vx_input->GetParameterDerivativeValue(&dvx[0],&xyz_list[0][0],gauss);
    3647                 vy_input->GetParameterDerivativeValue(&dvy[0],&xyz_list[0][0],gauss);
    3648                 adjointx_input->GetParameterDerivativeValue(&dadjx[0],&xyz_list[0][0],gauss);
    3649                 adjointy_input->GetParameterDerivativeValue(&dadjy[0],&xyz_list[0][0],gauss);
     3644                thickness_input->GetInputValue(&thickness,gauss);
     3645                rheologyb_input->GetInputDerivativeValue(&dB[0],&xyz_list[0][0],gauss);
     3646                vx_input->GetInputDerivativeValue(&dvx[0],&xyz_list[0][0],gauss);
     3647                vy_input->GetInputDerivativeValue(&dvy[0],&xyz_list[0][0],gauss);
     3648                adjointx_input->GetInputDerivativeValue(&dadjx[0],&xyz_list[0][0],gauss);
     3649                adjointy_input->GetInputDerivativeValue(&dadjy[0],&xyz_list[0][0],gauss);
    36503650
    36513651                this->GetStrainRate2d(&epsilon[0],&xyz_list[0][0],gauss,vx_input,vy_input);
    … …  
    37133713                friction->GetAlphaComplement(&alpha_complement, gauss,VxEnum,VyEnum,VzEnum);
    37143714       
    3715                 dragcoefficient_input->GetParameterValue(&drag, gauss);
    3716                 adjointx_input->GetParameterValue(&lambda, gauss);
    3717                 adjointy_input->GetParameterValue(&mu, gauss);
    3718                 vx_input->GetParameterValue(&vx,gauss);
    3719                 vy_input->GetParameterValue(&vy,gauss);
    3720                 dragcoefficient_input->GetParameterDerivativeValue(&dk[0],&xyz_list[0][0],gauss);
     3715                dragcoefficient_input->GetInputValue(&drag, gauss);
     3716                adjointx_input->GetInputValue(&lambda, gauss);
     3717                adjointy_input->GetInputValue(&mu, gauss);
     3718                vx_input->GetInputValue(&vx,gauss);
     3719                vy_input->GetInputValue(&vy,gauss);
     3720                dragcoefficient_input->GetInputDerivativeValue(&dk[0],&xyz_list[0][0],gauss);
    37213721
    37223722                /*Build gradje_g_gaussian vector (actually -dJ/ddrag): */
    … …  
    37373737        //      gauss->GaussVertex(iv);
    37383738        //      friction->GetAlphaComplement(&alpha_complement, gauss,VxEnum,VyEnum,VzEnum);
    3739         //      dragcoefficient_input->GetParameterValue(&drag, gauss);
    3740         //      adjointx_input->GetParameterValue(&lambda, gauss);
    3741         //      adjointy_input->GetParameterValue(&mu, gauss);
    3742         //      vx_input->GetParameterValue(&vx,gauss);
    3743         //      vy_input->GetParameterValue(&vy,gauss);
     3739        //      dragcoefficient_input->GetInputValue(&drag, gauss);
     3740        //      adjointx_input->GetInputValue(&lambda, gauss);
     3741        //      adjointy_input->GetInputValue(&mu, gauss);
     3742        //      vx_input->GetInputValue(&vx,gauss);
     3743        //      vy_input->GetInputValue(&vy,gauss);
    37443744        //      grade_g[iv]=-2*drag*alpha_complement*((lambda*vx+mu*vy));
    37453745        //      VecSetValues(gradient,NUMVERTICES,doflist1,(const double*)grade_g,INSERT_VALUES);
    … …  
    37813781                GetJacobianDeterminant2d(&Jdet, &xyz_list[0][0],gauss);
    37823782                GetNodalFunctionsDerivatives(&dbasis[0][0],&xyz_list[0][0],gauss);
    3783                 weights_input->GetParameterValue(&weight,gauss,weight_index);
     3783                weights_input->GetInputValue(&weight,gauss,weight_index);
    37843784
    37853785                /*Build alpha_complement_list: */
    3786                 dragcoefficient_input->GetParameterDerivativeValue(&dk[0],&xyz_list[0][0],gauss);
     3786                dragcoefficient_input->GetInputDerivativeValue(&dk[0],&xyz_list[0][0],gauss);
    37873787
    37883788                /*Build gradje_g_gaussian vector (actually -dJ/ddrag): */
    … …  
    38093809
    38103810        /*Compute Gradient*/
    3811         GetParameterListOnVertices(&lambda[0],AdjointEnum);
     3811        GetInputListOnVertices(&lambda[0],AdjointEnum);
    38123812        for(int i=0;i<NUMVERTICES;i++) gradient_g[i]=-lambda[i];
    38133813
    … …  
    38453845                GetNodalFunctions(basis, gauss);
    38463846               
    3847                 adjoint_input->GetParameterDerivativeValue(&Dlambda[0],&xyz_list[0][0],gauss);
    3848                 thickness_input->GetParameterValue(&thickness, gauss);
    3849                 thickness_input->GetParameterDerivativeValue(&dp[0],&xyz_list[0][0],gauss);
     3847                adjoint_input->GetInputDerivativeValue(&Dlambda[0],&xyz_list[0][0],gauss);
     3848                thickness_input->GetInputValue(&thickness, gauss);
     3849                thickness_input->GetInputDerivativeValue(&dp[0],&xyz_list[0][0],gauss);
    38503850
    38513851                for(i=0;i<NUMVERTICES;i++) grade_g[i]+=thickness*Dlambda[0]*Jdet*gauss->weight*basis[i];
    … …  
    38883888                GetNodalFunctions(basis, gauss);
    38893889
    3890                 adjoint_input->GetParameterDerivativeValue(&Dlambda[0],&xyz_list[0][0],gauss);
    3891                 thickness_input->GetParameterValue(&thickness, gauss);
    3892                 thickness_input->GetParameterDerivativeValue(&dp[0],&xyz_list[0][0],gauss);
     3890                adjoint_input->GetInputDerivativeValue(&Dlambda[0],&xyz_list[0][0],gauss);
     3891                thickness_input->GetInputValue(&thickness, gauss);
     3892                thickness_input->GetInputDerivativeValue(&dp[0],&xyz_list[0][0],gauss);
    38933893
    38943894                for(i=0;i<NUMVERTICES;i++) grade_g[i]+=thickness*Dlambda[1]*Jdet*gauss->weight*basis[i];
    … …  
    39323932
    39333933                /*Get all parameters at gaussian point*/
    3934                 weights_input->GetParameterValue(&weight,gauss,weight_index);
    3935                 rheologyb_input->GetParameterDerivativeValue(&dp[0],&xyz_list[0][0],gauss);
     3934                weights_input->GetInputValue(&weight,gauss,weight_index);
     3935                rheologyb_input->GetInputDerivativeValue(&dp[0],&xyz_list[0][0],gauss);
    39363936
    39373937                /*Tikhonov regularization: J = 1/2 ((dp/dx)^2 + (dp/dy)^2) */
    … …  
    39633963
    39643964        /*Retrieve all inputs we will be needing: */
    3965         inputs->GetParameterValue(&S,SurfaceAreaEnum);
     3965        inputs->GetInputValue(&S,SurfaceAreaEnum);
    39663966        Input* weights_input=inputs->GetInput(InversionCostFunctionsCoefficientsEnum);   _assert_(weights_input);
    39673967        Input* vx_input     =inputs->GetInput(VxEnum);        _assert_(vx_input);
    … …  
    39803980
    39813981                /*Get all parameters at gaussian point*/
    3982                 weights_input->GetParameterValue(&weight,gauss,weight_index);
    3983                 vx_input->GetParameterValue(&vx,gauss);
    3984                 vy_input->GetParameterValue(&vy,gauss);
    3985                 vxobs_input->GetParameterValue(&vxobs,gauss);
    3986                 vyobs_input->GetParameterValue(&vyobs,gauss);
     3982                weights_input->GetInputValue(&weight,gauss,weight_index);
     3983                vx_input->GetInputValue(&vx,gauss);
     3984                vy_input->GetInputValue(&vy,gauss);
     3985                vxobs_input->GetInputValue(&vxobs,gauss);
     3986                vyobs_input->GetInputValue(&vyobs,gauss);
    39873987
    39883988                /*Compute SurfaceAverageVelMisfitEnum:
    … …  
    40434043
    40444044                /*Get all parameters at gaussian point*/
    4045                 weights_input->GetParameterValue(&weight,gauss,weight_index);
    4046                 vx_input->GetParameterValue(&vx,gauss);
    4047                 vy_input->GetParameterValue(&vy,gauss);
    4048                 vxobs_input->GetParameterValue(&vxobs,gauss);
    4049                 vyobs_input->GetParameterValue(&vyobs,gauss);
     4045                weights_input->GetInputValue(&weight,gauss,weight_index);
     4046                vx_input->GetInputValue(&vx,gauss);
     4047                vy_input->GetInputValue(&vy,gauss);
     4048                vxobs_input->GetInputValue(&vxobs,gauss);
     4049                vyobs_input->GetInputValue(&vyobs,gauss);
    40504050
    40514051                /*Compute SurfaceLogVelMisfit:
    … …  
    41084108
    41094109                /*Get all parameters at gaussian point*/
    4110                 weights_input->GetParameterValue(&weight,gauss,weight_index);
    4111                 vx_input->GetParameterValue(&vx,gauss);
    4112                 vy_input->GetParameterValue(&vy,gauss);
    4113                 vxobs_input->GetParameterValue(&vxobs,gauss);
    4114                 vyobs_input->GetParameterValue(&vyobs,gauss);
     4110                weights_input->GetInputValue(&weight,gauss,weight_index);
     4111                vx_input->GetInputValue(&vx,gauss);
     4112                vy_input->GetInputValue(&vy,gauss);
     4113                vxobs_input->GetInputValue(&vxobs,gauss);
     4114                vyobs_input->GetInputValue(&vyobs,gauss);
    41154115
    41164116                /*Compute SurfaceRelVelMisfit:
    … …  
    41714171
    41724172                /*Get all parameters at gaussian point*/
    4173                 weights_input->GetParameterValue(&weight,gauss,weight_index);
    4174                 vx_input->GetParameterValue(&vx,gauss);
    4175                 vy_input->GetParameterValue(&vy,gauss);
    4176                 vxobs_input->GetParameterValue(&vxobs,gauss);
    4177                 vyobs_input->GetParameterValue(&vyobs,gauss);
     4173                weights_input->GetInputValue(&weight,gauss,weight_index);
     4174                vx_input->GetInputValue(&vx,gauss);
     4175                vy_input->GetInputValue(&vy,gauss);
     4176                vxobs_input->GetInputValue(&vxobs,gauss);
     4177                vyobs_input->GetInputValue(&vyobs,gauss);
    41784178
    41794179                /*Compute SurfaceAbsVelMisfitEnum:
    … …  
    42344234
    42354235                /*Get all parameters at gaussian point*/
    4236                 weights_input->GetParameterValue(&weight,gauss,weight_index);
    4237                 vx_input->GetParameterValue(&vx,gauss);
    4238                 vy_input->GetParameterValue(&vy,gauss);
    4239                 vxobs_input->GetParameterValue(&vxobs,gauss);
    4240                 vyobs_input->GetParameterValue(&vyobs,gauss);
     4236                weights_input->GetInputValue(&weight,gauss,weight_index);
     4237                vx_input->GetInputValue(&vx,gauss);
     4238                vy_input->GetInputValue(&vy,gauss);
     4239                vxobs_input->GetInputValue(&vxobs,gauss);
     4240                vyobs_input->GetInputValue(&vyobs,gauss);
    42414241
    42424242                /*Compute SurfaceRelVelMisfit:
    … …  
    42934293
    42944294                /*Get all parameters at gaussian point*/
    4295                 weights_input->GetParameterValue(&weight,gauss,weight_index);
    4296                 thickness_input->GetParameterDerivativeValue(&dp[0],&xyz_list[0][0],gauss);
     4295                weights_input->GetInputValue(&weight,gauss,weight_index);
     4296                thickness_input->GetInputDerivativeValue(&dp[0],&xyz_list[0][0],gauss);
    42974297
    42984298                /*Tikhonov regularization: J = 1/2 ((dp/dx)^2 + (dp/dy)^2) */
    … …  
    43364336
    43374337                /*Get parameters at gauss point*/
    4338                 thickness_input->GetParameterValue(&thickness,gauss);
    4339                 thickness_input->GetParameterDerivativeValue(&dH[0],&xyz_list[0][0],gauss);
    4340                 thicknessobs_input->GetParameterValue(&thicknessobs,gauss);
    4341                 weights_input->GetParameterValue(&weight,gauss,weight_index);
     4338                thickness_input->GetInputValue(&thickness,gauss);
     4339                thickness_input->GetInputDerivativeValue(&dH[0],&xyz_list[0][0],gauss);
     4340                thicknessobs_input->GetInputValue(&thicknessobs,gauss);
     4341                weights_input->GetInputValue(&weight,gauss,weight_index);
    43424342
    43434343                /*compute ThicknessAbsMisfit*/
    … …  
    43894389                GetNodalFunctionsDerivatives(&dbasis[0][0],&xyz_list[0][0],gauss);
    43904390
    4391                 thickness_input->GetParameterValue(&thickness, gauss);
    4392                 thickness_input->GetParameterDerivativeValue(&dH[0],&xyz_list[0][0],gauss);
    4393                 thicknessobs_input->GetParameterValue(&thicknessobs, gauss);
     4391                thickness_input->GetInputValue(&thickness, gauss);
     4392                thickness_input->GetInputDerivativeValue(&dH[0],&xyz_list[0][0],gauss);
     4393                thicknessobs_input->GetInputValue(&thicknessobs, gauss);
    43944394
    43954395                /*Loop over all requested responses*/
    … …  
    43974397
    43984398                        case ThicknessAbsMisfitEnum:
    4399                                 weights_input->GetParameterValue(&weight, gauss,resp);
     4399                                weights_input->GetInputValue(&weight, gauss,resp);
    44004400                                for(i=0;i<numdof;i++) pe->values[i]+=(thicknessobs-thickness)*weight*Jdet*gauss->weight*basis[i];
    44014401                                break;
    44024402                        case ThicknessAbsGradientEnum:
    4403                                 weights_input->GetParameterValue(&weight, gauss,resp);
     4403                                weights_input->GetInputValue(&weight, gauss,resp);
    44044404                                for(i=0;i<numdof;i++) pe->values[i]+= - weight*dH[0]*dbasis[0][i]*Jdet*gauss->weight;
    44054405                                for(i=0;i<numdof;i++) pe->values[i]+= - weight*dH[1]*dbasis[1][i]*Jdet*gauss->weight;
    … …  
    44524452        for(resp=0;resp<num_responses;resp++){
    44534453                if(responses[resp]==SurfaceAverageVelMisfitEnum){
    4454                         inputs->GetParameterValue(&S,SurfaceAreaEnum); break;
     4454                        inputs->GetInputValue(&S,SurfaceAreaEnum); break;
    44554455                }
    44564456        }
    … …  
    44664466
    44674467                /*Get all parameters at gaussian point*/
    4468                 vx_input->GetParameterValue(&vx,gauss);
    4469                 vy_input->GetParameterValue(&vy,gauss);
    4470                 vxobs_input->GetParameterValue(&vxobs,gauss);
    4471                 vyobs_input->GetParameterValue(&vyobs,gauss);
     4468                vx_input->GetInputValue(&vx,gauss);
     4469                vy_input->GetInputValue(&vy,gauss);
     4470                vxobs_input->GetInputValue(&vxobs,gauss);
     4471                vyobs_input->GetInputValue(&vyobs,gauss);
    44724472                GetNodalFunctions(basis, gauss);
    44734473
    … …  
    44754475                for(resp=0;resp<num_responses;resp++){
    44764476
    4477                         weights_input->GetParameterValue(&weight,gauss,resp);
     4477                        weights_input->GetInputValue(&weight,gauss,resp);
    44784478
    44794479                        switch(responses[resp]){
    … …  
    46284628        for(resp=0;resp<num_responses;resp++){
    46294629                if(responses[resp]==SurfaceAverageVelMisfitEnum){
    4630                         inputs->GetParameterValue(&S,SurfaceAreaEnum); break;
     4630                        inputs->GetInputValue(&S,SurfaceAreaEnum); break;
    46314631                }
    46324632        }
    … …  
    46424642
    46434643                /*Get all parameters at gaussian point*/
    4644                 vx_input->GetParameterValue(&vx,gauss);
    4645                 vy_input->GetParameterValue(&vy,gauss);
    4646                 vxobs_input->GetParameterValue(&vxobs,gauss);
    4647                 vyobs_input->GetParameterValue(&vyobs,gauss);
     4644                vx_input->GetInputValue(&vx,gauss);
     4645                vy_input->GetInputValue(&vy,gauss);
     4646                vxobs_input->GetInputValue(&vxobs,gauss);
     4647                vyobs_input->GetInputValue(&vyobs,gauss);
    46484648                GetNodalFunctions(basis, gauss);
    46494649
    … …  
    46514651                for(resp=0;resp<num_responses;resp++){
    46524652
    4653                         weights_input->GetParameterValue(&weight,gauss,resp);
     4653                        weights_input->GetInputValue(&weight,gauss,resp);
    46544654
    46554655                        switch(responses[resp]){
    … …  
    48034803
    48044804                /*Get all parameters at gaussian point*/
    4805                 weights_input->GetParameterValue(&weight,gauss,weight_index);
    4806                 drag_input->GetParameterDerivativeValue(&dp[0],&xyz_list[0][0],gauss);
     4805                weights_input->GetInputValue(&weight,gauss,weight_index);
     4806                drag_input->GetInputDerivativeValue(&dp[0],&xyz_list[0][0],gauss);
    48074807
    48084808                /*Tikhonov regularization: J = 1/2 ((dp/dx)^2 + (dp/dy)^2) */
    … …  
    49294929        for (int iv=0;iv<NUMVERTICES;iv++){
    49304930                gauss->GaussVertex(iv);
    4931                 surfaceslopex_input->GetParameterValue(&dsdx,gauss);
    4932                 surfaceslopey_input->GetParameterValue(&dsdy,gauss);
    4933                 bedslopex_input->GetParameterValue(&dbdx,gauss);
    4934                 bedslopey_input->GetParameterValue(&dbdy,gauss);
    4935                 watercolumn_input->GetParameterValue(&w,gauss);
     4931                surfaceslopex_input->GetInputValue(&dsdx,gauss);
     4932                surfaceslopey_input->GetInputValue(&dsdy,gauss);
     4933                bedslopex_input->GetInputValue(&dbdx,gauss);
     4934                bedslopey_input->GetInputValue(&dbdy,gauss);
     4935                watercolumn_input->GetInputValue(&w,gauss);
    49364936
    49374937                /* Water velocity x and y components */
    … …  
    49964996                GetL(&L[0], &xyz_list[0][0], gauss,NDOF1);
    49974997
    4998                 vx_input->GetParameterValue(&vx,gauss);
    4999                 vy_input->GetParameterValue(&vy,gauss);
    5000                 vx_input->GetParameterDerivativeValue(&dvx[0],&xyz_list[0][0],gauss);
    5001                 vy_input->GetParameterDerivativeValue(&dvy[0],&xyz_list[0][0],gauss);
     4998                vx_input->GetInputValue(&vx,gauss);
     4999                vy_input->GetInputValue(&vy,gauss);
     5000                vx_input->GetInputDerivativeValue(&dvx[0],&xyz_list[0][0],gauss);
     5001                vy_input->GetInputDerivativeValue(&dvy[0],&xyz_list[0][0],gauss);
    50025002
    50035003                DL_scalar=gauss->weight*Jdettria;
    … …  
    50865086                GetNodalFunctions(basis, gauss);
    50875087
    5088                 basal_melting_input->GetParameterValue(&basal_melting_g,gauss);
    5089                 old_watercolumn_input->GetParameterValue(&old_watercolumn_g,gauss);
     5088                basal_melting_input->GetInputValue(&basal_melting_g,gauss);
     5089                old_watercolumn_input->GetInputValue(&old_watercolumn_g,gauss);
    50905090
    50915091                if(dt)for(i=0;i<numdof;i++) pe->values[i]+=Jdettria*gauss->weight*(old_watercolumn_g+dt*basal_melting_g)*basis[i];
    … …  
    51235123
    51245124                /*Recover watercolumn*/
    5125                 watercolumn_input->GetParameterValue(&watercolumn,gauss);
     5125                watercolumn_input->GetInputValue(&watercolumn,gauss);
    51265126                values[i]=watercolumn;
    51275127        }
    … …  
    51965196                                       
    51975197                                        /*retrieve inputs: */
    5198                                         GetParameterListOnVertices(&thickness_init[0],ThicknessEnum);
    5199                                         GetParameterListOnVertices(&hydrostatic_ratio[0],GeometryHydrostaticRatioEnum);
    5200                                         GetParameterListOnVertices(&bed[0],BedEnum);
    5201                                         GetParameterListOnVertices(&surface[0],SurfaceEnum);
     5198                                        GetInputListOnVertices(&thickness_init[0],ThicknessEnum);
     5199                                        GetInputListOnVertices(&hydrostatic_ratio[0],GeometryHydrostaticRatioEnum);
     5200                                        GetInputListOnVertices(&bed[0],BedEnum);
     5201                                        GetInputListOnVertices(&surface[0],SurfaceEnum);
    52025202
    52035203                                        /*build new thickness: */
    … …  
    53425342        //      delete gauss;
    53435343
    5344         //      vxaverage_input->GetParameterAverage(&vx);
    5345         //      vyaverage_input->GetParameterAverage(&vy);
     5344        //      vxaverage_input->GetInputAverage(&vx);
     5345        //      vyaverage_input->GetInputAverage(&vy);
    53465346        //      K[0][0]=pow(Jdettria,(double).5)/2.0*fabs(vx);
    53475347        //      K[1][1]=pow(Jdettria,(double).5)/2.0*fabs(vy);
    … …  
    53585358                GetBprimePrognostic(&Bprime[0][0], &xyz_list[0][0], gauss);
    53595359
    5360                 vxaverage_input->GetParameterValue(&vx,gauss);
    5361                 vyaverage_input->GetParameterValue(&vy,gauss);
    5362                 vxaverage_input->GetParameterDerivativeValue(&dvx[0],&xyz_list[0][0],gauss);
    5363                 vyaverage_input->GetParameterDerivativeValue(&dvy[0],&xyz_list[0][0],gauss);
     5360                vxaverage_input->GetInputValue(&vx,gauss);
     5361                vyaverage_input->GetInputValue(&vy,gauss);
     5362                vxaverage_input->GetInputDerivativeValue(&dvx[0],&xyz_list[0][0],gauss);
     5363                vyaverage_input->GetInputDerivativeValue(&dvy[0],&xyz_list[0][0],gauss);
    53645364
    53655365                dvxdx=dvx[0];
    … …  
    54455445                GetBprimePrognostic(&B[0][0], &xyz_list[0][0], gauss);
    54465446
    5447                 vx_input->GetParameterValue(&vx,gauss);
    5448                 vy_input->GetParameterValue(&vy,gauss);
     5447                vx_input->GetInputValue(&vx,gauss);
     5448                vy_input->GetInputValue(&vy,gauss);
    54495449
    54505450                DL_scalar=-gauss->weight*Jdettria;
    … …  
    55055505                gauss->GaussPoint(ig);
    55065506
    5507                 surface_mass_balance_input->GetParameterValue(&surface_mass_balance_g,gauss);
    5508                 basal_melting_input->GetParameterValue(&basal_melting_g,gauss);
    5509                 dhdt_input->GetParameterValue(&dhdt_g,gauss);
     5507                surface_mass_balance_input->GetInputValue(&surface_mass_balance_g,gauss);
     5508                basal_melting_input->GetInputValue(&basal_melting_g,gauss);
     5509                dhdt_input->GetInputValue(&dhdt_g,gauss);
    55105510
    55115511                GetJacobianDeterminant2d(&Jdettria, &xyz_list[0][0],gauss);
    … …  
    55485548                gauss->GaussPoint(ig);
    55495549
    5550                 surface_mass_balance_input->GetParameterValue(&surface_mass_balance_g,gauss);
    5551                 basal_melting_input->GetParameterValue(&basal_melting_g,gauss);
    5552                 dhdt_input->GetParameterValue(&dhdt_g,gauss);
     5550                surface_mass_balance_input->GetInputValue(&surface_mass_balance_g,gauss);
     5551                basal_melting_input->GetInputValue(&basal_melting_g,gauss);
     5552                dhdt_input->GetInputValue(&dhdt_g,gauss);
    55535553
    55545554                GetJacobianDeterminant2d(&Jdettria, &xyz_list[0][0],gauss);

  • issm/trunk/src/c/objects/Elements/Tria.h

    r9883 r10135  
    186186                double         GetArea(void);
    187187                int            GetElementType(void);
    188                 void           GetDofList(int** pdoflist,int approximation_enum,int setenum);
    189                 void           GetDofList1(int* doflist);
     188                void             GetDofList(int** pdoflist,int approximation_enum,int setenum);
     189                void             GetDofList1(int* doflist);
    190190                void           GetSidList(int* sidlist);
    191                 void           GetParameterListOnVertices(double* pvalue,int enumtype);
    192                 void           GetParameterListOnVertices(double* pvalue,int enumtype,double defaultvalue);
    193                 void           GetParameterListOnVertices(double* pvalue,int enumtype,double defaultvalue,int index); //TO BE REMOVED
    194                 void           GetParameterValue(double* pvalue,Node* node,int enumtype);
     191                void           GetInputListOnVertices(double* pvalue,int enumtype);
     192                void           GetInputListOnVertices(double* pvalue,int enumtype,double defaultvalue);
     193                void           GetInputListOnVertices(double* pvalue,int enumtype,double defaultvalue,int index); //TO BE REMOVED
     194                void           GetInputValue(double* pvalue,Node* node,int enumtype);
    195195                void           GetStrainRate2d(double* epsilon,double* xyz_list, GaussTria* gauss, Input* vx_input, Input* vy_input);
    196196                void           InputUpdateFromSolutionOneDof(double* solution,int enum_type);

  • issm/trunk/src/c/objects/Elements/TriaRef.cpp

    r9320 r10135  
    463463}
    464464/*}}}*/
    465 /*FUNCTION TriaRef::GetParameterDerivativeValue{{{1*/
    466 void TriaRef::GetParameterDerivativeValue(double* p, double* plist,double* xyz_list, GaussTria* gauss){
     465/*FUNCTION TriaRef::GetInputDerivativeValue{{{1*/
     466void TriaRef::GetInputDerivativeValue(double* p, double* plist,double* xyz_list, GaussTria* gauss){
    467467
    468468        /*From node values of parameter p (plist[0],plist[1],plist[2]), return parameter derivative value at gaussian
    … …  
    486486}
    487487/*}}}*/
    488 /*FUNCTION TriaRef::GetParameterValue{{{1*/
    489 void TriaRef::GetParameterValue(double* p, double* plist, GaussTria* gauss){
     488/*FUNCTION TriaRef::GetInputValue{{{1*/
     489void TriaRef::GetInputValue(double* p, double* plist, GaussTria* gauss){
    490490
    491491        /*From node values of parameter p (plist[0],plist[1],plist[2]), return parameter value at gaussian

  • issm/trunk/src/c/objects/Elements/TriaRef.h

    r6987 r10135  
    4343                void GetNodalFunctionsDerivatives(double* l1l2l3,double* xyz_list, GaussTria* gauss);
    4444                void GetNodalFunctionsDerivativesReference(double* dl1dl3,GaussTria* gauss);
    45                 void GetParameterValue(double* pp, double* plist, GaussTria* gauss);
    46                 void GetParameterDerivativeValue(double* pp, double* plist,double* xyz_list, GaussTria* gauss);
     45                void GetInputValue(double* pp, double* plist, GaussTria* gauss);
     46                void GetInputDerivativeValue(double* pp, double* plist,double* xyz_list, GaussTria* gauss);
    4747
    4848};

  • issm/trunk/src/c/objects/Inputs/BoolInput.cpp

    r9883 r10135  
    157157
    158158/*Object functions*/
    159 /*FUNCTION BoolInput::GetParameterValue(bool* pvalue) {{{1*/
    160 void BoolInput::GetParameterValue(bool* pvalue){
     159/*FUNCTION BoolInput::GetInputValue(bool* pvalue) {{{1*/
     160void BoolInput::GetInputValue(bool* pvalue){
    161161        *pvalue=value;
    162162}
    163163/*}}}*/
    164 /*FUNCTION BoolInput::GetParameterValue(int* pvalue){{{1*/
    165 void BoolInput::GetParameterValue(int* pvalue){_error_(" not supported yet!");}
    166 /*}}}*/
    167 /*FUNCTION BoolInput::GetParameterValue(double* pvalue){{{1*/
    168 void BoolInput::GetParameterValue(double* pvalue){_error_(" not supported yet!");}
    169 /*}}}*/
    170 /*FUNCTION BoolInput::GetParameterValue(double* pvalue,GaussTria* gauss){{{1*/
    171 void BoolInput::GetParameterValue(double* pvalue,GaussTria* gauss){_error_(" not supported yet!");}
    172 /*}}}*/
    173 /*FUNCTION BoolInput::GetParameterValue(double* pvalue,GaussPenta* gauss){{{1*/
    174 void BoolInput::GetParameterValue(double* pvalue,GaussPenta* gauss){_error_(" not supported yet!");}
    175 /*}}}*/
    176 /*FUNCTION BoolInput::GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss){{{1*/
    177 void BoolInput::GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss){_error_(" not supported yet!");}
    178 /*}}}*/
    179 /*FUNCTION BoolInput::GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){{{1*/
    180 void BoolInput::GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){_error_(" not supported yet!");}
     164/*FUNCTION BoolInput::GetInputValue(int* pvalue){{{1*/
     165void BoolInput::GetInputValue(int* pvalue){_error_(" not supported yet!");}
     166/*}}}*/
     167/*FUNCTION BoolInput::GetInputValue(double* pvalue){{{1*/
     168void BoolInput::GetInputValue(double* pvalue){_error_(" not supported yet!");}
     169/*}}}*/
     170/*FUNCTION BoolInput::GetInputValue(double* pvalue,GaussTria* gauss){{{1*/
     171void BoolInput::GetInputValue(double* pvalue,GaussTria* gauss){_error_(" not supported yet!");}
     172/*}}}*/
     173/*FUNCTION BoolInput::GetInputValue(double* pvalue,GaussPenta* gauss){{{1*/
     174void BoolInput::GetInputValue(double* pvalue,GaussPenta* gauss){_error_(" not supported yet!");}
     175/*}}}*/
     176/*FUNCTION BoolInput::GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss){{{1*/
     177void BoolInput::GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss){_error_(" not supported yet!");}
     178/*}}}*/
     179/*FUNCTION BoolInput::GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){{{1*/
     180void BoolInput::GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){_error_(" not supported yet!");}
    181181/*}}}*/
    182182/*FUNCTION BoolInput::ChangeEnum{{{1*/

  • issm/trunk/src/c/objects/Inputs/BoolInput.h

    r9883 r10135  
    5050                /*}}}*/
    5151                /*numerics: {{{1*/
    52                 void GetParameterValue(bool* pvalue);
    53                 void GetParameterValue(int* pvalue);
    54                 void GetParameterValue(double* pvalue);
    55                 void GetParameterValue(double* pvalue,GaussTria* gauss);
    56                 void GetParameterValue(double* pvalue,GaussPenta* gauss);
    57                 void GetParameterValue(double* pvalue,GaussTria* gauss ,int index){_error_("not implemented yet");};
    58                 void GetParameterValue(double* pvalue,GaussPenta* gauss ,int index){_error_("not implemented yet");};
    59                 void GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss);
    60                 void GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss);
    61                 void GetParameterAverage(double* pvalue){_error_("not implemented yet");};
     52                void GetInputValue(bool* pvalue);
     53                void GetInputValue(int* pvalue);
     54                void GetInputValue(double* pvalue);
     55                void GetInputValue(double* pvalue,GaussTria* gauss);
     56                void GetInputValue(double* pvalue,GaussPenta* gauss);
     57                void GetInputValue(double* pvalue,GaussTria* gauss ,int index){_error_("not implemented yet");};
     58                void GetInputValue(double* pvalue,GaussPenta* gauss ,int index){_error_("not implemented yet");};
     59                void GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss);
     60                void GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss);
     61                void GetInputAverage(double* pvalue){_error_("not implemented yet");};
    6262                void GetVxStrainRate2d(double* epsilonvx,double* xyz_list, GaussTria* gauss){_error_("not implemented yet");};
    6363                void GetVyStrainRate2d(double* epsilonvy,double* xyz_list, GaussTria* gauss){_error_("not implemented yet");};

  • issm/trunk/src/c/objects/Inputs/ControlInput.cpp

    r9883 r10135  
    398398        return gradient->SpawnResult(step,time);
    399399}/*}}}*/
    400 /*FUNCTION ControlInput::GetParameterValue(bool* pvalue){{{1*/
     400/*FUNCTION ControlInput::GetInputValue(bool* pvalue){{{1*/
    401401void ControlInput::GetVectorFromInputs(Vec vector,int* doflist){
    402402        values->GetVectorFromInputs(vector,doflist);
    403403}/*}}}*/
    404 /*FUNCTION ControlInput::GetParameterAverage(double* pvalue){{{1*/
    405 void ControlInput::GetParameterAverage(double* pvalue){
    406         values->GetParameterAverage(pvalue);
    407 }/*}}}*/
    408 /*FUNCTION ControlInput::GetParameterValue(bool* pvalue){{{1*/
    409 void ControlInput::GetParameterValue(bool* pvalue){
    410         values->GetParameterValue(pvalue);
    411 }/*}}}*/
    412 /*FUNCTION ControlInput::GetParameterValue(int* pvalue){{{1*/
    413 void ControlInput::GetParameterValue(int* pvalue){
    414         values->GetParameterValue(pvalue);
    415 }/*}}}*/
    416 /*FUNCTION ControlInput::GetParameterValue(double* pvalue){{{1*/
    417 void ControlInput::GetParameterValue(double* pvalue){
    418         values->GetParameterValue(pvalue);
    419 }/*}}}*/
    420 /*FUNCTION ControlInput::GetParameterValue(double* pvalue){{{1*/
    421 void ControlInput::GetParameterValue(double* pvalue,GaussTria* gauss){
    422         values->GetParameterValue(pvalue,gauss);
    423 }/*}}}*/
    424 /*FUNCTION ControlInput::GetParameterValue(double* pvalue){{{1*/
    425 void ControlInput::GetParameterValue(double* pvalue,GaussPenta* gauss){
    426         values->GetParameterValue(pvalue,gauss);
    427 }/*}}}*/
    428 /*FUNCTION ControlInput::GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss){{{1*/
    429 void ControlInput::GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss){
    430         values->GetParameterDerivativeValue(derivativevalues,xyz_list,gauss);
    431 }/*}}}*/
    432 /*FUNCTION ControlInput::GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){{{1*/
    433 void ControlInput::GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){
    434         values->GetParameterDerivativeValue(derivativevalues,xyz_list,gauss);
     404/*FUNCTION ControlInput::GetInputAverage(double* pvalue){{{1*/
     405void ControlInput::GetInputAverage(double* pvalue){
     406        values->GetInputAverage(pvalue);
     407}/*}}}*/
     408/*FUNCTION ControlInput::GetInputValue(bool* pvalue){{{1*/
     409void ControlInput::GetInputValue(bool* pvalue){
     410        values->GetInputValue(pvalue);
     411}/*}}}*/
     412/*FUNCTION ControlInput::GetInputValue(int* pvalue){{{1*/
     413void ControlInput::GetInputValue(int* pvalue){
     414        values->GetInputValue(pvalue);
     415}/*}}}*/
     416/*FUNCTION ControlInput::GetInputValue(double* pvalue){{{1*/
     417void ControlInput::GetInputValue(double* pvalue){
     418        values->GetInputValue(pvalue);
     419}/*}}}*/
     420/*FUNCTION ControlInput::GetInputValue(double* pvalue){{{1*/
     421void ControlInput::GetInputValue(double* pvalue,GaussTria* gauss){
     422        values->GetInputValue(pvalue,gauss);
     423}/*}}}*/
     424/*FUNCTION ControlInput::GetInputValue(double* pvalue){{{1*/
     425void ControlInput::GetInputValue(double* pvalue,GaussPenta* gauss){
     426        values->GetInputValue(pvalue,gauss);
     427}/*}}}*/
     428/*FUNCTION ControlInput::GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss){{{1*/
     429void ControlInput::GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss){
     430        values->GetInputDerivativeValue(derivativevalues,xyz_list,gauss);
     431}/*}}}*/
     432/*FUNCTION ControlInput::GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){{{1*/
     433void ControlInput::GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){
     434        values->GetInputDerivativeValue(derivativevalues,xyz_list,gauss);
    435435}/*}}}*/
    436436/*FUNCTION ControlInput::SaveValue{{{1*/

  • issm/trunk/src/c/objects/Inputs/ControlInput.h

    r9883 r10135  
    5454                /*}}}*/
    5555                /*numerics: {{{1*/
    56                 void GetParameterValue(bool* pvalue);
    57                 void GetParameterValue(int* pvalue);
    58                 void GetParameterValue(double* pvalue);
    59                 void GetParameterValue(double* pvalue,GaussTria* gauss);
    60                 void GetParameterValue(double* pvalue,GaussPenta* gauss);
    61                 void GetParameterValue(double* pvalue,GaussTria* gauss ,int index){_error_("not implemented yet");};
    62                 void GetParameterValue(double* pvalue,GaussPenta* gauss ,int index){_error_("not implemented yet");};
    63                 void GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss);
    64                 void GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss);
    65                 void GetParameterAverage(double* pvalue);
     56                void GetInputValue(bool* pvalue);
     57                void GetInputValue(int* pvalue);
     58                void GetInputValue(double* pvalue);
     59                void GetInputValue(double* pvalue,GaussTria* gauss);
     60                void GetInputValue(double* pvalue,GaussPenta* gauss);
     61                void GetInputValue(double* pvalue,GaussTria* gauss ,int index){_error_("not implemented yet");};
     62                void GetInputValue(double* pvalue,GaussPenta* gauss ,int index){_error_("not implemented yet");};
     63                void GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss);
     64                void GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss);
     65                void GetInputAverage(double* pvalue);
    6666                void GetVxStrainRate2d(double* epsilonvx,double* xyz_list, GaussTria* gauss){_error_("not implemented yet");};
    6767                void GetVyStrainRate2d(double* epsilonvy,double* xyz_list, GaussTria* gauss){_error_("not implemented yet");};

  • issm/trunk/src/c/objects/Inputs/DatasetInput.cpp

    r9883 r10135  
    175175}
    176176/*}}}*/
    177 /*FUNCTION DatasetInput::GetParameterValue(double* pvalue,GaussTria* gauss,int index){{{1*/
    178 void DatasetInput::GetParameterValue(double* pvalue,GaussTria* gauss,int index){
     177/*FUNCTION DatasetInput::GetInputValue(double* pvalue,GaussTria* gauss,int index){{{1*/
     178void DatasetInput::GetInputValue(double* pvalue,GaussTria* gauss,int index){
    179179
    180180        /*Get requested input within dataset*/
    … …  
    182182        Input* input=(Input*)this->inputs->GetObjectByOffset(index);
    183183       
    184         input->GetParameterValue(pvalue,gauss);
     184        input->GetInputValue(pvalue,gauss);
    185185}
    186186/*}}}*/

  • issm/trunk/src/c/objects/Inputs/DatasetInput.h

    r9883 r10135  
    5050                /*}}}*/
    5151                /*numeriics: {{{1*/
    52                 void GetParameterValue(bool* pvalue){_error_("not implemented yet");};
    53                 void GetParameterValue(int* pvalue){_error_("not implemented yet");};
    54                 void GetParameterValue(double* pvalue){_error_("not implemented yet");};
    55                 void GetParameterValue(double* pvalue,GaussTria* gauss){_error_("not implemented yet");};
    56                 void GetParameterValue(double* pvalue,GaussPenta* gauss){_error_("not implemented yet");};
    57                 void GetParameterValue(double* pvalue,GaussTria* gauss ,int index);
    58                 void GetParameterValue(double* pvalue,GaussPenta* gauss ,int index){_error_("not implemented yet");};
    59                 void GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss){_error_("not implemented yet");};
    60                 void GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
    61                 void GetParameterAverage(double* pvalue){_error_("not implemented yet");};
     52                void GetInputValue(bool* pvalue){_error_("not implemented yet");};
     53                void GetInputValue(int* pvalue){_error_("not implemented yet");};
     54                void GetInputValue(double* pvalue){_error_("not implemented yet");};
     55                void GetInputValue(double* pvalue,GaussTria* gauss){_error_("not implemented yet");};
     56                void GetInputValue(double* pvalue,GaussPenta* gauss){_error_("not implemented yet");};
     57                void GetInputValue(double* pvalue,GaussTria* gauss ,int index);
     58                void GetInputValue(double* pvalue,GaussPenta* gauss ,int index){_error_("not implemented yet");};
     59                void GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss){_error_("not implemented yet");};
     60                void GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
     61                void GetInputAverage(double* pvalue){_error_("not implemented yet");};
    6262                void GetVxStrainRate2d(double* epsilonvx,double* xyz_list, GaussTria* gauss){_error_("not implemented yet");};
    6363                void GetVyStrainRate2d(double* epsilonvy,double* xyz_list, GaussTria* gauss){_error_("not implemented yet");};

  • issm/trunk/src/c/objects/Inputs/DoubleInput.cpp

    r9883 r10135  
    157157
    158158/*Object functions*/
    159 /*FUNCTION DoubleInput::GetParameterValue(bool* pvalue) {{{1*/
    160 void DoubleInput::GetParameterValue(bool* pvalue){
     159/*FUNCTION DoubleInput::GetInputValue(bool* pvalue) {{{1*/
     160void DoubleInput::GetInputValue(bool* pvalue){
    161161#ifdef _SERIAL_
    162162        *pvalue=(bool)value;
    … …  
    167167}
    168168/*}}}*/
    169 /*FUNCTION DoubleInput::GetParameterValue(int* pvalue){{{1*/
    170 void DoubleInput::GetParameterValue(int* pvalue){
     169/*FUNCTION DoubleInput::GetInputValue(int* pvalue){{{1*/
     170void DoubleInput::GetInputValue(int* pvalue){
    171171#ifdef _SERIAL_
    172172        *pvalue=(int)value;
    … …  
    177177}
    178178/*}}}*/
    179 /*FUNCTION DoubleInput::GetParameterValue(double* pvalue){{{1*/
    180 void DoubleInput::GetParameterValue(double* pvalue){
     179/*FUNCTION DoubleInput::GetInputValue(double* pvalue){{{1*/
     180void DoubleInput::GetInputValue(double* pvalue){
    181181
    182182        /*return value*/
    … …  
    184184}
    185185/*}}}*/
    186 /*FUNCTION DoubleInput::GetParameterValue(double* pvalue,GaussTria* gauss){{{1*/
    187 void DoubleInput::GetParameterValue(double* pvalue,GaussTria* gauss){*pvalue=this->value;}
    188 /*}}}*/
    189 /*FUNCTION DoubleInput::GetParameterValue(double* pvalue,GaussPenta* gauss){{{1*/
    190 void DoubleInput::GetParameterValue(double* pvalue,GaussPenta* gauss){*pvalue=this->value;}
    191 /*}}}*/
    192 /*FUNCTION DoubleInput::GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss){{{1*/
    193 void DoubleInput::GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss){_error_(" not supported yet!");}
    194 /*}}}*/
    195 /*FUNCTION DoubleInput::GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){{{1*/
    196 void DoubleInput::GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){_error_(" not supported yet!");}
     186/*FUNCTION DoubleInput::GetInputValue(double* pvalue,GaussTria* gauss){{{1*/
     187void DoubleInput::GetInputValue(double* pvalue,GaussTria* gauss){*pvalue=this->value;}
     188/*}}}*/
     189/*FUNCTION DoubleInput::GetInputValue(double* pvalue,GaussPenta* gauss){{{1*/
     190void DoubleInput::GetInputValue(double* pvalue,GaussPenta* gauss){*pvalue=this->value;}
     191/*}}}*/
     192/*FUNCTION DoubleInput::GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss){{{1*/
     193void DoubleInput::GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss){_error_(" not supported yet!");}
     194/*}}}*/
     195/*FUNCTION DoubleInput::GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){{{1*/
     196void DoubleInput::GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){_error_(" not supported yet!");}
    197197/*}}}*/
    198198/*FUNCTION DoubleInput::GetVxStrainRate2d(double* epsilonvx,double* xyz_list, GaussTria* gauss){{{1*/
    … …  
    323323}
    324324/*}}}*/
    325 /*FUNCTION DoubleInput::GetParameterAverage{{{1*/
    326 void DoubleInput::GetParameterAverage(double* pvalue){
     325/*FUNCTION DoubleInput::GetInputAverage{{{1*/
     326void DoubleInput::GetInputAverage(double* pvalue){
    327327        *pvalue=value;
    328328}
    … …  
    341341
    342342                case PentaVertexInputEnum:
    343                         thickness_input->GetParameterAverage(&thickness_value);
     343                        thickness_input->GetInputAverage(&thickness_value);
    344344                        this->value=this->value*thickness_value;
    345345                        return;
    … …  
    360360
    361361        /*Check that inputB is of the same type*/
    362         inputB->GetParameterAverage(&Bvalue);
     362        inputB->GetInputAverage(&Bvalue);
    363363
    364364        /*Create new DoubleInput*/

  • issm/trunk/src/c/objects/Inputs/DoubleInput.h

    r9883 r10135  
    4949                /*}}}*/
    5050                /*numerics: {{{1*/
    51                 void GetParameterValue(bool* pvalue);
    52                 void GetParameterValue(int* pvalue);
    53                 void GetParameterValue(double* pvalue);
    54                 void GetParameterValue(double* pvalue,GaussTria* gauss);
    55                 void GetParameterValue(double* pvalue,GaussPenta* gauss);
    56                 void GetParameterValue(double* pvalue,GaussTria* gauss ,int index){_error_("not implemented yet");};
    57                 void GetParameterValue(double* pvalue,GaussPenta* gauss ,int index){_error_("not implemented yet");};
    58                 void GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss);
    59                 void GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss);
    60                 void GetParameterAverage(double* pvalue);
     51                void GetInputValue(bool* pvalue);
     52                void GetInputValue(int* pvalue);
     53                void GetInputValue(double* pvalue);
     54                void GetInputValue(double* pvalue,GaussTria* gauss);
     55                void GetInputValue(double* pvalue,GaussPenta* gauss);
     56                void GetInputValue(double* pvalue,GaussTria* gauss ,int index){_error_("not implemented yet");};
     57                void GetInputValue(double* pvalue,GaussPenta* gauss ,int index){_error_("not implemented yet");};
     58                void GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss);
     59                void GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss);
     60                void GetInputAverage(double* pvalue);
    6161                void GetVxStrainRate2d(double* epsilonvx,double* xyz_list, GaussTria* gauss);
    6262                void GetVyStrainRate2d(double* epsilonvy,double* xyz_list, GaussTria* gauss);

  • issm/trunk/src/c/objects/Inputs/Input.h

    r9883 r10135  
    2323                /*Virtual functions:{{{1*/
    2424                virtual int  InstanceEnum()=0;
    25                 virtual void GetParameterValue(bool* pvalue)=0;
    26                 virtual void GetParameterValue(int* pvalue)=0;
    27                 virtual void GetParameterValue(double* pvalue)=0;
    28                 virtual void GetParameterValue(double* pvalue,GaussTria* gauss)=0;
    29                 virtual void GetParameterValue(double* pvalue,GaussPenta* gauss)=0;
    30                 virtual void GetParameterValue(double* pvalue,GaussTria* gauss ,int index)=0;
    31                 virtual void GetParameterValue(double* pvalue,GaussPenta* gauss,int index)=0;
    32                 virtual void GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss)=0;
    33                 virtual void GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss)=0;
    34                 virtual void GetParameterAverage(double* pvalue)=0;
     25                virtual void GetInputValue(bool* pvalue)=0;
     26                virtual void GetInputValue(int* pvalue)=0;
     27                virtual void GetInputValue(double* pvalue)=0;
     28                virtual void GetInputValue(double* pvalue,GaussTria* gauss)=0;
     29                virtual void GetInputValue(double* pvalue,GaussPenta* gauss)=0;
     30                virtual void GetInputValue(double* pvalue,GaussTria* gauss ,int index)=0;
     31                virtual void GetInputValue(double* pvalue,GaussPenta* gauss,int index)=0;
     32                virtual void GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss)=0;
     33                virtual void GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss)=0;
     34                virtual void GetInputAverage(double* pvalue)=0;
    3535                virtual void GetVxStrainRate2d(double* epsilonvx,double* xyz_list, GaussTria* gauss)=0;
    3636                virtual void GetVyStrainRate2d(double* epsilonvy,double* xyz_list, GaussTria* gauss)=0;

  • issm/trunk/src/c/objects/Inputs/IntInput.cpp

    r9883 r10135  
    156156
    157157/*Object functions*/
    158 /*FUNCTION IntInput::GetParameterValue(bool* pvalue) {{{1*/
    159 void IntInput::GetParameterValue(bool* pvalue){_error_(" not supported yet!");}
    160 /*}}}*/
    161 /*FUNCTION IntInput::GetParameterValue(int* pvalue){{{1*/
    162 void IntInput::GetParameterValue(int* pvalue){
     158/*FUNCTION IntInput::GetInputValue(bool* pvalue) {{{1*/
     159void IntInput::GetInputValue(bool* pvalue){_error_(" not supported yet!");}
     160/*}}}*/
     161/*FUNCTION IntInput::GetInputValue(int* pvalue){{{1*/
     162void IntInput::GetInputValue(int* pvalue){
    163163        *pvalue=value;
    164164}
    165165/*}}}*/
    166 /*FUNCTION IntInput::GetParameterValue(double* pvalue){{{1*/
    167 void IntInput::GetParameterValue(double* pvalue){
     166/*FUNCTION IntInput::GetInputValue(double* pvalue){{{1*/
     167void IntInput::GetInputValue(double* pvalue){
    168168        _error_("IntInput cannot return a double in parallel");
    169169}
    170170/*}}}*/
    171 /*FUNCTION IntInput::GetParameterValue(double* pvalue,GaussTria* gauss){{{1*/
    172 void IntInput::GetParameterValue(double* pvalue,GaussTria* gauss){_error_(" not supported yet!");}
    173 /*}}}*/
    174 /*FUNCTION IntInput::GetParameterValue(double* pvalue,GaussPenta* gauss){{{1*/
    175 void IntInput::GetParameterValue(double* pvalue,GaussPenta* gauss){_error_(" not supported yet!");}
    176 /*}}}*/
    177 /*FUNCTION IntInput::GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss){{{1*/
    178 void IntInput::GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss){_error_(" not supported yet!");}
    179 /*}}}*/
    180 /*FUNCTION IntInput::GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){{{1*/
    181 void IntInput::GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){_error_(" not supported yet!");}
     171/*FUNCTION IntInput::GetInputValue(double* pvalue,GaussTria* gauss){{{1*/
     172void IntInput::GetInputValue(double* pvalue,GaussTria* gauss){_error_(" not supported yet!");}
     173/*}}}*/
     174/*FUNCTION IntInput::GetInputValue(double* pvalue,GaussPenta* gauss){{{1*/
     175void IntInput::GetInputValue(double* pvalue,GaussPenta* gauss){_error_(" not supported yet!");}
     176/*}}}*/
     177/*FUNCTION IntInput::GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss){{{1*/
     178void IntInput::GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss){_error_(" not supported yet!");}
     179/*}}}*/
     180/*FUNCTION IntInput::GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){{{1*/
     181void IntInput::GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){_error_(" not supported yet!");}
    182182/*}}}*/
    183183/*FUNCTION IntInput::ChangeEnum{{{1*/

  • issm/trunk/src/c/objects/Inputs/IntInput.h

    r9883 r10135  
    5050                /*}}}*/
    5151                /*numerics: {{{1*/
    52                 void GetParameterValue(bool* pvalue);
    53                 void GetParameterValue(int* pvalue);
    54                 void GetParameterValue(double* pvalue);
    55                 void GetParameterValue(double* pvalue,GaussTria* gauss);
    56                 void GetParameterValue(double* pvalue,GaussPenta* gauss);
    57                 void GetParameterValue(double* pvalue,GaussTria* gauss ,int index){_error_("not implemented yet");};
    58                 void GetParameterValue(double* pvalue,GaussPenta* gauss ,int index){_error_("not implemented yet");};
    59                 void GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss);
    60                 void GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss);
    61                 void GetParameterAverage(double* pvalue){_error_("not implemented yet");};
     52                void GetInputValue(bool* pvalue);
     53                void GetInputValue(int* pvalue);
     54                void GetInputValue(double* pvalue);
     55                void GetInputValue(double* pvalue,GaussTria* gauss);
     56                void GetInputValue(double* pvalue,GaussPenta* gauss);
     57                void GetInputValue(double* pvalue,GaussTria* gauss ,int index){_error_("not implemented yet");};
     58                void GetInputValue(double* pvalue,GaussPenta* gauss ,int index){_error_("not implemented yet");};
     59                void GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss);
     60                void GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss);
     61                void GetInputAverage(double* pvalue){_error_("not implemented yet");};
    6262                void GetVxStrainRate2d(double* epsilonvx,double* xyz_list, GaussTria* gauss){_error_("not implemented yet");};
    6363                void GetVyStrainRate2d(double* epsilonvy,double* xyz_list, GaussTria* gauss){_error_("not implemented yet");};

  • issm/trunk/src/c/objects/Inputs/PentaVertexInput.cpp

    r9883 r10135  
    178178
    179179/*Object functions*/
    180 /*FUNCTION PentaVertexInput::GetParameterValue(double* pvalue,GaussPenta* gauss){{{1*/
    181 void PentaVertexInput::GetParameterValue(double* pvalue,GaussPenta* gauss){
     180/*FUNCTION PentaVertexInput::GetInputValue(double* pvalue,GaussPenta* gauss){{{1*/
     181void PentaVertexInput::GetInputValue(double* pvalue,GaussPenta* gauss){
    182182
    183183        /*Call PentaRef function*/
    184         PentaRef::GetParameterValue(pvalue,&values[0],gauss);
    185 
    186 }
    187 /*}}}*/
    188 /*FUNCTION PentaVertexInput::GetParameterDerivativeValue(double* p, double* xyz_list, GaussPenta* gauss){{{1*/
    189 void PentaVertexInput::GetParameterDerivativeValue(double* p, double* xyz_list, GaussPenta* gauss){
     184        PentaRef::GetInputValue(pvalue,&values[0],gauss);
     185
     186}
     187/*}}}*/
     188/*FUNCTION PentaVertexInput::GetInputDerivativeValue(double* p, double* xyz_list, GaussPenta* gauss){{{1*/
     189void PentaVertexInput::GetInputDerivativeValue(double* p, double* xyz_list, GaussPenta* gauss){
    190190
    191191        /*Call PentaRef function*/
    192         PentaRef::GetParameterDerivativeValue(p,&values[0],xyz_list,gauss);
     192        PentaRef::GetInputDerivativeValue(p,&values[0],xyz_list,gauss);
    193193}
    194194/*}}}*/
    … …  
    382382}
    383383/*}}}*/
    384 /*FUNCTION PentaVertexInput::GetParameterAverage{{{1*/
    385 void PentaVertexInput::GetParameterAverage(double* pvalue){
     384/*FUNCTION PentaVertexInput::GetInputAverage{{{1*/
     385void PentaVertexInput::GetInputAverage(double* pvalue){
    386386        *pvalue=1./6.*(values[0]+values[1]+values[2]+values[3]+values[4]+values[5]);
    387387}

  • issm/trunk/src/c/objects/Inputs/PentaVertexInput.h

    r9883 r10135  
    5050                /*}}}*/
    5151                /*numerics: {{{1*/
    52                 void GetParameterValue(bool* pvalue){_error_("not implemented yet");};
    53                 void GetParameterValue(int* pvalue){_error_("not implemented yet");};
    54                 void GetParameterValue(double* pvalue){_error_("not implemented yet");};
    55                 void GetParameterValue(double* pvalue,GaussTria* gauss){_error_("not implemented yet");};
    56                 void GetParameterValue(double* pvalue,GaussPenta* gauss);
    57                 void GetParameterValue(double* pvalue,GaussTria* gauss ,int index){_error_("not implemented yet");};
    58                 void GetParameterValue(double* pvalue,GaussPenta* gauss ,int index){_error_("not implemented yet");};
    59                 void GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss){_error_("not implemented yet");};
    60                 void GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss);
    61                 void GetParameterAverage(double* pvalue);
     52                void GetInputValue(bool* pvalue){_error_("not implemented yet");};
     53                void GetInputValue(int* pvalue){_error_("not implemented yet");};
     54                void GetInputValue(double* pvalue){_error_("not implemented yet");};
     55                void GetInputValue(double* pvalue,GaussTria* gauss){_error_("not implemented yet");};
     56                void GetInputValue(double* pvalue,GaussPenta* gauss);
     57                void GetInputValue(double* pvalue,GaussTria* gauss ,int index){_error_("not implemented yet");};
     58                void GetInputValue(double* pvalue,GaussPenta* gauss ,int index){_error_("not implemented yet");};
     59                void GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss){_error_("not implemented yet");};
     60                void GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss);
     61                void GetInputAverage(double* pvalue);
    6262                void GetVxStrainRate2d(double* epsilonvx,double* xyz_list, GaussTria* gauss){_error_("not implemented yet");};
    6363                void GetVyStrainRate2d(double* epsilonvy,double* xyz_list, GaussTria* gauss){_error_("not implemented yet");};

  • issm/trunk/src/c/objects/Inputs/TransientInput.cpp

    r9883 r10135  
    258258
    259259/*Object functions*/
    260 /*FUNCTION TransientInput::GetParameterValue(double* pvalue,GaussTria* gauss){{{1*/
    261 void TransientInput::GetParameterValue(double* pvalue,GaussTria* gauss){
     260/*FUNCTION TransientInput::GetInputValue(double* pvalue,GaussTria* gauss){{{1*/
     261void TransientInput::GetInputValue(double* pvalue,GaussTria* gauss){
    262262       
    263263        double time;
    … …  
    270270
    271271        /*Call input function*/
    272         input->GetParameterValue(pvalue,gauss);
    273 
    274         delete input;
    275 
    276 }
    277 /*}}}*/
    278 /*FUNCTION TransientInput::GetParameterDerivativeValue(double* p, double* xyz_list, GaussTria* gauss){{{1*/
    279 void TransientInput::GetParameterDerivativeValue(double* p, double* xyz_list, GaussTria* gauss){
     272        input->GetInputValue(pvalue,gauss);
     273
     274        delete input;
     275
     276}
     277/*}}}*/
     278/*FUNCTION TransientInput::GetInputDerivativeValue(double* p, double* xyz_list, GaussTria* gauss){{{1*/
     279void TransientInput::GetInputDerivativeValue(double* p, double* xyz_list, GaussTria* gauss){
    280280
    281281        double time;
    … …  
    288288                   
    289289        /*Call input function*/
    290         input->GetParameterDerivativeValue(p,xyz_list,gauss);
     290        input->GetInputDerivativeValue(p,xyz_list,gauss);
    291291
    292292        delete input;
    … …  
    299299}
    300300/*}}}*/
    301 /*FUNCTION TransientInput::GetParameterAverage{{{1*/
    302 void TransientInput::GetParameterAverage(double* pvalue){
     301/*FUNCTION TransientInput::GetInputAverage{{{1*/
     302void TransientInput::GetInputAverage(double* pvalue){
    303303       
    304304        double time;
    … …  
    311311
    312312        /*Call input function*/
    313         input->GetParameterAverage(pvalue);
     313        input->GetInputAverage(pvalue);
    314314                           
    315315        delete input;

  • issm/trunk/src/c/objects/Inputs/TransientInput.h

    r9883 r10135  
    5252                /*}}}*/
    5353                /*numerics: {{{1*/
    54                 void GetParameterValue(bool* pvalue){_error_("not implemented yet");};
    55                 void GetParameterValue(int* pvalue){_error_("not implemented yet");};
    56                 void GetParameterValue(double* pvalue){_error_("not implemented yet");};
    57                 void GetParameterValue(double* pvalue,GaussTria* gauss);
    58                 void GetParameterValue(double* pvalue,GaussPenta* gauss){_error_("not implemented yet");};
    59                 void GetParameterValue(double* pvalue,GaussTria* gauss ,int index){_error_("not implemented yet");};
    60                 void GetParameterValue(double* pvalue,GaussPenta* gauss ,int index){_error_("not implemented yet");};
    61                 void GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss);
    62                 void GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
    63                 void GetParameterAverage(double* pvalue);
     54                void GetInputValue(bool* pvalue){_error_("not implemented yet");};
     55                void GetInputValue(int* pvalue){_error_("not implemented yet");};
     56                void GetInputValue(double* pvalue){_error_("not implemented yet");};
     57                void GetInputValue(double* pvalue,GaussTria* gauss);
     58                void GetInputValue(double* pvalue,GaussPenta* gauss){_error_("not implemented yet");};
     59                void GetInputValue(double* pvalue,GaussTria* gauss ,int index){_error_("not implemented yet");};
     60                void GetInputValue(double* pvalue,GaussPenta* gauss ,int index){_error_("not implemented yet");};
     61                void GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss);
     62                void GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
     63                void GetInputAverage(double* pvalue);
    6464                void GetVxStrainRate2d(double* epsilonvx,double* xyz_list, GaussTria* gauss){_error_("not implemented yet");};
    6565                void GetVyStrainRate2d(double* epsilonvy,double* xyz_list, GaussTria* gauss){_error_("not implemented yet");};

  • issm/trunk/src/c/objects/Inputs/TriaVertexInput.cpp

    r9883 r10135  
    167167
    168168/*Object functions*/
    169 /*FUNCTION TriaVertexInput::GetParameterValue(double* pvalue,GaussTria* gauss){{{1*/
    170 void TriaVertexInput::GetParameterValue(double* pvalue,GaussTria* gauss){
     169/*FUNCTION TriaVertexInput::GetInputValue(double* pvalue,GaussTria* gauss){{{1*/
     170void TriaVertexInput::GetInputValue(double* pvalue,GaussTria* gauss){
    171171
    172172        /*Call TriaRef function*/
    173         TriaRef::GetParameterValue(pvalue,&values[0],gauss);
    174 
    175 }
    176 /*}}}*/
    177 /*FUNCTION TriaVertexInput::GetParameterDerivativeValue(double* p, double* xyz_list, GaussTria* gauss){{{1*/
    178 void TriaVertexInput::GetParameterDerivativeValue(double* p, double* xyz_list, GaussTria* gauss){
     173        TriaRef::GetInputValue(pvalue,&values[0],gauss);
     174
     175}
     176/*}}}*/
     177/*FUNCTION TriaVertexInput::GetInputDerivativeValue(double* p, double* xyz_list, GaussTria* gauss){{{1*/
     178void TriaVertexInput::GetInputDerivativeValue(double* p, double* xyz_list, GaussTria* gauss){
    179179
    180180        /*Call TriaRef function*/
    181         TriaRef::GetParameterDerivativeValue(p,&values[0],xyz_list,gauss);
     181        TriaRef::GetInputDerivativeValue(p,&values[0],xyz_list,gauss);
    182182}
    183183/*}}}*/
    … …  
    233233}
    234234/*}}}*/
    235 /*FUNCTION TriaVertexInput::GetParameterAverage{{{1*/
    236 void TriaVertexInput::GetParameterAverage(double* pvalue){
     235/*FUNCTION TriaVertexInput::GetInputAverage{{{1*/
     236void TriaVertexInput::GetInputAverage(double* pvalue){
    237237        *pvalue=1./3.*(values[0]+values[1]+values[2]);
    238238}

  • issm/trunk/src/c/objects/Inputs/TriaVertexInput.h

    r9883 r10135  
    5050                /*}}}*/
    5151                /*numerics: {{{1*/
    52                 void GetParameterValue(bool* pvalue){_error_("not implemented yet");}
    53                 void GetParameterValue(int* pvalue){_error_("not implemented yet");}
    54                 void GetParameterValue(double* pvalue){_error_("not implemented yet");}
    55                 void GetParameterValue(double* pvalue,GaussTria* gauss);
    56                 void GetParameterValue(double* pvalue,GaussPenta* gauss){_error_("not implemented yet");};
    57                 void GetParameterValue(double* pvalue,GaussTria* gauss ,int index){_error_("not implemented yet");};
    58                 void GetParameterValue(double* pvalue,GaussPenta* gauss,int index){_error_("not implemented yet");};
    59                 void GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss);
    60                 void GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
    61                 void GetParameterAverage(double* pvalue);
     52                void GetInputValue(bool* pvalue){_error_("not implemented yet");}
     53                void GetInputValue(int* pvalue){_error_("not implemented yet");}
     54                void GetInputValue(double* pvalue){_error_("not implemented yet");}
     55                void GetInputValue(double* pvalue,GaussTria* gauss);
     56                void GetInputValue(double* pvalue,GaussPenta* gauss){_error_("not implemented yet");};
     57                void GetInputValue(double* pvalue,GaussTria* gauss ,int index){_error_("not implemented yet");};
     58                void GetInputValue(double* pvalue,GaussPenta* gauss,int index){_error_("not implemented yet");};
     59                void GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss);
     60                void GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
     61                void GetInputAverage(double* pvalue);
    6262                void GetVxStrainRate2d(double* epsilonvx,double* xyz_list, GaussTria* gauss);
    6363                void GetVyStrainRate2d(double* epsilonvy,double* xyz_list, GaussTria* gauss);

  • issm/trunk/src/c/objects/Loads/Friction.cpp

    r9610 r10135  
    7373
    7474        /*Recover parameters: */
    75         inputs->GetParameterValue(&drag_p,FrictionPEnum);
    76         inputs->GetParameterValue(&drag_q,FrictionQEnum);
    77         this->GetParameterValue(&thickness, gauss,ThicknessEnum);
    78         this->GetParameterValue(&bed, gauss,BedEnum);
    79         this->GetParameterValue(&drag_coefficient, gauss,FrictionCoefficientEnum);
     75        inputs->GetInputValue(&drag_p,FrictionPEnum);
     76        inputs->GetInputValue(&drag_q,FrictionQEnum);
     77        this->GetInputValue(&thickness, gauss,ThicknessEnum);
     78        this->GetInputValue(&bed, gauss,BedEnum);
     79        this->GetInputValue(&drag_coefficient, gauss,FrictionCoefficientEnum);
    8080
    8181        /*Get material parameters: */
    … …  
    9898
    9999        if(strcmp(element_type,"2d")==0){
    100                 this->GetParameterValue(&vx, gauss,vxenum);
    101                 this->GetParameterValue(&vy, gauss,vyenum);
     100                this->GetInputValue(&vx, gauss,vxenum);
     101                this->GetInputValue(&vy, gauss,vyenum);
    102102                vmag=sqrt(pow(vx,2)+pow(vy,2));
    103103        }
    104104        else if (strcmp(element_type,"3d")==0){
    105                 this->GetParameterValue(&vx, gauss,vxenum);
    106                 this->GetParameterValue(&vy, gauss,vyenum);
    107                 this->GetParameterValue(&vz, gauss,vzenum);
     105                this->GetInputValue(&vx, gauss,vxenum);
     106                this->GetInputValue(&vy, gauss,vyenum);
     107                this->GetInputValue(&vz, gauss,vzenum);
    108108                vmag=sqrt(pow(vx,2)+pow(vy,2)+pow(vz,2));
    109109        }
    … …  
    137137
    138138        /*Recover parameters: */
    139         inputs->GetParameterValue(&drag_p,FrictionPEnum);
    140         inputs->GetParameterValue(&drag_q,FrictionQEnum);
    141         this->GetParameterValue(&thickness, gauss,ThicknessEnum);
    142         this->GetParameterValue(&bed, gauss,BedEnum);
    143         this->GetParameterValue(&drag_coefficient, gauss,FrictionCoefficientEnum);
     139        inputs->GetInputValue(&drag_p,FrictionPEnum);
     140        inputs->GetInputValue(&drag_q,FrictionQEnum);
     141        this->GetInputValue(&thickness, gauss,ThicknessEnum);
     142        this->GetInputValue(&bed, gauss,BedEnum);
     143        this->GetInputValue(&drag_coefficient, gauss,FrictionCoefficientEnum);
    144144
    145145        /*Get material parameters: */
    … …  
    162162
    163163        if(strcmp(element_type,"2d")==0){
    164                 this->GetParameterValue(&vx, gauss,vxenum);
    165                 this->GetParameterValue(&vy, gauss,vyenum);
     164                this->GetInputValue(&vx, gauss,vxenum);
     165                this->GetInputValue(&vy, gauss,vyenum);
    166166                vmag=sqrt(pow(vx,2)+pow(vy,2));
    167167        }
    168168        else if (strcmp(element_type,"3d")==0){
    169                 this->GetParameterValue(&vx, gauss,vxenum);
    170                 this->GetParameterValue(&vy, gauss,vyenum);
    171                 this->GetParameterValue(&vz, gauss,vzenum);
     169                this->GetInputValue(&vx, gauss,vxenum);
     170                this->GetInputValue(&vy, gauss,vyenum);
     171                this->GetInputValue(&vz, gauss,vzenum);
    172172                vmag=sqrt(pow(vx,2)+pow(vy,2)+pow(vz,2));
    173173        }
    … …  
    203203
    204204        /*Recover parameters: */
    205         inputs->GetParameterValue(&drag_p,FrictionPEnum);
    206         inputs->GetParameterValue(&drag_q,FrictionQEnum);
    207         this->GetParameterValue(&thickness, gauss,ThicknessEnum);
    208         this->GetParameterValue(&bed, gauss,BedEnum);
    209         this->GetParameterValue(&drag_coefficient, gauss,FrictionCoefficientEnum);
     205        inputs->GetInputValue(&drag_p,FrictionPEnum);
     206        inputs->GetInputValue(&drag_q,FrictionQEnum);
     207        this->GetInputValue(&thickness, gauss,ThicknessEnum);
     208        this->GetInputValue(&bed, gauss,BedEnum);
     209        this->GetInputValue(&drag_coefficient, gauss,FrictionCoefficientEnum);
    210210
    211211        /*Get material parameters: */
    … …  
    229229        //We need the velocity magnitude to evaluate the basal stress:
    230230        if(strcmp(element_type,"2d")==0){
    231                 this->GetParameterValue(&vx, gauss,vxenum);
    232                 this->GetParameterValue(&vy, gauss,vyenum);
     231                this->GetInputValue(&vx, gauss,vxenum);
     232                this->GetInputValue(&vy, gauss,vyenum);
    233233                vmag=sqrt(pow(vx,2)+pow(vy,2));
    234234        }
    235235        else if (strcmp(element_type,"3d")==0){
    236                 this->GetParameterValue(&vx, gauss,vxenum);
    237                 this->GetParameterValue(&vy, gauss,vyenum);
    238                 this->GetParameterValue(&vz, gauss,vzenum);
     236                this->GetInputValue(&vx, gauss,vxenum);
     237                this->GetInputValue(&vy, gauss,vyenum);
     238                this->GetInputValue(&vz, gauss,vzenum);
    239239                vmag=sqrt(pow(vx,2)+pow(vy,2)+pow(vz,2));
    240240        }
    … …  
    269269
    270270        /*Recover parameters: */
    271         inputs->GetParameterValue(&drag_p,FrictionPEnum);
    272         inputs->GetParameterValue(&drag_q,FrictionQEnum);
    273         this->GetParameterValue(&thickness, gauss,ThicknessEnum);
    274         this->GetParameterValue(&bed, gauss,BedEnum);
    275         this->GetParameterValue(&drag_coefficient, gauss,FrictionCoefficientEnum);
     271        inputs->GetInputValue(&drag_p,FrictionPEnum);
     272        inputs->GetInputValue(&drag_q,FrictionQEnum);
     273        this->GetInputValue(&thickness, gauss,ThicknessEnum);
     274        this->GetInputValue(&bed, gauss,BedEnum);
     275        this->GetInputValue(&drag_coefficient, gauss,FrictionCoefficientEnum);
    276276
    277277        /*Get material parameters: */
    … …  
    295295        //We need the velocity magnitude to evaluate the basal stress:
    296296        if(strcmp(element_type,"2d")==0){
    297                 this->GetParameterValue(&vx, gauss,vxenum);
    298                 this->GetParameterValue(&vy, gauss,vyenum);
     297                this->GetInputValue(&vx, gauss,vxenum);
     298                this->GetInputValue(&vy, gauss,vyenum);
    299299                vmag=sqrt(pow(vx,2)+pow(vy,2));
    300300        }
    301301        else if (strcmp(element_type,"3d")==0){
    302                 this->GetParameterValue(&vx, gauss,vxenum);
    303                 this->GetParameterValue(&vy, gauss,vyenum);
    304                 this->GetParameterValue(&vz, gauss,vzenum);
     302                this->GetInputValue(&vx, gauss,vxenum);
     303                this->GetInputValue(&vy, gauss,vyenum);
     304                this->GetInputValue(&vz, gauss,vzenum);
    305305                vmag=sqrt(pow(vx,2)+pow(vy,2)+pow(vz,2));
    306306        }
    … …  
    316316}
    317317/*}}}*/
    318 /*FUNCTION Friction::GetParameterValue{{{1*/
    319 void Friction::GetParameterValue(double* pvalue,GaussTria* gauss,int enum_type){
     318/*FUNCTION Friction::GetInputValue{{{1*/
     319void Friction::GetInputValue(double* pvalue,GaussTria* gauss,int enum_type){
    320320
    321321        Input* input=inputs->GetInput(enum_type);
    322322        if(!input) _error_("input %s not found",EnumToStringx(enum_type));
    323         input->GetParameterValue(pvalue,gauss);
    324 
    325 }
    326 /*}}}*/
    327 /*FUNCTION Friction::GetParameterValue{{{1*/
    328 void Friction::GetParameterValue(double* pvalue,GaussPenta* gauss,int enum_type){
     323        input->GetInputValue(pvalue,gauss);
     324
     325}
     326/*}}}*/
     327/*FUNCTION Friction::GetInputValue{{{1*/
     328void Friction::GetInputValue(double* pvalue,GaussPenta* gauss,int enum_type){
    329329
    330330        Input* input=inputs->GetInput(enum_type);
    331331        if(!input) _error_("input %s not found",EnumToStringx(enum_type));
    332         input->GetParameterValue(pvalue,gauss);
    333 
    334 }
    335 /*}}}*/
     332        input->GetInputValue(pvalue,gauss);
     333
     334}
     335/*}}}*/

  • issm/trunk/src/c/objects/Loads/Friction.h

    r8657 r10135  
    3131                void  GetAlphaComplement(double* alpha_complement, GaussTria* gauss,int vxenum,int vyenum,int vzenum);
    3232                void  GetAlphaComplement(double* alpha_complement, GaussPenta* gauss,int vxenum,int vyenum,int vzenum);
    33                 void  GetParameterValue(double* pvalue,GaussTria* gauss,int enum_type);
    34                 void  GetParameterValue(double* pvalue,GaussPenta* gauss,int enum_type);
     33                void  GetInputValue(double* pvalue,GaussTria* gauss,int enum_type);
     34                void  GetInputValue(double* pvalue,GaussPenta* gauss,int enum_type);
    3535
    3636};

  • issm/trunk/src/c/objects/Loads/Icefront.cpp

    r9883 r10135  
    438438
    439439        int type;
    440         inputs->GetParameterValue(&type,TypeEnum);
     440        inputs->GetInputValue(&type,TypeEnum);
    441441
    442442        switch(type){
    … …  
    483483        Input* thickness_input=tria->inputs->GetInput(ThicknessEnum); _assert_(thickness_input);
    484484        Input* bed_input      =tria->inputs->GetInput(BedEnum);       _assert_(bed_input);
    485         inputs->GetParameterValue(&fill,FillEnum);
     485        inputs->GetInputValue(&fill,FillEnum);
    486486        rho_water=matpar->GetRhoWater();
    487487        rho_ice  =matpar->GetRhoIce();
    … …  
    498498                gauss->GaussPoint(ig);
    499499
    500                 thickness_input->GetParameterValue(&thickness,gauss);
    501                 bed_input->GetParameterValue(&bed,gauss);
     500                thickness_input->GetInputValue(&thickness,gauss);
     501                bed_input->GetInputValue(&bed,gauss);
    502502
    503503                switch(fill){
    … …  
    599599        GetVerticesCoordinates(&xyz_list[0][0], nodes, NUMVERTICESQUA);
    600600        Input* surface_input  =penta->inputs->GetInput(SurfaceEnum);   _assert_(surface_input);
    601         inputs->GetParameterValue(&fill,FillEnum);
     601        inputs->GetInputValue(&fill,FillEnum);
    602602        rho_water=matpar->GetRhoWater();
    603603        rho_ice  =matpar->GetRhoIce();
    … …  
    623623                penta->GetQuadJacobianDeterminant(&Jdet,xyz_list,gauss);
    624624                z_g=penta->GetZcoord(gauss);
    625                 surface_input->GetParameterValue(&surface,gauss);
     625                surface_input->GetInputValue(&surface,gauss);
    626626
    627627                switch(fill){
    … …  
    672672        /*Retrieve all inputs and parameters*/
    673673        GetVerticesCoordinates(&xyz_list[0][0], nodes, NUMVERTICESQUA);
    674         inputs->GetParameterValue(&fill,FillEnum);
     674        inputs->GetInputValue(&fill,FillEnum);
    675675        rho_water=matpar->GetRhoWater();
    676676        gravity  =matpar->GetG();
    … …  
    737737       
    738738        /*recover type: */
    739         inputs->GetParameterValue(&type,TypeEnum);
     739        inputs->GetInputValue(&type,TypeEnum);
    740740
    741741        /*Some checks for debugging*/

  • issm/trunk/src/c/objects/Loads/Numericalflux.cpp

    r9883 r10135  
    422422
    423423        int type;
    424         inputs->GetParameterValue(&type,TypeEnum);
     424        inputs->GetInputValue(&type,TypeEnum);
    425425
    426426        switch(type){
    … …  
    474474                tria->GetSegmentBprimeFlux(&Bprime[0],gauss,index1,index2);
    475475
    476                 vxaverage_input->GetParameterValue(&vx,gauss);
    477                 vyaverage_input->GetParameterValue(&vy,gauss);
     476                vxaverage_input->GetInputValue(&vx,gauss);
     477                vyaverage_input->GetInputValue(&vy,gauss);
    478478                UdotN=vx*normal[0]+vy*normal[1];
    479479                tria->GetSegmentJacobianDeterminant(&Jdet,&xyz_list[0][0],gauss);
    … …  
    532532        gauss=new GaussTria();
    533533        gauss->GaussEdgeCenter(index1,index2);
    534         vxaverage_input->GetParameterValue(&mean_vx,gauss);
    535         vyaverage_input->GetParameterValue(&mean_vy,gauss);
     534        vxaverage_input->GetInputValue(&mean_vx,gauss);
     535        vyaverage_input->GetInputValue(&mean_vy,gauss);
    536536        delete gauss;
    537537
    … …  
    552552                tria->GetSegmentNodalFunctions(&L[0],gauss,index1,index2);
    553553
    554                 vxaverage_input->GetParameterValue(&vx,gauss);
    555                 vyaverage_input->GetParameterValue(&vy,gauss);
     554                vxaverage_input->GetInputValue(&vx,gauss);
     555                vyaverage_input->GetInputValue(&vy,gauss);
    556556                UdotN=vx*normal[0]+vy*normal[1];
    557557                tria->GetSegmentJacobianDeterminant(&Jdet,&xyz_list[0][0],gauss);
    … …  
    575575
    576576        int type;
    577         inputs->GetParameterValue(&type,TypeEnum);
     577        inputs->GetInputValue(&type,TypeEnum);
    578578
    579579        switch(type){
    … …  
    626626                tria->GetSegmentBprimeFlux(&Bprime[0],gauss,index1,index2);
    627627
    628                 vxaverage_input->GetParameterValue(&vx,gauss);
    629                 vyaverage_input->GetParameterValue(&vy,gauss);
     628                vxaverage_input->GetInputValue(&vx,gauss);
     629                vyaverage_input->GetInputValue(&vy,gauss);
    630630                UdotN=vx*normal[0]+vy*normal[1];
    631631                tria->GetSegmentJacobianDeterminant(&Jdet,&xyz_list[0][0],gauss);
    … …  
    683683        gauss=new GaussTria();
    684684        gauss->GaussEdgeCenter(index1,index2);
    685         vxaverage_input->GetParameterValue(&mean_vx,gauss);
    686         vyaverage_input->GetParameterValue(&mean_vy,gauss);
     685        vxaverage_input->GetInputValue(&mean_vx,gauss);
     686        vyaverage_input->GetInputValue(&mean_vy,gauss);
    687687        delete gauss;
    688688
    … …  
    703703                tria->GetSegmentNodalFunctions(&L[0],gauss,index1,index2);
    704704
    705                 vxaverage_input->GetParameterValue(&vx,gauss);
    706                 vyaverage_input->GetParameterValue(&vy,gauss);
     705                vxaverage_input->GetInputValue(&vx,gauss);
     706                vyaverage_input->GetInputValue(&vy,gauss);
    707707                UdotN=vx*normal[0]+vy*normal[1];
    708708                tria->GetSegmentJacobianDeterminant(&Jdet,&xyz_list[0][0],gauss);
    … …  
    726726
    727727        int type;
    728         inputs->GetParameterValue(&type,TypeEnum);
     728        inputs->GetInputValue(&type,TypeEnum);
    729729
    730730        switch(type){
    … …  
    758758
    759759        int type;
    760         inputs->GetParameterValue(&type,TypeEnum);
     760        inputs->GetInputValue(&type,TypeEnum);
    761761
    762762        switch(type){
    … …  
    811811        gauss=new GaussTria();
    812812        gauss->GaussEdgeCenter(index1,index2);
    813         vxaverage_input->GetParameterValue(&mean_vx,gauss);
    814         vyaverage_input->GetParameterValue(&mean_vy,gauss);
     813        vxaverage_input->GetInputValue(&mean_vx,gauss);
     814        vyaverage_input->GetInputValue(&mean_vy,gauss);
    815815        delete gauss;
    816816
    … …  
    831831                tria->GetSegmentNodalFunctions(&L[0],gauss,index1,index2);
    832832
    833                 vxaverage_input->GetParameterValue(&vx,gauss);
    834                 vyaverage_input->GetParameterValue(&vy,gauss);
    835                 spcthickness_input->GetParameterValue(&thickness,gauss);
     833                vxaverage_input->GetInputValue(&vx,gauss);
     834                vyaverage_input->GetInputValue(&vy,gauss);
     835                spcthickness_input->GetInputValue(&thickness,gauss);
    836836                if(isnan(thickness)) _error_("Cannot weakly apply constraint because NaN was provided");
    837837
    … …  
    852852
    853853        int type;
    854         inputs->GetParameterValue(&type,TypeEnum);
     854        inputs->GetInputValue(&type,TypeEnum);
    855855
    856856        switch(type){
    … …  
    904904        gauss=new GaussTria();
    905905        gauss->GaussEdgeCenter(index1,index2);
    906         vxaverage_input->GetParameterValue(&mean_vx,gauss);
    907         vyaverage_input->GetParameterValue(&mean_vy,gauss);
     906        vxaverage_input->GetInputValue(&mean_vx,gauss);
     907        vyaverage_input->GetInputValue(&mean_vy,gauss);
    908908        delete gauss;
    909909        UdotN=mean_vx*normal[0]+mean_vy*normal[1];
    … …  
    923923                tria->GetSegmentNodalFunctions(&L[0],gauss,index1,index2);
    924924
    925                 vxaverage_input->GetParameterValue(&vx,gauss);
    926                 vyaverage_input->GetParameterValue(&vy,gauss);
    927                 thickness_input->GetParameterValue(&thickness,gauss);
     925                vxaverage_input->GetInputValue(&vx,gauss);
     926                vyaverage_input->GetInputValue(&vy,gauss);
     927                thickness_input->GetInputValue(&thickness,gauss);
    928928
    929929                UdotN=vx*normal[0]+vy*normal[1];

  • issm/trunk/src/c/objects/Loads/Pengrid.cpp

    r9883 r10135  
    491491
    492492        //First recover pressure and temperature values, using the element: */
    493         penta->GetParameterValue(&pressure,node,PressureEnum);
    494         penta->GetParameterValue(&temperature,node,TemperaturePicardEnum);
     493        penta->GetInputValue(&pressure,node,PressureEnum);
     494        penta->GetInputValue(&temperature,node,TemperaturePicardEnum);
    495495
    496496        //Recover our data:
    … …  
    545545
    546546        /*Initialize Element vector and return if necessary*/
    547         penta->inputs->GetParameterValue(&approximation,ApproximationEnum);
     547        penta->inputs->GetInputValue(&approximation,ApproximationEnum);
    548548        if(approximation!=StokesApproximationEnum &&  approximation!=PattynStokesApproximationEnum) return NULL;
    549549        ElementMatrix* Ke=new ElementMatrix(&node,1,this->parameters,StokesApproximationEnum);
    … …  
    551551        /*Retrieve all inputs and parameters*/
    552552        parameters->FindParam(&penalty_offset,DiagnosticPenaltyFactorEnum);
    553         penta->GetParameterValue(&slope[0],node,BedSlopeXEnum);
    554         penta->GetParameterValue(&slope[1],node,BedSlopeYEnum);
     553        penta->GetInputValue(&slope[0],node,BedSlopeXEnum);
     554        penta->GetInputValue(&slope[1],node,BedSlopeYEnum);
    555555
    556556        /*Create elementary matrix: add penalty to constrain wb (wb=ub*db/dx+vb*db/dy)*/
    … …  
    577577
    578578        /*Retrieve all inputs and parameters*/
    579         penta->GetParameterValue(&pressure,node,PressureEnum);
    580         penta->GetParameterValue(&temperature,node,TemperatureEnum);
     579        penta->GetInputValue(&pressure,node,PressureEnum);
     580        penta->GetInputValue(&temperature,node,TemperatureEnum);
    581581        parameters->FindParam(&penalty_factor,ThermalPenaltyFactorEnum);
    582582       
    … …  
    630630
    631631        /*Retrieve all inputs and parameters*/
    632         penta->GetParameterValue(&pressure,node,PressureEnum);
    633         penta->GetParameterValue(&temperature,node,TemperatureEnum);
    634         inputs->GetParameterValue(&melting_offset,MeltingOffsetEnum);
     632        penta->GetInputValue(&pressure,node,PressureEnum);
     633        penta->GetInputValue(&temperature,node,TemperatureEnum);
     634        inputs->GetInputValue(&melting_offset,MeltingOffsetEnum);
    635635        parameters->FindParam(&dt,TimesteppingTimeStepEnum);
    636636        parameters->FindParam(&penalty_factor,ThermalPenaltyFactorEnum);
    … …  
    670670
    671671        /*Retrieve all inputs and parameters*/
    672         penta->GetParameterValue(&pressure,node,PressureEnum);
     672        penta->GetInputValue(&pressure,node,PressureEnum);
    673673        parameters->FindParam(&penalty_factor,ThermalPenaltyFactorEnum);
    674674

  • issm/trunk/src/c/objects/Loads/Riftfront.cpp

    r9883 r10135  
    139139       
    140140        /*recover some inputs first: */
    141         input=(Input*)this->inputs->GetInput(FillEnum); input->GetParameterValue(&fill);
    142         input=(Input*)this->inputs->GetInput(FrictionEnum); input->GetParameterValue(&friction);
    143         input=(Input*)this->inputs->GetInput(FractionIncrementEnum); input->GetParameterValue(&fractionincrement);
     141        input=(Input*)this->inputs->GetInput(FillEnum); input->GetInputValue(&fill);
     142        input=(Input*)this->inputs->GetInput(FrictionEnum); input->GetInputValue(&friction);
     143        input=(Input*)this->inputs->GetInput(FractionIncrementEnum); input->GetInputValue(&fractionincrement);
    144144
    145145        printf("Riftfront:\n");
    … …  
    526526        /*Get some parameters: */
    527527        this->parameters->FindParam(&penalty_offset,DiagnosticPenaltyFactorEnum);
    528         this->inputs->GetParameterValue(&friction,FrictionEnum);
    529         tria1->GetParameterValue(&h[0],nodes[0],ThicknessEnum);
    530         tria2->GetParameterValue(&h[1],nodes[1],ThicknessEnum);
     528        this->inputs->GetInputValue(&friction,FrictionEnum);
     529        tria1->GetInputValue(&h[0],nodes[0],ThicknessEnum);
     530        tria2->GetInputValue(&h[1],nodes[1],ThicknessEnum);
    531531        if (h[0]!=h[1])_error_(" different thicknesses not supported for rift fronts");
    532532        thickness=h[0];
    … …  
    616616
    617617        /*Get some inputs: */
    618         this->inputs->GetParameterValue(&fill,FillEnum);
    619         this->inputs->GetParameterValue(&shelf,SegmentOnIceShelfEnum);
     618        this->inputs->GetInputValue(&fill,FillEnum);
     619        this->inputs->GetInputValue(&shelf,SegmentOnIceShelfEnum);
    620620        rho_ice=matpar->GetRhoIce();
    621621        rho_water=matpar->GetRhoWater();
    622622        gravity=matpar->GetG();
    623         tria1->GetParameterValue(&h[0],nodes[0],ThicknessEnum);
    624         tria2->GetParameterValue(&h[1],nodes[1],ThicknessEnum);
     623        tria1->GetInputValue(&h[0],nodes[0],ThicknessEnum);
     624        tria2->GetInputValue(&h[1],nodes[1],ThicknessEnum);
    625625        if (h[0]!=h[1])_error_(" different thicknesses not supported for rift fronts");
    626626        thickness=h[0];
    627         tria1->GetParameterValue(&b[0],nodes[0],BedEnum);
    628         tria2->GetParameterValue(&b[1],nodes[1],BedEnum);
     627        tria1->GetInputValue(&b[0],nodes[0],BedEnum);
     628        tria2->GetInputValue(&b[1],nodes[1],BedEnum);
    629629        if (b[0]!=b[1])_error_(" different beds not supported for rift fronts");
    630630        bed=b[0];
    … …  
    729729
    730730        /*recover parameters: */
    731         this->inputs->GetParameterValue(&fractionincrement,FractionIncrementEnum);
     731        this->inputs->GetInputValue(&fractionincrement,FractionIncrementEnum);
    732732
    733733        /*First recover velocity: */
    734         tria1->GetParameterValue(&vx1,nodes[0],VxEnum);
    735         tria2->GetParameterValue(&vx2,nodes[1],VxEnum);
    736         tria1->GetParameterValue(&vy1,nodes[0],VyEnum);
    737         tria2->GetParameterValue(&vy2,nodes[1],VyEnum);
     734        tria1->GetInputValue(&vx1,nodes[0],VxEnum);
     735        tria2->GetInputValue(&vx2,nodes[1],VxEnum);
     736        tria1->GetInputValue(&vy1,nodes[0],VyEnum);
     737        tria2->GetInputValue(&vy2,nodes[1],VyEnum);
    738738
    739739        /*Node 1 faces node 2, compute penetration of 2 into 1 (V2-V1).N (with N normal vector, and V velocity vector: */
    … …  
    795795        double converged=0;
    796796
    797         this->inputs->GetParameterValue(&converged,ConvergedEnum);
     797        this->inputs->GetInputValue(&converged,ConvergedEnum);
    798798
    799799        if(converged){
    … …  
    834834
    835835        /*recover velocity: */
    836         tria1->GetParameterValue(&vx1,nodes[0],VxEnum);
    837         tria2->GetParameterValue(&vx2,nodes[1],VxEnum);
    838         tria1->GetParameterValue(&vy1,nodes[0],VyEnum);
    839         tria2->GetParameterValue(&vy2,nodes[1],VyEnum);
     836        tria1->GetInputValue(&vx1,nodes[0],VxEnum);
     837        tria2->GetInputValue(&vx2,nodes[1],VxEnum);
     838        tria1->GetInputValue(&vy1,nodes[0],VyEnum);
     839        tria2->GetInputValue(&vy2,nodes[1],VyEnum);
    840840
    841841        /*Node1 faces node2, compute penetration of 2 into 1 (V2-V1).N (with N normal vector, and V velocity vector: */
    … …  
    876876
    877877        /*First recover velocity: */
    878         tria1->GetParameterValue(&vx1,nodes[0],VxEnum);
    879         tria2->GetParameterValue(&vx2,nodes[1],VxEnum);
    880         tria1->GetParameterValue(&vy1,nodes[0],VyEnum);
    881         tria2->GetParameterValue(&vy2,nodes[1],VyEnum);
     878        tria1->GetInputValue(&vx1,nodes[0],VxEnum);
     879        tria2->GetInputValue(&vx2,nodes[1],VxEnum);
     880        tria1->GetInputValue(&vy1,nodes[0],VyEnum);
     881        tria2->GetInputValue(&vy2,nodes[1],VyEnum);
    882882
    883883        /*Node 1 faces node 2, compute penetration of 2 into 1 (V2-V1).N (with N normal vector, and V velocity vector: */
    … …  
    919919
    920920        /*First recover velocity: */
    921         tria1->GetParameterValue(&vx1,nodes[0],VxEnum);
    922         tria2->GetParameterValue(&vx2,nodes[1],VxEnum);
    923         tria1->GetParameterValue(&vy1,nodes[0],VyEnum);
    924         tria2->GetParameterValue(&vy2,nodes[1],VyEnum);
     921        tria1->GetInputValue(&vx1,nodes[0],VxEnum);
     922        tria2->GetInputValue(&vx2,nodes[1],VxEnum);
     923        tria1->GetInputValue(&vy1,nodes[0],VyEnum);
     924        tria2->GetInputValue(&vy2,nodes[1],VyEnum);
    925925
    926926        /*Node 1 faces node 2, compute penetration of 2 into 1 (V2-V1).N (with N normal vector, and V velocity vector: */
    … …  
    968968
    969969        /*First recover velocity: */
    970         tria1->GetParameterValue(&vx1,nodes[0],VxEnum);
    971         tria2->GetParameterValue(&vx2,nodes[1],VxEnum);
    972         tria1->GetParameterValue(&vy1,nodes[0],VyEnum);
    973         tria2->GetParameterValue(&vy2,nodes[1],VyEnum);
     970        tria1->GetInputValue(&vx1,nodes[0],VxEnum);
     971        tria2->GetInputValue(&vx2,nodes[1],VxEnum);
     972        tria1->GetInputValue(&vy1,nodes[0],VyEnum);
     973        tria2->GetInputValue(&vy2,nodes[1],VyEnum);
    974974
    975975        /*Node 1 faces node 2, compute penetration of 2 into 1 (V2-V1).N (with N normal vector, and V velocity vector: */

  • issm/trunk/src/c/objects/Materials/Matice.cpp

    r9883 r10135  
    204204        double B;
    205205
    206         inputs->GetParameterAverage(&B,MaterialsRheologyBEnum);
     206        inputs->GetInputAverage(&B,MaterialsRheologyBEnum);
    207207        return B;
    208208}
    … …  
    214214        double Bbar;
    215215
    216         inputs->GetParameterAverage(&Bbar,MaterialsRheologyBbarEnum);
     216        inputs->GetInputAverage(&Bbar,MaterialsRheologyBbarEnum);
    217217        return Bbar;
    218218}
    … …  
    224224        double n;
    225225
    226         inputs->GetParameterAverage(&n,MaterialsRheologyNEnum);
     226        inputs->GetInputAverage(&n,MaterialsRheologyNEnum);
    227227        return n;
    228228}

  • issm/trunk/src/c/objects/Node.cpp

    r9883 r10135  
    632632
    633633        /*recover parameters: */
    634         inputs->GetParameterValue(&approximation,ApproximationEnum);
     634        inputs->GetInputValue(&approximation,ApproximationEnum);
    635635
    636636        return approximation;
    … …  
    642642
    643643        /*recover parameters: */
    644         inputs->GetParameterValue(&connectivity,NumberNodeToElementConnectivityEnum);
     644        inputs->GetInputValue(&connectivity,NumberNodeToElementConnectivityEnum);
    645645
    646646        return connectivity;
    … …  
    740740
    741741        /*recover parameters: */
    742         inputs->GetParameterValue(&onbed,MeshVertexonbedEnum);
     742        inputs->GetInputValue(&onbed,MeshVertexonbedEnum);
    743743
    744744        return onbed;
    … …  
    751751
    752752        /*recover parameters: */
    753         inputs->GetParameterValue(&onsheet,MaskVertexongroundediceEnum);
     753        inputs->GetInputValue(&onsheet,MaskVertexongroundediceEnum);
    754754
    755755        return onsheet;
    … …  
    762762
    763763        /*recover parameters: */
    764         inputs->GetParameterValue(&onshelf,MaskVertexonfloatingiceEnum);
     764        inputs->GetInputValue(&onshelf,MaskVertexonfloatingiceEnum);
    765765
    766766        return onshelf;
    … …  
    773773
    774774        /*recover parameters: */
    775         inputs->GetParameterValue(&onsurface,MeshVertexonsurfaceEnum);
     775        inputs->GetInputValue(&onsurface,MeshVertexonsurfaceEnum);
    776776
    777777        return onsurface;
Note: See TracChangeset for help on using the changeset viewer.