source: issm/oecreview/Archive/26740-27031/ISSM-27019-27020.diff@ 27032

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

@@ +1 @@
+%CALVINGTEST class definition
+%  For testing calving laws and coefficients
+%   Usage:
+%      calvingtest=calvingtest();
+
+classdef calvingtest
+        properties (SetAccess=public)
+                speedfactor = 1;
+        end
+        methods
+                function self = calvingtest(varargin) % {{{
+                        switch nargin
+                                case 0
+                                        self=setdefaultparameters(self);
+                                case 1
+                                        inputstruct=varargin{1};
+                                        list1 = properties('calvingtest');
+                                        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) % {{{
+                end % }}}
+                function self = setdefaultparameters(self) % {{{
+                        self.speedfactor = 1;
+                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.speedfactor','NaN',1,'Inf',1, 'singletimeseries', 1);
+                end % }}}
+                function disp(self) % {{{
+                        disp(sprintf('   Calving test parameters:'));
+                        fielddisplay(self,'speedfactor','calving rate is proportional to the ice velocity.');
+                end % }}}
+                function marshall(self,prefix,md,fid) % {{{
+                        yts=md.constants.yts;
+                        WriteData(fid,prefix,'name','md.calving.law','data',8,'format','Integer');
+                        WriteData(fid,prefix,'object',self,'fieldname','speedfactor','format','DoubleMat','mattype',1,'timeserieslength',2,'yts',md.constants.yts);
+                end % }}}
+        end
+end

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

@@ -170 +170 @@
         parameters->AddObject(iomodel->CopyConstantObject("md.levelset.migration_max",MigrationMaxEnum));
 
         int  calvinglaw;
+   IssmDouble *transparam = NULL;
+   IssmDouble  yts;
+   int         N,M;
+   bool        interp,cycle;
+
         iomodel->FindConstant(&calvinglaw,"md.calving.law");
         switch(calvinglaw){
                 case DefaultCalvingEnum:
@@ -191 +196 @@
                         parameters->AddObject(iomodel->CopyConstantObject("md.calving.height_above_floatation",CalvingHeightAboveFloatationEnum));
                         break;
                 case CalvingTestEnum:
-                        parameters->AddObject(iomodel->CopyConstantObject("md.calving.speedfactor",CalvingTestSpeedfactorEnum));
+                        iomodel->FetchData(&transparam,&N,&M,"md.calving.speedfactor");
+                        iomodel->FindConstant(&interp,"md.timestepping.interp_forcing");
+                        iomodel->FindConstant(&cycle,"md.timestepping.cycle_forcing");
+                        if(N==1){
+                                _assert_(M==1);
+                                parameters->AddObject(new DoubleParam(CalvingTestSpeedfactorEnum,transparam[0]));
+         }
+         else{
+            _assert_(N==2);
+            parameters->AddObject(new TransientParam(CalvingTestSpeedfactorEnum,&transparam[0],&transparam[M],interp,cycle,M));
+         }
+                        xDelete<IssmDouble>(transparam);
                         break;
                 case CalvingParameterizationEnum:
                         parameters->AddObject(iomodel->CopyConstantObject("md.calving.min_thickness",CalvingMinthicknessEnum));
@@ -208 +224 @@
         /*Get frontal melt parameters*/
         int melt_parameterization;
         iomodel->FindConstant(&melt_parameterization,"md.frontalforcings.parameterization");
-        int M,N;
-        IssmDouble* transparam = NULL;
         switch(melt_parameterization){
                 case FrontalForcingsDefaultEnum:
                         break;

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

@@ -3556 +3556 @@
                                                                                                           case CalvingParameterizationEnum:
                                                                                                                   this->CalvingRateParameterization();
                                                                                                                   break;
+                                                                                                          case CalvingTestEnum:
+                                                                                                                  this->CalvingRateTest();
+                                                                                                                  break;
                                                                                                           default:
                                                                                                                   _error_("Calving law "<<EnumToStringx(calvinglaw)<<" not supported yet");
                                                                                                   }

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

@@ -372 +372 @@
         IssmDouble  calvingratey[NUMVERTICES];
         IssmDouble  calvingrate[NUMVERTICES];
         IssmDouble  vx,vy;
+        IssmDouble  time;
+        IssmDouble  coeff;
 
         /*Retrieve all inputs and parameters we will need*/
-        IssmDouble coeff = parameters->FindParam(CalvingTestSpeedfactorEnum);
+        parameters->FindParam(&time,TimeEnum);
+        parameters->FindParam(&coeff,CalvingTestSpeedfactorEnum,time);
+
         Input* vx_input = this->GetInput(VxEnum); _assert_(vx_input);
         Input* vy_input = this->GetInput(VyEnum); _assert_(vy_input);