Changeset 15130


Ignore:
Timestamp:
05/28/13 15:16:02 (12 years ago)
Author:
Mathieu Morlighem
Message:

CHG: removing all process_units

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

Legend:

Unmodified
Added
Removed

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

    r15104 r15130  
    9494        }
    9595
    96         femmodel->Responsex(poutput_value,this->name,false,0);
     96        femmodel->Responsex(poutput_value,this->name,0);
    9797
    9898}

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

    r15129 r15130  
    7171                virtual void   RequestedOutput(int output_enum,int step,IssmDouble time)=0;
    7272
    73                 virtual int    NodalValue(IssmDouble* pvalue, int index, int natureofdataenum,bool process_units)=0;
     73                virtual int    NodalValue(IssmDouble* pvalue, int index, int natureofdataenum)=0;
    7474                virtual void   InputScale(int enum_type,IssmDouble scale_factor)=0;
    7575                virtual void   GetVectorFromInputs(Vector<IssmDouble>* vector, int name_enum)=0;
    … …  
    8989
    9090                #ifdef _HAVE_RESPONSES_
    91                 virtual void   MinVel(IssmDouble* pminvel, bool process_units)=0;
    92                 virtual void   MaxVel(IssmDouble* pmaxvel, bool process_units)=0;
    93                 virtual void   MinVx(IssmDouble* pminvx, bool process_units)=0;
    94                 virtual void   MaxVx(IssmDouble* pmaxvx, bool process_units)=0;
    95                 virtual void   MaxAbsVx(IssmDouble* pmaxabsvx, bool process_units)=0;
    96                 virtual void   MinVy(IssmDouble* pminvy, bool process_units)=0;
    97                 virtual void   MaxVy(IssmDouble* pmaxvy, bool process_units)=0;
    98                 virtual void   MaxAbsVy(IssmDouble* pmaxabsvy, bool process_units)=0;
    99                 virtual void   MinVz(IssmDouble* pminvz, bool process_units)=0;
    100                 virtual void   MaxVz(IssmDouble* pmaxvz, bool process_units)=0;
    101                 virtual void   MaxAbsVz(IssmDouble* pmaxabsvz, bool process_units)=0;
    102                 virtual IssmDouble MassFlux(IssmDouble* segment,bool process_units)=0;
     91                virtual void   MinVel(IssmDouble* pminvel)=0;
     92                virtual void   MaxVel(IssmDouble* pmaxvel)=0;
     93                virtual void   MinVx(IssmDouble* pminvx)=0;
     94                virtual void   MaxVx(IssmDouble* pmaxvx)=0;
     95                virtual void   MaxAbsVx(IssmDouble* pmaxabsvx)=0;
     96                virtual void   MinVy(IssmDouble* pminvy)=0;
     97                virtual void   MaxVy(IssmDouble* pmaxvy)=0;
     98                virtual void   MaxAbsVy(IssmDouble* pmaxabsvy)=0;
     99                virtual void   MinVz(IssmDouble* pminvz)=0;
     100                virtual void   MaxVz(IssmDouble* pmaxvz)=0;
     101                virtual void   MaxAbsVz(IssmDouble* pmaxabsvz)=0;
     102                virtual IssmDouble MassFlux(IssmDouble* segment)=0;
    103103                virtual void   ElementResponse(IssmDouble* presponse,int response_enum)=0;
    104104                virtual IssmDouble IceVolume(void)=0;
    … …  
    112112                #ifdef _HAVE_CONTROL_
    113113                virtual void   Gradj(Vector<IssmDouble>* gradient,int control_type,int control_index)=0;
    114                 virtual IssmDouble ThicknessAbsMisfit(bool process_units  ,int weight_index)=0;
    115                 virtual IssmDouble SurfaceAbsVelMisfit(bool process_units ,int weight_index)=0;
    116                 virtual IssmDouble SurfaceRelVelMisfit(bool process_units ,int weight_index)=0;
    117                 virtual IssmDouble SurfaceLogVelMisfit(bool process_units ,int weight_index)=0;
    118                 virtual IssmDouble SurfaceLogVxVyMisfit(bool process_units,int weight_index)=0;
    119                 virtual IssmDouble SurfaceAverageVelMisfit(bool process_units,int weight_index)=0;
    120                 virtual IssmDouble ThicknessAbsGradient(bool process_units,int weight_index)=0;
    121                 virtual IssmDouble ThicknessAlongGradient(bool process_units,int weight_index)=0;
    122                 virtual IssmDouble ThicknessAcrossGradient(bool process_units,int weight_index)=0;
    123                 virtual IssmDouble BalancethicknessMisfit(bool process_units,int weight_index)=0;
    124                 virtual IssmDouble RheologyBbarAbsGradient(bool process_units,int weight_index)=0;
    125                 virtual IssmDouble DragCoefficientAbsGradient(bool process_units,int weight_index)=0;
     114                virtual IssmDouble ThicknessAbsMisfit(int weight_index)=0;
     115                virtual IssmDouble SurfaceAbsVelMisfit(int weight_index)=0;
     116                virtual IssmDouble SurfaceRelVelMisfit(int weight_index)=0;
     117                virtual IssmDouble SurfaceLogVelMisfit(int weight_index)=0;
     118                virtual IssmDouble SurfaceLogVxVyMisfit(int weight_index)=0;
     119                virtual IssmDouble SurfaceAverageVelMisfit(int weight_index)=0;
     120                virtual IssmDouble ThicknessAbsGradient(int weight_index)=0;
     121                virtual IssmDouble ThicknessAlongGradient(int weight_index)=0;
     122                virtual IssmDouble ThicknessAcrossGradient(int weight_index)=0;
     123                virtual IssmDouble BalancethicknessMisfit(int weight_index)=0;
     124                virtual IssmDouble RheologyBbarAbsGradient(int weight_index)=0;
     125                virtual IssmDouble DragCoefficientAbsGradient(int weight_index)=0;
    126126                virtual void   ControlInputGetGradient(Vector<IssmDouble>* gradient,int enum_type,int control_index)=0;
    127127                virtual void   ControlInputSetGradient(IssmDouble* gradient,int enum_type,int control_index)=0;

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

    r15129 r15130  
    24292429/*}}}*/
    24302430/*FUNCTION Penta::NodalValue {{{*/
    2431 int    Penta::NodalValue(IssmDouble* pvalue, int index, int natureofdataenum,bool process_units){
     2431int    Penta::NodalValue(IssmDouble* pvalue, int index, int natureofdataenum){
    24322432
    24332433        int i;
    … …  
    29842984
    29852985        /*Get for Vx and Vy, the max of abs value: */
    2986         this->MaxAbsVx(&maxabsvx,false);
    2987         this->MaxAbsVy(&maxabsvy,false);
    2988         this->MaxAbsVz(&maxabsvz,false);
     2986        this->MaxAbsVx(&maxabsvx);
     2987        this->MaxAbsVy(&maxabsvy);
     2988        this->MaxAbsVz(&maxabsvz);
    29892989
    29902990        /* Get node coordinates and dof list: */
    … …  
    32663266/*}}}*/
    32673267/*FUNCTION Penta::MinVel{{{*/
    3268 void  Penta::MinVel(IssmDouble* pminvel, bool process_units){
     3268void  Penta::MinVel(IssmDouble* pminvel){
    32693269
    32703270        /*Get minimum:*/
    … …  
    32763276/*}}}*/
    32773277/*FUNCTION Penta::MinVx{{{*/
    3278 void  Penta::MinVx(IssmDouble* pminvx, bool process_units){
     3278void  Penta::MinVx(IssmDouble* pminvx){
    32793279
    32803280        /*Get minimum:*/
    … …  
    32863286/*}}}*/
    32873287/*FUNCTION Penta::MinVy{{{*/
    3288 void  Penta::MinVy(IssmDouble* pminvy, bool process_units){
     3288void  Penta::MinVy(IssmDouble* pminvy){
    32893289
    32903290        /*Get minimum:*/
    … …  
    32963296/*}}}*/
    32973297/*FUNCTION Penta::MinVz{{{*/
    3298 void  Penta::MinVz(IssmDouble* pminvz, bool process_units){
     3298void  Penta::MinVz(IssmDouble* pminvz){
    32993299
    33003300        /*Get minimum:*/
    … …  
    33063306/*}}}*/
    33073307/*FUNCTION Penta::MassFlux {{{*/
    3308 IssmDouble Penta::MassFlux( IssmDouble* segment,bool process_units){
     3308IssmDouble Penta::MassFlux( IssmDouble* segment){
    33093309
    33103310        IssmDouble mass_flux=0;
    … …  
    33183318        /*Spawn Tria element from the base of the Penta: */
    33193319        Tria* tria=(Tria*)SpawnTria(0,1,2); //nodes 0, 1 and 2 make the new tria.
    3320         mass_flux=tria->MassFlux(segment,process_units);
     3320        mass_flux=tria->MassFlux(segment);
    33213321        delete tria->material; delete tria;
    33223322
    … …  
    33303330/*}}}*/
    33313331/*FUNCTION Penta::MaxAbsVx{{{*/
    3332 void  Penta::MaxAbsVx(IssmDouble* pmaxabsvx, bool process_units){
     3332void  Penta::MaxAbsVx(IssmDouble* pmaxabsvx){
    33333333
    33343334        /*Get maximum:*/
    … …  
    33403340/*}}}*/
    33413341/*FUNCTION Penta::MaxAbsVy{{{*/
    3342 void  Penta::MaxAbsVy(IssmDouble* pmaxabsvy, bool process_units){
     3342void  Penta::MaxAbsVy(IssmDouble* pmaxabsvy){
    33433343
    33443344        /*Get maximum:*/
    … …  
    33503350/*}}}*/
    33513351/*FUNCTION Penta::MaxAbsVz{{{*/
    3352 void  Penta::MaxAbsVz(IssmDouble* pmaxabsvz, bool process_units){
     3352void  Penta::MaxAbsVz(IssmDouble* pmaxabsvz){
    33533353
    33543354        /*Get maximum:*/
    … …  
    33603360/*}}}*/
    33613361/*FUNCTION Penta::MaxVel{{{*/
    3362 void  Penta::MaxVel(IssmDouble* pmaxvel, bool process_units){
     3362void  Penta::MaxVel(IssmDouble* pmaxvel){
    33633363
    33643364        /*Get maximum:*/
    … …  
    33713371/*}}}*/
    33723372/*FUNCTION Penta::MaxVx{{{*/
    3373 void  Penta::MaxVx(IssmDouble* pmaxvx, bool process_units){
     3373void  Penta::MaxVx(IssmDouble* pmaxvx){
    33743374
    33753375        /*Get maximum:*/
    … …  
    33813381/*}}}*/
    33823382/*FUNCTION Penta::MaxVy{{{*/
    3383 void  Penta::MaxVy(IssmDouble* pmaxvy, bool process_units){
     3383void  Penta::MaxVy(IssmDouble* pmaxvy){
    33843384
    33853385        /*Get maximum:*/
    … …  
    33913391/*}}}*/
    33923392/*FUNCTION Penta::MaxVz{{{*/
    3393 void  Penta::MaxVz(IssmDouble* pmaxvz, bool process_units){
     3393void  Penta::MaxVz(IssmDouble* pmaxvz){
    33943394
    33953395        /*Get maximum:*/
    … …  
    54155415/*}}}*/
    54165416/*FUNCTION Penta::SurfaceAverageVelMisfit {{{*/
    5417 IssmDouble Penta::SurfaceAverageVelMisfit(bool process_units,int weight_index){
     5417IssmDouble Penta::SurfaceAverageVelMisfit(int weight_index){
    54185418
    54195419        int    approximation;
    … …  
    54385438                 * and compute SurfaceAverageVelMisfit*/
    54395439                tria=(Tria*)SpawnTria(0,1,2); //nodes 0, 1 and 2 make the new tria (lower face).
    5440                 J=tria->SurfaceAverageVelMisfit(process_units,weight_index);
     5440                J=tria->SurfaceAverageVelMisfit(weight_index);
    54415441                delete tria->material; delete tria;
    54425442                return J;
    … …  
    54455445
    54465446                tria=(Tria*)SpawnTria(3,4,5); //nodes 3, 4 and 5 make the new tria (upper face).
    5447                 J=tria->SurfaceAverageVelMisfit(process_units,weight_index);
     5447                J=tria->SurfaceAverageVelMisfit(weight_index);
    54485448                delete tria->material; delete tria;
    54495449                return J;
    … …  
    54525452/*}}}*/
    54535453/*FUNCTION Penta::SurfaceAbsVelMisfit {{{*/
    5454 IssmDouble Penta::SurfaceAbsVelMisfit(bool process_units,int weight_index){
     5454IssmDouble Penta::SurfaceAbsVelMisfit(int weight_index){
    54555455
    54565456        int    approximation;
    … …  
    54755475                 * and compute SurfaceAbsVelMisfit*/
    54765476                tria=(Tria*)SpawnTria(0,1,2); //nodes 0, 1 and 2 make the new tria (lower face).
    5477                 J=tria->SurfaceAbsVelMisfit(process_units,weight_index);
     5477                J=tria->SurfaceAbsVelMisfit(weight_index);
    54785478                delete tria->material; delete tria;
    54795479                return J;
    … …  
    54825482
    54835483                tria=(Tria*)SpawnTria(3,4,5); //nodes 3, 4 and 5 make the new tria (upper face).
    5484                 J=tria->SurfaceAbsVelMisfit(process_units,weight_index);
     5484                J=tria->SurfaceAbsVelMisfit(weight_index);
    54855485                delete tria->material; delete tria;
    54865486                return J;
    … …  
    54895489/*}}}*/
    54905490/*FUNCTION Penta::SurfaceLogVelMisfit {{{*/
    5491 IssmDouble Penta::SurfaceLogVelMisfit(bool process_units,int weight_index){
     5491IssmDouble Penta::SurfaceLogVelMisfit(int weight_index){
    54925492
    54935493        int    approximation;
    … …  
    55125512                 * and compute SurfaceLogVelMisfit*/
    55135513                tria=(Tria*)SpawnTria(0,1,2); //nodes 0, 1 and 2 make the new tria (lower face).
    5514                 J=tria->SurfaceLogVelMisfit(process_units,weight_index);
     5514                J=tria->SurfaceLogVelMisfit(weight_index);
    55155515                delete tria->material; delete tria;
    55165516                return J;
    … …  
    55195519
    55205520                tria=(Tria*)SpawnTria(3,4,5); //nodes 3, 4 and 5 make the new tria (upper face).
    5521                 J=tria->SurfaceLogVelMisfit(process_units,weight_index);
     5521                J=tria->SurfaceLogVelMisfit(weight_index);
    55225522                delete tria->material; delete tria;
    55235523                return J;
    … …  
    55265526/*}}}*/
    55275527/*FUNCTION Penta::SurfaceLogVxVyMisfit {{{*/
    5528 IssmDouble Penta::SurfaceLogVxVyMisfit(bool process_units,int weight_index){
     5528IssmDouble Penta::SurfaceLogVxVyMisfit(int weight_index){
    55295529
    55305530        IssmDouble J;
    … …  
    55515551                 * and compute SurfaceLogVxVyMisfit*/
    55525552                tria=(Tria*)SpawnTria(0,1,2); //nodes 0, 1 and 2 make the new tria (lower face).
    5553                 J=tria->SurfaceLogVxVyMisfit(process_units,weight_index);
     5553                J=tria->SurfaceLogVxVyMisfit(weight_index);
    55545554                delete tria->material; delete tria;
    55555555                return J;
    … …  
    55585558
    55595559                tria=(Tria*)SpawnTria(3,4,5); //nodes 3, 4 and 5 make the new tria (upper face).
    5560                 J=tria->SurfaceLogVxVyMisfit(process_units,weight_index);
     5560                J=tria->SurfaceLogVxVyMisfit(weight_index);
    55615561                delete tria->material; delete tria;
    55625562                return J;
    … …  
    55655565/*}}}*/
    55665566/*FUNCTION Penta::SurfaceRelVelMisfit {{{*/
    5567 IssmDouble Penta::SurfaceRelVelMisfit(bool process_units,int weight_index){
     5567IssmDouble Penta::SurfaceRelVelMisfit(int weight_index){
    55685568
    55695569        int    approximation;
    … …  
    55885588                 * and compute SurfaceRelVelMisfit*/
    55895589                tria=(Tria*)SpawnTria(0,1,2); //nodes 0, 1 and 2 make the new tria (lower face).
    5590                 J=tria->SurfaceRelVelMisfit(process_units,weight_index);
     5590                J=tria->SurfaceRelVelMisfit(weight_index);
    55915591                delete tria->material; delete tria;
    55925592                return J;
    … …  
    55955595
    55965596                tria=(Tria*)SpawnTria(3,4,5); //nodes 3, 4 and 5 make the new tria (upper face).
    5597                 J=tria->SurfaceRelVelMisfit(process_units,weight_index);
     5597                J=tria->SurfaceRelVelMisfit(weight_index);
    55985598                delete tria->material; delete tria;
    55995599                return J;
    … …  
    56025602/*}}}*/
    56035603/*FUNCTION Penta::ThicknessAbsGradient{{{*/
    5604 IssmDouble Penta::ThicknessAbsGradient(bool process_units,int weight_index){
     5604IssmDouble Penta::ThicknessAbsGradient(int weight_index){
    56055605
    56065606        _error_("Not implemented yet");
    … …  
    56085608/*}}}*/
    56095609/*FUNCTION Penta::ThicknessAbsMisfit {{{*/
    5610 IssmDouble Penta::ThicknessAbsMisfit(bool process_units,int weight_index){
     5610IssmDouble Penta::ThicknessAbsMisfit(int weight_index){
    56115611
    56125612        int    approximation;
    … …  
    56225622
    56235623        tria=(Tria*)SpawnTria(0,1,2);
    5624         J=tria->ThicknessAbsMisfit(process_units,weight_index);
     5624        J=tria->ThicknessAbsMisfit(weight_index);
    56255625        delete tria->material; delete tria;
    56265626        return J;
    … …  
    56285628/*}}}*/
    56295629/*FUNCTION Penta::DragCoefficientAbsGradient{{{*/
    5630 IssmDouble Penta::DragCoefficientAbsGradient(bool process_units,int weight_index){
     5630IssmDouble Penta::DragCoefficientAbsGradient(int weight_index){
    56315631
    56325632        IssmDouble J;
    … …  
    56375637
    56385638        tria=(Tria*)SpawnTria(0,1,2); //nodes 0, 1 and 2 make the new tria
    5639         J=tria->DragCoefficientAbsGradient(process_units,weight_index);
     5639        J=tria->DragCoefficientAbsGradient(weight_index);
    56405640        delete tria->material; delete tria;
    56415641        return J;
    … …  
    56435643/*}}}*/
    56445644/*FUNCTION Penta::RheologyBbarAbsGradient{{{*/
    5645 IssmDouble Penta::RheologyBbarAbsGradient(bool process_units,int weight_index){
     5645IssmDouble Penta::RheologyBbarAbsGradient(int weight_index){
    56465646
    56475647        IssmDouble J;
    … …  
    56525652
    56535653        tria=(Tria*)SpawnTria(0,1,2); //nodes 0, 1 and 2 make the new tria
    5654         J=tria->RheologyBbarAbsGradient(process_units,weight_index);
     5654        J=tria->RheologyBbarAbsGradient(weight_index);
    56555655        delete tria->material; delete tria;
    56565656        return J;

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

    r15129 r15130  
    118118                void   Update(int index, IoModel* iomodel,int analysis_counter,int analysis_type);
    119119                int    UpdatePotentialUngrounding(IssmDouble* potential_sheet_ungrounding,Vector<IssmDouble>* vec_nodes_on_iceshelf,IssmDouble* nodes_on_iceshelf);
    120                 int    NodalValue(IssmDouble* pvalue, int index, int natureofdataenum,bool process_units);
     120                int    NodalValue(IssmDouble* pvalue, int index, int natureofdataenum);
    121121                IssmDouble TimeAdapt();
    122122                int*   GetHorizontalNeighboorSids(void);
    … …  
    127127                IssmDouble IceVolume(void);
    128128                IssmDouble TotalSmb(void);
    129                 void   MinVel(IssmDouble* pminvel, bool process_units);
    130                 void   MinVx(IssmDouble* pminvx, bool process_units);
    131                 void   MinVy(IssmDouble* pminvy, bool process_units);
    132                 void   MinVz(IssmDouble* pminvz, bool process_units);
    133                 IssmDouble MassFlux(IssmDouble* segment,bool process_units);
    134                 void   MaxAbsVx(IssmDouble* pmaxabsvx, bool process_units);
    135                 void   MaxAbsVy(IssmDouble* pmaxabsvy, bool process_units);
    136                 void   MaxAbsVz(IssmDouble* pmaxabsvz, bool process_units);
    137                 void   MaxVel(IssmDouble* pmaxvel, bool process_units);
     129                void   MinVel(IssmDouble* pminvel);
     130                void   MinVx(IssmDouble* pminvx);
     131                void   MinVy(IssmDouble* pminvy);
     132                void   MinVz(IssmDouble* pminvz);
     133                IssmDouble MassFlux(IssmDouble* segment);
     134                void   MaxAbsVx(IssmDouble* pmaxabsvx);
     135                void   MaxAbsVy(IssmDouble* pmaxabsvy);
     136                void   MaxAbsVz(IssmDouble* pmaxabsvz);
     137                void   MaxVel(IssmDouble* pmaxvel);
    138138                void   ElementResponse(IssmDouble* presponse,int response_enum);
    139                 void   MaxVx(IssmDouble* pmaxvx, bool process_units);
    140                 void   MaxVy(IssmDouble* pmaxvy, bool process_units);
    141                 void   MaxVz(IssmDouble* pmaxvz, bool process_units);
     139                void   MaxVx(IssmDouble* pmaxvx);
     140                void   MaxVy(IssmDouble* pmaxvy);
     141                void   MaxVz(IssmDouble* pmaxvz);
    142142                #endif
    143143
    … …  
    147147
    148148                #ifdef _HAVE_CONTROL_
    149                 IssmDouble DragCoefficientAbsGradient(bool process_units,int weight_index);
     149                IssmDouble DragCoefficientAbsGradient(int weight_index);
    150150                void   GradientIndexing(int* indexing,int control_index);
    151151                void   Gradj(Vector<IssmDouble>* gradient,int control_type,int control_index);
    … …  
    161161                void   ControlInputScaleGradient(int enum_type,IssmDouble scale);
    162162                void   ControlInputSetGradient(IssmDouble* gradient,int enum_type,int control_index);
    163                 IssmDouble RheologyBbarAbsGradient(bool process_units,int weight_index);
    164                 IssmDouble ThicknessAbsMisfit(     bool process_units,int weight_index);
    165                 IssmDouble SurfaceAbsVelMisfit(    bool process_units,int weight_index);
    166                 IssmDouble SurfaceRelVelMisfit(    bool process_units,int weight_index);
    167                 IssmDouble SurfaceLogVelMisfit(    bool process_units,int weight_index);
    168                 IssmDouble SurfaceLogVxVyMisfit(   bool process_units,int weight_index);
    169                 IssmDouble SurfaceAverageVelMisfit(bool process_units,int weight_index);
    170                 IssmDouble ThicknessAbsGradient(bool process_units,int weight_index);
    171                 IssmDouble ThicknessAlongGradient( bool process_units,int weight_index){_error_("not supported");};
    172                 IssmDouble ThicknessAcrossGradient(bool process_units,int weight_index){_error_("not supported");};
    173                 IssmDouble BalancethicknessMisfit(bool process_units,int weight_index){_error_("not supported");};
     163                IssmDouble RheologyBbarAbsGradient(int weight_index);
     164                IssmDouble ThicknessAbsMisfit(     int weight_index);
     165                IssmDouble SurfaceAbsVelMisfit(    int weight_index);
     166                IssmDouble SurfaceRelVelMisfit(    int weight_index);
     167                IssmDouble SurfaceLogVelMisfit(    int weight_index);
     168                IssmDouble SurfaceLogVxVyMisfit(   int weight_index);
     169                IssmDouble SurfaceAverageVelMisfit(int weight_index);
     170                IssmDouble ThicknessAbsGradient(int weight_index);
     171                IssmDouble ThicknessAlongGradient( int weight_index){_error_("not supported");};
     172                IssmDouble ThicknessAcrossGradient(int weight_index){_error_("not supported");};
     173                IssmDouble BalancethicknessMisfit(int weight_index){_error_("not supported");};
    174174                void   InputControlUpdate(IssmDouble scalar,bool save_parameter);
    175175                #endif

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

    r15129 r15130  
    23572357/*}}}*/
    23582358/*FUNCTION Tria::NodalValue {{{*/
    2359 int    Tria::NodalValue(IssmDouble* pvalue, int index, int natureofdataenum,bool process_units){
     2359int    Tria::NodalValue(IssmDouble* pvalue, int index, int natureofdataenum){
    23602360
    23612361        int         found = 0;
    … …  
    26882688        /*Get for Vx and Vy, the max of abs value: */
    26892689        #ifdef _HAVE_RESPONSES_
    2690         this->MaxAbsVx(&maxabsvx,false);
    2691         this->MaxAbsVy(&maxabsvy,false);
     2690        this->MaxAbsVx(&maxabsvx);
     2691        this->MaxAbsVy(&maxabsvy);
    26922692        #else
    26932693                _error_("ISSM was not compiled with responses compiled in, exiting!");
    … …  
    28662866/*}}}*/
    28672867/*FUNCTION Tria::MassFlux {{{*/
    2868 IssmDouble Tria::MassFlux( IssmDouble* segment,bool process_units){
     2868IssmDouble Tria::MassFlux( IssmDouble* segment){
    28692869
    28702870        const int  numdofs=2;
    … …  
    29342934/*}}}*/
    29352935/*FUNCTION Tria::MaxAbsVx{{{*/
    2936 void  Tria::MaxAbsVx(IssmDouble* pmaxabsvx, bool process_units){
     2936void  Tria::MaxAbsVx(IssmDouble* pmaxabsvx){
    29372937
    29382938        /*Get maximum:*/
    … …  
    29442944/*}}}*/
    29452945/*FUNCTION Tria::MaxAbsVy{{{*/
    2946 void  Tria::MaxAbsVy(IssmDouble* pmaxabsvy, bool process_units){
     2946void  Tria::MaxAbsVy(IssmDouble* pmaxabsvy){
    29472947
    29482948        /*Get maximum:*/
    … …  
    29542954/*}}}*/
    29552955/*FUNCTION Tria::MaxAbsVz{{{*/
    2956 void  Tria::MaxAbsVz(IssmDouble* pmaxabsvz, bool process_units){
     2956void  Tria::MaxAbsVz(IssmDouble* pmaxabsvz){
    29572957
    29582958        /*Get maximum:*/
    … …  
    29642964/*}}}*/
    29652965/*FUNCTION Tria::MaxVel{{{*/
    2966 void  Tria::MaxVel(IssmDouble* pmaxvel, bool process_units){
     2966void  Tria::MaxVel(IssmDouble* pmaxvel){
    29672967
    29682968        /*Get maximum:*/
    … …  
    29742974/*}}}*/
    29752975/*FUNCTION Tria::MaxVx{{{*/
    2976 void  Tria::MaxVx(IssmDouble* pmaxvx, bool process_units){
     2976void  Tria::MaxVx(IssmDouble* pmaxvx){
    29772977
    29782978        /*Get maximum:*/
    … …  
    29842984/*}}}*/
    29852985/*FUNCTION Tria::MaxVy{{{*/
    2986 void  Tria::MaxVy(IssmDouble* pmaxvy, bool process_units){
     2986void  Tria::MaxVy(IssmDouble* pmaxvy){
    29872987
    29882988        /*Get maximum:*/
    … …  
    29952995/*}}}*/
    29962996/*FUNCTION Tria::MaxVz{{{*/
    2997 void  Tria::MaxVz(IssmDouble* pmaxvz, bool process_units){
     2997void  Tria::MaxVz(IssmDouble* pmaxvz){
    29982998
    29992999        /*Get maximum:*/
    … …  
    30053005/*}}}*/
    30063006/*FUNCTION Tria::MinVel{{{*/
    3007 void  Tria::MinVel(IssmDouble* pminvel, bool process_units){
     3007void  Tria::MinVel(IssmDouble* pminvel){
    30083008
    30093009        /*Get minimum:*/
    … …  
    30153015/*}}}*/
    30163016/*FUNCTION Tria::MinVx{{{*/
    3017 void  Tria::MinVx(IssmDouble* pminvx, bool process_units){
     3017void  Tria::MinVx(IssmDouble* pminvx){
    30183018
    30193019        /*Get minimum:*/
    … …  
    30253025/*}}}*/
    30263026/*FUNCTION Tria::MinVy{{{*/
    3027 void  Tria::MinVy(IssmDouble* pminvy, bool process_units){
     3027void  Tria::MinVy(IssmDouble* pminvy){
    30283028
    30293029        /*Get minimum:*/
    … …  
    30353035/*}}}*/
    30363036/*FUNCTION Tria::MinVz{{{*/
    3037 void  Tria::MinVz(IssmDouble* pminvz, bool process_units){
     3037void  Tria::MinVz(IssmDouble* pminvz){
    30383038
    30393039        /*Get minimum:*/
    … …  
    37933793#ifdef _HAVE_CONTROL_
    37943794/*FUNCTION Tria::BalancethicknessMisfit{{{*/
    3795 IssmDouble Tria::BalancethicknessMisfit(bool process_units,int weight_index){
     3795IssmDouble Tria::BalancethicknessMisfit(int weight_index){
    37963796
    37973797        /* Intermediaries */
    … …  
    45634563/*}}}*/
    45644564/*FUNCTION Tria::RheologyBbarAbsGradient{{{*/
    4565 IssmDouble Tria::RheologyBbarAbsGradient(bool process_units,int weight_index){
     4565IssmDouble Tria::RheologyBbarAbsGradient(int weight_index){
    45664566
    45674567        /* Intermediaries */
    … …  
    46064606/*}}}*/
    46074607/*FUNCTION Tria::SurfaceAverageVelMisfit {{{*/
    4608 IssmDouble Tria::SurfaceAverageVelMisfit(bool process_units,int weight_index){
     4608IssmDouble Tria::SurfaceAverageVelMisfit(int weight_index){
    46094609
    46104610        IssmDouble Jelem=0,S,Jdet;
    … …  
    46624662/*}}}*/
    46634663/*FUNCTION Tria::SurfaceLogVelMisfit {{{*/
    4664 IssmDouble Tria::SurfaceLogVelMisfit(bool process_units,int weight_index){
     4664IssmDouble Tria::SurfaceLogVelMisfit(int weight_index){
    46654665
    46664666        IssmDouble Jelem=0;
    … …  
    47224722/*}}}*/
    47234723/*FUNCTION Tria::SurfaceLogVxVyMisfit {{{*/
    4724 IssmDouble Tria::SurfaceLogVxVyMisfit(bool process_units,int weight_index){
     4724IssmDouble Tria::SurfaceLogVxVyMisfit(int weight_index){
    47254725
    47264726        int        fit=-1;
    … …  
    47844784/*}}}*/
    47854785/*FUNCTION Tria::SurfaceAbsVelMisfit {{{*/
    4786 IssmDouble Tria::SurfaceAbsVelMisfit(bool process_units,int weight_index){
     4786IssmDouble Tria::SurfaceAbsVelMisfit(int weight_index){
    47874787
    47884788        IssmDouble Jelem=0;
    … …  
    48404840/*}}}*/
    48414841/*FUNCTION Tria::SurfaceRelVelMisfit {{{*/
    4842 IssmDouble Tria::SurfaceRelVelMisfit(bool process_units,int weight_index){
     4842IssmDouble Tria::SurfaceRelVelMisfit(int weight_index){
    48434843
    48444844        IssmDouble  Jelem=0;
    … …  
    49014901/*}}}*/
    49024902/*FUNCTION Tria::ThicknessAbsGradient{{{*/
    4903 IssmDouble Tria::ThicknessAbsGradient(bool process_units,int weight_index){
     4903IssmDouble Tria::ThicknessAbsGradient(int weight_index){
    49044904
    49054905        /* Intermediaries */
    … …  
    49444944/*}}}*/
    49454945/*FUNCTION Tria::ThicknessAlongGradient{{{*/
    4946 IssmDouble Tria::ThicknessAlongGradient(bool process_units,int weight_index){
     4946IssmDouble Tria::ThicknessAlongGradient(int weight_index){
    49474947
    49484948        /* Intermediaries */
    … …  
    49954995/*}}}*/
    49964996/*FUNCTION Tria::ThicknessAcrossGradient{{{*/
    4997 IssmDouble Tria::ThicknessAcrossGradient(bool process_units,int weight_index){
     4997IssmDouble Tria::ThicknessAcrossGradient(int weight_index){
    49984998
    49994999        /* Intermediaries */
    … …  
    50465046/*}}}*/
    50475047/*FUNCTION Tria::ThicknessAbsMisfit {{{*/
    5048 IssmDouble Tria::ThicknessAbsMisfit(bool process_units,int weight_index){
     5048IssmDouble Tria::ThicknessAbsMisfit(int weight_index){
    50495049
    50505050        /*Intermediaries*/
    … …  
    55455545/*}}}*/
    55465546/*FUNCTION Tria::DragCoefficientAbsGradient{{{*/
    5547 IssmDouble Tria::DragCoefficientAbsGradient(bool process_units,int weight_index){
     5547IssmDouble Tria::DragCoefficientAbsGradient(int weight_index){
    55485548
    55495549        /* Intermediaries */

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

    r15129 r15130  
    106106                void   MaterialUpdateFromTemperature(void){_error_("not implemented yet");};
    107107                void   MigrateGroundingLine(IssmDouble* oldfloating,IssmDouble* sheet_ungrounding);
    108                 int    NodalValue(IssmDouble* pvalue, int index, int natureofdataenum,bool process_units);
     108                int    NodalValue(IssmDouble* pvalue, int index, int natureofdataenum);
    109109                void   PotentialUngrounding(Vector<IssmDouble>* potential_sheet_ungrounding);
    110110                void   PositiveDegreeDay(IssmDouble* pdds,IssmDouble* pds,IssmDouble signorm);
    … …  
    125125                IssmDouble IceVolume(void);
    126126                IssmDouble TotalSmb(void);
    127                 void   MinVel(IssmDouble* pminvel, bool process_units);
    128                 void   MinVx(IssmDouble* pminvx, bool process_units);
    129                 void   MinVy(IssmDouble* pminvy, bool process_units);
    130                 void   MinVz(IssmDouble* pminvz, bool process_units);
    131                 IssmDouble MassFlux(IssmDouble* segment,bool process_units);
    132                 void   MaxAbsVx(IssmDouble* pmaxabsvx, bool process_units);
    133                 void   MaxAbsVy(IssmDouble* pmaxabsvy, bool process_units);
    134                 void   MaxAbsVz(IssmDouble* pmaxabsvz, bool process_units);
     127                void   MinVel(IssmDouble* pminvel);
     128                void   MinVx(IssmDouble* pminvx);
     129                void   MinVy(IssmDouble* pminvy);
     130                void   MinVz(IssmDouble* pminvz);
     131                IssmDouble MassFlux(IssmDouble* segment);
     132                void   MaxAbsVx(IssmDouble* pmaxabsvx);
     133                void   MaxAbsVy(IssmDouble* pmaxabsvy);
     134                void   MaxAbsVz(IssmDouble* pmaxabsvz);
    135135                void   ElementResponse(IssmDouble* presponse,int response_enum);
    136                 void   MaxVel(IssmDouble* pmaxvel, bool process_units);
    137                 void   MaxVx(IssmDouble* pmaxvx, bool process_units);
    138                 void   MaxVy(IssmDouble* pmaxvy, bool process_units);
    139                 void   MaxVz(IssmDouble* pmaxvz, bool process_units);
     136                void   MaxVel(IssmDouble* pmaxvel);
     137                void   MaxVx(IssmDouble* pmaxvx);
     138                void   MaxVy(IssmDouble* pmaxvy);
     139                void   MaxVz(IssmDouble* pmaxvz);
    140140                #endif
    141141
    … …  
    145145
    146146                #ifdef _HAVE_CONTROL_
    147                 IssmDouble DragCoefficientAbsGradient(bool process_units,int weight_index);
     147                IssmDouble DragCoefficientAbsGradient(int weight_index);
    148148                void   GradientIndexing(int* indexing,int control_index);
    149149                void   Gradj(Vector<IssmDouble>* gradient,int control_type,int control_index);
    … …  
    164164                void   ControlInputScaleGradient(int enum_type,IssmDouble scale);
    165165                void   ControlInputSetGradient(IssmDouble* gradient,int enum_type,int control_index);
    166                 IssmDouble RheologyBbarAbsGradient(bool process_units,int weight_index);
    167                 IssmDouble ThicknessAbsMisfit(     bool process_units,int weight_index);
    168                 IssmDouble SurfaceAbsVelMisfit(    bool process_units,int weight_index);
    169                 IssmDouble ThicknessAbsGradient(   bool process_units,int weight_index);
    170                 IssmDouble ThicknessAlongGradient( bool process_units,int weight_index);
    171                 IssmDouble ThicknessAcrossGradient(bool process_units,int weight_index);
    172                 IssmDouble BalancethicknessMisfit(     bool process_units,int weight_index);
    173                 IssmDouble SurfaceRelVelMisfit(    bool process_units,int weight_index);
    174                 IssmDouble SurfaceLogVelMisfit(    bool process_units,int weight_index);
    175                 IssmDouble SurfaceLogVxVyMisfit(   bool process_units,int weight_index);
    176                 IssmDouble SurfaceAverageVelMisfit(bool process_units,int weight_index);
     166                IssmDouble RheologyBbarAbsGradient(int weight_index);
     167                IssmDouble ThicknessAbsMisfit(     int weight_index);
     168                IssmDouble SurfaceAbsVelMisfit(    int weight_index);
     169                IssmDouble ThicknessAbsGradient(   int weight_index);
     170                IssmDouble ThicknessAlongGradient( int weight_index);
     171                IssmDouble ThicknessAcrossGradient(int weight_index);
     172                IssmDouble BalancethicknessMisfit(     int weight_index);
     173                IssmDouble SurfaceRelVelMisfit(    int weight_index);
     174                IssmDouble SurfaceLogVelMisfit(    int weight_index);
     175                IssmDouble SurfaceLogVxVyMisfit(   int weight_index);
     176                IssmDouble SurfaceAverageVelMisfit(int weight_index);
    177177                void   InputControlUpdate(IssmDouble scalar,bool save_parameter);
    178178                #endif

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

    r15129 r15130  
    686686}
    687687/*}}}*/
    688 void FemModel::Responsex(IssmDouble* responses,const char* response_descriptor,bool process_units,int weight_index){/*{{{*/
     688void FemModel::Responsex(IssmDouble* responses,const char* response_descriptor,int weight_index){/*{{{*/
    689689
    690690        int response_descriptor_enum=StringToEnumx(response_descriptor);
    691         this->Responsex(responses, response_descriptor_enum, process_units, weight_index);
    692 
    693 }
    694 /*}}}*/
    695 void FemModel::Responsex(IssmDouble* responses,int response_descriptor_enum,bool process_units,int weight_index){/*{{{*/
     691        this->Responsex(responses, response_descriptor_enum,weight_index);
     692
     693}
     694/*}}}*/
     695void FemModel::Responsex(IssmDouble* responses,int response_descriptor_enum,int weight_index){/*{{{*/
    696696
    697697        switch (response_descriptor_enum){
    698698
    699699                #ifdef _HAVE_RESPONSES_
    700                 case IceVolumeEnum:              this->IceVolumex(responses,process_units); break;
    701                 case MinVelEnum:                 this->MinVelx(responses,process_units); break;
    702                 case MaxVelEnum:                 this->MaxVelx(                  responses,process_units); break;
    703                 case MinVxEnum:                  this->MinVxx(responses,process_units); break;
    704                 case MaxVxEnum:                  this->MaxVxx(                   responses,process_units); break;
    705                 case MaxAbsVxEnum:               this->MaxAbsVxx(                responses,process_units); break;
    706                 case MinVyEnum:                  this->MinVyx(responses,process_units); break;
    707                 case MaxVyEnum:                  this->MaxVyx(                   responses,process_units); break;
    708                 case MaxAbsVyEnum:               this->MaxAbsVyx(                responses,process_units); break;
    709                 case MinVzEnum:                  this->MinVzx(responses,process_units); break;
    710                 case MaxVzEnum:                  this->MaxVzx(                   responses,process_units); break;
    711                 case MaxAbsVzEnum:               this->MaxAbsVzx(                responses,process_units); break;
    712                 case MassFluxEnum:               this->MassFluxx(         responses,process_units); break;
     700                case IceVolumeEnum:              this->IceVolumex(responses); break;
     701                case MinVelEnum:                 this->MinVelx(responses); break;
     702                case MaxVelEnum:                 this->MaxVelx(                  responses); break;
     703                case MinVxEnum:                  this->MinVxx(responses); break;
     704                case MaxVxEnum:                  this->MaxVxx(                   responses); break;
     705                case MaxAbsVxEnum:               this->MaxAbsVxx(                responses); break;
     706                case MinVyEnum:                  this->MinVyx(responses); break;
     707                case MaxVyEnum:                  this->MaxVyx(                   responses); break;
     708                case MaxAbsVyEnum:               this->MaxAbsVyx(                responses); break;
     709                case MinVzEnum:                  this->MinVzx(responses); break;
     710                case MaxVzEnum:                  this->MaxVzx(                   responses); break;
     711                case MaxAbsVzEnum:               this->MaxAbsVzx(                responses); break;
     712                case MassFluxEnum:               this->MassFluxx(         responses); break;
    713713                #ifdef _HAVE_CONTROL_
    714                 case SurfaceAbsVelMisfitEnum:    SurfaceAbsVelMisfitx(responses, elements,nodes, vertices, loads, materials, parameters,process_units,weight_index); break;
    715                 case SurfaceRelVelMisfitEnum:    SurfaceRelVelMisfitx(responses, elements,nodes, vertices, loads, materials, parameters,process_units,weight_index); break;
    716                 case SurfaceLogVelMisfitEnum:    SurfaceLogVelMisfitx(responses, elements,nodes, vertices, loads, materials, parameters,process_units,weight_index); break;
    717                 case SurfaceLogVxVyMisfitEnum:   SurfaceLogVxVyMisfitx(responses, elements,nodes, vertices, loads, materials, parameters,process_units,weight_index); break;
    718                 case SurfaceAverageVelMisfitEnum:SurfaceAverageVelMisfitx( responses, elements,nodes, vertices, loads, materials, parameters,process_units,weight_index); break;
    719                 case ThicknessAbsMisfitEnum:     ThicknessAbsMisfitx(responses, elements,nodes, vertices, loads, materials, parameters,process_units,weight_index); break;
    720                 case ThicknessAbsGradientEnum:   this->ThicknessAbsGradientx(responses, process_units,weight_index); break;
    721                 case ThicknessAlongGradientEnum: ThicknessAlongGradientx(responses, elements,nodes, vertices, loads, materials, parameters,process_units,weight_index); break;
    722                 case ThicknessAcrossGradientEnum:ThicknessAcrossGradientx(responses, elements,nodes, vertices, loads, materials, parameters,process_units,weight_index); break;
    723                 case RheologyBbarAbsGradientEnum:RheologyBbarAbsGradientx(responses, elements,nodes, vertices, loads, materials, parameters,process_units,weight_index); break;
    724                 case DragCoefficientAbsGradientEnum:DragCoefficientAbsGradientx(responses, elements,nodes, vertices, loads, materials, parameters,process_units,weight_index); break;
    725                 case BalancethicknessMisfitEnum:BalancethicknessMisfitx(responses,process_units,weight_index); break;
     714                case SurfaceAbsVelMisfitEnum:    SurfaceAbsVelMisfitx(responses, elements,nodes, vertices, loads, materials, parameters,weight_index); break;
     715                case SurfaceRelVelMisfitEnum:    SurfaceRelVelMisfitx(responses, elements,nodes, vertices, loads, materials, parameters,weight_index); break;
     716                case SurfaceLogVelMisfitEnum:    SurfaceLogVelMisfitx(responses, elements,nodes, vertices, loads, materials, parameters,weight_index); break;
     717                case SurfaceLogVxVyMisfitEnum:   SurfaceLogVxVyMisfitx(responses, elements,nodes, vertices, loads, materials, parameters,weight_index); break;
     718                case SurfaceAverageVelMisfitEnum:SurfaceAverageVelMisfitx( responses, elements,nodes, vertices, loads, materials, parameters,weight_index); break;
     719                case ThicknessAbsMisfitEnum:     ThicknessAbsMisfitx(responses, elements,nodes, vertices, loads, materials, parameters,weight_index); break;
     720                case ThicknessAbsGradientEnum:   this->ThicknessAbsGradientx(responses,weight_index); break;
     721                case ThicknessAlongGradientEnum: ThicknessAlongGradientx(responses, elements,nodes, vertices, loads, materials, parameters,weight_index); break;
     722                case ThicknessAcrossGradientEnum:ThicknessAcrossGradientx(responses, elements,nodes, vertices, loads, materials, parameters,weight_index); break;
     723                case RheologyBbarAbsGradientEnum:RheologyBbarAbsGradientx(responses, elements,nodes, vertices, loads, materials, parameters,weight_index); break;
     724                case DragCoefficientAbsGradientEnum:DragCoefficientAbsGradientx(responses, elements,nodes, vertices, loads, materials, parameters,weight_index); break;
     725                case BalancethicknessMisfitEnum:BalancethicknessMisfitx(responses,weight_index); break;
    726726                #endif
    727                 case TotalSmbEnum:                                      this->TotalSmbx(responses,process_units); break;
    728                 case MaterialsRheologyBbarEnum: this->ElementResponsex(responses,MaterialsRheologyBbarEnum,process_units); break;
    729                 case VelEnum:                   this->ElementResponsex(responses,VelEnum,process_units); break;
    730                 case FrictionCoefficientEnum:NodalValuex(responses, FrictionCoefficientEnum,elements,nodes, vertices, loads, materials, parameters,process_units); break;
     727                case TotalSmbEnum:                                      this->TotalSmbx(responses); break;
     728                case MaterialsRheologyBbarEnum: this->ElementResponsex(responses,MaterialsRheologyBbarEnum); break;
     729                case VelEnum:                   this->ElementResponsex(responses,VelEnum); break;
     730                case FrictionCoefficientEnum:NodalValuex(responses, FrictionCoefficientEnum,elements,nodes, vertices, loads, materials, parameters); break;
    731731                default: _error_("response descriptor \"" << EnumToStringx(response_descriptor_enum) << "\" not supported yet!"); break;
    732732                #else
    … …  
    757757
    758758                                case IceVolumeEnum:
    759                                         Responsex(&output_value,"IceVolume",false,0);
     759                                        Responsex(&output_value,"IceVolume",0);
    760760                                        results->AddObject(new GenericExternalResult<double>(results->Size()+1,IceVolumeEnum,reCast<IssmPDouble>(output_value),step,time));
    761761                                        break;
    762762                                case TotalSmbEnum:
    763                                         Responsex(&output_value,"TotalSmb",false,0);
     763                                        Responsex(&output_value,"TotalSmb",0);
    764764                                        results->AddObject(new GenericExternalResult<double>(results->Size()+1,TotalSmbEnum,reCast<IssmPDouble>(output_value),step,time));
    765765                                        break;
    766766                                case MaxVelEnum:
    767                                         Responsex(&output_value,"MaxVel",false,0);
     767                                        Responsex(&output_value,"MaxVel",0);
    768768                                        results->AddObject(new GenericExternalResult<double>(results->Size()+1,MaxVelEnum,reCast<IssmPDouble>(output_value),step,time));
    769769                                        break;
    … …  
    951951/*}}}*/
    952952#ifdef _HAVE_RESPONSES_
    953 void FemModel::MassFluxx(IssmDouble* pmass_flux,bool process_units){/*{{{*/
     953void FemModel::MassFluxx(IssmDouble* pmass_flux){/*{{{*/
    954954
    955955        int          i,j;
    … …  
    987987                        if (element->Id()==element_id){
    988988                                /*We found the element which owns this segment, use it to compute the mass flux: */
    989                                 mass_flux+=element->MassFlux(segments+5*i+0,process_units);
     989                                mass_flux+=element->MassFlux(segments+5*i+0);
    990990                                break;
    991991                        }
    … …  
    10111011
    10121012}/*}}}*/
    1013 void FemModel::MaxAbsVxx(IssmDouble* pmaxabsvx,bool process_units){/*{{{*/
     1013void FemModel::MaxAbsVxx(IssmDouble* pmaxabsvx){/*{{{*/
    10141014
    10151015        int i;
    … …  
    10221022        for(i=0;i<this->elements->Size();i++){
    10231023                Element* element=(Element*)this->elements->GetObjectByOffset(i);
    1024                 element->MaxAbsVx(&element_maxabsvx,process_units);
     1024                element->MaxAbsVx(&element_maxabsvx);
    10251025                if(element_maxabsvx>maxabsvx) maxabsvx=element_maxabsvx;
    10261026        }
    … …  
    10371037
    10381038}/*}}}*/
    1039 void FemModel::MaxAbsVyx(IssmDouble* pmaxabsvy,bool process_units){/*{{{*/
     1039void FemModel::MaxAbsVyx(IssmDouble* pmaxabsvy){/*{{{*/
    10401040
    10411041        int i;
    … …  
    10481048        for(i=0;i<this->elements->Size();i++){
    10491049                Element* element=(Element*)this->elements->GetObjectByOffset(i);
    1050                 element->MaxAbsVy(&element_maxabsvy,process_units);
     1050                element->MaxAbsVy(&element_maxabsvy);
    10511051                if(element_maxabsvy>maxabsvy) maxabsvy=element_maxabsvy;
    10521052        }
    … …  
    10631063
    10641064}/*}}}*/
    1065 void FemModel::MaxAbsVzx(IssmDouble* pmaxabsvz,bool process_units){/*{{{*/
     1065void FemModel::MaxAbsVzx(IssmDouble* pmaxabsvz){/*{{{*/
    10661066
    10671067        int i;
    … …  
    10741074        for(i=0;i<this->elements->Size();i++){
    10751075                Element* element=(Element*)this->elements->GetObjectByOffset(i);
    1076                 element->MaxAbsVz(&element_maxabsvz,process_units);
     1076                element->MaxAbsVz(&element_maxabsvz);
    10771077                if(element_maxabsvz>maxabsvz) maxabsvz=element_maxabsvz;
    10781078        }
    … …  
    10891089
    10901090}/*}}}*/
    1091 void FemModel::MaxVelx(IssmDouble* pmaxvel,bool process_units){/*{{{*/
     1091void FemModel::MaxVelx(IssmDouble* pmaxvel){/*{{{*/
    10921092
    10931093        int i;
    … …  
    11001100        for(i=0;i<this->elements->Size();i++){
    11011101                Element* element=(Element*)this->elements->GetObjectByOffset(i);
    1102                 element->MaxVel(&element_maxvel,process_units);
     1102                element->MaxVel(&element_maxvel);
    11031103                if(element_maxvel>maxvel) maxvel=element_maxvel;
    11041104        }
    … …  
    11151115
    11161116}/*}}}*/
    1117 void FemModel::MaxVxx(IssmDouble* pmaxvx,bool process_units){/*{{{*/
     1117void FemModel::MaxVxx(IssmDouble* pmaxvx){/*{{{*/
    11181118
    11191119        int i;
    … …  
    11261126        for(i=0;i<this->elements->Size();i++){
    11271127                Element* element=(Element*)this->elements->GetObjectByOffset(i);
    1128                 element->MaxVx(&element_maxvx,process_units);
     1128                element->MaxVx(&element_maxvx);
    11291129                if(element_maxvx>maxvx) maxvx=element_maxvx;
    11301130        }
    … …  
    11411141
    11421142}/*}}}*/
    1143 void FemModel::MaxVyx(IssmDouble* pmaxvy,bool process_units){/*{{{*/
     1143void FemModel::MaxVyx(IssmDouble* pmaxvy){/*{{{*/
    11441144
    11451145        int i;
    … …  
    11521152        for(i=0;i<this->elements->Size();i++){
    11531153                Element* element=(Element*)this->elements->GetObjectByOffset(i);
    1154                 element->MaxVy(&element_maxvy,process_units);
     1154                element->MaxVy(&element_maxvy);
    11551155                if(element_maxvy>maxvy) maxvy=element_maxvy;
    11561156        }
    … …  
    11671167
    11681168}/*}}}*/
    1169 void FemModel::MaxVzx(IssmDouble* pmaxvz,bool process_units){/*{{{*/
     1169void FemModel::MaxVzx(IssmDouble* pmaxvz){/*{{{*/
    11701170
    11711171        int i;
    … …  
    11781178        for(i=0;i<this->elements->Size();i++){
    11791179                Element* element=(Element*)this->elements->GetObjectByOffset(i);
    1180                 element->MaxVz(&element_maxvz,process_units);
     1180                element->MaxVz(&element_maxvz);
    11811181                if(element_maxvz>maxvz) maxvz=element_maxvz;
    11821182        }
    … …  
    11931193
    11941194}/*}}}*/
    1195 void FemModel::MinVelx(IssmDouble* pminvel,bool process_units){/*{{{*/
     1195void FemModel::MinVelx(IssmDouble* pminvel){/*{{{*/
    11961196
    11971197        int i;
    … …  
    12041204        for(i=0;i<this->elements->Size();i++){
    12051205                Element* element=(Element*)this->elements->GetObjectByOffset(i);
    1206                 element->MinVel(&element_minvel,process_units);
     1206                element->MinVel(&element_minvel);
    12071207                if(element_minvel<minvel) minvel=element_minvel;
    12081208        }
    … …  
    12191219
    12201220}/*}}}*/
    1221 void FemModel::MinVxx(IssmDouble* pminvx,bool process_units){/*{{{*/
     1221void FemModel::MinVxx(IssmDouble* pminvx){/*{{{*/
    12221222
    12231223        int i;
    … …  
    12301230        for(i=0;i<this->elements->Size();i++){
    12311231                Element* element=(Element*)this->elements->GetObjectByOffset(i);
    1232                 element->MinVx(&element_minvx,process_units);
     1232                element->MinVx(&element_minvx);
    12331233                if(element_minvx<minvx) minvx=element_minvx;
    12341234        }
    … …  
    12451245
    12461246}/*}}}*/
    1247 void FemModel::MinVyx(IssmDouble* pminvy,bool process_units){/*{{{*/
     1247void FemModel::MinVyx(IssmDouble* pminvy){/*{{{*/
    12481248
    12491249        int i;
    … …  
    12561256        for(i=0;i<this->elements->Size();i++){
    12571257                Element* element=(Element*)this->elements->GetObjectByOffset(i);
    1258                 element->MinVy(&element_minvy,process_units);
     1258                element->MinVy(&element_minvy);
    12591259                if(element_minvy<minvy) minvy=element_minvy;
    12601260        }
    … …  
    12711271
    12721272}/*}}}*/
    1273 void FemModel::MinVzx(IssmDouble* pminvz,bool process_units){/*{{{*/
     1273void FemModel::MinVzx(IssmDouble* pminvz){/*{{{*/
    12741274
    12751275        int i;
    … …  
    12821282        for(i=0;i<this->elements->Size();i++){
    12831283                Element* element=(Element*)this->elements->GetObjectByOffset(i);
    1284                 element->MinVz(&element_minvz,process_units);
     1284                element->MinVz(&element_minvz);
    12851285                if(element_minvz<minvz) minvz=element_minvz;
    12861286        }
    … …  
    12971297
    12981298}/*}}}*/
    1299 void FemModel::TotalSmbx(IssmDouble* pSmb,bool process_units){/*{{{*/
     1299void FemModel::TotalSmbx(IssmDouble* pSmb){/*{{{*/
    13001300
    13011301        IssmDouble local_smb = 0;
    … …  
    13171317
    13181318}/*}}}*/
    1319 void FemModel::IceVolumex(IssmDouble* pV,bool process_units){/*{{{*/
     1319void FemModel::IceVolumex(IssmDouble* pV){/*{{{*/
    13201320
    13211321        IssmDouble local_ice_volume = 0;
    … …  
    13371337
    13381338}/*}}}*/
    1339 void FemModel::ElementResponsex(IssmDouble* presponse,int response_enum,bool process_units){/*{{{*/
     1339void FemModel::ElementResponsex(IssmDouble* presponse,int response_enum){/*{{{*/
    13401340
    13411341        int found=0;
    … …  
    13831383#endif
    13841384#ifdef _HAVE_CONTROL_
    1385 void FemModel::BalancethicknessMisfitx(IssmDouble* presponse,bool process_units,int weight_index){/*{{{*/
     1385void FemModel::BalancethicknessMisfitx(IssmDouble* presponse,int weight_index){/*{{{*/
    13861386
    13871387        IssmDouble J = 0;
    … …  
    13901390        for(int i=0;i<this->elements->Size();i++){
    13911391                Element* element=dynamic_cast<Element*>(this->elements->GetObjectByOffset(i));
    1392                 J+=element->BalancethicknessMisfit(process_units,weight_index);
     1392                J+=element->BalancethicknessMisfit(weight_index);
    13931393        }
    13941394        #ifdef _HAVE_MPI_
    … …  
    14021402
    14031403}/*}}}*/
    1404 void FemModel::ThicknessAbsGradientx( IssmDouble* pJ, bool process_units, int weight_index){/*{{{*/
     1404void FemModel::ThicknessAbsGradientx( IssmDouble* pJ, int weight_index){/*{{{*/
    14051405
    14061406        /*Intermediary*/
    … …  
    14151415        for (i=0;i<elements->Size();i++){
    14161416                element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
    1417                 J+=element->ThicknessAbsGradient(process_units,weight_index);
     1417                J+=element->ThicknessAbsGradient(weight_index);
    14181418        }
    14191419
    … …  
    14461446        J=0;
    14471447        for(int i=0;i<num_responses;i++){
    1448                 this->Responsex(&Jplus,EnumToStringx(responses[i]),false,i); //False means DO NOT process units
     1448                this->Responsex(&Jplus,EnumToStringx(responses[i]),i);
    14491449                J+=Jplus;
    14501450        }
    … …  
    14611461        int        i,j;
    14621462        int        my_rank;
    1463         bool       process_units = true;
    14641463
    14651464        /*intermediary: */
    … …  
    15141513                        parameters->SetParam(index,IndexEnum);
    15151514
    1516                         this->Responsex(&femmodel_response,root,process_units,0);//0 is the index for weights
     1515                        this->Responsex(&femmodel_response,root,0);//0 is the index for weights
    15171516
    15181517                        if(my_rank==0){
    … …  
    15331532
    15341533                        /*perfectly normal response function: */
    1535                         this->Responsex(&femmodel_response,root,process_units,0);//0 is the weight index
     1534                        this->Responsex(&femmodel_response,root,0);//0 is the weight index
    15361535
    15371536                        if(my_rank==0){

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

    r15067 r15130  
    6464                /*Modules*/
    6565                #ifdef _HAVE_RESPONSES_
    66                 void MassFluxx(IssmDouble* presponse,bool process_units);
    67                 void MaxAbsVxx(IssmDouble* presponse,bool process_units);
    68                 void MaxAbsVyx(IssmDouble* presponse,bool process_units);
    69                 void MaxAbsVzx(IssmDouble* presponse,bool process_units);
    70                 void MaxVelx(IssmDouble* presponse,bool process_units);
    71                 void MaxVxx(IssmDouble* presponse,bool process_units);
    72                 void MaxVyx(IssmDouble* presponse,bool process_units);
    73                 void MaxVzx(IssmDouble* presponse,bool process_units);
    74                 void MinVelx(IssmDouble* presponse,bool process_units);
    75                 void MinVxx(IssmDouble* presponse,bool process_units);
    76                 void MinVyx(IssmDouble* presponse,bool process_units);
    77                 void MinVzx(IssmDouble* presponse,bool process_units);
    78                 void TotalSmbx(IssmDouble* pSmb,bool process_units);
    79                 void IceVolumex(IssmDouble* pV,bool process_units);
    80                 void ElementResponsex(IssmDouble* presponse,int response_enum,bool process_units);
    81                 void BalancethicknessMisfitx(IssmDouble* pV,bool process_units,int weight_index);
     66                void MassFluxx(IssmDouble* presponse);
     67                void MaxAbsVxx(IssmDouble* presponse);
     68                void MaxAbsVyx(IssmDouble* presponse);
     69                void MaxAbsVzx(IssmDouble* presponse);
     70                void MaxVelx(IssmDouble* presponse);
     71                void MaxVxx(IssmDouble* presponse);
     72                void MaxVyx(IssmDouble* presponse);
     73                void MaxVzx(IssmDouble* presponse);
     74                void MinVelx(IssmDouble* presponse);
     75                void MinVxx(IssmDouble* presponse);
     76                void MinVyx(IssmDouble* presponse);
     77                void MinVzx(IssmDouble* presponse);
     78                void TotalSmbx(IssmDouble* pSmb);
     79                void IceVolumex(IssmDouble* pV);
     80                void ElementResponsex(IssmDouble* presponse,int response_enum);
     81                void BalancethicknessMisfitx(IssmDouble* pV,int weight_index);
    8282                #endif
    8383                #ifdef  _HAVE_DAKOTA_
    … …  
    8686                void RequestedOutputsx(int* requested_outputs, int numoutputs);
    8787                void RequestedDependentsx(void);
    88                 void Responsex(IssmDouble* presponse,int response_descriptor_enum,bool process_units,int weight_index);
    89                 void Responsex(IssmDouble* presponse,const char* response_descriptor,bool process_units,int weight_index);
     88                void Responsex(IssmDouble* presponse,int response_descriptor_enum,int weight_index);
     89                void Responsex(IssmDouble* presponse,const char* response_descriptor,int weight_index);
    9090                #ifdef _HAVE_CONTROL_
    9191                void CostFunctionx( IssmDouble* pJ);
    92                 void ThicknessAbsGradientx( IssmDouble* pJ, bool process_units,int weight_index);
     92                void ThicknessAbsGradientx( IssmDouble* pJ,int weight_index);
    9393                #endif
    9494                #ifdef _HAVE_GIA_

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

    r15104 r15130  
    124124/*}}}*/
    125125/*FUNCTION BoolInput::SquareMin{{{*/
    126 void BoolInput::SquareMin(IssmDouble* psquaremin, bool process_units,Parameters* parameters){
     126void BoolInput::SquareMin(IssmDouble* psquaremin,Parameters* parameters){
    127127        /*square of a bool is the bool itself: */
    128128        *psquaremin=value;

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

    r15082 r15130  
    6565                void GetVyStrainRate3dPattyn(IssmDouble* epsilonvy,IssmDouble* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
    6666                void ChangeEnum(int newenumtype);
    67                 void SquareMin(IssmDouble* psquaremin, bool process_units,Parameters* parameters);
     67                void SquareMin(IssmDouble* psquaremin, Parameters* parameters);
    6868                void ConstrainMin(IssmDouble minimum){_error_("not implemented yet");};
    6969                IssmDouble InfinityNorm(void){_error_("InfinityNorm not implemented for booleans");};

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

    r15082 r15130  
    7070                void GetVyStrainRate3dPattyn(IssmDouble* epsilonvy,IssmDouble* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
    7171                void ChangeEnum(int newenumtype){_error_("not implemented yet");};
    72                 void SquareMin(IssmDouble* psquaremin, bool process_units,Parameters* parameters){_error_("not implemented yet");};
     72                void SquareMin(IssmDouble* psquaremin,Parameters* parameters){_error_("not implemented yet");};
    7373                void ConstrainMin(IssmDouble minimum){_error_("not implemented yet");};
    7474                void Scale(IssmDouble scale_factor){_error_("not implemented yet");};

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

    r15082 r15130  
    6464                void GetVyStrainRate3dPattyn(IssmDouble* epsilonvy,IssmDouble* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
    6565                void ChangeEnum(int newenumtype){_error_("not implemented yet");};
    66                 void SquareMin(IssmDouble* psquaremin, bool process_units,Parameters* parameters){_error_("not implemented yet");};
     66                void SquareMin(IssmDouble* psquaremin,Parameters* parameters){_error_("not implemented yet");};
    6767                void ConstrainMin(IssmDouble minimum){_error_("not implemented yet");};
    6868                void Scale(IssmDouble scale_factor){_error_("not implemented yet");};

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

    r15104 r15130  
    174174/*}}}*/
    175175/*FUNCTION DoubleInput::SquareMin{{{*/
    176 void DoubleInput::SquareMin(IssmDouble* psquaremin, bool process_units,Parameters* parameters){
     176void DoubleInput::SquareMin(IssmDouble* psquaremin,Parameters* parameters){
    177177
    178178        /*square min of a IssmDouble is the square of the IssmDouble itself: */

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

    r15082 r15130  
    6464                void GetVyStrainRate3dPattyn(IssmDouble* epsilonvy,IssmDouble* xyz_list, GaussPenta* gauss);
    6565                void ChangeEnum(int newenumtype);
    66                 void SquareMin(IssmDouble* psquaremin, bool process_units,Parameters* parameters);
     66                void SquareMin(IssmDouble* psquaremin,Parameters* parameters);
    6767                void ConstrainMin(IssmDouble minimum);
    6868                void Scale(IssmDouble scale_factor);

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

    r15082 r15130  
    4949                virtual void Configure(Parameters* parameters)=0;
    5050
    51                 virtual void   SquareMin(IssmDouble* psquaremin, bool process_units,Parameters* parameters)=0;
     51                virtual void   SquareMin(IssmDouble* psquaremin,Parameters* parameters)=0;
    5252                virtual void   ConstrainMin(IssmDouble minimum)=0;
    5353                virtual IssmDouble InfinityNorm(void)=0;

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

    r15104 r15130  
    125125/*}}}*/
    126126/*FUNCTION IntInput::SquareMin{{{*/
    127 void IntInput::SquareMin(IssmDouble* psquaremin, bool process_units,Parameters* parameters){
     127void IntInput::SquareMin(IssmDouble* psquaremin,Parameters* parameters){
    128128
    129129        /*square min of an integer is the square of the integer itself: */

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

    r15082 r15130  
    6666                void GetVyStrainRate3dPattyn(IssmDouble* epsilonvy,IssmDouble* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
    6767                void ChangeEnum(int newenumtype);
    68                 void SquareMin(IssmDouble* psquaremin, bool process_units,Parameters* parameters);
     68                void SquareMin(IssmDouble* psquaremin,Parameters* parameters);
    6969                void ConstrainMin(IssmDouble minimum){_error_("not implemented yet");};
    7070                void Scale(IssmDouble scale_factor);

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

    r15128 r15130  
    328328/*Intermediary*/
    329329/*FUNCTION PentaP1Input::SquareMin{{{*/
    330 void PentaP1Input::SquareMin(IssmDouble* psquaremin, bool process_units,Parameters* parameters){
     330void PentaP1Input::SquareMin(IssmDouble* psquaremin,Parameters* parameters){
    331331
    332332        int i;

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

    r15082 r15130  
    6868                void ChangeEnum(int newenumtype);
    6969
    70                 void SquareMin(IssmDouble* psquaremin, bool process_units,Parameters* parameters);
     70                void SquareMin(IssmDouble* psquaremin,Parameters* parameters);
    7171                void ConstrainMin(IssmDouble minimum);
    7272                void Scale(IssmDouble scale_factor);

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

    r15104 r15130  
    348348/*}}}*/
    349349/*FUNCTION TransientInput::SquareMin{{{*/
    350 void TransientInput::SquareMin(IssmDouble* psquaremin, bool process_units,Parameters* parameters){
     350void TransientInput::SquareMin(IssmDouble* psquaremin,Parameters* parameters){
    351351
    352352        IssmDouble time;
    … …  
    359359
    360360        /*Call input function*/
    361         input->SquareMin(psquaremin,process_units,parameters);
     361        input->SquareMin(psquaremin,parameters);
    362362
    363363        delete input;

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

    r15082 r15130  
    6969                void ChangeEnum(int newenumtype);
    7070
    71                 void SquareMin(IssmDouble* psquaremin, bool process_units,Parameters* parameters);
     71                void SquareMin(IssmDouble* psquaremin,Parameters* parameters);
    7272                void ConstrainMin(IssmDouble minimum){_error_("not implemented yet");};
    7373                void Scale(IssmDouble scale_factor){_error_("not implemented yet");};

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

    r15128 r15130  
    219219/*Intermediary*/
    220220/*FUNCTION TriaP1Input::SquareMin{{{*/
    221 void TriaP1Input::SquareMin(IssmDouble* psquaremin, bool process_units,Parameters* parameters){
     221void TriaP1Input::SquareMin(IssmDouble* psquaremin,Parameters* parameters){
    222222
    223223        int i;

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

    r15082 r15130  
    6767                void ChangeEnum(int newenumtype);
    6868
    69                 void SquareMin(IssmDouble* psquaremin, bool process_units,Parameters* parameters);
     69                void SquareMin(IssmDouble* psquaremin,Parameters* parameters);
    7070                void ConstrainMin(IssmDouble minimum);
    7171                void Scale(IssmDouble scale_factor);

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

    r14999 r15130  
    88#include "../../toolkits/toolkits.h"
    99
    10 void DragCoefficientAbsGradientx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units, int weight_index){
     10void DragCoefficientAbsGradientx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,int weight_index){
    1111
    1212        /*Intermediary*/
    … …  
    2121        for (i=0;i<elements->Size();i++){
    2222                element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
    23                 J+=element->DragCoefficientAbsGradient(process_units,weight_index);
     23                J+=element->DragCoefficientAbsGradient(weight_index);
    2424        }
    2525

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

    r15000 r15130  
    99
    1010/* local prototypes: */
    11 void DragCoefficientAbsGradientx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units,int weight_index);
     11void DragCoefficientAbsGradientx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,int weight_index);
    1212
    1313#endif

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

    r14999 r15130  
    88#include "../../toolkits/toolkits.h"
    99
    10 void NodalValuex( IssmDouble* pnodalvalue, int natureofdataenum,Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units){
     10void NodalValuex( IssmDouble* pnodalvalue, int natureofdataenum,Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters){
    1111
    1212        int my_rank;
    … …  
    2929        for(i=0;i<elements->Size();i++){
    3030                Element* element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
    31                 found=element->NodalValue(&value,index,natureofdataenum,process_units);
     31                found=element->NodalValue(&value,index,natureofdataenum);
    3232                if (found){
    3333                        cpu_found=my_rank;

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

    r15000 r15130  
    99
    1010/* local prototypes: */
    11 void NodalValuex( IssmDouble* pnodalvalue, int natureofdataenum,Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
     11void NodalValuex( IssmDouble* pnodalvalue, int natureofdataenum,Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters);
    1212
    1313#endif  /* _NODALVALUEX_H */

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

    r14999 r15130  
    88#include "../../toolkits/toolkits.h"
    99
    10 void RheologyBbarAbsGradientx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units, int weight_index){
     10void RheologyBbarAbsGradientx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters, int weight_index){
    1111
    1212        /*Intermediary*/
    … …  
    2121        for (i=0;i<elements->Size();i++){
    2222                element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
    23                 J+=element->RheologyBbarAbsGradient(process_units,weight_index);
     23                J+=element->RheologyBbarAbsGradient(weight_index);
    2424        }
    2525

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

    r15000 r15130  
    99
    1010/* local prototypes: */
    11 void RheologyBbarAbsGradientx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units,int weight_index);
     11void RheologyBbarAbsGradientx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,int weight_index);
    1212
    1313#endif

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

    r14999 r15130  
    88#include "../../toolkits/toolkits.h"
    99
    10 void SurfaceAbsVelMisfitx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units,int weight_index){
     10void SurfaceAbsVelMisfitx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,int weight_index){
    1111
    1212        /*Intermediary*/
    … …  
    2121        for (i=0;i<elements->Size();i++){
    2222                element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
    23                 J+=element->SurfaceAbsVelMisfit(process_units,weight_index);
     23                J+=element->SurfaceAbsVelMisfit(weight_index);
    2424        }
    2525

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

    r15000 r15130  
    99
    1010/* local prototypes: */
    11 void SurfaceAbsVelMisfitx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units,int weight_index);
     11void SurfaceAbsVelMisfitx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,int weight_index);
    1212
    1313#endif

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

    r14999 r15130  
    99#include "../SurfaceAreax/SurfaceAreax.h"
    1010
    11 void SurfaceAverageVelMisfitx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units,int weight_index){
     11void SurfaceAverageVelMisfitx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,int weight_index){
    1212
    1313        /*Intermediary*/
    … …  
    2525        for (i=0;i<elements->Size();i++){
    2626                element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
    27                 J+=element->SurfaceAverageVelMisfit(process_units,weight_index);
     27                J+=element->SurfaceAverageVelMisfit(weight_index);
    2828        }
    2929

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

    r15000 r15130  
    99
    1010/* local prototypes: */
    11 void SurfaceAverageVelMisfitx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units,int weight_index);
     11void SurfaceAverageVelMisfitx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,int weight_index);
    1212
    1313#endif

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

    r14999 r15130  
    88#include "../../toolkits/toolkits.h"
    99
    10 void SurfaceLogVelMisfitx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units,int weight_index){
     10void SurfaceLogVelMisfitx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,int weight_index){
    1111
    1212        /*Intermediary*/
    … …  
    2121        for (i=0;i<elements->Size();i++){
    2222                element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
    23                 J+=element->SurfaceLogVelMisfit(process_units,weight_index);
     23                J+=element->SurfaceLogVelMisfit(weight_index);
    2424        }
    2525

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

    r15000 r15130  
    99
    1010/* local prototypes: */
    11 void SurfaceLogVelMisfitx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units,int weight_index);
     11void SurfaceLogVelMisfitx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,int weight_index);
    1212
    1313#endif

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

    r14999 r15130  
    88#include "../../toolkits/toolkits.h"
    99
    10 void SurfaceLogVxVyMisfitx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units,int weight_index){
     10void SurfaceLogVxVyMisfitx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,int weight_index){
    1111
    1212        /*Intermediary*/
    … …  
    2121        for (i=0;i<elements->Size();i++){
    2222                element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
    23                 J+=element->SurfaceLogVxVyMisfit(process_units,weight_index);
     23                J+=element->SurfaceLogVxVyMisfit(weight_index);
    2424        }
    2525

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

    r15000 r15130  
    99
    1010/* local prototypes: */
    11 void SurfaceLogVxVyMisfitx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units,int weight_index);
     11void SurfaceLogVxVyMisfitx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,int weight_index);
    1212
    1313#endif

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

    r14999 r15130  
    88#include "../../toolkits/toolkits.h"
    99
    10 void SurfaceRelVelMisfitx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units,int weight_index){
     10void SurfaceRelVelMisfitx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,int weight_index){
    1111
    1212        /*Intermediary*/
    … …  
    2121        for (i=0;i<elements->Size();i++){
    2222                element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
    23                 J+=element->SurfaceRelVelMisfit(process_units,weight_index);
     23                J+=element->SurfaceRelVelMisfit(weight_index);
    2424        }
    2525

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

    r15000 r15130  
    99
    1010/* local prototypes: */
    11 void SurfaceRelVelMisfitx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units,int weight_index);
     11void SurfaceRelVelMisfitx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,int weight_index);
    1212
    1313#endif

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

    r14999 r15130  
    88#include "../../toolkits/toolkits.h"
    99
    10 void ThicknessAbsMisfitx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units, int weight_index){
     10void ThicknessAbsMisfitx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters, int weight_index){
    1111
    1212        /*Intermediary*/
    … …  
    2121        for (i=0;i<elements->Size();i++){
    2222                element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
    23                 J+=element->ThicknessAbsMisfit(process_units,weight_index);
     23                J+=element->ThicknessAbsMisfit(weight_index);
    2424        }
    2525

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

    r15000 r15130  
    99
    1010/* local prototypes: */
    11 void ThicknessAbsMisfitx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units,int weight_index);
     11void ThicknessAbsMisfitx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,int weight_index);
    1212
    1313#endif

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

    r14999 r15130  
    88#include "../../toolkits/toolkits.h"
    99
    10 void ThicknessAcrossGradientx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units, int weight_index){
     10void ThicknessAcrossGradientx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,int weight_index){
    1111
    1212        /*Intermediary*/
    … …  
    2121        for (i=0;i<elements->Size();i++){
    2222                element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
    23                 J+=element->ThicknessAcrossGradient(process_units,weight_index);
     23                J+=element->ThicknessAcrossGradient(weight_index);
    2424        }
    2525

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

    r15000 r15130  
    99
    1010/* local prototypes: */
    11 void ThicknessAcrossGradientx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units,int weight_index);
     11void ThicknessAcrossGradientx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,int weight_index);
    1212
    1313#endif

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

    r14999 r15130  
    88#include "../../toolkits/toolkits.h"
    99
    10 void ThicknessAlongGradientx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units, int weight_index){
     10void ThicknessAlongGradientx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,int weight_index){
    1111
    1212        /*Intermediary*/
    … …  
    2121        for (i=0;i<elements->Size();i++){
    2222                element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
    23                 J+=element->ThicknessAlongGradient(process_units,weight_index);
     23                J+=element->ThicknessAlongGradient(weight_index);
    2424        }
    2525

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

    r15000 r15130  
    99
    1010/* local prototypes: */
    11 void ThicknessAlongGradientx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units,int weight_index);
     11void ThicknessAlongGradientx( IssmDouble* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,int weight_index);
    1212
    1313#endif
Note: See TracChangeset for help on using the changeset viewer.