Changeset 24434


Ignore:
Timestamp:
12/05/19 11:30:04 (5 years ago)
Author:
Mathieu Morlighem
Message:

CHG: speeding up code by reducing constant allocation of Gauss points

Location:
issm/trunk-jpl/src/c/classes/Elements
Files:
10 edited

Legend:

Unmodified
Added
Removed

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

    r24431 r24434  
    11081108/*}}}*/
    11091109void       Element::GetInputListOnNodes(IssmDouble* pvalue,int enumtype,IssmDouble defaultvalue){/*{{{*/
    1110 
    1111         _assert_(pvalue);
    1112 
    11131110        Input2 *input    = this->GetInput2(enumtype);
    1114         int    numnodes = this->GetNumberOfNodes();
    1115 
    1116         /* Start looping on the number of vertices: */
    1117         if(input){
    1118                 Gauss* gauss=this->NewGauss();
    1119                 for(int iv=0;iv<numnodes;iv++){
    1120                         gauss->GaussNode(this->FiniteElement(),iv);
    1121                         input->GetInputValue(&pvalue[iv],gauss);
    1122                 }
    1123                 delete gauss;
    1124         }
    1125         else{
    1126                 for(int iv=0;iv<numnodes;iv++) pvalue[iv]=defaultvalue;
    1127         }
     1111        this->GetInputListOnNodes(pvalue,input,defaultvalue);
    11281112}
    11291113/*}}}*/
    11301114void       Element::GetInputListOnNodes(IssmDouble* pvalue,int enumtype){/*{{{*/
    11311115
    1132         _assert_(pvalue);
    1133 
    1134         int     numnodes = this->GetNumberOfNodes();
    11351116        Input2 *input    = this->GetInput2(enumtype);
    11361117        if(!input) _error_("Input " << EnumToStringx(enumtype) << " not found in element");
    1137 
    1138         /* Start looping on the number of vertices: */
    1139         Gauss* gauss=this->NewGauss();
    1140         for(int iv=0;iv<numnodes;iv++){
    1141                 gauss->GaussNode(this->FiniteElement(),iv);
    1142                 input->GetInputValue(&pvalue[iv],gauss);
    1143         }
    1144         delete gauss;
     1118        this->GetInputListOnNodes(pvalue,input,0.);
     1119
    11451120}
    11461121/*}}}*/
    … …  
    11621137}
    11631138/*}}}*/
    1164 void       Element::GetInputListOnVertices(IssmDouble* pvalue,ElementInput2* input){/*{{{*/
    1165 
    1166         /*Fetch number vertices for this element*/
    1167         const int NUM_VERTICES = this->GetNumberOfVertices();
    1168 
    1169         /*Checks in debugging mode*/
    1170         _assert_(input);
    1171         _assert_(pvalue);
    1172 
    1173         /* Start looping on the number of vertices: */
    1174         Gauss*gauss=this->NewGauss();
    1175         for(int iv=0;iv<NUM_VERTICES;iv++){
    1176                 gauss->GaussVertex(iv);
    1177                 input->GetInputValue(&pvalue[iv],gauss);
    1178         }
    1179         delete gauss;
    1180 }
    1181 /*}}}*/
    11821139void       Element::GetInputListOnVertices(IssmDouble* pvalue,int enumtype){/*{{{*/
    1183 
    1184         /*Fetch number vertices for this element*/
    1185         const int NUM_VERTICES = this->GetNumberOfVertices();
    1186 
    1187         /*Checks in debugging mode*/
    1188         _assert_(pvalue);
    11891140
    11901141        /*Recover input*/
    11911142        Input2* input2=this->GetInput2(enumtype);
    11921143        if(!input2) _error_("input "<<EnumToStringx(enumtype)<<" not found in element");
    1193         /* Start looping on the number of vertices: */
    1194         Gauss*gauss=this->NewGauss();
    1195         for(int iv=0;iv<NUM_VERTICES;iv++){
    1196                 gauss->GaussVertex(iv);
    1197                 input2->GetInputValue(&pvalue[iv],gauss);
    1198         }
    1199         delete gauss;
     1144        this->GetInputListOnVertices(pvalue,input2,0.);
    12001145}
    12011146/*}}}*/
    … …  
    12051150        Input2* input=this->GetInput2(enumtype,time);
    12061151        if (!input) _error_("Input " << EnumToStringx(enumtype) << " not found in element");
    1207 
    1208         /*Fetch number vertices for this element*/
    1209         const int NUM_VERTICES = this->GetNumberOfVertices();
    1210 
    1211         /*Checks in debugging mode*/
    1212         _assert_(pvalue);
    1213 
    1214         /* Start looping on the number of vertices: */
    1215         Gauss*gauss=this->NewGauss();
    1216         for(int iv=0;iv<NUM_VERTICES;iv++){
    1217                 gauss->GaussVertex(iv);
    1218                 input->GetInputValue(&pvalue[iv],gauss);
    1219         }
    1220 
    1221         /*clean-up*/
    1222         delete gauss;
     1152        this->GetInputListOnVertices(pvalue,input,0.);
    12231153}
    12241154/*}}}*/
    12251155void       Element::GetInputListOnVertices(IssmDouble* pvalue,int enumtype,IssmDouble defaultvalue){/*{{{*/
    1226 
    1227         /*Recover input*/
    12281156        Input2* input=this->GetInput2(enumtype);
    1229 
    1230         /*Checks in debugging mode*/
    1231         _assert_(pvalue);
    1232 
    1233         /*Fetch number vertices for this element*/
    1234         const int NUM_VERTICES = this->GetNumberOfVertices();
    1235 
    1236         /* Start looping on the number of vertices: */
    1237         if (input){
    1238                 Gauss* gauss=this->NewGauss();
    1239                 for (int iv=0;iv<NUM_VERTICES;iv++){
    1240                         gauss->GaussVertex(iv);
    1241                         input->GetInputValue(&pvalue[iv],gauss);
    1242                 }
    1243                 delete gauss;
    1244         }
    1245         else{
    1246                 for(int iv=0;iv<NUM_VERTICES;iv++) pvalue[iv]=defaultvalue;
    1247         }
     1157        this->GetInputListOnVertices(pvalue,input,defaultvalue);
    12481158}
    12491159/*}}}*/

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

    r24431 r24434  
    9494                void               GetInputListOnNodes(IssmDouble* pvalue,int enumtype,IssmDouble defaultvalue);
    9595                void               GetInputListOnNodesVelocity(IssmDouble* pvalue,int enumtype);
    96                 void               GetInputListOnVertices(IssmDouble* pvalue,ElementInput2* input);
    9796                void               GetInputListOnVertices(IssmDouble* pvalue,int enumtype);
    9897                void               GetInputListOnVerticesAtTime(IssmDouble* pvalue,int enumtype,IssmDouble time);
    … …  
    253252                virtual void       GetInputValue(IssmDouble* pvalue,Vertex* vertex,int enumtype){_error_("not implemented yet");};
    254253                virtual void       GetInputValue(IssmDouble* pvalue,Node* node,int enumtype){_error_("not implemented yet");};
     254                virtual void       GetInputListOnVertices(IssmDouble* pvalue,Input2* input,IssmDouble default_value)=0;
     255                virtual void       GetInputListOnNodes(IssmDouble* pvalue,Input2* input,IssmDouble default_value)=0;
    255256                virtual void       GetLevelCoordinates(IssmDouble** pxyz_front,IssmDouble* xyz_list,int levelsetenum,IssmDouble level)=0;
    256257                virtual void       GetLevelsetPositivePart(int* point1,IssmDouble* fraction1,IssmDouble* fraction2, bool* mainlynegative,IssmDouble* levelsetvalues)=0;

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

    r24426 r24434  
    432432
    433433                /*Recover parameters and values*/
    434                 GetInputListOnVertices(&gl[0],MaskIceLevelsetEnum);
     434                Element::GetInputListOnVertices(&gl[0],MaskIceLevelsetEnum);
    435435
    436436                /*Be sure that values are not zero*/
    … …  
    554554
    555555                /*Recover parameters and values*/
    556                 GetInputListOnVertices(&gl[0],MaskIceLevelsetEnum);
     556                Element::GetInputListOnVertices(&gl[0],MaskIceLevelsetEnum);
    557557
    558558                /*Be sure that values are not zero*/
    … …  
    985985        /*Get current field and vertex coordinates*/
    986986        IssmDouble ls[NUMVERTICES],distance;
    987         GetInputListOnVertices(&ls[0],distanceenum);
     987        Element::GetInputListOnVertices(&ls[0],distanceenum);
    988988
    989989        /*Get distance from list of segments and reset ls*/
    … …  
    11101110        IssmDouble  sigmayz[NUMVERTICES],sigmaxz[NUMVERTICES],sigma_nn[NUMVERTICES];
    11111111        IssmDouble  viscosity,epsilon[NUMVERTICES];
    1112         GetInputListOnVertices(&base[0],BaseEnum);
    1113         GetInputListOnVertices(&bed[0],BedEnum);
    1114         GetInputListOnVertices(&surface[0],SurfaceEnum);
    1115         GetInputListOnVertices(&pressure[0],PressureEnum);
    1116         GetInputListOnVertices(&phi[0],MaskGroundediceLevelsetEnum);
     1112        Element::GetInputListOnVertices(&base[0],BaseEnum);
     1113        Element::GetInputListOnVertices(&bed[0],BedEnum);
     1114        Element::GetInputListOnVertices(&surface[0],SurfaceEnum);
     1115        Element::GetInputListOnVertices(&pressure[0],PressureEnum);
     1116        Element::GetInputListOnVertices(&phi[0],MaskGroundediceLevelsetEnum);
    11171117        IssmDouble rho_ice   = FindParam(MaterialsRhoIceEnum);
    11181118        IssmDouble rho_water = FindParam(MaterialsRhoSeawaterEnum);
    … …  
    12531253
    12541254        /*Recover parameters and values*/
    1255         GetInputListOnVertices(&gl[0],MaskGroundediceLevelsetEnum);
     1255        Element::GetInputListOnVertices(&gl[0],MaskGroundediceLevelsetEnum);
    12561256
    12571257        /*Be sure that values are not zero*/
    … …  
    13071307
    13081308        /*Recover parameters and values*/
    1309         GetInputListOnVertices(&gl[0],MaskGroundediceLevelsetEnum);
     1309        Element::GetInputListOnVertices(&gl[0],MaskGroundediceLevelsetEnum);
    13101310
    13111311        /*Be sure that values are not zero*/
    … …  
    14131413
    14141414        /*Retrieve all inputs and parameters*/
    1415         GetInputListOnVertices(&bed[0],BedEnum);
    1416         GetInputListOnVertices(&surfaces[0],SurfaceEnum);
    1417         GetInputListOnVertices(&bases[0],BaseEnum);
    1418         GetInputListOnVertices(&lsf[0],MaskIceLevelsetEnum);
     1415        Element::GetInputListOnVertices(&bed[0],BedEnum);
     1416        Element::GetInputListOnVertices(&surfaces[0],SurfaceEnum);
     1417        Element::GetInputListOnVertices(&bases[0],BaseEnum);
     1418        Element::GetInputListOnVertices(&lsf[0],MaskIceLevelsetEnum);
    14191419
    14201420        nrfrontbed=0;
    … …  
    15081508
    15091509        /*Recover parameters and values*/
    1510         GetInputListOnVertices(&levelset[0],levelsetenum);
     1510        Element::GetInputListOnVertices(&levelset[0],levelsetenum);
    15111511
    15121512        int* indicesfront = xNew<int>(NUMVERTICES);
    … …  
    15961596        return input;
    15971597}/*}}}*/
     1598void       Penta::GetInputListOnVertices(IssmDouble* pvalue,Input2* input,IssmDouble default_value){/*{{{*/
     1599
     1600        /*Checks in debugging mode*/
     1601        _assert_(pvalue);
     1602
     1603        /* Start looping on the number of vertices: */
     1604        if(input){
     1605                GaussPenta gauss;
     1606                for(int iv=0;iv<NUMVERTICES;iv++){
     1607                        gauss.GaussVertex(iv);
     1608                        input->GetInputValue(&pvalue[iv],&gauss);
     1609                }
     1610        }
     1611        else{
     1612                for(int iv=0;iv<NUMVERTICES;iv++) pvalue[iv] = default_value;
     1613        }
     1614}
     1615/*}}}*/
     1616void       Penta::GetInputListOnNodes(IssmDouble* pvalue,Input2* input,IssmDouble default_value){/*{{{*/
     1617
     1618        /*Checks in debugging mode*/
     1619        _assert_(pvalue);
     1620
     1621        /*What type of finite element are we dealing with?*/
     1622        int fe       = this->FiniteElement();
     1623        int numnodes = this->GetNumberOfNodes();
     1624
     1625        /* Start looping on the number of vertices: */
     1626        if(input){
     1627                GaussPenta gauss;
     1628                for(int iv=0;iv<numnodes;iv++){
     1629                        gauss.GaussNode(fe,iv);
     1630                        input->GetInputValue(&pvalue[iv],&gauss);
     1631                }
     1632        }
     1633        else{
     1634                for(int iv=0;iv<numnodes;iv++) pvalue[iv] = default_value;
     1635        }
     1636}
     1637/*}}}*/
    15981638DatasetInput2* Penta::GetDatasetInput2(int inputenum){/*{{{*/
    15991639
    … …  
    16751715
    16761716        /*Retrieve all inputs and parameters*/
    1677         GetInputListOnVertices(&lsf[0],levelset_enum);
     1717        Element::GetInputListOnVertices(&lsf[0],levelset_enum);
    16781718
    16791719        /* Determine distribution of ice over element.
    … …  
    19111951
    19121952        /*Recover parameters and values*/
    1913         GetInputListOnVertices(&gl[0],MaskGroundediceLevelsetEnum);
     1953        Element::GetInputListOnVertices(&gl[0],MaskGroundediceLevelsetEnum);
    19141954
    19151955        /*Be sure that values are not zero*/
    … …  
    20302070
    20312071        /*Recover parameters and values*/
    2032         GetInputListOnVertices(&gl[0],MaskIceLevelsetEnum);
     2072        Element::GetInputListOnVertices(&gl[0],MaskIceLevelsetEnum);
    20332073
    20342074        /*Be sure that values are not zero*/
    … …  
    22912331                        /*Extrude values first*/
    22922332                        IssmDouble extrudedvalues[NUMVERTICES];
    2293                         this->GetInputListOnVertices(&extrudedvalues[0],pentainput);
     2333                        this->GetInputListOnVertices(&extrudedvalues[0],pentainput,0.);
    22942334
    22952335                        if(start==-1){
    … …  
    23592399                IssmDouble extrudedvalues3[NUMVERTICES];
    23602400
    2361                 this->GetInputListOnVertices(&extrudedvalues[0],pentainput);
    2362                 this->GetInputListOnVertices(&extrudedvalues2[0],pentainput2);
    2363                 this->GetInputListOnVertices(&extrudedvalues3[0],pentainput3);
     2401                this->GetInputListOnVertices(&extrudedvalues[0],pentainput,0.);
     2402                this->GetInputListOnVertices(&extrudedvalues2[0],pentainput2,0.);
     2403                this->GetInputListOnVertices(&extrudedvalues3[0],pentainput3,0.);
    23642404
    23652405                if(start==-1){
    … …  
    24252465                IssmDouble extrudedvalues[NUMVERTICES];
    24262466
    2427                 this->GetInputListOnVertices(&extrudedvalues[0],enum_type);
     2467                Element::GetInputListOnVertices(&extrudedvalues[0],enum_type);
    24282468                if(start==-1){
    24292469                        for(int i=0;i<NUMVERTICES2D;i++) extrudedvalues[i+NUMVERTICES2D]=extrudedvalues[i];
    … …  
    26282668
    26292669        /*Retrieve all inputs and parameters*/
    2630         GetInputListOnVertices(&ls[0],MaskIceLevelsetEnum);
     2670        Element::GetInputListOnVertices(&ls[0],MaskIceLevelsetEnum);
    26312671
    26322672        /* If only one vertex has ice, there is an ice front here */
    … …  
    26602700
    26612701        /*Retrieve all inputs and parameters*/
    2662         GetInputListOnVertices(&ls[0],levelset_enum);
     2702        Element::GetInputListOnVertices(&ls[0],levelset_enum);
    26632703
    26642704        /*If the level set has always same sign, there is no ice front here*/
    … …  
    30113051        rho_ice=FindParam(MaterialsRhoIceEnum);
    30123052        density=rho_ice/rho_water;
    3013         GetInputListOnVertices(&h[0],ThicknessEnum);
    3014         GetInputListOnVertices(&r[0],BedEnum);
    3015         GetInputListOnVertices(&gl[0],MaskGroundediceLevelsetEnum);
     3053        Element::GetInputListOnVertices(&h[0],ThicknessEnum);
     3054        Element::GetInputListOnVertices(&r[0],BedEnum);
     3055        Element::GetInputListOnVertices(&gl[0],MaskGroundediceLevelsetEnum);
    30163056
    30173057        /*go through vertices, and figure out which ones are on the ice sheet, and want to unground: */
    … …  
    31873227        Input2* qsg_input = this->GetInput2(FrontalForcingsSubglacialDischargeEnum);             _assert_(qsg_input);
    31883228        Input2* TF_input  = this->GetInput2(FrontalForcingsThermalForcingEnum);          _assert_(TF_input);
    3189         GetInputListOnVertices(&basinid[0],FrontalForcingsBasinIdEnum);
     3229        Element::GetInputListOnVertices(&basinid[0],FrontalForcingsBasinIdEnum);
    31903230
    31913231        this->FindParam(&yts, ConstantsYtsEnum);
    … …  
    37503790
    37513791        /*Recover parameters and values*/
    3752         GetInputListOnVertices(&gl[0],MaskIceLevelsetEnum);
     3792        Element::GetInputListOnVertices(&gl[0],MaskIceLevelsetEnum);
    37533793
    37543794        /*Be sure that values are not zero*/
    … …  
    38683908
    38693909        /*Recover parameters and values*/
    3870         GetInputListOnVertices(&gl[0],MaskIceLevelsetEnum);
     3910        Element::GetInputListOnVertices(&gl[0],MaskIceLevelsetEnum);
    38713911
    38723912        /*Be sure that values are not zero*/
    … …  
    47354775
    47364776                                        /*retrieve inputs: */
    4737                                         GetInputListOnVertices(&thickness_init[0],ThicknessEnum);
    4738                                         GetInputListOnVertices(&hydrostatic_ratio[0],GeometryHydrostaticRatioEnum);
    4739                                         GetInputListOnVertices(&bed[0],BaseEnum);
    4740                                         GetInputListOnVertices(&surface[0],SurfaceEnum);
     4777                                        Element::GetInputListOnVertices(&thickness_init[0],ThicknessEnum);
     4778                                        Element::GetInputListOnVertices(&hydrostatic_ratio[0],GeometryHydrostaticRatioEnum);
     4779                                        Element::GetInputListOnVertices(&bed[0],BaseEnum);
     4780                                        Element::GetInputListOnVertices(&surface[0],SurfaceEnum);
    47414781
    47424782                                        /*build new thickness: */

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

    r24376 r24434  
    8585                Input2*        GetInput2(int enumtype);
    8686                Input2*        GetInput2(int enumtype,IssmDouble time);
     87                void        GetInputListOnVertices(IssmDouble* pvalue,Input2* input,IssmDouble default_value);
     88                void        GetInputListOnNodes(IssmDouble* pvalue,Input2* input,IssmDouble default_value);
    8789                DatasetInput2* GetDatasetInput2(int inputenum);
    8890                void           GetInputValue(IssmDouble* pvalue,Vertex* vertex,int enumtype);

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

    r24378 r24434  
    164164
    165165        /*Recover parameters and values*/
    166         GetInputListOnVertices(&levelset[0],levelsetenum);
     166        Element::GetInputListOnVertices(&levelset[0],levelsetenum);
     167
    167168        /* Get nodes where there is no ice */
    168169        nrfrontnodes=0;
    … …  
    263264
    264265        /*Recover parameters and values*/
    265         GetInputListOnVertices(&gl[0],MaskGroundediceLevelsetEnum);
     266        Element::GetInputListOnVertices(&gl[0],MaskGroundediceLevelsetEnum);
    266267
    267268        /*Be sure that values are not zero*/
    … …  
    300301
    301302}/*}}}*/
     303void       Seg::GetInputListOnVertices(IssmDouble* pvalue,Input2* input,IssmDouble default_value){/*{{{*/
     304
     305        /*Checks in debugging mode*/
     306        _assert_(pvalue);
     307
     308        /* Start looping on the number of vertices: */
     309        if(input){
     310                GaussSeg gauss;
     311                for(int iv=0;iv<NUMVERTICES;iv++){
     312                        gauss.GaussVertex(iv);
     313                        input->GetInputValue(&pvalue[iv],&gauss);
     314                }
     315        }
     316        else{
     317                for(int iv=0;iv<NUMVERTICES;iv++) pvalue[iv] = default_value;
     318        }
     319}
     320/*}}}*/
     321void       Seg::GetInputListOnNodes(IssmDouble* pvalue,Input2* input,IssmDouble default_value){/*{{{*/
     322
     323        /*Checks in debugging mode*/
     324        _assert_(pvalue);
     325
     326        /*What type of finite element are we dealing with?*/
     327        int fe       = this->FiniteElement();
     328        int numnodes = this->GetNumberOfNodes();
     329
     330        /* Start looping on the number of vertices: */
     331        if(input){
     332                GaussSeg gauss;
     333                for(int iv=0;iv<numnodes;iv++){
     334                        gauss.GaussNode(fe,iv);
     335                        input->GetInputValue(&pvalue[iv],&gauss);
     336                }
     337        }
     338        else{
     339                for(int iv=0;iv<numnodes;iv++) pvalue[iv] = default_value;
     340        }
     341}
     342/*}}}*/
    302343bool       Seg::IsIcefront(void){/*{{{*/
    303344
    … …  
    307348
    308349        /*Retrieve all inputs and parameters*/
    309         GetInputListOnVertices(&ls[0],MaskIceLevelsetEnum);
     350        Element::GetInputListOnVertices(&ls[0],MaskIceLevelsetEnum);
    310351
    311352        /* If only one vertex has ice, there is an ice front here */

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

    r24376 r24434  
    6565                Input2*     GetInput2(int enumtype);
    6666                Input2*     GetInput2(int enumtype,IssmDouble time);
     67                void        GetInputListOnVertices(IssmDouble* pvalue,Input2* input,IssmDouble default_value);
     68                void        GetInputListOnNodes(IssmDouble* pvalue,Input2* input,IssmDouble default_value);
    6769                void        GetInputValue(IssmDouble* pvalue,Vertex* vertex,int enumtype){_error_("not implemented yet");};
    6870                void               GetLevelCoordinates(IssmDouble** pxyz_front,IssmDouble* xyz_list,int levelsetenum,IssmDouble level){_error_("not implemented");};

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

    r24378 r24434  
    194194
    195195        /*Retrieve all inputs and parameters*/
    196         GetInputListOnVertices(&values[0],MeshVertexonbaseEnum);
     196        Element::GetInputListOnVertices(&values[0],MeshVertexonbaseEnum);
    197197
    198198        for(int i=0;i<4;i++){
    … …  
    214214
    215215        /*Retrieve all inputs and parameters*/
    216         GetInputListOnVertices(&values[0],MaskIceLevelsetEnum);
     216        Element::GetInputListOnVertices(&values[0],MaskIceLevelsetEnum);
    217217
    218218        for(int i=0;i<4;i++){
    … …  
    234234
    235235        /*Retrieve all inputs and parameters*/
    236         GetInputListOnVertices(&values[0],MeshVertexonsurfaceEnum);
     236        Element::GetInputListOnVertices(&values[0],MeshVertexonsurfaceEnum);
    237237
    238238        for(int i=0;i<4;i++){
    … …  
    263263        _error_("not implemented yet");
    264264}/*}}}*/
     265void       Tetra::GetInputListOnVertices(IssmDouble* pvalue,Input2* input,IssmDouble default_value){/*{{{*/
     266
     267        /*Checks in debugging mode*/
     268        _assert_(pvalue);
     269
     270        /* Start looping on the number of vertices: */
     271        if(input){
     272                GaussTetra gauss;
     273                for(int iv=0;iv<NUMVERTICES;iv++){
     274                        gauss.GaussVertex(iv);
     275                        input->GetInputValue(&pvalue[iv],&gauss);
     276                }
     277        }
     278        else{
     279                for(int iv=0;iv<NUMVERTICES;iv++) pvalue[iv] = default_value;
     280        }
     281}
     282/*}}}*/
     283void       Tetra::GetInputListOnNodes(IssmDouble* pvalue,Input2* input,IssmDouble default_value){/*{{{*/
     284
     285        /*Checks in debugging mode*/
     286        _assert_(pvalue);
     287
     288        /*What type of finite element are we dealing with?*/
     289        int fe       = this->FiniteElement();
     290        int numnodes = this->GetNumberOfNodes();
     291
     292        /* Start looping on the number of vertices: */
     293        if(input){
     294                GaussTetra gauss;
     295                for(int iv=0;iv<numnodes;iv++){
     296                        gauss.GaussNode(fe,iv);
     297                        input->GetInputValue(&pvalue[iv],&gauss);
     298                }
     299        }
     300        else{
     301                for(int iv=0;iv<numnodes;iv++) pvalue[iv] = default_value;
     302        }
     303}
     304/*}}}*/
    265305void     Tetra::GetInputValue(IssmDouble* pvalue,Node* node,int enumtype){/*{{{*/
    266306
    … …  
    323363
    324364        /*Retrieve all inputs and parameters*/
    325         GetInputListOnVertices(&values[0],MeshVertexonbaseEnum);
     365        Element::GetInputListOnVertices(&values[0],MeshVertexonbaseEnum);
    326366        sum = values[0]+values[1]+values[2]+values[3];
    327367
    … …  
    342382
    343383        /*Retrieve all inputs and parameters*/
    344         GetInputListOnVertices(&values[0],MeshVertexonsurfaceEnum);
     384        Element::GetInputListOnVertices(&values[0],MeshVertexonsurfaceEnum);
    345385        sum = values[0]+values[1]+values[2]+values[3];
    346386
    … …  
    413453        /*Retrieve all inputs and parameters*/
    414454        IssmDouble ls[NUMVERTICES];
    415         GetInputListOnVertices(&ls[0],MaskIceLevelsetEnum);
     455        Element::GetInputListOnVertices(&ls[0],MaskIceLevelsetEnum);
    416456
    417457        /* If only one vertex has ice, there is an ice front here */

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

    r24376 r24434  
    6969                Input2*     GetInput2(int enumtype);
    7070                Input2*     GetInput2(int enumtype,IssmDouble time);
     71                void        GetInputListOnVertices(IssmDouble* pvalue,Input2* input,IssmDouble default_value);
     72                void        GetInputListOnNodes(IssmDouble* pvalue,Input2* input,IssmDouble default_value);
    7173                void        GetInputValue(IssmDouble* pvalue,Node* node,int enumtype);
    7274                void               GetLevelCoordinates(IssmDouble** pxyz_front,IssmDouble* xyz_list,int levelsetenum,IssmDouble level){_error_("not implemented yet");};

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

    r24379 r24434  
    561561                /*Recover parameters and values*/
    562562                parameters->FindParam(&domaintype,DomainTypeEnum);
    563                 GetInputListOnVertices(&gl[0],MaskIceLevelsetEnum);
     563                Element::GetInputListOnVertices(&gl[0],MaskIceLevelsetEnum);
    564564
    565565                /*Be sure that values are not zero*/
    … …  
    698698                /*Recover parameters and values*/
    699699                parameters->FindParam(&domaintype,DomainTypeEnum);
    700                 GetInputListOnVertices(&gl[0],MaskIceLevelsetEnum);
     700                Element::GetInputListOnVertices(&gl[0],MaskIceLevelsetEnum);
    701701
    702702                /*Be sure that values are not zero*/
    … …  
    11691169        /*Get current field and vertex coordinates*/
    11701170        IssmDouble ls[NUMVERTICES],distance;
    1171         GetInputListOnVertices(&ls[0],distanceenum);
     1171        Element::GetInputListOnVertices(&ls[0],distanceenum);
    11721172
    11731173        /*Get distance from list of segments and reset ls*/
    … …  
    11971197
    11981198        /*Retrieve all inputs and parameters*/
    1199         GetInputListOnVertices(&values[0],MeshVertexonbaseEnum);
     1199        Element::GetInputListOnVertices(&values[0],MeshVertexonbaseEnum);
    12001200
    12011201        for(int i=0;i<3;i++){
    … …  
    12151215
    12161216        /*Retrieve all inputs and parameters*/
    1217         GetInputListOnVertices(&values[0],MeshVertexonbaseEnum);
     1217        Element::GetInputListOnVertices(&values[0],MeshVertexonbaseEnum);
    12181218
    12191219        for(int i=0;i<3;i++){
    … …  
    12351235
    12361236        /*Retrieve all inputs and parameters*/
    1237         GetInputListOnVertices(&values[0],MeshVertexonsurfaceEnum);
     1237        Element::GetInputListOnVertices(&values[0],MeshVertexonsurfaceEnum);
    12381238
    12391239        for(int i=0;i<3;i++){
    … …  
    12531253
    12541254        /*Retrieve all inputs and parameters*/
    1255         GetInputListOnVertices(&values[0],MeshVertexonsurfaceEnum);
     1255        Element::GetInputListOnVertices(&values[0],MeshVertexonsurfaceEnum);
    12561256
    12571257        for(int i=0;i<3;i++){
    … …  
    13601360        IssmDouble  sigmaxx[NUMVERTICES],sigmayy[NUMVERTICES],sigmaxy[NUMVERTICES],sigma_nn[NUMVERTICES];
    13611361        IssmDouble  viscosity,epsilon[NUMVERTICES];
    1362         GetInputListOnVertices(&base[0],BaseEnum);
    1363         GetInputListOnVertices(&bed[0],BedEnum);
    1364         GetInputListOnVertices(&surface[0],SurfaceEnum);
    1365         GetInputListOnVertices(&pressure[0],PressureEnum);
    1366         GetInputListOnVertices(&phi[0],MaskGroundediceLevelsetEnum);
     1362        Element::GetInputListOnVertices(&base[0],BaseEnum);
     1363        Element::GetInputListOnVertices(&bed[0],BedEnum);
     1364        Element::GetInputListOnVertices(&surface[0],SurfaceEnum);
     1365        Element::GetInputListOnVertices(&pressure[0],PressureEnum);
     1366        Element::GetInputListOnVertices(&phi[0],MaskGroundediceLevelsetEnum);
    13671367        IssmDouble rho_ice   = FindParam(MaterialsRhoIceEnum);
    13681368        IssmDouble rho_water = FindParam(MaterialsRhoSeawaterEnum);
    … …  
    15701570
    15711571        /*Recover parameters and values*/
    1572         GetInputListOnVertices(&gl[0],MaskGroundediceLevelsetEnum);
     1572        Element::GetInputListOnVertices(&gl[0],MaskGroundediceLevelsetEnum);
    15731573
    15741574        /*Be sure that values are not zero*/
    … …  
    16261626        /*Recover parameters and values*/
    16271627        parameters->FindParam(&domaintype,DomainTypeEnum);
    1628         GetInputListOnVertices(&gl[0],MaskGroundediceLevelsetEnum);
     1628        Element::GetInputListOnVertices(&gl[0],MaskGroundediceLevelsetEnum);
    16291629
    16301630        /*Be sure that values are not zero*/
    … …  
    17521752
    17531753        /*Retrieve all inputs and parameters*/
    1754         GetInputListOnVertices(&bed[0],BedEnum);
    1755         GetInputListOnVertices(&surfaces[0],SurfaceEnum);
    1756         GetInputListOnVertices(&bases[0],BaseEnum);
    1757         GetInputListOnVertices(&lsf[0],MaskIceLevelsetEnum);
     1754        Element::GetInputListOnVertices(&bed[0],BedEnum);
     1755        Element::GetInputListOnVertices(&surfaces[0],SurfaceEnum);
     1756        Element::GetInputListOnVertices(&bases[0],BaseEnum);
     1757        Element::GetInputListOnVertices(&lsf[0],MaskIceLevelsetEnum);
    17581758
    17591759        nrfrontbed=0;
    … …  
    18461846
    18471847        /*Recover parameters and values*/
    1848         GetInputListOnVertices(&levelset[0],levelsetenum);
     1848        Element::GetInputListOnVertices(&levelset[0],levelsetenum);
    18491849
    18501850        /* Get nodes where there is no ice */
    … …  
    19111911        }
    19121912}/*}}}*/
     1913void       Tria::GetInputListOnVertices(IssmDouble* pvalue,Input2* input,IssmDouble default_value){/*{{{*/
     1914
     1915        /*Checks in debugging mode*/
     1916        _assert_(pvalue);
     1917
     1918        /* Start looping on the number of vertices: */
     1919        if(input){
     1920                GaussTria gauss;
     1921                for(int iv=0;iv<NUMVERTICES;iv++){
     1922                        gauss.GaussVertex(iv);
     1923                        input->GetInputValue(&pvalue[iv],&gauss);
     1924                }
     1925        }
     1926        else{
     1927                for(int iv=0;iv<NUMVERTICES;iv++) pvalue[iv] = default_value;
     1928        }
     1929}
     1930/*}}}*/
     1931void       Tria::GetInputListOnNodes(IssmDouble* pvalue,Input2* input,IssmDouble default_value){/*{{{*/
     1932
     1933        /*Checks in debugging mode*/
     1934        _assert_(pvalue);
     1935
     1936        /*What type of finite element are we dealing with?*/
     1937        int fe       = this->FiniteElement();
     1938        int numnodes = this->GetNumberOfNodes();
     1939
     1940        /* Start looping on the number of vertices: */
     1941        if(input){
     1942                GaussTria gauss;
     1943                for(int iv=0;iv<numnodes;iv++){
     1944                        gauss.GaussNode(fe,iv);
     1945                        input->GetInputValue(&pvalue[iv],&gauss);
     1946                }
     1947        }
     1948        else{
     1949                for(int iv=0;iv<numnodes;iv++) pvalue[iv] = default_value;
     1950        }
     1951}
     1952/*}}}*/
    19131953void       Tria::InputServe(Input2* input_in){/*{{{*/
    19141954
    … …  
    22522292
    22532293        /*Recover parameters and values*/
    2254         GetInputListOnVertices(&levelset[0],levelsetenum);
     2294        Element::GetInputListOnVertices(&levelset[0],levelsetenum);
    22552295
    22562296        /* Get nodes where there is no ice */
    … …  
    22972337
    22982338        /*Retrieve all inputs and parameters*/
    2299         GetInputListOnVertices(&lsf[0],levelset_enum);
     2339        Element::GetInputListOnVertices(&lsf[0],levelset_enum);
    23002340
    23012341        /* Determine distribution of ice over element.
    … …  
    26022642
    26032643        /*Retrieve all inputs and parameters*/
    2604         GetInputListOnVertices(&values[0],MeshVertexonbaseEnum);
     2644        Element::GetInputListOnVertices(&values[0],MeshVertexonbaseEnum);
    26052645        sum = values[0]+values[1]+values[2];
    26062646
    … …  
    26232663
    26242664        /*Retrieve all inputs and parameters*/
    2625         GetInputListOnVertices(&values[0],MeshVertexonsurfaceEnum);
     2665        Element::GetInputListOnVertices(&values[0],MeshVertexonsurfaceEnum);
    26262666        sum = values[0]+values[1]+values[2];
    26272667
    … …  
    27142754        /*Recover parameters and values*/
    27152755        parameters->FindParam(&domaintype,DomainTypeEnum);
    2716         GetInputListOnVertices(&gl[0],MaskIceLevelsetEnum);
     2756        Element::GetInputListOnVertices(&gl[0],MaskIceLevelsetEnum);
    27172757
    27182758        /*Be sure that values are not zero*/
    … …  
    28432883        /*Recover parameters and values*/
    28442884        parameters->FindParam(&domaintype,DomainTypeEnum);
    2845         GetInputListOnVertices(&gl[0],MaskGroundediceLevelsetEnum);
     2885        Element::GetInputListOnVertices(&gl[0],MaskGroundediceLevelsetEnum);
    28462886
    28472887        /*Be sure that values are not zero*/
    … …  
    29793019                area_base=this->GetAreaIce();
    29803020                if(scaled==true){
    2981                         GetInputListOnVertices(&scalefactors[0],MeshScaleFactorEnum);
     3021                        Element::GetInputListOnVertices(&scalefactors[0],MeshScaleFactorEnum);
    29823022                        for(i=0;i<NUMVERTICES;i++) SFaux[i]= scalefactors[indices[i]]; //sort thicknesses in ice/noice
    29833023                        switch(numiceverts){
    … …  
    30023042                        area_base=area_base*scalefactor;
    30033043                }
    3004                 GetInputListOnVertices(&surfaces[0],SurfaceEnum);
    3005                 GetInputListOnVertices(&bases[0],BaseEnum);
     3044                Element::GetInputListOnVertices(&surfaces[0],SurfaceEnum);
     3045                Element::GetInputListOnVertices(&bases[0],BaseEnum);
    30063046                for(i=0;i<NUMVERTICES;i++) Haux[i]= surfaces[indices[i]]-bases[indices[i]]; //sort thicknesses in ice/noice
    30073047                switch(numiceverts){
    … …  
    32703310
    32713311        /*Retrieve all inputs and parameters*/
    3272         GetInputListOnVertices(&values[0],MeshVertexonboundaryEnum);
     3312        Element::GetInputListOnVertices(&values[0],MeshVertexonboundaryEnum);
    32733313        sum = values[0]+values[1]+values[2];
    32743314
    … …  
    32913331
    32923332        /*Retrieve all inputs and parameters*/
    3293         GetInputListOnVertices(&ls[0],MaskIceLevelsetEnum);
     3333        Element::GetInputListOnVertices(&ls[0],MaskIceLevelsetEnum);
    32943334
    32953335        /* If only one vertex has ice, there is an ice front here */
    … …  
    33233363
    33243364        /*Retrieve all inputs and parameters*/
    3325         GetInputListOnVertices(&ls[0],levelset_enum);
     3365        Element::GetInputListOnVertices(&ls[0],levelset_enum);
    33263366
    33273367        /*If the level set is awlays <0, there is no ice front here*/
    … …  
    37733813        rho_ice=FindParam(MaterialsRhoIceEnum);
    37743814        density=rho_ice/rho_water;
    3775         GetInputListOnVertices(&h[0],ThicknessEnum);
    3776         GetInputListOnVertices(&r[0],BedEnum);
    3777         GetInputListOnVertices(&gl[0],MaskGroundediceLevelsetEnum);
     3815        Element::GetInputListOnVertices(&h[0],ThicknessEnum);
     3816        Element::GetInputListOnVertices(&r[0],BedEnum);
     3817        Element::GetInputListOnVertices(&gl[0],MaskGroundediceLevelsetEnum);
    37783818
    37793819        /*go through vertices, and figure out which ones are grounded and want to unground: */
    … …  
    39153955        Input2* qsg_input = this->GetInput2(FrontalForcingsSubglacialDischargeEnum);             _assert_(qsg_input);
    39163956        Input2* TF_input  = this->GetInput2(FrontalForcingsThermalForcingEnum);          _assert_(TF_input);
    3917         GetInputListOnVertices(&basinid[0],FrontalForcingsBasinIdEnum);
     3957        Element::GetInputListOnVertices(&basinid[0],FrontalForcingsBasinIdEnum);
    39183958
    39193959        this->FindParam(&yts, ConstantsYtsEnum);
    … …  
    43264366        /*Recover parameters and values*/
    43274367        parameters->FindParam(&domaintype,DomainTypeEnum);
    4328         GetInputListOnVertices(&gl[0],MaskIceLevelsetEnum);
     4368        Element::GetInputListOnVertices(&gl[0],MaskIceLevelsetEnum);
    43294369
    43304370        /*Be sure that values are not zero*/
    … …  
    44554495        /*Recover parameters and values*/
    44564496        parameters->FindParam(&domaintype,DomainTypeEnum);
    4457         GetInputListOnVertices(&gl[0],MaskIceLevelsetEnum);
     4497        Element::GetInputListOnVertices(&gl[0],MaskIceLevelsetEnum);
    44584498
    44594499        /*Be sure that values are not zero*/
    … …  
    49364976        /*Get field on vertices (we do not allow for higher order elements!!)*/
    49374977        IssmDouble lsf[NUMVERTICES];
    4938         this->GetInputListOnVertices(&lsf[0],fieldenum);
     4978        Element::GetInputListOnVertices(&lsf[0],fieldenum);
    49394979
    49404980        /*1. check that we do cross fieldvalue in this element*/
    … …  
    61446184
    61456185                                        /*retrieve inputs: */
    6146                                         GetInputListOnVertices(&thickness_init[0],ThicknessEnum);
    6147                                         GetInputListOnVertices(&hydrostatic_ratio[0],GeometryHydrostaticRatioEnum);
    6148                                         GetInputListOnVertices(&bed[0],BaseEnum);
    6149                                         GetInputListOnVertices(&surface[0],SurfaceEnum);
     6186                                        Element::GetInputListOnVertices(&thickness_init[0],ThicknessEnum);
     6187                                        Element::GetInputListOnVertices(&hydrostatic_ratio[0],GeometryHydrostaticRatioEnum);
     6188                                        Element::GetInputListOnVertices(&bed[0],BaseEnum);
     6189                                        Element::GetInputListOnVertices(&surface[0],SurfaceEnum);
    61506190
    61516191                                        /*build new bed and surface: */

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

    r24376 r24434  
    8484                IssmDouble  GetIcefrontArea();
    8585                void          GetIcefrontCoordinates(IssmDouble** pxyz_front,IssmDouble* xyz_list,int levelsetenum);
     86                void        GetInputListOnVertices(IssmDouble* pvalue,Input2* input,IssmDouble default_value);
     87                void        GetInputListOnNodes(IssmDouble* pvalue,Input2* input,IssmDouble default_value);
    8688                void          GetLevelCoordinates(IssmDouble** pxyz_front,IssmDouble* xyz_list,int levelsetenum,IssmDouble level);
    8789                int         GetVertexIndex(Vertex* vertex);
Note: See TracChangeset for help on using the changeset viewer.