Index: /issm/trunk-jpl/src/c/analyses/LevelsetAnalysis.cpp =================================================================== --- /issm/trunk-jpl/src/c/analyses/LevelsetAnalysis.cpp (revision 27249) +++ /issm/trunk-jpl/src/c/analyses/LevelsetAnalysis.cpp (revision 27250) @@ -149,8 +149,8 @@ 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,17 +238,20 @@ 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(transparam); iomodel->FetchData(&transparam,&M,&N,"md.frontalforcings.trend"); - parameters->AddObject(new DoubleVecParam(FrontalForcingsautoregressiontrendEnum,transparam,N)); + parameters->AddObject(new DoubleVecParam(FrontalForcingsARMAtrendEnum,transparam,N)); xDelete(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(transparam); + iomodel->FetchData(&transparam,&M,&N,"md.frontalforcings.malag_coefs"); + parameters->AddObject(new DoubleMatParam(FrontalForcingsARMAmalagcoefsEnum,transparam,M,N)); xDelete(transparam); /*Do not break here, generic FrontalForcingsRignot parameters still to be retrieved*/ Index: /issm/trunk-jpl/src/c/analyses/MasstransportAnalysis.cpp =================================================================== --- /issm/trunk-jpl/src/c/analyses/MasstransportAnalysis.cpp (revision 27249) +++ /issm/trunk-jpl/src/c/analyses/MasstransportAnalysis.cpp (revision 27250) @@ -219,5 +219,5 @@ 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); Index: /issm/trunk-jpl/src/c/analyses/SmbAnalysis.cpp =================================================================== --- /issm/trunk-jpl/src/c/analyses/SmbAnalysis.cpp (revision 27249) +++ /issm/trunk-jpl/src/c/analyses/SmbAnalysis.cpp (revision 27250) @@ -185,5 +185,5 @@ 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,5 +388,5 @@ /*Nothing to add to parameters*/ break; - case SMBautoregressionEnum: + case SMBarmaEnum: /*Nothing to add to parameters*/ break; @@ -483,7 +483,7 @@ 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: Index: /issm/trunk-jpl/src/c/classes/Elements/Element.cpp =================================================================== --- /issm/trunk-jpl/src/c/classes/Elements/Element.cpp (revision 27249) +++ /issm/trunk-jpl/src/c/classes/Elements/Element.cpp (revision 27250) @@ -61,4 +61,6 @@ 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,17 +75,17 @@ /*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,5 +102,5 @@ /*Get basin coefficients*/ this->GetInputValue(&basinid,basinenum_type); - for(int ii=0;iiGetInput(noiseenum_type); Gauss* gauss = this->NewGauss(); Index: /issm/trunk-jpl/src/c/classes/Elements/Element.h =================================================================== --- /issm/trunk-jpl/src/c/classes/Elements/Element.h (revision 27249) +++ /issm/trunk-jpl/src/c/classes/Elements/Element.h (revision 27250) @@ -68,4 +68,5 @@ /*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); Index: /issm/trunk-jpl/src/c/modules/FloatingiceMeltingRatex/FloatingiceMeltingRatex.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/FloatingiceMeltingRatex/FloatingiceMeltingRatex.cpp (revision 27249) +++ /issm/trunk-jpl/src/c/modules/FloatingiceMeltingRatex/FloatingiceMeltingRatex.cpp (revision 27250) @@ -46,7 +46,7 @@ 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,18 +210,18 @@ } /*}}}*/ -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)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,8 +244,8 @@ /*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,10 +262,10 @@ femmodel->parameters->FindParam(&stochasticfields,&N,StochasticForcingFieldsEnum); _assert_(N==numstochasticfields); for(int i=0;i(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,5 +273,5 @@ Element* element = xDynamicCast(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,5 +280,5 @@ xDelete(termconstant); xDelete(trend); - xDelete(lagcoefs); + xDelete(arlagcoefs); xDelete(deepwaterel); xDelete(upperwaterel); Index: /issm/trunk-jpl/src/c/modules/FloatingiceMeltingRatex/FloatingiceMeltingRatex.h =================================================================== --- /issm/trunk-jpl/src/c/modules/FloatingiceMeltingRatex/FloatingiceMeltingRatex.h (revision 27249) +++ /issm/trunk-jpl/src/c/modules/FloatingiceMeltingRatex/FloatingiceMeltingRatex.h (revision 27250) @@ -16,5 +16,5 @@ void FloatingiceMeltingRateIsmip6x(FemModel* femmodel); void BeckmannGoosseFloatingiceMeltingRatex(FemModel* femmodel); -void AutoregressionLinearFloatingiceMeltingRatex(FemModel* femmodel); +void LinearFloatingiceMeltingRatearmax(FemModel* femmodel); #endif /* _FloatingiceMeltingRatex_H*/ Index: /issm/trunk-jpl/src/c/modules/FrontalForcingsx/FrontalForcingsx.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/FrontalForcingsx/FrontalForcingsx.cpp (revision 27249) +++ /issm/trunk-jpl/src/c/modules/FrontalForcingsx/FrontalForcingsx.cpp (revision 27250) @@ -18,6 +18,6 @@ case FrontalForcingsDefaultEnum: break; - case FrontalForcingsRignotAutoregressionEnum: - Thermalforcingautoregressionx(femmodel); + case FrontalForcingsRignotarmaEnum: + Thermalforcingarmax(femmodel); /*Do not break here, call IcefrontAreax(),RignotMeltParameterizationx()*/ case FrontalForcingsRignotEnum: @@ -29,18 +29,18 @@ } }/*}}}*/ -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)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,15 +70,15 @@ femmodel->parameters->FindParam(&stochasticfields,&N,StochasticForcingFieldsEnum); _assert_(N==numstochasticfields); for(int i=0;i(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(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,4 +86,4 @@ xDelete(termconstant); xDelete(trend); - xDelete(lagcoefs); + xDelete(arlagcoefs); }/*}}}*/ Index: /issm/trunk-jpl/src/c/modules/FrontalForcingsx/FrontalForcingsx.h =================================================================== --- /issm/trunk-jpl/src/c/modules/FrontalForcingsx/FrontalForcingsx.h (revision 27249) +++ /issm/trunk-jpl/src/c/modules/FrontalForcingsx/FrontalForcingsx.h (revision 27250) @@ -7,5 +7,5 @@ /* local prototypes: */ void FrontalForcingsx(FemModel* femmodel); -void Thermalforcingautoregressionx(FemModel* femmodel); +void Thermalforcingarmax(FemModel* femmodel); #endif Index: /issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateParameters.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateParameters.cpp (revision 27249) +++ /issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateParameters.cpp (revision 27250) @@ -254,18 +254,22 @@ 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(transparam); iomodel->FetchData(&transparam,&M,&N,"md.basalforcings.trend"); - parameters->AddObject(new DoubleVecParam(BasalforcingsautoregressiontrendEnum,transparam,N)); + parameters->AddObject(new DoubleVecParam(BasalforcingsARMAtrendEnum,transparam,N)); xDelete(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(transparam); + iomodel->FetchData(&transparam,&M,&N,"md.basalforcings.malag_coefs"); + parameters->AddObject(new DoubleMatParam(BasalforcingsARMAmalagcoefsEnum,transparam,M,N)); xDelete(transparam); iomodel->FetchData(&transparam,&M,&N,"md.basalforcings.upperwater_melting_rate"); @@ -425,19 +429,24 @@ /*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(transparam); iomodel->FetchData(&transparam,&M,&N,"md.smb.trend"); - parameters->AddObject(new DoubleVecParam(SmbautoregressiontrendEnum,transparam,N)); + parameters->AddObject(new DoubleVecParam(SmbARMAtrendEnum,transparam,N)); xDelete(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(transparam); + iomodel->FetchData(&transparam,&M,&N,"md.smb.malag_coefs"); + parameters->AddObject(new DoubleMatParam(SmbARMAmalagcoefsEnum,transparam,M,N)); xDelete(transparam); iomodel->FetchData(&transparam,&M,&N,"md.smb.lapserates"); Index: /issm/trunk-jpl/src/c/modules/StochasticForcingx/StochasticForcingx.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/StochasticForcingx/StochasticForcingx.cpp (revision 27249) +++ /issm/trunk-jpl/src/c/modules/StochasticForcingx/StochasticForcingx.cpp (revision 27250) @@ -75,16 +75,16 @@ 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,7 +103,7 @@ else{ switch(fields[j]){ - case SMBautoregressionEnum: - case FrontalForcingsRignotAutoregressionEnum: - case BasalforcingsDeepwaterMeltingRateAutoregressionEnum: + case SMBarmaEnum: + case FrontalForcingsRignotarmaEnum: + case BasalforcingsDeepwaterMeltingRatearmaEnum: /*Already done above*/ break; Index: /issm/trunk-jpl/src/c/modules/SurfaceMassBalancex/SurfaceMassBalancex.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/SurfaceMassBalancex/SurfaceMassBalancex.cpp (revision 27249) +++ /issm/trunk-jpl/src/c/modules/SurfaceMassBalancex/SurfaceMassBalancex.cpp (revision 27250) @@ -147,18 +147,18 @@ }/*}}}*/ -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)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,16 +195,16 @@ femmodel->parameters->FindParam(&stochasticfields,&N,StochasticForcingFieldsEnum); _assert_(N==numstochasticfields); for(int i=0;i(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(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,5 +214,5 @@ xDelete(termconstant); xDelete(trend); - xDelete(lagcoefs); + xDelete(arlagcoefs); xDelete(lapserates); xDelete(elevbins); Index: /issm/trunk-jpl/src/c/modules/SurfaceMassBalancex/SurfaceMassBalancex.h =================================================================== --- /issm/trunk-jpl/src/c/modules/SurfaceMassBalancex/SurfaceMassBalancex.h (revision 27249) +++ /issm/trunk-jpl/src/c/modules/SurfaceMassBalancex/SurfaceMassBalancex.h (revision 27250) @@ -13,5 +13,5 @@ void SmbGradientsx(FemModel* femmodel); void SmbGradientsElax(FemModel* femmodel); -void Smbautoregressionx(FemModel* femmodel); +void Smbarmax(FemModel* femmodel); void Delta18oParameterizationx(FemModel* femmodel); void MungsmtpParameterizationx(FemModel* femmodel); Index: /issm/trunk-jpl/src/c/shared/Enum/Enum.vim =================================================================== --- /issm/trunk-jpl/src/c/shared/Enum/Enum.vim (revision 27249) +++ /issm/trunk-jpl/src/c/shared/Enum/Enum.vim (revision 27250) @@ -67,9 +67,10 @@ 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,5 +90,6 @@ 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,12 +198,14 @@ 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,10 +478,11 @@ 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,5 +521,6 @@ 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,5 +637,5 @@ 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,5 +960,5 @@ 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,4 +1049,5 @@ syn keyword cConstant SmbTzEnum syn keyword cConstant SmbValuesAutoregressionEnum +syn keyword cConstant SmbValuesMovingaverageEnum syn keyword cConstant SmbVEnum syn keyword cConstant SmbVmeanEnum @@ -1093,5 +1100,5 @@ 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,5 +1256,4 @@ syn keyword cConstant ArrheniusEnum syn keyword cConstant AutodiffJacobianEnum -syn keyword cConstant AutoregressionLinearFloatingMeltRateEnum syn keyword cConstant Balancethickness2AnalysisEnum syn keyword cConstant Balancethickness2SolutionEnum @@ -1346,5 +1352,5 @@ 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,4 +1421,5 @@ syn keyword cConstant LevelsetfunctionPicardEnum syn keyword cConstant LinearFloatingMeltRateEnum +syn keyword cConstant LinearFloatingMeltRatearmaEnum syn keyword cConstant LliboutryDuvalEnum syn keyword cConstant LoadsEnum @@ -1524,5 +1531,5 @@ 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,4 +1654,5 @@ syn keyword cType Cfsurfacesquare syn keyword cType Channel +syn keyword cType classes syn keyword cType Constraint syn keyword cType Constraints @@ -1653,6 +1661,6 @@ 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,6 +1675,6 @@ 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,9 +1683,10 @@ 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,4 +1705,5 @@ syn keyword cType IssmDirectApplicInterface syn keyword cType IssmParallelDirectApplicInterface +syn keyword cType krigingobjects syn keyword cType Load syn keyword cType Loads @@ -1706,4 +1716,5 @@ syn keyword cType Matice syn keyword cType Matlitho +syn keyword cType matrixobjects syn keyword cType MatrixParam syn keyword cType Misfit @@ -1718,6 +1729,6 @@ 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,11 +1744,11 @@ 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,8 +1769,4 @@ 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 Index: /issm/trunk-jpl/src/c/shared/Enum/EnumDefinitions.h =================================================================== --- /issm/trunk-jpl/src/c/shared/Enum/EnumDefinitions.h (revision 27249) +++ /issm/trunk-jpl/src/c/shared/Enum/EnumDefinitions.h (revision 27250) @@ -61,9 +61,10 @@ BalancethicknessStabilizationEnum, BarystaticContributionsEnum, - BasalforcingsAutoregressionInitialTimeEnum, - BasalforcingsAutoregressionTimestepEnum, - BasalforcingsAutoregressiveOrderEnum, - BasalforcingsautoregressionconstEnum, - BasalforcingsautoregressiontrendEnum, + BasalforcingsARMAInitialTimeEnum, + BasalforcingsARMATimestepEnum, + BasalforcingsARMAarOrderEnum, + BasalforcingsARMAmaOrderEnum, + BasalforcingsARMAconstEnum, + BasalforcingsARMAtrendEnum, BasalforcingsBottomplumedepthEnum, BasalforcingsCrustthicknessEnum, @@ -83,5 +84,6 @@ BasalforcingsMantleconductivityEnum, BasalforcingsNusseltEnum, - BasalforcingsarlagcoefsEnum, + BasalforcingsARMAarlagcoefsEnum, + BasalforcingsARMAmalagcoefsEnum, BasalforcingsPicoAverageOverturningEnum, BasalforcingsPicoAverageSalinityEnum, @@ -190,12 +192,14 @@ FrictionVoidRatioEnum, FrontalForcingsBasinIcefrontAreaEnum, - FrontalForcingsAutoregressionInitialTimeEnum, - FrontalForcingsAutoregressionTimestepEnum, - FrontalForcingsAutoregressiveOrderEnum, - FrontalForcingsautoregressionconstEnum, - FrontalForcingsautoregressiontrendEnum, + FrontalForcingsARMAInitialTimeEnum, + FrontalForcingsARMATimestepEnum, + FrontalForcingsARMAarOrderEnum, + FrontalForcingsARMAmaOrderEnum, + FrontalForcingsARMAconstEnum, + FrontalForcingsARMAtrendEnum, FrontalForcingsNumberofBasinsEnum, FrontalForcingsParamEnum, - FrontalForcingsarlagcoefsEnum, + FrontalForcingsARMAarlagcoefsEnum, + FrontalForcingsARMAmalagcoefsEnum, GrdModelEnum, GroundinglineFrictionInterpolationEnum, @@ -468,10 +472,11 @@ SmbAccurefEnum, SmbAdThreshEnum, - SmbAutoregressionInitialTimeEnum, - SmbAutoregressionTimestepEnum, - SmbAutoregressiveOrderEnum, + SmbARMAInitialTimeEnum, + SmbARMATimestepEnum, + SmbARMAarOrderEnum, + SmbARMAmaOrderEnum, SmbAveragingEnum, - SmbautoregressionconstEnum, - SmbautoregressiontrendEnum, + SmbARMAconstEnum, + SmbARMAtrendEnum, SmbDesfacEnum, SmbDpermilEnum, @@ -510,5 +515,6 @@ SmbNumRequestedOutputsEnum, SmbPfacEnum, - SmbarlagcoefsEnum, + SmbARMAarlagcoefsEnum, + SmbARMAmalagcoefsEnum, SmbRdlEnum, SmbRefElevationEnum, @@ -627,5 +633,5 @@ BalancethicknessThickeningRateEnum, BasalCrevasseEnum, - BasalforcingsDeepwaterMeltingRateAutoregressionEnum, + BasalforcingsDeepwaterMeltingRatearmaEnum, BasalforcingsDeepwaterMeltingRateNoiseEnum, BasalforcingsDeepwaterMeltingRateValuesAutoregressionEnum, @@ -950,5 +956,5 @@ SmbAdiffiniEnum, SmbAiniEnum, - SmbAutoregressionNoiseEnum, + SmbARMANoiseEnum, SmbBasinsIdEnum, SmbBMaxEnum, @@ -1040,4 +1046,5 @@ SmbTzEnum, SmbValuesAutoregressionEnum, + SmbValuesMovingaverageEnum, SmbVEnum, SmbVmeanEnum, @@ -1090,5 +1097,5 @@ TemperaturePicardEnum, TemperatureSEMICEnum, - ThermalforcingAutoregressionNoiseEnum, + ThermalforcingARMANoiseEnum, ThermalforcingValuesAutoregressionEnum, ThermalSpctemperatureEnum, @@ -1248,5 +1255,4 @@ ArrheniusEnum, AutodiffJacobianEnum, - AutoregressionLinearFloatingMeltRateEnum, Balancethickness2AnalysisEnum, Balancethickness2SolutionEnum, @@ -1345,5 +1351,5 @@ FrontalForcingsDefaultEnum, FrontalForcingsRignotEnum, - FrontalForcingsRignotAutoregressionEnum, + FrontalForcingsRignotarmaEnum, FsetEnum, FullMeltOnPartiallyFloatingEnum, @@ -1414,4 +1420,5 @@ LevelsetfunctionPicardEnum, LinearFloatingMeltRateEnum, + LinearFloatingMeltRatearmaEnum, LliboutryDuvalEnum, LoadsEnum, @@ -1523,5 +1530,5 @@ SamplingSolutionEnum, SIAApproximationEnum, - SMBautoregressionEnum, + SMBarmaEnum, SMBcomponentsEnum, SMBd18opddEnum, Index: /issm/trunk-jpl/src/c/shared/Enum/EnumToStringx.cpp =================================================================== --- /issm/trunk-jpl/src/c/shared/Enum/EnumToStringx.cpp (revision 27249) +++ /issm/trunk-jpl/src/c/shared/Enum/EnumToStringx.cpp (revision 27250) @@ -69,9 +69,10 @@ 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,5 +92,6 @@ 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,12 +200,14 @@ 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,10 +480,11 @@ 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,5 +523,6 @@ 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,5 +639,5 @@ 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,5 +962,5 @@ 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,4 +1051,5 @@ case SmbTzEnum : return "SmbTz"; case SmbValuesAutoregressionEnum : return "SmbValuesAutoregression"; + case SmbValuesMovingaverageEnum : return "SmbValuesMovingaverage"; case SmbVEnum : return "SmbV"; case SmbVmeanEnum : return "SmbVmean"; @@ -1095,5 +1102,5 @@ 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,5 +1258,4 @@ case ArrheniusEnum : return "Arrhenius"; case AutodiffJacobianEnum : return "AutodiffJacobian"; - case AutoregressionLinearFloatingMeltRateEnum : return "AutoregressionLinearFloatingMeltRate"; case Balancethickness2AnalysisEnum : return "Balancethickness2Analysis"; case Balancethickness2SolutionEnum : return "Balancethickness2Solution"; @@ -1348,5 +1354,5 @@ 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,4 +1423,5 @@ case LevelsetfunctionPicardEnum : return "LevelsetfunctionPicard"; case LinearFloatingMeltRateEnum : return "LinearFloatingMeltRate"; + case LinearFloatingMeltRatearmaEnum : return "LinearFloatingMeltRatearma"; case LliboutryDuvalEnum : return "LliboutryDuval"; case LoadsEnum : return "Loads"; @@ -1526,5 +1533,5 @@ case SamplingSolutionEnum : return "SamplingSolution"; case SIAApproximationEnum : return "SIAApproximation"; - case SMBautoregressionEnum : return "SMBautoregression"; + case SMBarmaEnum : return "SMBarma"; case SMBcomponentsEnum : return "SMBcomponents"; case SMBd18opddEnum : return "SMBd18opdd"; Index: /issm/trunk-jpl/src/c/shared/Enum/Enumjl.vim =================================================================== --- /issm/trunk-jpl/src/c/shared/Enum/Enumjl.vim (revision 27249) +++ /issm/trunk-jpl/src/c/shared/Enum/Enumjl.vim (revision 27250) @@ -60,9 +60,10 @@ 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,5 +83,6 @@ 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,12 +191,14 @@ 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,10 +471,11 @@ 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,5 +514,6 @@ 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,5 +630,5 @@ 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,5 +870,5 @@ 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,5 +953,5 @@ 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,4 +1042,5 @@ syn keyword juliaConstC SmbTzEnum syn keyword juliaConstC SmbValuesAutoregressionEnum +syn keyword juliaConstC SmbValuesMovingaverageEnum syn keyword juliaConstC SmbVEnum syn keyword juliaConstC SmbVmeanEnum @@ -1086,5 +1093,5 @@ 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,5 +1249,4 @@ syn keyword juliaConstC ArrheniusEnum syn keyword juliaConstC AutodiffJacobianEnum -syn keyword juliaConstC AutoregressionLinearFloatingMeltRateEnum syn keyword juliaConstC Balancethickness2AnalysisEnum syn keyword juliaConstC Balancethickness2SolutionEnum @@ -1339,5 +1345,5 @@ 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,4 +1414,5 @@ syn keyword juliaConstC LevelsetfunctionPicardEnum syn keyword juliaConstC LinearFloatingMeltRateEnum +syn keyword juliaConstC LinearFloatingMeltRatearmaEnum syn keyword juliaConstC LliboutryDuvalEnum syn keyword juliaConstC LoadsEnum @@ -1517,5 +1524,5 @@ syn keyword juliaConstC SamplingSolutionEnum syn keyword juliaConstC SIAApproximationEnum -syn keyword juliaConstC SMBautoregressionEnum +syn keyword juliaConstC SMBarmaEnum syn keyword juliaConstC SMBcomponentsEnum syn keyword juliaConstC SMBd18opddEnum Index: /issm/trunk-jpl/src/c/shared/Enum/StringToEnumx.cpp =================================================================== --- /issm/trunk-jpl/src/c/shared/Enum/StringToEnumx.cpp (revision 27249) +++ /issm/trunk-jpl/src/c/shared/Enum/StringToEnumx.cpp (revision 27250) @@ -69,9 +69,10 @@ 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,5 +92,6 @@ 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,10 +137,10 @@ 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,12 +203,14 @@ 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,12 +260,12 @@ 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,12 +383,12 @@ 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,10 +489,11 @@ 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,13 +506,13 @@ 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,5 +535,6 @@ 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,5 +629,8 @@ 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,8 +638,5 @@ 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,5 +654,5 @@ 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,5 +752,8 @@ 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,8 +761,5 @@ 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,5 +875,8 @@ 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,8 +884,5 @@ 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,5 +983,5 @@ 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,5 +998,8 @@ 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,8 +1007,5 @@ 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,4 +1075,5 @@ 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,15 +1121,15 @@ 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,5 +1244,8 @@ 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,8 +1254,5 @@ 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,5 +1288,4 @@ 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,5 +1367,8 @@ 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,8 +1376,5 @@ 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,5 +1387,5 @@ 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,4 +1456,5 @@ 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,5 +1490,8 @@ 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,8 +1500,5 @@ 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,5 +1569,5 @@ 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,5 +1613,8 @@ 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,8 +1623,5 @@ 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; Index: /issm/trunk-jpl/src/c/shared/io/Marshalling/IoCodeConversions.cpp =================================================================== --- /issm/trunk-jpl/src/c/shared/io/Marshalling/IoCodeConversions.cpp (revision 27249) +++ /issm/trunk-jpl/src/c/shared/io/Marshalling/IoCodeConversions.cpp (revision 27250) @@ -241,5 +241,5 @@ case 11: return SMBgradientscomponentsEnum; case 12: return SMBsemicEnum; - case 13: return SMBautoregressionEnum; + case 13: return SMBarmaEnum; default: _error_("Marshalled SMB code \""<',0); + md = checkfield(md,'fieldname','smb.basin_id','Inf',1,'>=',0,'<=',md.smb.num_basins,'size',[md.mesh.numberofelements,1]); + md = checkfield(md,'fieldname','smb.const','NaN',1,'Inf',1,'size',[1,md.smb.num_basins],'numel',md.smb.num_basins); %scheme fails if passed as column vector + md = checkfield(md,'fieldname','smb.trend','NaN',1,'Inf',1,'size',[1,md.smb.num_basins],'numel',md.smb.num_basins); %scheme fails if passed as column vector + md = checkfield(md,'fieldname','smb.ar_order','numel',1,'NaN',1,'Inf',1,'>=',0); + md = checkfield(md,'fieldname','smb.ma_order','numel',1,'NaN',1,'Inf',1,'>=',0); + md = checkfield(md,'fieldname','smb.arma_initialtime','numel',1,'NaN',1,'Inf',1); + md = checkfield(md,'fieldname','smb.arma_timestep','numel',1,'NaN',1,'Inf',1,'>=',md.timestepping.time_step); %arma time step cannot be finer than ISSM timestep + md = checkfield(md,'fieldname','smb.arlag_coefs','NaN',1,'Inf',1,'size',[md.smb.num_basins,md.smb.ar_order]); + md = checkfield(md,'fieldname','smb.malag_coefs','NaN',1,'Inf',1,'size',[md.smb.num_basins,md.smb.ma_order]); + + if (any(isnan(md.smb.refelevation)==0) || numel(md.smb.refelevation)>1) + md = checkfield(md,'fieldname','smb.refelevation','NaN',1,'Inf',1,'>=',0,'size',[1,md.smb.num_basins],'numel',md.smb.num_basins); + end + [nbas,nbins] = size(md.smb.lapserates); + if (any(isnan(reshape(md.smb.lapserates,[1,nbas*nbins]))==0) || numel(md.smb.lapserates)>1) + md = checkfield(md,'fieldname','smb.lapserates','NaN',1,'Inf',1,'size',[md.smb.num_basins,nbins],'numel',md.smb.num_basins*nbins); + md = checkfield(md,'fieldname','smb.elevationbins','NaN',1,'Inf',1,'size',[md.smb.num_basins,nbins-1],'numel',md.smb.num_basins*(nbins-1)); + if(issorted(md.smb.elevationbins,2)==0) + error('md.smb.elevationbins should have rows in order of increasing elevation'); + end + elseif (isnan(md.smb.elevationbins(1,1))==0 || numel(md.smb.elevationbins)>1) + %elevationbins specified but not lapserates: this will inevitably lead to inconsistencies + [nbas,nbins] = size(md.smb.elevationbins); + nbins = nbins+1; + md = checkfield(md,'fieldname','smb.lapserates','NaN',1,'Inf',1,'size',[md.smb.num_basins,nbins],'numel',md.smb.num_basins*nbins); + md = checkfield(md,'fieldname','smb.elevationbins','NaN',1,'Inf',1,'size',[md.smb.num_basins,nbins-1],'numel',md.smb.num_basins*(nbins-1)); + end + end + md = checkfield(md,'fieldname','smb.steps_per_step','>=',1,'numel',[1]); + md = checkfield(md,'fieldname','smb.averaging','numel',[1],'values',[0 1 2]); + md = checkfield(md,'fieldname','smb.requested_outputs','stringrow',1); + end % }}} + function disp(self) % {{{ + disp(sprintf(' surface forcings parameters:')); + fielddisplay(self,'num_basins','number of different basins [unitless]'); + fielddisplay(self,'basin_id','basin number assigned to each element [unitless]'); + fielddisplay(self,'const','basin-specific constant values [m ice eq./yr]'); + fielddisplay(self,'trend','basin-specific trend values [m ice eq. yr^(-2)]'); + fielddisplay(self,'ar_order','order of the autoregressive model [unitless]'); + fielddisplay(self,'ma_order','order of the moving-average model [unitless]'); + fielddisplay(self,'arma_initialtime','initial time assumed in the ARMA model parameterization [yr]'); + fielddisplay(self,'arma_timestep','time resolution of the ARMA model [yr]'); + fielddisplay(self,'arlag_coefs','basin-specific vectors of AR lag coefficients [unitless]'); + fielddisplay(self,'malag_coefs','basin-specific vectors of MA lag coefficients [unitless]'); + fielddisplay(self,'lapserates','basin-specific SMB lapse rates applied in each elevation bin, 1 row per basin, 1 column per bin [m ice eq yr^-1 m^-1] (default: no lapse rate)'); + fielddisplay(self,'elevationbins','basin-specific separations between elevation bins, 1 row per basin, 1 column per limit between bins [m] (default: no basin separation)'); + fielddisplay(self,'refelevation','basin-specific reference elevations at which SMB is calculated, and from which SMB is downscaled using lapserates (default: basin mean elevation) [m]'); + fielddisplay(self, 'steps_per_step', 'number of smb steps per time step'); + fielddisplay(self, 'averaging', 'averaging methods from short to long steps'); + disp(sprintf('%51s 0: Arithmetic (default)',' ')); + disp(sprintf('%51s 1: Geometric',' ')); + disp(sprintf('%51s 2: Harmonic',' ')); + fielddisplay(self,'requested_outputs','additional outputs requested'); + + end % }}} + function marshall(self,prefix,md,fid) % {{{ + + disp('ARMA is still under development'); + yts=md.constants.yts; + + templapserates = md.smb.lapserates; + tempelevationbins = md.smb.elevationbins; + temprefelevation = md.smb.refelevation; + [nbas,nbins] = size(md.smb.lapserates); + if(any(isnan(reshape(md.smb.lapserates,[1,nbas*nbins])))) + templapserates = zeros(md.smb.num_basins,2); + disp(' smb.lapserates not specified: set to 0'); + tempelevationbins = zeros(md.smb.num_basins,1); %dummy elevation bins + end + if(any(isnan(md.smb.refelevation))) + temprefelevation = zeros(1,md.smb.num_basins); + areas = GetAreas(md.mesh.elements,md.mesh.x,md.mesh.y); + for ii=1:md.smb.num_basins + indices = find(md.smb.basin_id==ii); + elemsh = zeros(numel(indices),1); + for jj=1:numel(indices) + elemsh(jj) = mean(md.geometry.surface(md.mesh.elements(indices(jj),:))); + end + temprefelevation(ii) = sum(areas(indices).*elemsh)/sum(areas(indices)); + end + if(any(reshape(md.smb.lapserates,[1,nbas*nbins])~=0)) + disp(' smb.refelevation not specified: Reference elevations set to mean surface elevation of basins'); + end + end + [nbas,nbins] = size(templapserates); + + WriteData(fid,prefix,'name','md.smb.model','data',13,'format','Integer'); + WriteData(fid,prefix,'object',self,'class','smb','fieldname','num_basins','format','Integer'); + WriteData(fid,prefix,'object',self,'class','smb','fieldname','ar_order','format','Integer'); + WriteData(fid,prefix,'object',self,'class','smb','fieldname','ma_order','format','Integer'); + WriteData(fid,prefix,'object',self,'class','smb','fieldname','arma_initialtime','format','Double','scale',yts); + WriteData(fid,prefix,'object',self,'class','smb','fieldname','arma_timestep','format','Double','scale',yts); + WriteData(fid,prefix,'object',self,'class','smb','fieldname','basin_id','data',self.basin_id-1,'name','md.smb.basin_id','format','IntMat','mattype',2); %0-indexed + WriteData(fid,prefix,'object',self,'class','smb','fieldname','const','format','DoubleMat','name','md.smb.const','scale',1./yts,'yts',yts); + WriteData(fid,prefix,'object',self,'class','smb','fieldname','trend','format','DoubleMat','name','md.smb.trend','scale',1./(yts^2),'yts',yts); + WriteData(fid,prefix,'object',self,'class','smb','fieldname','arlag_coefs','format','DoubleMat','name','md.smb.arlag_coefs','yts',yts); + WriteData(fid,prefix,'object',self,'class','smb','fieldname','malag_coefs','format','DoubleMat','name','md.smb.malag_coefs','yts',yts); + WriteData(fid,prefix,'data',templapserates,'format','DoubleMat','name','md.smb.lapserates','scale',1./yts,'yts',yts); + WriteData(fid,prefix,'data',tempelevationbins,'format','DoubleMat','name','md.smb.elevationbins'); + WriteData(fid,prefix,'data',temprefelevation,'format','DoubleMat','name','md.smb.refelevation'); + WriteData(fid,prefix,'data',nbins,'format','Integer','name','md.smb.num_bins'); + WriteData(fid,prefix,'object',self,'fieldname','steps_per_step','format','Integer'); + WriteData(fid,prefix,'object',self,'fieldname','averaging','format','Integer'); + + %process requested outputs + outputs = self.requested_outputs; + pos = find(ismember(outputs,'default')); + if ~isempty(pos), + outputs(pos) = []; %remove 'default' from outputs + outputs = [outputs defaultoutputs(self,md)]; %add defaults + end + WriteData(fid,prefix,'data',outputs,'name','md.smb.requested_outputs','format','StringArray'); + + end % }}} + end +end Index: /issm/trunk-jpl/src/m/classes/SMBarma.py =================================================================== --- /issm/trunk-jpl/src/m/classes/SMBarma.py (revision 27250) +++ /issm/trunk-jpl/src/m/classes/SMBarma.py (revision 27250) @@ -0,0 +1,199 @@ +import numpy as np + +from checkfield import * +from fielddisplay import fielddisplay +from project3d import * +from WriteData import * +from GetAreas import * + +class SMBarma(object): + """SMBARMA class definition + + Usage: + SMBarma = SMBarma() + """ + + def __init__(self, *args): # {{{ + self.num_basins = 0 + self.const = np.nan + self.trend = np.nan + self.ar_order = 0 + self.arma_initialtime = 0 + self.arma_timestep = 0 + self.arlag_coefs = np.nan + self.malag_coefs = np.nan + self.basin_id = np.nan + self.lapserates = np.nan + self.elevationbins = np.nan + self.refelevation = np.nan + self.steps_per_step = 1 + self.averaging = 0 + self.requested_outputs = [] + + nargs = len(args) + if nargs == 0: + self.setdefaultparameters() + else: + raise Exception('constructor not supported') + # }}} + + def __repr__(self): # {{{ + s = ' surface forcings parameters:\n' + s += '{}\n'.format(fielddisplay(self, 'num_basins', 'number of different basins [unitless]')) + s += '{}\n'.format(fielddisplay(self, 'basin_id', 'basin number assigned to each element [unitless]')) + s += '{}\n'.format(fielddisplay(self, 'const', 'basin-specific constant values [m ice eq./yr]')) + s += '{}\n'.format(fielddisplay(self, 'trend', 'basin-specific trend values [m ice eq. yr^(-2)]')) + s += '{}\n'.format(fielddisplay(self, 'ar_order', 'order of the autoregressive model [unitless]')) + s += '{}\n'.format(fielddisplay(self, 'ma_order', 'order of the moving-average model [unitless]')) + s += '{}\n'.format(fielddisplay(self, 'arma_initialtime', 'initial time assumed in the autoregressive model parameterization [yr]')) + s += '{}\n'.format(fielddisplay(self, 'arma_timestep', 'time resolution of the ARMA model [yr]')) + s += '{}\n'.format(fielddisplay(self, 'arlag_coefs', 'basin-specific vectors of AR lag coefficients [unitless]')) + s += '{}\n'.format(fielddisplay(self, 'malag_coefs', 'basin-specific vectors of MA lag coefficients [unitless]')) + s += '{}\n'.format(fielddisplay(self, 'lapserates', 'basin-specific SMB lapse rates applied in each elevation bin, 1 row per basin, 1 column per bin [m ice eq yr^-1 m^-1] (default: no lapse rate)')) + s += '{}\n'.format(fielddisplay(self, 'elevationbins', 'basin-specific SMB lapse rates applied in range of SMB<0 [m ice eq yr^-1 m^-1] (default: no lapse rate)')) + s += '{}\n'.format(fielddisplay(self, 'refelevation', 'basin-specific reference elevations at which SMB is calculated, and from which SMB is downscaled using lapserates (default: basin mean elevation) [m]')) + s += '{}\n'.format(fielddisplay(self, 'steps_per_step', 'number of smb steps per time step')) + s += '{}\n'.format(fielddisplay(self, 'averaging', 'averaging methods from short to long steps')) + s += '\t\t{}\n'.format('0: Arithmetic (default)') + s += '\t\t{}\n'.format('1: Geometric') + s += '\t\t{}\n'.format('2: Harmonic') + s += '{}\n'.format(fielddisplay(self, 'requested_outputs', 'additional outputs requested')) + return s + # }}} + + def setdefaultparameters(self): #{{{ + self.ar_order = 0.0 # Autoregression model of order 0 + self.ma_order = 0.0 # Moving-average model of order 0 + # }}} + + def extrude(self, md): # {{{ + return self # Nothing for now + # }}} + + def defaultoutputs(self, md): # {{{ + return [] + # }}} + + def initialize(self, md): # {{{ + if np.all(np.isnan(self.trend)): + self.trend = np.zeros((1, self.num_basins)) # No trend in SMB + print(' smb.trend (trend) not specified: value set to 0') + if self.ar_order == 0: + self.ar_order = 1 # Dummy 1 value for autoregression + self.arlag_coefs = np.zeros((self.num_basins, self.ar_order)) # Autoregression coefficients all set to 0 + print(' smb.ar_order (order of autoregressive model) not specified: order of autoregressive model set to 0') + if self.arma_initialtime == 0: + self.arma_initialtime = md.timestepping.start_time # ARMA model has no prescribed initial time + print(' smb.arma_initialtime (initial time in the ARMA model parameterization) not specified: set to md.timestepping.start_time') + if self.arma_timestep == 0: + self.arma_timestep = md.timestepping.time_step # ARMA model has no prescribed time step + print(' smb.arma_timestep (timestep of ARMA model) not specified: set to md.timestepping.time_step') + if np.all(np.isnan(self.arlag_coefs)): + self.arlag_coefs = np.zeros((self.num_basins, self.ar_order)) # Autoregression model of order 0 + print(' smb.arlag_coefs (AR lag coefficients) not specified: order of autoregressive model set to 0') + if np.all(np.isnan(self.malag_coefs)): + self.arlag_coefs = np.zeros((self.num_basins, self.ma_order)) # Moving-average model of order 0 + print(' smb.malag_coefs (MA lag coefficients) not specified: order of moving-average model set to 0') + return self + # }}} + + def checkconsistency(self, md, solution, analyses): # {{{ + if 'MasstransportAnalysis' in analyses: + md = checkfield(md, 'fieldname', 'smb.num_basins', 'numel', 1, 'NaN', 1, 'Inf', 1, '>', 0) + md = checkfield(md, 'fieldname', 'smb.basin_id', 'Inf', 1, '>=', 0, '<=', md.smb.num_basins, 'size', [md.mesh.numberofelements]) + if len(np.shape(self.const)) == 1: + self.const = np.array([self.const]) + self.trend = np.array([self.trend]) + md = checkfield(md, 'fieldname', 'smb.const', 'NaN', 1, 'Inf', 1, 'size', [1, md.smb.num_basins], 'numel', md.smb.num_basins) # Scheme fails if passed as column vector + md = checkfield(md, 'fieldname', 'smb.trend', 'NaN', 1, 'Inf', 1, 'size', [1, md.smb.num_basins], 'numel', md.smb.num_basins) # Scheme fails if passed as column vector; NOTE: As opposed to MATLAB implementation, pass list + md = checkfield(md, 'fieldname', 'smb.ar_order', 'numel', 1, 'NaN', 1, 'Inf', 1, '>=', 0) + md = checkfield(md, 'fieldname', 'smb.arma_initialtime', 'numel', 1, 'NaN', 1, 'Inf', 1) + md = checkfield(md, 'fieldname', 'smb.arma_timestep', 'numel', 1, 'NaN', 1, 'Inf', 1, '>=', md.timestepping.time_step) # Autoregression time step cannot be finer than ISSM timestep + md = checkfield(md, 'fieldname', 'smb.arlag_coefs', 'NaN', 1, 'Inf', 1, 'size', [md.smb.num_basins, md.smb.ar_order]) + md = checkfield(md, 'fieldname', 'smb.malag_coefs', 'NaN', 1, 'Inf', 1, 'size', [md.smb.num_basins, md.smb.ma_order]) + + if(np.any(np.isnan(self.refelevation) is False) or np.size(self.refelevation) > 1): + if len(np.shape(self.refelevation)) == 1: + self.refelevation = np.array([self.refelevation]) + md = checkfield(md, 'fieldname', 'smb.refelevation', 'NaN', 1, 'Inf', 1, '>=', 0, 'size', [1, md.smb.num_basins], 'numel', md.smb.num_basins) + + if(np.any(np.isnan(self.lapserates) is False) or np.size(self.lapserates) > 1): + if len(np.shape(self.lapserates)) == 1: + self.lapserates = np.array([self.lapserates]) + nbins = 1 + else: + nbins = np.shape(self.lapserates)[1] + if len(np.shape(self.elevationbins)) == 1: + self.elevationbins = np.array([self.elevationbins]) + md = checkfield(md, 'fieldname', 'smb.lapserates', 'NaN', 1, 'Inf', 1, 'size', [md.smb.num_basins, nbins], 'numel', md.smb.num_basins*nbins) + md = checkfield(md, 'fieldname', 'smb.elevationbins', 'NaN', 1, 'Inf', 1, 'size', [md.smb.num_basins, nbins-1], 'numel', md.smb.num_basins*(nbins-1)) + for rr in range(md.smb.num_basins): + if(np.all(self.elevationbins[rr,0:-1]<=self.elevationbins[rr,1:])==False): + raise TypeError('md.smb.elevationbins should have rows in order of increasing elevation') + elif(np.any(np.isnan(self.elevationbins) is False) or np.size(self.elevationbins) > 1): + #elevationbins specified but not lapserates: this will inevitably lead to inconsistencies + if len(np.shape(self.elevationbins)) == 1: + self.elevationbins = np.array([self.elevationbins]) + nbins = 1 + else: + nbins = np.shape(self.elevationbins)[1]+1 + md = checkfield(md, 'fieldname', 'smb.lapserates', 'NaN', 1, 'Inf', 1, 'size', [md.smb.num_basins, nbins], 'numel', md.smb.num_basins*nbins) + md = checkfield(md, 'fieldname', 'smb.elevationbins', 'NaN', 1, 'Inf', 1, 'size', [md.smb.num_basins, nbins-1], 'numel', md.smb.num_basins*(nbins-1)) + + md = checkfield(md, 'fieldname', 'smb.steps_per_step', '>=', 1, 'numel', [1]) + md = checkfield(md, 'fieldname', 'smb.averaging', 'numel', [1], 'values', [0, 1, 2]) + md = checkfield(md, 'fieldname', 'smb.requested_outputs', 'stringrow', 1) + return md + # }}} + + def marshall(self, prefix, md, fid): # {{{ + print('ARMA is still under development') + yts = md.constants.yts + + templapserates = np.copy(md.smb.lapserates) + tempelevationbins = np.copy(md.smb.elevationbins) + temprefelevation = np.copy(md.smb.refelevation) + if(np.any(np.isnan(md.smb.lapserates))): + templapserates = np.zeros((md.smb.num_basins,2)) + print(' smb.lapserates not specified: set to 0') + tempelevationbins = np.zeros((md.smb.num_basins,1)) #dummy elevation bins + if(np.any(np.isnan(md.smb.refelevation))): + temprefelevation = np.zeros((md.smb.num_basins)).reshape(1,md.smb.num_basins) + areas = GetAreas(md.mesh.elements, md.mesh.x, md.mesh.y) + for ii, bid in enumerate(np.unique(md.smb.basin_id)): + indices = np.where(md.smb.basin_id == bid)[0] + elemsh = np.zeros((len(indices))) + for jj in range(len(indices)): + elemsh[jj] = np.mean(md.geometry.surface[md.mesh.elements[indices[jj], :] - 1]) + temprefelevation[0, ii] = np.sum(areas[indices] * elemsh) / np.sum(areas[indices]) + if(np.any(templapserates != 0)): + print(' smb.refelevation not specified: Reference elevations set to mean surface elevation of basins') + nbins = np.shape(templapserates)[1] + + WriteData(fid, prefix, 'name', 'md.smb.model', 'data', 13, 'format', 'Integer') + WriteData(fid, prefix, 'object', self, 'class', 'smb', 'fieldname', 'num_basins', 'format', 'Integer') + WriteData(fid, prefix, 'object', self, 'class', 'smb', 'fieldname', 'ar_order', 'format', 'Integer') + WriteData(fid, prefix, 'object', self, 'class', 'smb', 'fieldname', 'ma_order', 'format', 'Integer') + WriteData(fid, prefix, 'object', self, 'class', 'smb', 'fieldname', 'arma_initialtime', 'format', 'Double', 'scale', yts) + WriteData(fid, prefix, 'object', self, 'class', 'smb', 'fieldname', 'arma_timestep', 'format', 'Double', 'scale', yts) + WriteData(fid, prefix, 'object', self, 'class', 'smb', 'fieldname', 'basin_id', 'data', self.basin_id - 1, 'name', 'md.smb.basin_id', 'format', 'IntMat', 'mattype', 2) # 0-indexed + WriteData(fid, prefix, 'object', self, 'class', 'smb', 'fieldname', 'const', 'format', 'DoubleMat', 'name', 'md.smb.const', 'scale', 1 / yts, 'yts', yts) + WriteData(fid, prefix, 'object', self, 'class', 'smb', 'fieldname', 'trend', 'format', 'DoubleMat', 'name', 'md.smb.trend', 'scale', 1 / (yts ** 2), 'yts', yts) + WriteData(fid, prefix, 'object', self, 'class', 'smb', 'fieldname', 'arlag_coefs', 'format', 'DoubleMat', 'name', 'md.smb.arlag_coefs', 'yts', yts) + WriteData(fid, prefix, 'object', self, 'class', 'smb', 'fieldname', 'malag_coefs', 'format', 'DoubleMat', 'name', 'md.smb.malag_coefs', 'yts', yts) + WriteData(fid, prefix, 'data', templapserates, 'name', 'md.smb.lapserates', 'format', 'DoubleMat', 'scale', 1 / yts, 'yts', yts) + WriteData(fid, prefix, 'data', tempelevationbins, 'name', 'md.smb.elevationbins', 'format', 'DoubleMat') + WriteData(fid, prefix, 'data', temprefelevation, 'name', 'md.smb.refelevation', 'format', 'DoubleMat') + WriteData(fid, prefix, 'data', nbins, 'name', 'md.smb.num_bins', 'format', 'Integer') + WriteData(fid, prefix, 'object', self, 'fieldname', 'steps_per_step', 'format', 'Integer') + WriteData(fid, prefix, 'object', self, 'fieldname', 'averaging', 'format', 'Integer') + + # Process requested outputs + outputs = self.requested_outputs + indices = [i for i, x in enumerate(outputs) if x == 'default'] + if len(indices) > 0: + outputscopy = outputs[0:max(0, indices[0] - 1)] + self.defaultoutputs(md) + outputs[indices[0] + 1:] + outputs = outputscopy + WriteData(fid, prefix, 'data', outputs, 'name', 'md.smb.requested_outputs', 'format', 'StringArray') + + # }}} Index: /issm/trunk-jpl/src/m/classes/frontalforcingsrignotarma.m =================================================================== --- /issm/trunk-jpl/src/m/classes/frontalforcingsrignotarma.m (revision 27250) +++ /issm/trunk-jpl/src/m/classes/frontalforcingsrignotarma.m (revision 27250) @@ -0,0 +1,99 @@ +%FRONTAL FORCINGS rignot arma class definition +% +% Usage: +% frontalforcingsrignotarma=frontalforcingsrignotarma(); + +classdef frontalforcingsrignotarma + properties (SetAccess=public) + num_basins = 0; + const = NaN; + trend = NaN; + ar_order = 0; + ma_order = 0; + arma_initialtime = 0; + arma_timestep = 0; + arlag_coefs = NaN; + malag_coefs = NaN; + basin_id = NaN; + subglacial_discharge = NaN; + end + methods + function self = frontalforcingsrignotarma(varargin) % {{{ + switch nargin + case 0 + self=setdefaultparameters(self); + case 1 + inputstruct=varargin{1}; + list1 = properties('frontalforcingsrignotarma'); + list2 = fieldnames(inputstruct); + for i=1:length(list1) + fieldname = list1{i}; + if ismember(fieldname,list2), + self.(fieldname) = inputstruct.(fieldname); + end + end + otherwise + error('constructor not supported'); + end + end % }}} + function self = extrude(self,md) % {{{ + % nothing for now + end % }}} + function self = setdefaultparameters(self) % {{{ + + self.basin_id = NaN; + self.num_basins = 0; + self.subglacial_discharge = NaN; + self.ar_order = 0.0; %autoregression model of order 0 + self.ma_order = 0.0; %moving-average model of order 0 + + end % }}} + function md = checkconsistency(self,md,solution,analyses) % {{{ + %Early return + if (~strcmp(solution,'TransientSolution') | md.transient.ismovingfront==0), return; end + + md = checkfield(md,'fieldname','frontalforcings.num_basins','numel',1,'NaN',1,'Inf',1,'>',0); + md = checkfield(md,'fieldname','frontalforcings.basin_id','Inf',1,'>=',0,'<=',md.frontalforcings.num_basins,'size',[md.mesh.numberofelements 1]); + md = checkfield(md,'fieldname','frontalforcings.subglacial_discharge','>=',0,'NaN',1,'Inf',1,'timeseries',1); + md = checkfield(md,'fieldname','frontalforcings.const','NaN',1,'Inf',1,'size',[1,md.frontalforcings.num_basins],'numel',md.frontalforcings.num_basins); + md = checkfield(md,'fieldname','frontalforcings.trend','NaN',1,'Inf',1,'size',[1,md.frontalforcings.num_basins],'numel',md.frontalforcings.num_basins); + md = checkfield(md,'fieldname','frontalforcings.ar_order','numel',1,'NaN',1,'Inf',1,'>=',0); + md = checkfield(md,'fieldname','frontalforcings.ma_order','numel',1,'NaN',1,'Inf',1,'>=',0); + md = checkfield(md,'fieldname','frontalforcings.arma_initialtime','numel',1,'NaN',1,'Inf',1); + md = checkfield(md,'fieldname','frontalforcings.arma_timestep','numel',1,'NaN',1,'Inf',1,'>=',md.timestepping.time_step); %ARMA time step cannot be finer than ISSM timestep + md = checkfield(md,'fieldname','frontalforcings.arlag_coefs','NaN',1,'Inf',1,'size',[md.frontalforcings.num_basins,md.frontalforcings.ar_order]); + md = checkfield(md,'fieldname','frontalforcings.malag_coefs','NaN',1,'Inf',1,'size',[md.frontalforcings.num_basins,md.frontalforcings.ma_order]); + + end % }}} + function disp(self) % {{{ + disp(sprintf(' Frontalforcings parameters:')); + fielddisplay(self,'num_basins','number of different basins [unitless]'); + fielddisplay(self,'basin_id','basin number assigned to each element [unitless]'); + fielddisplay(self,'subglacial_discharge','sum of subglacial discharge for each basin [m/d]'); + fielddisplay(self,'const','basin-specific constant term [∘C]'); + fielddisplay(self,'trend','basin-specific trend values [∘C yr^(-1)]'); + fielddisplay(self,'ar_order','order of the autoregressive model [unitless]'); + fielddisplay(self,'ma_order','order of the moving-average model [unitless]'); + fielddisplay(self,'arma_initialtime','initial time assumed in the ARMA model parameterization [yr]'); + fielddisplay(self,'arma_timestep','time resolution of the autoregressive model [yr]'); + fielddisplay(self,'arlag_coefs','basin-specific vectors of AR lag coefficients [unitless]'); + fielddisplay(self,'malag_coefs','basin-specific vectors of MA lag coefficients [unitless]'); + end % }}} + function marshall(self,prefix,md,fid) % {{{ + disp('ARMA is still under development'); + yts=md.constants.yts; + WriteData(fid,prefix,'name','md.frontalforcings.parameterization','data',3,'format','Integer'); + WriteData(fid,prefix,'object',self,'class','frontalforcings','fieldname','num_basins','format','Integer'); + WriteData(fid,prefix,'object',self,'class','frontalforcings','fieldname','subglacial_discharge','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1,'yts',yts); + WriteData(fid,prefix,'object',self,'class','frontalforcings','fieldname','ar_order','format','Integer'); + WriteData(fid,prefix,'object',self,'class','frontalforcings','fieldname','ma_order','format','Integer'); + WriteData(fid,prefix,'object',self,'class','frontalforcings','fieldname','arma_initialtime','format','Double','scale',yts); + WriteData(fid,prefix,'object',self,'class','frontalforcings','fieldname','arma_timestep','format','Double','scale',yts); + WriteData(fid,prefix,'object',self,'class','frontalforcings','fieldname','basin_id','data',self.basin_id-1,'name','md.frontalforcings.basin_id','format','IntMat','mattype',2); %0-indexed + WriteData(fid,prefix,'object',self,'class','frontalforcings','fieldname','const','format','DoubleMat','name','md.frontalforcings.const'); + WriteData(fid,prefix,'object',self,'class','frontalforcings','fieldname','trend','format','DoubleMat','name','md.frontalforcings.trend','scale',1./yts,'yts',yts); + WriteData(fid,prefix,'object',self,'class','frontalforcings','fieldname','arlag_coefs','format','DoubleMat','name','md.frontalforcings.arlag_coefs','yts',yts); + WriteData(fid,prefix,'object',self,'class','frontalforcings','fieldname','malag_coefs','format','DoubleMat','name','md.frontalforcings.malag_coefs','yts',yts); + end % }}} + end +end Index: /issm/trunk-jpl/src/m/classes/frontalforcingsrignotarma.py =================================================================== --- /issm/trunk-jpl/src/m/classes/frontalforcingsrignotarma.py (revision 27250) +++ /issm/trunk-jpl/src/m/classes/frontalforcingsrignotarma.py (revision 27250) @@ -0,0 +1,99 @@ +# -*- coding: utf-8 -*- +import numpy as np +from checkfield import checkfield +from fielddisplay import fielddisplay +from MatlabFuncs import * +from WriteData import WriteData + + +class frontalforcingsrignotarma(object): + """FRONTALFORCINGSRIGNOTARMA class definition + + Usage: + frontalforcingsrignotarma = frontalforcingsrignotarma() + """ + + def __init__(self, *args): # {{{ + self.num_basins = 0 + self.const = np.nan + self.trend = np.nan + self.ar_order = 0 + self.arma_initialtime = 0 + self.arma_timestep = 0 + self.arlag_coefs = np.nan + self.basin_id = np.nan + self.subglacial_discharge = np.nan + + if len(args) == 0: + self.setdefaultparameters() + else: + error('constructor not supported') + + def __repr__(self): # {{{ + s = ' Frontalforcings parameters:\n' + s += '{}\n'.format(fielddisplay(self, 'num_basins', 'number of different basins [unitless]')) + s += '{}\n'.format(fielddisplay(self, 'basin_id', 'basin number assigned to each element [unitless]')) + s += '{}\n'.format(fielddisplay(self, 'subglacial_discharge', 'sum of subglacial discharge for each basin [m/d]')) + s += '{}\n'.format(fielddisplay(self, 'const', 'basin-specific constant values [°C]')) + s += '{}\n'.format(fielddisplay(self, 'trend', 'basin-specific trend values [°C yr^(-1)]')) + s += '{}\n'.format(fielddisplay(self, 'ar_order', 'order of the autoregressive model [unitless]')) + s += '{}\n'.format(fielddisplay(self, 'ma_order', 'order of the moving-average model [unitless]')) + s += '{}\n'.format(fielddisplay(self, 'arma_initialtime', 'initial time assumed in the ARMA model parameterization [yr]')) + s += '{}\n'.format(fielddisplay(self, 'arma_timestep', 'time resolution of the ARMA model [yr]')) + s += '{}\n'.format(fielddisplay(self, 'arlag_coefs', 'basin-specific vectors of AR lag coefficients [unitless]')) + s += '{}\n'.format(fielddisplay(self, 'malag_coefs', 'basin-specific vectors of MA lag coefficients [unitless]')) + return s + #}}} + + def setdefaultparameters(self): # {{{ + self.basin_id = np.nan + self.num_basins = 0 + self.subglacial_discharge = np.nan + self.ar_order = 0.0 # Autoregression model of order 0 + self.ma_order = 0.0 # Moving-average model of order 0 + return self + #}}} + + def checkconsistency(self, md, solution, analyses): # {{{ + # Early return + if not (solution == 'TransientSolution') or not md.transient.ismovingfront: + return md + + md = checkfield(md, 'fieldname', 'frontalforcings.num_basins', 'numel', 1, 'NaN', 1, 'Inf', 1, '>', 0) + md = checkfield(md, 'fieldname', 'frontalforcings.basin_id', 'Inf', 1, '>=', 0, '<=', md.frontalforcings.num_basins, 'size', [md.mesh.numberofelements]) + md = checkfield(md, 'fieldname', 'frontalforcings.subglacial_discharge', '>=', 0, 'NaN', 1, 'Inf', 1, 'timeseries', 1) + if len(np.shape(self.const)) == 1: + self.const = np.array([self.const]) + self.trend = np.array([self.trend]) + md = checkfield(md, 'fieldname', 'frontalforcings.const', 'NaN', 1, 'Inf', 1, 'size', [1, md.frontalforcings.num_basins], 'numel', md.frontalforcings.num_basins) + md = checkfield(md, 'fieldname', 'frontalforcings.trend', 'NaN', 1, 'Inf', 1, 'size', [1, md.frontalforcings.num_basins], 'numel', md.frontalforcings.num_basins) + md = checkfield(md, 'fieldname', 'frontalforcings.ar_order', 'numel', 1, 'NaN', 1, 'Inf', 1, '>=', 0) + md = checkfield(md, 'fieldname', 'frontalforcings.ma_order', 'numel', 1, 'NaN', 1, 'Inf', 1, '>=', 0) + md = checkfield(md, 'fieldname', 'frontalforcings.arma_initialtime', 'numel', 1, 'NaN', 1, 'Inf', 1) + md = checkfield(md, 'fieldname', 'frontalforcings.arma_timestep', 'numel', 1, 'NaN', 1, 'Inf', 1, '>=', md.timestepping.time_step) # ARMA time step cannot be finer than ISSM timestep + md = checkfield(md, 'fieldname', 'frontalforcings.arlag_coefs', 'NaN', 1, 'Inf', 1, 'size', [md.frontalforcings.num_basins, md.frontalforcings.ar_order]) + md = checkfield(md, 'fieldname', 'frontalforcings.malag_coefs', 'NaN', 1, 'Inf', 1, 'size', [md.frontalforcings.num_basins, md.frontalforcings.ma_order]) + return md + # }}} + + def extrude(self, md): # {{{ + # Nothing for now + return self + # }}} + + def marshall(self, prefix, md, fid): # {{{ + print('ARMA is still under development') + yts = md.constants.yts + WriteData(fid, prefix, 'name', 'md.frontalforcings.parameterization', 'data', 3, 'format', 'Integer') + WriteData(fid, prefix, 'object', self, 'class', 'frontalforcings', 'fieldname', 'num_basins', 'format', 'Integer') + WriteData(fid, prefix, 'object', self, 'class', 'frontalforcings', 'fieldname', 'subglacial_discharge', 'format', 'DoubleMat', 'mattype', 1, 'timeserieslength', md.mesh.numberofvertices + 1, 'yts', yts) + WriteData(fid, prefix, 'object', self, 'class', 'frontalforcings', 'fieldname', 'ar_order', 'format', 'Integer') + WriteData(fid, prefix, 'object', self, 'class', 'frontalforcings', 'fieldname', 'ma_order', 'format', 'Integer') + WriteData(fid, prefix, 'object', self, 'class', 'frontalforcings', 'fieldname', 'arma_initialtime', 'format', 'Double', 'scale', yts) + WriteData(fid, prefix, 'object', self, 'class', 'frontalforcings', 'fieldname', 'arma_timestep', 'format', 'Double', 'scale', yts) + WriteData(fid, prefix, 'object', self, 'class', 'frontalforcings', 'fieldname', 'basin_id', 'data', self.basin_id - 1, 'name', 'md.frontalforcings.basin_id', 'format', 'IntMat', 'mattype', 2) # 0-indexed + WriteData(fid, prefix, 'object', self, 'class', 'frontalforcings', 'fieldname', 'const', 'format', 'DoubleMat', 'name', 'md.frontalforcings.const') + WriteData(fid, prefix, 'object', self, 'class', 'frontalforcings', 'fieldname', 'trend', 'format', 'DoubleMat', 'name', 'md.frontalforcings.trend', 'scale', 1 / yts, 'yts', yts) + WriteData(fid, prefix, 'object', self, 'class', 'frontalforcings', 'fieldname', 'arlag_coefs', 'format', 'DoubleMat', 'name', 'md.frontalforcings.arlag_coefs', 'yts', yts) + WriteData(fid, prefix, 'object', self, 'class', 'frontalforcings', 'fieldname', 'malag_coefs', 'format', 'DoubleMat', 'name', 'md.frontalforcings.malag_coefs', 'yts', yts) + # }}} Index: /issm/trunk-jpl/src/m/classes/linearbasalforcingsarma.m =================================================================== --- /issm/trunk-jpl/src/m/classes/linearbasalforcingsarma.m (revision 27250) +++ /issm/trunk-jpl/src/m/classes/linearbasalforcingsarma.m (revision 27250) @@ -0,0 +1,151 @@ +%LINEAR BASAL FORCINGS ARMA class definition +% +% Usage: +% linearbasalforcingsarma=linearbasalforcingsarma(); + +classdef linearbasalforcingsarma + + properties (SetAccess=public) + num_basins = 0; + const = NaN; + trend = NaN; + ar_order = 0; + ma_order = 0; + arma_initialtime = 0; + arma_timestep = 0; + arlag_coefs = NaN; + malag_coefs = NaN; + basin_id = NaN; + groundedice_melting_rate = NaN; + deepwater_elevation = NaN; + upperwater_melting_rate = NaN; + upperwater_elevation = NaN; + geothermalflux = NaN; + end + methods + function self = linearbasalforcingsarma(varargin) % {{{ + switch nargin + case 0 + self=setdefaultparameters(self); + otherwise + error('constructor not supported'); + end + end % }}} + function self = extrude(self,md) % {{{ + self.groundedice_melting_rate=project3d(md,'vector',self.groundedice_melting_rate,'type','node','layer',1); + self.deepwater_elevation=project3d(md,'vector',self.deepwater_elevation,'type','node','layer',1); + self.upperwater_melting_rate=project3d(md,'vector',self.upperwater_melting_rate,'type','node','layer',1); + self.upperwater_elevation=project3d(md,'vector',self.upperwater_elevation,'type','node','layer',1); + self.geothermalflux=project3d(md,'vector',self.geothermalflux,'type','node','layer',1); %bedrock only gets geothermal flux + end % }}} + function self = initialize(self,md) % {{{ + + if isnan(self.groundedice_melting_rate), + self.groundedice_melting_rate=zeros(md.mesh.numberofvertices,1); + disp(' no basalforcings.groundedice_melting_rate specified: values set as zero'); + end + if isnan(self.trend) + self.trend = zeros(1,self.num_basins); %no trend in SMB + disp(' basalforcings.trend (trend) not specified: value set to 0'); + end + if (self.ar_order==0) + self.ar_order = 1; %dummy 1 value for autoregression + self.arlag_coefs = zeros(self.num_basins,self.ar_order); %autoregression coefficients all set to 0 + disp(' basalforcings.ar_order (order of autoregressive model) not specified: order of autoregressive model set to 0'); + end + if (self.ma_order==0) + self.ma_order = 1; %dummy 1 value for moving-average + self.arlag_coefs = zeros(self.num_basins,self.ma_order); %moving-average coefficients all set to 0 + disp(' basalforcings.ma_order (order of moving-average model) not specified: order of moving-average model set to 0'); + end + if (self.arma_initialtime==0) + self.ar_initialtime = md.timestepping.start_time; %ARMA model has no prescribed initial time + disp(' basalforcings.arma_initialtime (initial time in the ARMA model parameterization) not specified: set to md.timestepping.start_time'); + end + if (self.arma_timestep==0) + self.arma_timestep = md.timestepping.time_step; %ARMA model has no prescribed time step + disp(' basalforcings.arma_timestep (timestep of ARMA model) not specified: set to md.timestepping.time_step'); + end + if isnan(self.arlag_coefs) + self.arlag_coefs = zeros(self.num_basins,self.ar_order); %autoregression model of order 0 + disp(' basalforcings.arlag_coefs (AR lag coefficients) not specified: order of autoregressive model set to 0'); + end + + end % }}} + function self = setdefaultparameters(self) % {{{ + self.ar_order = 0.0; %autoregression model of order 0 + self.ma_order = 0.0; %moving-average model of order 0 + end % }}} + function md = checkconsistency(self,md,solution,analyses) % {{{ + + if ismember('MasstransportAnalysis',analyses) & ~(strcmp(solution,'TransientSolution') & md.transient.ismasstransport==0), + md = checkfield(md,'fieldname','basalforcings.num_basins','numel',1,'NaN',1,'Inf',1,'>',0); + md = checkfield(md,'fieldname','basalforcings.groundedice_melting_rate','NaN',1,'Inf',1,'timeseries',1); + md = checkfield(md,'fieldname','basalforcings.deepwater_elevation','NaN',1,'Inf',1,'size',[1,md.basalforcings.num_basins],'numel',md.basalforcings.num_basins); + md = checkfield(md,'fieldname','basalforcings.upperwater_melting_rate','NaN',1,'Inf',1,'>=',0,'size',[1,md.basalforcings.num_basins],'numel',md.basalforcings.num_basins); + md = checkfield(md,'fieldname','basalforcings.upperwater_elevation','NaN',1,'Inf',1,'<=',0,'size',[1,md.basalforcings.num_basins],'numel',md.basalforcings.num_basins); + md = checkfield(md,'fieldname','basalforcings.basin_id','Inf',1,'>=',0,'<=',md.basalforcings.num_basins,'size',[md.mesh.numberofelements,1]); + md = checkfield(md,'fieldname','basalforcings.const','NaN',1,'Inf',1,'size',[1,md.basalforcings.num_basins],'numel',md.basalforcings.num_basins); + md = checkfield(md,'fieldname','basalforcings.trend','NaN',1,'Inf',1,'size',[1,md.basalforcings.num_basins],'numel',md.basalforcings.num_basins); + md = checkfield(md,'fieldname','basalforcings.ar_order','numel',1,'NaN',1,'Inf',1,'>=',0); + md = checkfield(md,'fieldname','basalforcings.ma_order','numel',1,'NaN',1,'Inf',1,'>=',0); + md = checkfield(md,'fieldname','basalforcings.arma_initialtime','numel',1,'NaN',1,'Inf',1); + md = checkfield(md,'fieldname','basalforcings.arma_timestep','numel',1,'NaN',1,'Inf',1,'>=',md.timestepping.time_step); %moving-average time step cannot be finer than ISSM timestep + md = checkfield(md,'fieldname','basalforcings.arlag_coefs','NaN',1,'Inf',1,'size',[md.basalforcings.num_basins,md.basalforcings.ar_order]); + md = checkfield(md,'fieldname','basalforcings.malag_coefs','NaN',1,'Inf',1,'size',[md.basalforcings.num_basins,md.basalforcings.ma_order]); + end + if ismember('BalancethicknessAnalysis',analyses), + error('not implemented yet!'); + end + if ismember('ThermalAnalysis',analyses) & ~(strcmp(solution,'TransientSolution') & md.transient.isthermal==0), + error('not implemented yet!'); + end + if numel(md.basalforcings.geothermalflux)>1 + md = checkfield(md,'fieldname','basalforcings.geothermalflux','NaN',1,'Inf',1,'timeseries',1,'>=',0); + end + end % }}} + function disp(self) % {{{ + disp(sprintf(' autoregression linear basal forcings parameters:')); + disp(sprintf(' autoregressive model is applied for deepwater_melting_rate')); + + fielddisplay(self,'num_basins','number of different basins [unitless]'); + fielddisplay(self,'basin_id','basin number assigned to each element [unitless]'); + fielddisplay(self,'const','basin-specific constant values [m/yr]'); + fielddisplay(self,'trend','basin-specific trend values [m yr^(-2)]'); + fielddisplay(self,'ar_order','order of the autoregressive model [unitless]'); + fielddisplay(self,'ar_order','order of the moving-average model [unitless]'); + fielddisplay(self,'arma_initialtime','initial time assumed in the ARMA model parameterization [yr]'); + fielddisplay(self,'arma_timestep','time resolution of the ARMA model [yr]'); + fielddisplay(self,'arlag_coefs','basin-specific vectors of AR lag coefficients [unitless]'); + fielddisplay(self,'malag_coefs','basin-specific vectors of MA lag coefficients [unitless]'); + fielddisplay(self,'deepwater_elevation','basin-specific elevation of ocean deepwater [m]'); + fielddisplay(self,'upperwater_melting_rate','basin-specific basal melting rate (positive if melting applied for floating ice whith base >= upperwater_elevation) [m/yr]'); + fielddisplay(self,'upperwater_elevation','basin-specific elevation of ocean upperwater [m]'); + fielddisplay(self,'groundedice_melting_rate','node-specific basal melting rate (positive if melting) [m/yr]'); + fielddisplay(self,'geothermalflux','node-specific geothermal heat flux [W/m^2]'); + + end % }}} + function marshall(self,prefix,md,fid) % {{{ + + disp('ARMA is still under development'); + yts=md.constants.yts; + + WriteData(fid,prefix,'name','md.basalforcings.model','data',9,'format','Integer'); + WriteData(fid,prefix,'object',self,'fieldname','groundedice_melting_rate','format','DoubleMat','name','md.basalforcings.groundedice_melting_rate','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1,'yts',md.constants.yts); + WriteData(fid,prefix,'object',self,'fieldname','geothermalflux','name','md.basalforcings.geothermalflux','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1,'yts',md.constants.yts); + WriteData(fid,prefix,'object',self,'fieldname','num_basins','format','Integer'); + WriteData(fid,prefix,'object',self,'fieldname','ar_order','format','Integer'); + WriteData(fid,prefix,'object',self,'fieldname','ma_order','format','Integer'); + WriteData(fid,prefix,'object',self,'fieldname','arma_initialtime','format','Double','scale',yts); + WriteData(fid,prefix,'object',self,'fieldname','arma_timestep','format','Double','scale',yts); + WriteData(fid,prefix,'object',self,'fieldname','basin_id','data',self.basin_id-1,'name','md.basalforcings.basin_id','format','IntMat','mattype',2); %0-indexed + WriteData(fid,prefix,'object',self,'fieldname','const','format','DoubleMat','name','md.basalforcings.const','scale',1./yts,'yts',yts); + WriteData(fid,prefix,'object',self,'fieldname','trend','format','DoubleMat','name','md.basalforcings.trend','scale',1./(yts^2),'yts',yts); + WriteData(fid,prefix,'object',self,'fieldname','arlag_coefs','format','DoubleMat','name','md.basalforcings.arlag_coefs','yts',yts); + WriteData(fid,prefix,'object',self,'fieldname','malag_coefs','format','DoubleMat','name','md.basalforcings.malag_coefs','yts',yts); + WriteData(fid,prefix,'object',self,'fieldname','deepwater_elevation','format','DoubleMat','name','md.basalforcings.deepwater_elevation'); + WriteData(fid,prefix,'object',self,'fieldname','upperwater_melting_rate','format','DoubleMat','name','md.basalforcings.upperwater_melting_rate','scale',1./yts); + WriteData(fid,prefix,'object',self,'fieldname','upperwater_elevation','format','DoubleMat','name','md.basalforcings.upperwater_elevation'); + end % }}} + end +end Index: /issm/trunk-jpl/src/m/classes/linearbasalforcingsarma.py =================================================================== --- /issm/trunk-jpl/src/m/classes/linearbasalforcingsarma.py (revision 27250) +++ /issm/trunk-jpl/src/m/classes/linearbasalforcingsarma.py (revision 27250) @@ -0,0 +1,151 @@ +import numpy as np + +from checkfield import * +from fielddisplay import fielddisplay +from project3d import * +from WriteData import * + +class linearbasalforcingsarma(object): + """linearbasalforcingsarma class definition + + Usage: + linearbasalforcingsarma = linearbasalforcingsarma() + """ + + def __init__(self, *args): # {{{ + self.num_basins = 0 + self.const = np.nan + self.trend = np.nan + self.ar_order = 0 + self.ma_order = 0 + self.arma_initialtime = 0 + self.arma_timestep = 0 + self.arlag_coefs = np.nan + self.malag_coefs = np.nan + self.basin_id = np.nan + self.groundedice_melting_rate = np.nan + self.deepwater_elevation = np.nan + self.upperwater_melting_rate = np.nan + self.upperwater_elevation = np.nan + self.geothermalflux = np.nan + + nargs = len(args) + if nargs == 0: + self.setdefaultparameters() + else: + raise Exception('constructor not supported') + # }}} + + def __repr__(self): # {{{ + s = ' surface forcings parameters:\n' + s += ' autoregressive model is applied for deepwater_melting_rate\n' + s += '{}\n'.format(fielddisplay(self, 'num_basins', 'number of different basins [unitless]')) + s += '{}\n'.format(fielddisplay(self, 'basin_id', 'basin number assigned to each element [unitless]')) + s += '{}\n'.format(fielddisplay(self, 'const', 'basin-specific constant values [m ice eq./yr]')) + s += '{}\n'.format(fielddisplay(self, 'trend', 'basin-specific trend values [m ice eq. yr^(-2)]')) + s += '{}\n'.format(fielddisplay(self, 'ar_order', 'order of the autoregressive model [unitless]')) + s += '{}\n'.format(fielddisplay(self, 'ma_order', 'order of the moving-average model [unitless]')) + s += '{}\n'.format(fielddisplay(self, 'arma_initialtime', 'initial time assumed in the ARMA model parameterization [yr]')) + s += '{}\n'.format(fielddisplay(self, 'arma_timestep', 'time resolution of the ARMA model [yr]')) + s += '{}\n'.format(fielddisplay(self, 'arlag_coefs', 'basin-specific vectors of AR lag coefficients [unitless]')) + s += '{}\n'.format(fielddisplay(self, 'malag_coefs', 'basin-specific vectors of MA lag coefficients [unitless]')) + s += '{}\n'.format(fielddisplay(self, 'deepwater_elevation', 'basin-specific elevation of ocean deepwater [m]')) + s += '{}\n'.format(fielddisplay(self, 'upperwater_melting_rate', 'basin-specic basal melting rate (positive if melting applied for floating ice whith base >= upperwater_elevation) [m/yr]')) + s += '{}\n'.format(fielddisplay(self, 'upperwater_elevation', 'basin-specific elevation of ocean upperwater [m]')) + s += '{}\n'.format(fielddisplay(self, 'groundedice_melting_rate','node-specific basal melting rate (positive if melting) [m/yr]')) + s += '{}\n'.format(fielddisplay(self, 'geothermalflux','node-specific geothermal heat flux [W/m^2]')) + return s + # }}} + + def setdefaultparameters(self): #{{{ + self.ar_order = 0.0 # Autoregression model of order 0 + self.ma_order = 0.0 # Moving-average model of order 0 + return self + # }}} + + def extrude(self, md): # {{{ + return self # Nothing for now + # }}} + + def initialize(self, md): # {{{ + if np.all(np.isnan(self.groundedice_melting_rate)): + self.groundedice_melting_rate = np.zeros((md.mesh.numberofvertices)) + print(" no basalforcings.groundedice_melting_rate specified: values set as zero") + if np.all(np.isnan(self.trend)): + self.trend = np.zeros((1, self.num_basins)) # No trend in SMB + print(' basalforcings.trend (trend) not specified: value set to 0') + if self.ar_order == 0: + self.ar_order = 1 # Dummy 1 value for autoregression + self.arlag_coefs = np.zeros((self.num_basins, self.ar_order)) # Autoregression coefficients all set to 0 + print(' basalforcings.ar_order (order of autoregressive model) not specified: order of autoregressive model set to 0') + if self.arma_initialtime == 0: + self.arma_initialtime = md.timestepping.start_time # ARMA model has no prescribed initial time + print(' basalforcings.arma_initialtime (initial time in the ARMA model parameterization) not specified: set to md.timestepping.start_time') + if self.arma_timestep == 0: + self.arma_timestep = md.timestepping.time_step # ARMA model has no prescribed time step + print(' basalforcings.arma_timestep (timestep of ARMA model) not specified: set to md.timestepping.time_step') + if np.all(np.isnan(self.arlag_coefs)): + self.arlag_coefs = np.zeros((self.num_basins, self.ar_order)) # Autoregression model of order 0 + print(' basalforcings.arlag_coefs (AR lag coefficients) not specified: order of autoregressive model set to 0') + if np.all(np.isnan(self.malag_coefs)): + self.arlag_coefs = np.zeros((self.num_basins, self.ma_order)) # Moving-average model of order 0 + print(' basalforcings.malag_coefs (MA lag coefficients) not specified: order of moving-average model set to 0') + return self + # }}} + + def checkconsistency(self, md, solution, analyses): # {{{ + if 'MasstransportAnalysis' in analyses: + md = checkfield(md, 'fieldname', 'basalforcings.num_basins', 'numel', 1, 'NaN', 1, 'Inf', 1, '>', 0) + md = checkfield(md, 'fieldname', 'basalforcings.groundedice_melting_rate', 'NaN', 1, 'Inf', 1, 'timeseries', 1) + + if len(np.shape(self.deepwater_elevation)) == 1: + self.deepwater_elevation = np.array([self.deepwater_elevation]) + self.upperwater_elevation = np.array([self.upperwater_elevation]) + self.upperwater_melting_rate = np.array([self.upperwater_melting_rate]) + md = checkfield(md, 'fieldname', 'basalforcings.deepwater_elevation', 'NaN', 1, 'Inf', 1, 'size', [1, md.basalforcings.num_basins], 'numel', md.basalforcings.num_basins) + md = checkfield(md, 'fieldname', 'basalforcings.upperwater_elevation', 'NaN', 1, 'Inf', 1, '<=', 0, 'size', [1, md.basalforcings.num_basins], 'numel', md.basalforcings.num_basins) + md = checkfield(md, 'fieldname', 'basalforcings.upperwater_melting_rate', 'NaN', 1, 'Inf', 1,'>=', 0, 'size', [1, md.basalforcings.num_basins], 'numel', md.basalforcings.num_basins) + md = checkfield(md, 'fieldname', 'basalforcings.basin_id', 'Inf', 1, '>=', 0, '<=', md.basalforcings.num_basins, 'size', [md.mesh.numberofelements]) + + if len(np.shape(self.const)) == 1: + self.const = np.array([self.const]) + self.trend = np.array([self.trend]) + + md = checkfield(md, 'fieldname', 'basalforcings.const', 'NaN', 1, 'Inf', 1, 'size', [1, md.basalforcings.num_basins], 'numel', md.basalforcings.num_basins) # Scheme fails if passed as column vector + md = checkfield(md, 'fieldname', 'basalforcings.trend', 'NaN', 1, 'Inf', 1, 'size', [1, md.basalforcings.num_basins], 'numel', md.basalforcings.num_basins) # Scheme fails if passed as column vector; NOTE: As opposed to MATLAB implementation, pass list + md = checkfield(md, 'fieldname', 'basalforcings.ar_order', 'numel', 1, 'NaN', 1, 'Inf', 1, '>=', 0) + md = checkfield(md, 'fieldname', 'basalforcings.ma_order', 'numel', 1, 'NaN', 1, 'Inf', 1, '>=', 0) + md = checkfield(md, 'fieldname', 'basalforcings.arma_initialtime', 'numel', 1, 'NaN', 1, 'Inf', 1) + md = checkfield(md, 'fieldname', 'basalforcings.arma_timestep', 'numel', 1, 'NaN', 1, 'Inf', 1, '>=', md.timestepping.time_step) # Autoregression time step cannot be finer than ISSM timestep + md = checkfield(md, 'fieldname', 'basalforcings.arlag_coefs', 'NaN', 1, 'Inf', 1, 'size', [md.basalforcings.num_basins, md.basalforcings.ar_order]) + md = checkfield(md, 'fieldname', 'basalforcings.malag_coefs', 'NaN', 1, 'Inf', 1, 'size', [md.basalforcings.num_basins, md.basalforcings.ma_order]) + if 'BalancethicknessAnalysis' in analyses: + raise Exception('not implemented yet!') + if 'ThermalAnalysis' in analyses and not solution == 'TransientSolution' and not md.transient.isthermal: + raise Exception('not implemented yet!') + + return md + # }}} + + def marshall(self, prefix, md, fid): # {{{ + print('ARMA is still under development') + yts = md.constants.yts + + WriteData(fid, prefix, 'name', 'md.basalforcings.model', 'data', 9, 'format', 'Integer') + WriteData(fid, prefix, 'object', self, 'fieldname', 'groundedice_melting_rate', 'name', 'md.basalforcings.groundedice_melting_rate', 'format', 'DoubleMat', 'mattype', 1, 'scale', 1. / yts, 'timeserieslength', md.mesh.numberofvertices + 1, 'yts', yts) + WriteData(fid, prefix, 'object', self, 'fieldname', 'geothermalflux', 'name', 'md.basalforcings.geothermalflux', 'format', 'DoubleMat', 'mattype', 1, 'timeserieslength', md.mesh.numberofvertices + 1, 'yts', yts) + WriteData(fid, prefix, 'object', self, 'fieldname', 'num_basins', 'format', 'Integer') + WriteData(fid, prefix, 'object', self, 'fieldname', 'ar_order', 'format', 'Integer') + WriteData(fid, prefix, 'object', self, 'fieldname', 'ma_order', 'format', 'Integer') + WriteData(fid, prefix, 'object', self, 'fieldname', 'arma_initialtime', 'format', 'Double', 'scale', yts) + WriteData(fid, prefix, 'object', self, 'fieldname', 'arma_timestep', 'format', 'Double', 'scale', yts) + WriteData(fid, prefix, 'object', self, 'fieldname', 'basin_id', 'data', self.basin_id - 1, 'name', 'md.basalforcings.basin_id', 'format', 'IntMat', 'mattype', 2) # 0-indexed + WriteData(fid, prefix, 'object', self, 'fieldname', 'const', 'format', 'DoubleMat', 'name', 'md.basalforcings.const', 'scale', 1 / yts, 'yts', yts) + WriteData(fid, prefix, 'object', self, 'fieldname', 'trend', 'format', 'DoubleMat', 'name', 'md.basalforcings.trend', 'scale', 1 / (yts ** 2), 'yts', yts) + WriteData(fid, prefix, 'object', self, 'fieldname', 'arlag_coefs', 'format', 'DoubleMat', 'name', 'md.basalforcings.arlag_coefs', 'yts', yts) + WriteData(fid, prefix, 'object', self, 'fieldname', 'malag_coefs', 'format', 'DoubleMat', 'name', 'md.basalforcings.malag_coefs', 'yts', yts) + WriteData(fid, prefix, 'object', self, 'fieldname', 'deepwater_elevation', 'format', 'DoubleMat', 'name', 'md.basalforcings.deepwater_elevation') + WriteData(fid, prefix, 'object', self, 'fieldname', 'upperwater_melting_rate', 'format', 'DoubleMat', 'name', 'md.basalforcings.upperwater_melting_rate', 'scale', 1 / yts, 'yts', yts) + WriteData(fid, prefix, 'object', self, 'fieldname', 'upperwater_elevation', 'format', 'DoubleMat', 'name', 'md.basalforcings.upperwater_elevation') + + # }}} Index: /issm/trunk-jpl/test/NightlyRun/test257.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test257.m (revision 27249) +++ /issm/trunk-jpl/test/NightlyRun/test257.m (revision 27250) @@ -1,3 +1,3 @@ -%Test Name: SquareShelfSMBautoregression +%Test Name: SquareShelfSMBarma md=triangle(model(),'../Exp/Square.exp',80000.); md=setmask(md,'all',''); @@ -36,19 +36,21 @@ 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 Index: /issm/trunk-jpl/test/NightlyRun/test257.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test257.py (revision 27249) +++ /issm/trunk-jpl/test/NightlyRun/test257.py (revision 27250) @@ -1,3 +1,3 @@ -#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,5 +7,5 @@ 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,13 +41,15 @@ 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,5 +57,5 @@ # 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 Index: /issm/trunk-jpl/test/NightlyRun/test543.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test543.m (revision 27249) +++ /issm/trunk-jpl/test/NightlyRun/test543.m (revision 27250) @@ -45,5 +45,5 @@ 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,8 +51,10 @@ 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,5 +70,5 @@ %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; Index: /issm/trunk-jpl/test/NightlyRun/test543.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test543.py (revision 27249) +++ /issm/trunk-jpl/test/NightlyRun/test543.py (revision 27250) @@ -1,5 +1,5 @@ #Test Name: PigTranStochasticforcing import numpy as np -from frontalforcingsrignotautoregression import frontalforcingsrignotautoregression +from frontalforcingsrignotarma import frontalforcingsrignotarma from socket import gethostname from model import * @@ -50,5 +50,5 @@ 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,8 +56,10 @@ 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,5 +87,5 @@ # 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 Index: /issm/trunk-jpl/test/NightlyRun/test544.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test544.m (revision 27249) +++ /issm/trunk-jpl/test/NightlyRun/test544.m (revision 27250) @@ -1,3 +1,3 @@ -%Test Name: PigTranAutoregressionAndStochasticforcings +%Test Name: PigTranARMAandStochasticforcings md=triangle(model(),'../Exp/Pig.exp',8000.); md=setmask(md,'../Exp/PigShelves.exp','../Exp/PigIslands.exp'); @@ -24,13 +24,15 @@ %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,13 +44,15 @@ % 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,5 +69,5 @@ % 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; Index: /issm/trunk-jpl/test/NightlyRun/test544.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test544.py (revision 27249) +++ /issm/trunk-jpl/test/NightlyRun/test544.py (revision 27250) @@ -1,6 +1,6 @@ -#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,13 +34,15 @@ #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,13 +54,15 @@ #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,5 +80,5 @@ #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