source: issm/oecreview/Archive/21724-22754/ISSM-22191-22192.diff@ 22755

../trunk-jpl/src/c/modules/Calvingx/Calvingx.cpp

@@ -30 +30 @@
                         femmodel->StrainRateperpendicularx();
                         femmodel->CalvingRateLevermannx();
                         break;
-                case CalvingDevEnum:
-                        femmodel->CalvingRateDevx();
-                        femmodel->ElementOperationx(&Element::CalvingRateDev);
+                case CalvingVonmisesEnum:
+                        femmodel->CalvingRateVonmisesx();
+                        femmodel->ElementOperationx(&Element::CalvingRateVonmises);
                         break;
                 default:
                         _error_("Caving law "<<EnumToStringx(calvinglaw)<<" not supported yet");

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

@@ -919 +919 @@
         *presponse=J;
 
 }/*}}}*/
-void FemModel::CalvingRateDevx(){/*{{{*/
+void FemModel::CalvingRateVonmisesx(){/*{{{*/
 
         for(int i=0;i<elements->Size();i++){
                 Element* element=dynamic_cast<Element*>(this->elements->GetObjectByOffset(i));
-                element->CalvingRateDev();
+                element->CalvingRateVonmises();
         }
 }
 /*}}}*/

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

@@ -51 +51 @@
                 /*}}}*/
                 /*Element virtual functions definitions: {{{*/
                 void        AverageOntoPartition(Vector<IssmDouble>* partition_contributions,Vector<IssmDouble>* partition_areas,IssmDouble* vertex_response,IssmDouble* qmu_part);
-                void                    CalvingRateDev();
+                void                    CalvingRateVonmises();
                 void        CalvingCrevasseDepth();
                 void                    CalvingRateLevermann();
                 IssmDouble  CharacteristicLength(void);

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

@@ -181 +181 @@
         _error_("Not supported yet!");
 }
 /*}}}*/
-void       Penta::CalvingRateDev(){/*{{{*/
+void       Penta::CalvingRateVonmises(){/*{{{*/
 
         if(!this->IsOnBase()) return;
 

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

@@ -48 +48 @@
                 void           AddInput(int input_enum, IssmDouble* values, int interpolation_enum);
                 void           AverageOntoPartition(Vector<IssmDouble>* partition_contributions,Vector<IssmDouble>* partition_areas,IssmDouble* vertex_response,IssmDouble* qmu_part);
                 void           BasalNodeIndices(int* pnumindices,int** pindices,int finiteelement);
-                void           CalvingRateDev();
+                void           CalvingRateVonmises();
                 void           CalvingRateLevermann();
                 IssmDouble     CharacteristicLength(void){_error_("not implemented yet");};
                 void           ComputeBasalStress(Vector<IssmDouble>* sigma_b);

../trunk-jpl/src/c/classes/Elements/Element.cpp

@@ -2352 +2352 @@
                                 case CalvingLevermannEnum:
                                         this->CalvingRateLevermann();
                                         break;
-                                case CalvingDevEnum:
-                                        this->CalvingRateDev();
+                                case CalvingVonmisesEnum:
+                                        this->CalvingRateVonmises();
                                         break;
                                 case CalvingCrevasseDepthEnum:
                                         this->CalvingCrevasseDepth();
@@ -2365 +2365 @@
                 case StrainRateparallelEnum: this->StrainRateparallel(); break;
                 case StrainRateperpendicularEnum: this->StrainRateperpendicular(); break;
                 case SurfaceCrevasseEnum: this->CalvingCrevasseDepth(); break;
-                case SigmaVMEnum: this->CalvingRateDev(); break;
+                case SigmaVMEnum: this->CalvingRateVonmises(); break;
         }
 
         /*Find input*/

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

@@ -187 +187 @@
                 virtual void       AddInput(int input_enum, IssmDouble* values, int interpolation_enum)=0;
                 virtual void       AverageOntoPartition(Vector<IssmDouble>* partition_contributions,Vector<IssmDouble>* partition_areas,IssmDouble* vertex_response,IssmDouble* qmu_part)=0;
                 virtual void             BasalNodeIndices(int* pnumindices,int** pindices,int finiteelement){_error_("not implemented yet");};
-                virtual void       CalvingRateDev(void){_error_("not implemented yet");};
+                virtual void       CalvingRateVonmises(void){_error_("not implemented yet");};
                 virtual void       CalvingCrevasseDepth(void){_error_("not implemented yet");};
                 virtual void        CalvingRateLevermann(void)=0;
                 virtual IssmDouble CharacteristicLength(void)=0;

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

@@ -207 +207 @@
         }
 }
 /*}}}*/
