Changeset 18104


Ignore:
Timestamp:
06/04/14 06:55:27 (11 years ago)
Author:
Mathieu Morlighem
Message:

CHG: moved vx vy vz max,min,abs to module

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

Legend:

Unmodified
Added
Removed

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

    r18093 r18104  
    255255
    256256                virtual void   AverageOntoPartition(Vector<IssmDouble>* partition_contributions,Vector<IssmDouble>* partition_areas,IssmDouble* vertex_response,IssmDouble* qmu_part)=0;
    257                 virtual void   MinVel(IssmDouble* pminvel)=0;
    258                 virtual void   MaxVel(IssmDouble* pmaxvel)=0;
    259                 virtual void   MinVx(IssmDouble* pminvx)=0;
    260                 virtual void   MaxVx(IssmDouble* pmaxvx)=0;
    261                 virtual void   MaxAbsVx(IssmDouble* pmaxabsvx)=0;
    262                 virtual void   MinVy(IssmDouble* pminvy)=0;
    263                 virtual void   MaxVy(IssmDouble* pmaxvy)=0;
    264                 virtual void   MaxAbsVy(IssmDouble* pmaxabsvy)=0;
    265                 virtual void   MinVz(IssmDouble* pminvz)=0;
    266                 virtual void   MaxVz(IssmDouble* pmaxvz)=0;
    267                 virtual void   MaxAbsVz(IssmDouble* pmaxabsvz)=0;
    268257                virtual IssmDouble MassFlux(IssmDouble* segment)=0;
    269258                virtual IssmDouble MassFlux(IssmDouble x1,IssmDouble y1, IssmDouble x2, IssmDouble y2,int segment_id)=0;

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

    r18079 r18104  
    20532053
    20542054        /*Get for Vx and Vy, the max of abs value: */
    2055         this->MaxAbsVx(&maxabsvx);
    2056         this->MaxAbsVy(&maxabsvy);
    2057         this->MaxAbsVz(&maxabsvz);
     2055        maxabsvx = this->inputs->MaxAbs(VxEnum);
     2056        maxabsvy = this->inputs->MaxAbs(VyEnum);
     2057        maxabsvz = this->inputs->MaxAbs(VzEnum);
    20582058
    20592059        /* Get node coordinates and dof list: */
    … …  
    25782578}
    25792579/*}}}*/
    2580 void       Penta::MinVel(IssmDouble* pminvel){/*{{{*/
    2581 
    2582         /*Get minimum:*/
    2583         IssmDouble minvel=this->inputs->Min(VelEnum);
    2584 
    2585         /*Assign output pointers:*/
    2586         *pminvel=minvel;
    2587 }
    2588 /*}}}*/
    2589 void       Penta::MinVx(IssmDouble* pminvx){/*{{{*/
    2590 
    2591         /*Get minimum:*/
    2592         IssmDouble minvx=this->inputs->Min(VxEnum);
    2593 
    2594         /*Assign output pointers:*/
    2595         *pminvx=minvx;
    2596 }
    2597 /*}}}*/
    2598 void       Penta::MinVy(IssmDouble* pminvy){/*{{{*/
    2599 
    2600         /*Get minimum:*/
    2601         IssmDouble minvy=this->inputs->Min(VyEnum);
    2602 
    2603         /*Assign output pointers:*/
    2604         *pminvy=minvy;
    2605 }
    2606 /*}}}*/
    2607 void       Penta::MinVz(IssmDouble* pminvz){/*{{{*/
    2608 
    2609         /*Get minimum:*/
    2610         IssmDouble minvz=this->inputs->Min(VzEnum);
    2611 
    2612         /*Assign output pointers:*/
    2613         *pminvz=minvz;
    2614 }
    2615 /*}}}*/
    26162580IssmDouble Penta::MassFlux( IssmDouble* segment){/*{{{*/
    26172581
    … …  
    26582622        /*clean up and return*/
    26592623        return mass_flux;
    2660 }
    2661 /*}}}*/
    2662 void       Penta::MaxAbsVx(IssmDouble* pmaxabsvx){/*{{{*/
    2663 
    2664         /*Get maximum:*/
    2665         IssmDouble maxabsvx=this->inputs->MaxAbs(VxEnum);
    2666 
    2667         /*Assign output pointers:*/
    2668         *pmaxabsvx=maxabsvx;
    2669 }
    2670 /*}}}*/
    2671 void       Penta::MaxAbsVy(IssmDouble* pmaxabsvy){/*{{{*/
    2672 
    2673         /*Get maximum:*/
    2674         IssmDouble maxabsvy=this->inputs->MaxAbs(VyEnum);
    2675 
    2676         /*Assign output pointers:*/
    2677         *pmaxabsvy=maxabsvy;
    2678 }
    2679 /*}}}*/
    2680 void       Penta::MaxAbsVz(IssmDouble* pmaxabsvz){/*{{{*/
    2681 
    2682         /*Get maximum:*/
    2683         IssmDouble maxabsvz=this->inputs->MaxAbs(VzEnum);
    2684 
    2685         /*Assign output pointers:*/
    2686         *pmaxabsvz=maxabsvz;
    2687 }
    2688 /*}}}*/
    2689 void       Penta::MaxVel(IssmDouble* pmaxvel){/*{{{*/
    2690 
    2691         /*Get maximum:*/
    2692         IssmDouble maxvel=this->inputs->Max(VelEnum);
    2693 
    2694         /*Assign output pointers:*/
    2695         *pmaxvel=maxvel;
    2696 
    2697 }
    2698 /*}}}*/
    2699 void       Penta::MaxVx(IssmDouble* pmaxvx){/*{{{*/
    2700 
    2701         /*Get maximum:*/
    2702         IssmDouble maxvx=this->inputs->Max(VxEnum);
    2703 
    2704         /*Assign output pointers:*/
    2705         *pmaxvx=maxvx;
    2706 }
    2707 /*}}}*/
    2708 void       Penta::MaxVy(IssmDouble* pmaxvy){/*{{{*/
    2709 
    2710         /*Get maximum:*/
    2711         IssmDouble maxvy=this->inputs->Max(VyEnum);
    2712 
    2713         /*Assign output pointers:*/
    2714         *pmaxvy=maxvy;
    2715 }
    2716 /*}}}*/
    2717 void       Penta::MaxVz(IssmDouble* pmaxvz){/*{{{*/
    2718 
    2719         /*Get maximum:*/
    2720         IssmDouble maxvz=this->inputs->Max(VzEnum);
    2721 
    2722         /*Assign output pointers:*/
    2723         *pmaxvz=maxvz;
    27242624}
    27252625/*}}}*/

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

    r18062 r18104  
    112112                IssmDouble IceVolumeAboveFloatation(void);
    113113                IssmDouble TotalSmb(void);
    114                 void   MinVel(IssmDouble* pminvel);
    115                 void   MinVx(IssmDouble* pminvx);
    116                 void   MinVy(IssmDouble* pminvy);
    117                 void   MinVz(IssmDouble* pminvz);
    118114                IssmDouble MassFlux(IssmDouble* segment);
    119115                IssmDouble MassFlux(IssmDouble x1,IssmDouble y1, IssmDouble x2, IssmDouble y2,int segment_id);
    120                 void   MaxAbsVx(IssmDouble* pmaxabsvx);
    121                 void   MaxAbsVy(IssmDouble* pmaxabsvy);
    122                 void   MaxAbsVz(IssmDouble* pmaxabsvz);
    123                 void   MaxVel(IssmDouble* pmaxvel);
    124116                void   ElementResponse(IssmDouble* presponse,int response_enum);
    125                 void   MaxVx(IssmDouble* pmaxvx);
    126                 void   MaxVy(IssmDouble* pmaxvy);
    127                 void   MaxVz(IssmDouble* pmaxvz);
    128117
    129118                #ifdef _HAVE_GIA_

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

    r18062 r18104  
    146146                IssmDouble IceVolumeAboveFloatation(void){_error_("not implemented yet");};
    147147                IssmDouble TotalSmb(void){_error_("not implemented yet");};
    148                 void       MinVel(IssmDouble* pminvel){_error_("not implemented yet");};
    149                 void       MinVx(IssmDouble* pminvx){_error_("not implemented yet");};
    150                 void       MinVy(IssmDouble* pminvy){_error_("not implemented yet");};
    151                 void       MinVz(IssmDouble* pminvz){_error_("not implemented yet");};
    152148                IssmDouble MassFlux(IssmDouble* segment){_error_("not implemented yet");};
    153149                IssmDouble MassFlux(IssmDouble x1,IssmDouble y1, IssmDouble x2, IssmDouble y2,int segment_id){_error_("not implemented yet");}
    154                 void       MaxAbsVx(IssmDouble* pmaxabsvx){_error_("not implemented yet");};
    155                 void       MaxAbsVy(IssmDouble* pmaxabsvy){_error_("not implemented yet");};
    156                 void       MaxAbsVz(IssmDouble* pmaxabsvz){_error_("not implemented yet");};
    157150                void       ElementResponse(IssmDouble* presponse,int response_enum){_error_("not implemented yet");};
    158                 void       MaxVel(IssmDouble* pmaxvel){_error_("not implemented yet");};
    159                 void       MaxVx(IssmDouble* pmaxvx){_error_("not implemented yet");};
    160                 void       MaxVy(IssmDouble* pmaxvy){_error_("not implemented yet");};
    161                 void       MaxVz(IssmDouble* pmaxvz){_error_("not implemented yet");};
    162151                IssmDouble Misfit(int modelenum,int observationenum,int weightsenum){_error_("not implemented yet");};
    163152                IssmDouble MisfitArea(int weightsenum){_error_("not implemented yet");};

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

    r18062 r18104  
    150150                IssmDouble IceVolumeAboveFloatation(void){_error_("not implemented yet");};
    151151                IssmDouble TotalSmb(void){_error_("not implemented yet");};
    152                 void       MinVel(IssmDouble* pminvel){_error_("not implemented yet");};
    153                 void       MinVx(IssmDouble* pminvx){_error_("not implemented yet");};
    154                 void       MinVy(IssmDouble* pminvy){_error_("not implemented yet");};
    155                 void       MinVz(IssmDouble* pminvz){_error_("not implemented yet");};
    156152                IssmDouble MassFlux(IssmDouble* segment){_error_("not implemented yet");};
    157153                IssmDouble MassFlux(IssmDouble x1,IssmDouble y1, IssmDouble x2, IssmDouble y2,int segment_id){_error_("not implemented yet");}
    158                 void       MaxAbsVx(IssmDouble* pmaxabsvx){_error_("not implemented yet");};
    159                 void       MaxAbsVy(IssmDouble* pmaxabsvy){_error_("not implemented yet");};
    160                 void       MaxAbsVz(IssmDouble* pmaxabsvz){_error_("not implemented yet");};
    161154                void       ElementResponse(IssmDouble* presponse,int response_enum){_error_("not implemented yet");};
    162                 void       MaxVel(IssmDouble* pmaxvel){_error_("not implemented yet");};
    163                 void       MaxVx(IssmDouble* pmaxvx){_error_("not implemented yet");};
    164                 void       MaxVy(IssmDouble* pmaxvy){_error_("not implemented yet");};
    165                 void       MaxVz(IssmDouble* pmaxvz){_error_("not implemented yet");};
    166155                IssmDouble Misfit(int modelenum,int observationenum,int weightsenum){_error_("not implemented yet");};
    167156                IssmDouble MisfitArea(int weightsenum){_error_("not implemented yet");};

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

    r18078 r18104  
    18551855
    18561856        /*Get for Vx and Vy, the max of abs value: */
    1857         this->MaxAbsVx(&maxabsvx);
    1858         this->MaxAbsVy(&maxabsvy);
     1857        maxabsvx = this->inputs->MaxAbs(VxEnum);
     1858        maxabsvy = this->inputs->MaxAbs(VyEnum);
    18591859
    18601860        /* Get node coordinates and dof list: */
    … …  
    23192319}
    23202320/*}}}*/
    2321 void       Tria::MaxAbsVx(IssmDouble* pmaxabsvx){/*{{{*/
    2322 
    2323         /*Get maximum:*/
    2324         IssmDouble maxabsvx=this->inputs->MaxAbs(VxEnum);
    2325 
    2326         /*Assign output pointers:*/
    2327         *pmaxabsvx=maxabsvx;
    2328 }
    2329 /*}}}*/
    2330 void       Tria::MaxAbsVy(IssmDouble* pmaxabsvy){/*{{{*/
    2331 
    2332         /*Get maximum:*/
    2333         IssmDouble maxabsvy=this->inputs->MaxAbs(VyEnum);
    2334 
    2335         /*Assign output pointers:*/
    2336         *pmaxabsvy=maxabsvy;
    2337 }
    2338 /*}}}*/
    2339 void       Tria::MaxAbsVz(IssmDouble* pmaxabsvz){/*{{{*/
    2340 
    2341         /*Get maximum:*/
    2342         IssmDouble maxabsvz=this->inputs->MaxAbs(VzEnum);
    2343 
    2344         /*Assign output pointers:*/
    2345         *pmaxabsvz=maxabsvz;
    2346 }
    2347 /*}}}*/
    2348 void       Tria::MaxVel(IssmDouble* pmaxvel){/*{{{*/
    2349 
    2350         /*Get maximum:*/
    2351         IssmDouble maxvel=this->inputs->Max(VelEnum);
    2352 
    2353         /*Assign output pointers:*/
    2354         *pmaxvel=maxvel;
    2355 }
    2356 /*}}}*/
    2357 void       Tria::MaxVx(IssmDouble* pmaxvx){/*{{{*/
    2358 
    2359         /*Get maximum:*/
    2360         IssmDouble maxvx=this->inputs->Max(VxEnum);
    2361 
    2362         /*Assign output pointers:*/
    2363         *pmaxvx=maxvx;
    2364 }
    2365 /*}}}*/
    2366 void       Tria::MaxVy(IssmDouble* pmaxvy){/*{{{*/
    2367 
    2368         /*Get maximum:*/
    2369         IssmDouble maxvy=this->inputs->Max(VyEnum);
    2370 
    2371         /*Assign output pointers:*/
    2372         *pmaxvy=maxvy;
    2373 
    2374 }
    2375 /*}}}*/
    2376 void       Tria::MaxVz(IssmDouble* pmaxvz){/*{{{*/
    2377 
    2378         /*Get maximum:*/
    2379         IssmDouble maxvz=this->inputs->Max(VzEnum);
    2380 
    2381         /*Assign output pointers:*/
    2382         *pmaxvz=maxvz;
    2383 }
    2384 /*}}}*/
    2385 void       Tria::MinVel(IssmDouble* pminvel){/*{{{*/
    2386 
    2387         /*Get minimum:*/
    2388         IssmDouble minvel=this->inputs->Min(VelEnum);
    2389 
    2390         /*Assign output pointers:*/
    2391         *pminvel=minvel;
    2392 }
    2393 /*}}}*/
    2394 void       Tria::MinVx(IssmDouble* pminvx){/*{{{*/
    2395 
    2396         /*Get minimum:*/
    2397         IssmDouble minvx=this->inputs->Min(VxEnum);
    2398 
    2399         /*Assign output pointers:*/
    2400         *pminvx=minvx;
    2401 }
    2402 /*}}}*/
    2403 void       Tria::MinVy(IssmDouble* pminvy){/*{{{*/
    2404 
    2405         /*Get minimum:*/
    2406         IssmDouble minvy=this->inputs->Min(VyEnum);
    2407 
    2408         /*Assign output pointers:*/
    2409         *pminvy=minvy;
    2410 }
    2411 /*}}}*/
    2412 void       Tria::MinVz(IssmDouble* pminvz){/*{{{*/
    2413 
    2414         /*Get minimum:*/
    2415         IssmDouble minvz=this->inputs->Min(VzEnum);
    2416 
    2417         /*Assign output pointers:*/
    2418         *pminvz=minvz;
    2419 }
    2420 /*}}}*/
    24212321void       Tria::ElementResponse(IssmDouble* presponse,int response_enum){/*{{{*/
    24222322

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

    r18062 r18104  
    115115                IssmDouble IceVolumeAboveFloatation(void);
    116116                IssmDouble TotalSmb(void);
    117                 void       MinVel(IssmDouble* pminvel);
    118                 void       MinVx(IssmDouble* pminvx);
    119                 void       MinVy(IssmDouble* pminvy);
    120                 void       MinVz(IssmDouble* pminvz);
    121117                IssmDouble MassFlux(IssmDouble* segment);
    122118                IssmDouble MassFlux(IssmDouble x1,IssmDouble y1, IssmDouble x2, IssmDouble y2,int segment_id);
    123                 void       MaxAbsVx(IssmDouble* pmaxabsvx);
    124                 void       MaxAbsVy(IssmDouble* pmaxabsvy);
    125                 void       MaxAbsVz(IssmDouble* pmaxabsvz);
    126119                void       ElementResponse(IssmDouble* presponse,int response_enum);
    127                 void       MaxVel(IssmDouble* pmaxvel);
    128                 void       MaxVx(IssmDouble* pmaxvx);
    129                 void       MaxVy(IssmDouble* pmaxvy);
    130                 void       MaxVz(IssmDouble* pmaxvz);
    131120                IssmDouble Misfit(int modelenum,int observationenum,int weightsenum);
    132121                IssmDouble MisfitArea(int weightsenum);

  • issm/trunk-jpl/src/c/classes/FemModel.cpp

    r18068 r18104  
    767767        maxabsvx=-INFINITY;
    768768        for(i=0;i<this->elements->Size();i++){
    769                 Element* element=(Element*)this->elements->GetObjectByOffset(i);
    770                 element->MaxAbsVx(&element_maxabsvx);
     769                Element* element=dynamic_cast<Element*>(this->elements->GetObjectByOffset(i));
     770                element_maxabsvx=element->inputs->MaxAbs(VxEnum);
    771771                if(element_maxabsvx>maxabsvx) maxabsvx=element_maxabsvx;
    772772        }
    … …  
    791791        maxabsvy=-INFINITY;
    792792        for(i=0;i<this->elements->Size();i++){
    793                 Element* element=(Element*)this->elements->GetObjectByOffset(i);
    794                 element->MaxAbsVy(&element_maxabsvy);
     793                Element* element=dynamic_cast<Element*>(this->elements->GetObjectByOffset(i));
     794                element_maxabsvy=element->inputs->MaxAbs(VyEnum);
    795795                if(element_maxabsvy>maxabsvy) maxabsvy=element_maxabsvy;
    796796        }
    … …  
    815815        maxabsvz=-INFINITY;
    816816        for(i=0;i<this->elements->Size();i++){
    817                 Element* element=(Element*)this->elements->GetObjectByOffset(i);
    818                 element->MaxAbsVz(&element_maxabsvz);
     817                Element* element=dynamic_cast<Element*>(this->elements->GetObjectByOffset(i));
     818                element_maxabsvz=element->inputs->MaxAbs(VzEnum);
    819819                if(element_maxabsvz>maxabsvz) maxabsvz=element_maxabsvz;
    820820        }
    … …  
    839839        maxvel=-INFINITY;
    840840        for(i=0;i<this->elements->Size();i++){
    841                 Element* element=(Element*)this->elements->GetObjectByOffset(i);
    842                 element->MaxVel(&element_maxvel);
     841                Element* element=dynamic_cast<Element*>(this->elements->GetObjectByOffset(i));
     842                element_maxvel = element->inputs->Max(VelEnum);
    843843                if(element_maxvel>maxvel) maxvel=element_maxvel;
    844844        }
    … …  
    863863        maxvx=-INFINITY;
    864864        for(i=0;i<this->elements->Size();i++){
    865                 Element* element=(Element*)this->elements->GetObjectByOffset(i);
    866                 element->MaxVx(&element_maxvx);
     865                Element* element=dynamic_cast<Element*>(this->elements->GetObjectByOffset(i));
     866                element_maxvx = element->inputs->Max(VxEnum);
    867867                if(element_maxvx>maxvx) maxvx=element_maxvx;
    868868        }
    … …  
    887887        maxvy=-INFINITY;
    888888        for(i=0;i<this->elements->Size();i++){
    889                 Element* element=(Element*)this->elements->GetObjectByOffset(i);
    890                 element->MaxVy(&element_maxvy);
     889                Element* element=dynamic_cast<Element*>(this->elements->GetObjectByOffset(i));
     890                element_maxvy = element->inputs->Max(VyEnum);
    891891                if(element_maxvy>maxvy) maxvy=element_maxvy;
    892892        }
    … …  
    911911        maxvz=-INFINITY;
    912912        for(i=0;i<this->elements->Size();i++){
    913                 Element* element=(Element*)this->elements->GetObjectByOffset(i);
    914                 element->MaxVz(&element_maxvz);
     913                Element* element=dynamic_cast<Element*>(this->elements->GetObjectByOffset(i));
     914                element_maxvz = element->inputs->Max(VzEnum);
    915915                if(element_maxvz>maxvz) maxvz=element_maxvz;
    916916        }
    … …  
    935935        minvel=INFINITY;
    936936        for(i=0;i<this->elements->Size();i++){
    937                 Element* element=(Element*)this->elements->GetObjectByOffset(i);
    938                 element->MinVel(&element_minvel);
     937                Element* element=dynamic_cast<Element*>(this->elements->GetObjectByOffset(i));
     938                element_minvel = element->inputs->Min(VelEnum);
    939939                if(element_minvel<minvel) minvel=element_minvel;
    940940        }
    … …  
    959959        minvx=INFINITY;
    960960        for(i=0;i<this->elements->Size();i++){
    961                 Element* element=(Element*)this->elements->GetObjectByOffset(i);
    962                 element->MinVx(&element_minvx);
     961                Element* element=dynamic_cast<Element*>(this->elements->GetObjectByOffset(i));
     962                element_minvx = element->inputs->Min(VxEnum);
    963963                if(element_minvx<minvx) minvx=element_minvx;
    964964        }
    … …  
    983983        minvy=INFINITY;
    984984        for(i=0;i<this->elements->Size();i++){
    985                 Element* element=(Element*)this->elements->GetObjectByOffset(i);
    986                 element->MinVy(&element_minvy);
     985                Element* element=dynamic_cast<Element*>(this->elements->GetObjectByOffset(i));
     986                element_minvy = element->inputs->Min(VyEnum);
    987987                if(element_minvy<minvy) minvy=element_minvy;
    988988        }
    … …  
    10071007        minvz=INFINITY;
    10081008        for(i=0;i<this->elements->Size();i++){
    1009                 Element* element=(Element*)this->elements->GetObjectByOffset(i);
    1010                 element->MinVz(&element_minvz);
     1009                Element* element=dynamic_cast<Element*>(this->elements->GetObjectByOffset(i));
     1010                element_minvz = element->inputs->Min(VzEnum);
    10111011                if(element_minvz<minvz) minvz=element_minvz;
    10121012        }
Note: See TracChangeset for help on using the changeset viewer.