Changeset 27250

Timestamp:

08/31/22 05:54:38 (3 years ago)

Author:

vverjans

Message:

CHG Changing autoregression schemes towards ARMA schemes: work is ongoing

Location:

issm/trunk-jpl

Files:

• src/c/analyses/LevelsetAnalysis.cpp (modified) (2 diffs)
• src/c/analyses/MasstransportAnalysis.cpp (modified) (1 diff)
• src/c/analyses/SmbAnalysis.cpp (modified) (3 diffs)
• src/c/classes/Elements/Element.cpp (modified) (4 diffs)
• src/c/classes/Elements/Element.h (modified) (1 diff)
• src/c/modules/FloatingiceMeltingRatex/FloatingiceMeltingRatex.cpp (modified) (7 diffs)
• src/c/modules/FloatingiceMeltingRatex/FloatingiceMeltingRatex.h (modified) (1 diff)
• src/c/modules/FrontalForcingsx/FrontalForcingsx.cpp (modified) (5 diffs)
• src/c/modules/FrontalForcingsx/FrontalForcingsx.h (modified) (1 diff)
• src/c/modules/ModelProcessorx/CreateParameters.cpp (modified) (2 diffs)
• src/c/modules/StochasticForcingx/StochasticForcingx.cpp (modified) (2 diffs)
• src/c/modules/SurfaceMassBalancex/SurfaceMassBalancex.cpp (modified) (4 diffs)
• src/c/modules/SurfaceMassBalancex/SurfaceMassBalancex.h (modified) (1 diff)
• src/c/shared/Enum/Enum.vim (modified) (22 diffs)
• src/c/shared/Enum/EnumDefinitions.h (modified) (13 diffs)
• src/c/shared/Enum/EnumToStringx.cpp (modified) (13 diffs)
• src/c/shared/Enum/Enumjl.vim (modified) (14 diffs)
• src/c/shared/Enum/StringToEnumx.cpp (modified) (33 diffs)
• src/c/shared/io/Marshalling/IoCodeConversions.cpp (modified) (3 diffs)
• src/m/classes/SMBarma.m (added)
• src/m/classes/SMBarma.py (added)
• src/m/classes/frontalforcingsrignotarma.m (added)
• src/m/classes/frontalforcingsrignotarma.py (added)
• src/m/classes/linearbasalforcingsarma.m (added)
• src/m/classes/linearbasalforcingsarma.py (added)
• test/NightlyRun/test257.m (modified) (2 diffs)
• test/NightlyRun/test257.py (modified) (4 diffs)
• test/NightlyRun/test543.m (modified) (3 diffs)
• test/NightlyRun/test543.py (modified) (4 diffs)
• test/NightlyRun/test544.m (modified) (4 diffs)
• test/NightlyRun/test544.py (modified) (4 diffs)

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

@@ -149 +149 @@
                         break;
                 case FrontalForcingsRignotEnum:
-         /*Retrieve thermal forcing only in the case of non-autoregressive FrontalForcingsRignot*/
+         /*Retrieve thermal forcing only in the case of non-arma FrontalForcingsRignot*/
          iomodel->FetchDataToInput(inputs,elements,"md.frontalforcings.thermalforcing",FrontalForcingsThermalForcingEnum);
          /* Do not break here, still retrieve basin_ID,subglacial_discharge, etc.*/
-      case FrontalForcingsRignotAutoregressionEnum:
+      case FrontalForcingsRignotarmaEnum:
          iomodel->FetchDataToInput(inputs,elements,"md.frontalforcings.basin_id",FrontalForcingsBasinIdEnum);
          iomodel->FetchDataToInput(inputs,elements,"md.frontalforcings.subglacial_discharge",FrontalForcingsSubglacialDischargeEnum);
@@ -238 +238 @@
                 case FrontalForcingsDefaultEnum:
                         break;
-                case FrontalForcingsRignotAutoregressionEnum:
+                case FrontalForcingsRignotarmaEnum:
                         /*Retrieve autoregressive parameters*/
-         parameters->AddObject(iomodel->CopyConstantObject("md.frontalforcings.ar_order",FrontalForcingsAutoregressiveOrderEnum));
-         parameters->AddObject(iomodel->CopyConstantObject("md.frontalforcings.ar_initialtime",FrontalForcingsAutoregressionInitialTimeEnum));
-         parameters->AddObject(iomodel->CopyConstantObject("md.frontalforcings.ar_timestep",FrontalForcingsAutoregressionTimestepEnum));
+         parameters->AddObject(iomodel->CopyConstantObject("md.frontalforcings.ar_order",FrontalForcingsARMAarOrderEnum));
+         parameters->AddObject(iomodel->CopyConstantObject("md.frontalforcings.arma_initialtime",FrontalForcingsARMAInitialTimeEnum));
+         parameters->AddObject(iomodel->CopyConstantObject("md.frontalforcings.arma_timestep",FrontalForcingsARMATimestepEnum));
                         iomodel->FetchData(&transparam,&M,&N,"md.frontalforcings.const");
-         parameters->AddObject(new DoubleVecParam(FrontalForcingsautoregressionconstEnum,transparam,N));
+         parameters->AddObject(new DoubleVecParam(FrontalForcingsARMAconstEnum,transparam,N));
          xDelete<IssmDouble>(transparam);
          iomodel->FetchData(&transparam,&M,&N,"md.frontalforcings.trend");
-         parameters->AddObject(new DoubleVecParam(FrontalForcingsautoregressiontrendEnum,transparam,N));
+         parameters->AddObject(new DoubleVecParam(FrontalForcingsARMAtrendEnum,transparam,N));
          xDelete<IssmDouble>(transparam);
          iomodel->FetchData(&transparam,&M,&N,"md.frontalforcings.arlag_coefs");
-         parameters->AddObject(new DoubleMatParam(FrontalForcingsarlagcoefsEnum,transparam,M,N));
+         parameters->AddObject(new DoubleMatParam(FrontalForcingsARMAarlagcoefsEnum,transparam,M,N));
+         xDelete<IssmDouble>(transparam);
+         iomodel->FetchData(&transparam,&M,&N,"md.frontalforcings.malag_coefs");
+         parameters->AddObject(new DoubleMatParam(FrontalForcingsARMAmalagcoefsEnum,transparam,M,N));
          xDelete<IssmDouble>(transparam);
                         /*Do not break here, generic FrontalForcingsRignot parameters still to be retrieved*/

issm/trunk-jpl/src/c/analyses/MasstransportAnalysis.cpp

@@ -219 +219 @@
                         iomodel->FetchDataToInput(inputs,elements,"md.basalforcings.ocean_temp",BasalforcingsOceanTempEnum);
                         break;
-                case AutoregressionLinearFloatingMeltRateEnum:
+                case LinearFloatingMeltRatearmaEnum:
                         iomodel->FetchDataToInput(inputs,elements,"md.basalforcings.basin_id",BasalforcingsLinearBasinIdEnum);
                         if(isstochastic) iomodel->FetchDataToInput(inputs,elements,"md.stochasticforcing.default_id",StochasticForcingDefaultIdEnum);

issm/trunk-jpl/src/c/analyses/SmbAnalysis.cpp

@@ -185 +185 @@
                         iomodel->FetchDataToInput(inputs,elements,"md.smb.b_min",SmbBMinEnum);
                         break;
-                case SMBautoregressionEnum:
+                case SMBarmaEnum:
          iomodel->FetchDataToInput(inputs,elements,"md.smb.basin_id",SmbBasinsIdEnum);
          break;
@@ -388 +388 @@
                         /*Nothing to add to parameters*/
                         break;
-                case SMBautoregressionEnum:
+                case SMBarmaEnum:
          /*Nothing to add to parameters*/
          break;
@@ -483 +483 @@
                         SmbGradientsElax(femmodel);
                         break;
-                case SMBautoregressionEnum:
-         if(VerboseSolution())_printf0_("    call smb autoregression module\n");
-         Smbautoregressionx(femmodel);
+                case SMBarmaEnum:
+         if(VerboseSolution())_printf0_("    call smb arma module\n");
+         Smbarmax(femmodel);
          break;
                 case SMBhenningEnum:

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

@@ -61 +61 @@
         return false;
 }/*}}}*/
