Index: /issm/trunk-jpl/src/c/classes/Elements/Element.cpp =================================================================== --- /issm/trunk-jpl/src/c/classes/Elements/Element.cpp (revision 22325) +++ /issm/trunk-jpl/src/c/classes/Elements/Element.cpp (revision 22326) @@ -861,5 +861,5 @@ this->parameters->FindParam(pvalues,psize,paramenum); }/*}}}*/ -IssmDouble Element::FloatingArea(IssmDouble* mask){/*{{{*/ +IssmDouble Element::FloatingArea(IssmDouble* mask, bool scaled){/*{{{*/ /*Retrieve values of the mask defining the element: */ @@ -871,5 +871,5 @@ /*Return: */ - return this->FloatingArea(); + return this->FloatingArea(scaled); } /*}}}*/ @@ -1404,5 +1404,5 @@ } /*}}}*/ -IssmDouble Element::GroundedArea(IssmDouble* mask){/*{{{*/ +IssmDouble Element::GroundedArea(IssmDouble* mask, bool scaled){/*{{{*/ /*Retrieve values of the mask defining the element: */ @@ -1414,5 +1414,5 @@ /*Return: */ - return this->GroundedArea(); + return this->GroundedArea(scaled); } /*}}}*/ @@ -1423,5 +1423,5 @@ return (this->inputs->Max(MeshVertexonsurfaceEnum)>0.); }/*}}}*/ -IssmDouble Element::IceMass(void){/*{{{*/ +IssmDouble Element::IceMass(bool scaled){/*{{{*/ IssmDouble rho_ice; @@ -1432,8 +1432,8 @@ rho_ice=matpar->GetMaterialParameter(MaterialsRhoIceEnum); - return rho_ice*this->IceVolume(); -} -/*}}}*/ -IssmDouble Element::IceMass(IssmDouble* mask){/*{{{*/ + return rho_ice*this->IceVolume(scaled); +} +/*}}}*/ +IssmDouble Element::IceMass(IssmDouble* mask, bool scaled){/*{{{*/ /*Retrieve values of the mask defining the element: */ @@ -1445,8 +1445,8 @@ /*Return: */ - return this->IceMass(); -} -/*}}}*/ -IssmDouble Element::IceVolume(IssmDouble* mask){/*{{{*/ + return this->IceMass(scaled); +} +/*}}}*/ +IssmDouble Element::IceVolume(IssmDouble* mask, bool scaled){/*{{{*/ /*Retrieve values of the mask defining the element: */ @@ -1458,8 +1458,8 @@ /*Return: */ - return this->IceVolume(); -} -/*}}}*/ -IssmDouble Element::IceVolumeAboveFloatation(IssmDouble* mask){/*{{{*/ + return this->IceVolume(scaled); +} +/*}}}*/ +IssmDouble Element::IceVolumeAboveFloatation(IssmDouble* mask, bool scaled){/*{{{*/ /*Retrieve values of the mask defining the element: */ @@ -1471,5 +1471,5 @@ /*Return: */ - return this->IceVolumeAboveFloatation(); + return this->IceVolumeAboveFloatation(scaled); } /*}}}*/ @@ -3137,5 +3137,5 @@ return this->matpar->TMeltingPoint(pressure); }/*}}}*/ -IssmDouble Element::TotalFloatingBmb(IssmDouble* mask){/*{{{*/ +IssmDouble Element::TotalFloatingBmb(IssmDouble* mask, bool scaled){/*{{{*/ /*Retrieve values of the mask defining the element: */ @@ -3147,8 +3147,8 @@ /*Return: */ - return this->TotalFloatingBmb(); -} -/*}}}*/ -IssmDouble Element::TotalGroundedBmb(IssmDouble* mask){/*{{{*/ + return this->TotalFloatingBmb(scaled); +} +/*}}}*/ +IssmDouble Element::TotalGroundedBmb(IssmDouble* mask, bool scaled){/*{{{*/ /*Retrieve values of the mask defining the element: */ @@ -3160,8 +3160,8 @@ /*Return: */ - return this->TotalGroundedBmb(); -} -/*}}}*/ -IssmDouble Element::TotalSmb(IssmDouble* mask){/*{{{*/ + return this->TotalGroundedBmb(scaled); +} +/*}}}*/ +IssmDouble Element::TotalSmb(IssmDouble* mask, bool scaled){/*{{{*/ /*Retrieve values of the mask defining the element: */ @@ -3173,5 +3173,5 @@ /*Return: */ - return this->TotalSmb(); + return this->TotalSmb(scaled); } /*}}}*/ Index: /issm/trunk-jpl/src/c/classes/Elements/Element.h =================================================================== --- /issm/trunk-jpl/src/c/classes/Elements/Element.h (revision 22325) +++ /issm/trunk-jpl/src/c/classes/Elements/Element.h (revision 22326) @@ -81,5 +81,5 @@ void FindParam(IssmDouble* pvalue,int paramenum); void FindParam(int** pvalues,int* psize,int paramenum); - IssmDouble FloatingArea(IssmDouble* mask); + IssmDouble FloatingArea(IssmDouble* mask, bool scaled); void GetDofList(int** pdoflist,int approximation_enum,int setenum); void GetDofListPressure(int** pdoflist,int setenum); @@ -112,11 +112,11 @@ IssmDouble GetZcoord(IssmDouble* xyz_list,Gauss* gauss); void GradientIndexing(int* indexing,int control_index,bool onsid=false); - IssmDouble GroundedArea(IssmDouble* mask); + IssmDouble GroundedArea(IssmDouble* mask, bool scaled); bool HasNodeOnBase(); bool HasNodeOnSurface(); - IssmDouble IceMass(); - IssmDouble IceMass(IssmDouble* mask); - IssmDouble IceVolume(IssmDouble* mask); - IssmDouble IceVolumeAboveFloatation(IssmDouble* mask); + IssmDouble IceMass(bool scaled); + IssmDouble IceMass(IssmDouble* mask, bool scaled); + IssmDouble IceVolume(IssmDouble* mask, bool scaled); + IssmDouble IceVolumeAboveFloatation(IssmDouble* mask, bool scaled); int Id(); void InputChangeName(int enum_type,int enum_type_old); @@ -158,7 +158,7 @@ void ThermalToEnthalpy(IssmDouble* penthalpy,IssmDouble temperature,IssmDouble waterfraction,IssmDouble pressure); IssmDouble TMeltingPoint(IssmDouble pressure); - IssmDouble TotalFloatingBmb(IssmDouble* mask); - IssmDouble TotalGroundedBmb(IssmDouble* mask); - IssmDouble TotalSmb(IssmDouble* mask); + IssmDouble TotalFloatingBmb(IssmDouble* mask, bool scaled); + IssmDouble TotalGroundedBmb(IssmDouble* mask, bool scaled); + IssmDouble TotalSmb(IssmDouble* mask, bool scaled); void TransformInvStiffnessMatrixCoord(ElementMatrix* Ke,int cs_enum); void TransformInvStiffnessMatrixCoord(ElementMatrix* Ke,Node** nodes,int numnodes,int cs_enum); @@ -203,5 +203,5 @@ virtual void ElementSizes(IssmDouble* phx,IssmDouble* phy,IssmDouble* phz)=0; virtual int FiniteElement(void)=0; - virtual IssmDouble FloatingArea(void)=0; + virtual IssmDouble FloatingArea(bool scaled)=0; virtual void FSContactMigration(Vector* vertexgrounded,Vector* vertexfloating)=0; virtual Element* GetBasalElement(void)=0; @@ -221,7 +221,7 @@ virtual void GetVerticesCoordinatesBase(IssmDouble** xyz_list)=0; virtual void GetVerticesCoordinatesTop(IssmDouble** xyz_list)=0; - virtual IssmDouble GroundedArea(void)=0; - virtual IssmDouble IceVolume(void)=0; - virtual IssmDouble IceVolumeAboveFloatation(void)=0; + virtual IssmDouble GroundedArea(bool scaled)=0; + virtual IssmDouble IceVolume(bool scaled)=0; + virtual IssmDouble IceVolumeAboveFloatation(bool scaled)=0; virtual void InputDepthAverageAtBase(int enum_type,int average_enum_type)=0; virtual void InputExtrude(int input_enum,int start)=0; @@ -289,7 +289,7 @@ virtual int TensorInterpolation()=0; virtual IssmDouble TimeAdapt()=0; - virtual IssmDouble TotalFloatingBmb(void)=0; - virtual IssmDouble TotalGroundedBmb(void)=0; - virtual IssmDouble TotalSmb(void)=0; + virtual IssmDouble TotalFloatingBmb(bool scaled)=0; + virtual IssmDouble TotalGroundedBmb(bool scaled)=0; + virtual IssmDouble TotalSmb(bool scaled)=0; virtual void Update(int index, IoModel* iomodel,int analysis_counter,int analysis_type,int finite_element)=0; virtual void UpdateConstraintsExtrudeFromBase(void)=0; Index: /issm/trunk-jpl/src/c/classes/Elements/Penta.cpp =================================================================== --- /issm/trunk-jpl/src/c/classes/Elements/Penta.cpp (revision 22325) +++ /issm/trunk-jpl/src/c/classes/Elements/Penta.cpp (revision 22326) @@ -686,5 +686,5 @@ } /*}}}*/ -IssmDouble Penta::FloatingArea(void){/*{{{*/ +IssmDouble Penta::FloatingArea(bool scaled){/*{{{*/ /*Intermediaries*/ @@ -1160,5 +1160,5 @@ }/*}}}*/ -IssmDouble Penta::GroundedArea(void){/*{{{*/ +IssmDouble Penta::GroundedArea(bool scaled){/*{{{*/ /*Intermediaries*/ @@ -1181,5 +1181,5 @@ } /*}}}*/ -IssmDouble Penta::IceVolume(void){/*{{{*/ +IssmDouble Penta::IceVolume(bool scaled){/*{{{*/ /*The volume of a troncated prism is base * 1/3 sum(length of edges)*/ @@ -1203,5 +1203,5 @@ } /*}}}*/ -IssmDouble Penta::IceVolumeAboveFloatation(void){/*{{{*/ +IssmDouble Penta::IceVolumeAboveFloatation(bool scaled){/*{{{*/ /*Volume above floatation: H + rho_water/rho_ice*bathymetry for nodes on the bed*/ @@ -2633,5 +2633,5 @@ return dt; }/*}}}*/ -IssmDouble Penta::TotalFloatingBmb(void){/*{{{*/ +IssmDouble Penta::TotalFloatingBmb(bool scaled){/*{{{*/ /*The fbmb[kg yr-1] of one element is area[m2] * melting_rate [kg m^-2 yr^-1]*/ @@ -2670,5 +2670,5 @@ } /*}}}*/ -IssmDouble Penta::TotalGroundedBmb(void){/*{{{*/ +IssmDouble Penta::TotalGroundedBmb(bool scaled){/*{{{*/ /*The gbmb[kg yr-1] of one element is area[m2] * gounded melting rate [kg m^-2 yr^-1]*/ @@ -2707,5 +2707,5 @@ } /*}}}*/ -IssmDouble Penta::TotalSmb(void){/*{{{*/ +IssmDouble Penta::TotalSmb(bool scaled){/*{{{*/ /*The smb[Gt yr-1] of one element is area[m2] * smb [ m ice yr^-1] * rho_ice [kg m-3] / 1e+10^12 */ Index: /issm/trunk-jpl/src/c/classes/Elements/Penta.h =================================================================== --- /issm/trunk-jpl/src/c/classes/Elements/Penta.h (revision 22325) +++ /issm/trunk-jpl/src/c/classes/Elements/Penta.h (revision 22326) @@ -64,5 +64,5 @@ void ElementSizes(IssmDouble* hx,IssmDouble* hy,IssmDouble* hz); int FiniteElement(void); - IssmDouble FloatingArea(void); + IssmDouble FloatingArea(bool scaled); void FSContactMigration(Vector* vertexgrounded,Vector* vertexfloating); IssmDouble GetArea3D(void){_error_("not implemented yet!");}; @@ -88,7 +88,7 @@ void GetVerticesCoordinatesBase(IssmDouble** pxyz_list); void GetVerticesCoordinatesTop(IssmDouble** pxyz_list); - IssmDouble GroundedArea(void); - IssmDouble IceVolume(void); - IssmDouble IceVolumeAboveFloatation(void); + IssmDouble GroundedArea(bool scaled); + IssmDouble IceVolume(bool scaled); + IssmDouble IceVolumeAboveFloatation(bool scaled); void InputDepthAverageAtBase(int enum_type,int average_enum_type); void InputExtrude(int enum_type,int start); @@ -159,7 +159,7 @@ int TensorInterpolation(){_error_("not implemented yet");}; IssmDouble TimeAdapt(); - IssmDouble TotalFloatingBmb(void); - IssmDouble TotalGroundedBmb(void); - IssmDouble TotalSmb(void); + IssmDouble TotalFloatingBmb(bool scaled); + IssmDouble TotalGroundedBmb(bool scaled); + IssmDouble TotalSmb(bool scaled); void Update(int index, IoModel* iomodel,int analysis_counter,int analysis_type,int finitelement); void UpdateConstraintsExtrudeFromBase(void); Index: /issm/trunk-jpl/src/c/classes/Elements/Seg.h =================================================================== --- /issm/trunk-jpl/src/c/classes/Elements/Seg.h (revision 22325) +++ /issm/trunk-jpl/src/c/classes/Elements/Seg.h (revision 22326) @@ -57,5 +57,5 @@ void ElementSizes(IssmDouble* hx,IssmDouble* hy,IssmDouble* hz){_error_("not implemented yet");}; int FiniteElement(void); - IssmDouble FloatingArea(void){_error_("not implemented yet");}; + IssmDouble FloatingArea(bool scaled){_error_("not implemented yet");}; void FSContactMigration(Vector* vertexgrounded,Vector* vertexfloating){_error_("not implemented yet");}; Element* GetBasalElement(void){_error_("not implemented yet");}; @@ -76,7 +76,7 @@ void GetVerticesCoordinatesBase(IssmDouble** pxyz_list){_error_("not implemented yet");}; void GetVerticesCoordinatesTop(IssmDouble** pxyz_list){_error_("not implemented yet");}; - IssmDouble GroundedArea(void){_error_("not implemented yet");}; - IssmDouble IceVolume(void){_error_("not implemented yet");}; - IssmDouble IceVolumeAboveFloatation(void){_error_("not implemented yet");}; + IssmDouble GroundedArea(bool scaled){_error_("not implemented yet");}; + IssmDouble IceVolume(bool scaled){_error_("not implemented yet");}; + IssmDouble IceVolumeAboveFloatation(bool scaled){_error_("not implemented yet");}; void InputDepthAverageAtBase(int enum_type,int average_enum_type){_error_("not implemented yet");}; void InputExtrude(int enum_type,int start){_error_("not implemented"); /*For penta only*/}; @@ -145,7 +145,7 @@ int TensorInterpolation(void){_error_("not implemented yet");}; IssmDouble TimeAdapt(){_error_("not implemented yet");}; - IssmDouble TotalFloatingBmb(void){_error_("not implemented yet");}; - IssmDouble TotalGroundedBmb(void){_error_("not implemented yet");}; - IssmDouble TotalSmb(void){_error_("not implemented yet");}; + IssmDouble TotalFloatingBmb(bool scaled){_error_("not implemented yet");}; + IssmDouble TotalGroundedBmb(bool scaled){_error_("not implemented yet");}; + IssmDouble TotalSmb(bool scaled){_error_("not implemented yet");}; void Update(int index, IoModel* iomodel,int analysis_counter,int analysis_type,int finitelement){_error_("not implemented yet");}; void UpdateConstraintsExtrudeFromBase(){_error_("not implemented");}; Index: /issm/trunk-jpl/src/c/classes/Elements/Tetra.h =================================================================== --- /issm/trunk-jpl/src/c/classes/Elements/Tetra.h (revision 22325) +++ /issm/trunk-jpl/src/c/classes/Elements/Tetra.h (revision 22326) @@ -61,5 +61,5 @@ void FaceOnSurfaceIndices(int* pindex1,int* pindex2,int* pindex3); int FiniteElement(void); - IssmDouble FloatingArea(void){_error_("not implemented yet");}; + IssmDouble FloatingArea(bool scaled){_error_("not implemented yet");}; void FSContactMigration(Vector* vertexgrounded,Vector* vertexfloating){_error_("not implemented yet");}; IssmDouble GetArea3D(void){_error_("not implemented yet!");}; @@ -82,9 +82,9 @@ void GetVerticesCoordinatesTop(IssmDouble** pxyz_list); void GradientIndexing(int* indexing,int control_index){_error_("not implemented yet");}; - IssmDouble GroundedArea(void){_error_("not implemented yet");}; + IssmDouble GroundedArea(bool scaled){_error_("not implemented yet");}; bool HasFaceOnBase(); bool HasFaceOnSurface(); - IssmDouble IceVolume(void){_error_("not implemented yet");}; - IssmDouble IceVolumeAboveFloatation(void){_error_("not implemented yet");}; + IssmDouble IceVolume(bool scaled){_error_("not implemented yet");}; + IssmDouble IceVolumeAboveFloatation(bool scaled){_error_("not implemented yet");}; bool IsFaceOnBoundary(void){_error_("not implemented yet");}; bool IsIcefront(void); @@ -154,7 +154,7 @@ int TensorInterpolation(void); IssmDouble TimeAdapt(){_error_("not implemented yet");}; - IssmDouble TotalFloatingBmb(void){_error_("not implemented yet");}; - IssmDouble TotalGroundedBmb(void){_error_("not implemented yet");}; - IssmDouble TotalSmb(void){_error_("not implemented yet");}; + IssmDouble TotalFloatingBmb(bool scaled){_error_("not implemented yet");}; + IssmDouble TotalGroundedBmb(bool scaled){_error_("not implemented yet");}; + IssmDouble TotalSmb(bool scaled){_error_("not implemented yet");}; void Update(int index, IoModel* iomodel,int analysis_counter,int analysis_type,int finitelement); void UpdateConstraintsExtrudeFromBase(){_error_("not implemented");}; Index: /issm/trunk-jpl/src/c/classes/Elements/Tria.cpp =================================================================== --- /issm/trunk-jpl/src/c/classes/Elements/Tria.cpp (revision 22325) +++ /issm/trunk-jpl/src/c/classes/Elements/Tria.cpp (revision 22326) @@ -890,5 +890,5 @@ } /*}}}*/ -IssmDouble Tria::FloatingArea(void){/*{{{*/ +IssmDouble Tria::FloatingArea(bool scaled){/*{{{*/ /*Intermediaries*/ @@ -1610,5 +1610,5 @@ }/*}}}*/ -IssmDouble Tria::GroundedArea(void){/*{{{*/ +IssmDouble Tria::GroundedArea(bool scaled){/*{{{*/ /*Intermediaries*/ @@ -1673,5 +1673,5 @@ } /*}}}*/ -IssmDouble Tria::IceVolume(void){/*{{{*/ +IssmDouble Tria::IceVolume(bool scaled){/*{{{*/ /*The volume of a truncated prism is area_base * 1/numedges sum(length of edges)*/ @@ -1744,5 +1744,5 @@ } /*}}}*/ -IssmDouble Tria::IceVolumeAboveFloatation(void){/*{{{*/ +IssmDouble Tria::IceVolumeAboveFloatation(bool scaled){/*{{{*/ /*The volume above floatation: H + rho_water/rho_ice * bathymetry */ @@ -3115,5 +3115,5 @@ } /*}}}*/ -IssmDouble Tria::TotalFloatingBmb(void){/*{{{*/ +IssmDouble Tria::TotalFloatingBmb(bool scaled){/*{{{*/ /*The fbmb[kg yr-1] of one element is area[m2] * melting_rate [kg m^-2 yr^-1]*/ @@ -3152,5 +3152,5 @@ } /*}}}*/ -IssmDouble Tria::TotalGroundedBmb(void){/*{{{*/ +IssmDouble Tria::TotalGroundedBmb(bool scaled){/*{{{*/ /*The gbmb[kg yr-1] of one element is area[m2] * gounded melting rate [kg m^-2 yr^-1]*/ @@ -3189,5 +3189,5 @@ } /*}}}*/ -IssmDouble Tria::TotalSmb(void){/*{{{*/ +IssmDouble Tria::TotalSmb(bool scaled){/*{{{*/ /*The smb[kg yr-1] of one element is area[m2] * smb [kg m^-2 yr^-1]*/ Index: /issm/trunk-jpl/src/c/classes/Elements/Tria.h =================================================================== --- /issm/trunk-jpl/src/c/classes/Elements/Tria.h (revision 22325) +++ /issm/trunk-jpl/src/c/classes/Elements/Tria.h (revision 22326) @@ -72,5 +72,5 @@ void ElementSizes(IssmDouble* hx,IssmDouble* hy,IssmDouble* hz); int FiniteElement(void); - IssmDouble FloatingArea(void); + IssmDouble FloatingArea(bool scaled); void FSContactMigration(Vector* vertexgrounded,Vector* vertexfloating); Element* GetBasalElement(void){_error_("not implemented yet");}; @@ -87,9 +87,9 @@ void GetVerticesCoordinatesBase(IssmDouble** pxyz_list); void GetVerticesCoordinatesTop(IssmDouble** pxyz_list); - IssmDouble GroundedArea(void); + IssmDouble GroundedArea(bool scaled); bool HasEdgeOnBase(); bool HasEdgeOnSurface(); - IssmDouble IceVolume(void); - IssmDouble IceVolumeAboveFloatation(void); + IssmDouble IceVolume(bool scaled); + IssmDouble IceVolumeAboveFloatation(bool scaled); void InputDepthAverageAtBase(int enum_type,int average_enum_type); void InputExtrude(int enum_type,int start){_error_("not implemented"); /*For penta only*/}; @@ -125,7 +125,7 @@ int TensorInterpolation(); IssmDouble TimeAdapt(); - IssmDouble TotalFloatingBmb(void); - IssmDouble TotalGroundedBmb(void); - IssmDouble TotalSmb(void); + IssmDouble TotalFloatingBmb(bool scaled); + IssmDouble TotalGroundedBmb(bool scaled); + IssmDouble TotalSmb(bool scaled); void Update(int index, IoModel* iomodel,int analysis_counter,int analysis_type,int finitelement); int UpdatePotentialUngrounding(IssmDouble* vertices_potentially_ungrounding,Vector* vec_nodes_on_iceshelf,IssmDouble* nodes_on_iceshelf); Index: /issm/trunk-jpl/src/c/classes/FemModel.cpp =================================================================== --- /issm/trunk-jpl/src/c/classes/FemModel.cpp (revision 22325) +++ /issm/trunk-jpl/src/c/classes/FemModel.cpp (revision 22326) @@ -1042,5 +1042,5 @@ }/*}}}*/ -void FemModel::FloatingAreax(IssmDouble* pV){/*{{{*/ +void FemModel::FloatingAreax(IssmDouble* pV, bool scaled){/*{{{*/ IssmDouble local_floating_area= 0; @@ -1049,5 +1049,5 @@ for(int i=0;ielements->Size();i++){ Element* element=xDynamicCast(this->elements->GetObjectByOffset(i)); - local_floating_area+=element->FloatingArea(); + local_floating_area+=element->FloatingArea(scaled); } ISSM_MPI_Reduce(&local_floating_area,&total_floating_area,1,ISSM_MPI_DOUBLE,ISSM_MPI_SUM,0,IssmComm::GetComm() ); @@ -1091,5 +1091,5 @@ }/*}}}*/ -void FemModel::GroundedAreax(IssmDouble* pV){/*{{{*/ +void FemModel::GroundedAreax(IssmDouble* pV, bool scaled){/*{{{*/ IssmDouble local_grounded_area= 0; @@ -1098,5 +1098,5 @@ for(int i=0;ielements->Size();i++){ Element* element=xDynamicCast(this->elements->GetObjectByOffset(i)); - local_grounded_area+=element->GroundedArea(); + local_grounded_area+=element->GroundedArea(scaled); } ISSM_MPI_Reduce(&local_grounded_area,&total_grounded_area,1,ISSM_MPI_DOUBLE,ISSM_MPI_SUM,0,IssmComm::GetComm() ); @@ -1107,5 +1107,5 @@ }/*}}}*/ -void FemModel::IceMassx(IssmDouble* pM){/*{{{*/ +void FemModel::IceMassx(IssmDouble* pM, bool scaled){/*{{{*/ IssmDouble local_ice_mass = 0; @@ -1114,5 +1114,5 @@ for(int i=0;ielements->Size();i++){ Element* element=xDynamicCast(this->elements->GetObjectByOffset(i)); - local_ice_mass+=element->IceMass(); + local_ice_mass+=element->IceMass(scaled); } ISSM_MPI_Reduce(&local_ice_mass,&total_ice_mass,1,ISSM_MPI_DOUBLE,ISSM_MPI_SUM,0,IssmComm::GetComm() ); @@ -1123,5 +1123,5 @@ }/*}}}*/ -void FemModel::IceVolumeAboveFloatationx(IssmDouble* pV){/*{{{*/ +void FemModel::IceVolumeAboveFloatationx(IssmDouble* pV, bool scaled){/*{{{*/ IssmDouble local_ice_volume_af = 0; @@ -1130,5 +1130,5 @@ for(int i=0;ielements->Size();i++){ Element* element=xDynamicCast(this->elements->GetObjectByOffset(i)); - local_ice_volume_af+=element->IceVolumeAboveFloatation(); + local_ice_volume_af+=element->IceVolumeAboveFloatation(scaled); } ISSM_MPI_Reduce(&local_ice_volume_af,&total_ice_volume_af,1,ISSM_MPI_DOUBLE,ISSM_MPI_SUM,0,IssmComm::GetComm() ); @@ -1139,5 +1139,5 @@ }/*}}}*/ -void FemModel::IceVolumex(IssmDouble* pV){/*{{{*/ +void FemModel::IceVolumex(IssmDouble* pV, bool scaled){/*{{{*/ IssmDouble local_ice_volume = 0; @@ -1146,5 +1146,5 @@ for(int i=0;ielements->Size();i++){ Element* element=xDynamicCast(this->elements->GetObjectByOffset(i)); - local_ice_volume+=element->IceVolume(); + local_ice_volume+=element->IceVolume(scaled); } ISSM_MPI_Reduce(&local_ice_volume,&total_ice_volume,1,ISSM_MPI_DOUBLE,ISSM_MPI_SUM,0,IssmComm::GetComm() ); @@ -1744,26 +1744,34 @@ /*Scalar output*/ - case DivergenceEnum: this->Divergencex(&double_result); break; - case MaxDivergenceEnum: this->MaxDivergencex(&double_result); break; - case IceMassEnum: this->IceMassx(&double_result); break; - case IceVolumeEnum: this->IceVolumex(&double_result); break; - case IceVolumeAboveFloatationEnum: this->IceVolumeAboveFloatationx(&double_result); break; - case GroundedAreaEnum: this->GroundedAreax(&double_result); break; - case FloatingAreaEnum: this->FloatingAreax(&double_result); break; - case MinVelEnum: this->MinVelx(&double_result); break; - case MaxVelEnum: this->MaxVelx(&double_result); break; - case MinVxEnum: this->MinVxx(&double_result); break; - case MaxVxEnum: this->MaxVxx(&double_result); break; - case MaxAbsVxEnum: this->MaxAbsVxx(&double_result); break; - case MinVyEnum: this->MinVyx(&double_result); break; - case MaxVyEnum: this->MaxVyx(&double_result); break; - case MaxAbsVyEnum: this->MaxAbsVyx(&double_result); break; - case MinVzEnum: this->MinVzx(&double_result); break; - case MaxVzEnum: this->MaxVzx(&double_result); break; - case MaxAbsVzEnum: this->MaxAbsVzx(&double_result); break; - case MassFluxEnum: this->MassFluxx(&double_result); break; - case TotalFloatingBmbEnum: this->TotalFloatingBmbx(&double_result); break; - case TotalGroundedBmbEnum: this->TotalGroundedBmbx(&double_result); break; - case TotalSmbEnum: this->TotalSmbx(&double_result); break; + case DivergenceEnum: this->Divergencex(&double_result); break; + case MaxDivergenceEnum: this->MaxDivergencex(&double_result); break; + case IceMassEnum: this->IceMassx(&double_result,false); break; + case IceMassScaledEnum: this->IceMassx(&double_result,true); break; + case IceVolumeEnum: this->IceVolumex(&double_result,false); break; + case IceVolumeScaledEnum: this->IceVolumex(&double_result,true); break; + case IceVolumeAboveFloatationEnum: this->IceVolumeAboveFloatationx(&double_result,false); break; + case IceVolumeAboveFloatationScaledEnum: this->IceVolumeAboveFloatationx(&double_result,true); break; + case GroundedAreaEnum: this->GroundedAreax(&double_result,false); break; + case GroundedAreaScaledEnum: this->GroundedAreax(&double_result,true); break; + case FloatingAreaEnum: this->FloatingAreax(&double_result,false); break; + case FloatingAreaScaledEnum: this->FloatingAreax(&double_result,true); break; + case MinVelEnum: this->MinVelx(&double_result); break; + case MaxVelEnum: this->MaxVelx(&double_result); break; + case MinVxEnum: this->MinVxx(&double_result); break; + case MaxVxEnum: this->MaxVxx(&double_result); break; + case MaxAbsVxEnum: this->MaxAbsVxx(&double_result); break; + case MinVyEnum: this->MinVyx(&double_result); break; + case MaxVyEnum: this->MaxVyx(&double_result); break; + case MaxAbsVyEnum: this->MaxAbsVyx(&double_result); break; + case MinVzEnum: this->MinVzx(&double_result); break; + case MaxVzEnum: this->MaxVzx(&double_result); break; + case MaxAbsVzEnum: this->MaxAbsVzx(&double_result); break; + case MassFluxEnum: this->MassFluxx(&double_result); break; + case TotalFloatingBmbEnum: this->TotalFloatingBmbx(&double_result,false); break; + case TotalFloatingBmbScaledEnum: this->TotalFloatingBmbx(&double_result,true); break; + case TotalGroundedBmbEnum: this->TotalGroundedBmbx(&double_result,false); break; + case TotalGroundedBmbScaledEnum: this->TotalGroundedBmbx(&double_result,true); break; + case TotalSmbEnum: this->TotalSmbx(&double_result,false); break; + case TotalSmbScaledEnum: this->TotalSmbx(&double_result,true); break; /*Scalar control output*/ @@ -1994,41 +2002,49 @@ switch (response_descriptor_enum){ - case DivergenceEnum: this->Divergencex(responses); break; - case MaxDivergenceEnum: this->MaxDivergencex(responses); break; - case IceMassEnum: this->IceMassx(responses); break; - case IceVolumeEnum: this->IceVolumex(responses); break; - case IceVolumeAboveFloatationEnum: this->IceVolumeAboveFloatationx(responses); break; - case GroundedAreaEnum: this->GroundedAreax(responses); break; - case FloatingAreaEnum: this->FloatingAreax(responses); break; - case MinVelEnum: this->MinVelx(responses); break; - case MaxVelEnum: this->MaxVelx(responses); break; - case MinVxEnum: this->MinVxx(responses); break; - case MaxVxEnum: this->MaxVxx(responses); break; - case MaxAbsVxEnum: this->MaxAbsVxx(responses); break; - case MinVyEnum: this->MinVyx(responses); break; - case MaxVyEnum: this->MaxVyx(responses); break; - case MaxAbsVyEnum: this->MaxAbsVyx(responses); break; - case MinVzEnum: this->MinVzx(responses); break; - case MaxVzEnum: this->MaxVzx(responses); break; - case MaxAbsVzEnum: this->MaxAbsVzx(responses); break; - case MassFluxEnum: this->MassFluxx(responses); break; - case SurfaceAbsVelMisfitEnum: SurfaceAbsVelMisfitx(responses, elements,nodes, vertices, loads, materials,parameters); break; - case SurfaceRelVelMisfitEnum: SurfaceRelVelMisfitx(responses, elements,nodes, vertices, loads, materials,parameters); break; - case SurfaceLogVelMisfitEnum: SurfaceLogVelMisfitx(responses, elements,nodes, vertices, loads, materials,parameters); break; - case SurfaceLogVxVyMisfitEnum: SurfaceLogVxVyMisfitx(responses, elements,nodes, vertices, loads, materials,parameters); break; - case SurfaceAverageVelMisfitEnum: SurfaceAverageVelMisfitx(responses,this); break; - case ThicknessAbsMisfitEnum: ThicknessAbsMisfitx(responses, elements,nodes, vertices, loads, materials, parameters); break; - case ThicknessAbsGradientEnum: this->ThicknessAbsGradientx(responses); break; - case ThicknessAlongGradientEnum: ThicknessAlongGradientx(responses, elements,nodes, vertices, loads, materials, parameters); break; - case ThicknessAcrossGradientEnum: ThicknessAcrossGradientx(responses, elements,nodes, vertices, loads, materials, parameters); break; - case RheologyBbarAbsGradientEnum: RheologyBbarAbsGradientx(responses, elements,nodes, vertices, loads, materials, parameters); break; - case DragCoefficientAbsGradientEnum:DragCoefficientAbsGradientx(responses, elements,nodes, vertices, loads, materials, parameters); break; - case BalancethicknessMisfitEnum: BalancethicknessMisfitx(responses); break; - case TotalFloatingBmbEnum: this->TotalFloatingBmbx(responses); break; - case TotalGroundedBmbEnum: this->TotalGroundedBmbx(responses); break; - case TotalSmbEnum: this->TotalSmbx(responses); break; - case MaterialsRheologyBbarEnum: this->ElementResponsex(responses,MaterialsRheologyBbarEnum); break; - case VelEnum: this->ElementResponsex(responses,VelEnum); break; - case FrictionCoefficientEnum: NodalValuex(responses, FrictionCoefficientEnum,elements,nodes, vertices, loads, materials, parameters); break; + case DivergenceEnum: this->Divergencex(responses); break; + case MaxDivergenceEnum: this->MaxDivergencex(responses); break; + case IceMassEnum: this->IceMassx(responses, false); break; + case IceMassScaledEnum: this->IceMassx(responses, true); break; + case IceVolumeEnum: this->IceVolumex(responses, false); break; + case IceVolumeScaledEnum: this->IceVolumex(responses, true); break; + case IceVolumeAboveFloatationEnum: this->IceVolumeAboveFloatationx(responses, false); break; + case IceVolumeAboveFloatationScaledEnum: this->IceVolumeAboveFloatationx(responses, true); break; + case GroundedAreaEnum: this->GroundedAreax(responses, false); break; + case GroundedAreaScaledEnum: this->GroundedAreax(responses, true); break; + case FloatingAreaEnum: this->FloatingAreax(responses, false); break; + case FloatingAreaScaledEnum: this->FloatingAreax(responses, true); break; + case MinVelEnum: this->MinVelx(responses); break; + case MaxVelEnum: this->MaxVelx(responses); break; + case MinVxEnum: this->MinVxx(responses); break; + case MaxVxEnum: this->MaxVxx(responses); break; + case MaxAbsVxEnum: this->MaxAbsVxx(responses); break; + case MinVyEnum: this->MinVyx(responses); break; + case MaxVyEnum: this->MaxVyx(responses); break; + case MaxAbsVyEnum: this->MaxAbsVyx(responses); break; + case MinVzEnum: this->MinVzx(responses); break; + case MaxVzEnum: this->MaxVzx(responses); break; + case MaxAbsVzEnum: this->MaxAbsVzx(responses); break; + case MassFluxEnum: this->MassFluxx(responses); break; + case SurfaceAbsVelMisfitEnum: SurfaceAbsVelMisfitx(responses, elements,nodes, vertices, loads, materials,parameters); break; + case SurfaceRelVelMisfitEnum: SurfaceRelVelMisfitx(responses, elements,nodes, vertices, loads, materials,parameters); break; + case SurfaceLogVelMisfitEnum: SurfaceLogVelMisfitx(responses, elements,nodes, vertices, loads, materials,parameters); break; + case SurfaceLogVxVyMisfitEnum: SurfaceLogVxVyMisfitx(responses, elements,nodes, vertices, loads, materials,parameters); break; + case SurfaceAverageVelMisfitEnum: SurfaceAverageVelMisfitx(responses,this); break; + case ThicknessAbsMisfitEnum: ThicknessAbsMisfitx(responses, elements,nodes, vertices, loads, materials, parameters); break; + case ThicknessAbsGradientEnum: this->ThicknessAbsGradientx(responses); break; + case ThicknessAlongGradientEnum: ThicknessAlongGradientx(responses, elements,nodes, vertices, loads, materials, parameters); break; + case ThicknessAcrossGradientEnum: ThicknessAcrossGradientx(responses, elements,nodes, vertices, loads, materials, parameters); break; + case RheologyBbarAbsGradientEnum: RheologyBbarAbsGradientx(responses, elements,nodes, vertices, loads, materials, parameters); break; + case DragCoefficientAbsGradientEnum: DragCoefficientAbsGradientx(responses, elements,nodes, vertices, loads, materials, parameters); break; + case BalancethicknessMisfitEnum: BalancethicknessMisfitx(responses); break; + case TotalFloatingBmbEnum: this->TotalFloatingBmbx(responses, false); break; + case TotalFloatingBmbScaledEnum: this->TotalFloatingBmbx(responses, true); break; + case TotalGroundedBmbEnum: this->TotalGroundedBmbx(responses, false); break; + case TotalGroundedBmbScaledEnum: this->TotalGroundedBmbx(responses, true); break; + case TotalSmbEnum: this->TotalSmbx(responses, false); break; + case TotalSmbScaledEnum: this->TotalSmbx(responses, true); break; + case MaterialsRheologyBbarEnum: this->ElementResponsex(responses,MaterialsRheologyBbarEnum); break; + case VelEnum: this->ElementResponsex(responses,VelEnum); break; + case FrictionCoefficientEnum: NodalValuex(responses, FrictionCoefficientEnum,elements,nodes, vertices, loads, materials, parameters); break; default: if(response_descriptor_enum>=Outputdefinition1Enum && response_descriptor_enum <=Outputdefinition100Enum){ @@ -2278,5 +2294,5 @@ } /*}}}*/ -void FemModel::TotalFloatingBmbx(IssmDouble* pFbmb){/*{{{*/ +void FemModel::TotalFloatingBmbx(IssmDouble* pFbmb, bool scaled){/*{{{*/ IssmDouble local_fbmb = 0; @@ -2285,5 +2301,5 @@ for(int i=0;ielements->Size();i++){ Element* element=xDynamicCast(this->elements->GetObjectByOffset(i)); - local_fbmb+=element->TotalFloatingBmb(); + local_fbmb+=element->TotalFloatingBmb(scaled); } ISSM_MPI_Reduce(&local_fbmb,&total_fbmb,1,ISSM_MPI_DOUBLE,ISSM_MPI_SUM,0,IssmComm::GetComm() ); @@ -2294,5 +2310,5 @@ }/*}}}*/ -void FemModel::TotalGroundedBmbx(IssmDouble* pGbmb){/*{{{*/ +void FemModel::TotalGroundedBmbx(IssmDouble* pGbmb, bool scaled){/*{{{*/ IssmDouble local_gbmb = 0; @@ -2301,5 +2317,5 @@ for(int i=0;ielements->Size();i++){ Element* element=xDynamicCast(this->elements->GetObjectByOffset(i)); - local_gbmb+=element->TotalGroundedBmb(); + local_gbmb+=element->TotalGroundedBmb(scaled); } ISSM_MPI_Reduce(&local_gbmb,&total_gbmb,1,ISSM_MPI_DOUBLE,ISSM_MPI_SUM,0,IssmComm::GetComm() ); @@ -2310,5 +2326,5 @@ }/*}}}*/ -void FemModel::TotalSmbx(IssmDouble* pSmb){/*{{{*/ +void FemModel::TotalSmbx(IssmDouble* pSmb, bool scaled){/*{{{*/ IssmDouble local_smb = 0; @@ -2317,5 +2333,5 @@ for(int i=0;ielements->Size();i++){ Element* element=xDynamicCast(this->elements->GetObjectByOffset(i)); - local_smb+=element->TotalSmb(); + local_smb+=element->TotalSmb(scaled); } ISSM_MPI_Reduce(&local_smb,&total_smb,1,ISSM_MPI_DOUBLE,ISSM_MPI_SUM,0,IssmComm::GetComm() ); Index: /issm/trunk-jpl/src/c/classes/FemModel.h =================================================================== --- /issm/trunk-jpl/src/c/classes/FemModel.h (revision 22325) +++ /issm/trunk-jpl/src/c/classes/FemModel.h (revision 22326) @@ -88,10 +88,10 @@ void ElementOperationx(void (Element::*function)(void)); void ElementResponsex(IssmDouble* presponse,int response_enum); - void FloatingAreax(IssmDouble* pV); + void FloatingAreax(IssmDouble* pV, bool scaled); void GetInputLocalMinMaxOnNodesx(IssmDouble** pmin,IssmDouble** pmax,IssmDouble* ug); - void GroundedAreax(IssmDouble* pV); - void IceMassx(IssmDouble* pV); - void IceVolumex(IssmDouble* pV); - void IceVolumeAboveFloatationx(IssmDouble* pV); + void GroundedAreax(IssmDouble* pV, bool scaled); + void IceMassx(IssmDouble* pV, bool scaled); + void IceVolumex(IssmDouble* pV, bool scaled); + void IceVolumeAboveFloatationx(IssmDouble* pV, bool scaled); void MassFluxx(IssmDouble* presponse); void MaxAbsVxx(IssmDouble* presponse); @@ -112,7 +112,7 @@ void StrainRateeffectivex(); void StressIntensityFactorx(); - void TotalFloatingBmbx(IssmDouble* pFbmb); - void TotalGroundedBmbx(IssmDouble* pGbmb); - void TotalSmbx(IssmDouble* pSmb); + void TotalFloatingBmbx(IssmDouble* pFbmb, bool scaled); + void TotalGroundedBmbx(IssmDouble* pGbmb, bool scaled); + void TotalSmbx(IssmDouble* pSmb, bool scaled); #ifdef _HAVE_DAKOTA_ void DakotaResponsesx(double* d_responses,char** responses_descriptors,int numresponsedescriptors,int d_numresponses); Index: /issm/trunk-jpl/src/c/shared/Enum/EnumDefinitions.h =================================================================== --- /issm/trunk-jpl/src/c/shared/Enum/EnumDefinitions.h (revision 22325) +++ /issm/trunk-jpl/src/c/shared/Enum/EnumDefinitions.h (revision 22326) @@ -1077,11 +1077,19 @@ MaxAbsVzEnum, FloatingAreaEnum, + FloatingAreaScaledEnum, GroundedAreaEnum, + GroundedAreaScaledEnum, IceMassEnum, + IceMassScaledEnum, IceVolumeEnum, + IceVolumeScaledEnum, IceVolumeAboveFloatationEnum, + IceVolumeAboveFloatationScaledEnum, TotalFloatingBmbEnum, + TotalFloatingBmbScaledEnum, TotalGroundedBmbEnum, + TotalGroundedBmbScaledEnum, TotalSmbEnum, + TotalSmbScaledEnum, /*}}}*/ /*Element Interpolations{{{*/ Index: /issm/trunk-jpl/src/c/shared/Enum/EnumToStringx.cpp =================================================================== --- /issm/trunk-jpl/src/c/shared/Enum/EnumToStringx.cpp (revision 22325) +++ /issm/trunk-jpl/src/c/shared/Enum/EnumToStringx.cpp (revision 22326) @@ -1034,11 +1034,19 @@ case MaxAbsVzEnum : return "MaxAbsVz"; case FloatingAreaEnum : return "FloatingArea"; + case FloatingAreaScaledEnum : return "FloatingAreaScaled"; case GroundedAreaEnum : return "GroundedArea"; + case GroundedAreaScaledEnum : return "GroundedAreaScaled"; case IceMassEnum : return "IceMass"; + case IceMassScaledEnum : return "IceMassScaled"; case IceVolumeEnum : return "IceVolume"; + case IceVolumeScaledEnum : return "IceVolumeScaled"; case IceVolumeAboveFloatationEnum : return "IceVolumeAboveFloatation"; + case IceVolumeAboveFloatationScaledEnum : return "IceVolumeAboveFloatationScaled"; case TotalFloatingBmbEnum : return "TotalFloatingBmb"; + case TotalFloatingBmbScaledEnum : return "TotalFloatingBmbScaled"; case TotalGroundedBmbEnum : return "TotalGroundedBmb"; + case TotalGroundedBmbScaledEnum : return "TotalGroundedBmbScaled"; case TotalSmbEnum : return "TotalSmb"; + case TotalSmbScaledEnum : return "TotalSmbScaled"; case P0Enum : return "P0"; case P0ArrayEnum : return "P0Array"; Index: /issm/trunk-jpl/src/c/shared/Enum/StringToEnumx.cpp =================================================================== --- /issm/trunk-jpl/src/c/shared/Enum/StringToEnumx.cpp (revision 22325) +++ /issm/trunk-jpl/src/c/shared/Enum/StringToEnumx.cpp (revision 22326) @@ -1058,11 +1058,19 @@ else if (strcmp(name,"MaxAbsVz")==0) return MaxAbsVzEnum; else if (strcmp(name,"FloatingArea")==0) return FloatingAreaEnum; + else if (strcmp(name,"FloatingAreaScaled")==0) return FloatingAreaScaledEnum; else if (strcmp(name,"GroundedArea")==0) return GroundedAreaEnum; + else if (strcmp(name,"GroundedAreaScaled")==0) return GroundedAreaScaledEnum; else if (strcmp(name,"IceMass")==0) return IceMassEnum; + else if (strcmp(name,"IceMassScaled")==0) return IceMassScaledEnum; else if (strcmp(name,"IceVolume")==0) return IceVolumeEnum; + else if (strcmp(name,"IceVolumeScaled")==0) return IceVolumeScaledEnum; else if (strcmp(name,"IceVolumeAboveFloatation")==0) return IceVolumeAboveFloatationEnum; + else if (strcmp(name,"IceVolumeAboveFloatationScaled")==0) return IceVolumeAboveFloatationScaledEnum; else if (strcmp(name,"TotalFloatingBmb")==0) return TotalFloatingBmbEnum; + else if (strcmp(name,"TotalFloatingBmbScaled")==0) return TotalFloatingBmbScaledEnum; else if (strcmp(name,"TotalGroundedBmb")==0) return TotalGroundedBmbEnum; + else if (strcmp(name,"TotalGroundedBmbScaled")==0) return TotalGroundedBmbScaledEnum; else if (strcmp(name,"TotalSmb")==0) return TotalSmbEnum; + else if (strcmp(name,"TotalSmbScaled")==0) return TotalSmbScaledEnum; else if (strcmp(name,"P0")==0) return P0Enum; else if (strcmp(name,"P0Array")==0) return P0ArrayEnum;