Changeset 16675 for issm/trunk-jpl/src


Ignore:
Timestamp:
11/08/13 09:15:08 (11 years ago)
Author:
Mathieu Morlighem
Message:

NEW: moved GetSolutionFromInputs from Element to analysis

Location:
issm/trunk-jpl/src/c
Files:
1 added
94 edited

Legend:

Unmodified
Added
Removed

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

    r16550 r16675  
    2525                                        ./datastructures/datastructures.h\
    2626                                        ./classes/classes.h\
     27                                        ./classes/gauss/Gauss.h\
    2728                                        ./classes/gauss/GaussSeg.h\
    2829                                        ./classes/gauss/GaussSeg.cpp\

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

    r16542 r16675  
    2424        _error_("not implemented yet");
    2525}/*}}}*/
     26
     27/*Numerics*/
     28void AdjointBalancethicknessAnalysis::GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element){/*{{{*/
     29        _error_("not implemented yet");
     30}/*}}}*/

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

    r16542 r16675  
    1818                void CreateConstraints(Constraints* constraints,IoModel* iomodel);
    1919                void CreateLoads(Loads* loads, IoModel* iomodel);
     20                void GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element);
    2021};
    2122#endif

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

    r16542 r16675  
    2424           _error_("not implemented yet");
    2525}/*}}}*/
     26
     27/*Numerics*/
     28void AdjointHorizAnalysis::GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element){/*{{{*/
     29           _error_("not implemented yet");
     30}/*}}}*/

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

    r16542 r16675  
    1818                void CreateConstraints(Constraints* constraints,IoModel* iomodel);
    1919                void CreateLoads(Loads* loads, IoModel* iomodel);
     20                void GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element);
    2021};
    2122#endif

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

    r16542 r16675  
    66#define _ANALYSIS_H_
    77
     8#include "../toolkits/objects/toolkitobjects.h"
    89class Parameters;
    910class IoModel;
    … …  
    1213class Constraints;
    1314class Loads;
     15class Element;
    1416
    1517class Analysis{
    … …  
    2426                virtual void CreateConstraints(Constraints* constraints,IoModel* iomodel)=0;
    2527                virtual void CreateLoads(Loads* loads, IoModel* iomodel)=0;
     28
     29                virtual void GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element)=0;
    2630};
    2731#endif

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

    r16542 r16675  
    112112        }
    113113}/*}}}*/
     114
     115/*Numerics*/
     116void BalancethicknessAnalysis::GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element){/*{{{*/
     117           _error_("not implemented yet");
     118}/*}}}*/

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

    r16542 r16675  
    1818                void CreateConstraints(Constraints* constraints,IoModel* iomodel);
    1919                void CreateLoads(Loads* loads, IoModel* iomodel);
     20                void GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element);
    2021};
    2122#endif

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

    r16542 r16675  
    2424           _error_("not implemented yet");
    2525}/*}}}*/
     26
     27/*Numerics*/
     28void BalancethicknessSoftAnalysis::GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element){/*{{{*/
     29           _error_("not implemented yet");
     30}/*}}}*/

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

    r16542 r16675  
    1818                void CreateConstraints(Constraints* constraints,IoModel* iomodel);
    1919                void CreateLoads(Loads* loads, IoModel* iomodel);
     20                void GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element);
    2021};
    2122#endif

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

    r16542 r16675  
    5757        /*No loads*/
    5858}/*}}}*/
     59
     60/*Numerics*/
     61void BalancevelocityAnalysis::GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element){/*{{{*/
     62           _error_("not implemented yet");
     63}/*}}}*/

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

    r16542 r16675  
    1818                void CreateConstraints(Constraints* constraints,IoModel* iomodel);
    1919                void CreateLoads(Loads* loads, IoModel* iomodel);
     20                void GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element);
    2021};
    2122#endif

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

    r16542 r16675  
    9393
    9494}/*}}}*/
     95
     96/*Numerics*/
     97void DamageEvolutionAnalysis::GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element){/*{{{*/
     98           _error_("not implemented yet");
     99}/*}}}*/

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

    r16542 r16675  
    1818                void CreateConstraints(Constraints* constraints,IoModel* iomodel);
    1919                void CreateLoads(Loads* loads, IoModel* iomodel);
     20                void GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element);
    2021};
    2122#endif

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

    r16604 r16675  
    182182        /*No loads */
    183183}/*}}}*/
     184
     185/*Numerics*/
     186void EnthalpyAnalysis::GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element){/*{{{*/
     187        element->GetSolutionFromInputsOneDof(solution,EnthalpyEnum);
     188}/*}}}*/

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

    r16542 r16675  
    1818                void CreateConstraints(Constraints* constraints,IoModel* iomodel);
    1919                void CreateLoads(Loads* loads, IoModel* iomodel);
     20                void GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element);
    2021};
    2122#endif

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

    r16542 r16675  
    1313                void CreateConstraints(Constraints* constraints,IoModel* iomodel);
    1414                void CreateLoads(Loads* loads, IoModel* iomodel);
     15                void GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element);

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

    r16542 r16675  
    3535void ExtrudeFromBaseAnalysis::CreateLoads(Loads* loads, IoModel* iomodel){/*{{{*/
    3636}/*}}}*/
     37
     38/*Numerics*/
     39void ExtrudeFromBaseAnalysis::GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element){/*{{{*/
     40           _error_("not implemented yet");
     41}/*}}}*/

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

    r16542 r16675  
    1818                void CreateConstraints(Constraints* constraints,IoModel* iomodel);
    1919                void CreateLoads(Loads* loads, IoModel* iomodel);
     20                void GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element);
    2021};
    2122#endif

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

    r16574 r16675  
    3535void ExtrudeFromTopAnalysis::CreateLoads(Loads* loads, IoModel* iomodel){/*{{{*/
    3636}/*}}}*/
     37
     38/*Numerics*/
     39void ExtrudeFromTopAnalysis::GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element){/*{{{*/
     40           _error_("not implemented yet");
     41}/*}}}*/

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

    r16542 r16675  
    1818                void CreateConstraints(Constraints* constraints,IoModel* iomodel);
    1919                void CreateLoads(Loads* loads, IoModel* iomodel);
     20                void GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element);
    2021};
    2122#endif

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

    r16542 r16675  
    8888        iomodel->DeleteData(nodeonbed,MeshVertexonbedEnum);
    8989}/*}}}*/
     90
     91/*Numerics*/
     92void FreeSurfaceBaseAnalysis::GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element){/*{{{*/
     93           _error_("not implemented yet");
     94}/*}}}*/

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

    r16542 r16675  
    1818                void CreateConstraints(Constraints* constraints,IoModel* iomodel);
    1919                void CreateLoads(Loads* loads, IoModel* iomodel);
     20                void GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element);
    2021};
    2122#endif

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

    r16542 r16675  
    8686        iomodel->DeleteData(nodeonsurface,MeshVertexonsurfaceEnum);
    8787}/*}}}*/
     88
     89/*Numerics*/
     90void FreeSurfaceTopAnalysis::GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element){/*{{{*/
     91           _error_("not implemented yet");
     92}/*}}}*/

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

    r16542 r16675  
    1818                void CreateConstraints(Constraints* constraints,IoModel* iomodel);
    1919                void CreateLoads(Loads* loads, IoModel* iomodel);
     20                void GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element);
    2021};
    2122#endif

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

    r16542 r16675  
    3636        /*No loads*/
    3737}/*}}}*/
     38
     39/*Numerics*/
     40void GiaAnalysis::GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element){/*{{{*/
     41           _error_("not implemented yet");
     42}/*}}}*/

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

    r16542 r16675  
    1818                void CreateConstraints(Constraints* constraints,IoModel* iomodel);
    1919                void CreateLoads(Loads* loads, IoModel* iomodel);
     20                void GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element);
    2021};
    2122#endif

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

    r16638 r16675  
    105105        /*Nothing for now*/
    106106}/*}}}*/
     107
     108/*Numerics*/
     109void HydrologyDCEfficientAnalysis::GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element){/*{{{*/
     110        element->GetSolutionFromInputsOneDof(solution,EplHeadEnum);
     111}/*}}}*/

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

    r16542 r16675  
    1818                void CreateConstraints(Constraints* constraints,IoModel* iomodel);
    1919                void CreateLoads(Loads* loads, IoModel* iomodel);
     20                void GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element);
    2021};
    2122#endif

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

    r16600 r16675  
    135135        iomodel->DeleteData(1,MeshVertexonbedEnum);
    136136}/*}}}*/
     137
     138/*Numerics*/
     139void HydrologyDCInefficientAnalysis::GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element){/*{{{*/
     140        element->GetSolutionFromInputsOneDof(solution,SedimentHeadEnum);
     141}/*}}}*/

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

    r16542 r16675  
    1818                void CreateConstraints(Constraints* constraints,IoModel* iomodel);
    1919                void CreateLoads(Loads* loads, IoModel* iomodel);
     20                void GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element);
    2021};
    2122#endif

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

    r16542 r16675  
    8080        /*No loads*/
    8181}/*}}}*/
     82
     83/*Numerics*/
     84void HydrologyShreveAnalysis::GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element){/*{{{*/
     85        element->GetSolutionFromInputsOneDof(solution,WatercolumnEnum);
     86}/*}}}*/

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

    r16542 r16675  
    1818                void CreateConstraints(Constraints* constraints,IoModel* iomodel);
    1919                void CreateLoads(Loads* loads, IoModel* iomodel);
     20                void GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element);
    2021};
    2122#endif

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

    r16542 r16675  
    5353        /*No loads*/
    5454}/*}}}*/
     55
     56/*Numerics*/
     57void L2ProjectionBaseAnalysis::GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element){/*{{{*/
     58           _error_("not implemented yet");
     59}/*}}}*/

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

    r16542 r16675  
    1818                void CreateConstraints(Constraints* constraints,IoModel* iomodel);
    1919                void CreateLoads(Loads* loads, IoModel* iomodel);
     20                void GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element);
    2021};
    2122#endif

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

    r16599 r16675  
    210210
    211211}/*}}}*/
     212
     213/*Numerics*/
     214void MasstransportAnalysis::GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element){/*{{{*/
     215           _error_("not implemented yet");
     216}/*}}}*/

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

    r16542 r16675  
    1818                void CreateConstraints(Constraints* constraints,IoModel* iomodel);
    1919                void CreateLoads(Loads* loads, IoModel* iomodel);
     20                void GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element);
    2021};
    2122#endif

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

    r16542 r16675  
    7070
    7171}/*}}}*/
     72
     73/*Numerics*/
     74void MeltingAnalysis::GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element){/*{{{*/
     75           _error_("not implemented yet");
     76}/*}}}*/

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

    r16542 r16675  
    1818                void CreateConstraints(Constraints* constraints,IoModel* iomodel);
    1919                void CreateLoads(Loads* loads, IoModel* iomodel);
     20                void GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element);
    2021};
    2122#endif

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

    r16542 r16675  
    2424           _error_("not implemented yet");
    2525}/*}}}*/
     26
     27/*Numerics*/
     28void MeshdeformationAnalysis::GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element){/*{{{*/
     29           _error_("not implemented yet");
     30}/*}}}*/

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

    r16542 r16675  
    1818                void CreateConstraints(Constraints* constraints,IoModel* iomodel);
    1919                void CreateLoads(Loads* loads, IoModel* iomodel);
     20                void GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element);
    2021};
    2122#endif

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

    r16542 r16675  
    4343void SmoothedSurfaceSlopeXAnalysis::CreateLoads(Loads* loads, IoModel* iomodel){/*{{{*/
    4444}/*}}}*/
     45
     46/*Numerics*/
     47void SmoothedSurfaceSlopeXAnalysis::GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element){/*{{{*/
     48           _error_("not implemented yet");
     49}/*}}}*/

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

    r16542 r16675  
    1818                void CreateConstraints(Constraints* constraints,IoModel* iomodel);
    1919                void CreateLoads(Loads* loads, IoModel* iomodel);
     20                void GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element);
    2021};
    2122#endif

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

    r16542 r16675  
    4343void SmoothedSurfaceSlopeYAnalysis::CreateLoads(Loads* loads, IoModel* iomodel){/*{{{*/
    4444}/*}}}*/
     45
     46/*Numerics*/
     47void SmoothedSurfaceSlopeYAnalysis::GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element){/*{{{*/
     48           _error_("not implemented yet");
     49}/*}}}*/

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

    r16542 r16675  
    1818                void CreateConstraints(Constraints* constraints,IoModel* iomodel);
    1919                void CreateLoads(Loads* loads, IoModel* iomodel);
     20                void GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element);
    2021};
    2122#endif

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

    r16612 r16675  
    800800#endif
    801801}/*}}}*/
     802
     803/*Numerics*/
     804void StressbalanceAnalysis::GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element){/*{{{*/
     805
     806        int approximation;
     807        element->GetInputValue(&approximation,ApproximationEnum);
     808        switch(approximation){
     809                case FSApproximationEnum: case NoneApproximationEnum:
     810                        GetSolutionFromInputsFS(solution,element);
     811                        return;
     812                case SSAApproximationEnum: case HOApproximationEnum: case SIAApproximationEnum:
     813                        GetSolutionFromInputsHoriz(solution,element);
     814                        return;
     815                case SSAHOApproximationEnum: case HOFSApproximationEnum: case SSAFSApproximationEnum:
     816                        /*the elements around will create the solution*/
     817                        return;
     818                default:
     819                        _error_("Approximation "<<EnumToStringx(approximation)<<" not supported");
     820        }
     821}/*}}}*/
     822void StressbalanceAnalysis::GetSolutionFromInputsFS(Vector<IssmDouble>* solution,Element* element){/*{{{*/
     823
     824        int*         vdoflist=NULL;
     825        int*         pdoflist=NULL;
     826        Input*       vz_input=NULL;
     827        int          meshtype,dim;
     828        IssmDouble   vx,vy,vz,p;
     829        IssmDouble   FSreconditioning;
     830
     831        /*Get some parameters*/
     832        element->FindParam(&meshtype,MeshTypeEnum);
     833        element->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum);
     834        switch(meshtype){
     835                case Mesh2DverticalEnum: dim = 2; break;
     836                case Mesh3DEnum:         dim = 3; break;
     837                default: _error_("mesh "<<EnumToStringx(meshtype)<<" not supported yet");
     838        }
     839
     840        /*Fetch number of nodes and dof for this finite element*/
     841        int vnumnodes = element->NumberofNodesVelocity();
     842        int pnumnodes = element->NumberofNodesPressure();
     843        int vnumdof   = vnumnodes*dim;
     844        int pnumdof   = pnumnodes*1;
     845
     846        /*Initialize values*/
     847        IssmDouble* vvalues = xNew<IssmDouble>(vnumdof);
     848        IssmDouble* pvalues = xNew<IssmDouble>(pnumdof);
     849
     850        /*Get dof list: */
     851        element->GetDofListVelocity(&vdoflist,GsetEnum);
     852        element->GetDofListPressure(&pdoflist,GsetEnum);
     853        Input*     vx_input=element->GetInput(VxEnum);       _assert_(vx_input);
     854        Input*     vy_input=element->GetInput(VyEnum);       _assert_(vy_input);
     855        if(dim==3) vz_input=element->GetInput(VzEnum);       _assert_(vz_input);
     856        Input*     p_input =element->GetInput(PressureEnum); _assert_(p_input);
     857
     858        element->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum);
     859
     860        /*Ok, we have the velocities in inputs, fill in solution */
     861        Gauss* gauss = element->NewGauss();
     862        for(int i=0;i<vnumnodes;i++){
     863                gauss->GaussNode(element->VelocityInterpolation(),i);
     864                vx_input->GetInputValue(&vx,gauss);
     865                vy_input->GetInputValue(&vy,gauss);
     866                vvalues[i*dim+0]=vx;
     867                vvalues[i*dim+1]=vy;
     868                if(dim==3){
     869                        vz_input->GetInputValue(&vz,gauss);
     870                        vvalues[i*dim+2]=vz;
     871                }
     872        }
     873        for(int i=0;i<pnumnodes;i++){
     874                gauss->GaussNode(element->PressureInterpolation(),i);
     875                p_input->GetInputValue(&p ,gauss);
     876                pvalues[i]=p/FSreconditioning;
     877        }
     878
     879        /*Add value to global vector*/
     880        solution->SetValues(vnumdof,vdoflist,vvalues,INS_VAL);
     881        solution->SetValues(pnumdof,pdoflist,pvalues,INS_VAL);
     882
     883        /*Free ressources:*/
     884        delete gauss;
     885        xDelete<int>(pdoflist);
     886        xDelete<int>(vdoflist);
     887        xDelete<IssmDouble>(pvalues);
     888        xDelete<IssmDouble>(vvalues);
     889}/*}}}*/
     890void StressbalanceAnalysis::GetSolutionFromInputsHoriz(Vector<IssmDouble>* solution,Element* element){/*{{{*/
     891
     892        IssmDouble   vx,vy;
     893        int*         doflist = NULL;
     894
     895        /*Fetch number of nodes and dof for this finite element*/
     896        int numnodes = element->GetNumberOfNodes();
     897        int numdof   = numnodes*2;
     898
     899        /*Fetch dof list and allocate solution vector*/
     900        element->GetDofList(&doflist,NoneApproximationEnum,GsetEnum);
     901        IssmDouble* values = xNew<IssmDouble>(numdof);
     902
     903        /*Get inputs*/
     904        Input* vx_input=element->GetInput(VxEnum); _assert_(vx_input);
     905        Input* vy_input=element->GetInput(VyEnum); _assert_(vy_input);
     906
     907        /*Ok, we have vx and vy in values, fill in vx and vy arrays: */
     908        Gauss* gauss=element->NewGauss();
     909        for(int i=0;i<numnodes;i++){
     910                gauss->GaussNode(element->FiniteElement(),i);
     911
     912                /*Recover vx and vy*/
     913                vx_input->GetInputValue(&vx,gauss);
     914                vy_input->GetInputValue(&vy,gauss);
     915                values[i*NDOF2+0]=vx;
     916                values[i*NDOF2+1]=vy;
     917        }
     918
     919        solution->SetValues(numdof,doflist,values,INS_VAL);
     920
     921        /*Free ressources:*/
     922        delete gauss;
     923        xDelete<IssmDouble>(values);
     924        xDelete<int>(doflist);
     925}/*}}}*/

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

    r16542 r16675  
    1818                void CreateConstraints(Constraints* constraints,IoModel* iomodel);
    1919                void CreateLoads(Loads* loads, IoModel* iomodel);
     20                void GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element);
     21                void GetSolutionFromInputsFS(Vector<IssmDouble>* solution,Element* element);
     22                void GetSolutionFromInputsHoriz(Vector<IssmDouble>* solution,Element* element);
    2023};
    2124#endif

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

    r16542 r16675  
    132132
    133133}/*}}}*/
     134
     135/*Numerics*/
     136void StressbalanceSIAAnalysis::GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element){/*{{{*/
     137
     138        IssmDouble vx,vy;
     139        int       *doflist = NULL;
     140
     141        /*Fetch number of nodes and initialize values*/
     142        int         numnodes = element->GetNumberOfNodes();
     143        int         numdof   = numnodes*2;
     144        IssmDouble* values   = xNew<IssmDouble>(numdof);
     145
     146        /*Get dof list and inputs */
     147        element->GetDofList(&doflist,NoneApproximationEnum,GsetEnum);
     148        Input* vx_input=element->GetInput(VxEnum); _assert_(vx_input);
     149        Input* vy_input=element->GetInput(VyEnum); _assert_(vy_input);
     150
     151        /*Ok, we have the velocities in inputs, fill in solution */
     152        Gauss* gauss=element->NewGauss();
     153        for(int i=0;i<numnodes;i++){
     154                gauss->GaussVertex(i);
     155                vx_input->GetInputValue(&vx,gauss);
     156                vy_input->GetInputValue(&vy,gauss);
     157                values[i*2+0]=vx;
     158                values[i*2+1]=vy;
     159        }
     160
     161        /*Add value to global vector*/
     162        solution->SetValues(numdof,doflist,values,INS_VAL);
     163
     164        /*Free ressources:*/
     165        delete gauss;
     166        xDelete<int>(doflist);
     167        xDelete<IssmDouble>(values);
     168}/*}}}*/

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

    r16542 r16675  
    1818                void CreateConstraints(Constraints* constraints,IoModel* iomodel);
    1919                void CreateLoads(Loads* loads, IoModel* iomodel);
     20                void GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element);
    2021};
    2122#endif

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

    r16607 r16675  
    9494
    9595}/*}}}*/
     96
     97/*Numerics*/
     98void StressbalanceVerticalAnalysis::GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element){/*{{{*/
     99           _error_("not implemented yet");
     100}/*}}}*/

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

    r16542 r16675  
    1818                void CreateConstraints(Constraints* constraints,IoModel* iomodel);
    1919                void CreateLoads(Loads* loads, IoModel* iomodel);
     20                void GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element);
    2021};
    2122#endif

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

    r16605 r16675  
    110110
    111111}/*}}}*/
     112
     113/*Numerics*/
     114void ThermalAnalysis::GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element){/*{{{*/
     115        element->GetSolutionFromInputsOneDof(solution,TemperatureEnum);
     116}/*}}}*/

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

    r16542 r16675  
    1818                void CreateConstraints(Constraints* constraints,IoModel* iomodel);
    1919                void CreateLoads(Loads* loads, IoModel* iomodel);
     20                void GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element);
    2021};
    2122#endif

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

    r16600 r16675  
    2121class Vertices;
    2222class Materials;
     23class Input;
     24class Gauss;
    2325template <class doublematrix> class Matrix;
    2426template <class doubletype> class Vector;
    … …  
    4042                virtual void   CreatePVector(Vector<IssmDouble>* pf)=0;
    4143                virtual void   CreateJacobianMatrix(Matrix<IssmDouble>* Jff)=0;
     44                virtual void   FindParam(int* pvalue,int paramenum)=0;
     45                virtual void   FindParam(IssmDouble* pvalue,int paramenum)=0;
     46                virtual int    FiniteElement(void)=0;
     47                virtual void    GetDofList(int** pdoflist,int approximation_enum,int setenum)=0;
     48                virtual void    GetDofListVelocity(int** pdoflist,int setenum)=0;
     49                virtual void    GetDofListPressure(int** pdoflist,int setenum)=0;
    4250                virtual void   GetSolutionFromInputs(Vector<IssmDouble>* solution)=0;
     51                virtual void   GetSolutionFromInputsOneDof(Vector<IssmDouble>* solution,int solutionenum)=0;
    4352                virtual int    GetNodeIndex(Node* node)=0;
    4453                virtual int    GetNumberOfNodes(void)=0;
    … …  
    5261                virtual void   GetInputListOnVertices(IssmDouble* pvalue,int enumtype)=0;
    5362                virtual void   GetInputListOnVertices(IssmDouble* pvalue,int enumtype,IssmDouble defaultvalue)=0;
     63                virtual Input* GetInput(int inputenum)=0;
    5464                virtual void   GetInputValue(IssmDouble* pvalue,Node* node,int enumtype)=0;
     65                virtual void   GetInputValue(bool* pvalue,int enum_type)=0;
     66                virtual void   GetInputValue(int* pvalue,int enum_type)=0;
     67                virtual void   GetInputValue(IssmDouble* pvalue,int enum_type)=0;
    5568                virtual void   GetMaterialInputValue(IssmDouble* pvalue,Node* node,int enumtype)=0;
    5669
    … …  
    6679
    6780                virtual int    NodalValue(IssmDouble* pvalue, int index, int natureofdataenum)=0;
     81                virtual int    NumberofNodesVelocity(void)=0;
     82                virtual int    NumberofNodesPressure(void)=0;
     83                virtual Gauss* NewGauss(void)=0;
    6884                virtual void   InputScale(int enum_type,IssmDouble scale_factor)=0;
    6985                virtual void   GetVectorFromInputs(Vector<IssmDouble>* vector, int name_enum)=0;
    … …  
    7389                virtual void   SmbGradients()=0;
    7490                virtual void   ResetCoordinateSystem()=0;
     91                virtual int    VelocityInterpolation()=0;
     92                virtual int    PressureInterpolation()=0;
    7593
    7694                #ifdef _HAVE_RESPONSES_

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

    r16638 r16675  
    918918}
    919919/*}}}*/
     920/*FUNCTION Penta::FindParam(int* pvalue,int paramenum){{{*/
     921void Penta::FindParam(int* pvalue,int paramenum){
     922        this->parameters->FindParam(pvalue,paramenum);
     923}
     924/*}}}*/
     925/*FUNCTION Penta::FindParam(IssmDouble* pvalue,int paramenum){{{*/
     926void Penta::FindParam(IssmDouble* pvalue,int paramenum){
     927        this->parameters->FindParam(pvalue,paramenum);
     928}
     929/*}}}*/
     930/*FUNCTION Penta::FiniteElement{{{*/
     931int Penta::FiniteElement(void){
     932        return this->element_type;
     933}
     934/*}}}*/
    920935/*FUNCTION Penta::ObjectEnum{{{*/
    921936int Penta::ObjectEnum(void){
    … …  
    13161331}
    13171332/*}}}*/
     1333/*FUNCTION Penta::GetInput(int inputenum) {{{*/
     1334Input* Penta::GetInput(int inputenum){
     1335        return inputs->GetInput(inputenum);
     1336}
     1337/*}}}*/
    13181338/*FUNCTION Penta::GetInputListOnVertices(IssmDouble* pvalue,int enumtype) {{{*/
    13191339void Penta::GetInputListOnVertices(IssmDouble* pvalue,int enumtype){
    … …  
    14131433}
    14141434/*}}}*/
     1435/*FUNCTION Penta::GetInputValue(bool* pvalue,int inputenum) {{{*/
     1436void Penta::GetInputValue(bool* pvalue,int inputenum){
     1437
     1438        Input* input=inputs->GetInput(inputenum);
     1439        if(!input) _error_("Input " << EnumToStringx(inputenum) << " not found in element");
     1440        input->GetInputValue(pvalue);
     1441
     1442}/*}}}*/
     1443/*FUNCTION Penta::GetInputValue(int* pvalue,int inputenum) {{{*/
     1444void Penta::GetInputValue(int* pvalue,int inputenum){
     1445
     1446        Input* input=inputs->GetInput(inputenum);
     1447        if(!input) _error_("Input " << EnumToStringx(inputenum) << " not found in element");
     1448        input->GetInputValue(pvalue);
     1449
     1450}/*}}}*/
     1451/*FUNCTION Penta::GetInputValue(IssmDouble* pvalue,int inputenum) {{{*/
     1452void Penta::GetInputValue(IssmDouble* pvalue,int inputenum){
     1453
     1454        Input* input=inputs->GetInput(inputenum);
     1455        if(!input) _error_("Input " << EnumToStringx(inputenum) << " not found in element");
     1456        input->GetInputValue(pvalue);
     1457
     1458}/*}}}*/
    14151459/*FUNCTION Penta::GetMaterialInputValue(IssmDouble* pvalue,Node* node,int enumtype) {{{*/
    14161460void Penta::GetMaterialInputValue(IssmDouble* pvalue,Node* node,int enumtype){
    … …  
    27652809        if(found)*pvalue=value;
    27662810        return found;
     2811}
     2812/*}}}*/
     2813/*FUNCTION Penta::NewGauss{{{*/
     2814Gauss* Penta::NewGauss(void){
     2815        return new GaussPenta();
     2816}
     2817/*}}}*/
     2818/*FUNCTION Penta::NumberofNodesPressure{{{*/
     2819int Penta::NumberofNodesPressure(void){
     2820        return PentaRef::NumberofNodesPressure();
     2821}
     2822/*}}}*/
     2823/*FUNCTION Penta::NumberofNodesVelocity{{{*/
     2824int Penta::NumberofNodesVelocity(void){
     2825        return PentaRef::NumberofNodesVelocity();
    27672826}
    27682827/*}}}*/
    … …  
    34573516        /*Clean up and return*/
    34583517        delete gauss;
     3518}
     3519/*}}}*/
     3520/*FUNCTION Penta::VelocityInterpolation{{{*/
     3521int Penta::VelocityInterpolation(void){
     3522        return PentaRef::VelocityInterpolation();
     3523}
     3524/*}}}*/
     3525/*FUNCTION Penta::PressureInterpolation{{{*/
     3526int Penta::PressureInterpolation(void){
     3527        return PentaRef::PressureInterpolation();
    34593528}
    34603529/*}}}*/

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

    r16600 r16675  
    7474                void   ComputeStressTensor();
    7575                void   Configure(Elements* elements,Loads* loads,Nodes* nodes,Vertices* vertices,Materials* materials,Parameters* parameters);
     76                void   FindParam(int* pvalue,int paramenum);
     77                void   FindParam(IssmDouble* pvalue,int paramenum);
     78                int    FiniteElement(void);
    7679                void   SetCurrentConfiguration(Elements* elements,Loads* loads,Nodes* nodes,Materials* materials,Parameters* parameters);
    7780                void   SetwiseNodeConnectivity(int* d_nz,int* o_nz,Node* node,bool* flags,int* flagsindices,int set1_enum,int set2_enum);
    … …  
    8184                void   CreateJacobianMatrix(Matrix<IssmDouble>* Jff);
    8285                void   Delta18oParameterization(void);
     86                void     GetDofList(int** pdoflist,int approximation_enum,int setenum);
     87                void     GetDofListVelocity(int** pdoflist,int setenum);
     88                void     GetDofListPressure(int** pdoflist,int setenum);
    8389                int    GetNodeIndex(Node* node);
    8490                void   GetNodesSidList(int* sidlist);
    … …  
    8692                int    GetNumberOfNodes(void);
    8793                void   GetSolutionFromInputs(Vector<IssmDouble>* solution);
     94                void   GetSolutionFromInputsOneDof(Vector<IssmDouble>* solution,int enum_type);
    8895                IssmDouble GetZcoord(GaussPenta* gauss);
    8996                void   GetVectorFromInputs(Vector<IssmDouble>* vector,int name_enum);
    … …  
    94101                void   InputDuplicate(int original_enum,int new_enum);
    95102                void   InputScale(int enum_type,IssmDouble scale_factor);
     103                int    NumberofNodesVelocity(void);
     104                int    NumberofNodesPressure(void);
     105                int    VelocityInterpolation();
     106                int    PressureInterpolation();
    96107
    97108                void   ResultInterpolation(int* pinterpolation,int output_enum);
    … …  
    181192                ElementVector* CreatePVectorL2ProjectionBase(void);
    182193                void           GetAreaCoordinates(IssmDouble *area_coordinates,IssmDouble xyz_zero[3][3],IssmDouble xyz_list[6][3],int numpoints);
    183                 void             GetDofList(int** pdoflist,int approximation_enum,int setenum);
    184                 void             GetDofListVelocity(int** pdoflist,int setenum);
    185                 void             GetDofListPressure(int** pdoflist,int setenum);
     194
    186195                void             GetVertexPidList(int* doflist);
    187196                void           GetVertexSidList(int* sidlist);
    … …  
    191200                int            GetElementType(void);
    192201                void           GetElementSizes(IssmDouble* hx,IssmDouble* hy,IssmDouble* hz);
     202                Input*         GetInput(int inputenum);
    193203                void           GetInputListOnVertices(IssmDouble* pvalue,int enumtype);
    194204                void           GetInputListOnVertices(IssmDouble* pvalue,int enumtype,IssmDouble defaultvalue);
    … …  
    196206                void           GetInputListOnNodes(IssmDouble* pvalue,int enumtype,IssmDouble defaultvalue);
    197207                void           GetInputValue(IssmDouble* pvalue,Node* node,int enumtype);
     208                void           GetInputValue(bool* pvalue,int enum_type);
     209                void           GetInputValue(int* pvalue,int enum_type);
     210                void           GetInputValue(IssmDouble* pvalue,int enum_type);
    198211                void           GetMaterialInputValue(IssmDouble* pvalue,Node* node,int enumtype);
    199212                void             GetPhi(IssmDouble* phi, IssmDouble*  epsilon, IssmDouble viscosity);
    … …  
    218231                bool           IsNodeOnShelfFromFlags(IssmDouble* flags);
    219232                bool           NoIceInElement(void);
     233                Gauss*         NewGauss(void);
    220234                IssmDouble     MinEdgeLength(IssmDouble xyz_list[6][3]);
    221235                void             SetClone(int* minranks);
    … …  
    319333                void    GetHydrologyDCInefficientHmax(IssmDouble* ph_max, Node* innode);
    320334                void    GetHydrologyTransfer(Vector<IssmDouble>* transfer);
    321                 void    GetSolutionFromInputsOneDof(Vector<IssmDouble>* solution, int enum_type);
    322335                void    HydrologyEPLGetActive(Vector<IssmDouble>* active_vec);
    323336                void    HydrologyEPLGetMask(Vector<IssmDouble>* vec_mask);

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

    r16611 r16675  
    8888}
    8989/*}}}*/
     90/*FUNCTION Seg::FindParam(int* pvalue,int paramenum){{{*/
     91void Seg::FindParam(int* pvalue,int paramenum){
     92        this->parameters->FindParam(pvalue,paramenum);
     93}
     94/*}}}*/
     95/*FUNCTION Seg::FindParam(IssmDouble* pvalue,int paramenum){{{*/
     96void Seg::FindParam(IssmDouble* pvalue,int paramenum){
     97        this->parameters->FindParam(pvalue,paramenum);
     98}
     99/*}}}*/
     100/*FUNCTION Seg::FiniteElement{{{*/
     101int Seg::FiniteElement(void){
     102        return this->element_type;
     103}
     104/*}}}*/
    90105/*FUNCTION Seg::DeepEcho{{{*/
    91106void Seg::DeepEcho(void){

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

    r16600 r16675  
    7878                void        CreateJacobianMatrix(Matrix<IssmDouble>* Jff){_error_("not implemented yet");};
    7979                void        Delta18oParameterization(void){_error_("not implemented yet");};
     80                void        FindParam(int* pvalue,int paramenum);
     81                void        FindParam(IssmDouble* pvalue,int paramenum);
     82                int         FiniteElement(void);
     83                void        GetDofList(int** pdoflist,int approximation_enum,int setenum){_error_("not implemented yet");};
     84                void        GetDofListVelocity(int** pdoflist,int setenum){_error_("not implemented yet");};
     85                void        GetDofListPressure(int** pdoflist,int setenum){_error_("not implemented yet");};
    8086                int         GetNodeIndex(Node* node){_error_("not implemented yet");};
    8187                void        GetNodesSidList(int* sidlist){_error_("not implemented yet");};
    … …  
    8692                bool        IsFloating(){_error_("not implemented yet");};
    8793                bool        IsNodeOnShelfFromFlags(IssmDouble* flags){_error_("not implemented yet");};
     94                int         NumberofNodesVelocity(void){_error_("not implemented yet");};
     95                int         NumberofNodesPressure(void){_error_("not implemented yet");};
     96                int         VelocityInterpolation(void){_error_("not implemented yet");};
     97                int         PressureInterpolation(void){_error_("not implemented yet");};
    8898                bool        NoIceInElement(){_error_("not implemented yet");};
    89                 void           GetInputListOnVertices(IssmDouble* pvalue,int enumtype){_error_("not implemented yet");};
    90                 void           GetInputListOnVertices(IssmDouble* pvalue,int enumtype,IssmDouble defaultvalue){_error_("not implemented yet");};
    91                 void           GetInputValue(IssmDouble* pvalue,Node* node,int enumtype){_error_("not implemented yet");};
    92                 void           GetMaterialInputValue(IssmDouble* pvalue,Node* node,int enumtype){_error_("not implemented yet");};
     99                Input*      GetInput(int inputenum){_error_("not implemented yet");};
     100                void        GetInputListOnVertices(IssmDouble* pvalue,int enumtype){_error_("not implemented yet");};
     101                void        GetInputListOnVertices(IssmDouble* pvalue,int enumtype,IssmDouble defaultvalue){_error_("not implemented yet");};
     102                void        GetInputValue(IssmDouble* pvalue,Node* node,int enumtype){_error_("not implemented yet");};
     103                void        GetInputValue(bool* pvalue,int enum_type){_error_("not implemented yet");};
     104                void        GetInputValue(int* pvalue,int enum_type){_error_("not implemented yet");};
     105                void        GetInputValue(IssmDouble* pvalue,int enum_type){_error_("not implemented yet");};
     106                void        GetMaterialInputValue(IssmDouble* pvalue,Node* node,int enumtype){_error_("not implemented yet");};
     107                Gauss*      NewGauss(void){_error_("not implemented yet");};
    93108                #ifdef _HAVE_THERMAL_
    94109                void UpdateBasalConstraintsEnthalpy(void){_error_("not implemented yet");};
    … …  
    104119                #endif
    105120                void        GetSolutionFromInputs(Vector<IssmDouble>* solution){_error_("not implemented yet");};
     121                void        GetSolutionFromInputsOneDof(Vector<IssmDouble>* solution,int enum_type){_error_("not implemented yet");};
    106122                void        GetVectorFromInputs(Vector<IssmDouble>* vector, int name_enum){_error_("not implemented yet");};
    107123                void        InputCreate(IssmDouble* vector,IoModel* iomodel,int M,int N,int vector_type,int vector_enum,int code){_error_("not implemented yet");};

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

    r16657 r16675  
    867867}
    868868/*}}}*/
     869/*FUNCTION Tria::FindParam(int* pvalue,int paramenum){{{*/
     870void Tria::FindParam(int* pvalue,int paramenum){
     871        this->parameters->FindParam(pvalue,paramenum);
     872}
     873/*}}}*/
     874/*FUNCTION Tria::FindParam(IssmDouble* pvalue,int paramenum){{{*/
     875void Tria::FindParam(IssmDouble* pvalue,int paramenum){
     876        this->parameters->FindParam(pvalue,paramenum);
     877}
     878/*}}}*/
     879/*FUNCTION Tria::FiniteElement{{{*/
     880int Tria::FiniteElement(void){
     881        return this->element_type;
     882}
     883/*}}}*/
    869884/*FUNCTION Tria::ObjectEnum{{{*/
    870885int Tria::ObjectEnum(void){
    … …  
    13111326}
    13121327/*}}}*/
     1328/*FUNCTION Tria::GetInput(int inputenum) {{{*/
     1329Input* Tria::GetInput(int inputenum){
     1330        return inputs->GetInput(inputenum);
     1331}
     1332/*}}}*/
    13131333/*FUNCTION Tria::GetInputListOnVertices(IssmDouble* pvalue,int enumtype) {{{*/
    13141334void Tria::GetInputListOnVertices(IssmDouble* pvalue,int enumtype){
    … …  
    14291449}
    14301450/*}}}*/
     1451/*FUNCTION Tria::GetInputValue(bool* pvalue,int inputenum) {{{*/
     1452void Tria::GetInputValue(bool* pvalue,int inputenum){
     1453
     1454        Input* input=inputs->GetInput(inputenum);
     1455        if(!input) _error_("Input " << EnumToStringx(inputenum) << " not found in element");
     1456        input->GetInputValue(pvalue);
     1457
     1458}/*}}}*/
     1459/*FUNCTION Tria::GetInputValue(int* pvalue,int inputenum) {{{*/
     1460void Tria::GetInputValue(int* pvalue,int inputenum){
     1461
     1462        Input* input=inputs->GetInput(inputenum);
     1463        if(!input) _error_("Input " << EnumToStringx(inputenum) << " not found in element");
     1464        input->GetInputValue(pvalue);
     1465
     1466}/*}}}*/
     1467/*FUNCTION Tria::GetInputValue(IssmDouble* pvalue,int inputenum) {{{*/
     1468void Tria::GetInputValue(IssmDouble* pvalue,int inputenum){
     1469
     1470        Input* input=inputs->GetInput(inputenum);
     1471        if(!input) _error_("Input " << EnumToStringx(inputenum) << " not found in element");
     1472        input->GetInputValue(pvalue);
     1473
     1474}/*}}}*/
    14311475/*FUNCTION Tria::GetMaterialInputValue(IssmDouble* pvalue,Node* node,int enumtype) {{{*/
    14321476void Tria::GetMaterialInputValue(IssmDouble* pvalue,Node* node,int enumtype){
    … …  
    23272371}
    23282372/*}}}*/
     2373/*FUNCTION Tria::NewGauss{{{*/
     2374Gauss* Tria::NewGauss(void){
     2375        return new GaussTria();
     2376}
     2377/*}}}*/
    23292378/*FUNCTION Tria::NoIceInElement {{{*/
    23302379bool   Tria::NoIceInElement(){
    … …  
    23722421        if(found)*pvalue=value;
    23732422        return found;
     2423}
     2424/*}}}*/
     2425/*FUNCTION Tria::VelocityInterpolation{{{*/
     2426int Tria::VelocityInterpolation(void){
     2427        return TriaRef::VelocityInterpolation();
     2428}
     2429/*}}}*/
     2430/*FUNCTION Tria::PressureInterpolation{{{*/
     2431int Tria::PressureInterpolation(void){
     2432        return TriaRef::PressureInterpolation();
     2433}
     2434/*}}}*/
     2435/*FUNCTION Tria::NumberofNodesPressure{{{*/
     2436int Tria::NumberofNodesPressure(void){
     2437        return TriaRef::NumberofNodesPressure();
     2438}
     2439/*}}}*/
     2440/*FUNCTION Tria::NumberofNodesVelocity{{{*/
     2441int Tria::NumberofNodesVelocity(void){
     2442        return TriaRef::NumberofNodesVelocity();
    23742443}
    23752444/*}}}*/
    … …  
    73387407}
    73397408/*}}}*/
    7340 
    7341 
    73427409#endif
    73437410

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

    r16657 r16675  
    7979                void        CreateJacobianMatrix(Matrix<IssmDouble>* Jff);
    8080                void        Delta18oParameterization(void);
     81                void        FindParam(int* pvalue,int paramenum);
     82                void        FindParam(IssmDouble* pvalue,int paramenum);
     83                int         FiniteElement(void);
     84                void          GetDofList(int** pdoflist,int approximation_enum,int setenum);
     85                void          GetDofListVelocity(int** pdoflist,int setenum);
     86                void          GetDofListPressure(int** pdoflist,int setenum);
    8187                int         GetNodeIndex(Node* node);
    8288                void        GetNodesSidList(int* sidlist);
    … …  
    95101                bool        IsFloating();
    96102                bool        IsNodeOnShelfFromFlags(IssmDouble* flags);
     103                int         NumberofNodesVelocity(void);
     104                int         NumberofNodesPressure(void);
    97105                bool        NoIceInElement();
    98106                void        GetSolutionFromInputs(Vector<IssmDouble>* solution);
     107                void        GetSolutionFromInputsOneDof(Vector<IssmDouble>* solution,int enum_type);
    99108                void        GetVectorFromInputs(Vector<IssmDouble>* vector, int name_enum);
    100109                void        InputCreate(IssmDouble* vector,IoModel* iomodel,int M,int N,int vector_type,int vector_enum,int code);
    … …  
    109118                void        ResetCoordinateSystem(void);
    110119                void          SmbGradients();
     120                int         VelocityInterpolation();
     121                int         PressureInterpolation();
    111122                IssmDouble  SurfaceArea(void);
    112123                void        Update(int index, IoModel* iomodel,int analysis_counter,int analysis_type,int finitelement);
    … …  
    220231                void           GetAreaCoordinates(IssmDouble *area_coordinates,IssmDouble xyz_zero[3][3],IssmDouble xyz_list[3][3],int numpoints);
    221232                int            GetElementType(void);
    222                 void             GetDofList(int** pdoflist,int approximation_enum,int setenum);
    223                 void             GetDofListVelocity(int** pdoflist,int setenum);
    224                 void             GetDofListPressure(int** pdoflist,int setenum);
     233
    225234                void             GetVertexPidList(int* doflist);
    226235                void           GetVertexSidList(int* sidlist);
    … …  
    230239                void           GetSegmentNormal(IssmDouble* normal,IssmDouble xyz_list[2][3]);
    231240                void           GetZeroLevelsetCoordinates(IssmDouble* xyz_zero,IssmDouble xyz_list[3][3],int levelsetenum);
     241                Input*         GetInput(int inputenum);
    232242                void           GetInputListOnVertices(IssmDouble* pvalue,int enumtype);
    233243                void           GetInputListOnVertices(IssmDouble* pvalue,int enumtype,IssmDouble defaultvalue);
    … …  
    236246                void           GetInputListOnNodes(IssmDouble* pvalue,int enumtype,IssmDouble defaultvalue);
    237247                void           GetInputValue(IssmDouble* pvalue,Node* node,int enumtype);
     248                void           GetInputValue(bool* pvalue,int enum_type);
     249                void           GetInputValue(int* pvalue,int enum_type);
     250                void           GetInputValue(IssmDouble* pvalue,int enum_type);
    238251                void           GetMaterialInputValue(IssmDouble* pvalue,Node* node,int enumtype);
    239252                void           GetStrainRate2d(IssmDouble* epsilon,IssmDouble* xyz_list, GaussTria* gauss, Input* vx_input, Input* vy_input);
    … …  
    241254                void             InputUpdateFromSolutionMasstransport(IssmDouble* solution);
    242255                bool             IsInput(int name);
     256                Gauss*         NewGauss(void);
    243257                void             SetClone(int* minranks);
    244258                Seg*             SpawnSeg(int index1,int index2);
    … …  
    294308                ElementVector* CreatePVectorHydrologyDCInefficient(void);
    295309                ElementVector* CreatePVectorHydrologyDCEfficient(void);
    296                 void    GetSolutionFromInputsOneDof(Vector<IssmDouble>* solution,int enum_type);
    297310                void    CreateHydrologyWaterVelocityInput(void);
    298311                void      InputUpdateFromSolutionHydrology(IssmDouble* solution);

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

    r16656 r16675  
    112112void BoolInput::GetInputValue(IssmDouble* pvalue){_error_("not supported yet!");}
    113113/*}}}*/
    114 /*FUNCTION BoolInput::GetInputValue(IssmDouble* pvalue,GaussTria* gauss){{{*/
    115 void BoolInput::GetInputValue(IssmDouble* pvalue,GaussTria* gauss){_error_("not supported yet!");}
    116 /*}}}*/
    117 /*FUNCTION BoolInput::GetInputValue(IssmDouble* pvalue,GaussPenta* gauss){{{*/
    118 void BoolInput::GetInputValue(IssmDouble* pvalue,GaussPenta* gauss){_error_("not supported yet!");}
     114/*FUNCTION BoolInput::GetInputValue(IssmDouble* pvalue,Gauss* gauss){{{*/
     115void BoolInput::GetInputValue(IssmDouble* pvalue,Gauss* gauss){_error_("not supported yet!");}
    119116/*}}}*/
    120117/*FUNCTION BoolInput::GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussTria* gauss){{{*/

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

    r16486 r16675  
    4747                void GetInputValue(int* pvalue);
    4848                void GetInputValue(IssmDouble* pvalue);
    49                 void GetInputValue(IssmDouble* pvalue,GaussSeg* gauss){_error_("not implemented yet");};
    50                 void GetInputValue(IssmDouble* pvalue,GaussTria* gauss);
    51                 void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss);
    52                 void GetInputValue(IssmDouble* pvalue,GaussTria* gauss,IssmDouble time){_error_("not implemented yet");};
    53                 void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss,IssmDouble time){_error_("not implemented yet");};
    54                 void GetInputValue(IssmDouble* pvalue,GaussTria* gauss ,int index){_error_("not implemented yet");};
    55                 void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss ,int index){_error_("not implemented yet");};
     49                void GetInputValue(IssmDouble* pvalue,Gauss* gauss);
     50                void GetInputValue(IssmDouble* pvalue,Gauss* gauss,IssmDouble time){_error_("not implemented yet");};
     51                void GetInputValue(IssmDouble* pvalue,Gauss* gauss ,int index){_error_("not implemented yet");};
    5652                void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussSeg* gauss){_error_("not implemented yet");};
    5753                void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussTria* gauss);

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

    r16656 r16675  
    235235        values->GetInputValue(pvalue);
    236236}/*}}}*/
    237 /*FUNCTION ControlInput::GetInputValue(IssmDouble* pvalue){{{*/
    238 void ControlInput::GetInputValue(IssmDouble* pvalue,GaussTria* gauss){
    239         values->GetInputValue(pvalue,gauss);
    240 }/*}}}*/
    241 /*FUNCTION ControlInput::GetInputValue(IssmDouble* pvalue){{{*/
    242 void ControlInput::GetInputValue(IssmDouble* pvalue,GaussPenta* gauss){
     237/*FUNCTION ControlInput::GetInputValue(Issm* pvalue,Gauss* gauss){{{*/
     238void ControlInput::GetInputValue(IssmDouble* pvalue,Gauss* gauss){
    243239        values->GetInputValue(pvalue,gauss);
    244240}/*}}}*/

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

    r16486 r16675  
    5353                void GetInputValue(int* pvalue);
    5454                void GetInputValue(IssmDouble* pvalue);
    55                 void GetInputValue(IssmDouble* pvalue,GaussSeg* gauss){_error_("not implemented yet");};
    56                 void GetInputValue(IssmDouble* pvalue,GaussTria* gauss);
    57                 void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss);
    58                 void GetInputValue(IssmDouble* pvalue,GaussTria* gauss,IssmDouble time){_error_("not implemented yet");};
    59                 void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss,IssmDouble time){_error_("not implemented yet");};
    60                 void GetInputValue(IssmDouble* pvalue,GaussTria* gauss ,int index){_error_("not implemented yet");};
    61                 void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss ,int index){_error_("not implemented yet");};
     55                void GetInputValue(IssmDouble* pvalue,Gauss* gauss);
     56                void GetInputValue(IssmDouble* pvalue,Gauss* gauss,IssmDouble time){_error_("not implemented yet");};
     57                void GetInputValue(IssmDouble* pvalue,Gauss* gauss ,int index){_error_("not implemented yet");};
    6258                void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussSeg* gauss){_error_("not implemented yet");};
    6359                void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussTria* gauss);

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

    r16382 r16675  
    158158}
    159159/*}}}*/
    160 /*FUNCTION DatasetInput::GetInputValue(IssmDouble* pvalue,GaussTria* gauss,int id){{{*/
    161 void DatasetInput::GetInputValue(IssmDouble* pvalue,GaussTria* gauss,int id){
     160/*FUNCTION DatasetInput::GetInputValue(IssmDouble* pvalue,Gauss* gauss,int id){{{*/
     161void DatasetInput::GetInputValue(IssmDouble* pvalue,Gauss* gauss,int id){
    162162
    163163        int  offset = -1;
    … …  
    172172}
    173173/*}}}*/
    174 /*FUNCTION DatasetInput::GetInputValue(IssmDouble* pvalue,GaussPenta* gauss,int id){{{*/
    175 void DatasetInput::GetInputValue(IssmDouble* pvalue,GaussPenta* gauss,int id){
    176 
    177         int  offset = -1;
    178         _assert_(this->numids == this->inputs->Size());
    179 
    180         /*Get requested input within dataset*/
    181         for(int i=0;i<this->numids;i++) if(this->ids[i]==id) offset=i;
    182         if(offset<0) _error_("Could not find input of id "<<id);
    183 
    184         Input* input=dynamic_cast<Input*>(this->inputs->GetObjectByOffset(offset));
    185         input->GetInputValue(pvalue,gauss);
    186 }
    187 /*}}}*/

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

    r16486 r16675  
    4848                void GetInputValue(int* pvalue){_error_("not implemented yet");};
    4949                void GetInputValue(IssmDouble* pvalue){_error_("not implemented yet");};
    50                 void GetInputValue(IssmDouble* pvalue,GaussSeg* gauss){_error_("not implemented yet");};
    51                 void GetInputValue(IssmDouble* pvalue,GaussTria* gauss){_error_("not implemented yet");};
    52                 void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss){_error_("not implemented yet");};
    53                 void GetInputValue(IssmDouble* pvalue,GaussTria* gauss,IssmDouble time){_error_("not implemented yet");};
    54                 void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss,IssmDouble time){_error_("not implemented yet");};
    55                 void GetInputValue(IssmDouble* pvalue,GaussTria* gauss ,int index);
    56                 void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss ,int index);
     50                void GetInputValue(IssmDouble* pvalue,Gauss* gauss){_error_("not implemented yet");};
     51                void GetInputValue(IssmDouble* pvalue,Gauss* gauss,IssmDouble time){_error_("not implemented yet");};
     52                void GetInputValue(IssmDouble* pvalue,Gauss* gauss ,int index);
    5753                void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussSeg* gauss){_error_("not implemented yet");};
    5854                void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussTria* gauss){_error_("not implemented yet");};

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

    r16656 r16675  
    120120}
    121121/*}}}*/
    122 /*FUNCTION DoubleInput::GetInputValue(IssmDouble* pvalue,GaussTria* gauss){{{*/
    123 void DoubleInput::GetInputValue(IssmDouble* pvalue,GaussTria* gauss){*pvalue=this->value;}
    124 /*}}}*/
    125 /*FUNCTION DoubleInput::GetInputValue(IssmDouble* pvalue,GaussPenta* gauss){{{*/
    126 void DoubleInput::GetInputValue(IssmDouble* pvalue,GaussPenta* gauss){*pvalue=this->value;}
     122/*FUNCTION DoubleInput::GetInputValue(IssmDouble* pvalue,Gauss* gauss){{{*/
     123void DoubleInput::GetInputValue(IssmDouble* pvalue,Gauss* gauss){*pvalue=this->value;}
    127124/*}}}*/
    128125/*FUNCTION DoubleInput::GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussTria* gauss){{{*/

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

    r16486 r16675  
    4646                void GetInputValue(int* pvalue);
    4747                void GetInputValue(IssmDouble* pvalue);
    48                 void GetInputValue(IssmDouble* pvalue,GaussSeg* gauss){_error_("not implemented yet");};
    49                 void GetInputValue(IssmDouble* pvalue,GaussTria* gauss);
    50                 void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss);
    51                 void GetInputValue(IssmDouble* pvalue,GaussTria* gauss,IssmDouble time){_error_("not implemented yet");};
    52                 void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss,IssmDouble time){_error_("not implemented yet");};
    53                 void GetInputValue(IssmDouble* pvalue,GaussTria* gauss ,int index){_error_("not implemented yet");};
    54                 void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss ,int index){_error_("not implemented yet");};
     48                void GetInputValue(IssmDouble* pvalue,Gauss* gauss);
     49                void GetInputValue(IssmDouble* pvalue,Gauss* gauss,IssmDouble time){_error_("not implemented yet");};
     50                void GetInputValue(IssmDouble* pvalue,Gauss* gauss ,int index){_error_("not implemented yet");};
    5551                void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussSeg* gauss){_error_("not implemented yet");};
    5652                void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussTria* gauss);

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

    r16486 r16675  
    1111#include "../../shared/shared.h"
    1212class Node;
     13class Gauss;
    1314class GaussTria;
    1415class GaussSeg;
    … …  
    2829                virtual void GetInputValue(int* pvalue)=0;
    2930                virtual void GetInputValue(IssmDouble* pvalue)=0;
    30                 virtual void GetInputValue(IssmDouble* pvalue,GaussSeg* gauss)=0;
    31                 virtual void GetInputValue(IssmDouble* pvalue,GaussTria* gauss)=0;
    32                 virtual void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss)=0;
    33                 virtual void GetInputValue(IssmDouble* pvalue,GaussTria* gauss,IssmDouble time)=0;
    34                 virtual void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss,IssmDouble time)=0;
    35                 virtual void GetInputValue(IssmDouble* pvalue,GaussTria* gauss ,int index)=0;
    36                 virtual void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss,int index)=0;
     31                virtual void GetInputValue(IssmDouble* pvalue,Gauss* gauss)=0;
     32                virtual void GetInputValue(IssmDouble* pvalue,Gauss* gauss,IssmDouble time)=0;
     33                virtual void GetInputValue(IssmDouble* pvalue,Gauss* gauss,int index)=0;
    3734                virtual void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussSeg* gauss)=0;
    3835                virtual void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussTria* gauss)=0;

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

    r16656 r16675  
    112112}
    113113/*}}}*/
    114 /*FUNCTION IntInput::GetInputValue(IssmDouble* pvalue,GaussTria* gauss){{{*/
    115 void IntInput::GetInputValue(IssmDouble* pvalue,GaussTria* gauss){_error_("not supported yet!");}
    116 /*}}}*/
    117 /*FUNCTION IntInput::GetInputValue(IssmDouble* pvalue,GaussPenta* gauss){{{*/
    118 void IntInput::GetInputValue(IssmDouble* pvalue,GaussPenta* gauss){_error_("not supported yet!");}
     114/*FUNCTION IntInput::GetInputValue(IssmDouble* pvalue,Gauss* gauss){{{*/
     115void IntInput::GetInputValue(IssmDouble* pvalue,Gauss* gauss){_error_("not supported yet!");}
    119116/*}}}*/
    120117/*FUNCTION IntInput::GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussTria* gauss){{{*/

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

    r16486 r16675  
    4747                void GetInputValue(int* pvalue);
    4848                void GetInputValue(IssmDouble* pvalue);
    49                 void GetInputValue(IssmDouble* pvalue,GaussSeg* gauss){_error_("not implemented yet");};
    50                 void GetInputValue(IssmDouble* pvalue,GaussTria* gauss);
    51                 void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss);
    52                 void GetInputValue(IssmDouble* pvalue,GaussTria* gauss,IssmDouble time){_error_("not implemented yet");};
    53                 void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss,IssmDouble time){_error_("not implemented yet");};
    54                 void GetInputValue(IssmDouble* pvalue,GaussTria* gauss ,int index){_error_("not implemented yet");};
    55                 void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss ,int index){_error_("not implemented yet");};
     49                void GetInputValue(IssmDouble* pvalue,Gauss* gauss);
     50                void GetInputValue(IssmDouble* pvalue,Gauss* gauss,IssmDouble time){_error_("not implemented yet");};
     51                void GetInputValue(IssmDouble* pvalue,Gauss* gauss ,int index){_error_("not implemented yet");};
    5652                void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussSeg* gauss){_error_("not implemented yet");};
    5753                void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussTria* gauss);

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

    r16656 r16675  
    137137
    138138/*Object functions*/
    139 /*FUNCTION PentaInput::GetInputValue(IssmDouble* pvalue,GaussPenta* gauss){{{*/
    140 void PentaInput::GetInputValue(IssmDouble* pvalue,GaussPenta* gauss){
     139/*FUNCTION PentaInput::GetInputValue(IssmDouble* pvalue,Gauss* gauss){{{*/
     140void PentaInput::GetInputValue(IssmDouble* pvalue,Gauss* gauss){
    141141
    142142        /*Call PentaRef function*/
    143         PentaRef::GetInputValue(pvalue,&values[0],gauss);
     143        _assert_(gauss->Enum()==GaussPentaEnum);
     144        PentaRef::GetInputValue(pvalue,&values[0],(GaussPenta*)gauss);
    144145
    145146}

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

    r16486 r16675  
    4646                void GetInputValue(int* pvalue){_error_("not implemented yet");};
    4747                void GetInputValue(IssmDouble* pvalue){_error_("not implemented yet");};
    48                 void GetInputValue(IssmDouble* pvalue,GaussSeg* gauss){_error_("not implemented yet");};
    49                 void GetInputValue(IssmDouble* pvalue,GaussTria* gauss){_error_("not implemented yet");};
    50                 void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss);
    51                 void GetInputValue(IssmDouble* pvalue,GaussTria* gauss,IssmDouble time){_error_("not implemented yet");};
    52                 void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss,IssmDouble time){_error_("not implemented yet");};
    53                 void GetInputValue(IssmDouble* pvalue,GaussTria* gauss ,int index){_error_("not implemented yet");};
    54                 void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss ,int index){_error_("not implemented yet");};
     48                void GetInputValue(IssmDouble* pvalue,Gauss* gauss);
     49                void GetInputValue(IssmDouble* pvalue,Gauss* gauss,IssmDouble time){_error_("not implemented yet");};
     50                void GetInputValue(IssmDouble* pvalue,Gauss* gauss ,int index){_error_("not implemented yet");};
    5551                void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussSeg* gauss){_error_("not implemented yet");};
    5652                void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussTria* gauss){_error_("not implemented yet");};

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

    r16656 r16675  
    9696}
    9797/*}}}*/
    98 /*FUNCTION SegInput::GetInputValue(IssmDouble* pvalue,GaussSeg* gauss){{{*/
    99 void SegInput::GetInputValue(IssmDouble* pvalue,GaussSeg* gauss){
     98/*FUNCTION SegInput::GetInputValue(IssmDouble* pvalue,Gauss* gauss){{{*/
     99void SegInput::GetInputValue(IssmDouble* pvalue,Gauss* gauss){
    100100
    101101        /*Call SegRef function*/
    102         SegRef::GetInputValue(pvalue,&values[0],gauss);
     102        _assert_(gauss->Enum()==GaussSegEnum);
     103        SegRef::GetInputValue(pvalue,&values[0],(GaussSeg*)gauss);
    103104
    104105}

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

    r16486 r16675  
    4747                void GetInputValue(int* pvalue){_error_("not implemented yet");}
    4848                void GetInputValue(IssmDouble* pvalue){_error_("not implemented yet");}
    49                 void GetInputValue(IssmDouble* pvalue,GaussSeg* gauss);
     49                void GetInputValue(IssmDouble* pvalue,Gauss* gauss);
    5050                void GetInputValue(IssmDouble* pvalue,GaussTria* gauss){_error_("not implemented yet");};
    51                 void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss){_error_("not implemented yet");};
    52                 void GetInputValue(IssmDouble* pvalue,GaussTria* gauss,IssmDouble time){_error_("not implemented yet");};
    53                 void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss,IssmDouble time){_error_("not implemented yet");};
    54                 void GetInputValue(IssmDouble* pvalue,GaussTria* gauss ,int index){_error_("not implemented yet");};
    55                 void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss,int index){_error_("not implemented yet");};
     51                void GetInputValue(IssmDouble* pvalue,Gauss* gauss,IssmDouble time){_error_("not implemented yet");};
     52                void GetInputValue(IssmDouble* pvalue,Gauss* gauss ,int index){_error_("not implemented yet");};
    5653                void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussSeg* gauss);
    5754                void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussTria* gauss){_error_("not implemented yet");};

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

    r16486 r16675  
    149149
    150150/*Object functions*/
    151 /*FUNCTION TransientInput::GetInputValue(IssmDouble* pvalue,GaussTria* gauss){{{*/
    152 void TransientInput::GetInputValue(IssmDouble* pvalue,GaussTria* gauss){
     151/*FUNCTION TransientInput::GetInputValue(IssmDouble* pvalue,Gauss* gauss){{{*/
     152void TransientInput::GetInputValue(IssmDouble* pvalue,Gauss* gauss){
    153153        IssmDouble time;
    154154
    … …  
    165165}
    166166/*}}}*/
    167 /*FUNCTION TransientInput::GetInputValue(IssmDouble* pvalue,GaussPenta* gauss){{{*/
    168 void TransientInput::GetInputValue(IssmDouble* pvalue,GaussPenta* gauss){
    169         IssmDouble time;
    170 
    171         /*First, recover current time from parameters: */
    172         this->parameters->FindParam(&time,TimeEnum);
    173 
    174         /*Retrieve interpolated values for this time step: */
    175         Input* input=GetTimeInput(time);
    176 
    177         /*Call input function*/
    178         input->GetInputValue(pvalue,gauss);
    179 
    180         delete input;
    181 }
    182 /*}}}*/
    183 /*FUNCTION TransientInput::GetInputValue(IssmDouble* pvalue,GaussTria* gauss,IssmDouble time){{{*/
    184 void TransientInput::GetInputValue(IssmDouble* pvalue,GaussTria* gauss,IssmDouble time){
    185 
    186         /*Retrieve interpolated values for this time step: */
    187         Input* input=GetTimeInput(time);
    188 
    189         /*Call input function*/
    190         input->GetInputValue(pvalue,gauss);
    191 
    192         delete input;
    193 }
    194 /*}}}*/
    195 /*FUNCTION TransientInput::GetInputValue(IssmDouble* pvalue,GaussPenta* gauss,IssmDouble time){{{*/
    196 void TransientInput::GetInputValue(IssmDouble* pvalue,GaussPenta* gauss,IssmDouble time){
     167/*FUNCTION TransientInput::GetInputValue(IssmDouble* pvalue,Gauss* gauss,IssmDouble time){{{*/
     168void TransientInput::GetInputValue(IssmDouble* pvalue,Gauss* gauss,IssmDouble time){
    197169
    198170        /*Retrieve interpolated values for this time step: */

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

    r16486 r16675  
    5050                void GetInputValue(int* pvalue){_error_("not implemented yet");};
    5151                void GetInputValue(IssmDouble* pvalue){_error_("not implemented yet");};
    52                 void GetInputValue(IssmDouble* pvalue,GaussSeg* gauss){_error_("not implemented yet");};
    53                 void GetInputValue(IssmDouble* pvalue,GaussTria* gauss);
    54                 void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss);
    55                 void GetInputValue(IssmDouble* pvalue,GaussTria* gauss,IssmDouble time);
    56                 void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss,IssmDouble time);
    57                 void GetInputValue(IssmDouble* pvalue,GaussTria* gauss ,int index){_error_("not implemented yet");};
    58                 void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss ,int index){_error_("not implemented yet");};
     52                void GetInputValue(IssmDouble* pvalue,Gauss* gauss);
     53                void GetInputValue(IssmDouble* pvalue,Gauss* gauss,IssmDouble time);
     54                void GetInputValue(IssmDouble* pvalue,Gauss* gauss ,int index){_error_("not implemented yet");};
    5955                void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussSeg* gauss){_error_("not implemented yet");};
    6056                void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussTria* gauss);

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

    r16656 r16675  
    124124
    125125/*Object functions*/
    126 /*FUNCTION TriaInput::GetInputValue(IssmDouble* pvalue,GaussTria* gauss){{{*/
    127 void TriaInput::GetInputValue(IssmDouble* pvalue,GaussTria* gauss){
     126/*FUNCTION TriaInput::GetInputValue(IssmDouble* pvalue,Gauss* gauss){{{*/
     127void TriaInput::GetInputValue(IssmDouble* pvalue,Gauss* gauss){
    128128
    129129        /*Call TriaRef function*/
    130         TriaRef::GetInputValue(pvalue,&values[0],gauss);
     130        _assert_(gauss->Enum()==GaussTriaEnum);
     131        TriaRef::GetInputValue(pvalue,&values[0],(GaussTria*)gauss);
    131132
    132133}

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

    r16486 r16675  
    4747                void GetInputValue(int* pvalue){_error_("not implemented yet");}
    4848                void GetInputValue(IssmDouble* pvalue){_error_("not implemented yet");}
    49                 void GetInputValue(IssmDouble* pvalue,GaussSeg* gauss){_error_("not implemented yet");};
    50                 void GetInputValue(IssmDouble* pvalue,GaussTria* gauss);
    51                 void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss){_error_("not implemented yet");};
    52                 void GetInputValue(IssmDouble* pvalue,GaussTria* gauss,IssmDouble time){_error_("not implemented yet");};
    53                 void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss,IssmDouble time){_error_("not implemented yet");};
    54                 void GetInputValue(IssmDouble* pvalue,GaussTria* gauss ,int index){_error_("not implemented yet");};
    55                 void GetInputValue(IssmDouble* pvalue,GaussPenta* gauss,int index){_error_("not implemented yet");};
     49                void GetInputValue(IssmDouble* pvalue,Gauss* gauss);
     50                void GetInputValue(IssmDouble* pvalue,Gauss* gauss,IssmDouble time){_error_("not implemented yet");};
     51                void GetInputValue(IssmDouble* pvalue,Gauss* gauss,int index){_error_("not implemented yet");};
    5652                void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussSeg* gauss){_error_("not implemented yet");};
    5753                void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussTria* gauss);

  • issm/trunk-jpl/src/c/classes/gauss/GaussPenta.cpp

    r16233 r16675  
    495495}
    496496/*}}}*/
     497/*FUNCTION GaussPenta::Enum{{{*/
     498int GaussPenta::Enum(void){
     499        return GaussPentaEnum;
     500}
     501/*}}}*/
    497502/*FUNCTION GaussPenta::GaussPoint{{{*/
    498503void GaussPenta::GaussPoint(int ig){

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

    r16233 r16675  
    88/*Headers:*/
    99#include "../../shared/Numerics/types.h"
     10#include "./Gauss.h"
    1011class GaussTria;
    1112
    12 class GaussPenta{
     13class GaussPenta: public Gauss{
    1314
    1415        private:
    … …  
    4344                int  end(void);
    4445                void Echo(void);
     46                int  Enum(void);
    4547                void GaussPoint(int ig);
    4648                void GaussVertex(int iv);

  • issm/trunk-jpl/src/c/classes/gauss/GaussSeg.cpp

    r16440 r16675  
    7070}
    7171/*}}}*/
     72/*FUNCTION GaussSeg::Enum{{{*/
     73int GaussSeg::Enum(void){
     74        return GaussSegEnum;
     75}
     76/*}}}*/
    7277/*FUNCTION GaussSeg::GaussPoint{{{*/
    7378void GaussSeg::GaussPoint(int ig){
    … …  
    7984         weight=weights[ig];
    8085         coord1=coords1[ig];
     86}
     87/*}}}*/
     88/*FUNCTION GaussSeg::GaussVertex{{{*/
     89void GaussSeg::GaussVertex(int iv){
     90
     91        _error_("not supported");
     92}
     93/*}}}*/
     94/*FUNCTION GaussSeg::GaussNode{{{*/
     95void GaussSeg::GaussNode(int finiteelement,int iv){
     96
     97        _error_("not supported");
     98
    8199}
    82100/*}}}*/

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

    r16376 r16675  
    88/*Headers:*/
    99#include "../../shared/Numerics/types.h"
     10#include "./Gauss.h"
    1011
    11 class GaussSeg{
     12class GaussSeg: public Gauss{
    1213
    1314        private:
    … …  
    3031                int  end(void);
    3132                void Echo(void);
     33                int  Enum(void);
    3234                void GaussPoint(int ig);
     35                void GaussVertex(int iv);
     36                void GaussNode(int finitelement,int iv);
    3337};
    3438#endif

  • issm/trunk-jpl/src/c/classes/gauss/GaussTria.cpp

    r16233 r16675  
    339339        _printf_("   coord3 = " << coord3 << "\n");
    340340
     341}
     342/*}}}*/
     343/*FUNCTION GaussTria::Enum{{{*/
     344int GaussTria::Enum(void){
     345        return GaussTriaEnum;
    341346}
    342347/*}}}*/

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

    r16233 r16675  
    88/*Headers:*/
    99#include "../../shared/Numerics/types.h"
     10#include "./Gauss.h"
    1011
    11 class GaussTria{
     12class GaussTria: public Gauss{
    1213
    1314        private:
    … …  
    3839                int  end(void);
    3940                void Echo(void);
     41                int  Enum(void);
    4042                void GaussFromCoords(IssmDouble x1,IssmDouble y1,IssmDouble* xyz_list);
    4143                void GaussPoint(int ig);

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

    r16376 r16675  
    66#define ALL_GAUSS_OBJECTS_H_
    77
     8#include "./Gauss.h"
    89#include "./GaussSeg.h"
    910#include "./GaussTria.h"

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

    r15849 r16675  
    1111        /*intermediary: */
    1212        int      gsize;
    13         Element* element = NULL;
    14 
    15         int configuration_type;
     13        int      configuration,analysisenum;
    1614
    1715        /*output: */
    … …  
    2119
    2220        /*retrive parameters: */
    23         femmodel->parameters->FindParam(&configuration_type,ConfigurationTypeEnum);
     21        femmodel->parameters->FindParam(&configuration,ConfigurationTypeEnum);
     22        femmodel->parameters->FindParam(&analysisenum,AnalysisTypeEnum);
    2423
    2524        /*Get size of vector: */
    26         gsize=femmodel->nodes->NumberOfDofs(configuration_type,GsetEnum);
    27         if(gsize==0) _error_("Allocating a Vec of size 0 as gsize=0 for configuration: " << EnumToStringx(configuration_type));
     25        gsize=femmodel->nodes->NumberOfDofs(configuration,GsetEnum);
     26        if(gsize==0) _error_("Allocating a Vec of size 0 as gsize=0 for configuration "<<EnumToStringx(configuration));
    2827
    2928        /*Initialize solution: */
    … …  
    3130
    3231        /*Go through elements and plug solution: */
     32        Analysis* analysis = EnumToAnalysis(analysisenum);
    3333        for(int i=0;i<femmodel->elements->Size();i++){
    34                 element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
    35                 element->GetSolutionFromInputs(solution);
     34                Element* element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
     35                analysis->GetSolutionFromInputs(solution,element);
    3636        }
     37        delete analysis;
    3738
    3839        /*Assemble vector: */

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

    r15849 r16675  
    77
    88#include "../../classes/classes.h"
     9#include "../../analyses/analyses.h"
    910
    1011/* local prototypes: */

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

    r16669 r16675  
    580580        QmuMaskGroundediceLevelsetEnum,
    581581        /*}}}*/
     582        /*Gauss{{{*/
     583        GaussSegEnum,
     584        GaussTriaEnum,
     585        GaussPentaEnum,
     586        /*}}}*/
    582587        /*Solver{{{*/
    583588        FSSolverEnum,

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

    r16669 r16675  
    561561                case MaskGroundediceLevelsetEnum : return "MaskGroundediceLevelset";
    562562                case QmuMaskGroundediceLevelsetEnum : return "QmuMaskGroundediceLevelset";
     563                case GaussSegEnum : return "GaussSeg";
     564                case GaussTriaEnum : return "GaussTria";
     565                case GaussPentaEnum : return "GaussPenta";
    563566                case FSSolverEnum : return "FSSolver";
    564567                case AdjointEnum : return "Adjoint";

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

    r16669 r16675  
    573573              else if (strcmp(name,"MaskGroundediceLevelset")==0) return MaskGroundediceLevelsetEnum;
    574574              else if (strcmp(name,"QmuMaskGroundediceLevelset")==0) return QmuMaskGroundediceLevelsetEnum;
     575              else if (strcmp(name,"GaussSeg")==0) return GaussSegEnum;
     576              else if (strcmp(name,"GaussTria")==0) return GaussTriaEnum;
     577              else if (strcmp(name,"GaussPenta")==0) return GaussPentaEnum;
    575578              else if (strcmp(name,"FSSolver")==0) return FSSolverEnum;
    576579              else if (strcmp(name,"Adjoint")==0) return AdjointEnum;

  • issm/trunk-jpl/src/c/toolkits/objects/Matrix.h

    r15238 r16675  
    1616#include <cstring>
    1717#include "../../shared/Enum/Enum.h"
     18#include "../petsc/petscincludes.h"
    1819#include "../issm/issmtoolkit.h"
    1920/*}}}*/

  • issm/trunk-jpl/src/c/toolkits/objects/Solver.h

    r15051 r16675  
    1414#include "./Vector.h"
    1515#include "../issm/issmtoolkit.h"
     16#include "../petsc/petscincludes.h"
    1617class Parameters;
    1718

  • issm/trunk-jpl/src/c/toolkits/objects/Vector.h

    r15051 r16675  
    1616#include <cstring>
    1717#include "../../shared/Enum/Enum.h"
     18#include "../petsc/petscincludes.h"
    1819#include "../issm/issmtoolkit.h"
    1920/*}}}*/
Note: See TracChangeset for help on using the changeset viewer.