Changeset 17493


Ignore:
Timestamp:
03/20/14 05:57:57 (11 years ago)
Author:
Mathieu Morlighem
Message:

CHG: working on MINI elements FS

Location:
issm/trunk-jpl/src/c
Files:
5 edited

Legend:

Unmodified
Added
Removed

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

    r17472 r17493  
    422422                        iomodel->FetchData(&nodeonbed,NULL,NULL,MeshVertexonbedEnum);
    423423                        iomodel->FetchData(&groundedice_ls,NULL,NULL,MaskGroundediceLevelsetEnum);
    424                         if(iomodel->meshtype==Mesh3DEnum){
     424                        if(iomodel->meshtype==Mesh3DEnum || iomodel->meshtype==Mesh3DtetrasEnum){
    425425                                iomodel->FetchData(&spcvz,&Mz,&Nz,StressbalanceSpcvzEnum);
    426426                        }
    … …  
    431431                                _error_("not supported yet");
    432432                        }
    433                         if(iomodel->meshtype==Mesh3DEnum){
     433                        if(iomodel->meshtype==Mesh3DEnum || iomodel->meshtype==Mesh3DtetrasEnum){
    434434                                IoModelToConstraintsx(constraints,iomodel,StressbalanceSpcvxEnum,StressbalanceAnalysisEnum,finiteelement,1);
    435435                                IoModelToConstraintsx(constraints,iomodel,StressbalanceSpcvyEnum,StressbalanceAnalysisEnum,finiteelement,2);
    … …  
    511511        iomodel->FetchData(&spcvz,&Mz,&Nz,StressbalanceSpcvzEnum);
    512512        iomodel->FetchData(&nodeonSSA,NULL,NULL,FlowequationBorderSSAEnum);
    513         if(iomodel->meshtype==Mesh3DEnum)iomodel->FetchData(&nodeonHO,NULL,NULL,FlowequationBorderHOEnum);
    514         if(iomodel->meshtype==Mesh3DEnum)iomodel->FetchData(&nodeonFS,NULL,NULL,FlowequationBorderFSEnum);
    515         if(iomodel->meshtype==Mesh3DEnum)iomodel->FetchData(&nodeonbed,NULL,NULL,MeshVertexonbedEnum);
    516         if(iomodel->meshtype==Mesh3DEnum)iomodel->FetchData(&groundedice_ls,NULL,NULL,MaskGroundediceLevelsetEnum);
     513        if(iomodel->meshtype==Mesh3DEnum || iomodel->meshtype==Mesh3DtetrasEnum)iomodel->FetchData(&nodeonHO,NULL,NULL,FlowequationBorderHOEnum);
     514        if(iomodel->meshtype==Mesh3DEnum || iomodel->meshtype==Mesh3DtetrasEnum)iomodel->FetchData(&nodeonFS,NULL,NULL,FlowequationBorderFSEnum);
     515        if(iomodel->meshtype==Mesh3DEnum || iomodel->meshtype==Mesh3DtetrasEnum)iomodel->FetchData(&nodeonbed,NULL,NULL,MeshVertexonbedEnum);
     516        if(iomodel->meshtype==Mesh3DEnum || iomodel->meshtype==Mesh3DtetrasEnum)iomodel->FetchData(&groundedice_ls,NULL,NULL,MaskGroundediceLevelsetEnum);
    517517        iomodel->FetchData(&vertices_type,NULL,NULL,FlowequationVertexEquationEnum);
    518518        iomodel->FetchData(&surface,NULL,NULL,SurfaceEnum);
    … …  
    741741        iomodel->DeleteData(spcvz,StressbalanceSpcvzEnum);
    742742        iomodel->DeleteData(nodeonSSA,FlowequationBorderSSAEnum);
    743         if(iomodel->meshtype==Mesh3DEnum)iomodel->DeleteData(nodeonHO,FlowequationBorderHOEnum);
    744         if(iomodel->meshtype==Mesh3DEnum)iomodel->DeleteData(nodeonFS,FlowequationBorderFSEnum);
    745         if(iomodel->meshtype==Mesh3DEnum)iomodel->DeleteData(nodeonbed,MeshVertexonbedEnum);
    746         if(iomodel->meshtype==Mesh3DEnum)iomodel->DeleteData(groundedice_ls,MaskGroundediceLevelsetEnum);
     743        if(iomodel->meshtype==Mesh3DEnum || iomodel->meshtype==Mesh3DtetrasEnum)iomodel->DeleteData(nodeonHO,FlowequationBorderHOEnum);
     744        if(iomodel->meshtype==Mesh3DEnum || iomodel->meshtype==Mesh3DtetrasEnum)iomodel->DeleteData(nodeonFS,FlowequationBorderFSEnum);
     745        if(iomodel->meshtype==Mesh3DEnum || iomodel->meshtype==Mesh3DtetrasEnum)iomodel->DeleteData(nodeonbed,MeshVertexonbedEnum);
     746        if(iomodel->meshtype==Mesh3DEnum || iomodel->meshtype==Mesh3DtetrasEnum)iomodel->DeleteData(groundedice_ls,MaskGroundediceLevelsetEnum);
    747747        iomodel->DeleteData(vertices_type,FlowequationVertexEquationEnum);
    748748        iomodel->DeleteData(surface,SurfaceEnum);

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

    r17491 r17493  
    238238int Tetra::GetNumberOfVertices(void){
    239239        return NUMVERTICES;
     240}
     241/*}}}*/
     242/*FUNCTION Tetra::GetNumberOfNodesPressure         THIS ONE (and corresponding TetraRef function){{{*/
     243int Tetra::GetNumberOfNodesPressure(void){
     244        return this->NumberofNodesPressure();
     245}
     246/*}}}*/
     247/*FUNCTION Tetra::GetNumberOfNodesVelocity;{{{*/
     248int Tetra::GetNumberOfNodesVelocity(void){
     249        return this->NumberofNodesVelocity();
    240250}
    241251/*}}}*/
    … …  
    548558}
    549559/*}}}*/
     560/*FUNCTION Tetra::NodalFunctionsVelocity{{{*/
     561void Tetra::NodalFunctionsVelocity(IssmDouble* basis, Gauss* gauss){
     562
     563        _assert_(gauss->Enum()==GaussTetraEnum);
     564        this->GetNodalFunctionsVelocity(basis,(GaussTetra*)gauss);
     565
     566}
     567/*}}}*/
     568/*FUNCTION Tetra::NodalFunctionsPressure{{{*/
     569void Tetra::NodalFunctionsPressure(IssmDouble* basis, Gauss* gauss){
     570
     571        _assert_(gauss->Enum()==GaussTetraEnum);
     572        this->GetNodalFunctionsPressure(basis,(GaussTetra*)gauss);
     573
     574}
     575/*}}}*/
    550576/*FUNCTION Tetra::NodalFunctionsDerivatives{{{*/
    551577void Tetra::NodalFunctionsDerivatives(IssmDouble* dbasis,IssmDouble* xyz_list,Gauss* gauss){
    … …  
    553579        _assert_(gauss->Enum()==GaussTetraEnum);
    554580        this->GetNodalFunctionsDerivatives(dbasis,xyz_list,(GaussTetra*)gauss);
     581
     582}
     583/*}}}*/
     584/*FUNCTION Tetra::NodalFunctionsDerivativesVelocity{{{*/
     585void Tetra::NodalFunctionsDerivativesVelocity(IssmDouble* dbasis,IssmDouble* xyz_list,Gauss* gauss){
     586
     587        _assert_(gauss->Enum()==GaussTetraEnum);
     588        this->GetNodalFunctionsDerivativesVelocity(dbasis,xyz_list,(GaussTetra*)gauss);
    555589
    556590}
    … …  
    575609
    576610        for(int i=0;i<3;i++) normal[i]=normal[i]/norm;
     611}
     612/*}}}*/
     613/*FUNCTION Tetra::NumberofNodesPressure{{{*/
     614int Tetra::NumberofNodesPressure(void){
     615        return TetraRef::NumberofNodesPressure();
     616}
     617/*}}}*/
     618/*FUNCTION Tetra::NumberofNodesVelocity{{{*/
     619int Tetra::NumberofNodesVelocity(void){
     620        return TetraRef::NumberofNodesVelocity();
    577621}
    578622/*}}}*/
    … …  
    752796                        tetra_node_ids[9]=iomodel->nodecounter+iomodel->numberofvertices+iomodel->elementtoedgeconnectivity[6*index+5]+1;
    753797                        break;
     798                case MINIEnum: case MINIcondensedEnum:
     799                        numnodes         = 9;
     800                        tetra_node_ids   = xNew<int>(numnodes);
     801                        tetra_node_ids[0]=iomodel->nodecounter+iomodel->elements[4*index+0];
     802                        tetra_node_ids[1]=iomodel->nodecounter+iomodel->elements[4*index+1];
     803                        tetra_node_ids[2]=iomodel->nodecounter+iomodel->elements[4*index+2];
     804                        tetra_node_ids[3]=iomodel->nodecounter+iomodel->elements[4*index+3];
     805                        tetra_node_ids[4]=iomodel->nodecounter+iomodel->numberofvertices+index+1;
     806
     807                        tetra_node_ids[5]=iomodel->nodecounter+iomodel->numberofvertices+iomodel->numberofelements+iomodel->elements[4*index+0];
     808                        tetra_node_ids[6]=iomodel->nodecounter+iomodel->numberofvertices+iomodel->numberofelements+iomodel->elements[4*index+1];
     809                        tetra_node_ids[7]=iomodel->nodecounter+iomodel->numberofvertices+iomodel->numberofelements+iomodel->elements[4*index+2];
     810                        tetra_node_ids[8]=iomodel->nodecounter+iomodel->numberofvertices+iomodel->numberofelements+iomodel->elements[4*index+3];
     811                        break;
     812                        numnodes        = 14;
     813                        tetra_node_ids   = xNew<int>(numnodes);
     814                        tetra_node_ids[0]=iomodel->nodecounter+iomodel->elements[4*index+0];
     815                        tetra_node_ids[1]=iomodel->nodecounter+iomodel->elements[4*index+1];
     816                        tetra_node_ids[2]=iomodel->nodecounter+iomodel->elements[4*index+2];
     817                        tetra_node_ids[3]=iomodel->nodecounter+iomodel->elements[4*index+3];
     818                        tetra_node_ids[4]=iomodel->nodecounter+iomodel->numberofvertices+iomodel->elementtoedgeconnectivity[6*index+0]+1;
     819                        tetra_node_ids[5]=iomodel->nodecounter+iomodel->numberofvertices+iomodel->elementtoedgeconnectivity[6*index+1]+1;
     820                        tetra_node_ids[6]=iomodel->nodecounter+iomodel->numberofvertices+iomodel->elementtoedgeconnectivity[6*index+2]+1;
     821                        tetra_node_ids[7]=iomodel->nodecounter+iomodel->numberofvertices+iomodel->elementtoedgeconnectivity[6*index+3]+1;
     822                        tetra_node_ids[8]=iomodel->nodecounter+iomodel->numberofvertices+iomodel->elementtoedgeconnectivity[6*index+4]+1;
     823                        tetra_node_ids[9]=iomodel->nodecounter+iomodel->numberofvertices+iomodel->elementtoedgeconnectivity[6*index+5]+1;
     824
     825                        tetra_node_ids[10]=iomodel->nodecounter+iomodel->numberofvertices+iomodel->numberofedges+iomodel->elements[4*index+0];
     826                        tetra_node_ids[11]=iomodel->nodecounter+iomodel->numberofvertices+iomodel->numberofedges+iomodel->elements[4*index+1];
     827                        tetra_node_ids[12]=iomodel->nodecounter+iomodel->numberofvertices+iomodel->numberofedges+iomodel->elements[4*index+2];
     828                        tetra_node_ids[13]=iomodel->nodecounter+iomodel->numberofvertices+iomodel->numberofedges+iomodel->elements[4*index+3];
     829                        break;
    754830                default:
    755831                        _error_("Finite element "<<EnumToStringx(finiteelement_type)<<" not supported yet");

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

    r17472 r17493  
    8181                int         GetNodeIndex(Node* node){_error_("not implemented yet");};
    8282                int         GetNumberOfNodes(void);
    83                 int         GetNumberOfNodesVelocity(void){_error_("not implemented yet");};
    84                 int         GetNumberOfNodesPressure(void){_error_("not implemented yet");};
     83                int         GetNumberOfNodesVelocity(void);
     84                int         GetNumberOfNodesPressure(void);
    8585                int         GetNumberOfVertices(void);
    8686                void        GetVerticesCoordinatesBase(IssmDouble** pxyz_list);
    … …  
    100100                void        NodalFunctions(IssmDouble* basis,Gauss* gauss);
    101101                void        NodalFunctionsP1(IssmDouble* basis,Gauss* gauss){_error_("not implemented yet");};
    102                 void        NodalFunctionsVelocity(IssmDouble* basis,Gauss* gauss){_error_("not implemented yet");};
    103                 void        NodalFunctionsPressure(IssmDouble* basis,Gauss* gauss){_error_("not implemented yet");};
     102                void        NodalFunctionsVelocity(IssmDouble* basis,Gauss* gauss);
     103                void        NodalFunctionsPressure(IssmDouble* basis,Gauss* gauss);
    104104                void        NodalFunctionsDerivatives(IssmDouble* dbasis,IssmDouble* xyz_list,Gauss* gauss);
    105105                void        NodalFunctionsP1Derivatives(IssmDouble* dbasis,IssmDouble* xyz_list,Gauss* gauss){_error_("not implemented yet");};
    106106                void        NodalFunctionsMINIDerivatives(IssmDouble* dbasis,IssmDouble* xyz_list,Gauss* gauss){_error_("not implemented yet");};
    107                 void        NodalFunctionsDerivativesVelocity(IssmDouble* dbasis,IssmDouble* xyz_list,Gauss* gauss){_error_("not implemented yet");};
     107                void        NodalFunctionsDerivativesVelocity(IssmDouble* dbasis,IssmDouble* xyz_list,Gauss* gauss);
    108108                bool        IsIceInElement();
    109109                void        NormalSection(IssmDouble* normal,IssmDouble* xyz_list);
    110110                void        NormalTop(IssmDouble* normal,IssmDouble* xyz_list){_error_("not implemented yet");};
    111111                void        NormalBase(IssmDouble* normal,IssmDouble* xyz_list){_error_("not implemented yet");};
    112                 int         NumberofNodesVelocity(void){_error_("not implemented yet");};
    113                 int         NumberofNodesPressure(void){_error_("not implemented yet");};
     112                int         NumberofNodesVelocity(void);
     113                int         NumberofNodesPressure(void);
    114114           Element*    SpawnBasalElement(void){_error_("not implemented yet");};
    115115                Element*    SpawnTopElement(void){_error_("not implemented yet");};

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

    r17490 r17493  
    102102}
    103103/*}}}*/
     104/*FUNCTION TetraRef::GetNodalFunctionsVelocity{{{*/
     105void TetraRef::GetNodalFunctionsVelocity(IssmDouble* basis,GaussTetra* gauss){
     106        /*This routine returns the values of the nodal functions  at the gaussian point.*/
     107
     108        switch(this->element_type){
     109                case P1P1Enum:
     110                        this->element_type = P1Enum;
     111                        this->GetNodalFunctions(basis,gauss);
     112                        this->element_type = P1P1Enum;
     113                        return;
     114                case P1P1GLSEnum:
     115                        this->element_type = P1Enum;
     116                        this->GetNodalFunctions(basis,gauss);
     117                        this->element_type = P1P1GLSEnum;
     118                        return;
     119                case MINIcondensedEnum:
     120                        this->element_type = P1bubbleEnum;
     121                        this->GetNodalFunctions(basis,gauss);
     122                        this->element_type = MINIcondensedEnum;
     123                        return;
     124                case MINIEnum:
     125                        this->element_type = P1bubbleEnum;
     126                        this->GetNodalFunctions(basis,gauss);
     127                        this->element_type = MINIEnum;
     128                        return;
     129                case TaylorHoodEnum:
     130                        this->element_type = P2Enum;
     131                        this->GetNodalFunctions(basis,gauss);
     132                        this->element_type = TaylorHoodEnum;
     133                        return;
     134                default:
     135                        _error_("Element type "<<EnumToStringx(this->element_type)<<" not supported yet");
     136        }
     137}
     138/*}}}*/
     139/*FUNCTION TetraRef::GetNodalFunctionsPressure{{{*/
     140void TetraRef::GetNodalFunctionsPressure(IssmDouble* basis,GaussTetra* gauss){
     141        /*This routine returns the values of the nodal functions  at the gaussian point.*/
     142
     143        switch(this->element_type){
     144                case P1P1Enum:
     145                        this->element_type = P1Enum;
     146                        this->GetNodalFunctions(basis,gauss);
     147                        this->element_type = P1P1Enum;
     148                        return;
     149                case P1P1GLSEnum:
     150                        this->element_type = P1Enum;
     151                        this->GetNodalFunctions(basis,gauss);
     152                        this->element_type = P1P1GLSEnum;
     153                        return;
     154                case MINIcondensedEnum:
     155                        this->element_type = P1Enum;
     156                        this->GetNodalFunctions(basis,gauss);
     157                        this->element_type = MINIcondensedEnum;
     158                        return;
     159                case MINIEnum:
     160                        this->element_type = P1Enum;
     161                        this->GetNodalFunctions(basis,gauss);
     162                        this->element_type = MINIEnum;
     163                        return;
     164                case TaylorHoodEnum:
     165                        this->element_type = P1Enum;
     166                        this->GetNodalFunctions(basis,gauss);
     167                        this->element_type = TaylorHoodEnum;
     168                        return;
     169                default:
     170                        _error_("Element type "<<EnumToStringx(this->element_type)<<" not supported yet");
     171        }
     172}
     173/*}}}*/
    104174/*FUNCTION TetraRef::GetNodalFunctionsDerivatives(IssmDouble* dbasis,IssmDouble* xyz_list, GaussTetra* gauss){{{*/
    105175void TetraRef::GetNodalFunctionsDerivatives(IssmDouble* dbasis,IssmDouble* xyz_list, GaussTetra* gauss){
    … …  
    139209        /*Clean up*/
    140210        xDelete<IssmDouble>(dbasis_ref);
     211}
     212/*}}}*/
     213/*FUNCTION TetraRef::GetNodalFunctionsDerivativesPressure         (THIS ONE and following ones){{{*/
     214void TetraRef::GetNodalFunctionsDerivativesPressure(IssmDouble* dbasis,IssmDouble* xyz_list, GaussTetra* gauss){
     215        switch(this->element_type){
     216                case P1P1Enum:
     217                        this->element_type = P1Enum;
     218                        this->GetNodalFunctionsDerivatives(dbasis,xyz_list,gauss);
     219                        this->element_type = P1P1Enum;
     220                        return;
     221                case P1P1GLSEnum:
     222                        this->element_type = P1Enum;
     223                        this->GetNodalFunctionsDerivatives(dbasis,xyz_list,gauss);
     224                        this->element_type = P1P1GLSEnum;
     225                        return;
     226                case MINIcondensedEnum:
     227                        this->element_type = P1Enum;
     228                        this->GetNodalFunctionsDerivatives(dbasis,xyz_list,gauss);
     229                        this->element_type = MINIcondensedEnum;
     230                        return;
     231                case MINIEnum:
     232                        this->element_type = P1Enum;
     233                        this->GetNodalFunctionsDerivatives(dbasis,xyz_list,gauss);
     234                        this->element_type = MINIEnum;
     235                        return;
     236                case TaylorHoodEnum:
     237                        this->element_type = P1Enum;
     238                        this->GetNodalFunctionsDerivatives(dbasis,xyz_list,gauss);
     239                        this->element_type = TaylorHoodEnum;
     240                        return;
     241                default:
     242                        _error_("Element type "<<EnumToStringx(this->element_type)<<" not supported yet");
     243        }
     244}
     245/*}}}*/
     246/*FUNCTION TetraRef::GetNodalFunctionsDerivativesVelocity{{{*/
     247void TetraRef::GetNodalFunctionsDerivativesVelocity(IssmDouble* dbasis,IssmDouble* xyz_list, GaussTetra* gauss){
     248        switch(this->element_type){
     249                case P1P1Enum:
     250                        this->element_type = P1Enum;
     251                        this->GetNodalFunctionsDerivatives(dbasis,xyz_list,gauss);
     252                        this->element_type = P1P1Enum;
     253                        return;
     254                case P1P1GLSEnum:
     255                        this->element_type = P1Enum;
     256                        this->GetNodalFunctionsDerivatives(dbasis,xyz_list,gauss);
     257                        this->element_type = P1P1GLSEnum;
     258                        return;
     259                case MINIcondensedEnum:
     260                        this->element_type = P1bubbleEnum;
     261                        this->GetNodalFunctionsDerivatives(dbasis,xyz_list,gauss);
     262                        this->element_type = MINIcondensedEnum;
     263                        return;
     264                case MINIEnum:
     265                        this->element_type = P1bubbleEnum;
     266                        this->GetNodalFunctionsDerivatives(dbasis,xyz_list,gauss);
     267                        this->element_type = MINIEnum;
     268                        return;
     269                case TaylorHoodEnum:
     270                        this->element_type = P2Enum;
     271                        this->GetNodalFunctionsDerivatives(dbasis,xyz_list,gauss);
     272                        this->element_type = TaylorHoodEnum;
     273                        return;
     274                default:
     275                        _error_("Element type "<<EnumToStringx(this->element_type)<<" not supported yet");
     276        }
    141277}
    142278/*}}}*/
    … …  
    415551}
    416552/*}}}*/
     553/*FUNCTION TetraRef::NumberofNodesPressure{{{*/
     554int TetraRef::NumberofNodesPressure(void){
     555
     556        switch(this->element_type){
     557                case P1P1Enum:          return NUMNODESP1;
     558                case P1P1GLSEnum:       return NUMNODESP1;
     559                case MINIcondensedEnum: return NUMNODESP1;
     560                case MINIEnum:          return NUMNODESP1;
     561                case TaylorHoodEnum:    return NUMNODESP1;
     562                default: _error_("Element type "<<EnumToStringx(this->element_type)<<" not supported yet");
     563        }
     564
     565        return -1;
     566}
     567/*}}}*/
     568/*FUNCTION TetraRef::NumberofNodesVelocity{{{*/
     569int TetraRef::NumberofNodesVelocity(void){
     570
     571        switch(this->element_type){
     572                case P1P1Enum:          return NUMNODESP1;
     573                case P1P1GLSEnum:       return NUMNODESP1;
     574                case MINIcondensedEnum: return NUMNODESP1b;
     575                case MINIEnum:          return NUMNODESP1b;
     576                case TaylorHoodEnum:    return NUMNODESP2;
     577                default:       _error_("Element type "<<EnumToStringx(this->element_type)<<" not supported yet");
     578        }
     579
     580        return -1;
     581}
     582/*}}}*/
     583/*FUNCTION TetraRef::VelocityInterpolation{{{*/
     584int TetraRef::VelocityInterpolation(void){
     585
     586        switch(this->element_type){
     587                case P1P1Enum:          return P1Enum;
     588                case P1P1GLSEnum:       return P1Enum;
     589                case MINIcondensedEnum: return P1bubbleEnum;
     590                case MINIEnum:          return P1bubbleEnum;
     591                case TaylorHoodEnum:    return P2Enum;
     592                default:       _error_("Element type "<<EnumToStringx(this->element_type)<<" not supported yet");
     593        }
     594
     595        return -1;
     596}
     597/*}}}*/
     598/*FUNCTION TetraRef::PressureInterpolation{{{*/
     599int TetraRef::PressureInterpolation(void){
     600
     601        switch(this->element_type){
     602                case P1P1Enum:          return P1Enum;
     603                case P1P1GLSEnum:       return P1Enum;
     604                case MINIcondensedEnum: return P1Enum;
     605                case MINIEnum:          return P1Enum;
     606                case TaylorHoodEnum:    return P1Enum;
     607                default:       _error_("Element type "<<EnumToStringx(this->element_type)<<" not supported yet");
     608        }
     609
     610        return -1;
     611}
     612/*}}}*/

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

    r17472 r17493  
    2929                void GetNodalFunctions(IssmDouble* basis,GaussTetra* gauss);
    3030                void GetNodalFunctions(IssmDouble* basis,GaussTetra* gauss,int finiteelement);
     31                void GetNodalFunctionsVelocity(IssmDouble* basis, GaussTetra* gauss);
     32                void GetNodalFunctionsPressure(IssmDouble* basis, GaussTetra* gauss);
    3133                void GetNodalFunctionsDerivatives(IssmDouble* dbasis,IssmDouble* xyz_list, GaussTetra* gauss);
    3234                void GetNodalFunctionsDerivatives(IssmDouble* dbasis,IssmDouble* xyz_list, GaussTetra* gauss,int finiteelement);
     35                void GetNodalFunctionsDerivativesVelocity(IssmDouble* dbasis,IssmDouble* xyz_list,GaussTetra* gauss);
     36                void GetNodalFunctionsDerivativesPressure(IssmDouble* dbasis,IssmDouble* xyz_list,GaussTetra* gauss);
    3337                void GetNodalFunctionsDerivativesReference(IssmDouble* dbasis,GaussTetra* gauss);
    3438                void GetNodalFunctionsDerivativesReference(IssmDouble* dbasis,GaussTetra* gauss,int finiteelement);
    … …  
    3943                int  NumberofNodes(void);
    4044                int  NumberofNodes(int finiteelement);
     45                int  NumberofNodesVelocity(void);
     46                int  NumberofNodesPressure(void);
     47                int  VelocityInterpolation(void);
     48                int  PressureInterpolation(void);
    4149};
    4250#endif
Note: See TracChangeset for help on using the changeset viewer.