Changeset 15128


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

DEL: removed ProcessUnits from core, moved everything to m/py

Location:
issm/trunk-jpl/src
Files:
1 deleted
72 edited

Legend:

Unmodified
Added
Removed

  • issm/trunk-jpl/src/c/Makefile.am

    r15091 r15128  
    199199                                        ./shared/Numerics/extrema.cpp\
    200200                                        ./shared/Numerics/XZvectorsToCoordinateSystem.cpp\
    201                                         ./shared/Numerics/UnitConversion.cpp\
    202201                                        ./shared/Numerics/OptArgs.h\
    203202                                        ./shared/Numerics/OptPars.h\

  • issm/trunk-jpl/src/c/classes/ElementResults/BoolElementResult.cpp

    r15104 r15128  
    9292}
    9393/*}}}*/
    94 /*FUNCTION BoolElementResult::ProcessUnits{{{*/
    95 void BoolElementResult::ProcessUnits(Parameters* parameters){
    96 // no op
    97 }
    98 /*}}}*/
    9994/*FUNCTION BoolElementResult::NumberOfNodalValues{{{*/
    10095int BoolElementResult::NumberOfNodalValues(void){

  • issm/trunk-jpl/src/c/classes/ElementResults/BoolElementResult.h

    r15012 r15128  
    3737                IssmDouble  GetTime(void){return time;};
    3838                int     GetStep(void){return step;};
    39                 void    ProcessUnits(Parameters* parameters);
    4039                int     NumberOfNodalValues(void);
    4140                void    PatchFill(int row, Patch* patch);

  • issm/trunk-jpl/src/c/classes/ElementResults/DoubleElementResult.cpp

    r15104 r15128  
    9292}
    9393/*}}}*/
    94 /*FUNCTION DoubleElementResult::ProcessUnits{{{*/
    95 void DoubleElementResult::ProcessUnits(Parameters* parameters){
    96 
    97         this->value=UnitConversion(this->value,IuToExtEnum,this->enum_type);
    98 
    99 }
    100 /*}}}*/
    10194/*FUNCTION DoubleElementResult::NumberOfNodalValues{{{*/
    10295int DoubleElementResult::NumberOfNodalValues(void){

  • issm/trunk-jpl/src/c/classes/ElementResults/DoubleElementResult.h

    r15012 r15128  
    3737                IssmDouble  GetTime(void){return time;};
    3838                int     GetStep(void){return step;};
    39                 void    ProcessUnits(Parameters* parameters);
    4039                int     NumberOfNodalValues(void);
    4140                void    PatchFill(int row, Patch* patch);

  • issm/trunk-jpl/src/c/classes/ElementResults/ElementResult.h

    r15067 r15128  
    1919                virtual IssmDouble  GetTime(void)=0;
    2020                virtual int     GetStep(void)=0;
    21                 virtual void    ProcessUnits(Parameters* parameters)=0;
    2221                virtual int     NumberOfNodalValues(void)=0;
    2322                virtual void    PatchFill(int row, Patch* patch)=0;

  • issm/trunk-jpl/src/c/classes/ElementResults/PentaP1ElementResult.cpp

    r15104 r15128  
    103103}
    104104/*}}}*/
    105 /*FUNCTION PentaP1ElementResult::ProcessUnits{{{*/
    106 void PentaP1ElementResult::ProcessUnits(Parameters* parameters){
    107 
    108         UnitConversion(this->values,6,IuToExtEnum,this->enum_type);
    109 
    110 }
    111 /*}}}*/
    112105/*FUNCTION PentaP1ElementResult::NumberOfNodalValues{{{*/
    113106int PentaP1ElementResult::NumberOfNodalValues(void){

  • issm/trunk-jpl/src/c/classes/ElementResults/PentaP1ElementResult.h

    r15012 r15128  
    3636                IssmDouble  GetTime(void){return time;};
    3737                int     GetStep(void){return step;};
    38                 void    ProcessUnits(Parameters* parameters);
    3938                int     NumberOfNodalValues(void);
    4039                void    PatchFill(int row, Patch* patch);

  • issm/trunk-jpl/src/c/classes/ElementResults/TriaP1ElementResult.cpp

    r15104 r15128  
    9191}
    9292/*}}}*/
    93 /*FUNCTION TriaP1ElementResult::ProcessUnits{{{*/
    94 void TriaP1ElementResult::ProcessUnits(Parameters* parameters){
    95 
    96         UnitConversion(this->values,3,IuToExtEnum,this->enum_type);
    97 
    98 }
    99 /*}}}*/
    10093/*FUNCTION TriaP1ElementResult::NumberOfNodalValues{{{*/
    10194int TriaP1ElementResult::NumberOfNodalValues(void){

  • issm/trunk-jpl/src/c/classes/ElementResults/TriaP1ElementResult.h

    r15012 r15128  
    3535                IssmDouble  GetTime(void){return time;};
    3636                int     GetStep(void){return step;};
    37                 void    ProcessUnits(Parameters* parameters);
    3837                int     NumberOfNodalValues(void);
    3938                void    PatchFill(int row, Patch* patch);

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

    r15082 r15128  
    6969                virtual void   InputCreate(IssmDouble scalar,int name,int code)=0;
    7070                virtual void   InputCreate(IssmDouble* vector, int index,IoModel* iomodel,int M,int N,int vector_type,int vector_enum,int code)=0;
    71                 virtual void   ProcessResultsUnits(void)=0;
    7271                virtual void   RequestedOutput(int output_enum,int step,IssmDouble time)=0;
    7372

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

    r15051 r15128  
    5050        }
    5151
    52 }
    53 /*}}}*/
    54 /*FUNCTION Elements::ProcessResultsUnits{{{*/
    55 void Elements::ProcessResultsUnits(void){
    56 
    57         //Process results to be output in the correct units
    58         for(int i=0;i<this->Size();i++){
    59                 Element* element=dynamic_cast<Element*>(this->GetObjectByOffset(i));
    60                 element->ProcessResultsUnits();
    61         }
    6252}
    6353/*}}}*/

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

    r15067 r15128  
    2828                void   DeleteResults(void);
    2929                int    MaxNumNodes(void);
    30                 void   ProcessResultsUnits(void);
    3130                void   SetCurrentConfiguration(Elements* elements,Loads* loads, Nodes* nodes, Vertices* vertices, Materials* materials,Parameters* parameters);
    3231                void   ToResults(Results* results,Parameters* parameters);

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

    r15104 r15128  
    14331433                        for(i=0;i<6;i++)nodeinputs[i]=(IssmDouble)vector[penta_vertex_ids[i]-1];
    14341434
    1435                         /*process units: */
    1436                         UnitConversion(&nodeinputs[0], 6 ,ExtToIuEnum, vector_enum);
    1437 
    14381435                        /*create static input: */
    14391436                        this->inputs->AddInput(new PentaP1Input(vector_enum,nodeinputs));
    … …  
    14481445                                        nodeinputs[i]=(IssmDouble)vector[N*row+t];
    14491446                                }
    1450 
    1451                                 /*process units: */
    1452                                 UnitConversion(&nodeinputs[0], 6 ,ExtToIuEnum, vector_enum);
    14531447
    14541448                                /*time? :*/
    … …  
    25952589                        }
    25962590                }
    2597         }
    2598 }
    2599 /*}}}*/
    2600 /*FUNCTION Penta::ProcessResultsUnits{{{*/
    2601 void  Penta::ProcessResultsUnits(void){
    2602 
    2603         int i;
    2604 
    2605         for(i=0;i<this->results->Size();i++){
    2606                 ElementResult* elementresult=(ElementResult*)this->results->GetObjectByOffset(i);
    2607                 elementresult->ProcessUnits(this->parameters);
    26082591        }
    26092592}
    … …  
    32883271        IssmDouble minvel=this->inputs->Min(VelEnum);
    32893272
    3290         /*process units if requested: */
    3291         if(process_units) minvel=UnitConversion(minvel,IuToExtEnum,VelEnum);
    3292 
    32933273        /*Assign output pointers:*/
    32943274        *pminvel=minvel;
    … …  
    33013281        IssmDouble minvx=this->inputs->Min(VxEnum);
    33023282
    3303         /*process units if requested: */
    3304         if(process_units) minvx=UnitConversion(minvx,IuToExtEnum,VxEnum);
    3305 
    33063283        /*Assign output pointers:*/
    33073284        *pminvx=minvx;
    … …  
    33143291        IssmDouble minvy=this->inputs->Min(VyEnum);
    33153292
    3316         /*process units if requested: */
    3317         if(process_units) minvy=UnitConversion(minvy,IuToExtEnum,VyEnum);
    3318 
    33193293        /*Assign output pointers:*/
    33203294        *pminvy=minvy;
    … …  
    33263300        /*Get minimum:*/
    33273301        IssmDouble minvz=this->inputs->Min(VzEnum);
    3328 
    3329         /*process units if requested: */
    3330         if(process_units) minvz=UnitConversion(minvz,IuToExtEnum,VzEnum);
    33313302
    33323303        /*Assign output pointers:*/
    … …  
    33643335        IssmDouble maxabsvx=this->inputs->MaxAbs(VxEnum);
    33653336
    3366         /*process units if requested: */
    3367         if(process_units) maxabsvx=UnitConversion(maxabsvx,IuToExtEnum,VxEnum);
    3368 
    33693337        /*Assign output pointers:*/
    33703338        *pmaxabsvx=maxabsvx;
    … …  
    33773345        IssmDouble maxabsvy=this->inputs->MaxAbs(VyEnum);
    33783346
    3379         /*process units if requested: */
    3380         if(process_units) maxabsvy=UnitConversion(maxabsvy,IuToExtEnum,VyEnum);
    3381 
    33823347        /*Assign output pointers:*/
    33833348        *pmaxabsvy=maxabsvy;
    … …  
    33903355        IssmDouble maxabsvz=this->inputs->MaxAbs(VzEnum);
    33913356
    3392         /*process units if requested: */
    3393         if(process_units) maxabsvz=UnitConversion(maxabsvz,IuToExtEnum,VyEnum);
    3394 
    33953357        /*Assign output pointers:*/
    33963358        *pmaxabsvz=maxabsvz;
    … …  
    34033365        IssmDouble maxvel=this->inputs->Max(VelEnum);
    34043366
    3405         /*process units if requested: */
    3406         if(process_units) maxvel=UnitConversion(maxvel,IuToExtEnum,VelEnum);
    3407 
    34083367        /*Assign output pointers:*/
    34093368        *pmaxvel=maxvel;
    … …  
    34173376        IssmDouble maxvx=this->inputs->Max(VxEnum);
    34183377
    3419         /*process units if requested: */
    3420         if(process_units) maxvx=UnitConversion(maxvx,IuToExtEnum,VxEnum);
    3421 
    34223378        /*Assign output pointers:*/
    34233379        *pmaxvx=maxvx;
    … …  
    34303386        IssmDouble maxvy=this->inputs->Max(VyEnum);
    34313387
    3432         /*process units if requested: */
    3433         if(process_units) maxvy=UnitConversion(maxvy,IuToExtEnum,VyEnum);
    3434 
    34353388        /*Assign output pointers:*/
    34363389        *pmaxvy=maxvy;
    … …  
    34423395        /*Get maximum:*/
    34433396        IssmDouble maxvz=this->inputs->Max(VzEnum);
    3444 
    3445         /*process units if requested: */
    3446         if(process_units) maxvz=UnitConversion(maxvz,IuToExtEnum,VzEnum);
    34473397
    34483398        /*Assign output pointers:*/
    … …  
    34703420                                vel_input->GetInputAverage(&vel);
    34713421
    3472                                 /*process units if requested: */
    3473                                 if(process_units) vel=UnitConversion(vel,IuToExtEnum,VelEnum);
    3474 
    34753422                                /*Assign output pointers:*/
    34763423                                *presponse=vel;
    … …  
    35083455        smb_input->GetInputAverage(&smb);
    35093456        Total_Smb=rho_ice*base*smb;// smb on element in kg s-1
    3510 
    3511         /*Process units: */
    3512         Total_Smb=UnitConversion(Total_Smb,IuToExtEnum,TotalSmbEnum);// smb on element in GigaTon yr-1
    35133457
    35143458        /*Return: */

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

    r15082 r15128  
    113113                void   PatchSize(int* pnumrows, int* pnumvertices,int* pnumnodes);
    114114                void   PositiveDegreeDay(IssmDouble* pdds,IssmDouble* pds,IssmDouble signorm);
    115                 void   ProcessResultsUnits(void);
    116115                void   ResetCoordinateSystem(void);
    117116                void   SmbGradients();

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

    r15106 r15128  
    20592059                        for(i=0;i<3;i++)nodeinputs[i]=(IssmDouble)vector[tria_vertex_ids[i]-1];
    20602060
    2061                         /*process units: */
    2062                         UnitConversion(&nodeinputs[0], 3 ,ExtToIuEnum, vector_enum);
    2063 
    20642061                        /*create static input: */
    20652062                        this->inputs->AddInput(new TriaP1Input(vector_enum,nodeinputs));
    … …  
    20742071                                        nodeinputs[i]=(IssmDouble)vector[N*row+t];
    20752072                                }
    2076 
    2077                                 /*process units: */
    2078                                 UnitConversion(&nodeinputs[0], 3 ,ExtToIuEnum, vector_enum);
    20792073
    20802074                                /*time? :*/
    … …  
    25242518}
    25252519/*}}}*/
    2526 /*FUNCTION Tria::ProcessResultsUnits{{{*/
    2527 void  Tria::ProcessResultsUnits(void){
    2528 
    2529         int i;
    2530 
    2531         for(i=0;i<this->results->Size();i++){
    2532                 ElementResult* elementresult=(ElementResult*)this->results->GetObjectByOffset(i);
    2533                 elementresult->ProcessUnits(this->parameters);
    2534         }
    2535 }
    2536 /*}}}*/
    25372520/*FUNCTION Tria::RequestedOutput{{{*/
    25382521void Tria::RequestedOutput(int output_enum,int step,IssmDouble time){
    … …  
    29442927                                );
    29452928
    2946         /*Process units: */
    2947         mass_flux=UnitConversion(mass_flux,IuToExtEnum,MassFluxEnum);
    2948 
    29492929        /*clean up and return:*/
    29502930        delete gauss_1;
    … …  
    29592939        IssmDouble maxabsvx=this->inputs->MaxAbs(VxEnum);
    29602940
    2961         /*process units if requested: */
    2962         if(process_units) maxabsvx=UnitConversion(maxabsvx,IuToExtEnum,VxEnum);
    2963 
    29642941        /*Assign output pointers:*/
    29652942        *pmaxabsvx=maxabsvx;
    … …  
    29722949        IssmDouble maxabsvy=this->inputs->MaxAbs(VyEnum);
    29732950
    2974         /*process units if requested: */
    2975         if(process_units) maxabsvy=UnitConversion(maxabsvy,IuToExtEnum,VyEnum);
    2976 
    29772951        /*Assign output pointers:*/
    29782952        *pmaxabsvy=maxabsvy;
    … …  
    29852959        IssmDouble maxabsvz=this->inputs->MaxAbs(VzEnum);
    29862960
    2987         /*process units if requested: */
    2988         if(process_units) maxabsvz=UnitConversion(maxabsvz,IuToExtEnum,VyEnum);
    2989 
    29902961        /*Assign output pointers:*/
    29912962        *pmaxabsvz=maxabsvz;
    … …  
    29982969        IssmDouble maxvel=this->inputs->Max(VelEnum);
    29992970
    3000         /*process units if requested: */
    3001         if(process_units) maxvel=UnitConversion(maxvel,IuToExtEnum,VelEnum);
    3002 
    30032971        /*Assign output pointers:*/
    30042972        *pmaxvel=maxvel;
    … …  
    30112979        IssmDouble maxvx=this->inputs->Max(VxEnum);
    30122980
    3013         /*process units if requested: */
    3014         if(process_units) maxvx=UnitConversion(maxvx,IuToExtEnum,VxEnum);
    3015 
    30162981        /*Assign output pointers:*/
    30172982        *pmaxvx=maxvx;
    … …  
    30242989        IssmDouble maxvy=this->inputs->Max(VyEnum);
    30252990
    3026         /*process units if requested: */
    3027         if(process_units) maxvy=UnitConversion(maxvy,IuToExtEnum,VyEnum);
    3028 
    30292991        /*Assign output pointers:*/
    30302992        *pmaxvy=maxvy;
    … …  
    30383000        IssmDouble maxvz=this->inputs->Max(VzEnum);
    30393001
    3040         /*process units if requested: */
    3041         if(process_units) maxvz=UnitConversion(maxvz,IuToExtEnum,VzEnum);
    3042 
    30433002        /*Assign output pointers:*/
    30443003        *pmaxvz=maxvz;
    … …  
    30513010        IssmDouble minvel=this->inputs->Min(VelEnum);
    30523011
    3053         /*process units if requested: */
    3054         if(process_units) minvel=UnitConversion(minvel,IuToExtEnum,VelEnum);
    3055 
    30563012        /*Assign output pointers:*/
    30573013        *pminvel=minvel;
    … …  
    30643020        IssmDouble minvx=this->inputs->Min(VxEnum);
    30653021
    3066         /*process units if requested: */
    3067         if(process_units) minvx=UnitConversion(minvx,IuToExtEnum,VxEnum);
    3068 
    30693022        /*Assign output pointers:*/
    30703023        *pminvx=minvx;
    … …  
    30773030        IssmDouble minvy=this->inputs->Min(VyEnum);
    30783031
    3079         /*process units if requested: */
    3080         if(process_units) minvy=UnitConversion(minvy,IuToExtEnum,VyEnum);
    3081 
    30823032        /*Assign output pointers:*/
    30833033        *pminvy=minvy;
    … …  
    30893039        /*Get minimum:*/
    30903040        IssmDouble minvz=this->inputs->Min(VzEnum);
    3091 
    3092         /*process units if requested: */
    3093         if(process_units) minvz=UnitConversion(minvz,IuToExtEnum,VzEnum);
    30943041
    30953042        /*Assign output pointers:*/
    … …  
    31163063                        vel_input->GetInputAverage(&vel);
    31173064
    3118                         /*process units if requested: */
    3119                         if(process_units) vel=UnitConversion(vel,IuToExtEnum,VelEnum);
    3120 
    31213065                        /*Assign output pointers:*/
    31223066                        *presponse=vel;}
    … …  
    31523096        smb_input->GetInputAverage(&smb);                                                                                                                                                                                               // average smb on element in m ice s-1
    31533097   Total_Smb=rho_ice*base*smb;                                                                                                                                                                                                                  // smb on element in kg s-1
    3154 
    3155         /*Process units: */
    3156         Total_Smb=UnitConversion(Total_Smb,IuToExtEnum,TotalSmbEnum);                                                                                                                           // smb on element in GigaTon yr-1
    31573098
    31583099        /*Return: */
    … …  
    47114652                misfit=1/S*sqrt( pow(vx-vxobs,2) + pow(vy-vyobs,2));
    47124653
    4713                 if(process_units)UnitConversion(misfit,IuToExtEnum,SurfaceAverageVelMisfitEnum);
    4714 
    47154654                /*Add to cost function*/
    47164655                Jelem+=misfit*weight*Jdet*gauss->weight;
    … …  
    47724711                obs_velocity_mag=sqrt(pow(vxobs,2)+pow(vyobs,2))+epsvel;
    47734712                misfit=4*pow(meanvel,2)*pow(log(velocity_mag/obs_velocity_mag),2);
    4774 
    4775                 if(process_units)UnitConversion(misfit,IuToExtEnum,SurfaceLogVelMisfitEnum);
    47764713
    47774714                /*Add to cost function*/
    … …  
    48364773                                        pow(log((fabs(vy)+epsvel)/(fabs(vyobs)+epsvel)),2) );
    48374774
    4838                 if(process_units)UnitConversion(misfit,IuToExtEnum,SurfaceLogVxVyMisfitEnum);
    48394775
    48404776                /*Add to cost function*/
    … …  
    48934829                 */
    48944830                misfit=0.5*( pow(vx-vxobs,2) + pow(vy-vyobs,2) );
    4895 
    4896                 if(process_units)UnitConversion(misfit,IuToExtEnum,SurfaceAverageVelMisfitEnum);
    48974831
    48984832                /*Add to cost function*/
    … …  
    49564890                scaley=pow(meanvel/(vyobs+epsvel),2); if(vyobs==0)scaley=0;
    49574891                misfit=0.5*(scalex*pow((vx-vxobs),2)+scaley*pow((vy-vyobs),2));
    4958                 if(process_units)UnitConversion(misfit,IuToExtEnum,SurfaceRelVelMisfitEnum);
    49594892
    49604893                /*Add to cost function*/

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

    r15082 r15128  
    113113                void   PatchFill(int* pcount, Patch* patch);
    114114                void   PatchSize(int* pnumrows, int* pnumvertices,int* pnumnodes);
    115                 void   ProcessResultsUnits(void);
    116115                void   ResetCoordinateSystem(void){_error_("not implemented yet");};
    117116                void     SmbGradients();

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

    r15104 r15128  
    337337        /*First,  copy values, to process units if requested: */
    338338        for(i=0;i<numnodes;i++)valuescopy[i]=this->values[i];
    339 
    340         /*Process units if requested: */
    341         if(process_units)UnitConversion(&valuescopy[0],numnodes,IuToExtEnum,enum_type);
    342339
    343340        /*Now, figure out minimum of valuescopy: */

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

    r15104 r15128  
    229229        for(i=0;i<numnodes;i++)valuescopy[i]=this->values[i];
    230230
    231         /*Process units if requested: */
    232         if(process_units)UnitConversion(&valuescopy[0],numnodes,IuToExtEnum,enum_type);
    233 
    234231        /*Now, figure out minimum of valuescopy: */
    235232        squaremin=pow(valuescopy[0],2);

  • issm/trunk-jpl/src/c/classes/Materials/Matpar.cpp

    r15104 r15128  
    7878        iomodel->Constant(&this->mantle_shear_modulus,MaterialsMantleShearModulusEnum);
    7979        iomodel->Constant(&this->mantle_density,MaterialsMantleDensityEnum);
    80 
    81         /*Unit conversion: */
    82         this->UnitConversion();
    8380
    8481        this->inputs=NULL; /*not used here*/
    … …  
    458455}               
    459456/*}}}*/
    460 /*FUNCTION Matpar::UnitConversion {{{*/                 
    461 void Matpar::UnitConversion(void){               
    462 
    463         /*convert units of fields that were allocated using the Ext unit system, into the Iu unit system: */
    464         ::UnitConversion(&this->lithosphere_density,1,ExtToIuEnum,MaterialsLithosphereDensityEnum);
    465         ::UnitConversion(&this->mantle_density,1,ExtToIuEnum,MaterialsMantleDensityEnum);
    466 
    467 }               
    468 /*}}}*/

  • issm/trunk-jpl/src/c/classes/Materials/Matpar.h

    r15015 r15128  
    136136                IssmDouble GetDesFac();
    137137                IssmDouble GetS0p();
    138                 void   UnitConversion(void);
    139138                /*}}}*/
    140139

  • issm/trunk-jpl/src/c/classes/Params/BoolParam.cpp

    r15104 r15128  
    7272}
    7373/*}}}*/
    74 /*FUNCTION BoolParam::UnitConversion{{{*/
    75 void  BoolParam::UnitConversion(int direction_enum){
    76         /*do nothing, no unit conversion*/
    77 }
    78 /*}}}*/

  • issm/trunk-jpl/src/c/classes/Params/BoolParam.h

    r15012 r15128  
    6868                void  SetValue(FILE* fid){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a FILE");}
    6969                void  SetValue(IssmDouble** array, int M, int* mdim_array, int* ndim_array){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold an array of matrices");}
    70                 void  UnitConversion(int direction_enum);
    7170
    7271                void GetParameterName(char**pname);

  • issm/trunk-jpl/src/c/classes/Params/DataSetParam.cpp

    r15104 r15128  
    7373}
    7474/*}}}*/
    75 /*FUNCTION DataSetParam::UnitConversion{{{*/
    76 void  DataSetParam::UnitConversion(int direction_enum){
    77         /*do nothing, no unit conversion*/
    78 }
    79 /*}}}*/
    8075/*FUNCTION DataSetParam::GetParameterValue{{{*/
    8176void DataSetParam::GetParameterValue(DataSet** pdataset){

  • issm/trunk-jpl/src/c/classes/Params/DataSetParam.h

    r15012 r15128  
    6969                void  SetValue(DataSet* dataset){_error_("DataSet param of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot hold a DataSet yet");}
    7070                void  SetValue(IssmDouble** array, int M, int* mdim_array, int* ndim_array){_error_("DataSet param of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot hold an array of matrices");}
    71                 void  UnitConversion(int direction_enum);
    7271
    7372                void GetParameterName(char**pname);

  • issm/trunk-jpl/src/c/classes/Params/DoubleMatArrayParam.cpp

    r15104 r15128  
    226226}
    227227/*}}}*/
    228 /*FUNCTION DoubleMatArrayParam::UnitConversion{{{*/
    229 void  DoubleMatArrayParam::UnitConversion(int direction_enum){
    230         /*go through all matrices and convert: */
    231         for (int i=0;i<this->M;i++){
    232                 IssmDouble* matrix=this->array[i];
    233                 int     m=this->mdim_array[i];
    234                 int     n=this->ndim_array[i];
    235                 ::UnitConversion(matrix,m*n,direction_enum,this->enum_type);
    236         }
    237 
    238 }
    239 /*}}}*/

  • issm/trunk-jpl/src/c/classes/Params/DoubleMatArrayParam.h

    r15012 r15128  
    7171                void  SetValue(FILE* fid){_error_("Bool param of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot hold a FILE");}
    7272                void  SetValue(IssmDouble** array, int M, int* mdim_array, int* ndim_array);
    73                 void  UnitConversion(int direction_enum);
    7473
    7574                void GetParameterName(char**pname);

  • issm/trunk-jpl/src/c/classes/Params/DoubleMatParam.cpp

    r15104 r15128  
    119119}
    120120/*}}}*/
    121 /*FUNCTION DoubleMatParam::UnitConversion{{{*/
    122 void  DoubleMatParam::UnitConversion(int direction_enum){
    123         ::UnitConversion(this->value,this->M*this->N,direction_enum,this->enum_type);
    124 }
    125 /*}}}*/

  • issm/trunk-jpl/src/c/classes/Params/DoubleMatParam.h

    r15012 r15128  
    7070                void  SetValue(FILE* fid){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a FILE");}
    7171                void  SetValue(IssmDouble** array, int M, int* mdim_array, int* ndim_array){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold an array of matrices");}
    72                 void  UnitConversion(int direction_enum);
    7372
    7473                void GetParameterName(char**pname);

  • issm/trunk-jpl/src/c/classes/Params/DoubleParam.cpp

    r15104 r15128  
    9999}
    100100/*}}}*/
    101 /*FUNCTION DoubleParam::UnitConversion{{{*/
    102 void  DoubleParam::UnitConversion(int direction_enum){
    103         ::UnitConversion(&this->value,1,direction_enum,this->enum_type);
    104 }
    105 /*}}}*/

  • issm/trunk-jpl/src/c/classes/Params/DoubleParam.h

    r15012 r15128  
    6969                void  SetValue(FILE* fid){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a FILE");}
    7070                void  SetValue(IssmDouble** array, int M, int* mdim_array, int* ndim_array){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold an array of matrices");}
    71                 void  UnitConversion(int direction_enum);
    7271
    7372                void GetParameterName(char**pname);

  • issm/trunk-jpl/src/c/classes/Params/DoubleTransientMatParam.cpp

    r15012 r15128  
    1919}
    2020/*}}}*/
    21 /*FUNCTION DoubleTransientMatParam::UnitConversion{{{*/
    22 void  DoubleTransientMatParam::UnitConversion(int direction_enum){
    23         ::UnitConversion(this->value,(this->M-1)*this->N,direction_enum,this->enum_type);
    24 }
    25 /*}}}*/

  • issm/trunk-jpl/src/c/classes/Params/DoubleTransientMatParam.h

    r15012 r15128  
    2424                DoubleTransientMatParam(int enum_type,IssmDouble* value,int M,int N);
    2525                /*}}}*/
    26                 /*Param vritual function definitions: {{{*/
    27                 void  UnitConversion(int direction_enum);
    28                 /*}}}*/
    2926};
    3027#endif  /* _DOUBLETRANSIENTMATPARAM_H */

  • issm/trunk-jpl/src/c/classes/Params/DoubleVecParam.cpp

    r15104 r15128  
    133133}
    134134/*}}}*/
    135 /*FUNCTION DoubleVecParam::UnitConversion{{{*/
    136 void  DoubleVecParam::UnitConversion(int direction_enum){
    137         ::UnitConversion(this->values,this->M,direction_enum,this->enum_type);
    138 }
    139 /*}}}*/

  • issm/trunk-jpl/src/c/classes/Params/DoubleVecParam.h

    r15012 r15128  
    6969                void  SetValue(FILE* fid){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a FILE");}
    7070                void  SetValue(IssmDouble** array, int M, int* mdim_array, int* ndim_array){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold an array of matrices");}
    71                 void  UnitConversion(int direction_enum);
    7271
    7372                void GetParameterName(char**pname);

  • issm/trunk-jpl/src/c/classes/Params/FileParam.cpp

    r15104 r15128  
    7272}
    7373/*}}}*/
    74 /*FUNCTION FileParam::UnitConversion{{{*/
    75 void  FileParam::UnitConversion(int direction_enum){
    76         /*do nothing, no unit conversion*/
    77 }
    78 /*}}}*/

  • issm/trunk-jpl/src/c/classes/Params/FileParam.h

    r15012 r15128  
    6868                void  SetValue(FILE* fid){_error_("File param of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot hold a FILE");}
    6969                void  SetValue(IssmDouble** array, int M, int* mdim_array, int* ndim_array){_error_("File param of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot hold an array of matrices");}
    70                 void  UnitConversion(int direction_enum);
    7170
    7271                void GetParameterName(char**pname);

  • issm/trunk-jpl/src/c/classes/Params/GenericParam.h

    r15104 r15128  
    9090                void  SetValue(FILE* fid){_error_("Param "<< EnumToStringx(myEnumVal) << " cannot hold a FILE");}
    9191                void  SetValue(IssmDouble** array, int M, int* mdim_array, int* ndim_array){_error_("Param "<< EnumToStringx(myEnumVal) << " cannot hold an array of matrices");}
    92                 void  UnitConversion(int direction_enum) {/* nothing useful here either */};
    9392
    9493                /*}}}*/

  • issm/trunk-jpl/src/c/classes/Params/IntMatParam.cpp

    r15104 r15128  
    114114}
    115115/*}}}*/
    116 /*FUNCTION IntMatParam::UnitConversion{{{*/
    117 void  IntMatParam::UnitConversion(int direction_enum){
    118         /*do nothing, no unit conversion*/
    119 }
    120 /*}}}*/

  • issm/trunk-jpl/src/c/classes/Params/IntMatParam.h

    r15012 r15128  
    7070                void  SetValue(FILE* fid){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a FILE");}
    7171                void  SetValue(IssmDouble** array, int M, int* mdim_array, int* ndim_array){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold an array of matrices");}
    72                 void  UnitConversion(int direction_enum);
    7372
    7473                void GetParameterName(char**pname);

  • issm/trunk-jpl/src/c/classes/Params/IntParam.cpp

    r15104 r15128  
    7272}
    7373/*}}}*/
    74 /*FUNCTION IntParam::UnitConversion{{{*/
    75 void  IntParam::UnitConversion(int direction_enum){
    76         /*do nothing, no unit conversion*/
    77 }
    78 /*}}}*/

  • issm/trunk-jpl/src/c/classes/Params/IntParam.h

    r15012 r15128  
    6969                void  SetValue(FILE* fid){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a FILE");}
    7070                void  SetValue(IssmDouble** array, int M, int* mdim_array, int* ndim_array){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold an array of matrices");}
    71                 void  UnitConversion(int direction_enum);
    7271
    7372                void GetParameterName(char**pname);

  • issm/trunk-jpl/src/c/classes/Params/IntVecParam.cpp

    r15104 r15128  
    130130}
    131131/*}}}*/
    132 /*FUNCTION IntVecParam::UnitConversion{{{*/
    133 void  IntVecParam::UnitConversion(int direction_enum){
    134         /*do nothing, no unit conversion*/
    135 }
    136 /*}}}*/

  • issm/trunk-jpl/src/c/classes/Params/IntVecParam.h

    r15012 r15128  
    7070                void  SetValue(FILE* fid){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a FILE");}
    7171                void  SetValue(IssmDouble** array, int M, int* mdim_array, int* ndim_array){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold an array of matrices");}
    72                 void  UnitConversion(int direction_enum);
    7372
    7473                void GetParameterName(char**pname);

  • issm/trunk-jpl/src/c/classes/Params/MatrixParam.cpp

    r15104 r15128  
    9999}
    100100/*}}}*/
    101 /*FUNCTION MatrixParam::UnitConversion{{{*/
    102 void  MatrixParam::UnitConversion(int direction_enum){
    103         /*do nothing, no unit conversion*/
    104 }
    105 /*}}}*/

  • issm/trunk-jpl/src/c/classes/Params/MatrixParam.h

    r15012 r15128  
    6969                void  SetValue(FILE* fid){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a FILE");}
    7070                void  SetValue(IssmDouble** array, int M, int* mdim_array, int* ndim_array){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold an array of matrices");}
    71                 void  UnitConversion(int direction_enum);
    7271
    7372                void GetParameterName(char**pname);

  • issm/trunk-jpl/src/c/classes/Params/Param.h

    r15067 r15128  
    5555                virtual void  SetValue(FILE* fid)=0;
    5656                virtual void  SetValue(IssmDouble** array, int M, int* mdim_array, int* ndim_array)=0;
    57                 virtual void  UnitConversion(int direction_enum)=0;
    5857                virtual void  GetParameterName(char**pname)=0;
    5958};

  • issm/trunk-jpl/src/c/classes/Params/Parameters.cpp

    r15037 r15128  
    472472        if(param) param->SetValue(fid); //already exists, just set it.
    473473        else this->AddObject(new FileParam(enum_type,fid)); //just add the new parameter.
    474 }
    475 /*}}}*/
    476 /*FUNCTION Parameters::UnitConversion(int direction_enum);{{{*/
    477 void   Parameters::UnitConversion(int direction_enum){
    478 
    479         vector<Object*>::iterator object;
    480         Param* param=NULL;
    481 
    482         for ( object=objects.begin() ; object < objects.end(); object++ ){
    483                 param=dynamic_cast<Param*>(*object);
    484                 param->UnitConversion(direction_enum);
    485         }
    486 
    487474}
    488475/*}}}*/

  • issm/trunk-jpl/src/c/classes/Params/Parameters.h

    r15067 r15128  
    5252                void  SetParam(Matrix<IssmDouble>* mat,int enum_type);
    5353                void  SetParam(FILE* fid,int enum_type);
    54                 void  UnitConversion(int direction_enum);
    5554
    5655                Object* FindParamObject(int enum_type);

  • issm/trunk-jpl/src/c/classes/Params/StringArrayParam.cpp

    r15104 r15128  
    162162}
    163163/*}}}*/
    164 /*FUNCTION StringArrayParam::UnitConversion{{{*/
    165 void  StringArrayParam::UnitConversion(int direction_enum){
    166         /*do nothing, no unit conversion*/
    167 }
    168 /*}}}*/

  • issm/trunk-jpl/src/c/classes/Params/StringArrayParam.h

    r15012 r15128  
    7070                void  SetValue(FILE* fid){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a FILE");}
    7171                void  SetValue(IssmDouble** array, int M, int* mdim_array, int* ndim_array){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold an array of matrices");}
    72                 void  UnitConversion(int direction_enum);
    7372
    7473                void GetParameterName(char**pname);

  • issm/trunk-jpl/src/c/classes/Params/StringParam.cpp

    r15104 r15128  
    103103}
    104104/*}}}*/
    105 /*FUNCTION StringParam::UnitConversion{{{*/
    106 void  StringParam::UnitConversion(int direction_enum){
    107         /*do nothing, no unit conversion*/
    108 }
    109 /*}}}*/

  • issm/trunk-jpl/src/c/classes/Params/StringParam.h

    r15012 r15128  
    6969                void  SetValue(FILE* fid){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold a FILE");}
    7070                void  SetValue(IssmDouble** array, int M, int* mdim_array, int* ndim_array){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold an array of matrices");}
    71                 void  UnitConversion(int direction_enum);
    7271
    7372                void GetParameterName(char**pname);

  • issm/trunk-jpl/src/c/classes/Params/TransientParam.cpp

    r15104 r15128  
    132132}
    133133/*}}}*/
    134 /*FUNCTION TransientParam::UnitConversion{{{*/
    135 void  TransientParam::UnitConversion(int direction_enum){
    136         ::UnitConversion(this->values,this->N,direction_enum,this->enum_type);
    137 }
    138 /*}}}*/

  • issm/trunk-jpl/src/c/classes/Params/TransientParam.h

    r15012 r15128  
    7070                void  SetValue(FILE* fid){_error_("Parameter " <<EnumToStringx(enum_type) << " cannot hold a FILE");}
    7171                void  SetValue(IssmDouble** array, int M, int* mdim_array, int* ndim_array){_error_("Parameter " <<EnumToStringx(enum_type) << " cannot hold an array of matrices");}
    72                 void  UnitConversion(int direction_enum);
    7372
    7473                void GetParameterName(char**pname);

  • issm/trunk-jpl/src/c/classes/Params/VectorParam.cpp

    r15104 r15128  
    103103}
    104104/*}}}*/
    105 /*FUNCTION VectorParam::UnitConversion{{{*/
    106 void  VectorParam::UnitConversion(int direction_enum){
    107         /*do nothing, no unit conversion*/
    108 }
    109 /*}}}*/

  • issm/trunk-jpl/src/c/classes/Params/VectorParam.h

    r15012 r15128  
    6969                void  SetValue(FILE* fid){_error_("Vector of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot hold a FILE");}
    7070                void  SetValue(IssmDouble** array, int M, int* mdim_array, int* ndim_array){_error_("Param "<< EnumToStringx(enum_type) << " cannot hold an array of matrices");}
    71                 void  UnitConversion(int direction_enum);
    7271
    7372                void GetParameterName(char**pname);

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

    r14999 r15128  
    6666                        times[j]=IssmDoublevector[(M-1)*N+j];
    6767                }
    68                 /*unit conversion: */
    69                 UnitConversion(times,N,ExtToIuEnum,TimeEnum);
    7068
    7169                /*Create constraints from x,y,z: */

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateParameters.cpp

    r15000 r15128  
    246246        #endif
    247247
    248         /*Go through all parameters, and convert units to SI: */
    249         parameters->UnitConversion(ExtToIuEnum);
    250 
    251248        /*Assign output pointer: */
    252249        *pparameters=parameters;

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/DiagnosticHoriz/CreateConstraintsDiagnosticHoriz.cpp

    r15000 r15128  
    8888                timesx[j]=spcvx[(Mx-1)*Nx+j];
    8989        }
    90         /*unit conversion: */
    91         UnitConversion(timesx,Nx,ExtToIuEnum,TimeEnum);
    9290        /*figure out times: */
    9391        timesy=xNew<IssmDouble>(Ny);
    … …  
    9593                timesy[j]=spcvy[(My-1)*Ny+j];
    9694        }
    97         /*unit conversion: */
    98         UnitConversion(timesy,Ny,ExtToIuEnum,TimeEnum);
    9995        /*figure out times: */
    10096        timesz=xNew<IssmDouble>(Nz);
    … …  
    10298                timesz[j]=spcvz[(Mz-1)*Nz+j];
    10399        }
    104         /*unit conversion: */
    105         UnitConversion(timesz,Nz,ExtToIuEnum,TimeEnum);
    106100
    107101        /*Create spcs from x,y,z, as well as the spc values on those spcs: */

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/Enthalpy/CreateConstraintsEnthalpy.cpp

    r15000 r15128  
    7575                        times[j]=spcvector[(M-1)*N+j];
    7676                }
    77                 /*unit conversion: */
    78                 UnitConversion(times,N,ExtToIuEnum,TimeEnum);
    7977
    8078                /*Create constraints from x,y,z: */

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

    r15000 r15128  
    3838
    3939        /*We have results inside our elements, loads, etc ... Get them out of there, into the results dataset: */
    40         elements->ProcessResultsUnits();
    4140        elements->ToResults(results,parameters);
    4241        elements->DeleteResults();

  • issm/trunk-jpl/src/c/shared/Numerics/CMakeLists.txt

    r15082 r15128  
    1111                 $ENV{ISSM_DIR}/src/c/shared/Numerics/isnan.cpp
    1212   $ENV{ISSM_DIR}/src/c/shared/Numerics/OptionsFromAnalysis.cpp
    13         $ENV{ISSM_DIR}/src/c/shared/Numerics/UnitConversion.cpp
    1413             $ENV{ISSM_DIR}/src/c/shared/Numerics/Verbosity.cpp
    1514$ENV{ISSM_DIR}/src/c/shared/Numerics/XZvectorsToCoordinateSystem.cpp PARENT_SCOPE)

  • issm/trunk-jpl/src/c/shared/Numerics/numerics.h

    r14998 r15128  
    3535void        OptimalSearch(IssmDouble *psearch_scalar,IssmDouble*pJ,OptPars*optpars,IssmDouble (*f)(IssmDouble,OptArgs*), OptArgs*optargs);
    3636void        cross(IssmDouble *result,IssmDouble*vector1,IssmDouble*vector2);
    37 void        UnitConversion(IssmDouble *values, int numvalues,int direction_enum, int type_enum);
    38 IssmDouble  UnitConversion(IssmDouble value, int direction_enum, int type_enum);
    3937void        XZvectorsToCoordinateSystem(IssmDouble *T,IssmDouble*xzvectors);
    4038int         cubic(IssmDouble a, IssmDouble b, IssmDouble c, IssmDouble d, double X[3], int *num);

  • issm/trunk-jpl/src/m/classes/basalforcings.m

    r14640 r15128  
    4444                end % }}}
    4545                function marshall(obj,fid) % {{{
    46                         WriteData(fid,'object',obj,'fieldname','melting_rate','format','DoubleMat','mattype',1);
    47                         WriteData(fid,'object',obj,'fieldname','melting_rate_correction','format','DoubleMat','mattype',1);
     46
     47                        yts=365.0*24.0*3600.0;
     48
     49                        WriteData(fid,'object',obj,'fieldname','melting_rate','format','DoubleMat','mattype',1,'scale',1./yts);
     50                        WriteData(fid,'object',obj,'fieldname','melting_rate_correction','format','DoubleMat','mattype',1,'scale',1./yts);
    4851                        WriteData(fid,'object',obj,'fieldname','geothermalflux','format','DoubleMat','mattype',1);
    4952                end % }}}

  • issm/trunk-jpl/src/m/classes/basalforcings.py

    r14640 r15128  
    4747        # }}}
    4848        def marshall(self,fid):    # {{{
    49                 WriteData(fid,'object',self,'fieldname','melting_rate','format','DoubleMat','mattype',1)
    50                 WriteData(fid,'object',self,'fieldname','melting_rate_correction','format','DoubleMat','mattype',1)
     49
     50                yts=365.0*24.0*3600.0
     51
     52                WriteData(fid,'object',self,'fieldname','melting_rate','format','DoubleMat','mattype',1,'scale',1./yts)
     53                WriteData(fid,'object',self,'fieldname','melting_rate_correction','format','DoubleMat','mattype',1,'scale',1./yts)
    5154                WriteData(fid,'object',self,'fieldname','geothermalflux','format','DoubleMat','mattype',1)
    5255        # }}}

  • issm/trunk-jpl/src/m/classes/initialization.m

    r14771 r15128  
    9191                end % }}}
    9292                function marshall(obj,fid) % {{{
    93                         WriteData(fid,'data',obj.vx,'format','DoubleMat','mattype',1,'enum',VxEnum);
    94                         WriteData(fid,'data',obj.vy,'format','DoubleMat','mattype',1,'enum',VyEnum);
    95                         WriteData(fid,'data',obj.vz,'format','DoubleMat','mattype',1,'enum',VzEnum);
     93
     94                        yts=365.0*24.0*3600.0;
     95
     96                        WriteData(fid,'data',obj.vx,'format','DoubleMat','mattype',1,'enum',VxEnum,'scale',1./yts);
     97                        WriteData(fid,'data',obj.vy,'format','DoubleMat','mattype',1,'enum',VyEnum,'scale',1./yts);
     98                        WriteData(fid,'data',obj.vz,'format','DoubleMat','mattype',1,'enum',VzEnum,'scale',1./yts);
    9699                        WriteData(fid,'data',obj.pressure,'format','DoubleMat','mattype',1,'enum',PressureEnum);
    97100                        WriteData(fid,'data',obj.temperature,'format','DoubleMat','mattype',1,'enum',TemperatureEnum);

  • issm/trunk-jpl/src/m/classes/initialization.py

    r14771 r15128  
    7474        # }}}
    7575        def marshall(self,fid):    # {{{
    76                 WriteData(fid,'data',self.vx,'format','DoubleMat','mattype',1,'enum',VxEnum())
    77                 WriteData(fid,'data',self.vy,'format','DoubleMat','mattype',1,'enum',VyEnum())
    78                 WriteData(fid,'data',self.vz,'format','DoubleMat','mattype',1,'enum',VzEnum())
     76
     77                yts=365.0*24.0*3600.0
     78
     79                WriteData(fid,'data',self.vx,'format','DoubleMat','mattype',1,'enum',VxEnum(),'scale',1./yts)
     80                WriteData(fid,'data',self.vy,'format','DoubleMat','mattype',1,'enum',VyEnum(),'scale',1./yts)
     81                WriteData(fid,'data',self.vz,'format','DoubleMat','mattype',1,'enum',VzEnum(),'scale',1./yts)
    7982                WriteData(fid,'data',self.pressure,'format','DoubleMat','mattype',1,'enum',PressureEnum())
    8083                WriteData(fid,'data',self.temperature,'format','DoubleMat','mattype',1,'enum',TemperatureEnum())

  • issm/trunk-jpl/src/m/classes/surfaceforcings.m

    r14764 r15128  
    101101                end % }}}
    102102                function marshall(obj,fid) % {{{
    103                         WriteData(fid,'object',obj,'fieldname','precipitation','format','DoubleMat','mattype',1);
    104                         WriteData(fid,'object',obj,'fieldname','mass_balance','format','DoubleMat','mattype',1);
     103
     104                        yts=365.0*24.0*3600.0;
     105
     106                        WriteData(fid,'object',obj,'fieldname','precipitation','format','DoubleMat','mattype',1,'scale',1./yts);
     107                        WriteData(fid,'object',obj,'fieldname','mass_balance','format','DoubleMat','mattype',1,'scale',1./yts);
    105108                        WriteData(fid,'object',obj,'fieldname','ispdd','format','Boolean');
    106109                        WriteData(fid,'object',obj,'fieldname','isdelta18o','format','Boolean');
    … …  
    122125                        if obj.issmbgradients,
    123126                                WriteData(fid,'object',obj,'fieldname','href','format','DoubleMat','mattype',1);
    124                                 WriteData(fid,'object',obj,'fieldname','smbref','format','DoubleMat','mattype',1);
    125                                 WriteData(fid,'object',obj,'fieldname','b_pos','format','DoubleMat','mattype',1);
    126                                 WriteData(fid,'object',obj,'fieldname','b_neg','format','DoubleMat','mattype',1);
     127                                WriteData(fid,'object',obj,'fieldname','smbref','format','DoubleMat','mattype',1,'scale',1./yts);
     128                                WriteData(fid,'object',obj,'fieldname','b_pos','format','DoubleMat','mattype',1,'scale',1./yts);
     129                                WriteData(fid,'object',obj,'fieldname','b_neg','format','DoubleMat','mattype',1,'scale',1./yts);
    127130                        end
    128131

  • issm/trunk-jpl/src/m/classes/surfaceforcings.py

    r14764 r15128  
    101101        # }}}
    102102        def marshall(self,fid):    # {{{
    103                 WriteData(fid,'object',self,'fieldname','precipitation','format','DoubleMat','mattype',1)
    104                 WriteData(fid,'object',self,'fieldname','mass_balance','format','DoubleMat','mattype',1)
     103
     104                yts=365.0*24.0*3600.0
     105
     106                WriteData(fid,'object',self,'fieldname','precipitation','format','DoubleMat','mattype',1,'scale',1./yts)
     107                WriteData(fid,'object',self,'fieldname','mass_balance','format','DoubleMat','mattype',1,'scale',1./yts)
    105108                WriteData(fid,'object',self,'fieldname','ispdd','format','Boolean')
    106109                WriteData(fid,'object',self,'fieldname','isdelta18o','format','Boolean')
    … …  
    123126                if self.issmbgradients:
    124127                        WriteData(fid,'object',self,'fieldname','href','format','DoubleMat','mattype',1)
    125                         WriteData(fid,'object',self,'fieldname','smbref','format','DoubleMat','mattype',1)
    126                         WriteData(fid,'object',self,'fieldname','b_pos','format','DoubleMat','mattype',1)
    127                         WriteData(fid,'object',self,'fieldname','b_neg','format','DoubleMat','mattype',1)
     128                        WriteData(fid,'object',self,'fieldname','smbref','format','DoubleMat','mattype',1,'scale',1./yts)
     129                        WriteData(fid,'object',self,'fieldname','b_pos','format','DoubleMat','mattype',1,'scale',1./yts)
     130                        WriteData(fid,'object',self,'fieldname','b_neg','format','DoubleMat','mattype',1,'scale',1./yts)
    128131        # }}}

  • issm/trunk-jpl/src/m/solve/parseresultsfromdisk.m

    r15127 r15128  
    177177        if strcmp(fieldname,'BalancethicknessThickeningRate'),
    178178                field = field*yts;
     179        elseif strcmp(fieldname,'Time'),
     180                field = field/yts;
     181        elseif strcmp(fieldname,'HydrologyWaterVx'),
     182                field = field*yts;
     183        elseif strcmp(fieldname,'HydrologyWaterVy'),
     184                field = field*yts;
     185        elseif strcmp(fieldname,'Vx'),
     186                field = field*yts;
     187        elseif strcmp(fieldname,'Vy'),
     188                field = field*yts;
     189        elseif strcmp(fieldname,'Vz'),
     190                field = field*yts;
     191        elseif strcmp(fieldname,'Vel'),
     192                field = field*yts;
     193        elseif strcmp(fieldname,'BasalforcingsMeltingRate'),
     194                field = field*yts;
     195        elseif strcmp(fieldname,'TotalSmb'),
     196                field = field*10.^12/yts; %(GigaTon/year)
     197        elseif strcmp(fieldname,'SurfaceforcingsMassBalance'),
     198                field = field*yts;
    179199        end
    180200

  • issm/trunk-jpl/src/m/solve/parseresultsfromdisk.py

    r15127 r15128  
    191191                if strcmp(fieldname,'BalancethicknessThickeningRate'):
    192192                        field = field*yts
     193                elif strcmp(fieldname,'Time'):
     194                        field = field/yts
     195                elif strcmp(fieldname,'HydrologyWaterVx'):
     196                        field = field*yts
     197                elif strcmp(fieldname,'HydrologyWaterVy'):
     198                        field = field*yts
     199                elif strcmp(fieldname,'Vx'):
     200                        field = field*yts
     201                elif strcmp(fieldname,'Vy'):
     202                        field = field*yts
     203                elif strcmp(fieldname,'Vz'):
     204                        field = field*yts
     205                elif strcmp(fieldname,'Vel'):
     206                        field = field*yts
     207                elif strcmp(fieldname,'BasalforcingsMeltingRate'):
     208                        field = field*yts
     209                elif strcmp(fieldname,'TotalSmb'):
     210                        field = field*10.**12./yts #(GigaTon/year)
     211                elif strcmp(fieldname,'SurfaceforcingsMassBalance'):
     212                        field = field*yts
    193213
    194214                result=OrderedDict()
Note: See TracChangeset for help on using the changeset viewer.