-void       Tria::CalvingRateDev(){/*{{{*/
+void       Tria::CalvingRateVonmises(){/*{{{*/
 
         IssmDouble  xyz_list[NUMVERTICES][3];
         IssmDouble  epsilon[3]; /* epsilon=[exx,eyy,exy];*/

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

@@ -81 +81 @@
 
                 /*Modules*/ 
                 void BalancethicknessMisfitx(IssmDouble* pV);
-                void CalvingRateDevx();
+                void CalvingRateVonmisesx();
                 void CalvingRateLevermannx();
                 void DeviatoricStressx();
                 void Divergencex(IssmDouble* pdiv);

../trunk-jpl/src/c/analyses/LevelsetAnalysis.cpp

@@ -59 +59 @@
                         iomodel->FetchDataToInput(elements,"md.calving.coeff",CalvinglevermannCoeffEnum);
                         iomodel->FetchDataToInput(elements,"md.calving.meltingrate",CalvinglevermannMeltingrateEnum);
                         break;
-                case CalvingDevEnum:
+                case CalvingVonmisesEnum:
                         iomodel->FetchDataToInput(elements,"md.calving.stress_threshold_groundedice",CalvingStressThresholdGroundediceEnum);
                         iomodel->FetchDataToInput(elements,"md.calving.stress_threshold_floatingice",CalvingStressThresholdFloatingiceEnum);
                         iomodel->FetchDataToInput(elements,"md.calving.meltingrate",CalvingMeltingrateEnum);
@@ -88 +88 @@
         switch(calvinglaw){
                 case DefaultCalvingEnum:
                 case CalvingLevermannEnum:
-                case CalvingDevEnum:
+                case CalvingVonmisesEnum:
                         break;
                 case CalvingMinthicknessEnum:
                         parameters->AddObject(iomodel->CopyConstantObject("md.calving.min_thickness",CalvingMinthicknessEnum));
@@ -219 +219 @@
         /*Load calving inputs*/
         switch(calvinglaw){
                 case DefaultCalvingEnum:
-                case CalvingDevEnum:
+                case CalvingVonmisesEnum:
                         lsf_slopex_input  = basalelement->GetInput(LevelsetfunctionSlopeXEnum); _assert_(lsf_slopex_input);
                         if(dim==2) lsf_slopey_input  = basalelement->GetInput(LevelsetfunctionSlopeYEnum); _assert_(lsf_slopey_input);
                         calvingrate_input = basalelement->GetInput(CalvingCalvingrateEnum);     _assert_(calvingrate_input);
@@ -290 +290 @@
                 /*Get calving speed*/
                 switch(calvinglaw){
                         case DefaultCalvingEnum:
-                        case CalvingDevEnum:
+                        case CalvingVonmisesEnum:
                                 lsf_slopex_input->GetInputValue(&dlsf[0],gauss);
                                 if(dim==2) lsf_slopey_input->GetInputValue(&dlsf[1],gauss);
                                 calvingrate_input->GetInputValue(&calvingrate,gauss);

../trunk-jpl/src/m/classes/calvingdev.m

@@ -1 @@
-%CALVINGDEV class definition
-%
-%   Usage:
-%      calvingdev=calvingdev();
-
-classdef calvingdev
-        properties (SetAccess=public) 
-                stress_threshold_groundedice = 0.;
-                stress_threshold_floatingice = 0.;
-                meltingrate   = NaN;
-        end
-        methods
-                function self = calvingdev(varargin) % {{{
-                        switch nargin
-                                case 0
-                                        self=setdefaultparameters(self);
-                                case 1
-                                        inputstruct=varargin{1};
-                                        list1 = properties('calvingdev');
-                                        list2 = fieldnames(inputstruct);
-                                        for i=1:length(list1)
-                                                fieldname = list1{i};
-                                                if ismember(fieldname,list2),
-                                                        self.(fieldname) = inputstruct.(fieldname);
-                                                end
-                                        end
-                                otherwise
-                                        error('constructor not supported');
-                        end
-                end % }}}
-                function self = extrude(self,md) % {{{
-                        self.meltingrate=project3d(md,'vector',self.meltingrate,'type','node');
-                end % }}}
-                function self = setdefaultparameters(self) % {{{
-
-                        %Default sigma max
-                        self.stress_threshold_groundedice = 1e6;
-                        self.stress_threshold_floatingice = 150e3;
-                end % }}}
-                function md = checkconsistency(self,md,solution,analyses) % {{{
-                        %Early return
-                        if (~strcmp(solution,'TransientSolution') | md.transient.ismovingfront==0), return; end
-
-                        md = checkfield(md,'fieldname','calving.stress_threshold_groundedice','>',0,'nan',1,'Inf',1);
-                        md = checkfield(md,'fieldname','calving.stress_threshold_floatingice','>',0,'nan',1,'Inf',1);
-                        md = checkfield(md,'fieldname','calving.meltingrate','NaN',1,'Inf',1,'timeseries',1,'>=',0);
-                end % }}}
-                function disp(self) % {{{
-                        disp(sprintf('   Calving Pi parameters:'));
-                        fielddisplay(self,'stress_threshold_groundedice','sigma_max applied to grounded ice only [Pa]');
-                        fielddisplay(self,'stress_threshold_floatingice','sigma_max applied to floating ice only [Pa]');
-                        fielddisplay(self,'meltingrate','melting rate at given location [m/a]');
-
-                end % }}}
-                function marshall(self,prefix,md,fid) % {{{
-                        yts=md.constants.yts;
-                        WriteData(fid,prefix,'name','md.calving.law','data',2,'format','Integer');
-                        WriteData(fid,prefix,'object',self,'fieldname','stress_threshold_groundedice','format','DoubleMat','mattype',1);
-                        WriteData(fid,prefix,'object',self,'fieldname','stress_threshold_floatingice','format','DoubleMat','mattype',1);
-                        WriteData(fid,prefix,'object',self,'fieldname','meltingrate','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1,'yts',md.constants.yts,'scale',1./yts);
-                end % }}}
-        end
-end

../trunk-jpl/src/m/classes/calvingvonmises.m

@@ +1 @@
+%CALVINGVONMISES class definition
+%
+%   Usage:
+%      calvingvonmises=calvingvonmises();
+
+classdef calvingvonmises
+        properties (SetAccess=public) 
+                stress_threshold_groundedice = 0.;
+                stress_threshold_floatingice = 0.;
+                meltingrate   = NaN;
+        end
+        methods
+                function self = calvingvonmises(varargin) % {{{
+                        switch nargin
+                                case 0
+                                        self=setdefaultparameters(self);
+                                case 1
+                                        inputstruct=varargin{1};
+                                        list1 = properties('calvingvonmises');
+                                        list2 = fieldnames(inputstruct);
+                                        for i=1:length(list1)
+                                                fieldname = list1{i};
+                                                if ismember(fieldname,list2),
+                                                        self.(fieldname) = inputstruct.(fieldname);
+                                                end
+                                        end
+                                otherwise
+                                        error('constructor not supported');
+                        end
+                end % }}}
+                function self = extrude(self,md) % {{{
+                        self.meltingrate=project3d(md,'vector',self.meltingrate,'type','node');
+                end % }}}
+                function self = setdefaultparameters(self) % {{{
+
+                        %Default sigma max
+                        self.stress_threshold_groundedice = 1e6;
+                        self.stress_threshold_floatingice = 150e3;
+                end % }}}
+                function md = checkconsistency(self,md,solution,analyses) % {{{
+                        %Early return
+                        if (~strcmp(solution,'TransientSolution') | md.transient.ismovingfront==0), return; end
+
+                        md = checkfield(md,'fieldname','calving.stress_threshold_groundedice','>',0,'nan',1,'Inf',1);
+                        md = checkfield(md,'fieldname','calving.stress_threshold_floatingice','>',0,'nan',1,'Inf',1);
+                        md = checkfield(md,'fieldname','calving.meltingrate','NaN',1,'Inf',1,'timeseries',1,'>=',0);
+                end % }}}
+                function disp(self) % {{{
+                        disp(sprintf('   Calving VonMises parameters:'));
+                        fielddisplay(self,'stress_threshold_groundedice','sigma_max applied to grounded ice only [Pa]');
+                        fielddisplay(self,'stress_threshold_floatingice','sigma_max applied to floating ice only [Pa]');
+                        fielddisplay(self,'meltingrate','melting rate at given location [m/a]');
+
+                end % }}}
+                function marshall(self,prefix,md,fid) % {{{
+                        yts=md.constants.yts;
+                        WriteData(fid,prefix,'name','md.calving.law','data',2,'format','Integer');
+                        WriteData(fid,prefix,'object',self,'fieldname','stress_threshold_groundedice','format','DoubleMat','mattype',1);
+                        WriteData(fid,prefix,'object',self,'fieldname','stress_threshold_floatingice','format','DoubleMat','mattype',1);
+                        WriteData(fid,prefix,'object',self,'fieldname','meltingrate','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1,'yts',md.constants.yts,'scale',1./yts);
+                end % }}}
+        end
+end

../trunk-jpl/test/NightlyRun/test540.m

@@ -8 +8 @@
 
 %calving parameters
 md.mask.ice_levelset = 1e4*(md.mask.ice_levelset + 0.5);
-md.calving=calvingdev();
+md.calving=calvingvonmises();
 md.calving.meltingrate = zeros(md.mesh.numberofvertices,1);
 md.transient.ismovingfront = 1;
 md.levelset.spclevelset = NaN(md.mesh.numberofvertices,1);