Changeset 22326


Ignore:
Timestamp:
01/04/18 10:54:01 (7 years ago)
Author:
seroussi
Message:

CHG: adding scale factor in volume computation

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

Legend:

Unmodified
Added
Removed

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

    r22308 r22326  
    861861        this->parameters->FindParam(pvalues,psize,paramenum);
    862862}/*}}}*/
    863 IssmDouble Element::FloatingArea(IssmDouble* mask){/*{{{*/
     863IssmDouble Element::FloatingArea(IssmDouble* mask, bool scaled){/*{{{*/
    864864
    865865        /*Retrieve values of the mask defining the element: */
    … …  
    871871
    872872        /*Return: */
    873         return this->FloatingArea();
     873        return this->FloatingArea(scaled);
    874874}
    875875/*}}}*/
    … …  
    14041404}
    14051405/*}}}*/
    1406 IssmDouble Element::GroundedArea(IssmDouble* mask){/*{{{*/
     1406IssmDouble Element::GroundedArea(IssmDouble* mask, bool scaled){/*{{{*/
    14071407
    14081408        /*Retrieve values of the mask defining the element: */
    … …  
    14141414
    14151415        /*Return: */
    1416         return this->GroundedArea();
     1416        return this->GroundedArea(scaled);
    14171417}
    14181418/*}}}*/
    … …  
    14231423        return (this->inputs->Max(MeshVertexonsurfaceEnum)>0.);
    14241424}/*}}}*/
    1425 IssmDouble Element::IceMass(void){/*{{{*/
     1425IssmDouble Element::IceMass(bool scaled){/*{{{*/
    14261426
    14271427        IssmDouble rho_ice;
    … …  
    14321432        rho_ice=matpar->GetMaterialParameter(MaterialsRhoIceEnum);
    14331433
    1434         return rho_ice*this->IceVolume();
    1435 }
    1436 /*}}}*/
    1437 IssmDouble Element::IceMass(IssmDouble* mask){/*{{{*/
     1434        return rho_ice*this->IceVolume(scaled);
     1435}
     1436/*}}}*/
     1437IssmDouble Element::IceMass(IssmDouble* mask, bool scaled){/*{{{*/
    14381438
    14391439        /*Retrieve values of the mask defining the element: */
    … …  
    14451445
    14461446        /*Return: */
    1447         return this->IceMass();
    1448 }
    1449 /*}}}*/
    1450 IssmDouble Element::IceVolume(IssmDouble* mask){/*{{{*/
     1447        return this->IceMass(scaled);
     1448}
     1449/*}}}*/
     1450IssmDouble Element::IceVolume(IssmDouble* mask, bool scaled){/*{{{*/
    14511451
    14521452        /*Retrieve values of the mask defining the element: */
    … …  
    14581458
    14591459        /*Return: */
    1460         return this->IceVolume();
    1461 }
    1462 /*}}}*/
    1463 IssmDouble Element::IceVolumeAboveFloatation(IssmDouble* mask){/*{{{*/
     1460        return this->IceVolume(scaled);
     1461}
     1462/*}}}*/
     1463IssmDouble Element::IceVolumeAboveFloatation(IssmDouble* mask, bool scaled){/*{{{*/
    14641464
    14651465        /*Retrieve values of the mask defining the element: */
    … …  
    14711471
    14721472        /*Return: */
    1473         return this->IceVolumeAboveFloatation();
     1473        return this->IceVolumeAboveFloatation(scaled);
    14741474}
    14751475/*}}}*/
    … …  
    31373137        return this->matpar->TMeltingPoint(pressure);
    31383138}/*}}}*/
    3139 IssmDouble Element::TotalFloatingBmb(IssmDouble* mask){/*{{{*/
     3139IssmDouble Element::TotalFloatingBmb(IssmDouble* mask, bool scaled){/*{{{*/
    31403140
    31413141        /*Retrieve values of the mask defining the element: */
    … …  
    31473147
    31483148        /*Return: */
    3149         return this->TotalFloatingBmb();
    3150 }
    3151 /*}}}*/
    3152 IssmDouble Element::TotalGroundedBmb(IssmDouble* mask){/*{{{*/
     3149        return this->TotalFloatingBmb(scaled);
     3150}
     3151/*}}}*/
     3152IssmDouble Element::TotalGroundedBmb(IssmDouble* mask, bool scaled){/*{{{*/
    31533153
    31543154        /*Retrieve values of the mask defining the element: */
    … …  
    31603160
    31613161        /*Return: */
    3162         return this->TotalGroundedBmb();
    3163 }
    3164 /*}}}*/
    3165 IssmDouble Element::TotalSmb(IssmDouble* mask){/*{{{*/
     3162        return this->TotalGroundedBmb(scaled);
     3163}
     3164/*}}}*/
     3165IssmDouble Element::TotalSmb(IssmDouble* mask, bool scaled){/*{{{*/
    31663166
    31673167        /*Retrieve values of the mask defining the element: */
    … …  
    31733173
    31743174        /*Return: */
    3175         return this->TotalSmb();
     3175        return this->TotalSmb(scaled);
    31763176}
    31773177/*}}}*/

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

    r22192 r22326  
    8181                void               FindParam(IssmDouble* pvalue,int paramenum);
    8282                void               FindParam(int** pvalues,int* psize,int paramenum);
    83                 IssmDouble         FloatingArea(IssmDouble* mask);
     83                IssmDouble         FloatingArea(IssmDouble* mask, bool scaled);
    8484                void                 GetDofList(int** pdoflist,int approximation_enum,int setenum);
    8585                void                 GetDofListPressure(int** pdoflist,int setenum);
    … …  
    112112                IssmDouble         GetZcoord(IssmDouble* xyz_list,Gauss* gauss);
    113113                void               GradientIndexing(int* indexing,int control_index,bool onsid=false);
    114                 IssmDouble         GroundedArea(IssmDouble* mask);
     114                IssmDouble         GroundedArea(IssmDouble* mask, bool scaled);
    115115                bool               HasNodeOnBase();
    116116                bool               HasNodeOnSurface();
    117                 IssmDouble         IceMass();
    118                 IssmDouble         IceMass(IssmDouble* mask);
    119                 IssmDouble         IceVolume(IssmDouble* mask);
    120                 IssmDouble         IceVolumeAboveFloatation(IssmDouble* mask);
     117                IssmDouble         IceMass(bool scaled);
     118                IssmDouble         IceMass(IssmDouble* mask, bool scaled);
     119                IssmDouble         IceVolume(IssmDouble* mask, bool scaled);
     120                IssmDouble         IceVolumeAboveFloatation(IssmDouble* mask, bool scaled);
    121121                int                Id();
    122122                void               InputChangeName(int enum_type,int enum_type_old);
    … …  
    158158                void               ThermalToEnthalpy(IssmDouble* penthalpy,IssmDouble temperature,IssmDouble waterfraction,IssmDouble pressure);
    159159                IssmDouble         TMeltingPoint(IssmDouble pressure);
    160                 IssmDouble         TotalFloatingBmb(IssmDouble* mask);
    161                 IssmDouble         TotalGroundedBmb(IssmDouble* mask);
    162                 IssmDouble         TotalSmb(IssmDouble* mask);
     160                IssmDouble         TotalFloatingBmb(IssmDouble* mask, bool scaled);
     161                IssmDouble         TotalGroundedBmb(IssmDouble* mask, bool scaled);
     162                IssmDouble         TotalSmb(IssmDouble* mask, bool scaled);
    163163                void               TransformInvStiffnessMatrixCoord(ElementMatrix* Ke,int cs_enum);
    164164                void               TransformInvStiffnessMatrixCoord(ElementMatrix* Ke,Node** nodes,int numnodes,int cs_enum);
    … …  
    203203                virtual void       ElementSizes(IssmDouble* phx,IssmDouble* phy,IssmDouble* phz)=0;
    204204                virtual int        FiniteElement(void)=0;
    205                 virtual IssmDouble FloatingArea(void)=0;
     205                virtual IssmDouble FloatingArea(bool scaled)=0;
    206206                virtual void       FSContactMigration(Vector<IssmDouble>* vertexgrounded,Vector<IssmDouble>* vertexfloating)=0;
    207207                virtual Element*   GetBasalElement(void)=0;
    … …  
    221221                virtual void       GetVerticesCoordinatesBase(IssmDouble** xyz_list)=0;
    222222                virtual void       GetVerticesCoordinatesTop(IssmDouble** xyz_list)=0;
    223                 virtual IssmDouble GroundedArea(void)=0;
    224                 virtual IssmDouble IceVolume(void)=0;
    225                 virtual IssmDouble IceVolumeAboveFloatation(void)=0;
     223                virtual IssmDouble GroundedArea(bool scaled)=0;
     224                virtual IssmDouble IceVolume(bool scaled)=0;
     225                virtual IssmDouble IceVolumeAboveFloatation(bool scaled)=0;
    226226                virtual void       InputDepthAverageAtBase(int enum_type,int average_enum_type)=0;
    227227                virtual void       InputExtrude(int input_enum,int start)=0;
    … …  
    289289                virtual int        TensorInterpolation()=0;
    290290                virtual IssmDouble TimeAdapt()=0;
    291                 virtual IssmDouble TotalFloatingBmb(void)=0;
    292                 virtual IssmDouble TotalGroundedBmb(void)=0;
    293                 virtual IssmDouble TotalSmb(void)=0;
     291                virtual IssmDouble TotalFloatingBmb(bool scaled)=0;
     292                virtual IssmDouble TotalGroundedBmb(bool scaled)=0;
     293                virtual IssmDouble TotalSmb(bool scaled)=0;
    294294                virtual void       Update(int index, IoModel* iomodel,int analysis_counter,int analysis_type,int finite_element)=0;
    295295                virtual void       UpdateConstraintsExtrudeFromBase(void)=0;

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

    r22308 r22326  
    686686}
    687687/*}}}*/
    688 IssmDouble Penta::FloatingArea(void){/*{{{*/
     688IssmDouble Penta::FloatingArea(bool scaled){/*{{{*/
    689689
    690690        /*Intermediaries*/
    … …  
    11601160
    11611161}/*}}}*/
    1162 IssmDouble Penta::GroundedArea(void){/*{{{*/
     1162IssmDouble Penta::GroundedArea(bool scaled){/*{{{*/
    11631163
    11641164        /*Intermediaries*/
    … …  
    11811181}
    11821182/*}}}*/
    1183 IssmDouble Penta::IceVolume(void){/*{{{*/
     1183IssmDouble Penta::IceVolume(bool scaled){/*{{{*/
    11841184
    11851185        /*The volume of a troncated prism is base * 1/3 sum(length of edges)*/
    … …  
    12031203}
    12041204/*}}}*/
    1205 IssmDouble Penta::IceVolumeAboveFloatation(void){/*{{{*/
     1205IssmDouble Penta::IceVolumeAboveFloatation(bool scaled){/*{{{*/
    12061206
    12071207        /*Volume above floatation: H + rho_water/rho_ice*bathymetry for nodes on the bed*/
    … …  
    26332633        return dt;
    26342634}/*}}}*/
    2635 IssmDouble Penta::TotalFloatingBmb(void){/*{{{*/
     2635IssmDouble Penta::TotalFloatingBmb(bool scaled){/*{{{*/
    26362636
    26372637        /*The fbmb[kg yr-1] of one element is area[m2] * melting_rate [kg m^-2 yr^-1]*/
    … …  
    26702670}
    26712671/*}}}*/
    2672 IssmDouble Penta::TotalGroundedBmb(void){/*{{{*/
     2672IssmDouble Penta::TotalGroundedBmb(bool scaled){/*{{{*/
    26732673
    26742674        /*The gbmb[kg yr-1] of one element is area[m2] * gounded melting rate [kg m^-2 yr^-1]*/
    … …  
    27072707}
    27082708/*}}}*/
    2709 IssmDouble Penta::TotalSmb(void){/*{{{*/
     2709IssmDouble Penta::TotalSmb(bool scaled){/*{{{*/
    27102710
    27112711        /*The smb[Gt yr-1] of one element is area[m2] * smb [ m ice yr^-1] * rho_ice [kg m-3] / 1e+10^12 */

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

    r22192 r22326  
    6464                void           ElementSizes(IssmDouble* hx,IssmDouble* hy,IssmDouble* hz);
    6565                int            FiniteElement(void);
    66                 IssmDouble     FloatingArea(void);
     66                IssmDouble     FloatingArea(bool scaled);
    6767                void           FSContactMigration(Vector<IssmDouble>* vertexgrounded,Vector<IssmDouble>* vertexfloating);
    6868                IssmDouble     GetArea3D(void){_error_("not implemented yet!");};
    … …  
    8888                void           GetVerticesCoordinatesBase(IssmDouble** pxyz_list);
    8989                void           GetVerticesCoordinatesTop(IssmDouble** pxyz_list);
    90                 IssmDouble     GroundedArea(void);
    91                 IssmDouble     IceVolume(void);
    92                 IssmDouble     IceVolumeAboveFloatation(void);
     90                IssmDouble     GroundedArea(bool scaled);
     91                IssmDouble     IceVolume(bool scaled);
     92                IssmDouble     IceVolumeAboveFloatation(bool scaled);
    9393                void           InputDepthAverageAtBase(int enum_type,int average_enum_type);
    9494                void             InputExtrude(int enum_type,int start);
    … …  
    159159                int            TensorInterpolation(){_error_("not implemented yet");};
    160160                IssmDouble     TimeAdapt();
    161                 IssmDouble     TotalFloatingBmb(void);
    162                 IssmDouble     TotalGroundedBmb(void);
    163                 IssmDouble     TotalSmb(void);
     161                IssmDouble     TotalFloatingBmb(bool scaled);
     162                IssmDouble     TotalGroundedBmb(bool scaled);
     163                IssmDouble     TotalSmb(bool scaled);
    164164                void           Update(int index, IoModel* iomodel,int analysis_counter,int analysis_type,int finitelement);
    165165                void           UpdateConstraintsExtrudeFromBase(void);

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

    r21931 r22326  
    5757                void        ElementSizes(IssmDouble* hx,IssmDouble* hy,IssmDouble* hz){_error_("not implemented yet");};
    5858                int         FiniteElement(void);
    59                 IssmDouble  FloatingArea(void){_error_("not implemented yet");};
     59                IssmDouble  FloatingArea(bool scaled){_error_("not implemented yet");};
    6060                void        FSContactMigration(Vector<IssmDouble>* vertexgrounded,Vector<IssmDouble>* vertexfloating){_error_("not implemented yet");};
    6161                Element*    GetBasalElement(void){_error_("not implemented yet");};
    … …  
    7676                void        GetVerticesCoordinatesBase(IssmDouble** pxyz_list){_error_("not implemented yet");};
    7777                void        GetVerticesCoordinatesTop(IssmDouble** pxyz_list){_error_("not implemented yet");};
    78                 IssmDouble  GroundedArea(void){_error_("not implemented yet");};
    79                 IssmDouble  IceVolume(void){_error_("not implemented yet");};
    80                 IssmDouble  IceVolumeAboveFloatation(void){_error_("not implemented yet");};
     78                IssmDouble  GroundedArea(bool scaled){_error_("not implemented yet");};
     79                IssmDouble  IceVolume(bool scaled){_error_("not implemented yet");};
     80                IssmDouble  IceVolumeAboveFloatation(bool scaled){_error_("not implemented yet");};
    8181                void        InputDepthAverageAtBase(int enum_type,int average_enum_type){_error_("not implemented yet");};
    8282                void        InputExtrude(int enum_type,int start){_error_("not implemented"); /*For penta only*/};
    … …  
    145145                int         TensorInterpolation(void){_error_("not implemented yet");};
    146146                IssmDouble  TimeAdapt(){_error_("not implemented yet");};
    147                 IssmDouble  TotalFloatingBmb(void){_error_("not implemented yet");};
    148                 IssmDouble  TotalGroundedBmb(void){_error_("not implemented yet");};
    149                 IssmDouble  TotalSmb(void){_error_("not implemented yet");};
     147                IssmDouble  TotalFloatingBmb(bool scaled){_error_("not implemented yet");};
     148                IssmDouble  TotalGroundedBmb(bool scaled){_error_("not implemented yet");};
     149                IssmDouble  TotalSmb(bool scaled){_error_("not implemented yet");};
    150150                void        Update(int index, IoModel* iomodel,int analysis_counter,int analysis_type,int finitelement){_error_("not implemented yet");};
    151151                void        UpdateConstraintsExtrudeFromBase(){_error_("not implemented");};

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

    r21931 r22326  
    6161                void        FaceOnSurfaceIndices(int* pindex1,int* pindex2,int* pindex3);
    6262                int         FiniteElement(void);
    63                 IssmDouble  FloatingArea(void){_error_("not implemented yet");};
     63                IssmDouble  FloatingArea(bool scaled){_error_("not implemented yet");};
    6464                void        FSContactMigration(Vector<IssmDouble>* vertexgrounded,Vector<IssmDouble>* vertexfloating){_error_("not implemented yet");};
    6565                IssmDouble     GetArea3D(void){_error_("not implemented yet!");};
    … …  
    8282                void        GetVerticesCoordinatesTop(IssmDouble** pxyz_list);
    8383                void        GradientIndexing(int* indexing,int control_index){_error_("not implemented yet");};
    84                 IssmDouble  GroundedArea(void){_error_("not implemented yet");};
     84                IssmDouble  GroundedArea(bool scaled){_error_("not implemented yet");};
    8585                bool        HasFaceOnBase();
    8686                bool        HasFaceOnSurface();
    87                 IssmDouble  IceVolume(void){_error_("not implemented yet");};
    88                 IssmDouble  IceVolumeAboveFloatation(void){_error_("not implemented yet");};
     87                IssmDouble  IceVolume(bool scaled){_error_("not implemented yet");};
     88                IssmDouble  IceVolumeAboveFloatation(bool scaled){_error_("not implemented yet");};
    8989                bool        IsFaceOnBoundary(void){_error_("not implemented yet");};
    9090                bool               IsIcefront(void);
    … …  
    154154                int         TensorInterpolation(void);
    155155                IssmDouble  TimeAdapt(){_error_("not implemented yet");};
    156                 IssmDouble  TotalFloatingBmb(void){_error_("not implemented yet");};
    157                 IssmDouble  TotalGroundedBmb(void){_error_("not implemented yet");};
    158                 IssmDouble  TotalSmb(void){_error_("not implemented yet");};
     156                IssmDouble  TotalFloatingBmb(bool scaled){_error_("not implemented yet");};
     157                IssmDouble  TotalGroundedBmb(bool scaled){_error_("not implemented yet");};
     158                IssmDouble  TotalSmb(bool scaled){_error_("not implemented yet");};
    159159                void        Update(int index, IoModel* iomodel,int analysis_counter,int analysis_type,int finitelement);
    160160                void        UpdateConstraintsExtrudeFromBase(){_error_("not implemented");};

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

    r22308 r22326  
    890890}
    891891/*}}}*/
    892 IssmDouble Tria::FloatingArea(void){/*{{{*/
     892IssmDouble Tria::FloatingArea(bool scaled){/*{{{*/
    893893
    894894        /*Intermediaries*/
    … …  
    16101610
    16111611}/*}}}*/
    1612 IssmDouble Tria::GroundedArea(void){/*{{{*/
     1612IssmDouble Tria::GroundedArea(bool scaled){/*{{{*/
    16131613
    16141614        /*Intermediaries*/
    … …  
    16731673}
    16741674/*}}}*/
    1675 IssmDouble Tria::IceVolume(void){/*{{{*/
     1675IssmDouble Tria::IceVolume(bool scaled){/*{{{*/
    16761676
    16771677        /*The volume of a truncated prism is area_base * 1/numedges sum(length of edges)*/
    … …  
    17441744}
    17451745/*}}}*/
    1746 IssmDouble Tria::IceVolumeAboveFloatation(void){/*{{{*/
     1746IssmDouble Tria::IceVolumeAboveFloatation(bool scaled){/*{{{*/
    17471747
    17481748        /*The volume above floatation: H + rho_water/rho_ice * bathymetry */
    … …  
    31153115}
    31163116/*}}}*/
    3117 IssmDouble Tria::TotalFloatingBmb(void){/*{{{*/
     3117IssmDouble Tria::TotalFloatingBmb(bool scaled){/*{{{*/
    31183118
    31193119        /*The fbmb[kg yr-1] of one element is area[m2] * melting_rate [kg m^-2 yr^-1]*/
    … …  
    31523152}
    31533153/*}}}*/
    3154 IssmDouble Tria::TotalGroundedBmb(void){/*{{{*/
     3154IssmDouble Tria::TotalGroundedBmb(bool scaled){/*{{{*/
    31553155
    31563156        /*The gbmb[kg yr-1] of one element is area[m2] * gounded melting rate [kg m^-2 yr^-1]*/
    … …  
    31893189}
    31903190/*}}}*/
    3191 IssmDouble Tria::TotalSmb(void){/*{{{*/
     3191IssmDouble Tria::TotalSmb(bool scaled){/*{{{*/
    31923192
    31933193        /*The smb[kg yr-1] of one element is area[m2] * smb [kg m^-2 yr^-1]*/

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

    r22192 r22326  
    7272                void        ElementSizes(IssmDouble* hx,IssmDouble* hy,IssmDouble* hz);
    7373                int         FiniteElement(void);
    74                 IssmDouble  FloatingArea(void);
     74                IssmDouble  FloatingArea(bool scaled);
    7575                void        FSContactMigration(Vector<IssmDouble>* vertexgrounded,Vector<IssmDouble>* vertexfloating);
    7676                Element*    GetBasalElement(void){_error_("not implemented yet");};
    … …  
    8787                void        GetVerticesCoordinatesBase(IssmDouble** pxyz_list);
    8888                void        GetVerticesCoordinatesTop(IssmDouble** pxyz_list);
    89                 IssmDouble  GroundedArea(void);
     89                IssmDouble  GroundedArea(bool scaled);
    9090                bool        HasEdgeOnBase();
    9191                bool        HasEdgeOnSurface();
    92                 IssmDouble  IceVolume(void);
    93                 IssmDouble  IceVolumeAboveFloatation(void);
     92                IssmDouble  IceVolume(bool scaled);
     93                IssmDouble  IceVolumeAboveFloatation(bool scaled);
    9494                void        InputDepthAverageAtBase(int enum_type,int average_enum_type);
    9595                void        InputExtrude(int enum_type,int start){_error_("not implemented"); /*For penta only*/};
    … …  
    125125                int         TensorInterpolation();
    126126                IssmDouble  TimeAdapt();
    127                 IssmDouble  TotalFloatingBmb(void);
    128                 IssmDouble  TotalGroundedBmb(void);
    129                 IssmDouble  TotalSmb(void);
     127                IssmDouble  TotalFloatingBmb(bool scaled);
     128                IssmDouble  TotalGroundedBmb(bool scaled);
     129                IssmDouble  TotalSmb(bool scaled);
    130130                void        Update(int index, IoModel* iomodel,int analysis_counter,int analysis_type,int finitelement);
    131131                int         UpdatePotentialUngrounding(IssmDouble* vertices_potentially_ungrounding,Vector<IssmDouble>* vec_nodes_on_iceshelf,IssmDouble* nodes_on_iceshelf);

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

    r22294 r22326  
    10421042
    10431043}/*}}}*/
    1044 void FemModel::FloatingAreax(IssmDouble* pV){/*{{{*/
     1044void FemModel::FloatingAreax(IssmDouble* pV, bool scaled){/*{{{*/
    10451045
    10461046        IssmDouble local_floating_area= 0;
    … …  
    10491049        for(int i=0;i<this->elements->Size();i++){
    10501050                Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
    1051                 local_floating_area+=element->FloatingArea();
     1051                local_floating_area+=element->FloatingArea(scaled);
    10521052        }
    10531053        ISSM_MPI_Reduce(&local_floating_area,&total_floating_area,1,ISSM_MPI_DOUBLE,ISSM_MPI_SUM,0,IssmComm::GetComm() );
    … …  
    10911091
    10921092}/*}}}*/
    1093 void FemModel::GroundedAreax(IssmDouble* pV){/*{{{*/
     1093void FemModel::GroundedAreax(IssmDouble* pV, bool scaled){/*{{{*/
    10941094
    10951095        IssmDouble local_grounded_area= 0;
    … …  
    10981098        for(int i=0;i<this->elements->Size();i++){
    10991099                Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
    1100                 local_grounded_area+=element->GroundedArea();
     1100                local_grounded_area+=element->GroundedArea(scaled);
    11011101        }
    11021102        ISSM_MPI_Reduce(&local_grounded_area,&total_grounded_area,1,ISSM_MPI_DOUBLE,ISSM_MPI_SUM,0,IssmComm::GetComm() );
    … …  
    11071107
    11081108}/*}}}*/
    1109 void FemModel::IceMassx(IssmDouble* pM){/*{{{*/
     1109void FemModel::IceMassx(IssmDouble* pM, bool scaled){/*{{{*/
    11101110
    11111111        IssmDouble local_ice_mass = 0;
    … …  
    11141114        for(int i=0;i<this->elements->Size();i++){
    11151115                Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
    1116                 local_ice_mass+=element->IceMass();
     1116                local_ice_mass+=element->IceMass(scaled);
    11171117        }
    11181118        ISSM_MPI_Reduce(&local_ice_mass,&total_ice_mass,1,ISSM_MPI_DOUBLE,ISSM_MPI_SUM,0,IssmComm::GetComm() );
    … …  
    11231123
    11241124}/*}}}*/
    1125 void FemModel::IceVolumeAboveFloatationx(IssmDouble* pV){/*{{{*/
     1125void FemModel::IceVolumeAboveFloatationx(IssmDouble* pV, bool scaled){/*{{{*/
    11261126
    11271127        IssmDouble local_ice_volume_af = 0;
    … …  
    11301130        for(int i=0;i<this->elements->Size();i++){
    11311131                Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
    1132                 local_ice_volume_af+=element->IceVolumeAboveFloatation();
     1132                local_ice_volume_af+=element->IceVolumeAboveFloatation(scaled);
    11331133        }
    11341134        ISSM_MPI_Reduce(&local_ice_volume_af,&total_ice_volume_af,1,ISSM_MPI_DOUBLE,ISSM_MPI_SUM,0,IssmComm::GetComm() );
    … …  
    11391139
    11401140}/*}}}*/
    1141 void FemModel::IceVolumex(IssmDouble* pV){/*{{{*/
     1141void FemModel::IceVolumex(IssmDouble* pV, bool scaled){/*{{{*/
    11421142
    11431143        IssmDouble local_ice_volume = 0;
    … …  
    11461146        for(int i=0;i<this->elements->Size();i++){
    11471147                Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
    1148                 local_ice_volume+=element->IceVolume();
     1148                local_ice_volume+=element->IceVolume(scaled);
    11491149        }
    11501150        ISSM_MPI_Reduce(&local_ice_volume,&total_ice_volume,1,ISSM_MPI_DOUBLE,ISSM_MPI_SUM,0,IssmComm::GetComm() );
    … …  
    17441744
    17451745                                        /*Scalar output*/
    1746                                         case DivergenceEnum:               this->Divergencex(&double_result);               break;
    1747                                         case MaxDivergenceEnum:            this->MaxDivergencex(&double_result);            break;
    1748                                         case IceMassEnum:                  this->IceMassx(&double_result);                  break;
    1749                                         case IceVolumeEnum:                this->IceVolumex(&double_result);                break;
    1750                                         case IceVolumeAboveFloatationEnum: this->IceVolumeAboveFloatationx(&double_result); break;
    1751                                         case GroundedAreaEnum:             this->GroundedAreax(&double_result);             break;
    1752                                         case FloatingAreaEnum:             this->FloatingAreax(&double_result);             break;
    1753                                         case MinVelEnum:                   this->MinVelx(&double_result);                   break;
    1754                                         case MaxVelEnum:                   this->MaxVelx(&double_result);                   break;
    1755                                         case MinVxEnum:                    this->MinVxx(&double_result);                    break;
    1756                                         case MaxVxEnum:                    this->MaxVxx(&double_result);                    break;
    1757                                         case MaxAbsVxEnum:                 this->MaxAbsVxx(&double_result);                 break;
    1758                                         case MinVyEnum:                    this->MinVyx(&double_result);                    break;
    1759                                         case MaxVyEnum:                    this->MaxVyx(&double_result);                    break;
    1760                                         case MaxAbsVyEnum:                 this->MaxAbsVyx(&double_result);                 break;
    1761                                         case MinVzEnum:                    this->MinVzx(&double_result);                    break;
    1762                                         case MaxVzEnum:                    this->MaxVzx(&double_result);                    break;
    1763                                         case MaxAbsVzEnum:                 this->MaxAbsVzx(&double_result);                 break;
    1764                                         case MassFluxEnum:                 this->MassFluxx(&double_result);                 break;
    1765                                         case TotalFloatingBmbEnum:         this->TotalFloatingBmbx(&double_result);         break;
    1766                                         case TotalGroundedBmbEnum:         this->TotalGroundedBmbx(&double_result);         break;
    1767                                         case TotalSmbEnum:                 this->TotalSmbx(&double_result);                 break;
     1746                                        case DivergenceEnum:                     this->Divergencex(&double_result);                     break;
     1747                                        case MaxDivergenceEnum:                  this->MaxDivergencex(&double_result);                  break;
     1748                                        case IceMassEnum:                        this->IceMassx(&double_result,false);                  break;
     1749                                        case IceMassScaledEnum:                  this->IceMassx(&double_result,true);                   break;
     1750                                        case IceVolumeEnum:                      this->IceVolumex(&double_result,false);                break;
     1751                                        case IceVolumeScaledEnum:                this->IceVolumex(&double_result,true);                 break;
     1752                                        case IceVolumeAboveFloatationEnum:       this->IceVolumeAboveFloatationx(&double_result,false); break;
     1753                                        case IceVolumeAboveFloatationScaledEnum: this->IceVolumeAboveFloatationx(&double_result,true);  break;
     1754                                        case GroundedAreaEnum:                   this->GroundedAreax(&double_result,false);             break;
     1755                                        case GroundedAreaScaledEnum:             this->GroundedAreax(&double_result,true);              break;
     1756                                        case FloatingAreaEnum:                   this->FloatingAreax(&double_result,false);             break;
     1757                                        case FloatingAreaScaledEnum:             this->FloatingAreax(&double_result,true);              break;
     1758                                        case MinVelEnum:                         this->MinVelx(&double_result);                         break;
     1759                                        case MaxVelEnum:                         this->MaxVelx(&double_result);                         break;
     1760                                        case MinVxEnum:                          this->MinVxx(&double_result);                          break;
     1761                                        case MaxVxEnum:                          this->MaxVxx(&double_result);                          break;
     1762                                        case MaxAbsVxEnum:                       this->MaxAbsVxx(&double_result);                       break;
     1763                                        case MinVyEnum:                          this->MinVyx(&double_result);                          break;
     1764                                        case MaxVyEnum:                          this->MaxVyx(&double_result);                          break;
     1765                                        case MaxAbsVyEnum:                       this->MaxAbsVyx(&double_result);                       break;
     1766                                        case MinVzEnum:                          this->MinVzx(&double_result);                          break;
     1767                                        case MaxVzEnum:                          this->MaxVzx(&double_result);                          break;
     1768                                        case MaxAbsVzEnum:                       this->MaxAbsVzx(&double_result);                       break;
     1769                                        case MassFluxEnum:                       this->MassFluxx(&double_result);                       break;
     1770                                        case TotalFloatingBmbEnum:               this->TotalFloatingBmbx(&double_result,false);         break;
     1771                                        case TotalFloatingBmbScaledEnum:         this->TotalFloatingBmbx(&double_result,true);          break;
     1772                                        case TotalGroundedBmbEnum:               this->TotalGroundedBmbx(&double_result,false);         break;
     1773                                        case TotalGroundedBmbScaledEnum:         this->TotalGroundedBmbx(&double_result,true);          break;
     1774                                        case TotalSmbEnum:                       this->TotalSmbx(&double_result,false);                 break;
     1775                                        case TotalSmbScaledEnum:                 this->TotalSmbx(&double_result,true);                  break;
    17681776
    17691777                           /*Scalar control output*/
    … …  
    19942002        switch (response_descriptor_enum){
    19952003
    1996                 case DivergenceEnum:               this->Divergencex(responses); break;
    1997                 case MaxDivergenceEnum:            this->MaxDivergencex(responses); break;
    1998                 case IceMassEnum:                  this->IceMassx(responses); break;
    1999                 case IceVolumeEnum:                this->IceVolumex(responses); break;
    2000                 case IceVolumeAboveFloatationEnum: this->IceVolumeAboveFloatationx(responses); break;
    2001                 case GroundedAreaEnum:             this->GroundedAreax(responses); break;
    2002                 case FloatingAreaEnum:             this->FloatingAreax(responses); break;
    2003                 case MinVelEnum:                   this->MinVelx(responses); break;
    2004                 case MaxVelEnum:                   this->MaxVelx(responses); break;
    2005                 case MinVxEnum:                    this->MinVxx(responses); break;
    2006                 case MaxVxEnum:                    this->MaxVxx(responses); break;
    2007                 case MaxAbsVxEnum:                 this->MaxAbsVxx(responses); break;
    2008                 case MinVyEnum:                    this->MinVyx(responses); break;
    2009                 case MaxVyEnum:                    this->MaxVyx(responses); break;
    2010                 case MaxAbsVyEnum:                 this->MaxAbsVyx(responses); break;
    2011                 case MinVzEnum:                    this->MinVzx(responses); break;
    2012                 case MaxVzEnum:                    this->MaxVzx(responses); break;
    2013                 case MaxAbsVzEnum:                 this->MaxAbsVzx(responses); break;
    2014                 case MassFluxEnum:                 this->MassFluxx(responses); break;
    2015                 case SurfaceAbsVelMisfitEnum:      SurfaceAbsVelMisfitx(responses, elements,nodes, vertices, loads, materials,parameters); break;
    2016                 case SurfaceRelVelMisfitEnum:      SurfaceRelVelMisfitx(responses, elements,nodes, vertices, loads, materials,parameters); break;
    2017                 case SurfaceLogVelMisfitEnum:      SurfaceLogVelMisfitx(responses, elements,nodes, vertices, loads, materials,parameters); break;
    2018                 case SurfaceLogVxVyMisfitEnum:     SurfaceLogVxVyMisfitx(responses, elements,nodes, vertices, loads, materials,parameters); break;
    2019                 case SurfaceAverageVelMisfitEnum:  SurfaceAverageVelMisfitx(responses,this); break;
    2020                 case ThicknessAbsMisfitEnum:       ThicknessAbsMisfitx(responses, elements,nodes, vertices, loads, materials, parameters); break;
    2021                 case ThicknessAbsGradientEnum:     this->ThicknessAbsGradientx(responses); break;
    2022                 case ThicknessAlongGradientEnum:   ThicknessAlongGradientx(responses, elements,nodes, vertices, loads, materials, parameters); break;
    2023                 case ThicknessAcrossGradientEnum:  ThicknessAcrossGradientx(responses, elements,nodes, vertices, loads, materials, parameters); break;
    2024                 case RheologyBbarAbsGradientEnum:  RheologyBbarAbsGradientx(responses, elements,nodes, vertices, loads, materials, parameters); break;
    2025                 case DragCoefficientAbsGradientEnum:DragCoefficientAbsGradientx(responses, elements,nodes, vertices, loads, materials, parameters); break;
    2026                 case BalancethicknessMisfitEnum:   BalancethicknessMisfitx(responses); break;
    2027                 case TotalFloatingBmbEnum:                        this->TotalFloatingBmbx(responses); break;
    2028                 case TotalGroundedBmbEnum:                        this->TotalGroundedBmbx(responses); break;
    2029                 case TotalSmbEnum:                                        this->TotalSmbx(responses); break;
    2030                 case MaterialsRheologyBbarEnum:    this->ElementResponsex(responses,MaterialsRheologyBbarEnum); break;
    2031                 case VelEnum:                      this->ElementResponsex(responses,VelEnum); break;
    2032                 case FrictionCoefficientEnum:      NodalValuex(responses, FrictionCoefficientEnum,elements,nodes, vertices, loads, materials, parameters); break;
     2004                case DivergenceEnum:                     this->Divergencex(responses); break;
     2005                case MaxDivergenceEnum:                  this->MaxDivergencex(responses); break;
     2006                case IceMassEnum:                        this->IceMassx(responses, false); break;
     2007                case IceMassScaledEnum:                  this->IceMassx(responses, true); break;
     2008                case IceVolumeEnum:                      this->IceVolumex(responses, false); break;
     2009                case IceVolumeScaledEnum:                this->IceVolumex(responses, true); break;
     2010                case IceVolumeAboveFloatationEnum:       this->IceVolumeAboveFloatationx(responses, false); break;
     2011                case IceVolumeAboveFloatationScaledEnum: this->IceVolumeAboveFloatationx(responses, true); break;
     2012                case GroundedAreaEnum:                   this->GroundedAreax(responses, false); break;
     2013                case GroundedAreaScaledEnum:             this->GroundedAreax(responses, true); break;
     2014                case FloatingAreaEnum:                   this->FloatingAreax(responses, false); break;
     2015                case FloatingAreaScaledEnum:             this->FloatingAreax(responses, true); break;
     2016                case MinVelEnum:                         this->MinVelx(responses); break;
     2017                case MaxVelEnum:                         this->MaxVelx(responses); break;
     2018                case MinVxEnum:                          this->MinVxx(responses); break;
     2019                case MaxVxEnum:                          this->MaxVxx(responses); break;
     2020                case MaxAbsVxEnum:                       this->MaxAbsVxx(responses); break;
     2021                case MinVyEnum:                          this->MinVyx(responses); break;
     2022                case MaxVyEnum:                          this->MaxVyx(responses); break;
     2023                case MaxAbsVyEnum:                       this->MaxAbsVyx(responses); break;
     2024                case MinVzEnum:                          this->MinVzx(responses); break;
     2025                case MaxVzEnum:                          this->MaxVzx(responses); break;
     2026                case MaxAbsVzEnum:                       this->MaxAbsVzx(responses); break;
     2027                case MassFluxEnum:                       this->MassFluxx(responses); break;
     2028                case SurfaceAbsVelMisfitEnum:            SurfaceAbsVelMisfitx(responses, elements,nodes, vertices, loads, materials,parameters); break;
     2029                case SurfaceRelVelMisfitEnum:            SurfaceRelVelMisfitx(responses, elements,nodes, vertices, loads, materials,parameters); break;
     2030                case SurfaceLogVelMisfitEnum:            SurfaceLogVelMisfitx(responses, elements,nodes, vertices, loads, materials,parameters); break;
     2031                case SurfaceLogVxVyMisfitEnum:           SurfaceLogVxVyMisfitx(responses, elements,nodes, vertices, loads, materials,parameters); break;
     2032                case SurfaceAverageVelMisfitEnum:        SurfaceAverageVelMisfitx(responses,this); break;
     2033                case ThicknessAbsMisfitEnum:             ThicknessAbsMisfitx(responses, elements,nodes, vertices, loads, materials, parameters); break;
     2034                case ThicknessAbsGradientEnum:           this->ThicknessAbsGradientx(responses); break;
     2035                case ThicknessAlongGradientEnum:         ThicknessAlongGradientx(responses, elements,nodes, vertices, loads, materials, parameters); break;
     2036                case ThicknessAcrossGradientEnum:        ThicknessAcrossGradientx(responses, elements,nodes, vertices, loads, materials, parameters); break;
     2037                case RheologyBbarAbsGradientEnum:        RheologyBbarAbsGradientx(responses, elements,nodes, vertices, loads, materials, parameters); break;
     2038                case DragCoefficientAbsGradientEnum:     DragCoefficientAbsGradientx(responses, elements,nodes, vertices, loads, materials, parameters); break;
     2039                case BalancethicknessMisfitEnum:         BalancethicknessMisfitx(responses); break;
     2040                case TotalFloatingBmbEnum:                              this->TotalFloatingBmbx(responses, false); break;
     2041                case TotalFloatingBmbScaledEnum:                          this->TotalFloatingBmbx(responses, true); break;
     2042                case TotalGroundedBmbEnum:                              this->TotalGroundedBmbx(responses, false); break;
     2043                case TotalGroundedBmbScaledEnum:                          this->TotalGroundedBmbx(responses, true); break;
     2044                case TotalSmbEnum:                                              this->TotalSmbx(responses, false); break;
     2045                case TotalSmbScaledEnum:                                          this->TotalSmbx(responses, true); break;
     2046                case MaterialsRheologyBbarEnum:          this->ElementResponsex(responses,MaterialsRheologyBbarEnum); break;
     2047                case VelEnum:                            this->ElementResponsex(responses,VelEnum); break;
     2048                case FrictionCoefficientEnum:            NodalValuex(responses, FrictionCoefficientEnum,elements,nodes, vertices, loads, materials, parameters); break;
    20332049                default:
    20342050                        if(response_descriptor_enum>=Outputdefinition1Enum && response_descriptor_enum <=Outputdefinition100Enum){
    … …  
    22782294}
    22792295/*}}}*/
    2280 void FemModel::TotalFloatingBmbx(IssmDouble* pFbmb){/*{{{*/
     2296void FemModel::TotalFloatingBmbx(IssmDouble* pFbmb, bool scaled){/*{{{*/
    22812297
    22822298        IssmDouble local_fbmb = 0;
    … …  
    22852301        for(int i=0;i<this->elements->Size();i++){
    22862302                Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
    2287                 local_fbmb+=element->TotalFloatingBmb();
     2303                local_fbmb+=element->TotalFloatingBmb(scaled);
    22882304        }
    22892305        ISSM_MPI_Reduce(&local_fbmb,&total_fbmb,1,ISSM_MPI_DOUBLE,ISSM_MPI_SUM,0,IssmComm::GetComm() );
    … …  
    22942310
    22952311}/*}}}*/
    2296 void FemModel::TotalGroundedBmbx(IssmDouble* pGbmb){/*{{{*/
     2312void FemModel::TotalGroundedBmbx(IssmDouble* pGbmb, bool scaled){/*{{{*/
    22972313
    22982314        IssmDouble local_gbmb = 0;
    … …  
    23012317        for(int i=0;i<this->elements->Size();i++){
    23022318                Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
    2303                 local_gbmb+=element->TotalGroundedBmb();
     2319                local_gbmb+=element->TotalGroundedBmb(scaled);
    23042320        }
    23052321        ISSM_MPI_Reduce(&local_gbmb,&total_gbmb,1,ISSM_MPI_DOUBLE,ISSM_MPI_SUM,0,IssmComm::GetComm() );
    … …  
    23102326
    23112327}/*}}}*/
    2312 void FemModel::TotalSmbx(IssmDouble* pSmb){/*{{{*/
     2328void FemModel::TotalSmbx(IssmDouble* pSmb, bool scaled){/*{{{*/
    23132329
    23142330        IssmDouble local_smb = 0;
    … …  
    23172333        for(int i=0;i<this->elements->Size();i++){
    23182334                Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
    2319                 local_smb+=element->TotalSmb();
     2335                local_smb+=element->TotalSmb(scaled);
    23202336        }
    23212337        ISSM_MPI_Reduce(&local_smb,&total_smb,1,ISSM_MPI_DOUBLE,ISSM_MPI_SUM,0,IssmComm::GetComm() );

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

    r22285 r22326  
    8888                void ElementOperationx(void (Element::*function)(void));
    8989                void ElementResponsex(IssmDouble* presponse,int response_enum);
    90                 void FloatingAreax(IssmDouble* pV);
     90                void FloatingAreax(IssmDouble* pV, bool scaled);
    9191                void GetInputLocalMinMaxOnNodesx(IssmDouble** pmin,IssmDouble** pmax,IssmDouble* ug);
    92                 void GroundedAreax(IssmDouble* pV);
    93                 void IceMassx(IssmDouble* pV);
    94                 void IceVolumex(IssmDouble* pV);
    95                 void IceVolumeAboveFloatationx(IssmDouble* pV);
     92                void GroundedAreax(IssmDouble* pV, bool scaled);
     93                void IceMassx(IssmDouble* pV, bool scaled);
     94                void IceVolumex(IssmDouble* pV, bool scaled);
     95                void IceVolumeAboveFloatationx(IssmDouble* pV, bool scaled);
    9696                void MassFluxx(IssmDouble* presponse);
    9797                void MaxAbsVxx(IssmDouble* presponse);
    … …  
    112112                void StrainRateeffectivex();
    113113                void StressIntensityFactorx();
    114                 void TotalFloatingBmbx(IssmDouble* pFbmb);
    115                 void TotalGroundedBmbx(IssmDouble* pGbmb);
    116                 void TotalSmbx(IssmDouble* pSmb);
     114                void TotalFloatingBmbx(IssmDouble* pFbmb, bool scaled);
     115                void TotalGroundedBmbx(IssmDouble* pGbmb, bool scaled);
     116                void TotalSmbx(IssmDouble* pSmb, bool scaled);
    117117                #ifdef  _HAVE_DAKOTA_
    118118                void DakotaResponsesx(double* d_responses,char** responses_descriptors,int numresponsedescriptors,int d_numresponses);

  • TabularUnified issm/trunk-jpl/src/c/shared/Enum/EnumDefinitions.h

    r22323 r22326  
    10771077        MaxAbsVzEnum,
    10781078        FloatingAreaEnum,
     1079        FloatingAreaScaledEnum,
    10791080        GroundedAreaEnum,
     1081        GroundedAreaScaledEnum,
    10801082        IceMassEnum,
     1083        IceMassScaledEnum,
    10811084        IceVolumeEnum,
     1085        IceVolumeScaledEnum,
    10821086        IceVolumeAboveFloatationEnum,
     1087        IceVolumeAboveFloatationScaledEnum,
    10831088        TotalFloatingBmbEnum,
     1089        TotalFloatingBmbScaledEnum,
    10841090        TotalGroundedBmbEnum,
     1091        TotalGroundedBmbScaledEnum,
    10851092        TotalSmbEnum,
     1093        TotalSmbScaledEnum,
    10861094        /*}}}*/
    10871095        /*Element Interpolations{{{*/

  • TabularUnified issm/trunk-jpl/src/c/shared/Enum/EnumToStringx.cpp

    r22323 r22326  
    10341034                case MaxAbsVzEnum : return "MaxAbsVz";
    10351035                case FloatingAreaEnum : return "FloatingArea";
     1036                case FloatingAreaScaledEnum : return "FloatingAreaScaled";
    10361037                case GroundedAreaEnum : return "GroundedArea";
     1038                case GroundedAreaScaledEnum : return "GroundedAreaScaled";
    10371039                case IceMassEnum : return "IceMass";
     1040                case IceMassScaledEnum : return "IceMassScaled";
    10381041                case IceVolumeEnum : return "IceVolume";
     1042                case IceVolumeScaledEnum : return "IceVolumeScaled";
    10391043                case IceVolumeAboveFloatationEnum : return "IceVolumeAboveFloatation";
     1044                case IceVolumeAboveFloatationScaledEnum : return "IceVolumeAboveFloatationScaled";
    10401045                case TotalFloatingBmbEnum : return "TotalFloatingBmb";
     1046                case TotalFloatingBmbScaledEnum : return "TotalFloatingBmbScaled";
    10411047                case TotalGroundedBmbEnum : return "TotalGroundedBmb";
     1048                case TotalGroundedBmbScaledEnum : return "TotalGroundedBmbScaled";
    10421049                case TotalSmbEnum : return "TotalSmb";
     1050                case TotalSmbScaledEnum : return "TotalSmbScaled";
    10431051                case P0Enum : return "P0";
    10441052                case P0ArrayEnum : return "P0Array";

  • TabularUnified issm/trunk-jpl/src/c/shared/Enum/StringToEnumx.cpp

    r22323 r22326  
    10581058              else if (strcmp(name,"MaxAbsVz")==0) return MaxAbsVzEnum;
    10591059              else if (strcmp(name,"FloatingArea")==0) return FloatingAreaEnum;
     1060              else if (strcmp(name,"FloatingAreaScaled")==0) return FloatingAreaScaledEnum;
    10601061              else if (strcmp(name,"GroundedArea")==0) return GroundedAreaEnum;
     1062              else if (strcmp(name,"GroundedAreaScaled")==0) return GroundedAreaScaledEnum;
    10611063              else if (strcmp(name,"IceMass")==0) return IceMassEnum;
     1064              else if (strcmp(name,"IceMassScaled")==0) return IceMassScaledEnum;
    10621065              else if (strcmp(name,"IceVolume")==0) return IceVolumeEnum;
     1066              else if (strcmp(name,"IceVolumeScaled")==0) return IceVolumeScaledEnum;
    10631067              else if (strcmp(name,"IceVolumeAboveFloatation")==0) return IceVolumeAboveFloatationEnum;
     1068              else if (strcmp(name,"IceVolumeAboveFloatationScaled")==0) return IceVolumeAboveFloatationScaledEnum;
    10641069              else if (strcmp(name,"TotalFloatingBmb")==0) return TotalFloatingBmbEnum;
     1070              else if (strcmp(name,"TotalFloatingBmbScaled")==0) return TotalFloatingBmbScaledEnum;
    10651071              else if (strcmp(name,"TotalGroundedBmb")==0) return TotalGroundedBmbEnum;
     1072              else if (strcmp(name,"TotalGroundedBmbScaled")==0) return TotalGroundedBmbScaledEnum;
    10661073              else if (strcmp(name,"TotalSmb")==0) return TotalSmbEnum;
     1074              else if (strcmp(name,"TotalSmbScaled")==0) return TotalSmbScaledEnum;
    10671075              else if (strcmp(name,"P0")==0) return P0Enum;
    10681076              else if (strcmp(name,"P0Array")==0) return P0ArrayEnum;
Note: See TracChangeset for help on using the changeset viewer.