+void       Element::ArmaProcess(bool isstepforarma,int arorder,IssmDouble telapsed_arma,IssmDouble tstep_arma,IssmDouble* termconstant,IssmDouble* trend,IssmDouble* arlagcoefs,bool isfieldstochastic,int enum_type){/*{{{*/
+}/*}}}*/
 void       Element::Autoregression(bool isstepforar,int arorder,IssmDouble telapsed_ar,IssmDouble tstep_ar,IssmDouble* termconstant,IssmDouble* trend,IssmDouble* lagcoefs,bool isfieldstochastic,int enum_type){/*{{{*/
 
@@ -73 +75 @@
    /*Get field-specific enums*/
    switch(enum_type){
-      case(SMBautoregressionEnum):
+      case(SMBarmaEnum):
          arenum_type    = SmbValuesAutoregressionEnum;
          basinenum_type = SmbBasinsIdEnum;
-         noiseenum_type = SmbAutoregressionNoiseEnum;
+         noiseenum_type = SmbARMANoiseEnum;
          outenum_type   = SmbMassBalanceEnum;
          break;
-      case(FrontalForcingsRignotAutoregressionEnum):
+      case(FrontalForcingsRignotarmaEnum):
          arenum_type    = ThermalforcingValuesAutoregressionEnum;
          basinenum_type = FrontalForcingsBasinIdEnum;
-         noiseenum_type = ThermalforcingAutoregressionNoiseEnum;
+         noiseenum_type = ThermalforcingARMANoiseEnum;
          outenum_type   = FrontalForcingsThermalForcingEnum;
          break;
-                case(BasalforcingsDeepwaterMeltingRateAutoregressionEnum):
+                case(BasalforcingsDeepwaterMeltingRatearmaEnum):
          arenum_type    = BasalforcingsDeepwaterMeltingRateValuesAutoregressionEnum;
          basinenum_type = BasalforcingsLinearBasinIdEnum;
@@ -100 +102 @@
    /*Get basin coefficients*/
    this->GetInputValue(&basinid,basinenum_type);
-   for(int ii=0;ii<arorder;ii++) lagcoefs_basin[ii] = lagcoefs[basinid*arorder+ii];
+        for(int ii=0;ii<arorder;ii++) lagcoefs_basin[ii] = lagcoefs[basinid*arorder+ii];
    termconstant_basin   = termconstant[basinid];
    trend_basin   = trend[basinid];
@@ -113 +115 @@
 
    /*Get noise and autoregressive terms*/
-   if(isfieldstochastic){
+        if(isfieldstochastic){
       noiseterm_input = this->GetInput(noiseenum_type);
       Gauss* gauss = this->NewGauss();

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

@@ -68 +68 @@
                 /*bool               AnyActive(void);*/
                 bool               AnyFSet(void);
+      void               ArmaProcess(bool isstepforarma,int arorder,IssmDouble telapsed_arma,IssmDouble tstep_arma,IssmDouble* termconstant,IssmDouble* trend,IssmDouble* arlagcoefs,bool isfieldstochastic,int enum_type);
       void               Autoregression(bool isstepforar,int arorder,IssmDouble telapsed_ar,IssmDouble tstep_ar,IssmDouble* termconstant,IssmDouble* trend,IssmDouble* lagcoefs,bool isfieldstochastic,int enum_type);
                 void               BasinLinearFloatingiceMeltingRate(IssmDouble* deepwaterel,IssmDouble* upperwatermelt,IssmDouble* upperwaterel,IssmDouble* perturbation);

issm/trunk-jpl/src/c/modules/FloatingiceMeltingRatex/FloatingiceMeltingRatex.cpp

@@ -46 +46 @@
                         BeckmannGoosseFloatingiceMeltingRatex(femmodel);
                         break;
-                case AutoregressionLinearFloatingMeltRateEnum:
-                        if(VerboseSolution())_printf0_("        call Autoregression Linear Floating melting rate module\n");
-                        AutoregressionLinearFloatingiceMeltingRatex(femmodel);
+                case LinearFloatingMeltRatearmaEnum:
+                        if(VerboseSolution())_printf0_("        call Linear Floating melting rate ARMA module\n");
+                        LinearFloatingiceMeltingRatearmax(femmodel);
                         break;
                 default:
@@ -210 +210 @@
 }
 /*}}}*/
-void AutoregressionLinearFloatingiceMeltingRatex(FemModel* femmodel){/*{{{*/
+void LinearFloatingiceMeltingRatearmax(FemModel* femmodel){/*{{{*/
 
         /*Get time parameters*/
-   IssmDouble time,dt,starttime,tstep_ar;
+   IssmDouble time,dt,starttime,tstep_arma;
    femmodel->parameters->FindParam(&time,TimeEnum);
    femmodel->parameters->FindParam(&dt,TimesteppingTimeStepEnum);
    femmodel->parameters->FindParam(&starttime,TimesteppingStartTimeEnum);
-   femmodel->parameters->FindParam(&tstep_ar,BasalforcingsAutoregressionTimestepEnum);
-
-   /*Determine if this is a time step for the AR model*/
-   bool isstepforar = false;
+   femmodel->parameters->FindParam(&tstep_arma,BasalforcingsARMATimestepEnum);
+
+   /*Determine if this is a time step for the ARMA model*/
+   bool isstepforarma = false;
 
    #ifndef _HAVE_AD_
-   if((fmod(time,tstep_ar)<fmod((time-dt),tstep_ar)) || (time<=starttime+dt) || tstep_ar==dt) isstepforar = true;
+   if((fmod(time,tstep_arma)<fmod((time-dt),tstep_arma)) || (time<=starttime+dt) || tstep_arma==dt) isstepforarma = true;
    #else
    _error_("not implemented yet");
@@ -231 +231 @@
    bool isstochastic;
    bool isdeepmeltingstochastic = false;
-   int M,N,Nlags,arorder,numbasins,my_rank;
+   int M,N,Narlags,arorder,numbasins,my_rank;
    femmodel->parameters->FindParam(&numbasins,BasalforcingsLinearNumBasinsEnum);
-        femmodel->parameters->FindParam(&arorder,BasalforcingsAutoregressiveOrderEnum);
-   IssmDouble tinit_ar;
+        femmodel->parameters->FindParam(&arorder,BasalforcingsARMAarOrderEnum);
+   IssmDouble tinit_arma;
    IssmDouble* termconstant   = NULL;
    IssmDouble* trend          = NULL;
-   IssmDouble* lagcoefs       = NULL;
+   IssmDouble* arlagcoefs     = NULL;
    IssmDouble* deepwaterel    = NULL;
    IssmDouble* upperwaterel   = NULL;
@@ -244 +244 @@
 
         /*Get autoregressive parameters*/
-   femmodel->parameters->FindParam(&tinit_ar,BasalforcingsAutoregressionInitialTimeEnum);
-   femmodel->parameters->FindParam(&termconstant,&M,BasalforcingsautoregressionconstEnum);               _assert_(M==numbasins);
-   femmodel->parameters->FindParam(&trend,&M,BasalforcingsautoregressiontrendEnum);               _assert_(M==numbasins);
-   femmodel->parameters->FindParam(&lagcoefs,&M,&Nlags,BasalforcingsarlagcoefsEnum);             _assert_(M==numbasins); _assert_(Nlags==arorder);
+   femmodel->parameters->FindParam(&tinit_arma,BasalforcingsARMAInitialTimeEnum);
+   femmodel->parameters->FindParam(&termconstant,&M,BasalforcingsARMAconstEnum);              _assert_(M==numbasins);
+   femmodel->parameters->FindParam(&trend,&M,BasalforcingsARMAtrendEnum);                     _assert_(M==numbasins);
+   femmodel->parameters->FindParam(&arlagcoefs,&M,&Narlags,BasalforcingsARMAarlagcoefsEnum);  _assert_(M==numbasins); _assert_(Narlags==arorder);
 
         /*Get basin-specific parameters*/
@@ -262 +262 @@
       femmodel->parameters->FindParam(&stochasticfields,&N,StochasticForcingFieldsEnum); _assert_(N==numstochasticfields);
       for(int i=0;i<numstochasticfields;i++){
-         if(stochasticfields[i]==BasalforcingsDeepwaterMeltingRateAutoregressionEnum) isdeepmeltingstochastic = true;
+         if(stochasticfields[i]==BasalforcingsDeepwaterMeltingRatearmaEnum) isdeepmeltingstochastic = true;
       }
       xDelete<int>(stochasticfields);
    }
-   /*Time elapsed with respect to AR model initial time*/
-   IssmDouble telapsed_ar = time-tinit_ar;
+   /*Time elapsed with respect to ARMA model initial time*/
+   IssmDouble telapsed_arma = time-tinit_arma;
 
         /*Loop over each element to compute FloatingiceMeltingRate at vertices*/
@@ -273 +273 @@
       Element* element = xDynamicCast<Element*>(object);
       /*Compute autoregression*/
-      element->Autoregression(isstepforar,arorder,telapsed_ar,tstep_ar,termconstant,trend,lagcoefs,isdeepmeltingstochastic,BasalforcingsDeepwaterMeltingRateAutoregressionEnum);
+      element->Autoregression(isstepforarma,arorder,telapsed_arma,tstep_arma,termconstant,trend,arlagcoefs,isdeepmeltingstochastic,BasalforcingsDeepwaterMeltingRatearmaEnum);
                 element->BasinLinearFloatingiceMeltingRate(deepwaterel,upperwatermelt,upperwaterel,perturbation);
         }
@@ -280 +280 @@
         xDelete<IssmDouble>(termconstant);
         xDelete<IssmDouble>(trend);
-        xDelete<IssmDouble>(lagcoefs);
+        xDelete<IssmDouble>(arlagcoefs);
         xDelete<IssmDouble>(deepwaterel);
         xDelete<IssmDouble>(upperwaterel);

issm/trunk-jpl/src/c/modules/FloatingiceMeltingRatex/FloatingiceMeltingRatex.h

@@ -16 +16 @@
 void FloatingiceMeltingRateIsmip6x(FemModel* femmodel);
 void BeckmannGoosseFloatingiceMeltingRatex(FemModel* femmodel);
-void AutoregressionLinearFloatingiceMeltingRatex(FemModel* femmodel);
+void LinearFloatingiceMeltingRatearmax(FemModel* femmodel);
 
 #endif  /* _FloatingiceMeltingRatex_H*/

issm/trunk-jpl/src/c/modules/FrontalForcingsx/FrontalForcingsx.cpp

@@ -18 +18 @@
                 case FrontalForcingsDefaultEnum:
                         break;
-                case FrontalForcingsRignotAutoregressionEnum:
-                        Thermalforcingautoregressionx(femmodel);
+                case FrontalForcingsRignotarmaEnum:
+                        Thermalforcingarmax(femmodel);
                         /*Do not break here, call IcefrontAreax(),RignotMeltParameterizationx()*/
                 case FrontalForcingsRignotEnum:
@@ -29 +29 @@
         }
 }/*}}}*/
-void Thermalforcingautoregressionx(FemModel* femmodel){/*{{{*/
+void Thermalforcingarmax(FemModel* femmodel){/*{{{*/
 
    /*Get time parameters*/
-   IssmDouble time,dt,starttime,tstep_ar;
+   IssmDouble time,dt,starttime,tstep_arma;
    femmodel->parameters->FindParam(&time,TimeEnum);
    femmodel->parameters->FindParam(&dt,TimesteppingTimeStepEnum);
    femmodel->parameters->FindParam(&starttime,TimesteppingStartTimeEnum);
-   femmodel->parameters->FindParam(&tstep_ar,FrontalForcingsAutoregressionTimestepEnum);
+   femmodel->parameters->FindParam(&tstep_arma,FrontalForcingsARMATimestepEnum);
 
-   /*Determine if this is a time step for the AR model*/
-   bool isstepforar = false;
+   /*Determine if this is a time step for the ARMA model*/
+   bool isstepforarma = false;
 
    #ifndef _HAVE_AD_
-   if((fmod(time,tstep_ar)<fmod((time-dt),tstep_ar)) || (time<=starttime+dt) || tstep_ar==dt) isstepforar = true;
+   if((fmod(time,tstep_arma)<fmod((time-dt),tstep_arma)) || (time<=starttime+dt) || tstep_arma==dt) isstepforarma = true;
    #else
    _error_("not implemented yet");
@@ -50 +50 @@
         bool isstochastic;
    bool istfstochastic = false;
-        int M,N,Nlagcoefs,arorder,numbasins,my_rank;
+        int M,N,Narlagcoefs,arorder,numbasins,my_rank;
    femmodel->parameters->FindParam(&numbasins,FrontalForcingsNumberofBasinsEnum);
-   femmodel->parameters->FindParam(&arorder,FrontalForcingsAutoregressiveOrderEnum);
-   IssmDouble tinit_ar;
+   femmodel->parameters->FindParam(&arorder,FrontalForcingsARMAarOrderEnum);
+   IssmDouble tinit_arma;
    IssmDouble* termconstant  = NULL;
    IssmDouble* trend         = NULL;
-   IssmDouble* lagcoefs      = NULL;
+   IssmDouble* arlagcoefs    = NULL;
 
-        femmodel->parameters->FindParam(&tinit_ar,FrontalForcingsAutoregressionInitialTimeEnum);
-   femmodel->parameters->FindParam(&termconstant,&M,FrontalForcingsautoregressionconstEnum);    _assert_(M==numbasins);
-   femmodel->parameters->FindParam(&trend,&M,FrontalForcingsautoregressiontrendEnum);    _assert_(M==numbasins);
-   femmodel->parameters->FindParam(&lagcoefs,&M,&Nlagcoefs,FrontalForcingsarlagcoefsEnum);  _assert_(M==numbasins); _assert_(Nlagcoefs==arorder);
+        femmodel->parameters->FindParam(&tinit_arma,FrontalForcingsARMAInitialTimeEnum);
+   femmodel->parameters->FindParam(&termconstant,&M,FrontalForcingsARMAconstEnum);                  _assert_(M==numbasins);
+   femmodel->parameters->FindParam(&trend,&M,FrontalForcingsARMAtrendEnum);                         _assert_(M==numbasins);
+   femmodel->parameters->FindParam(&arlagcoefs,&M,&Narlagcoefs,FrontalForcingsARMAarlagcoefsEnum);  _assert_(M==numbasins); _assert_(Narlagcoefs==arorder);
 
         femmodel->parameters->FindParam(&isstochastic,StochasticForcingIsStochasticForcingEnum);
@@ -70 +70 @@
                 femmodel->parameters->FindParam(&stochasticfields,&N,StochasticForcingFieldsEnum); _assert_(N==numstochasticfields);
                 for(int i=0;i<numstochasticfields;i++){
-                        if(stochasticfields[i]==FrontalForcingsRignotAutoregressionEnum) istfstochastic = true;
+                        if(stochasticfields[i]==FrontalForcingsRignotarmaEnum) istfstochastic = true;
                 }
                 xDelete<int>(stochasticfields);
         }
-   /*Time elapsed with respect to AR model initial time*/
-   IssmDouble telapsed_ar = time-tinit_ar;
+   /*Time elapsed with respect to ARMA model initial time*/
+   IssmDouble telapsed_arma = time-tinit_arma;
 
    /*Loop over each element to compute Thermal Forcing at vertices*/
    for(Object* &object:femmodel->elements->objects){
       Element* element = xDynamicCast<Element*>(object);
-      element->Autoregression(isstepforar,arorder,telapsed_ar,tstep_ar,termconstant,trend,lagcoefs,istfstochastic,FrontalForcingsRignotAutoregressionEnum);
+      element->Autoregression(isstepforarma,arorder,telapsed_arma,tstep_arma,termconstant,trend,arlagcoefs,istfstochastic,FrontalForcingsRignotarmaEnum);
    }
 
@@ -86 +86 @@
    xDelete<IssmDouble>(termconstant);
    xDelete<IssmDouble>(trend);
-   xDelete<IssmDouble>(lagcoefs);
+   xDelete<IssmDouble>(arlagcoefs);
 }/*}}}*/

issm/trunk-jpl/src/c/modules/FrontalForcingsx/FrontalForcingsx.h

@@ -7 +7 @@
 /* local prototypes: */
 void FrontalForcingsx(FemModel* femmodel);
-void Thermalforcingautoregressionx(FemModel* femmodel);
+void Thermalforcingarmax(FemModel* femmodel);
 
 #endif

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

@@ -254 +254 @@
                 case BeckmannGoosseFloatingMeltRateEnum:
                         break;
-                case AutoregressionLinearFloatingMeltRateEnum:
+                case LinearFloatingMeltRatearmaEnum:
                         /*Add parameters that are not in standard nbvertices format*/
          parameters->AddObject(iomodel->CopyConstantObject("md.basalforcings.num_basins",BasalforcingsLinearNumBasinsEnum));
-         parameters->AddObject(iomodel->CopyConstantObject("md.basalforcings.ar_order",BasalforcingsAutoregressiveOrderEnum));
-         parameters->AddObject(iomodel->CopyConstantObject("md.basalforcings.ar_initialtime",BasalforcingsAutoregressionInitialTimeEnum));
-         parameters->AddObject(iomodel->CopyConstantObject("md.basalforcings.ar_timestep",BasalforcingsAutoregressionTimestepEnum));
+         parameters->AddObject(iomodel->CopyConstantObject("md.basalforcings.ar_order",BasalforcingsARMAarOrderEnum));
+         parameters->AddObject(iomodel->CopyConstantObject("md.basalforcings.ma_order",BasalforcingsARMAmaOrderEnum));
+         parameters->AddObject(iomodel->CopyConstantObject("md.basalforcings.arma_initialtime",BasalforcingsARMAInitialTimeEnum));
+         parameters->AddObject(iomodel->CopyConstantObject("md.basalforcings.arma_timestep",BasalforcingsARMATimestepEnum));
                         iomodel->FetchData(&transparam,&M,&N,"md.basalforcings.const");
-         parameters->AddObject(new DoubleVecParam(BasalforcingsautoregressionconstEnum,transparam,N));
+         parameters->AddObject(new DoubleVecParam(BasalforcingsARMAconstEnum,transparam,N));
          xDelete<IssmDouble>(transparam);
          iomodel->FetchData(&transparam,&M,&N,"md.basalforcings.trend");
-         parameters->AddObject(new DoubleVecParam(BasalforcingsautoregressiontrendEnum,transparam,N));
+         parameters->AddObject(new DoubleVecParam(BasalforcingsARMAtrendEnum,transparam,N));
          xDelete<IssmDouble>(transparam);
          iomodel->FetchData(&transparam,&M,&N,"md.basalforcings.arlag_coefs");
-         parameters->AddObject(new DoubleMatParam(BasalforcingsarlagcoefsEnum,transparam,M,N));
+         parameters->AddObject(new DoubleMatParam(BasalforcingsARMAarlagcoefsEnum,transparam,M,N));
+         xDelete<IssmDouble>(transparam);
+         iomodel->FetchData(&transparam,&M,&N,"md.basalforcings.malag_coefs");
+         parameters->AddObject(new DoubleMatParam(BasalforcingsARMAmalagcoefsEnum,transparam,M,N));
          xDelete<IssmDouble>(transparam);
                         iomodel->FetchData(&transparam,&M,&N,"md.basalforcings.upperwater_melting_rate");
@@ -425 +429 @@
                         /*Nothing to add*/
                         break;
-                case SMBautoregressionEnum:
+                //case SMBarmaEnum:
+                case SMBarmaEnum:
          /*Add parameters that are not in standard nbvertices format*/
          parameters->AddObject(iomodel->CopyConstantObject("md.smb.num_basins",SmbNumBasinsEnum));
-         parameters->AddObject(iomodel->CopyConstantObject("md.smb.ar_order",SmbAutoregressiveOrderEnum));
-         parameters->AddObject(iomodel->CopyConstantObject("md.smb.ar_initialtime",SmbAutoregressionInitialTimeEnum));
-         parameters->AddObject(iomodel->CopyConstantObject("md.smb.ar_timestep",SmbAutoregressionTimestepEnum));
+         parameters->AddObject(iomodel->CopyConstantObject("md.smb.ar_order",SmbARMAarOrderEnum));
+         parameters->AddObject(iomodel->CopyConstantObject("md.smb.ma_order",SmbARMAmaOrderEnum));
+         parameters->AddObject(iomodel->CopyConstantObject("md.smb.arma_initialtime",SmbARMAInitialTimeEnum));
+         parameters->AddObject(iomodel->CopyConstantObject("md.smb.arma_timestep",SmbARMATimestepEnum));
          parameters->AddObject(iomodel->CopyConstantObject("md.smb.num_bins",SmbNumElevationBinsEnum));
          iomodel->FetchData(&transparam,&M,&N,"md.smb.const");
-         parameters->AddObject(new DoubleVecParam(SmbautoregressionconstEnum,transparam,N));
+         parameters->AddObject(new DoubleVecParam(SmbARMAconstEnum,transparam,N));
          xDelete<IssmDouble>(transparam);
          iomodel->FetchData(&transparam,&M,&N,"md.smb.trend");
-         parameters->AddObject(new DoubleVecParam(SmbautoregressiontrendEnum,transparam,N));
+         parameters->AddObject(new DoubleVecParam(SmbARMAtrendEnum,transparam,N));
          xDelete<IssmDouble>(transparam);
          iomodel->FetchData(&transparam,&M,&N,"md.smb.arlag_coefs");
-         parameters->AddObject(new DoubleMatParam(SmbarlagcoefsEnum,transparam,M,N));
+         parameters->AddObject(new DoubleMatParam(SmbARMAarlagcoefsEnum,transparam,M,N));
+         xDelete<IssmDouble>(transparam);
+         iomodel->FetchData(&transparam,&M,&N,"md.smb.malag_coefs");
+         parameters->AddObject(new DoubleMatParam(SmbARMAmalagcoefsEnum,transparam,M,N));
          xDelete<IssmDouble>(transparam);
          iomodel->FetchData(&transparam,&M,&N,"md.smb.lapserates");

issm/trunk-jpl/src/c/modules/StochasticForcingx/StochasticForcingx.cpp

@@ -75 +75 @@
                 int dimensionid;
 
-                /*Deal with the autoregressive models*/
-                if(fields[j]==SMBautoregressionEnum || fields[j]==FrontalForcingsRignotAutoregressionEnum || fields[j]==BasalforcingsDeepwaterMeltingRateAutoregressionEnum){
+                /*Deal with the ARMA models*/
+                if(fields[j]==SMBarmaEnum || fields[j]==FrontalForcingsRignotarmaEnum || fields[j]==BasalforcingsDeepwaterMeltingRatearmaEnum){
                         switch(fields[j]){
-                                case SMBautoregressionEnum:
+                                case SMBarmaEnum:
                                         dimenum_type   = SmbBasinsIdEnum;
-                                        noiseenum_type = SmbAutoregressionNoiseEnum;
-                                        break;
-                                case FrontalForcingsRignotAutoregressionEnum:
+                                        noiseenum_type = SmbARMANoiseEnum;
+                                        break;
+                                case FrontalForcingsRignotarmaEnum:
                                         dimenum_type   = FrontalForcingsBasinIdEnum;
-                                        noiseenum_type = ThermalforcingAutoregressionNoiseEnum;
-                                        break;
-                                case BasalforcingsDeepwaterMeltingRateAutoregressionEnum:
+                                        noiseenum_type = ThermalforcingARMANoiseEnum;
+                                        break;
+                                case BasalforcingsDeepwaterMeltingRatearmaEnum:
                                         dimenum_type   = BasalforcingsLinearBasinIdEnum;
                                         noiseenum_type = BasalforcingsDeepwaterMeltingRateNoiseEnum;
@@ -103 +103 @@
                 else{
                         switch(fields[j]){
-                                case SMBautoregressionEnum:
-                                case FrontalForcingsRignotAutoregressionEnum:
-                                case BasalforcingsDeepwaterMeltingRateAutoregressionEnum:
+                                case SMBarmaEnum:
+                                case FrontalForcingsRignotarmaEnum:
+                                case BasalforcingsDeepwaterMeltingRatearmaEnum:
                                         /*Already done above*/
                                         break;

issm/trunk-jpl/src/c/modules/SurfaceMassBalancex/SurfaceMassBalancex.cpp

@@ -147 +147 @@
 
 }/*}}}*/
-void Smbautoregressionx(FemModel* femmodel){/*{{{*/
+void Smbarmax(FemModel* femmodel){/*{{{*/
 
    /*Get time parameters*/
-   IssmDouble time,dt,starttime,tstep_ar;
+   IssmDouble time,dt,starttime,tstep_arma;
    femmodel->parameters->FindParam(&time,TimeEnum);
    femmodel->parameters->FindParam(&dt,TimesteppingTimeStepEnum);
    femmodel->parameters->FindParam(&starttime,TimesteppingStartTimeEnum);
-   femmodel->parameters->FindParam(&tstep_ar,SmbAutoregressionTimestepEnum);
-
-   /*Determine if this is a time step for the AR model*/
-   bool isstepforar = false;
+   femmodel->parameters->FindParam(&tstep_arma,SmbARMATimestepEnum);
+
+   /*Determine if this is a time step for the ARMA model*/
+   bool isstepforarma = false;
 
    #ifndef _HAVE_AD_
-   if((fmod(time,tstep_ar)<fmod((time-dt),tstep_ar)) || (time<=starttime+dt) || tstep_ar==dt) isstepforar = true;
+   if((fmod(time,tstep_arma)<fmod((time-dt),tstep_arma)) || (time<=starttime+dt) || tstep_arma==dt) isstepforarma = true;
    #else
    _error_("not implemented yet");
@@ -168 +168 @@
    bool isstochastic;
    bool issmbstochastic = false;
-   int M,N,Nlagcoefs,arorder,numbasins,numelevbins,my_rank;
+   int M,N,Narlagcoefs,arorder,numbasins,numelevbins,my_rank;
    femmodel->parameters->FindParam(&numbasins,SmbNumBasinsEnum);
-   femmodel->parameters->FindParam(&arorder,SmbAutoregressiveOrderEnum);
+   femmodel->parameters->FindParam(&arorder,SmbARMAarOrderEnum);
    femmodel->parameters->FindParam(&numelevbins,SmbNumElevationBinsEnum);
-   IssmDouble tinit_ar;
+   IssmDouble tinit_arma;
    IssmDouble* termconstant  = NULL; 
    IssmDouble* trend         = NULL;
-   IssmDouble* lagcoefs      = NULL;
+   IssmDouble* arlagcoefs    = NULL;
    IssmDouble* lapserates    = NULL;
    IssmDouble* elevbins      = NULL;
    IssmDouble* refelevation  = NULL;
 
-   femmodel->parameters->FindParam(&tinit_ar,SmbAutoregressionInitialTimeEnum);
-   femmodel->parameters->FindParam(&termconstant,&M,SmbautoregressionconstEnum);  _assert_(M==numbasins);
-   femmodel->parameters->FindParam(&trend,&M,SmbautoregressiontrendEnum);         _assert_(M==numbasins);
-   femmodel->parameters->FindParam(&lagcoefs,&M,&Nlagcoefs,SmbarlagcoefsEnum);    _assert_(M==numbasins); _assert_(Nlagcoefs==arorder);
-   femmodel->parameters->FindParam(&lapserates,&M,&N,SmbLapseRatesEnum);          _assert_(M==numbasins); _assert_(N==numelevbins);
-   femmodel->parameters->FindParam(&elevbins,&M,&N,SmbElevationBinsEnum);         _assert_(M==numbasins); _assert_(N==numelevbins-1);
-   femmodel->parameters->FindParam(&refelevation,&M,SmbRefElevationEnum);         _assert_(M==numbasins);
+   femmodel->parameters->FindParam(&tinit_arma,SmbARMAInitialTimeEnum);
+   femmodel->parameters->FindParam(&termconstant,&M,SmbARMAconstEnum);                   _assert_(M==numbasins);
+   femmodel->parameters->FindParam(&trend,&M,SmbARMAtrendEnum);                          _assert_(M==numbasins);
+   femmodel->parameters->FindParam(&arlagcoefs,&M,&Narlagcoefs,SmbARMAarlagcoefsEnum);   _assert_(M==numbasins); _assert_(Narlagcoefs==arorder);
+   femmodel->parameters->FindParam(&lapserates,&M,&N,SmbLapseRatesEnum);                 _assert_(M==numbasins); _assert_(N==numelevbins);
+   femmodel->parameters->FindParam(&elevbins,&M,&N,SmbElevationBinsEnum);                _assert_(M==numbasins); _assert_(N==numelevbins-1);
+   femmodel->parameters->FindParam(&refelevation,&M,SmbRefElevationEnum);                _assert_(M==numbasins);
 
    femmodel->parameters->FindParam(&isstochastic,StochasticForcingIsStochasticForcingEnum);
@@ -195 +195 @@
       femmodel->parameters->FindParam(&stochasticfields,&N,StochasticForcingFieldsEnum); _assert_(N==numstochasticfields);
       for(int i=0;i<numstochasticfields;i++){
-         if(stochasticfields[i]==SMBautoregressionEnum) issmbstochastic = true;
+         if(stochasticfields[i]==SMBarmaEnum) issmbstochastic = true;
       }
       xDelete<int>(stochasticfields);
    }
-   /*Time elapsed with respect to AR model initial time*/
-   IssmDouble telapsed_ar = time-tinit_ar;
+   /*Time elapsed with respect to ARMA model initial time*/
+   IssmDouble telapsed_arma = time-tinit_arma;
 
    /*Loop over each element to compute SMB at vertices*/
    for(Object* &object:femmodel->elements->objects){
       Element* element = xDynamicCast<Element*>(object);
-      /*Compute autoregression*/
-                element->Autoregression(isstepforar,arorder,telapsed_ar,tstep_ar,termconstant,trend,lagcoefs,issmbstochastic,SMBautoregressionEnum);
+      /*Compute ARMA*/
+                element->Autoregression(isstepforarma,arorder,telapsed_arma,tstep_arma,termconstant,trend,arlagcoefs,issmbstochastic,SMBarmaEnum);
                 /*Compute lapse rate adjustment*/
                 element->LapseRateBasinSMB(numelevbins,lapserates,elevbins,refelevation);
@@ -214 +214 @@
    xDelete<IssmDouble>(termconstant);
    xDelete<IssmDouble>(trend);
-   xDelete<IssmDouble>(lagcoefs);
+   xDelete<IssmDouble>(arlagcoefs);
    xDelete<IssmDouble>(lapserates);
    xDelete<IssmDouble>(elevbins);

issm/trunk-jpl/src/c/modules/SurfaceMassBalancex/SurfaceMassBalancex.h

@@ -13 +13 @@
 void SmbGradientsx(FemModel* femmodel);
 void SmbGradientsElax(FemModel* femmodel);
-void Smbautoregressionx(FemModel* femmodel);
+void Smbarmax(FemModel* femmodel);
 void Delta18oParameterizationx(FemModel* femmodel);
 void MungsmtpParameterizationx(FemModel* femmodel);

issm/trunk-jpl/src/c/shared/Enum/Enum.vim

@@ -67 +67 @@
 syn keyword cConstant BalancethicknessStabilizationEnum
 syn keyword cConstant BarystaticContributionsEnum
-syn keyword cConstant BasalforcingsAutoregressionInitialTimeEnum
-syn keyword cConstant BasalforcingsAutoregressionTimestepEnum
-syn keyword cConstant BasalforcingsAutoregressiveOrderEnum
-syn keyword cConstant BasalforcingsautoregressionconstEnum
-syn keyword cConstant BasalforcingsautoregressiontrendEnum
+syn keyword cConstant BasalforcingsARMAInitialTimeEnum
+syn keyword cConstant BasalforcingsARMATimestepEnum
+syn keyword cConstant BasalforcingsARMAarOrderEnum
+syn keyword cConstant BasalforcingsARMAmaOrderEnum
+syn keyword cConstant BasalforcingsARMAconstEnum
+syn keyword cConstant BasalforcingsARMAtrendEnum
 syn keyword cConstant BasalforcingsBottomplumedepthEnum
 syn keyword cConstant BasalforcingsCrustthicknessEnum
@@ -89 +90 @@
 syn keyword cConstant BasalforcingsMantleconductivityEnum
 syn keyword cConstant BasalforcingsNusseltEnum
-syn keyword cConstant BasalforcingsarlagcoefsEnum
+syn keyword cConstant BasalforcingsARMAarlagcoefsEnum
+syn keyword cConstant BasalforcingsARMAmalagcoefsEnum
 syn keyword cConstant BasalforcingsPicoAverageOverturningEnum
 syn keyword cConstant BasalforcingsPicoAverageSalinityEnum
@@ -196 +198 @@
 syn keyword cConstant FrictionVoidRatioEnum
 syn keyword cConstant FrontalForcingsBasinIcefrontAreaEnum
-syn keyword cConstant FrontalForcingsAutoregressionInitialTimeEnum
-syn keyword cConstant FrontalForcingsAutoregressionTimestepEnum
-syn keyword cConstant FrontalForcingsAutoregressiveOrderEnum
-syn keyword cConstant FrontalForcingsautoregressionconstEnum
-syn keyword cConstant FrontalForcingsautoregressiontrendEnum
+syn keyword cConstant FrontalForcingsARMAInitialTimeEnum
+syn keyword cConstant FrontalForcingsARMATimestepEnum
+syn keyword cConstant FrontalForcingsARMAarOrderEnum
+syn keyword cConstant FrontalForcingsARMAmaOrderEnum
+syn keyword cConstant FrontalForcingsARMAconstEnum
+syn keyword cConstant FrontalForcingsARMAtrendEnum
 syn keyword cConstant FrontalForcingsNumberofBasinsEnum
 syn keyword cConstant FrontalForcingsParamEnum
-syn keyword cConstant FrontalForcingsarlagcoefsEnum
+syn keyword cConstant FrontalForcingsARMAarlagcoefsEnum
+syn keyword cConstant FrontalForcingsARMAmalagcoefsEnum
 syn keyword cConstant GrdModelEnum
 syn keyword cConstant GroundinglineFrictionInterpolationEnum
@@ -474 +478 @@
 syn keyword cConstant SmbAccurefEnum
 syn keyword cConstant SmbAdThreshEnum
-syn keyword cConstant SmbAutoregressionInitialTimeEnum
-syn keyword cConstant SmbAutoregressionTimestepEnum
-syn keyword cConstant SmbAutoregressiveOrderEnum
+syn keyword cConstant SmbARMAInitialTimeEnum
+syn keyword cConstant SmbARMATimestepEnum
+syn keyword cConstant SmbARMAarOrderEnum
+syn keyword cConstant SmbARMAmaOrderEnum
 syn keyword cConstant SmbAveragingEnum
-syn keyword cConstant SmbautoregressionconstEnum
-syn keyword cConstant SmbautoregressiontrendEnum
+syn keyword cConstant SmbARMAconstEnum
+syn keyword cConstant SmbARMAtrendEnum
 syn keyword cConstant SmbDesfacEnum
 syn keyword cConstant SmbDpermilEnum
@@ -516 +521 @@
 syn keyword cConstant SmbNumRequestedOutputsEnum
 syn keyword cConstant SmbPfacEnum
-syn keyword cConstant SmbarlagcoefsEnum
+syn keyword cConstant SmbARMAarlagcoefsEnum
+syn keyword cConstant SmbARMAmalagcoefsEnum
 syn keyword cConstant SmbRdlEnum
 syn keyword cConstant SmbRefElevationEnum
@@ -631 +637 @@
 syn keyword cConstant BalancethicknessThickeningRateEnum
 syn keyword cConstant BasalCrevasseEnum
-syn keyword cConstant BasalforcingsDeepwaterMeltingRateAutoregressionEnum
+syn keyword cConstant BasalforcingsDeepwaterMeltingRatearmaEnum
 syn keyword cConstant BasalforcingsDeepwaterMeltingRateNoiseEnum
 syn keyword cConstant BasalforcingsDeepwaterMeltingRateValuesAutoregressionEnum
@@ -954 +960 @@
 syn keyword cConstant SmbAdiffiniEnum
 syn keyword cConstant SmbAiniEnum
-syn keyword cConstant SmbAutoregressionNoiseEnum
+syn keyword cConstant SmbARMANoiseEnum
 syn keyword cConstant SmbBasinsIdEnum
 syn keyword cConstant SmbBMaxEnum
@@ -1043 +1049 @@
 syn keyword cConstant SmbTzEnum
 syn keyword cConstant SmbValuesAutoregressionEnum
+syn keyword cConstant SmbValuesMovingaverageEnum
 syn keyword cConstant SmbVEnum
 syn keyword cConstant SmbVmeanEnum
@@ -1093 +1100 @@
 syn keyword cConstant TemperaturePicardEnum
 syn keyword cConstant TemperatureSEMICEnum
-syn keyword cConstant ThermalforcingAutoregressionNoiseEnum
+syn keyword cConstant ThermalforcingARMANoiseEnum
 syn keyword cConstant ThermalforcingValuesAutoregressionEnum
 syn keyword cConstant ThermalSpctemperatureEnum
@@ -1249 +1256 @@
 syn keyword cConstant ArrheniusEnum
 syn keyword cConstant AutodiffJacobianEnum
-syn keyword cConstant AutoregressionLinearFloatingMeltRateEnum
 syn keyword cConstant Balancethickness2AnalysisEnum
 syn keyword cConstant Balancethickness2SolutionEnum
@@ -1346 +1352 @@
 syn keyword cConstant FrontalForcingsDefaultEnum
 syn keyword cConstant FrontalForcingsRignotEnum
-syn keyword cConstant FrontalForcingsRignotAutoregressionEnum
+syn keyword cConstant FrontalForcingsRignotarmaEnum
 syn keyword cConstant FsetEnum
 syn keyword cConstant FullMeltOnPartiallyFloatingEnum
@@ -1415 +1421 @@
 syn keyword cConstant LevelsetfunctionPicardEnum
 syn keyword cConstant LinearFloatingMeltRateEnum
+syn keyword cConstant LinearFloatingMeltRatearmaEnum
 syn keyword cConstant LliboutryDuvalEnum
 syn keyword cConstant LoadsEnum
@@ -1524 +1531 @@
 syn keyword cConstant SamplingSolutionEnum
 syn keyword cConstant SIAApproximationEnum
-syn keyword cConstant SMBautoregressionEnum
+syn keyword cConstant SMBarmaEnum
 syn keyword cConstant SMBcomponentsEnum
 syn keyword cConstant SMBd18opddEnum
@@ -1647 +1654 @@
 syn keyword cType Cfsurfacesquare
 syn keyword cType Channel
+syn keyword cType classes
 syn keyword cType Constraint
 syn keyword cType Constraints
@@ -1653 +1661 @@
 syn keyword cType ControlInput
 syn keyword cType Covertree
+syn keyword cType DatasetInput
 syn keyword cType DataSetParam
-syn keyword cType DatasetInput
 syn keyword cType Definition
 syn keyword cType DependentObject
@@ -1667 +1675 @@
 syn keyword cType ElementInput
 syn keyword cType ElementMatrix
+syn keyword cType Elements
 syn keyword cType ElementVector
-syn keyword cType Elements
 syn keyword cType ExponentialVariogram
 syn keyword cType ExternalResult
@@ -1675 +1683 @@
 syn keyword cType Friction
 syn keyword cType Gauss
+syn keyword cType GaussianVariogram
+syn keyword cType gaussobjects
 syn keyword cType GaussPenta
 syn keyword cType GaussSeg
 syn keyword cType GaussTetra
 syn keyword cType GaussTria
-syn keyword cType GaussianVariogram
 syn keyword cType GenericExternalResult
 syn keyword cType GenericOption
@@ -1696 +1705 @@
 syn keyword cType IssmDirectApplicInterface
 syn keyword cType IssmParallelDirectApplicInterface
+syn keyword cType krigingobjects
 syn keyword cType Load
 syn keyword cType Loads
@@ -1706 +1716 @@
 syn keyword cType Matice
 syn keyword cType Matlitho
+syn keyword cType matrixobjects
 syn keyword cType MatrixParam
 syn keyword cType Misfit
@@ -1718 +1729 @@
 syn keyword cType Observations
 syn keyword cType Option
+syn keyword cType Options
 syn keyword cType OptionUtilities
-syn keyword cType Options
 syn keyword cType Param
 syn keyword cType Parameters
@@ -1733 +1744 @@
 syn keyword cType Regionaloutput
 syn keyword cType Results
+syn keyword cType Riftfront
 syn keyword cType RiftStruct
-syn keyword cType Riftfront
 syn keyword cType SealevelGeometry
 syn keyword cType Seg
 syn keyword cType SegInput
+syn keyword cType Segment
 syn keyword cType SegRef
-syn keyword cType Segment
 syn keyword cType SpcDynamic
 syn keyword cType SpcStatic
@@ -1758 +1769 @@
 syn keyword cType Vertex
 syn keyword cType Vertices
-syn keyword cType classes
-syn keyword cType gaussobjects
-syn keyword cType krigingobjects
-syn keyword cType matrixobjects
 syn keyword cType AdjointBalancethickness2Analysis
 syn keyword cType AdjointBalancethicknessAnalysis

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

@@ -61 +61 @@
         BalancethicknessStabilizationEnum,
         BarystaticContributionsEnum,
-        BasalforcingsAutoregressionInitialTimeEnum,
-        BasalforcingsAutoregressionTimestepEnum,
-        BasalforcingsAutoregressiveOrderEnum,
-        BasalforcingsautoregressionconstEnum,
-        BasalforcingsautoregressiontrendEnum,
+        BasalforcingsARMAInitialTimeEnum,
+        BasalforcingsARMATimestepEnum,
+        BasalforcingsARMAarOrderEnum,
+        BasalforcingsARMAmaOrderEnum,
+        BasalforcingsARMAconstEnum,
+        BasalforcingsARMAtrendEnum,
         BasalforcingsBottomplumedepthEnum,
         BasalforcingsCrustthicknessEnum,
@@ -83 +84 @@
         BasalforcingsMantleconductivityEnum,
         BasalforcingsNusseltEnum,
-        BasalforcingsarlagcoefsEnum,
+        BasalforcingsARMAarlagcoefsEnum,
+        BasalforcingsARMAmalagcoefsEnum,
         BasalforcingsPicoAverageOverturningEnum,
         BasalforcingsPicoAverageSalinityEnum,
@@ -190 +192 @@
         FrictionVoidRatioEnum,
         FrontalForcingsBasinIcefrontAreaEnum,
-        FrontalForcingsAutoregressionInitialTimeEnum,
-   FrontalForcingsAutoregressionTimestepEnum,
-   FrontalForcingsAutoregressiveOrderEnum,
-        FrontalForcingsautoregressionconstEnum,
-   FrontalForcingsautoregressiontrendEnum,
+        FrontalForcingsARMAInitialTimeEnum,
+   FrontalForcingsARMATimestepEnum,
+   FrontalForcingsARMAarOrderEnum,
+   FrontalForcingsARMAmaOrderEnum,
+        FrontalForcingsARMAconstEnum,
+   FrontalForcingsARMAtrendEnum,
         FrontalForcingsNumberofBasinsEnum,
         FrontalForcingsParamEnum,
-   FrontalForcingsarlagcoefsEnum,
+   FrontalForcingsARMAarlagcoefsEnum,
+   FrontalForcingsARMAmalagcoefsEnum,
         GrdModelEnum,
         GroundinglineFrictionInterpolationEnum,
@@ -468 +472 @@
         SmbAccurefEnum,
         SmbAdThreshEnum,
-        SmbAutoregressionInitialTimeEnum,
-        SmbAutoregressionTimestepEnum,
-   SmbAutoregressiveOrderEnum,
+        SmbARMAInitialTimeEnum,
+        SmbARMATimestepEnum,
+   SmbARMAarOrderEnum,
+   SmbARMAmaOrderEnum,
         SmbAveragingEnum,
-        SmbautoregressionconstEnum,
-   SmbautoregressiontrendEnum,
+        SmbARMAconstEnum,
+   SmbARMAtrendEnum,
         SmbDesfacEnum,
         SmbDpermilEnum,
@@ -510 +515 @@
         SmbNumRequestedOutputsEnum,
         SmbPfacEnum,
-        SmbarlagcoefsEnum,
+        SmbARMAarlagcoefsEnum,
+        SmbARMAmalagcoefsEnum,
         SmbRdlEnum,
         SmbRefElevationEnum,
@@ -627 +633 @@
         BalancethicknessThickeningRateEnum,
         BasalCrevasseEnum,
-        BasalforcingsDeepwaterMeltingRateAutoregressionEnum,
+        BasalforcingsDeepwaterMeltingRatearmaEnum,
         BasalforcingsDeepwaterMeltingRateNoiseEnum,
         BasalforcingsDeepwaterMeltingRateValuesAutoregressionEnum,
@@ -950 +956 @@
         SmbAdiffiniEnum,
         SmbAiniEnum,
-   SmbAutoregressionNoiseEnum,
+   SmbARMANoiseEnum,
         SmbBasinsIdEnum,
         SmbBMaxEnum,
@@ -1040 +1046 @@
         SmbTzEnum,
         SmbValuesAutoregressionEnum,
+        SmbValuesMovingaverageEnum,
         SmbVEnum,
         SmbVmeanEnum,
@@ -1090 +1097 @@
         TemperaturePicardEnum,
         TemperatureSEMICEnum,
-   ThermalforcingAutoregressionNoiseEnum,
+   ThermalforcingARMANoiseEnum,
         ThermalforcingValuesAutoregressionEnum,
         ThermalSpctemperatureEnum,
@@ -1248 +1255 @@
         ArrheniusEnum,
         AutodiffJacobianEnum,
-        AutoregressionLinearFloatingMeltRateEnum,
         Balancethickness2AnalysisEnum,
         Balancethickness2SolutionEnum,
@@ -1345 +1351 @@
         FrontalForcingsDefaultEnum,
         FrontalForcingsRignotEnum,
-        FrontalForcingsRignotAutoregressionEnum,
+        FrontalForcingsRignotarmaEnum,
         FsetEnum,
         FullMeltOnPartiallyFloatingEnum,
@@ -1414 +1420 @@
         LevelsetfunctionPicardEnum,
         LinearFloatingMeltRateEnum,
+        LinearFloatingMeltRatearmaEnum,
         LliboutryDuvalEnum,
         LoadsEnum,
@@ -1523 +1530 @@
         SamplingSolutionEnum,
         SIAApproximationEnum,
-        SMBautoregressionEnum,
+        SMBarmaEnum,
         SMBcomponentsEnum,
         SMBd18opddEnum,

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

@@ -69 +69 @@
                 case BalancethicknessStabilizationEnum : return "BalancethicknessStabilization";
                 case BarystaticContributionsEnum : return "BarystaticContributions";
-                case BasalforcingsAutoregressionInitialTimeEnum : return "BasalforcingsAutoregressionInitialTime";
-                case BasalforcingsAutoregressionTimestepEnum : return "BasalforcingsAutoregressionTimestep";
-                case BasalforcingsAutoregressiveOrderEnum : return "BasalforcingsAutoregressiveOrder";
-                case BasalforcingsautoregressionconstEnum : return "Basalforcingsautoregressionconst";
-                case BasalforcingsautoregressiontrendEnum : return "Basalforcingsautoregressiontrend";
+                case BasalforcingsARMAInitialTimeEnum : return "BasalforcingsARMAInitialTime";
+                case BasalforcingsARMATimestepEnum : return "BasalforcingsARMATimestep";
+                case BasalforcingsARMAarOrderEnum : return "BasalforcingsARMAarOrder";
+                case BasalforcingsARMAmaOrderEnum : return "BasalforcingsARMAmaOrder";
+                case BasalforcingsARMAconstEnum : return "BasalforcingsARMAconst";
+                case BasalforcingsARMAtrendEnum : return "BasalforcingsARMAtrend";
                 case BasalforcingsBottomplumedepthEnum : return "BasalforcingsBottomplumedepth";
                 case BasalforcingsCrustthicknessEnum : return "BasalforcingsCrustthickness";
@@ -91 +92 @@
                 case BasalforcingsMantleconductivityEnum : return "BasalforcingsMantleconductivity";
                 case BasalforcingsNusseltEnum : return "BasalforcingsNusselt";
-                case BasalforcingsarlagcoefsEnum : return "Basalforcingsarlagcoefs";
+                case BasalforcingsARMAarlagcoefsEnum : return "BasalforcingsARMAarlagcoefs";
+                case BasalforcingsARMAmalagcoefsEnum : return "BasalforcingsARMAmalagcoefs";
                 case BasalforcingsPicoAverageOverturningEnum : return "BasalforcingsPicoAverageOverturning";
                 case BasalforcingsPicoAverageSalinityEnum : return "BasalforcingsPicoAverageSalinity";
@@ -198 +200 @@
                 case FrictionVoidRatioEnum : return "FrictionVoidRatio";
                 case FrontalForcingsBasinIcefrontAreaEnum : return "FrontalForcingsBasinIcefrontArea";
-                case FrontalForcingsAutoregressionInitialTimeEnum : return "FrontalForcingsAutoregressionInitialTime";
-                case FrontalForcingsAutoregressionTimestepEnum : return "FrontalForcingsAutoregressionTimestep";
-                case FrontalForcingsAutoregressiveOrderEnum : return "FrontalForcingsAutoregressiveOrder";
-                case FrontalForcingsautoregressionconstEnum : return "FrontalForcingsautoregressionconst";
-                case FrontalForcingsautoregressiontrendEnum : return "FrontalForcingsautoregressiontrend";
+                case FrontalForcingsARMAInitialTimeEnum : return "FrontalForcingsARMAInitialTime";
+                case FrontalForcingsARMATimestepEnum : return "FrontalForcingsARMATimestep";
+                case FrontalForcingsARMAarOrderEnum : return "FrontalForcingsARMAarOrder";
+                case FrontalForcingsARMAmaOrderEnum : return "FrontalForcingsARMAmaOrder";
+                case FrontalForcingsARMAconstEnum : return "FrontalForcingsARMAconst";
+                case FrontalForcingsARMAtrendEnum : return "FrontalForcingsARMAtrend";
                 case FrontalForcingsNumberofBasinsEnum : return "FrontalForcingsNumberofBasins";
                 case FrontalForcingsParamEnum : return "FrontalForcingsParam";
-                case FrontalForcingsarlagcoefsEnum : return "FrontalForcingsarlagcoefs";
+                case FrontalForcingsARMAarlagcoefsEnum : return "FrontalForcingsARMAarlagcoefs";
+                case FrontalForcingsARMAmalagcoefsEnum : return "FrontalForcingsARMAmalagcoefs";
                 case GrdModelEnum : return "GrdModel";
                 case GroundinglineFrictionInterpolationEnum : return "GroundinglineFrictionInterpolation";
@@ -476 +480 @@
                 case SmbAccurefEnum : return "SmbAccuref";
                 case SmbAdThreshEnum : return "SmbAdThresh";
-                case SmbAutoregressionInitialTimeEnum : return "SmbAutoregressionInitialTime";
-                case SmbAutoregressionTimestepEnum : return "SmbAutoregressionTimestep";
-                case SmbAutoregressiveOrderEnum : return "SmbAutoregressiveOrder";
+                case SmbARMAInitialTimeEnum : return "SmbARMAInitialTime";
+                case SmbARMATimestepEnum : return "SmbARMATimestep";
+                case SmbARMAarOrderEnum : return "SmbARMAarOrder";
+                case SmbARMAmaOrderEnum : return "SmbARMAmaOrder";
                 case SmbAveragingEnum : return "SmbAveraging";
-                case SmbautoregressionconstEnum : return "Smbautoregressionconst";
-                case SmbautoregressiontrendEnum : return "Smbautoregressiontrend";
+                case SmbARMAconstEnum : return "SmbARMAconst";
+                case SmbARMAtrendEnum : return "SmbARMAtrend";
                 case SmbDesfacEnum : return "SmbDesfac";
                 case SmbDpermilEnum : return "SmbDpermil";
@@ -518 +523 @@
                 case SmbNumRequestedOutputsEnum : return "SmbNumRequestedOutputs";
                 case SmbPfacEnum : return "SmbPfac";
-                case SmbarlagcoefsEnum : return "Smbarlagcoefs";
+                case SmbARMAarlagcoefsEnum : return "SmbARMAarlagcoefs";
+                case SmbARMAmalagcoefsEnum : return "SmbARMAmalagcoefs";
                 case SmbRdlEnum : return "SmbRdl";
                 case SmbRefElevationEnum : return "SmbRefElevation";
@@ -633 +639 @@
                 case BalancethicknessThickeningRateEnum : return "BalancethicknessThickeningRate";
                 case BasalCrevasseEnum : return "BasalCrevasse";
-                case BasalforcingsDeepwaterMeltingRateAutoregressionEnum : return "BasalforcingsDeepwaterMeltingRateAutoregression";
+                case BasalforcingsDeepwaterMeltingRatearmaEnum : return "BasalforcingsDeepwaterMeltingRatearma";
                 case BasalforcingsDeepwaterMeltingRateNoiseEnum : return "BasalforcingsDeepwaterMeltingRateNoise";
                 case BasalforcingsDeepwaterMeltingRateValuesAutoregressionEnum : return "BasalforcingsDeepwaterMeltingRateValuesAutoregression";
@@ -956 +962 @@
                 case SmbAdiffiniEnum : return "SmbAdiffini";
                 case SmbAiniEnum : return "SmbAini";
-                case SmbAutoregressionNoiseEnum : return "SmbAutoregressionNoise";
+                case SmbARMANoiseEnum : return "SmbARMANoise";
                 case SmbBasinsIdEnum : return "SmbBasinsId";
                 case SmbBMaxEnum : return "SmbBMax";
@@ -1045 +1051 @@
                 case SmbTzEnum : return "SmbTz";
                 case SmbValuesAutoregressionEnum : return "SmbValuesAutoregression";
+                case SmbValuesMovingaverageEnum : return "SmbValuesMovingaverage";
                 case SmbVEnum : return "SmbV";
                 case SmbVmeanEnum : return "SmbVmean";
@@ -1095 +1102 @@
                 case TemperaturePicardEnum : return "TemperaturePicard";
                 case TemperatureSEMICEnum : return "TemperatureSEMIC";
-                case ThermalforcingAutoregressionNoiseEnum : return "ThermalforcingAutoregressionNoise";
+                case ThermalforcingARMANoiseEnum : return "ThermalforcingARMANoise";
                 case ThermalforcingValuesAutoregressionEnum : return "ThermalforcingValuesAutoregression";
                 case ThermalSpctemperatureEnum : return "ThermalSpctemperature";
@@ -1251 +1258 @@
                 case ArrheniusEnum : return "Arrhenius";
                 case AutodiffJacobianEnum : return "AutodiffJacobian";
-                case AutoregressionLinearFloatingMeltRateEnum : return "AutoregressionLinearFloatingMeltRate";
                 case Balancethickness2AnalysisEnum : return "Balancethickness2Analysis";
                 case Balancethickness2SolutionEnum : return "Balancethickness2Solution";
@@ -1348 +1354 @@
                 case FrontalForcingsDefaultEnum : return "FrontalForcingsDefault";
                 case FrontalForcingsRignotEnum : return "FrontalForcingsRignot";
-                case FrontalForcingsRignotAutoregressionEnum : return "FrontalForcingsRignotAutoregression";
+                case FrontalForcingsRignotarmaEnum : return "FrontalForcingsRignotarma";
                 case FsetEnum : return "Fset";
                 case FullMeltOnPartiallyFloatingEnum : return "FullMeltOnPartiallyFloating";
@@ -1417 +1423 @@
                 case LevelsetfunctionPicardEnum : return "LevelsetfunctionPicard";
                 case LinearFloatingMeltRateEnum : return "LinearFloatingMeltRate";
+                case LinearFloatingMeltRatearmaEnum : return "LinearFloatingMeltRatearma";
                 case LliboutryDuvalEnum : return "LliboutryDuval";
                 case LoadsEnum : return "Loads";
@@ -1526 +1533 @@
                 case SamplingSolutionEnum : return "SamplingSolution";
                 case SIAApproximationEnum : return "SIAApproximation";
-                case SMBautoregressionEnum : return "SMBautoregression";
+                case SMBarmaEnum : return "SMBarma";
                 case SMBcomponentsEnum : return "SMBcomponents";
                 case SMBd18opddEnum : return "SMBd18opdd";

issm/trunk-jpl/src/c/shared/Enum/Enumjl.vim

@@ -60 +60 @@
 syn keyword juliaConstC BalancethicknessStabilizationEnum
 syn keyword juliaConstC BarystaticContributionsEnum
-syn keyword juliaConstC BasalforcingsAutoregressionInitialTimeEnum
-syn keyword juliaConstC BasalforcingsAutoregressionTimestepEnum
-syn keyword juliaConstC BasalforcingsAutoregressiveOrderEnum
-syn keyword juliaConstC BasalforcingsautoregressionconstEnum 
-syn keyword juliaConstC BasalforcingsautoregressiontrendEnum
+syn keyword juliaConstC BasalforcingsARMAInitialTimeEnum
+syn keyword juliaConstC BasalforcingsARMATimestepEnum
+syn keyword juliaConstC BasalforcingsARMAarOrderEnum
+syn keyword juliaConstC BasalforcingsARMAmaOrderEnum
+syn keyword juliaConstC BasalforcingsARMAconstEnum
+syn keyword juliaConstC BasalforcingsARMAtrendEnum
 syn keyword juliaConstC BasalforcingsBottomplumedepthEnum
 syn keyword juliaConstC BasalforcingsCrustthicknessEnum
@@ -82 +83 @@
 syn keyword juliaConstC BasalforcingsMantleconductivityEnum
 syn keyword juliaConstC BasalforcingsNusseltEnum
-syn keyword juliaConstC BasalforcingsarlagcoefsEnum
+syn keyword juliaConstC BasalforcingsARMAarlagcoefsEnum
+syn keyword juliaConstC BasalforcingsARMAmalagcoefsEnum
 syn keyword juliaConstC BasalforcingsPicoAverageOverturningEnum
 syn keyword juliaConstC BasalforcingsPicoAverageSalinityEnum
@@ -189 +191 @@
 syn keyword juliaConstC FrictionVoidRatioEnum
 syn keyword juliaConstC FrontalForcingsBasinIcefrontAreaEnum
-syn keyword juliaConstC FrontalForcingsAutoregressionInitialTimeEnum
-syn keyword juliaConstC FrontalForcingsAutoregressionTimestepEnum
-syn keyword juliaConstC FrontalForcingsAutoregressiveOrderEnum
-syn keyword juliaConstC FrontalForcingsautoregressionconstEnum
-syn keyword juliaConstC FrontalForcingsautoregressiontrendEnum
+syn keyword juliaConstC FrontalForcingsARMAInitialTimeEnum
+syn keyword juliaConstC FrontalForcingsARMATimestepEnum
+syn keyword juliaConstC FrontalForcingsARMAarOrderEnum
+syn keyword juliaConstC FrontalForcingsARMAmaOrderEnum
+syn keyword juliaConstC FrontalForcingsARMAconstEnum
+syn keyword juliaConstC FrontalForcingsARMAtrendEnum
 syn keyword juliaConstC FrontalForcingsNumberofBasinsEnum
 syn keyword juliaConstC FrontalForcingsParamEnum
-syn keyword juliaConstC FrontalForcingsarlagcoefsEnum
+syn keyword juliaConstC FrontalForcingsARMAarlagcoefsEnum
+syn keyword juliaConstC FrontalForcingsARMAmalagcoefsEnum
 syn keyword juliaConstC GrdModelEnum
 syn keyword juliaConstC GroundinglineFrictionInterpolationEnum
@@ -467 +471 @@
 syn keyword juliaConstC SmbAccurefEnum
 syn keyword juliaConstC SmbAdThreshEnum
-syn keyword juliaConstC SmbAutoregressionInitialTimeEnum
-syn keyword juliaConstC SmbAutoregressionTimestepEnum
-syn keyword juliaConstC SmbAutoregressiveOrderEnum
+syn keyword juliaConstC SmbARMAInitialTimeEnum
+syn keyword juliaConstC SmbARMATimestepEnum
+syn keyword juliaConstC SmbARMAarOrderEnum
+syn keyword juliaConstC SmbARMAmaOrderEnum
 syn keyword juliaConstC SmbAveragingEnum
-syn keyword juliaConstC SmbautoregressionconstEnum
-syn keyword juliaConstC SmbautoregressiontrendEnum
+syn keyword juliaConstC SmbARMAconstEnum
+syn keyword juliaConstC SmbARMAtrendEnum
 syn keyword juliaConstC SmbDesfacEnum
 syn keyword juliaConstC SmbDpermilEnum
@@ -509 +514 @@
 syn keyword juliaConstC SmbNumRequestedOutputsEnum
 syn keyword juliaConstC SmbPfacEnum
-syn keyword juliaConstC SmbarlagcoefsEnum
+syn keyword juliaConstC SmbARMAarlagcoefsEnum
+syn keyword juliaConstC SmbARMAmalagcoefsEnum
 syn keyword juliaConstC SmbRdlEnum
 syn keyword juliaConstC SmbRefElevationEnum
@@ -624 +630 @@
 syn keyword juliaConstC BalancethicknessThickeningRateEnum
 syn keyword juliaConstC BasalCrevasseEnum
-syn keyword juliaConstC BasalforcingsDeepwaterMeltingRateAutoregressionEnum
+syn keyword juliaConstC BasalforcingsDeepwaterMeltingRatearmaEnum
 syn keyword juliaConstC BasalforcingsDeepwaterMeltingRateNoiseEnum
 syn keyword juliaConstC BasalforcingsDeepwaterMeltingRateValuesAutoregressionEnum
@@ -864 +870 @@
 syn keyword juliaConstC SamplingBetaEnum
 syn keyword juliaConstC SamplingKappaEnum
-syn keyword juliaConstC SamplingarlagcoefsEnum
+syn keyword juliaConstC SamplingPhiEnum
 syn keyword juliaConstC SamplingTauEnum
 syn keyword juliaConstC SealevelEnum
@@ -947 +953 @@
 syn keyword juliaConstC SmbAdiffiniEnum
 syn keyword juliaConstC SmbAiniEnum
-syn keyword juliaConstC SmbAutoregressionNoiseEnum
+syn keyword juliaConstC SmbARMANoiseEnum
 syn keyword juliaConstC SmbBasinsIdEnum
 syn keyword juliaConstC SmbBMaxEnum
@@ -1036 +1042 @@
 syn keyword juliaConstC SmbTzEnum
 syn keyword juliaConstC SmbValuesAutoregressionEnum
+syn keyword juliaConstC SmbValuesMovingaverageEnum
 syn keyword juliaConstC SmbVEnum
 syn keyword juliaConstC SmbVmeanEnum
@@ -1086 +1093 @@
 syn keyword juliaConstC TemperaturePicardEnum
 syn keyword juliaConstC TemperatureSEMICEnum
-syn keyword juliaConstC ThermalforcingAutoregressionNoiseEnum
+syn keyword juliaConstC ThermalforcingARMANoiseEnum
 syn keyword juliaConstC ThermalforcingValuesAutoregressionEnum
 syn keyword juliaConstC ThermalSpctemperatureEnum
@@ -1242 +1249 @@
 syn keyword juliaConstC ArrheniusEnum
 syn keyword juliaConstC AutodiffJacobianEnum
-syn keyword juliaConstC AutoregressionLinearFloatingMeltRateEnum
 syn keyword juliaConstC Balancethickness2AnalysisEnum
 syn keyword juliaConstC Balancethickness2SolutionEnum
@@ -1339 +1345 @@
 syn keyword juliaConstC FrontalForcingsDefaultEnum
 syn keyword juliaConstC FrontalForcingsRignotEnum
-syn keyword juliaConstC FrontalForcingsRignotAutoregressionEnum
+syn keyword juliaConstC FrontalForcingsRignotarmaEnum
 syn keyword juliaConstC FsetEnum
 syn keyword juliaConstC FullMeltOnPartiallyFloatingEnum
@@ -1408 +1414 @@
 syn keyword juliaConstC LevelsetfunctionPicardEnum
 syn keyword juliaConstC LinearFloatingMeltRateEnum
+syn keyword juliaConstC LinearFloatingMeltRatearmaEnum
 syn keyword juliaConstC LliboutryDuvalEnum
 syn keyword juliaConstC LoadsEnum
@@ -1517 +1524 @@
 syn keyword juliaConstC SamplingSolutionEnum
 syn keyword juliaConstC SIAApproximationEnum
-syn keyword juliaConstC SMBautoregressionEnum
+syn keyword juliaConstC SMBarmaEnum
 syn keyword juliaConstC SMBcomponentsEnum
 syn keyword juliaConstC SMBd18opddEnum

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

@@ -69 +69 @@
               else if (strcmp(name,"BalancethicknessStabilization")==0) return BalancethicknessStabilizationEnum;
               else if (strcmp(name,"BarystaticContributions")==0) return BarystaticContributionsEnum;
-              else if (strcmp(name,"BasalforcingsAutoregressionInitialTime")==0) return BasalforcingsAutoregressionInitialTimeEnum;
-              else if (strcmp(name,"BasalforcingsAutoregressionTimestep")==0) return BasalforcingsAutoregressionTimestepEnum;
-              else if (strcmp(name,"BasalforcingsAutoregressiveOrder")==0) return BasalforcingsAutoregressiveOrderEnum;
-              else if (strcmp(name,"Basalforcingsautoregressionconst")==0) return BasalforcingsautoregressionconstEnum;
-              else if (strcmp(name,"Basalforcingsautoregressiontrend")==0) return BasalforcingsautoregressiontrendEnum;
+              else if (strcmp(name,"BasalforcingsARMAInitialTime")==0) return BasalforcingsARMAInitialTimeEnum;
+              else if (strcmp(name,"BasalforcingsARMATimestep")==0) return BasalforcingsARMATimestepEnum;
+              else if (strcmp(name,"BasalforcingsARMAarOrder")==0) return BasalforcingsARMAarOrderEnum;
+              else if (strcmp(name,"BasalforcingsARMAmaOrder")==0) return BasalforcingsARMAmaOrderEnum;
+              else if (strcmp(name,"BasalforcingsARMAconst")==0) return BasalforcingsARMAconstEnum;
+              else if (strcmp(name,"BasalforcingsARMAtrend")==0) return BasalforcingsARMAtrendEnum;
               else if (strcmp(name,"BasalforcingsBottomplumedepth")==0) return BasalforcingsBottomplumedepthEnum;
               else if (strcmp(name,"BasalforcingsCrustthickness")==0) return BasalforcingsCrustthicknessEnum;
@@ -91 +92 @@
               else if (strcmp(name,"BasalforcingsMantleconductivity")==0) return BasalforcingsMantleconductivityEnum;
               else if (strcmp(name,"BasalforcingsNusselt")==0) return BasalforcingsNusseltEnum;
-              else if (strcmp(name,"Basalforcingsarlagcoefs")==0) return BasalforcingsarlagcoefsEnum;
+              else if (strcmp(name,"BasalforcingsARMAarlagcoefs")==0) return BasalforcingsARMAarlagcoefsEnum;
+              else if (strcmp(name,"BasalforcingsARMAmalagcoefs")==0) return BasalforcingsARMAmalagcoefsEnum;
               else if (strcmp(name,"BasalforcingsPicoAverageOverturning")==0) return BasalforcingsPicoAverageOverturningEnum;
               else if (strcmp(name,"BasalforcingsPicoAverageSalinity")==0) return BasalforcingsPicoAverageSalinityEnum;
@@ -135 +137 @@
               else if (strcmp(name,"ControlInputInterpolation")==0) return ControlInputInterpolationEnum;
               else if (strcmp(name,"CumBslc")==0) return CumBslcEnum;
-              else if (strcmp(name,"CumBslcIce")==0) return CumBslcIceEnum;
-              else if (strcmp(name,"CumBslcHydro")==0) return CumBslcHydroEnum;
          else stage=2;
    }
    if(stage==2){
-              if (strcmp(name,"CumBslcOcean")==0) return CumBslcOceanEnum;
+              if (strcmp(name,"CumBslcIce")==0) return CumBslcIceEnum;
+              else if (strcmp(name,"CumBslcHydro")==0) return CumBslcHydroEnum;
+              else if (strcmp(name,"CumBslcOcean")==0) return CumBslcOceanEnum;
               else if (strcmp(name,"CumBslcIcePartition")==0) return CumBslcIcePartitionEnum;
               else if (strcmp(name,"CumBslcHydroPartition")==0) return CumBslcHydroPartitionEnum;
@@ -201 +203 @@
               else if (strcmp(name,"FrictionVoidRatio")==0) return FrictionVoidRatioEnum;
               else if (strcmp(name,"FrontalForcingsBasinIcefrontArea")==0) return FrontalForcingsBasinIcefrontAreaEnum;
-              else if (strcmp(name,"FrontalForcingsAutoregressionInitialTime")==0) return FrontalForcingsAutoregressionInitialTimeEnum;
-              else if (strcmp(name,"FrontalForcingsAutoregressionTimestep")==0) return FrontalForcingsAutoregressionTimestepEnum;
-              else if (strcmp(name,"FrontalForcingsAutoregressiveOrder")==0) return FrontalForcingsAutoregressiveOrderEnum;
-              else if (strcmp(name,"FrontalForcingsautoregressionconst")==0) return FrontalForcingsautoregressionconstEnum;
-              else if (strcmp(name,"FrontalForcingsautoregressiontrend")==0) return FrontalForcingsautoregressiontrendEnum;
+              else if (strcmp(name,"FrontalForcingsARMAInitialTime")==0) return FrontalForcingsARMAInitialTimeEnum;
+              else if (strcmp(name,"FrontalForcingsARMATimestep")==0) return FrontalForcingsARMATimestepEnum;
+              else if (strcmp(name,"FrontalForcingsARMAarOrder")==0) return FrontalForcingsARMAarOrderEnum;
+              else if (strcmp(name,"FrontalForcingsARMAmaOrder")==0) return FrontalForcingsARMAmaOrderEnum;
+              else if (strcmp(name,"FrontalForcingsARMAconst")==0) return FrontalForcingsARMAconstEnum;
+              else if (strcmp(name,"FrontalForcingsARMAtrend")==0) return FrontalForcingsARMAtrendEnum;
               else if (strcmp(name,"FrontalForcingsNumberofBasins")==0) return FrontalForcingsNumberofBasinsEnum;
               else if (strcmp(name,"FrontalForcingsParam")==0) return FrontalForcingsParamEnum;
-              else if (strcmp(name,"FrontalForcingsarlagcoefs")==0) return FrontalForcingsarlagcoefsEnum;
+              else if (strcmp(name,"FrontalForcingsARMAarlagcoefs")==0) return FrontalForcingsARMAarlagcoefsEnum;
+              else if (strcmp(name,"FrontalForcingsARMAmalagcoefs")==0) return FrontalForcingsARMAmalagcoefsEnum;
               else if (strcmp(name,"GrdModel")==0) return GrdModelEnum;
               else if (strcmp(name,"GroundinglineFrictionInterpolation")==0) return GroundinglineFrictionInterpolationEnum;
@@ -256 +260 @@
               else if (strcmp(name,"IcecapToEarthComm")==0) return IcecapToEarthCommEnum;
               else if (strcmp(name,"Index")==0) return IndexEnum;
-              else if (strcmp(name,"InputFileName")==0) return InputFileNameEnum;
+         else stage=3;
+   }
+   if(stage==3){
+              if (strcmp(name,"InputFileName")==0) return InputFileNameEnum;
               else if (strcmp(name,"DirectoryName")==0) return DirectoryNameEnum;
               else if (strcmp(name,"Indices")==0) return IndicesEnum;
               else if (strcmp(name,"InputToDepthaverageIn")==0) return InputToDepthaverageInEnum;
-         else stage=3;
-   }
-   if(stage==3){
-              if (strcmp(name,"InputToDepthaverageOut")==0) return InputToDepthaverageOutEnum;
+              else if (strcmp(name,"InputToDepthaverageOut")==0) return InputToDepthaverageOutEnum;
               else if (strcmp(name,"InputToExtrude")==0) return InputToExtrudeEnum;
               else if (strcmp(name,"InputToL2Project")==0) return InputToL2ProjectEnum;
@@ -379 +383 @@
               else if (strcmp(name,"QmuResponsePartitions")==0) return QmuResponsePartitionsEnum;
               else if (strcmp(name,"QmuResponsePartitionsNpart")==0) return QmuResponsePartitionsNpartEnum;
-              else if (strcmp(name,"QmuStatistics")==0) return QmuStatisticsEnum;
+         else stage=4;
+   }
+   if(stage==4){
+              if (strcmp(name,"QmuStatistics")==0) return QmuStatisticsEnum;
               else if (strcmp(name,"QmuNumstatistics")==0) return QmuNumstatisticsEnum;
               else if (strcmp(name,"QmuNdirectories")==0) return QmuNdirectoriesEnum;
               else if (strcmp(name,"QmuNfilesPerDirectory")==0) return QmuNfilesPerDirectoryEnum;
-         else stage=4;
-   }
-   if(stage==4){
-              if (strcmp(name,"QmuStatisticsMethod")==0) return QmuStatisticsMethodEnum;
+              else if (strcmp(name,"QmuStatisticsMethod")==0) return QmuStatisticsMethodEnum;
               else if (strcmp(name,"QmuMethods")==0) return QmuMethodsEnum;
               else if (strcmp(name,"RestartFileName")==0) return RestartFileNameEnum;
@@ -485 +489 @@
               else if (strcmp(name,"SmbAccuref")==0) return SmbAccurefEnum;
               else if (strcmp(name,"SmbAdThresh")==0) return SmbAdThreshEnum;
-              else if (strcmp(name,"SmbAutoregressionInitialTime")==0) return SmbAutoregressionInitialTimeEnum;
-              else if (strcmp(name,"SmbAutoregressionTimestep")==0) return SmbAutoregressionTimestepEnum;
-              else if (strcmp(name,"SmbAutoregressiveOrder")==0) return SmbAutoregressiveOrderEnum;
+              else if (strcmp(name,"SmbARMAInitialTime")==0) return SmbARMAInitialTimeEnum;
+              else if (strcmp(name,"SmbARMATimestep")==0) return SmbARMATimestepEnum;
+              else if (strcmp(name,"SmbARMAarOrder")==0) return SmbARMAarOrderEnum;
+              else if (strcmp(name,"SmbARMAmaOrder")==0) return SmbARMAmaOrderEnum;
               else if (strcmp(name,"SmbAveraging")==0) return SmbAveragingEnum;
-              else if (strcmp(name,"Smbautoregressionconst")==0) return SmbautoregressionconstEnum;
-              else if (strcmp(name,"Smbautoregressiontrend")==0) return SmbautoregressiontrendEnum;
+              else if (strcmp(name,"SmbARMAconst")==0) return SmbARMAconstEnum;
+              else if (strcmp(name,"SmbARMAtrend")==0) return SmbARMAtrendEnum;
               else if (strcmp(name,"SmbDesfac")==0) return SmbDesfacEnum;
               else if (strcmp(name,"SmbDpermil")==0) return SmbDpermilEnum;
@@ -501 +506 @@
               else if (strcmp(name,"SmbDt")==0) return SmbDtEnum;
               else if (strcmp(name,"Smb")==0) return SmbEnum;
-              else if (strcmp(name,"SmbEIdx")==0) return SmbEIdxEnum;
+         else stage=5;
+   }
+   if(stage==5){
+              if (strcmp(name,"SmbEIdx")==0) return SmbEIdxEnum;
               else if (strcmp(name,"SmbF")==0) return SmbFEnum;
               else if (strcmp(name,"SmbInitDensityScaling")==0) return SmbInitDensityScalingEnum;
               else if (strcmp(name,"SmbIsaccumulation")==0) return SmbIsaccumulationEnum;
               else if (strcmp(name,"SmbIsalbedo")==0) return SmbIsalbedoEnum;
-         else stage=5;
-   }
-   if(stage==5){
-              if (strcmp(name,"SmbIsconstrainsurfaceT")==0) return SmbIsconstrainsurfaceTEnum;
+              else if (strcmp(name,"SmbIsconstrainsurfaceT")==0) return SmbIsconstrainsurfaceTEnum;
               else if (strcmp(name,"SmbIsd18opd")==0) return SmbIsd18opdEnum;
               else if (strcmp(name,"SmbIsdelta18o")==0) return SmbIsdelta18oEnum;
@@ -530 +535 @@
               else if (strcmp(name,"SmbNumRequestedOutputs")==0) return SmbNumRequestedOutputsEnum;
               else if (strcmp(name,"SmbPfac")==0) return SmbPfacEnum;
-              else if (strcmp(name,"Smbarlagcoefs")==0) return SmbarlagcoefsEnum;
+              else if (strcmp(name,"SmbARMAarlagcoefs")==0) return SmbARMAarlagcoefsEnum;
+              else if (strcmp(name,"SmbARMAmalagcoefs")==0) return SmbARMAmalagcoefsEnum;
               else if (strcmp(name,"SmbRdl")==0) return SmbRdlEnum;
               else if (strcmp(name,"SmbRefElevation")==0) return SmbRefElevationEnum;
@@ -623 +629 @@
               else if (strcmp(name,"WorldComm")==0) return WorldCommEnum;
               else if (strcmp(name,"ParametersEND")==0) return ParametersENDEnum;
-              else if (strcmp(name,"InputsSTART")==0) return InputsSTARTEnum;
+         else stage=6;
+   }
+   if(stage==6){
+              if (strcmp(name,"InputsSTART")==0) return InputsSTARTEnum;
               else if (strcmp(name,"AccumulatedDeltaBottomPressure")==0) return AccumulatedDeltaBottomPressureEnum;
               else if (strcmp(name,"AccumulatedDeltaIceThickness")==0) return AccumulatedDeltaIceThicknessEnum;
@@ -629 +638 @@
               else if (strcmp(name,"Adjoint")==0) return AdjointEnum;
               else if (strcmp(name,"Adjointp")==0) return AdjointpEnum;
-         else stage=6;
-   }
-   if(stage==6){
-              if (strcmp(name,"Adjointx")==0) return AdjointxEnum;
+              else if (strcmp(name,"Adjointx")==0) return AdjointxEnum;
               else if (strcmp(name,"AdjointxBase")==0) return AdjointxBaseEnum;
               else if (strcmp(name,"AdjointxShear")==0) return AdjointxShearEnum;
@@ -648 +654 @@
               else if (strcmp(name,"BalancethicknessThickeningRate")==0) return BalancethicknessThickeningRateEnum;
               else if (strcmp(name,"BasalCrevasse")==0) return BasalCrevasseEnum;
-              else if (strcmp(name,"BasalforcingsDeepwaterMeltingRateAutoregression")==0) return BasalforcingsDeepwaterMeltingRateAutoregressionEnum;
+              else if (strcmp(name,"BasalforcingsDeepwaterMeltingRatearma")==0) return BasalforcingsDeepwaterMeltingRatearmaEnum;
               else if (strcmp(name,"BasalforcingsDeepwaterMeltingRateNoise")==0) return BasalforcingsDeepwaterMeltingRateNoiseEnum;
               else if (strcmp(name,"BasalforcingsDeepwaterMeltingRateValuesAutoregression")==0) return BasalforcingsDeepwaterMeltingRateValuesAutoregressionEnum;
@@ -746 +752 @@
               else if (strcmp(name,"EffectivePressureTransient")==0) return EffectivePressureTransientEnum;
               else if (strcmp(name,"Enthalpy")==0) return EnthalpyEnum;
-              else if (strcmp(name,"EnthalpyPicard")==0) return EnthalpyPicardEnum;
+         else stage=7;
+   }
+   if(stage==7){
+              if (strcmp(name,"EnthalpyPicard")==0) return EnthalpyPicardEnum;
               else if (strcmp(name,"EplHead")==0) return EplHeadEnum;
               else if (strcmp(name,"EplHeadOld")==0) return EplHeadOldEnum;
@@ -752 +761 @@
               else if (strcmp(name,"EplHeadSlopeY")==0) return EplHeadSlopeYEnum;
               else if (strcmp(name,"EplHeadSubstep")==0) return EplHeadSubstepEnum;
-         else stage=7;
-   }
-   if(stage==7){
-              if (strcmp(name,"EplHeadTransient")==0) return EplHeadTransientEnum;
+              else if (strcmp(name,"EplHeadTransient")==0) return EplHeadTransientEnum;
               else if (strcmp(name,"EsaEmotion")==0) return EsaEmotionEnum;
               else if (strcmp(name,"EsaNmotion")==0) return EsaNmotionEnum;
@@ -869 +875 @@
               else if (strcmp(name,"Node")==0) return NodeEnum;
               else if (strcmp(name,"OmegaAbsGradient")==0) return OmegaAbsGradientEnum;
-              else if (strcmp(name,"OceantransportSpcbottompressure")==0) return OceantransportSpcbottompressureEnum;
+         else stage=8;
+   }
+   if(stage==8){
+              if (strcmp(name,"OceantransportSpcbottompressure")==0) return OceantransportSpcbottompressureEnum;
               else if (strcmp(name,"OceantransportSpcstr")==0) return OceantransportSpcstrEnum;
               else if (strcmp(name,"OceantransportSpcdsl")==0) return OceantransportSpcdslEnum;
@@ -875 +884 @@
               else if (strcmp(name,"P1")==0) return P1Enum;
               else if (strcmp(name,"Partitioning")==0) return PartitioningEnum;
-         else stage=8;
-   }
-   if(stage==8){
-              if (strcmp(name,"Pressure")==0) return PressureEnum;
+              else if (strcmp(name,"Pressure")==0) return PressureEnum;
               else if (strcmp(name,"Radar")==0) return RadarEnum;
               else if (strcmp(name,"RadarAttenuationMacGregor")==0) return RadarAttenuationMacGregorEnum;
@@ -977 +983 @@
               else if (strcmp(name,"SmbAdiffini")==0) return SmbAdiffiniEnum;
               else if (strcmp(name,"SmbAini")==0) return SmbAiniEnum;
-              else if (strcmp(name,"SmbAutoregressionNoise")==0) return SmbAutoregressionNoiseEnum;
+              else if (strcmp(name,"SmbARMANoise")==0) return SmbARMANoiseEnum;
               else if (strcmp(name,"SmbBasinsId")==0) return SmbBasinsIdEnum;
               else if (strcmp(name,"SmbBMax")==0) return SmbBMaxEnum;
@@ -992 +998 @@
               else if (strcmp(name,"SmbDailydlradiation")==0) return SmbDailydlradiationEnum;
               else if (strcmp(name,"SmbDailydsradiation")==0) return SmbDailydsradiationEnum;
-              else if (strcmp(name,"SmbDailypressure")==0) return SmbDailypressureEnum;
+         else stage=9;
+   }
+   if(stage==9){
+              if (strcmp(name,"SmbDailypressure")==0) return SmbDailypressureEnum;
               else if (strcmp(name,"SmbDailyrainfall")==0) return SmbDailyrainfallEnum;
               else if (strcmp(name,"SmbDailysnowfall")==0) return SmbDailysnowfallEnum;
@@ -998 +1007 @@
               else if (strcmp(name,"SmbDailywindspeed")==0) return SmbDailywindspeedEnum;
               else if (strcmp(name,"SmbDini")==0) return SmbDiniEnum;
-         else stage=9;
-   }
-   if(stage==9){
-              if (strcmp(name,"SmbDlwrf")==0) return SmbDlwrfEnum;
+              else if (strcmp(name,"SmbDlwrf")==0) return SmbDlwrfEnum;
               else if (strcmp(name,"SmbDulwrfValue")==0) return SmbDulwrfValueEnum;
               else if (strcmp(name,"SmbDswrf")==0) return SmbDswrfEnum;
@@ -1069 +1075 @@
               else if (strcmp(name,"SmbTz")==0) return SmbTzEnum;
               else if (strcmp(name,"SmbValuesAutoregression")==0) return SmbValuesAutoregressionEnum;
+              else if (strcmp(name,"SmbValuesMovingaverage")==0) return SmbValuesMovingaverageEnum;
               else if (strcmp(name,"SmbV")==0) return SmbVEnum;
               else if (strcmp(name,"SmbVmean")==0) return SmbVmeanEnum;
@@ -1114 +1121 @@
               else if (strcmp(name,"SurfaceRelVelMisfit")==0) return SurfaceRelVelMisfitEnum;
               else if (strcmp(name,"SurfaceSlopeX")==0) return SurfaceSlopeXEnum;
-              else if (strcmp(name,"SurfaceSlopeY")==0) return SurfaceSlopeYEnum;
+         else stage=10;
+   }
+   if(stage==10){
+              if (strcmp(name,"SurfaceSlopeY")==0) return SurfaceSlopeYEnum;
               else if (strcmp(name,"Temperature")==0) return TemperatureEnum;
               else if (strcmp(name,"TemperaturePDD")==0) return TemperaturePDDEnum;
               else if (strcmp(name,"TemperaturePicard")==0) return TemperaturePicardEnum;
               else if (strcmp(name,"TemperatureSEMIC")==0) return TemperatureSEMICEnum;
-              else if (strcmp(name,"ThermalforcingAutoregressionNoise")==0) return ThermalforcingAutoregressionNoiseEnum;
+              else if (strcmp(name,"ThermalforcingARMANoise")==0) return ThermalforcingARMANoiseEnum;
               else if (strcmp(name,"ThermalforcingValuesAutoregression")==0) return ThermalforcingValuesAutoregressionEnum;
-         else stage=10;
-   }
-   if(stage==10){
-              if (strcmp(name,"ThermalSpctemperature")==0) return ThermalSpctemperatureEnum;
+              else if (strcmp(name,"ThermalSpctemperature")==0) return ThermalSpctemperatureEnum;
               else if (strcmp(name,"ThicknessAbsGradient")==0) return ThicknessAbsGradientEnum;
               else if (strcmp(name,"ThicknessAbsMisfit")==0) return ThicknessAbsMisfitEnum;
@@ -1237 +1244 @@
               else if (strcmp(name,"Outputdefinition74")==0) return Outputdefinition74Enum;
               else if (strcmp(name,"Outputdefinition75")==0) return Outputdefinition75Enum;
-              else if (strcmp(name,"Outputdefinition76")==0) return Outputdefinition76Enum;
+         else stage=11;
+   }
+   if(stage==11){
+              if (strcmp(name,"Outputdefinition76")==0) return Outputdefinition76Enum;
               else if (strcmp(name,"Outputdefinition77")==0) return Outputdefinition77Enum;
               else if (strcmp(name,"Outputdefinition78")==0) return Outputdefinition78Enum;
@@ -1244 +1254 @@
               else if (strcmp(name,"Outputdefinition80")==0) return Outputdefinition80Enum;
               else if (strcmp(name,"Outputdefinition81")==0) return Outputdefinition81Enum;
-         else stage=11;
-   }
-   if(stage==11){
-              if (strcmp(name,"Outputdefinition82")==0) return Outputdefinition82Enum;
+              else if (strcmp(name,"Outputdefinition82")==0) return Outputdefinition82Enum;
               else if (strcmp(name,"Outputdefinition83")==0) return Outputdefinition83Enum;
               else if (strcmp(name,"Outputdefinition84")==0) return Outputdefinition84Enum;
@@ -1281 +1288 @@
               else if (strcmp(name,"Arrhenius")==0) return ArrheniusEnum;
               else if (strcmp(name,"AutodiffJacobian")==0) return AutodiffJacobianEnum;
-              else if (strcmp(name,"AutoregressionLinearFloatingMeltRate")==0) return AutoregressionLinearFloatingMeltRateEnum;
               else if (strcmp(name,"Balancethickness2Analysis")==0) return Balancethickness2AnalysisEnum;
               else if (strcmp(name,"Balancethickness2Solution")==0) return Balancethickness2SolutionEnum;
@@ -1361 +1367 @@
               else if (strcmp(name,"ExternalResult")==0) return ExternalResultEnum;
               else if (strcmp(name,"ExtrapolationAnalysis")==0) return ExtrapolationAnalysisEnum;
-              else if (strcmp(name,"ExtrudeFromBaseAnalysis")==0) return ExtrudeFromBaseAnalysisEnum;
+         else stage=12;
+   }
+   if(stage==12){
+              if (strcmp(name,"ExtrudeFromBaseAnalysis")==0) return ExtrudeFromBaseAnalysisEnum;
               else if (strcmp(name,"ExtrudeFromTopAnalysis")==0) return ExtrudeFromTopAnalysisEnum;
               else if (strcmp(name,"FSApproximation")==0) return FSApproximationEnum;
@@ -1367 +1376 @@
               else if (strcmp(name,"FSpressure")==0) return FSpressureEnum;
               else if (strcmp(name,"FSvelocity")==0) return FSvelocityEnum;
-         else stage=12;
-   }
-   if(stage==12){
-              if (strcmp(name,"FemModel")==0) return FemModelEnum;
+              else if (strcmp(name,"FemModel")==0) return FemModelEnum;
               else if (strcmp(name,"FileParam")==0) return FileParamEnum;
               else if (strcmp(name,"FixedTimestepping")==0) return FixedTimesteppingEnum;
@@ -1381 +1387 @@
               else if (strcmp(name,"FrontalForcingsDefault")==0) return FrontalForcingsDefaultEnum;
               else if (strcmp(name,"FrontalForcingsRignot")==0) return FrontalForcingsRignotEnum;
-              else if (strcmp(name,"FrontalForcingsRignotAutoregression")==0) return FrontalForcingsRignotAutoregressionEnum;
+              else if (strcmp(name,"FrontalForcingsRignotarma")==0) return FrontalForcingsRignotarmaEnum;
               else if (strcmp(name,"Fset")==0) return FsetEnum;
               else if (strcmp(name,"FullMeltOnPartiallyFloating")==0) return FullMeltOnPartiallyFloatingEnum;
@@ -1450 +1456 @@
               else if (strcmp(name,"LevelsetfunctionPicard")==0) return LevelsetfunctionPicardEnum;
               else if (strcmp(name,"LinearFloatingMeltRate")==0) return LinearFloatingMeltRateEnum;
+              else if (strcmp(name,"LinearFloatingMeltRatearma")==0) return LinearFloatingMeltRatearmaEnum;
               else if (strcmp(name,"LliboutryDuval")==0) return LliboutryDuvalEnum;
               else if (strcmp(name,"Loads")==0) return LoadsEnum;
@@ -1483 +1490 @@
               else if (strcmp(name,"Matestar")==0) return MatestarEnum;
               else if (strcmp(name,"Matice")==0) return MaticeEnum;
-              else if (strcmp(name,"Matlitho")==0) return MatlithoEnum;
+         else stage=13;
+   }
+   if(stage==13){
+              if (strcmp(name,"Matlitho")==0) return MatlithoEnum;
               else if (strcmp(name,"Mathydro")==0) return MathydroEnum;
               else if (strcmp(name,"MatrixParam")==0) return MatrixParamEnum;
@@ -1490 +1500 @@
               else if (strcmp(name,"MaxAbsVz")==0) return MaxAbsVzEnum;
               else if (strcmp(name,"MaxDivergence")==0) return MaxDivergenceEnum;
-         else stage=13;
-   }
-   if(stage==13){
-              if (strcmp(name,"MaxVel")==0) return MaxVelEnum;
+              else if (strcmp(name,"MaxVel")==0) return MaxVelEnum;
               else if (strcmp(name,"MaxVx")==0) return MaxVxEnum;
               else if (strcmp(name,"MaxVy")==0) return MaxVyEnum;
@@ -1562 +1569 @@
               else if (strcmp(name,"SamplingSolution")==0) return SamplingSolutionEnum;
               else if (strcmp(name,"SIAApproximation")==0) return SIAApproximationEnum;
-              else if (strcmp(name,"SMBautoregression")==0) return SMBautoregressionEnum;
+              else if (strcmp(name,"SMBarma")==0) return SMBarmaEnum;
               else if (strcmp(name,"SMBcomponents")==0) return SMBcomponentsEnum;
               else if (strcmp(name,"SMBd18opdd")==0) return SMBd18opddEnum;
@@ -1606 +1613 @@
               else if (strcmp(name,"StatisticsSolution")==0) return StatisticsSolutionEnum;
               else if (strcmp(name,"SteadystateSolution")==0) return SteadystateSolutionEnum;
-              else if (strcmp(name,"StressIntensityFactor")==0) return StressIntensityFactorEnum;
+         else stage=14;
+   }
+   if(stage==14){
+              if (strcmp(name,"StressIntensityFactor")==0) return StressIntensityFactorEnum;
               else if (strcmp(name,"StressbalanceAnalysis")==0) return StressbalanceAnalysisEnum;
               else if (strcmp(name,"StressbalanceConvergenceNumSteps")==0) return StressbalanceConvergenceNumStepsEnum;
@@ -1613 +1623 @@
               else if (strcmp(name,"StressbalanceVerticalAnalysis")==0) return StressbalanceVerticalAnalysisEnum;
               else if (strcmp(name,"StringArrayParam")==0) return StringArrayParamEnum;
-         else stage=14;
-   }
-   if(stage==14){
-              if (strcmp(name,"StringExternalResult")==0) return StringExternalResultEnum;
+              else if (strcmp(name,"StringExternalResult")==0) return StringExternalResultEnum;
               else if (strcmp(name,"StringParam")==0) return StringParamEnum;
               else if (strcmp(name,"SubelementFriction1")==0) return SubelementFriction1Enum;

issm/trunk-jpl/src/c/shared/io/Marshalling/IoCodeConversions.cpp

@@ -241 +241 @@
                 case 11: return SMBgradientscomponentsEnum;
                 case 12: return SMBsemicEnum;   
-                case 13: return SMBautoregressionEnum;
+                case 13: return SMBarmaEnum;
                 default: _error_("Marshalled SMB code \""<<enum_in<<"\" not supported yet");
         }
@@ -255 +255 @@
                 case 7: return BasalforcingsIsmip6Enum;
                 case 8: return BeckmannGoosseFloatingMeltRateEnum;
-                case 9: return AutoregressionLinearFloatingMeltRateEnum;
+                case 9: return LinearFloatingMeltRatearmaEnum;
                 default: _error_("Marshalled Basal Forcings code \""<<enum_in<<"\" not supported yet");
         }
@@ -277 +277 @@
                 case 1: return FrontalForcingsDefaultEnum;
                 case 2: return FrontalForcingsRignotEnum;
-                case 3: return FrontalForcingsRignotAutoregressionEnum;
+                case 3: return FrontalForcingsRignotarmaEnum;
                 default: _error_("Marshalled Frontalforcings code \""<<enum_in<<"\" not supported yet");
         }

issm/trunk-jpl/test/NightlyRun/test257.m

@@ -1 @@
-%Test Name: SquareShelfSMBautoregression
+%Test Name: SquareShelfSMBarma
 md=triangle(model(),'../Exp/Square.exp',80000.);
 md=setmask(md,'all','');
@@ -36 +36 @@
 md.timestepping.time_step  = 1;
 md.timestepping.final_time = 5;
-md.smb                = SMBautoregression();
-md.smb.num_basins     = 3; %number of basins
-md.smb.basin_id       = idbasin; %prescribe basin ID number to elements
-md.smb.const          = [0.5,1.2,1.5]; %intercept values of SMB in basins [m ice eq./yr]
-md.smb.trend          = [0.0,0.01,-0.01]; %trend values of SMB in basins [m ice eq./yr^2]
-md.smb.ar_initialtime = md.timestepping.start_time;
-md.smb.ar_order       = 4;
-md.smb.ar_timestep    = 2.0; %timestep of the autoregressive model [yr]
-md.smb.arlag_coefs            = [[0.2,0.1,0.05,0.01];[0.4,0.2,-0.2,0.1];[0.4,-0.4,0.1,-0.1]];
-md.smb.lapserates     = [0.01,0.0;0.01,-0.01;0.0,-0.01];
-md.smb.elevationbins  = [100;150;100];
+md.smb                     = SMBarma();
+md.smb.num_basins          = 3; %number of basins
+md.smb.basin_id            = idbasin; %prescribe basin ID number to elements
+md.smb.const               = [0.5,1.2,1.5]; %intercept values of SMB in basins [m ice eq./yr]
+md.smb.trend               = [0.0,0.01,-0.01]; %trend values of SMB in basins [m ice eq./yr^2]
+md.smb.arma_initialtime    = md.timestepping.start_time;
+md.smb.ar_order            = 4;
+md.smb.ma_order            = 1;
+md.smb.arma_timestep       = 2.0; %timestep of the ARMA model [yr]
+md.smb.arlag_coefs         = [[0.2,0.1,0.05,0.01];[0.4,0.2,-0.2,0.1];[0.4,-0.4,0.1,-0.1]];
+md.smb.malag_coefs         = [0;0;0];
+md.smb.lapserates          = [0.01,0.0;0.01,-0.01;0.0,-0.01];
+md.smb.elevationbins       = [100;150;100];
 
 %Stochastic forcing
 md.stochasticforcing.isstochasticforcing = 1;
-md.stochasticforcing.fields              = [{'SMBautoregression'}];
+md.stochasticforcing.fields              = [{'SMBarma'}];
 md.stochasticforcing.covariance          = [[0.15 0.08 -0.02];[0.08 0.12 -0.05];[-0.02 -0.05 0.1]]; %global covariance among- and between-fields
 md.stochasticforcing.randomflag          = 0; %fixed random seeds

issm/trunk-jpl/test/NightlyRun/test257.py

@@ -1 @@
-#Test Name: SquareShelfSMBautoregression
+#Test Name: SquareShelfSMBarma
 from __future__ import division  # TODO: Remove this import after ISSM is updated to use Python 3 by default
 import numpy as np
@@ -7 +7 @@
 from setflowequation import setflowequation
 from setmask import setmask
-from SMBautoregression import SMBautoregression
+from SMBarma import SMBarma
 from solve import solve
 from triangle import triangle
@@ -41 +41 @@
 md.timestepping.time_step = 1
 md.timestepping.final_time = 5
-md.smb = SMBautoregression()
+md.smb = SMBarma()
 md.smb.num_basins = 3  # number of basins
 md.smb.basin_id = idbasin  # prescribe basin ID number to elements;
 md.smb.const = np.array([[0.5, 1.2, 1.5]])  # intercept values of SMB in basins [m ice eq./yr]
 md.smb.trend = np.array([[0.0, 0.01, -0.01]])  # trend values of SMB in basins [m ice eq./yr^2]
-md.smb.ar_initialtime = md.timestepping.start_time
+md.smb.arma_initialtime = md.timestepping.start_time
 md.smb.ar_order = 4
-md.smb.ar_timestep = 2.0  #timestep of the autoregressive model [yr]
+md.smb.ma_order = 1
+md.smb.arma_timestep = 2.0  #timestep of the ARMA model [yr]
 md.smb.arlag_coefs = np.array([[0.2, 0.1, 0.05, 0.01], [0.4, 0.2, -0.2, 0.1], [0.4, -0.4, 0.1, -0.1]])
+md.smb.malag_coefs = np.array([[0],[0],[0]])
 md.smb.lapserates        = np.array([[0.01,0.0],[0.01,-0.01],[0.0,-0.01]])
 md.smb.elevationbins  = np.array([100,150,100]).reshape(md.smb.num_basins,1)
@@ -55 +57 @@
 # Stochastic forcing
 md.stochasticforcing.isstochasticforcing = 1
-md.stochasticforcing.fields = ['SMBautoregression']
+md.stochasticforcing.fields = ['SMBarma']
 md.stochasticforcing.covariance = np.array([[0.15, 0.08, -0.02], [0.08, 0.12, -0.05], [-0.02, -0.05, 0.1]])  # global covariance among- and between-fields
 md.stochasticforcing.randomflag = 0  # fixed random seeds

issm/trunk-jpl/test/NightlyRun/test543.m

@@ -45 +45 @@
 md.levelset.migration_max = 10.0; %avoid fast advance/retreat of the front
 %Frontal forcing parameters
-md.frontalforcings=frontalforcingsrignotautoregression();
+md.frontalforcings=frontalforcingsrignotarma();
 md.frontalforcings.num_basins           = nb_tf;
 md.frontalforcings.basin_id             = idb_tf;
@@ -51 +51 @@
 md.frontalforcings.const                = [0.05,0.01]; %intercept values of TF in basins [C]
 md.frontalforcings.trend                = [0.001,0.0001]; %trend values of TF in basins [C/yr]
-md.frontalforcings.ar_initialtime       = md.timestepping.start_time; %initial time in the AR model parameterization [yr]
+md.frontalforcings.arma_initialtime     = md.timestepping.start_time; %initial time in the AR model parameterization [yr]
 md.frontalforcings.ar_order             = 4;
-md.frontalforcings.ar_timestep          = 2; %timestep of the autoregressive model [yr]
-md.frontalforcings.arlag_coefs                  = [[0.1,-0.1,0.01,-0.01];[0.2,-0.2,0.1,0.0]]; %autoregressive parameters
+md.frontalforcings.ma_order             = 2;
+md.frontalforcings.arma_timestep        = 2; %timestep of the ARMA model [yr]
+md.frontalforcings.arlag_coefs          = [[0.1,-0.1,0.01,-0.01];[0.2,-0.2,0.1,0.0]]; %autoregressive parameters
+md.frontalforcings.malag_coefs          = [[0.0,0.0];[0.0,0.0]]; %moving-average parameters
 
 % Floating Ice Melt parameters
@@ -68 +70 @@
 %Stochastic forcing
 md.stochasticforcing.isstochasticforcing = 1;
-md.stochasticforcing.fields              = [{'FrontalForcingsRignotAutoregression'},{'DefaultCalving'},{'FloatingMeltRate'}];
+md.stochasticforcing.fields              = [{'FrontalForcingsRignotarma'},{'DefaultCalving'},{'FloatingMeltRate'}];
 md.stochasticforcing.defaultdimension    = 2;
 md.stochasticforcing.default_id          = idb_df;

issm/trunk-jpl/test/NightlyRun/test543.py

@@ -1 +1 @@
 #Test Name: PigTranStochasticforcing
 import numpy as np
-from frontalforcingsrignotautoregression import frontalforcingsrignotautoregression
+from frontalforcingsrignotarma import frontalforcingsrignotarma
 from socket import gethostname
 from model import *
@@ -50 +50 @@
 md.levelset.migration_max = 10.0
 #Frontal forcing parameters
-md.frontalforcings = frontalforcingsrignotautoregression()
+md.frontalforcings = frontalforcingsrignotarma()
 md.frontalforcings.num_basins = nb_tf
 md.frontalforcings.basin_id = idb_tf
@@ -56 +56 @@
 md.frontalforcings.const = np.array([[0.05, 0.01]])  # intercept values of TF in basins [C]
 md.frontalforcings.trend = np.array([[0.001, 0.0001]])  # trend values of TF in basins [C/yr]
-md.frontalforcings.ar_initialtime = md.timestepping.start_time  # initial time in the AR model parameterization [yr]
+md.frontalforcings.arma_initialtime = md.timestepping.start_time  # initial time in the AR model parameterization [yr]
 md.frontalforcings.ar_order = 4
-md.frontalforcings.ar_timestep = 2  # timestep of the autoregressive model [yr]
+md.frontalforcings.ma_order = 2
+md.frontalforcings.arma_timestep = 2  # timestep of the ARMA model [yr]
 md.frontalforcings.arlag_coefs = np.array([[0.1, -0.1, 0.01, -0.01], [0.2, -0.2, 0.1, 0.0]])  # autoregressive parameters
+md.frontalforcings.malag_coefs = np.array([[0.0, 0.0], [0.0, 0.0]])  # moving-average parameters
 #Floating Ice Melt parameters
 md.basalforcings.floatingice_melting_rate = 0.1 * np.ones((md.mesh.numberofvertices,))
@@ -85 +87 @@
 # Stochastic forcing
 md.stochasticforcing.isstochasticforcing = 1
-md.stochasticforcing.fields = ['FrontalForcingsRignotAutoregression', 'DefaultCalving', 'FloatingMeltRate']
+md.stochasticforcing.fields = ['FrontalForcingsRignotarma', 'DefaultCalving', 'FloatingMeltRate']
 md.stochasticforcing.defaultdimension = 2
 md.stochasticforcing.default_id = idb_df

issm/trunk-jpl/test/NightlyRun/test544.m

@@ -1 @@
-%Test Name: PigTranAutoregressionAndStochasticforcings 
+%Test Name: PigTranARMAandStochasticforcings 
 md=triangle(model(),'../Exp/Pig.exp',8000.);
 md=setmask(md,'../Exp/PigShelves.exp','../Exp/PigIslands.exp');
@@ -24 +24 @@
 
 %SMB
-md.smb                = SMBautoregression();
-md.smb.num_basins     = nb_bas; %number of basins
-md.smb.basin_id       = idb; %prescribe basin ID number to elements
-md.smb.const          = [0.5,1.2]; %intercept values of SMB in basins [m ice eq./yr]
-md.smb.trend          = [0.0,0.01]; %trend values of SMB in basins [m ice eq./yr^2]
-md.smb.ar_initialtime = md.timestepping.start_time;
-md.smb.ar_order       = 4;
-md.smb.ar_timestep    = 2.0; %timestep of the autoregressive model [yr]
-md.smb.arlag_coefs            = [[0.2,0.1,0.05,0.01];[0.4,0.2,-0.2,0.1]];
+md.smb                  = SMBarma();
+md.smb.num_basins       = nb_bas; %number of basins
+md.smb.basin_id         = idb; %prescribe basin ID number to elements
+md.smb.const            = [0.5,1.2]; %intercept values of SMB in basins [m ice eq./yr]
+md.smb.trend            = [0.0,0.01]; %trend values of SMB in basins [m ice eq./yr^2]
+md.smb.arma_initialtime = md.timestepping.start_time;
+md.smb.ar_order         = 4;
+md.smb.ma_order         = 4;
+md.smb.arma_timestep    = 2.0; %timestep of the ARMA model [yr]
+md.smb.arlag_coefs      = [[0.2,0.1,0.05,0.01];[0.4,0.2,-0.2,0.1]];
+md.smb.malag_coefs      = [[0.0,0.0,0.0,0.0];[0.0,0.0,0.0,0.0]];
 
 %Calving
@@ -42 +44 @@
 
 % Basal forcing implementation
-md.basalforcings = autoregressionlinearbasalforcings();
-md.basalforcings.num_basins     = nb_bas; %number of basins
-md.basalforcings.basin_id       = idb; %prescribe basin ID number to elements
-md.basalforcings.const          = [1.0,2.50]; %intercept values of DeepwaterMelt in basins [m/yr]
-md.basalforcings.trend          = [0.2,0.01]; %trend values of DeepwaterMelt in basins [m/yr^2]
-md.basalforcings.ar_initialtime = md.timestepping.start_time;
-md.basalforcings.ar_order       = 1;
-md.basalforcings.ar_timestep    = 1.0; %timestep of the autoregressive model [yr]
-md.basalforcings.arlag_coefs            = [0.0;0.1];
+md.basalforcings = linearbasalforcingsarma();
+md.basalforcings.num_basins       = nb_bas; %number of basins
+md.basalforcings.basin_id         = idb; %prescribe basin ID number to elements
+md.basalforcings.const            = [1.0,2.50]; %intercept values of DeepwaterMelt in basins [m/yr]
+md.basalforcings.trend            = [0.2,0.01]; %trend values of DeepwaterMelt in basins [m/yr^2]
+md.basalforcings.arma_initialtime = md.timestepping.start_time;
+md.basalforcings.ar_order         = 1;
+md.basalforcings.ma_order         = 1;
+md.basalforcings.arma_timestep    = 1.0; %timestep of the ARMA model [yr]
+md.basalforcings.arlag_coefs      = [0.0;0.1];
+md.basalforcings.malag_coefs      = [0.0;0.0];
 md.basalforcings.deepwater_elevation       = [-1000,-1520];
 md.basalforcings.upperwater_elevation      = [0,-50];
@@ -65 +69 @@
 % Stochastic forcing
 md.stochasticforcing.isstochasticforcing = 1;
-md.stochasticforcing.fields              = [{'SMBautoregression'},{'DefaultCalving'},{'BasalforcingsDeepwaterMeltingRateAutoregression'}];
+md.stochasticforcing.fields              = [{'SMBarma'},{'DefaultCalving'},{'BasalforcingsDeepwaterMeltingRatearma'}];
 md.stochasticforcing.defaultdimension    = 2;
 md.stochasticforcing.default_id          = idb;

issm/trunk-jpl/test/NightlyRun/test544.py

@@ -1 @@
-#Test Name: PigTranAutoregressionAndStochasticforcings
+#Test Name: PigTranARMAandStochasticforcings
 import numpy as np
-from autoregressionlinearbasalforcings import autoregressionlinearbasalforcings
-from SMBautoregression import SMBautoregression
+from linearbasalforcingsarma import linearbasalforcingsarma
+from SMBarma import SMBarma
 from stochasticforcing import stochasticforcing
 from socket import gethostname
@@ -34 +34 @@
 
 #SMB
-md.smb = SMBautoregression()
+md.smb = SMBarma()
 md.smb.num_basins = nb_bas  # number of basins
 md.smb.basin_id = idb  # prescribe basin ID number to elements;
 md.smb.const = np.array([[0.5, 1.2]])  # intercept values of SMB in basins [m ice eq./yr]
 md.smb.trend = np.array([[0.0, 0.01]])  # trend values of SMB in basins [m ice eq./yr^2]
-md.smb.ar_initialtime = md.timestepping.start_time
+md.smb.arma_initialtime = md.timestepping.start_time
 md.smb.ar_order = 4
-md.smb.ar_timestep = 2.0  #timestep of the autoregressive model [yr]
-md.smb.arlag_coefs = np.array([[0.2, 0.1, 0.05, 0.01], [0.4, 0.2, -0.2, 0.1]])
+md.smb.ma_order = 4
+md.smb.arma_timestep = 2.0  #timestep of the ARMA model [yr]
+md.smb.arlag_coefs = np.array([[0.2,0.1,0.05,0.01],[0.4,0.2,-0.2,0.1]])
+md.smb.malag_coefs = np.array([[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0]])
 
 #Calving
@@ -52 +54 @@
 
 #Basal forcing implementation
-md.basalforcings = autoregressionlinearbasalforcings()
+md.basalforcings = linearbasalforcingsarma()
 md.basalforcings.num_basins = nb_bas
 md.basalforcings.basin_id  = idb
 md.basalforcings.const = np.array([[1.0, 2.50]])  # intercept values of DeepwaterMelt in basins [m/yr]
 md.basalforcings.trend  = np.array([[0.2, 0.01]])  # trend values of DeepwaterMelt in basins [m/yr^2]
-md.basalforcings.ar_initialtime = md.timestepping.start_time  # initial time in the AR model parameterization [yr]
+md.basalforcings.arma_initialtime = md.timestepping.start_time  # initial time in the ARMA model parameterization [yr]
 md.basalforcings.ar_order  = 1
-md.basalforcings.ar_timestep  = 1.0  # timestep of the autoregressive model [yr]
+md.basalforcings.ma_order  = 1
+md.basalforcings.arma_timestep  = 1.0  # timestep of the ARMA model [yr]
 md.basalforcings.arlag_coefs  = np.array([[0.0], [0.1]])  # autoregressive parameters
+md.basalforcings.malag_coefs  = np.array([[0.0], [0.0]])  # moving-average parameters
 md.basalforcings.deepwater_elevation = np.array([[-1000, -1520]])
 md.basalforcings.upperwater_elevation = np.array([[0, -50]])
@@ -76 +80 @@
 #Stochastic forcing
 md.stochasticforcing.isstochasticforcing = 1
-md.stochasticforcing.fields = ['SMBautoregression', 'DefaultCalving', 'BasalforcingsDeepwaterMeltingRateAutoregression']
+md.stochasticforcing.fields = ['SMBarma', 'DefaultCalving', 'BasalforcingsDeepwaterMeltingRatearma']
 md.stochasticforcing.defaultdimension = 2
 md.stochasticforcing.default_id = idb