Changeset 5659


Ignore:
Timestamp:
09/03/10 07:46:16 (15 years ago)
Author:
Mathieu Morlighem
Message:

Simplified MaxVx, MaxVy, MinVel... -> Min is now a method of Inputs

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

Legend:

Unmodified
Added
Removed

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

    r5640 r5659  
    411411}
    412412/*}}}*/
     413/*FUNCTION Inputs::Max{{{1*/
     414double Inputs::Max(int enumtype){
     415
     416        /*Output*/
     417        double max;
     418
     419        /*Get input*/
     420        Input* input=(Input*)this->GetInput(enumtype);
     421
     422        /*Apply ContrainMin: */
     423        if (input){
     424                max=input->Max();
     425        }
     426        else{
     427                ISSMERROR("Input %s not found",EnumToString(enumtype));
     428        }
     429
     430        /*Return output*/
     431        return max;
     432}
     433/*}}}*/
     434/*FUNCTION Inputs::MaxAbs{{{1*/
     435double Inputs::MaxAbs(int enumtype){
     436
     437        /*Output*/
     438        double max;
     439
     440        /*Get input*/
     441        Input* input=(Input*)this->GetInput(enumtype);
     442
     443        /*Apply ContrainMin: */
     444        if (input){
     445                max=input->MaxAbs();
     446        }
     447        else{
     448                ISSMERROR("Input %s not found",EnumToString(enumtype));
     449        }
     450
     451        /*Return output*/
     452        return max;
     453}
     454/*}}}*/
     455/*FUNCTION Inputs::Min{{{1*/
     456double Inputs::Min(int enumtype){
     457
     458        /*Output*/
     459        double min;
     460
     461        /*Get input*/
     462        Input* input=(Input*)this->GetInput(enumtype);
     463
     464        /*Apply ContrainMin: */
     465        if (input){
     466                min=input->Min();
     467        }
     468        else{
     469                ISSMERROR("Input %s not found",EnumToString(enumtype));
     470        }
     471
     472        /*Return output*/
     473        return min;
     474}
     475/*}}}*/
     476/*FUNCTION Inputs::MinAbs{{{1*/
     477double Inputs::MinAbs(int enumtype){
     478
     479        /*Output*/
     480        double min;
     481
     482        /*Get input*/
     483        Input* input=(Input*)this->GetInput(enumtype);
     484
     485        /*Apply ContrainMin: */
     486        if (input){
     487                min=input->MinAbs();
     488        }
     489        else{
     490                ISSMERROR("Input %s not found",EnumToString(enumtype));
     491        }
     492
     493        /*Return output*/
     494        return min;
     495}
     496/*}}}*/
    413497/*FUNCTION Inputs::GetInput{{{1*/
    414498Input* Inputs::GetInput(int enum_name){

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

    r5640 r5659  
    3838                void    AXPY(int YEnum, double scalar, int XEnum);
    3939                double  InfinityNorm(int enumtype);
     40                double  Max(int enumtype);
     41                double  MaxAbs(int enumtype);
     42                double  Min(int enumtype);
     43                double  MinAbs(int enumtype);
    4044               
    4145                void GetParameterAverage(double* pvalue, int enum_type);

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

    r5654 r5659  
    13141314void  Penta::MaxAbsVx(double* pmaxabsvx, bool process_units){
    13151315
    1316         int i;
    1317         int dim;
    1318         const int numgrids=6;
    1319         double  gaussgrids[numgrids][4]={{1,0,0,-1},{0,1,0,-1},{0,0,1,-1},{1,0,0,1},{0,1,0,1},{0,0,1,1}};
    1320         double  vx_values[numgrids];
    1321         double  maxabsvx;
    1322 
    1323         /*retrieve dim parameter: */
    1324         parameters->FindParam(&dim,DimEnum);
    1325 
    1326         /*retrive velocity values at nodes */
    1327         inputs->GetParameterValues(&vx_values[0],&gaussgrids[0][0],numgrids,VxEnum);
     1316        /*Get maximum:*/
     1317        double maxabsvx=this->inputs->MaxAbs(VxEnum);
    13281318
    13291319        /*process units if requested: */
    1330         if(process_units)UnitConversion(&vx_values[0],numgrids,IuToExtEnum,VxEnum,this->parameters);
    1331 
    1332         /*now, compute maximum:*/
    1333         maxabsvx=fabs(vx_values[0]);
    1334         for(i=1;i<numgrids;i++){
    1335                 if (fabs(vx_values[i])>maxabsvx)maxabsvx=fabs(vx_values[i]);
    1336         }
     1320        if(process_units) maxabsvx=UnitConversion(maxabsvx,IuToExtEnum,VxEnum,this->parameters);
    13371321
    13381322        /*Assign output pointers:*/
    … …  
    13431327void  Penta::MaxAbsVy(double* pmaxabsvy, bool process_units){
    13441328
    1345         int i;
    1346         int dim;
    1347         const int numgrids=6;
    1348         double  gaussgrids[numgrids][4]={{1,0,0,-1},{0,1,0,-1},{0,0,1,-1},{1,0,0,1},{0,1,0,1},{0,0,1,1}};
    1349         double  vy_values[numgrids];
    1350         double  maxabsvy;
    1351 
    1352         /*retrieve dim parameter: */
    1353         parameters->FindParam(&dim,DimEnum);
    1354 
    1355         /*retrive velocity values at nodes */
    1356         inputs->GetParameterValues(&vy_values[0],&gaussgrids[0][0],numgrids,VyEnum);
     1329        /*Get maximum:*/
     1330        double maxabsvy=this->inputs->MaxAbs(VyEnum);
    13571331
    13581332        /*process units if requested: */
    1359         if(process_units)UnitConversion(&vy_values[0],numgrids,IuToExtEnum,VyEnum,this->parameters);
    1360 
    1361         /*now, compute maximum:*/
    1362         maxabsvy=fabs(vy_values[0]);
    1363         for(i=1;i<numgrids;i++){
    1364                 if (fabs(vy_values[i])>maxabsvy)maxabsvy=fabs(vy_values[i]);
    1365         }
     1333        if(process_units) maxabsvy=UnitConversion(maxabsvy,IuToExtEnum,VyEnum,this->parameters);
    13661334
    13671335        /*Assign output pointers:*/
    … …  
    13721340void  Penta::MaxAbsVz(double* pmaxabsvz, bool process_units){
    13731341
    1374         int i;
    1375         int dim;
    1376         const int numgrids=6;
    1377         double  gaussgrids[numgrids][4]={{1,0,0,-1},{0,1,0,-1},{0,0,1,-1},{1,0,0,1},{0,1,0,1},{0,0,1,1}};
    1378         double  vz_values[numgrids];
    1379         double  maxabsvz;
    1380 
    1381         /*retrieve dim parameter: */
    1382         parameters->FindParam(&dim,DimEnum);
    1383 
    1384         /*retrive velocity values at nodes */
    1385         inputs->GetParameterValues(&vz_values[0],&gaussgrids[0][0],numgrids,VzEnum);
     1342        /*Get maximum:*/
     1343        double maxabsvz=this->inputs->MaxAbs(VzEnum);
    13861344
    13871345        /*process units if requested: */
    1388         if(process_units)UnitConversion(&vz_values[0],numgrids,IuToExtEnum,VzEnum,this->parameters);
    1389 
    1390         /*now, compute maximum:*/
    1391         maxabsvz=fabs(vz_values[0]);
    1392         for(i=1;i<numgrids;i++){
    1393                 if (fabs(vz_values[i])>maxabsvz)maxabsvz=fabs(vz_values[i]);
    1394         }
     1346        if(process_units) maxabsvz=UnitConversion(maxabsvz,IuToExtEnum,VyEnum,this->parameters);
    13951347
    13961348        /*Assign output pointers:*/
    … …  
    14011353void  Penta::MaxVel(double* pmaxvel, bool process_units){
    14021354
    1403         int i;
    1404         int dim;
    1405         const int numgrids=6;
    1406         double  gaussgrids[numgrids][4]={{1,0,0,-1},{0,1,0,-1},{0,0,1,-1},{1,0,0,1},{0,1,0,1},{0,0,1,1}};
    1407         double  vel_values[numgrids];
    1408         double  maxvel;
    1409 
    1410         /*retrieve dim parameter: */
    1411         parameters->FindParam(&dim,DimEnum);
    1412 
    1413         /*retrive velocity values at nodes */
    1414         inputs->GetParameterValues(&vel_values[0],&gaussgrids[0][0],numgrids,VelEnum);
     1355        /*Get maximum:*/
     1356        double maxvel=this->inputs->Max(VelEnum);
    14151357
    14161358        /*process units if requested: */
    1417         if(process_units)UnitConversion(&vel_values[0],numgrids,IuToExtEnum,VelEnum,this->parameters);
    1418 
    1419         /*now, compute maximum:*/
    1420         maxvel=vel_values[0];
    1421         for(i=1;i<numgrids;i++){
    1422                 if (vel_values[i]>maxvel)maxvel=vel_values[i];
    1423         }
     1359        if(process_units) maxvel=UnitConversion(maxvel,IuToExtEnum,VelEnum,this->parameters);
    14241360
    14251361        /*Assign output pointers:*/
    … …  
    14311367void  Penta::MaxVx(double* pmaxvx, bool process_units){
    14321368
    1433         int i;
    1434         int dim;
    1435         const int numgrids=6;
    1436         double  gaussgrids[numgrids][4]={{1,0,0,-1},{0,1,0,-1},{0,0,1,-1},{1,0,0,1},{0,1,0,1},{0,0,1,1}};
    1437         double  vx_values[numgrids];
    1438         double  maxvx;
    1439 
    1440         /*retrieve dim parameter: */
    1441         parameters->FindParam(&dim,DimEnum);
    1442 
    1443         /*retrive velocity values at nodes */
    1444         inputs->GetParameterValues(&vx_values[0],&gaussgrids[0][0],numgrids,VxEnum);
     1369        /*Get maximum:*/
     1370        double maxvx=this->inputs->Max(VxEnum);
    14451371
    14461372        /*process units if requested: */
    1447         if(process_units)UnitConversion(&vx_values[0],numgrids,IuToExtEnum,VxEnum,this->parameters);
    1448 
    1449         /*now, compute maximum:*/
    1450         maxvx=vx_values[0];
    1451         for(i=1;i<numgrids;i++){
    1452                 if (vx_values[i]>maxvx)maxvx=vx_values[i];
    1453         }
     1373        if(process_units) maxvx=UnitConversion(maxvx,IuToExtEnum,VxEnum,this->parameters);
    14541374
    14551375        /*Assign output pointers:*/
    … …  
    14611381void  Penta::MaxVy(double* pmaxvy, bool process_units){
    14621382
    1463         int i;
    1464         int dim;
    1465         const int numgrids=6;
    1466         double  gaussgrids[numgrids][4]={{1,0,0,-1},{0,1,0,-1},{0,0,1,-1},{1,0,0,1},{0,1,0,1},{0,0,1,1}};
    1467         double  vy_values[numgrids];
    1468         double  maxvy;
    1469 
    1470         /*retrieve dim parameter: */
    1471         parameters->FindParam(&dim,DimEnum);
    1472 
    1473         /*retrive velocity values at nodes */
    1474         inputs->GetParameterValues(&vy_values[0],&gaussgrids[0][0],numgrids,VyEnum);
     1383        /*Get maximum:*/
     1384        double maxvy=this->inputs->Max(VyEnum);
    14751385
    14761386        /*process units if requested: */
    1477         if(process_units)UnitConversion(&vy_values[0],numgrids,IuToExtEnum,VyEnum,this->parameters);
    1478 
    1479         /*now, compute maximum:*/
    1480         maxvy=vy_values[0];
    1481         for(i=1;i<numgrids;i++){
    1482                 if (vy_values[i]>maxvy)maxvy=vy_values[i];
    1483         }
     1387        if(process_units) maxvy=UnitConversion(maxvy,IuToExtEnum,VyEnum,this->parameters);
    14841388
    14851389        /*Assign output pointers:*/
    … …  
    14911395void  Penta::MaxVz(double* pmaxvz, bool process_units){
    14921396
    1493         int i;
    1494         int dim;
    1495         const int numgrids=6;
    1496         double  gaussgrids[numgrids][4]={{1,0,0,-1},{0,1,0,-1},{0,0,1,-1},{1,0,0,1},{0,1,0,1},{0,0,1,1}};
    1497         double  vz_values[numgrids];
    1498         double  maxvz;
    1499 
    1500         /*retrieve dim parameter: */
    1501         parameters->FindParam(&dim,DimEnum);
    1502 
    1503         /*retrive velocity values at nodes */
    1504         inputs->GetParameterValues(&vz_values[0],&gaussgrids[0][0],numgrids,VzEnum);
     1397        /*Get maximum:*/
     1398        double maxvz=this->inputs->Max(VzEnum);
    15051399
    15061400        /*process units if requested: */
    1507         if(process_units)UnitConversion(&vz_values[0],numgrids,IuToExtEnum,VzEnum,this->parameters);
    1508 
    1509         /*now, compute maximum:*/
    1510         maxvz=vz_values[0];
    1511         for(i=1;i<numgrids;i++){
    1512                 if (vz_values[i]>maxvz)maxvz=vz_values[i];
    1513         }
     1401        if(process_units) maxvz=UnitConversion(maxvz,IuToExtEnum,VzEnum,this->parameters);
    15141402
    15151403        /*Assign output pointers:*/
    … …  
    15211409void  Penta::MinVel(double* pminvel, bool process_units){
    15221410
    1523         int i;
    1524         int dim;
    1525         const int numgrids=6;
    1526         double  gaussgrids[numgrids][4]={{1,0,0,-1},{0,1,0,-1},{0,0,1,-1},{1,0,0,1},{0,1,0,1},{0,0,1,1}};
    1527         double  vel_values[numgrids];
    1528         double  minvel;
    1529 
    1530         /*retrieve dim parameter: */
    1531         parameters->FindParam(&dim,DimEnum);
    1532 
    1533         /*retrive velocity values at nodes */
    1534         inputs->GetParameterValues(&vel_values[0],&gaussgrids[0][0],numgrids,VelEnum);
     1411        /*Get minimum:*/
     1412        double minvel=this->inputs->Min(VelEnum);
    15351413
    15361414        /*process units if requested: */
    1537         if(process_units)UnitConversion(&vel_values[0],numgrids,IuToExtEnum,VelEnum,this->parameters);
    1538 
    1539         /*now, compute minimum:*/
    1540         minvel=vel_values[0];
    1541         for(i=1;i<numgrids;i++){
    1542                 if (vel_values[i]<minvel)minvel=vel_values[i];
    1543         }
     1415        if(process_units) minvel=UnitConversion(minvel,IuToExtEnum,VelEnum,this->parameters);
    15441416
    15451417        /*Assign output pointers:*/
    … …  
    15511423void  Penta::MinVx(double* pminvx, bool process_units){
    15521424
    1553         int i;
    1554         int dim;
    1555         const int numgrids=6;
    1556         double  gaussgrids[numgrids][4]={{1,0,0,-1},{0,1,0,-1},{0,0,1,-1},{1,0,0,1},{0,1,0,1},{0,0,1,1}};
    1557         double  vx_values[numgrids];
    1558         double  minvx;
    1559 
    1560         /*retrieve dim parameter: */
    1561         parameters->FindParam(&dim,DimEnum);
    1562 
    1563         /*retrive velocity values at nodes */
    1564         inputs->GetParameterValues(&vx_values[0],&gaussgrids[0][0],numgrids,VxEnum);
     1425        /*Get minimum:*/
     1426        double minvx=this->inputs->Min(VxEnum);
    15651427
    15661428        /*process units if requested: */
    1567         if(process_units)UnitConversion(&vx_values[0],numgrids,IuToExtEnum,VxEnum,this->parameters);
    1568 
    1569         /*now, compute minimum:*/
    1570         minvx=vx_values[0];
    1571         for(i=1;i<numgrids;i++){
    1572                 if (vx_values[i]<minvx)minvx=vx_values[i];
    1573         }
     1429        if(process_units) minvx=UnitConversion(minvx,IuToExtEnum,VxEnum,this->parameters);
    15741430
    15751431        /*Assign output pointers:*/
    … …  
    15811437void  Penta::MinVy(double* pminvy, bool process_units){
    15821438
    1583         int i;
    1584         int dim;
    1585         const int numgrids=6;
    1586         double  gaussgrids[numgrids][4]={{1,0,0,-1},{0,1,0,-1},{0,0,1,-1},{1,0,0,1},{0,1,0,1},{0,0,1,1}};
    1587         double  vy_values[numgrids];
    1588         double  minvy;
    1589 
    1590         /*retrieve dim parameter: */
    1591         parameters->FindParam(&dim,DimEnum);
    1592 
    1593         /*retrive velocity values at nodes */
    1594         inputs->GetParameterValues(&vy_values[0],&gaussgrids[0][0],numgrids,VyEnum);
     1439        /*Get minimum:*/
     1440        double minvy=this->inputs->Min(VyEnum);
    15951441
    15961442        /*process units if requested: */
    1597         if(process_units)UnitConversion(&vy_values[0],numgrids,IuToExtEnum,VyEnum,this->parameters);
    1598 
    1599         /*now, compute minimum:*/
    1600         minvy=vy_values[0];
    1601         for(i=1;i<numgrids;i++){
    1602                 if (vy_values[i]<minvy)minvy=vy_values[i];
    1603         }
     1443        if(process_units) minvy=UnitConversion(minvy,IuToExtEnum,VyEnum,this->parameters);
    16041444
    16051445        /*Assign output pointers:*/
    … …  
    16111451void  Penta::MinVz(double* pminvz, bool process_units){
    16121452
    1613         int i;
    1614         int dim;
    1615         const int numgrids=6;
    1616         double  gaussgrids[numgrids][4]={{1,0,0,-1},{0,1,0,-1},{0,0,1,-1},{1,0,0,1},{0,1,0,1},{0,0,1,1}};
    1617         double  vz_values[numgrids];
    1618         double  minvz;
    1619 
    1620         /*retrieve dim parameter: */
    1621         parameters->FindParam(&dim,DimEnum);
    1622 
    1623         /*retrive velocity values at nodes */
    1624         inputs->GetParameterValues(&vz_values[0],&gaussgrids[0][0],numgrids,VzEnum);
     1453        /*Get minimum:*/
     1454        double minvz=this->inputs->Min(VzEnum);
    16251455
    16261456        /*process units if requested: */
    1627         if(process_units)UnitConversion(&vz_values[0],numgrids,IuToExtEnum,VzEnum,this->parameters);
    1628 
    1629         /*now, compute minimum:*/
    1630         minvz=vz_values[0];
    1631         for(i=1;i<numgrids;i++){
    1632                 if (vz_values[i]<minvz)minvz=vz_values[i];
    1633         }
     1457        if(process_units) minvz=UnitConversion(minvz,IuToExtEnum,VzEnum,this->parameters);
    16341458
    16351459        /*Assign output pointers:*/

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

    r5640 r5659  
    14241424void  Tria::MaxAbsVx(double* pmaxabsvx, bool process_units){
    14251425
    1426         int i;
    1427         int dim;
    1428         const int numvertices=3;
    1429         double  vx_values[numvertices];
    1430         double  maxabsvx;
    1431 
    1432         /*retrieve dim parameter: */
    1433         parameters->FindParam(&dim,DimEnum);
    1434 
    1435         /*retrive velocity values at nodes */
    1436         GetParameterListOnVertices(&vx_values[0],VxEnum);
     1426        /*Get maximum:*/
     1427        double maxabsvx=this->inputs->MaxAbs(VxEnum);
    14371428
    14381429        /*process units if requested: */
    1439         if(process_units)UnitConversion(&vx_values[0],numvertices,IuToExtEnum,VxEnum,this->parameters);
    1440 
    1441         /*now, compute maximum:*/
    1442         maxabsvx=fabs(vx_values[0]);
    1443         for(i=1;i<numvertices;i++){
    1444                 if (fabs(vx_values[i])>maxabsvx)maxabsvx=fabs(vx_values[i]);
    1445         }
     1430        if(process_units) maxabsvx=UnitConversion(maxabsvx,IuToExtEnum,VxEnum,this->parameters);
    14461431
    14471432        /*Assign output pointers:*/
    … …  
    14521437void  Tria::MaxAbsVy(double* pmaxabsvy, bool process_units){
    14531438
    1454         int i;
    1455         int dim;
    1456         const int numvertices=3;
    1457         double  vy_values[numvertices];
    1458         double  maxabsvy;
    1459 
    1460         /*retrieve dim parameter: */
    1461         parameters->FindParam(&dim,DimEnum);
    1462 
    1463         /*retrive velocity values at nodes */
    1464         GetParameterListOnVertices(&vy_values[0],VyEnum);
     1439        /*Get maximum:*/
     1440        double maxabsvy=this->inputs->MaxAbs(VyEnum);
    14651441
    14661442        /*process units if requested: */
    1467         if(process_units)UnitConversion(&vy_values[0],numvertices,IuToExtEnum,VyEnum,this->parameters);
    1468 
    1469         /*now, compute maximum:*/
    1470         maxabsvy=fabs(vy_values[0]);
    1471         for(i=1;i<numvertices;i++){
    1472                 if (fabs(vy_values[i])>maxabsvy)maxabsvy=fabs(vy_values[i]);
    1473         }
     1443        if(process_units) maxabsvy=UnitConversion(maxabsvy,IuToExtEnum,VyEnum,this->parameters);
    14741444
    14751445        /*Assign output pointers:*/
    … …  
    14801450void  Tria::MaxAbsVz(double* pmaxabsvz, bool process_units){
    14811451
    1482         int i;
    1483         int dim;
    1484         const int numvertices=3;
    1485         double  vz_values[numvertices];
    1486         double  maxabsvz;
    1487 
    1488         /*retrieve dim parameter: */
    1489         parameters->FindParam(&dim,DimEnum);
    1490 
    1491         /*retrive velocity values at nodes */
    1492         GetParameterListOnVertices(&vz_values[0],VzEnum);
     1452        /*Get maximum:*/
     1453        double maxabsvz=this->inputs->MaxAbs(VzEnum);
    14931454
    14941455        /*process units if requested: */
    1495         if(process_units)UnitConversion(&vz_values[0],numvertices,IuToExtEnum,VzEnum,this->parameters);
    1496 
    1497         /*now, compute maximum:*/
    1498         maxabsvz=fabs(vz_values[0]);
    1499         for(i=1;i<numvertices;i++){
    1500                 if (fabs(vz_values[i])>maxabsvz)maxabsvz=fabs(vz_values[i]);
    1501         }
     1456        if(process_units) maxabsvz=UnitConversion(maxabsvz,IuToExtEnum,VyEnum,this->parameters);
    15021457
    15031458        /*Assign output pointers:*/
    … …  
    15081463void  Tria::MaxVel(double* pmaxvel, bool process_units){
    15091464
    1510         int i;
    1511         int dim;
    1512         const int numvertices=3;
    1513         double  vel_values[numvertices];
    1514         double  maxvel;
    1515 
    1516         /*retrieve dim parameter: */
    1517         parameters->FindParam(&dim,DimEnum);
    1518 
    1519         /*retrive velocity values at nodes */
    1520         GetParameterListOnVertices(&vel_values[0],VelEnum);
     1465        /*Get maximum:*/
     1466        double maxvel=this->inputs->Max(VelEnum);
    15211467
    15221468        /*process units if requested: */
    1523         if(process_units)UnitConversion(&vel_values[0],numvertices,IuToExtEnum,VelEnum,this->parameters);
    1524 
    1525         /*now, compute maximum:*/
    1526         maxvel=vel_values[0];
    1527         for(i=1;i<numvertices;i++){
    1528                 if (vel_values[i]>maxvel)maxvel=vel_values[i];
    1529         }
     1469        if(process_units) maxvel=UnitConversion(maxvel,IuToExtEnum,VelEnum,this->parameters);
    15301470
    15311471        /*Assign output pointers:*/
    … …  
    15371477void  Tria::MaxVx(double* pmaxvx, bool process_units){
    15381478
    1539         int i;
    1540         int dim;
    1541         const int numvertices=3;
    1542         double  vx_values[numvertices];
    1543         double  maxvx;
    1544 
    1545         /*retrieve dim parameter: */
    1546         parameters->FindParam(&dim,DimEnum);
    1547 
    1548         /*retrive velocity values at nodes */
    1549         GetParameterListOnVertices(&vx_values[0],VxEnum);
     1479        /*Get maximum:*/
     1480        double maxvx=this->inputs->Max(VxEnum);
    15501481
    15511482        /*process units if requested: */
    1552         if(process_units)UnitConversion(&vx_values[0],numvertices,IuToExtEnum,VxEnum,this->parameters);
    1553 
    1554         /*now, compute maximum:*/
    1555         maxvx=vx_values[0];
    1556         for(i=1;i<numvertices;i++){
    1557                 if (vx_values[i]>maxvx)maxvx=vx_values[i];
    1558         }
     1483        if(process_units) maxvx=UnitConversion(maxvx,IuToExtEnum,VxEnum,this->parameters);
    15591484
    15601485        /*Assign output pointers:*/
    … …  
    15661491void  Tria::MaxVy(double* pmaxvy, bool process_units){
    15671492
    1568         int i;
    1569         int dim;
    1570         const int numvertices=3;
    1571         double  vy_values[numvertices];
    1572         double  maxvy;
    1573 
    1574         /*retrieve dim parameter: */
    1575         parameters->FindParam(&dim,DimEnum);
    1576 
    1577         /*retrive velocity values at nodes */
    1578         GetParameterListOnVertices(&vy_values[0],VyEnum);
     1493        /*Get maximum:*/
     1494        double maxvy=this->inputs->Max(VyEnum);
    15791495
    15801496        /*process units if requested: */
    1581         if(process_units)UnitConversion(&vy_values[0],numvertices,IuToExtEnum,VyEnum,this->parameters);
    1582 
    1583         /*now, compute maximum:*/
    1584         maxvy=vy_values[0];
    1585         for(i=1;i<numvertices;i++){
    1586                 if (vy_values[i]>maxvy)maxvy=vy_values[i];
    1587         }
     1497        if(process_units) maxvy=UnitConversion(maxvy,IuToExtEnum,VyEnum,this->parameters);
    15881498
    15891499        /*Assign output pointers:*/
    … …  
    15951505void  Tria::MaxVz(double* pmaxvz, bool process_units){
    15961506
    1597         int i;
    1598         int dim;
    1599         const int numvertices=3;
    1600         double  vz_values[numvertices];
    1601         double  maxvz;
    1602 
    1603         /*retrieve dim parameter: */
    1604         parameters->FindParam(&dim,DimEnum);
    1605 
    1606         /*retrive velocity values at nodes */
    1607         GetParameterListOnVertices(&vz_values[0],VzEnum);
     1507        /*Get maximum:*/
     1508        double maxvz=this->inputs->Max(VzEnum);
    16081509
    16091510        /*process units if requested: */
    1610         if(process_units)UnitConversion(&vz_values[0],numvertices,IuToExtEnum,VzEnum,this->parameters);
    1611 
    1612         /*now, compute maximum:*/
    1613         maxvz=vz_values[0];
    1614         for(i=1;i<numvertices;i++){
    1615                 if (vz_values[i]>maxvz)maxvz=vz_values[i];
    1616         }
     1511        if(process_units) maxvz=UnitConversion(maxvz,IuToExtEnum,VzEnum,this->parameters);
    16171512
    16181513        /*Assign output pointers:*/
    … …  
    16241519void  Tria::MinVel(double* pminvel, bool process_units){
    16251520
    1626         int i;
    1627         int dim;
    1628         const int numvertices=3;
    1629         double  vel_values[numvertices];
    1630         double  minvel;
    1631 
    1632         /*retrieve dim parameter: */
    1633         parameters->FindParam(&dim,DimEnum);
    1634 
    1635         /*retrive velocity values at nodes */
    1636         GetParameterListOnVertices(&vel_values[0],VelEnum);
     1521        /*Get minimum:*/
     1522        double minvel=this->inputs->Min(VelEnum);
    16371523
    16381524        /*process units if requested: */
    1639         if(process_units)UnitConversion(&vel_values[0],numvertices,IuToExtEnum,VelEnum,this->parameters);
    1640 
    1641         /*now, compute minimum:*/
    1642         minvel=vel_values[0];
    1643         for(i=1;i<numvertices;i++){
    1644                 if (vel_values[i]<minvel)minvel=vel_values[i];
    1645         }
     1525        if(process_units) minvel=UnitConversion(minvel,IuToExtEnum,VelEnum,this->parameters);
    16461526
    16471527        /*Assign output pointers:*/
    … …  
    16531533void  Tria::MinVx(double* pminvx, bool process_units){
    16541534
    1655         int i;
    1656         int dim;
    1657         const int numvertices=3;
    1658         double  vx_values[numvertices];
    1659         double  minvx;
    1660 
    1661         /*retrieve dim parameter: */
    1662         parameters->FindParam(&dim,DimEnum);
    1663 
    1664         /*retrive velocity values at nodes */
    1665         GetParameterListOnVertices(&vx_values[0],VxEnum);
     1535        /*Get minimum:*/
     1536        double minvx=this->inputs->Min(VxEnum);
    16661537
    16671538        /*process units if requested: */
    1668         if(process_units)UnitConversion(&vx_values[0],numvertices,IuToExtEnum,VxEnum,this->parameters);
    1669 
    1670         /*now, compute minimum:*/
    1671         minvx=vx_values[0];
    1672         for(i=1;i<numvertices;i++){
    1673                 if (vx_values[i]<minvx)minvx=vx_values[i];
    1674         }
     1539        if(process_units) minvx=UnitConversion(minvx,IuToExtEnum,VxEnum,this->parameters);
    16751540
    16761541        /*Assign output pointers:*/
    … …  
    16821547void  Tria::MinVy(double* pminvy, bool process_units){
    16831548
    1684         int i;
    1685         int dim;
    1686         const int numvertices=3;
    1687         double  vy_values[numvertices];
    1688         double  minvy;
    1689 
    1690         /*retrieve dim parameter: */
    1691         parameters->FindParam(&dim,DimEnum);
    1692 
    1693         /*retrive velocity values at nodes */
    1694         GetParameterListOnVertices(&vy_values[0],VyEnum);
     1549        /*Get minimum:*/
     1550        double minvy=this->inputs->Min(VyEnum);
    16951551
    16961552        /*process units if requested: */
    1697         if(process_units)UnitConversion(&vy_values[0],numvertices,IuToExtEnum,VyEnum,this->parameters);
    1698 
    1699         /*now, compute minimum:*/
    1700         minvy=vy_values[0];
    1701         for(i=1;i<numvertices;i++){
    1702                 if (vy_values[i]<minvy)minvy=vy_values[i];
    1703         }
     1553        if(process_units) minvy=UnitConversion(minvy,IuToExtEnum,VyEnum,this->parameters);
    17041554
    17051555        /*Assign output pointers:*/
    … …  
    17111561void  Tria::MinVz(double* pminvz, bool process_units){
    17121562
    1713         int i;
    1714         int dim;
    1715         const int numvertices=3;
    1716         double  vz_values[numvertices];
    1717         double  minvz;
    1718 
    1719         /*retrieve dim parameter: */
    1720         parameters->FindParam(&dim,DimEnum);
    1721 
    1722         /*retrive velocity values at nodes */
    1723         GetParameterListOnVertices(&vz_values[0],VzEnum);
     1563        /*Get minimum:*/
     1564        double minvz=this->inputs->Min(VzEnum);
    17241565
    17251566        /*process units if requested: */
    1726         if(process_units)UnitConversion(&vz_values[0],numvertices,IuToExtEnum,VzEnum,this->parameters);
    1727 
    1728         /*now, compute minimum:*/
    1729         minvz=vz_values[0];
    1730         for(i=1;i<numvertices;i++){
    1731                 if (vz_values[i]<minvz)minvz=vz_values[i];
    1732         }
     1567        if(process_units) minvz=UnitConversion(minvz,IuToExtEnum,VzEnum,this->parameters);
    17331568
    17341569        /*Assign output pointers:*/

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

    r5647 r5659  
    7373                void ConstrainMin(double minimum){ISSMERROR("not implemented yet");};
    7474                double InfinityNorm(void){ISSMERROR("InfinityNorm not implemented for booleans");};
     75                double Max(void){ISSMERROR("Max not implemented for booleans");};
     76                double MaxAbs(void){ISSMERROR("Max not implemented for booleans");};
     77                double Min(void){ISSMERROR("Min not implemented for booleans");};
     78                double MinAbs(void){ISSMERROR("Min not implemented for booleans");};
    7579                void Scale(double scale_factor);
    7680                void ArtificialNoise(double min,double max){ISSMERROR("not implemented yet");};

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

    r5647 r5659  
    251251}
    252252/*}}}*/
     253/*FUNCTION DoubleInput::Max{{{1*/
     254double DoubleInput::Max(void){
     255        return this->value;
     256}
     257/*}}}*/
     258/*FUNCTION DoubleInput::MaxAbs{{{1*/
     259double DoubleInput::MaxAbs(void){
     260        return fabs(this->value);
     261}
     262/*}}}*/
     263/*FUNCTION DoubleInput::Min{{{1*/
     264double DoubleInput::Min(void){
     265        return this->value;
     266}
     267/*}}}*/
     268/*FUNCTION DoubleInput::MinAbs{{{1*/
     269double DoubleInput::MinAbs(void){
     270        return fabs(this->value);
     271}
     272/*}}}*/
    253273/*FUNCTION DoubleInput::GetVectorFromInputs{{{1*/
    254274void DoubleInput::GetVectorFromInputs(Vec vector,int* doflist){

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

    r5647 r5659  
    7676                void Constrain(double cm_min, double cm_max);
    7777                double InfinityNorm(void){ISSMERROR("not implemented yet");};
     78                double Max(void);
     79                double MaxAbs(void);
     80                double Min(void);
     81                double MinAbs(void);
    7882                void Extrude(void){ISSMERROR("not supported yet");};
    7983                void VerticallyIntegrate(Input* thickness_input);

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

    r5647 r5659  
    4949                virtual void ChangeEnum(int newenumtype)=0;
    5050
    51                 virtual void SquareMin(double* psquaremin, bool process_units,Parameters* parameters)=0;
    52                 virtual void ConstrainMin(double minimum)=0;
     51                virtual void   SquareMin(double* psquaremin, bool process_units,Parameters* parameters)=0;
     52                virtual void   ConstrainMin(double minimum)=0;
    5353                virtual double InfinityNorm(void)=0;
    54                 virtual void Scale(double scale_factor)=0;
    55                 virtual void ArtificialNoise(double min,double max)=0;
    56                 virtual void AXPY(Input* xinput,double scalar)=0;
    57                 virtual void Constrain(double cm_min, double cm_max)=0;
    58                 virtual void VerticallyIntegrate(Input* thickness_input)=0;
    59                 virtual void Extrude()=0;
    60                 virtual void GetVectorFromInputs(Vec vector,int* doflist)=0;
    61                 virtual void GetValuesPtr(double** pvalues,int* pnum_values)=0;
     54                virtual double MaxAbs(void)=0;
     55                virtual double MinAbs(void)=0;
     56                virtual double Max(void)=0;
     57                virtual double Min(void)=0;
     58                virtual void   Scale(double scale_factor)=0;
     59                virtual void   ArtificialNoise(double min,double max)=0;
     60                virtual void   AXPY(Input* xinput,double scalar)=0;
     61                virtual void   Constrain(double cm_min, double cm_max)=0;
     62                virtual void   VerticallyIntegrate(Input* thickness_input)=0;
     63                virtual void   Extrude()=0;
     64                virtual void   GetVectorFromInputs(Vec vector,int* doflist)=0;
     65                virtual void   GetValuesPtr(double** pvalues,int* pnum_values)=0;
    6266               
    6367                virtual Input* SpawnTriaInput(int* indices)=0;

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

    r5647 r5659  
    7777                void Constrain(double cm_min, double cm_max);
    7878                double InfinityNorm(void){ISSMERROR("InfinityNorm not implemented for integers");};
     79                double Max(void){ISSMERROR("Max not implemented for integers");};
     80                double MaxAbs(void){ISSMERROR("Max not implemented for integers");};
     81                double Min(void){ISSMERROR("Min not implemented for integers");};
     82                double MinAbs(void){ISSMERROR("Min not implemented for integers");};
    7983                void Extrude(void){ISSMERROR("not supported yet");};
    8084                void VerticallyIntegrate(Input* thickness_input){ISSMERROR("not supported yet");};

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

    r5647 r5659  
    650650}
    651651/*}}}*/
     652/*FUNCTION PentaVertexInput::Max{{{1*/
     653double PentaVertexInput::Max(void){
     654
     655        const int numgrids=6;
     656        double    max=values[0];
     657
     658        for(int i=1;i<numgrids;i++){
     659                if(values[i]>max) max=values[i];
     660        }
     661        return max;
     662}
     663/*}}}*/
     664/*FUNCTION PentaVertexInput::MaxAbs{{{1*/
     665double PentaVertexInput::MaxAbs(void){
     666
     667        const int numgrids=6;
     668        double    max=fabs(values[0]);
     669
     670        for(int i=1;i<numgrids;i++){
     671                if(fabs(values[i])>max) max=fabs(values[i]);
     672        }
     673        return max;
     674}
     675/*}}}*/
     676/*FUNCTION PentaVertexInput::Min{{{1*/
     677double PentaVertexInput::Min(void){
     678
     679        const int numgrids=6;
     680        double    min=values[0];
     681
     682        for(int i=1;i<numgrids;i++){
     683                if(values[i]<min) min=values[i];
     684        }
     685        return min;
     686}
     687/*}}}*/
     688/*FUNCTION PentaVertexInput::MinAbs{{{1*/
     689double PentaVertexInput::MinAbs(void){
     690
     691        const int numgrids=6;
     692        double    min=fabs(values[0]);
     693
     694        for(int i=1;i<numgrids;i++){
     695                if(fabs(values[i])<min) min=fabs(values[i]);
     696        }
     697        return min;
     698}
     699/*}}}*/
    652700/*FUNCTION PentaVertexInput::Scale{{{1*/
    653701void PentaVertexInput::Scale(double scale_factor){

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

    r5647 r5659  
    7878                void Constrain(double cm_min, double cm_max);
    7979                double InfinityNorm(void);
     80                double Max(void);
     81                double MaxAbs(void);
     82                double Min(void);
     83                double MinAbs(void);
    8084                void Extrude(void);
    8185                void VerticallyIntegrate(Input* thickness_input);

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

    r5631 r5659  
    364364}
    365365/*}}}*/
     366/*FUNCTION TriaVertexInput::Max{{{1*/
     367double TriaVertexInput::Max(void){
     368
     369        const int numgrids=3;
     370        double    max=values[0];
     371
     372        for(int i=1;i<numgrids;i++){
     373                if(values[i]>max) max=values[i];
     374        }
     375        return max;
     376}
     377/*}}}*/
     378/*FUNCTION TriaVertexInput::MaxAbs{{{1*/
     379double TriaVertexInput::MaxAbs(void){
     380
     381        const int numgrids=3;
     382        double    max=fabs(values[0]);
     383
     384        for(int i=1;i<numgrids;i++){
     385                if(fabs(values[i])>max) max=fabs(values[i]);
     386        }
     387        return max;
     388}
     389/*}}}*/
     390/*FUNCTION TriaVertexInput::Min{{{1*/
     391double TriaVertexInput::Min(void){
     392
     393        const int numgrids=3;
     394        double    min=values[0];
     395
     396        for(int i=1;i<numgrids;i++){
     397                if(values[i]<min) min=values[i];
     398        }
     399        return min;
     400}
     401/*}}}*/
     402/*FUNCTION TriaVertexInput::MinAbs{{{1*/
     403double TriaVertexInput::MinAbs(void){
     404
     405        const int numgrids=3;
     406        double    min=fabs(values[0]);
     407
     408        for(int i=1;i<numgrids;i++){
     409                if(fabs(values[i])<min) min=fabs(values[i]);
     410        }
     411        return min;
     412}
     413/*}}}*/
    366414/*FUNCTION TriaVertexInput::Scale{{{1*/
    367415void TriaVertexInput::Scale(double scale_factor){

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

    r5647 r5659  
    7878                void Constrain(double cm_min, double cm_max);
    7979                double InfinityNorm(void);
     80                double Max(void);
     81                double MaxAbs(void);
     82                double Min(void);
     83                double MinAbs(void);
    8084                void Extrude(void){ISSMERROR("not supported yet");};
    8185                void VerticallyIntegrate(Input* thickness_input){ISSMERROR("not supported yet");};

  • issm/trunk/src/c/shared/Numerics/UnitConversion.cpp

    r5529 r5659  
    5959        double scale;
    6060        switch(type_enum){
    61                 case VxEnum:   scale=yts;break; //m/yr
    62                 case VxObsEnum:   scale=yts;break; //m/yr
    63                 case VyEnum:   scale=yts;break; //m/yr
    64                 case VyObsEnum:   scale=yts;break; //m/yr
    65                 case VzEnum:   scale=yts;break; //m/yr
    66                 case VzObsEnum:   scale=yts;break; //m/yr
    67                 case VelEnum:  scale=yts;break; //m/yr
    68                 case VelObsEnum:  scale=yts;break; //m/yr
    69                 case DhDtEnum: scale=yts;break; //m/yr
     61                case VxEnum:          scale=yts;break; //m/yr
     62                case VxObsEnum:       scale=yts;break; //m/yr
     63                case VyEnum:          scale=yts;break; //m/yr
     64                case VyObsEnum:       scale=yts;break; //m/yr
     65                case VzEnum:          scale=yts;break; //m/yr
     66                case VzObsEnum:       scale=yts;break; //m/yr
     67                case VelEnum:         scale=yts;break; //m/yr
     68                case VelObsEnum:      scale=yts;break; //m/yr
     69                case DhDtEnum:        scale=yts;break; //m/yr
    7070                case MeltingRateEnum: scale=yts;break; //m/yr
    7171                case MisfitEnum:      scale=pow(yts,2);break; //(m/yr)^2
Note: See TracChangeset for help on using the changeset viewer.