Changeset 26208


Ignore:
Timestamp:
04/23/21 15:37:25 (4 years ago)
Author:
schlegel
Message:

CHG: clean up GEMB, change interp_forcings to interp_forcing, isclimatology is now cycle_forcing

Location:
issm/trunk-jpl
Files:
52 edited

Legend:

Unmodified
Added
Removed

  • issm/trunk-jpl/examples/SlrGRACE/runme.m

    r26142 r26208  
    190190        md.timestepping.final_time=nt;
    191191        md.timestepping.time_step=1;
    192         md.timestepping.interp_forcings=0;
     192        md.timestepping.interp_forcing=0;
    193193        md.settings.output_frequency=1;
    194194

  • issm/trunk-jpl/examples/SlrGRACE_NIMS/runme.m

    r25986 r26208  
    269269        md.timestepping.final_time=nt;
    270270        md.timestepping.time_step=1;
    271         md.timestepping.interp_forcings=0;
     271        md.timestepping.interp_forcing=0;
    272272        md.settings.output_frequency=1;
    273273

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

    r26196 r26208  
    226226
    227227        iomodel->FindConstant(&smb_model,"md.smb.model");
    228         iomodel->FindConstant(&interp,"md.timestepping.interp_forcings");
     228        iomodel->FindConstant(&interp,"md.timestepping.interp_forcing");
    229229        iomodel->FindConstant(&cycle,"md.timestepping.cycle_forcing");
    230230
    … …  
    237237        switch(smb_model){
    238238                case SMBforcingEnum:
    239                         parameters->AddObject(iomodel->CopyConstantObject("md.smb.isclimatology",SmbIsclimatologyEnum));
    240239                        break;
    241240                case SMBgembEnum:
    … …  
    259258                        parameters->AddObject(iomodel->CopyConstantObject("md.smb.isdensification",SmbIsdensificationEnum));
    260259                        parameters->AddObject(iomodel->CopyConstantObject("md.smb.isturbulentflux",SmbIsturbulentfluxEnum));
    261                         parameters->AddObject(iomodel->CopyConstantObject("md.smb.isclimatology",SmbIsclimatologyEnum));
    262260                        parameters->AddObject(iomodel->CopyConstantObject("md.smb.isconstrainsurfaceT",SmbIsconstrainsurfaceTEnum));
    263261                        parameters->AddObject(iomodel->CopyConstantObject("md.smb.InitDensityScaling",SmbInitDensityScalingEnum));
    … …  
    382380                        break;
    383381                case SMBcomponentsEnum:
    384                         parameters->AddObject(iomodel->CopyConstantObject("md.smb.isclimatology",SmbIsclimatologyEnum));
    385382                        break;
    386383                case SMBmeltcomponentsEnum:
    387                         parameters->AddObject(iomodel->CopyConstantObject("md.smb.isclimatology",SmbIsclimatologyEnum));
    388384                        break;
    389385                case SMBgradientscomponentsEnum:

  • issm/trunk-jpl/src/c/classes/Inputs/TransientInput.cpp

    r26200 r26208  
    417417        /*First, recover current time from parameters: */
    418418        bool linear_interp,cycle;
    419         this->parameters->FindParam(&linear_interp,TimesteppingInterpForcingsEnum);
     419        IssmDouble dt;
     420        this->parameters->FindParam(&linear_interp,TimesteppingInterpForcingEnum);
    420421        this->parameters->FindParam(&cycle,TimesteppingCycleForcingEnum);
     422        this->parameters->FindParam(&dt,TimesteppingTimeStepEnum);          /*transient core time step*/
    421423
    422424        /*Change input time if we cycle through the forcing*/
    423425        IssmDouble time0 = this->timesteps[0];
    424426        IssmDouble time1 = this->timesteps[this->numtimesteps - 1];
     427
     428        /*We need the end time to be the last timestep that would be taken*/
     429        /* i.e., the case where GEMB has time stamps (finer timestep) after the last timestep */
     430        IssmDouble nsteps = reCast<int,IssmDouble>(time1/dt);
     431        if (reCast<IssmDouble>(nsteps)<time1/dt) nsteps=nsteps+1;
     432        time1 = nsteps*dt;
     433
    425434        if(cycle && (time<time0 || time>time1)){
    426435
    … …  
    433442                /*Uncomment following line if you would like to apply a cycle BEFORE the time series starts*/
    434443                //if(time<time0) num_intervals = -num_intervals-1;
    435                
     444
    436445                if(fabs(time-time0)/deltat == reCast<IssmDouble>(num_intervals)){
    437446                        /*Hack to make sure we always cover the last value of the series (discussion with Nicole)*/

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

    r26196 r26208  
    159159                        break;
    160160                case LinearFloatingMeltRateEnum:
    161                         iomodel->FindConstant(&interp,"md.timestepping.interp_forcings");
     161                        iomodel->FindConstant(&interp,"md.timestepping.interp_forcing");
    162162                        iomodel->FindConstant(&cycle,"md.timestepping.cycle_forcing");
    163163                        iomodel->FetchData(&transparam,&N,&M,"md.basalforcings.deepwater_melting_rate");
    … …  
    224224                        break;
    225225                case BasalforcingsPicoEnum:
    226                         iomodel->FindConstant(&interp,"md.timestepping.interp_forcings");
     226                        iomodel->FindConstant(&interp,"md.timestepping.interp_forcing");
    227227                        iomodel->FindConstant(&cycle,"md.timestepping.cycle_forcing");
    228228                        parameters->AddObject(iomodel->CopyConstantObject("md.basalforcings.num_basins",BasalforcingsPicoNumBasinsEnum));
    … …  
    267267                        parameters->AddObject(iomodel->CopyConstantObject("md.timestepping.final_time",TimesteppingFinalTimeEnum));
    268268                        parameters->AddObject(iomodel->CopyConstantObject("md.timestepping.time_step",TimesteppingTimeStepEnum));
    269                         parameters->AddObject(iomodel->CopyConstantObject("md.timestepping.interp_forcings",TimesteppingInterpForcingsEnum));
     269                        parameters->AddObject(iomodel->CopyConstantObject("md.timestepping.interp_forcing",TimesteppingInterpForcingEnum));
    270270                        parameters->AddObject(iomodel->CopyConstantObject("md.timestepping.cycle_forcing",TimesteppingCycleForcingEnum));
    271271                        parameters->AddObject(iomodel->CopyConstantObject("md.timestepping.coupling_time",TimesteppingCouplingTimeEnum));
    … …  
    277277                        parameters->AddObject(iomodel->CopyConstantObject("md.timestepping.time_step_max",TimesteppingTimeStepMaxEnum));
    278278                        parameters->AddObject(iomodel->CopyConstantObject("md.timestepping.cfl_coefficient",TimesteppingCflCoefficientEnum));
    279                         parameters->AddObject(iomodel->CopyConstantObject("md.timestepping.interp_forcings",TimesteppingInterpForcingsEnum));
     279                        parameters->AddObject(iomodel->CopyConstantObject("md.timestepping.interp_forcing",TimesteppingInterpForcingEnum));
    280280                        parameters->AddObject(iomodel->CopyConstantObject("md.timestepping.cycle_forcing",TimesteppingCycleForcingEnum));
    281281                        parameters->AddObject(iomodel->CopyConstantObject("md.timestepping.coupling_time",TimesteppingCouplingTimeEnum));

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

    r25999 r26208  
    3939        IssmDouble t,smb_dt;
    4040   IssmDouble delta;
    41         bool       isclimatology=false;
    4241        bool       linear_interp=true;
    4342
    44         femmodel->parameters->FindParam(&linear_interp,TimesteppingInterpForcingsEnum); /*is interpolation requested*/
     43        femmodel->parameters->FindParam(&linear_interp,TimesteppingInterpForcingEnum); /*is interpolation requested*/
    4544        femmodel->parameters->FindParam(&time,TimeEnum);                        /*transient core time at which we run the smb core*/
    4645   femmodel->parameters->FindParam(&dt,TimesteppingTimeStepEnum);          /*transient core time step*/
    4746        femmodel->parameters->FindParam(&finaltime,TimesteppingFinalTimeEnum);
    4847   femmodel->parameters->FindParam(&smb_dt,SmbDtEnum);                     /*time period for the smb solution,  usually smaller than the glaciological dt*/
    49         femmodel->parameters->FindParam(&isclimatology,SmbIsclimatologyEnum);
    5048
    5149        //before starting loop, realize that the transient core runs this smb_core at time = time +deltaT.
    … …  
    6361
    6462                        timeclim=time;
    65                         if (isclimatology){
    66                                 //If this is a climatology, we need to repeat the forcing after the final time
    67                                 TransientInput* Ta_input_tr  = element->inputs->GetTransientInput(SmbTaEnum);    _assert_(Ta_input_tr);
    68 
    69                                 /*Get temperature climatology value*/
    70                                 int offsetend = Ta_input_tr->GetTimeInputOffset(finaltime);
    71                                 IssmDouble time0     = Ta_input_tr->GetTimeByOffset(-1);
    72                                 IssmDouble timeend   = Ta_input_tr->GetTimeByOffset(offsetend);
    73                                 timeend   = ceil(timeend/dt)*dt;
    74                                 if (time>time0 & timeend>time0){
    75                                         delta=(time-time0) - (timeend-time0)*(reCast<int,IssmDouble>((time-time0)/(timeend-time0)));
    76                                         timeclim=time0+delta;
    77                                 }
    78                         }
    7963                        if (linear_interp) timeinputs = t-time+timeclim;
    8064                        else timeinputs = t-time+timeclim+smb_dt/2;
    … …  
    515499        //  clabIce  = concentration of light absorbing carbon of first ice layer [ppm1], default 0
    516500
    517         // Methods 3
     501        // Method 3
    518502        //   d       = snow surface density [kg m-3]
    519503        //   n       = cloud amount
    … …  
    521505        //   aSnow   = albedo of fresh snow
    522506
    523         // Methods 4
     507        // Method 4
    524508        //   aIce    = albedo of ice
    525509        //   aSnow   = albedo of fresh snow
    … …  
    661645                //If we do not have fresh snow
    662646                if (aIdx<3 && aIdx>0 && (adThresh - d[0])>=Dtol){
    663                         // In a layer < 10cm, account for mix of ice and snow,
     647                        // In a snow layer < 10cm, account for mix of ice and snow,
    664648                        // after P. Alexander et al., 2014
    665649                        IssmDouble depthsnow=0.0;
    … …  
    10951079
    10961080        // swIdx = 1 : absorbed SW is distributed with depth as a function of:
    1097         //   default   : snow density (taken from Bassford, 2004)
     1081        //   default   : snow density (taken from Bassford, 2002)
    10981082        //   if aIdx=2 : grain size in 3 spectral bands (Brun et al., 1992)
    10991083
    … …  
    11771161                        swfS[2] = (sF[2] * dsw) * (1.0 - a2);
    11781162
    1179                         // absorption coeficient for spectral range:
     1163                        // absorption coefficient for spectral range:
    11801164                        h =xNew<IssmDouble>(m);
    11811165                        B1 =xNew<IssmDouble>(m);
    … …  
    13651349                        break;
    13661350
    1367                 case 2: // Density of Greenland snow, Fausto et al., 2008
     1351                case 2: // Density of Greenland snow, Fausto et al., 2018
    13681352                        dSnow = 315;
    13691353                        break;

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

    r25539 r26208  
    1414        //    INPUT parameters: ni: working size of arrays
    1515        //    OUTPUT: mass-balance (m/yr ice): agd(NA)
    16         bool isclimatology;
    17         femmodel->parameters->FindParam(&isclimatology,SmbIsclimatologyEnum);
    18 
    19         if (isclimatology){
    20 
    21                 /*Get time parameters*/
    22                 IssmDouble time,dt,starttime,finaltime;
    23                 femmodel->parameters->FindParam(&time,TimeEnum);
    24                 femmodel->parameters->FindParam(&dt,TimesteppingTimeStepEnum);
    25                 femmodel->parameters->FindParam(&finaltime,TimesteppingFinalTimeEnum);
    26                 femmodel->parameters->FindParam(&starttime,TimesteppingStartTimeEnum);
    27 
    28                 if(time<=starttime+dt){
    29                         /*FIXME: this is wrong, should be done at the ElementUpdate step of analysis, not here!*/
    30                         InputDuplicatex(femmodel,SmbMassBalanceEnum,SmbMassBalanceClimateEnum);
    31                         femmodel->inputs->DeleteInput(SmbMassBalanceEnum);
    32                 }
    33 
    34                 /*If this is a climatology, we need to repeat the forcing after the final time*/
    35                 TransientInput* smb_input=femmodel->inputs->GetTransientInput(SmbMassBalanceClimateEnum); _assert_(smb_input);
    36 
    37                 /*Get accumulation climatology value*/
    38                 int offsetend = smb_input->GetTimeInputOffset(finaltime);
    39                 IssmDouble time0     = smb_input->GetTimeByOffset(-1);
    40                 IssmDouble timeend   = smb_input->GetTimeByOffset(offsetend);
    41 
    42                 _assert_(timeend>time0);
    43                 IssmDouble timeclim  = time;
    44 
    45                 if(time>time0 && timeend>time0){
    46                         IssmDouble delta=(time-time0) - (timeend-time0)*(reCast<int,IssmDouble>((time-time0)/(timeend-time0)));
    47                         if(delta==0.){
    48                                 timeclim=timeend;
    49                         }
    50                         else{
    51                                 timeclim=time0+delta;
    52                         }
    53                 }
    54 
    55                 /*Loop over all the elements of this partition*/
    56                 for(Object* & object : femmodel->elements->objects){
    57                         Element* element=xDynamicCast<Element*>(object);
    58 
    59                         int         numvertices = element->GetNumberOfVertices();
    60                         IssmDouble* smb         = xNew<IssmDouble>(numvertices);
    61                         element->GetInputListOnVerticesAtTime(smb,SmbMassBalanceClimateEnum,timeclim);
    62 
    63                         /*Add input to element and Free memory*/
    64                         element->AddInput(SmbMassBalanceEnum,smb,P1Enum);
    65                         xDelete<IssmDouble>(smb);
    66                 }
    67         }
    6816
    6917}/*}}}*/
    … …  
    410358        //    surface runoff (m/yr water equivalent): runoff
    411359        //    OUTPUT: mass-balance (m/yr ice): agd(NA)
    412         bool isclimatology;
    413         femmodel->parameters->FindParam(&isclimatology,SmbIsclimatologyEnum);
    414360
    415361        /*Loop over all the elements of this partition*/
    … …  
    425371
    426372                /*Recover Smb Components*/
    427                 if(isclimatology){
    428 
    429                         int offsetend;
    430                         IssmDouble time0,timeend,timeclim;
    431                         IssmDouble time,starttime,finaltime;
    432 
    433                         /*Get time parameters*/
    434                         femmodel->parameters->FindParam(&time,TimeEnum);
    435                         femmodel->parameters->FindParam(&finaltime,TimesteppingFinalTimeEnum);
    436                         femmodel->parameters->FindParam(&starttime,TimesteppingStartTimeEnum);
    437 
    438                         //If this is a climatology, we need to repeat the forcing after the final time
    439                         TransientInput* acc_input    = element->inputs->GetTransientInput(SmbAccumulationEnum); _assert_(acc_input);
    440                         TransientInput* evap_input   = element->inputs->GetTransientInput(SmbEvaporationEnum);  _assert_(evap_input);
    441                         TransientInput* runoff_input = element->inputs->GetTransientInput(SmbRunoffEnum);       _assert_(runoff_input);
    442 
    443                         //Get accumulation climatology value
    444                         offsetend = acc_input->GetTimeInputOffset(finaltime);
    445                         time0     = acc_input->GetTimeByOffset(-1);
    446                         timeend   = acc_input->GetTimeByOffset(offsetend);
    447                         timeclim  = time;
    448                         if(time>time0 & timeend>time0){
    449                                 IssmDouble delta=(time-time0) - (timeend-time0)*(reCast<int,IssmDouble>((time-time0)/(timeend-time0)));
    450                                 if(delta==0.)
    451                                  timeclim=timeend;
    452                                 else
    453                                  timeclim=time0+delta;
    454                         }
    455                         element->GetInputListOnVerticesAtTime(acc,SmbAccumulationEnum,timeclim);
    456 
    457                         //Get evaporation climatology value
    458                         offsetend = evap_input->GetTimeInputOffset(finaltime);
    459                         time0     = evap_input->GetTimeByOffset(-1);
    460                         timeend   = evap_input->GetTimeByOffset(offsetend);
    461                         timeclim  = time;
    462                         if(time>time0 & timeend>time0){
    463                                 IssmDouble delta=(time-time0) - (timeend-time0)*(reCast<int,IssmDouble>((time-time0)/(timeend-time0)));
    464                                 if(delta==0.)
    465                                  timeclim=timeend;
    466                                 else
    467                                  timeclim=time0+delta;
    468                         }
    469                         element->GetInputListOnVerticesAtTime(evap,SmbEvaporationEnum,timeclim);
    470 
    471                         //Get runoff climatology value
    472                         offsetend = runoff_input->GetTimeInputOffset(finaltime);
    473                         time0     = runoff_input->GetTimeByOffset(-1);
    474                         timeend   = runoff_input->GetTimeByOffset(offsetend);
    475                         timeclim  = time;
    476                         if(time>time0 & timeend>time0){
    477                                 IssmDouble delta=(time-time0) - (timeend-time0)*(reCast<int,IssmDouble>((time-time0)/(timeend-time0)));
    478                                 if(delta==0.)
    479                                  timeclim=timeend;
    480                                 else
    481                                  timeclim=time0+delta;
    482                         }
    483                         element->GetInputListOnVerticesAtTime(runoff,SmbRunoffEnum,timeclim);
    484                 }
    485                 else{
    486                         element->GetInputListOnVertices(acc,SmbAccumulationEnum);
    487                         element->GetInputListOnVertices(evap,SmbEvaporationEnum);
    488                         element->GetInputListOnVertices(runoff,SmbRunoffEnum);
    489                 }
     373                element->GetInputListOnVertices(acc,SmbAccumulationEnum);
     374                element->GetInputListOnVertices(evap,SmbEvaporationEnum);
     375                element->GetInputListOnVertices(runoff,SmbRunoffEnum);
    490376
    491377                // loop over all vertices
    … …  
    510396        //    refreeze of surface melt (m/yr water equivalent): refreeze
    511397        //    OUTPUT: mass-balance (m/yr ice): agd(NA)
    512         bool isclimatology;
    513         femmodel->parameters->FindParam(&isclimatology,SmbIsclimatologyEnum);
    514398
    515399        /*Loop over all the elements of this partition*/
    … …  
    526410
    527411                /*Recover Smb Components*/
    528                 if (isclimatology){
    529 
    530                         int offsetend;
    531                         IssmDouble time0,timeend,timeclim;
    532                         IssmDouble time,starttime,finaltime;
    533                         femmodel->parameters->FindParam(&time,TimeEnum);
    534                         femmodel->parameters->FindParam(&finaltime,TimesteppingFinalTimeEnum);
    535                         femmodel->parameters->FindParam(&starttime,TimesteppingStartTimeEnum);
    536 
    537 
    538                         //If this is a climatology, we need to repeat the forcing after the final time
    539                         TransientInput* acc_input      = element->inputs->GetTransientInput(SmbAccumulationEnum); _assert_(acc_input);
    540                         TransientInput* evap_input     = element->inputs->GetTransientInput(SmbEvaporationEnum);  _assert_(evap_input);
    541                         TransientInput* melt_input     = element->inputs->GetTransientInput(SmbMeltEnum);         _assert_(melt_input);
    542                         TransientInput* refreeze_input = element->inputs->GetTransientInput(SmbRefreezeEnum);     _assert_(refreeze_input);
    543 
    544                         //Get accumulation climatology value
    545                         offsetend = acc_input->GetTimeInputOffset(finaltime);
    546                         time0     = acc_input->GetTimeByOffset(-1);
    547                         timeend   = acc_input->GetTimeByOffset(offsetend);
    548                         timeclim  = time;
    549                         if(time>time0 & timeend>time0){
    550                                 IssmDouble delta=(time-time0) - (timeend-time0)*(reCast<int,IssmDouble>((time-time0)/(timeend-time0)));
    551                                 if(delta==0.)
    552                                  timeclim=timeend;
    553                                 else
    554                                  timeclim=time0+delta;
    555                         }
    556                         element->GetInputListOnVerticesAtTime(acc,SmbAccumulationEnum,timeclim);
    557 
    558                         //Get evaporation climatology value
    559                         offsetend = evap_input->GetTimeInputOffset(finaltime);
    560                         time0     = evap_input->GetTimeByOffset(-1);
    561                         timeend   = evap_input->GetTimeByOffset(offsetend);
    562                         timeclim  = time;
    563                         if(time>time0 & timeend>time0){
    564                                 IssmDouble delta=(time-time0) - (timeend-time0)*(reCast<int,IssmDouble>((time-time0)/(timeend-time0)));
    565                                 if(delta==0.)
    566                                  timeclim=timeend;
    567                                 else
    568                                  timeclim=time0+delta;
    569                         }
    570                         element->GetInputListOnVerticesAtTime(evap,SmbEvaporationEnum,timeclim);
    571 
    572                         //Get melt climatology value
    573                         offsetend = melt_input->GetTimeInputOffset(finaltime);
    574                         time0     = melt_input->GetTimeByOffset(-1);
    575                         timeend   = melt_input->GetTimeByOffset(offsetend);
    576                         timeclim  = time;
    577                         if(time>time0 & timeend>time0){
    578                                 IssmDouble delta=(time-time0) - (timeend-time0)*(reCast<int,IssmDouble>((time-time0)/(timeend-time0)));
    579                                 if(delta==0.)
    580                                  timeclim=timeend;
    581                                 else
    582                                  timeclim=time0+delta;
    583                         }
    584                         element->GetInputListOnVerticesAtTime(melt,SmbMeltEnum,timeclim);
    585 
    586                         //Get refreeze climatology value
    587                         offsetend = refreeze_input->GetTimeInputOffset(finaltime);
    588                         time0     = refreeze_input->GetTimeByOffset(-1);
    589                         timeend   = refreeze_input->GetTimeByOffset(offsetend);
    590                         timeclim  = time;
    591                         if(time>time0 & timeend>time0){
    592                                 IssmDouble delta=(time-time0) - (timeend-time0)*(reCast<int,IssmDouble>((time-time0)/(timeend-time0)));
    593                                 if(delta==0.)
    594                                  timeclim=timeend;
    595                                 else
    596                                  timeclim=time0+delta;
    597                         }
    598                         element->GetInputListOnVerticesAtTime(refreeze,SmbRefreezeEnum,timeclim);
    599                 }
    600                 else{
    601                         element->GetInputListOnVertices(acc,SmbAccumulationEnum);
    602                         element->GetInputListOnVertices(evap,SmbEvaporationEnum);
    603                         element->GetInputListOnVertices(melt,SmbMeltEnum);
    604                         element->GetInputListOnVertices(refreeze,SmbRefreezeEnum);
    605                 }
     412                element->GetInputListOnVertices(acc,SmbAccumulationEnum);
     413                element->GetInputListOnVertices(evap,SmbEvaporationEnum);
     414                element->GetInputListOnVertices(melt,SmbMeltEnum);
     415                element->GetInputListOnVertices(refreeze,SmbRefreezeEnum);
    606416
    607417                // loop over all vertices

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

    r26204 r26208  
    408408syn keyword cConstant SmbIsaccumulationEnum
    409409syn keyword cConstant SmbIsalbedoEnum
    410 syn keyword cConstant SmbIsclimatologyEnum
    411410syn keyword cConstant SmbIsconstrainsurfaceTEnum
    412411syn keyword cConstant SmbIsd18opdEnum
    … …  
    477476syn keyword cConstant TimesteppingCouplingTimeEnum
    478477syn keyword cConstant TimesteppingFinalTimeEnum
    479 syn keyword cConstant TimesteppingInterpForcingsEnum
     478syn keyword cConstant TimesteppingInterpForcingEnum
    480479syn keyword cConstant TimesteppingCycleForcingEnum
    481480syn keyword cConstant TimesteppingStartTimeEnum
    … …  
    14561455syn keyword cType Cfsurfacesquare
    14571456syn keyword cType Channel
    1458 syn keyword cType classes
    14591457syn keyword cType Constraint
    14601458syn keyword cType Constraints
    … …  
    14631461syn keyword cType ControlInput
    14641462syn keyword cType Covertree
     1463syn keyword cType DataSetParam
    14651464syn keyword cType DatasetInput
    1466 syn keyword cType DataSetParam
    14671465syn keyword cType Definition
    14681466syn keyword cType DependentObject
    … …  
    14771475syn keyword cType ElementInput
    14781476syn keyword cType ElementMatrix
     1477syn keyword cType ElementVector
    14791478syn keyword cType Elements
    1480 syn keyword cType ElementVector
    14811479syn keyword cType ExponentialVariogram
    14821480syn keyword cType ExternalResult
    … …  
    14851483syn keyword cType Friction
    14861484syn keyword cType Gauss
    1487 syn keyword cType GaussianVariogram
    1488 syn keyword cType gaussobjects
    14891485syn keyword cType GaussPenta
    14901486syn keyword cType GaussSeg
    14911487syn keyword cType GaussTetra
    14921488syn keyword cType GaussTria
     1489syn keyword cType GaussianVariogram
    14931490syn keyword cType GenericExternalResult
    14941491syn keyword cType GenericOption
    … …  
    15051502syn keyword cType IssmDirectApplicInterface
    15061503syn keyword cType IssmParallelDirectApplicInterface
    1507 syn keyword cType krigingobjects
    15081504syn keyword cType Load
    15091505syn keyword cType Loads
    … …  
    15161512syn keyword cType Matice
    15171513syn keyword cType Matlitho
    1518 syn keyword cType matrixobjects
    15191514syn keyword cType MatrixParam
    15201515syn keyword cType Misfit
    … …  
    15291524syn keyword cType Observations
    15301525syn keyword cType Option
     1526syn keyword cType OptionUtilities
    15311527syn keyword cType Options
    1532 syn keyword cType OptionUtilities
    15331528syn keyword cType Param
    15341529syn keyword cType Parameters
    … …  
    15441539syn keyword cType Regionaloutput
    15451540syn keyword cType Results
     1541syn keyword cType RiftStruct
    15461542syn keyword cType Riftfront
    1547 syn keyword cType RiftStruct
    15481543syn keyword cType SealevelMasks
    15491544syn keyword cType Seg
    15501545syn keyword cType SegInput
     1546syn keyword cType SegRef
    15511547syn keyword cType Segment
    1552 syn keyword cType SegRef
    15531548syn keyword cType SpcDynamic
    15541549syn keyword cType SpcStatic
    … …  
    15691564syn keyword cType Vertex
    15701565syn keyword cType Vertices
     1566syn keyword cType classes
     1567syn keyword cType gaussobjects
     1568syn keyword cType krigingobjects
     1569syn keyword cType matrixobjects
    15711570syn keyword cType AdjointBalancethickness2Analysis
    15721571syn keyword cType AdjointBalancethicknessAnalysis

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

    r26204 r26208  
    402402        SmbIsaccumulationEnum,
    403403        SmbIsalbedoEnum,
    404         SmbIsclimatologyEnum,
    405404        SmbIsconstrainsurfaceTEnum,
    406405        SmbIsd18opdEnum,
    … …  
    471470        TimesteppingCouplingTimeEnum,
    472471        TimesteppingFinalTimeEnum,
    473         TimesteppingInterpForcingsEnum,
     472        TimesteppingInterpForcingEnum,
    474473        TimesteppingCycleForcingEnum,
    475474        TimesteppingStartTimeEnum,

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

    r26204 r26208  
    410410                case SmbIsaccumulationEnum : return "SmbIsaccumulation";
    411411                case SmbIsalbedoEnum : return "SmbIsalbedo";
    412                 case SmbIsclimatologyEnum : return "SmbIsclimatology";
    413412                case SmbIsconstrainsurfaceTEnum : return "SmbIsconstrainsurfaceT";
    414413                case SmbIsd18opdEnum : return "SmbIsd18opd";
    … …  
    479478                case TimesteppingCouplingTimeEnum : return "TimesteppingCouplingTime";
    480479                case TimesteppingFinalTimeEnum : return "TimesteppingFinalTime";
    481                 case TimesteppingInterpForcingsEnum : return "TimesteppingInterpForcings";
     480                case TimesteppingInterpForcingEnum : return "TimesteppingInterpForcing";
    482481                case TimesteppingCycleForcingEnum : return "TimesteppingCycleForcing";
    483482                case TimesteppingStartTimeEnum : return "TimesteppingStartTime";

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

    r26204 r26208  
    419419              else if (strcmp(name,"SmbIsaccumulation")==0) return SmbIsaccumulationEnum;
    420420              else if (strcmp(name,"SmbIsalbedo")==0) return SmbIsalbedoEnum;
    421               else if (strcmp(name,"SmbIsclimatology")==0) return SmbIsclimatologyEnum;
    422421              else if (strcmp(name,"SmbIsconstrainsurfaceT")==0) return SmbIsconstrainsurfaceTEnum;
    423422              else if (strcmp(name,"SmbIsd18opd")==0) return SmbIsd18opdEnum;
    … …  
    488487              else if (strcmp(name,"TimesteppingCouplingTime")==0) return TimesteppingCouplingTimeEnum;
    489488              else if (strcmp(name,"TimesteppingFinalTime")==0) return TimesteppingFinalTimeEnum;
    490               else if (strcmp(name,"TimesteppingInterpForcings")==0) return TimesteppingInterpForcingsEnum;
     489              else if (strcmp(name,"TimesteppingInterpForcing")==0) return TimesteppingInterpForcingEnum;
    491490              else if (strcmp(name,"TimesteppingCycleForcing")==0) return TimesteppingCycleForcingEnum;
    492491              else if (strcmp(name,"TimesteppingStartTime")==0) return TimesteppingStartTimeEnum;
    … …  
    506505              else if (strcmp(name,"TransientIsgroundingline")==0) return TransientIsgroundinglineEnum;
    507506              else if (strcmp(name,"TransientIshydrology")==0) return TransientIshydrologyEnum;
     507              else if (strcmp(name,"TransientIsmasstransport")==0) return TransientIsmasstransportEnum;
    508508         else stage=5;
    509509   }
    510510   if(stage==5){
    511               if (strcmp(name,"TransientIsmasstransport")==0) return TransientIsmasstransportEnum;
    512               else if (strcmp(name,"TransientIsoceantransport")==0) return TransientIsoceantransportEnum;
     511              if (strcmp(name,"TransientIsoceantransport")==0) return TransientIsoceantransportEnum;
    513512              else if (strcmp(name,"TransientIsmovingfront")==0) return TransientIsmovingfrontEnum;
    514513              else if (strcmp(name,"TransientIsoceancoupling")==0) return TransientIsoceancouplingEnum;
    … …  
    629628              else if (strcmp(name,"EplHead")==0) return EplHeadEnum;
    630629              else if (strcmp(name,"EplHeadOld")==0) return EplHeadOldEnum;
     630              else if (strcmp(name,"EplHeadSlopeX")==0) return EplHeadSlopeXEnum;
    631631         else stage=6;
    632632   }
    633633   if(stage==6){
    634               if (strcmp(name,"EplHeadSlopeX")==0) return EplHeadSlopeXEnum;
    635               else if (strcmp(name,"EplHeadSlopeY")==0) return EplHeadSlopeYEnum;
     634              if (strcmp(name,"EplHeadSlopeY")==0) return EplHeadSlopeYEnum;
    636635              else if (strcmp(name,"EplHeadSubstep")==0) return EplHeadSubstepEnum;
    637636              else if (strcmp(name,"EplHeadTransient")==0) return EplHeadTransientEnum;
    … …  
    752751              else if (strcmp(name,"RadarIcePeriod")==0) return RadarIcePeriodEnum;
    753752              else if (strcmp(name,"RadarPowerMacGregor")==0) return RadarPowerMacGregorEnum;
     753              else if (strcmp(name,"RadarPowerWolff")==0) return RadarPowerWolffEnum;
    754754         else stage=7;
    755755   }
    756756   if(stage==7){
    757               if (strcmp(name,"RadarPowerWolff")==0) return RadarPowerWolffEnum;
    758               else if (strcmp(name,"RheologyBAbsGradient")==0) return RheologyBAbsGradientEnum;
     757              if (strcmp(name,"RheologyBAbsGradient")==0) return RheologyBAbsGradientEnum;
    759758              else if (strcmp(name,"RheologyBInitialguess")==0) return RheologyBInitialguessEnum;
    760759              else if (strcmp(name,"RheologyBInitialguessMisfit")==0) return RheologyBInitialguessMisfitEnum;
    … …  
    875874              else if (strcmp(name,"SmbReini")==0) return SmbReiniEnum;
    876875              else if (strcmp(name,"SmbRunoff")==0) return SmbRunoffEnum;
     876              else if (strcmp(name,"SmbRunoffSubstep")==0) return SmbRunoffSubstepEnum;
    877877         else stage=8;
    878878   }
    879879   if(stage==8){
    880               if (strcmp(name,"SmbRunoffSubstep")==0) return SmbRunoffSubstepEnum;
    881               else if (strcmp(name,"SmbRunoffTransient")==0) return SmbRunoffTransientEnum;
     880              if (strcmp(name,"SmbRunoffTransient")==0) return SmbRunoffTransientEnum;
    882881              else if (strcmp(name,"SmbS0gcm")==0) return SmbS0gcmEnum;
    883882              else if (strcmp(name,"SmbS0p")==0) return SmbS0pEnum;
    … …  
    998997              else if (strcmp(name,"Outputdefinition18")==0) return Outputdefinition18Enum;
    999998              else if (strcmp(name,"Outputdefinition19")==0) return Outputdefinition19Enum;
     999              else if (strcmp(name,"Outputdefinition20")==0) return Outputdefinition20Enum;
    10001000         else stage=9;
    10011001   }
    10021002   if(stage==9){
    1003               if (strcmp(name,"Outputdefinition20")==0) return Outputdefinition20Enum;
    1004               else if (strcmp(name,"Outputdefinition21")==0) return Outputdefinition21Enum;
     1003              if (strcmp(name,"Outputdefinition21")==0) return Outputdefinition21Enum;
    10051004              else if (strcmp(name,"Outputdefinition22")==0) return Outputdefinition22Enum;
    10061005              else if (strcmp(name,"Outputdefinition23")==0) return Outputdefinition23Enum;
    … …  
    11211120              else if (strcmp(name,"BoolParam")==0) return BoolParamEnum;
    11221121              else if (strcmp(name,"Boundary")==0) return BoundaryEnum;
     1122              else if (strcmp(name,"BuddJacka")==0) return BuddJackaEnum;
    11231123         else stage=10;
    11241124   }
    11251125   if(stage==10){
    1126               if (strcmp(name,"BuddJacka")==0) return BuddJackaEnum;
    1127               else if (strcmp(name,"CalvingDev2")==0) return CalvingDev2Enum;
     1126              if (strcmp(name,"CalvingDev2")==0) return CalvingDev2Enum;
    11281127              else if (strcmp(name,"CalvingHab")==0) return CalvingHabEnum;
    11291128              else if (strcmp(name,"CalvingLevermann")==0) return CalvingLevermannEnum;
    … …  
    12441243              else if (strcmp(name,"IntExternalResult")==0) return IntExternalResultEnum;
    12451244              else if (strcmp(name,"ElementInput")==0) return ElementInputEnum;
     1245              else if (strcmp(name,"IntMatExternalResult")==0) return IntMatExternalResultEnum;
    12461246         else stage=11;
    12471247   }
    12481248   if(stage==11){
    1249               if (strcmp(name,"IntMatExternalResult")==0) return IntMatExternalResultEnum;
    1250               else if (strcmp(name,"IntMatParam")==0) return IntMatParamEnum;
     1249              if (strcmp(name,"IntMatParam")==0) return IntMatParamEnum;
    12511250              else if (strcmp(name,"IntParam")==0) return IntParamEnum;
    12521251              else if (strcmp(name,"IntVecParam")==0) return IntVecParamEnum;
    … …  
    13671366              else if (strcmp(name,"SamplingAnalysis")==0) return SamplingAnalysisEnum;
    13681367              else if (strcmp(name,"SamplingSolution")==0) return SamplingSolutionEnum;
     1368              else if (strcmp(name,"SIAApproximation")==0) return SIAApproximationEnum;
    13691369         else stage=12;
    13701370   }
    13711371   if(stage==12){
    1372               if (strcmp(name,"SIAApproximation")==0) return SIAApproximationEnum;
    1373               else if (strcmp(name,"SMBcomponents")==0) return SMBcomponentsEnum;
     1372              if (strcmp(name,"SMBcomponents")==0) return SMBcomponentsEnum;
    13741373              else if (strcmp(name,"SMBd18opdd")==0) return SMBd18opddEnum;
    13751374              else if (strcmp(name,"SMBforcing")==0) return SMBforcingEnum;

  • issm/trunk-jpl/src/m/classes/SMBcomponents.m

    r24806 r26208  
    66classdef SMBcomponents
    77        properties (SetAccess=public)
    8                 isclimatology = 0;
    98                accumulation = NaN;
    109                runoff = NaN;
    … …  
    6564                        md = checkfield(md,'fieldname','smb.averaging','numel',[1],'values',[0 1 2]);
    6665                        md = checkfield(md,'fieldname','smb.requested_outputs','stringrow',1);
    67                         md = checkfield(md,'fieldname','smb.isclimatology','values',[0 1]);
    68                         if (self.isclimatology)
    69                                 md = checkfield(md,'fieldname', 'smb.accumulation', 'size',[md.mesh.numberofvertices+1],...
    70                                                 'message',['accumulation must have md.mesh.numberofvertices+1 rows in order to force a climatology']);
    71                                 md = checkfield(md,'fieldname', 'smb.runoff', 'size',[md.mesh.numberofvertices+1],...
    72                                                 'message',['runoff must have md.mesh.numberofvertices+1 rows in order to force a climatology']);
    73                                 md = checkfield(md,'fieldname', 'smb.evaporation', 'size',[md.mesh.numberofvertices+1],...
    74                                                 'message',['evaporation must have md.mesh.numberofvertices+1 rows in order to force a climatology']);
    75                         end
    7666                end % }}}
    7767                function disp(self) % {{{
    … …  
    8070                        fielddisplay(self,'runoff','amount of ice melt lost from the ice column [m/yr ice eq]');
    8171                        fielddisplay(self,'evaporation','amount of ice lost to evaporative processes [m/yr ice eq]');
    82                         fielddisplay(self,'isclimatology','repeat all forcings when past last forcing time (default false)');
    8372                        fielddisplay(self, 'steps_per_step', 'number of smb steps per time step');
    8473                        fielddisplay(self, 'averaging', 'averaging methods from short to long steps');
    … …  
    10695                        end
    10796                        WriteData(fid,prefix,'data',outputs,'name','md.smb.requested_outputs','format','StringArray');
    108                         WriteData(fid,prefix,'object',self,'class','smb','fieldname','isclimatology','format','Boolean');
    10997
    11098                end % }}}

  • issm/trunk-jpl/src/m/classes/SMBcomponents.py

    r25688 r26208  
    1515
    1616    def __init__(self, *args):  # {{{
    17         self.isclimatology = 0
    1817        self.accumulation = np.nan
    1918        self.runoff = np.nan
    … …  
    3534        s += '{}\n'.format(fielddisplay(self, 'runoff', 'amount of ice melt lost from the ice column [m/yr ice eq]'))
    3635        s += '{}\n'.format(fielddisplay(self, 'evaporation', 'mount of ice lost to evaporative processes [m/yr ice eq]'))
    37         s += '{}\n'.format(fielddisplay(self, 'isclimatology', 'repeat all forcings when past last forcing time (default false)'))
    3836        s += '{}\n'.format(fielddisplay(self, 'steps_per_step', 'number of smb steps per time step'))
    3937        s += '{}\n'.format(fielddisplay(self, 'averaging', 'averaging methods from short to long steps'))
    … …  
    8280        md = checkfield(md, 'fieldname', 'smb.averaging', 'numel', [1], 'values', [0, 1, 2])
    8381        md = checkfield(md, 'fieldname', 'masstransport.requested_outputs', 'stringrow', 1)
    84         md = checkfield(md, 'fieldname', 'smb.isclimatology', 'values', [0, 1])
    85         if self.isclimatology:
    86             md = checkfield(md, 'fieldname', 'smb.accumulation', 'size', [md.mesh.numberofvertices + 1],
    87                 'message', 'accumulation must have md.mesh.numberofvertices+1 rows in order to force a climatology')
    88             md = checkfield(md, 'fieldname', 'smb.runoff', 'size', [md.mesh.numberofvertices + 1], 'message', 'runoff must have md.mesh.numberofvertices+1 rows in order to force a climatology')
    89             md = checkfield(md, 'fieldname', 'smb.evaporation', 'size', [md.mesh.numberofvertices + 1], 'message', 'evaporation must have md.mesh.numberofvertices+1 rows in order to force a climatology')
    9082        return md
    9183    # }}}
    … …  
    10799            outputs = outputscopy
    108100        WriteData(fid, prefix, 'data', outputs, 'name', 'md.smb.requested_outputs', 'format', 'StringArray')
    109         WriteData(fid, prefix, 'object', self, 'class', 'smb', 'fieldname', 'isclimatology', 'format', 'Boolean')
    110         if (self.isclimatology > 0):
    111             md = checkfield(md, 'fieldname', 'smb.accumulation', 'size', [md.mesh.numberofvertices + 1], 'message', 'accumulation must have md.mesh.numberofvertices + 1 rows in order to force a climatology')
    112             md = checkfield(md, 'fieldname', 'smb.runoff', 'size', [md.mesh.numberofvertices + 1], 'message', 'runoff must have md.mesh.numberofvertices + 1 rows in order to force a climatology')
    113             md = checkfield(md, 'fieldname', 'smb.evaporation', 'size', [md.mesh.numberofvertices + 1], 'message', 'evaporation must have md.mesh.numberofvertices + 1 rows in order to force a climatology')
    114101
    115102    # }}}

  • issm/trunk-jpl/src/m/classes/SMBforcing.m

    r25688 r26208  
    66classdef SMBforcing
    77        properties (SetAccess=public)
    8                 isclimatology     = 0;
    98                mass_balance      = NaN;
    109                steps_per_step    = 1;
    … …  
    5554                        md = checkfield(md,'fieldname','smb.steps_per_step','>=',1,'numel',[1]);
    5655                        md = checkfield(md,'fieldname','smb.requested_outputs','stringrow',1);
    57                         md = checkfield(md,'fieldname','smb.isclimatology','values',[0 1]);
    5856                        md = checkfield(md, 'fieldname', 'smb.averaging', 'numel', [1], 'values', [0, 1, 2]);
    59                         if (self.isclimatology)
    60                                 md = checkfield(md,'fieldname', 'smb.mass_balance', 'size',[md.mesh.numberofvertices+1],...
    61                                                 'message',['mass_balance must have md.mesh.numberofvertices+1 rows in order to force a climatology']);
    62                         end
    6357                end % }}}
    6458                function disp(self) % {{{
    6559                        disp(sprintf('   surface forcings parameters:'));
    6660                        fielddisplay(self,'mass_balance','surface mass balance [m/yr ice eq]');
    67                         fielddisplay(self,'isclimatology','repeat all forcings when past last forcing time (default false)');
    6861                        fielddisplay(self, 'steps_per_step', 'number of smb steps per time step');
    6962                        fielddisplay(self,'requested_outputs','additional outputs requested');
    … …  
    9083                        end
    9184                        WriteData(fid,prefix,'data',outputs,'name','md.smb.requested_outputs','format','StringArray');
    92                         WriteData(fid,prefix,'object',self,'class','smb','fieldname','isclimatology','format','Boolean');
    9385
    9486                end % }}}
    … …  
    9789                        writejs1Darray(fid,[modelname '.smb.mass_balance'],self.mass_balance);
    9890                        writejscellstring(fid,[modelname '.smb.requested_outputs'],self.requested_outputs);
    99                         writejs1Darray(fid,[modelname '.smb.isclimatology'],self.isclimatology);
    10091
    10192                end % }}}

  • issm/trunk-jpl/src/m/classes/SMBforcing.py

    r25688 r26208  
    1515
    1616    def __init__(self, *args):  # {{{
    17         self.isclimatology = 0
    1817        self.mass_balance = np.nan
    1918        self.steps_per_step = 1
    … …  
    3130        s = '   surface forcings parameters:\n'
    3231        s += '{}\n'.format(fielddisplay(self, 'mass_balance', 'surface mass balance [m/yr ice eq]'))
    33         s += '{}\n'.format(fielddisplay(self, 'isclimatology', 'repeat all forcings when past last forcing time (default false)'))
    3432        s += '{}\n'.format(fielddisplay(self, 'steps_per_step', 'number of smb steps per time step'))
    3533        s += '{}\n'.format(fielddisplay(self, 'averaging', 'averaging methods from short to long steps'))
    … …  
    6765        md = checkfield(md, 'fieldname', 'smb.averaging', 'numel', [1], 'values', [0, 1, 2])
    6866        md = checkfield(md, 'fieldname', 'masstransport.requested_outputs', 'stringrow', 1)
    69         md = checkfield(md, 'fieldname', 'smb.isclimatology', 'values', [0, 1])
    70         if self.isclimatology:
    71             md = checkfield(md, 'fieldname', 'smb.mass_balance', 'size', [md.mesh.numberofvertices + 1], 'message', 'mass_balance must have md.mesh.numberofvertices + 1 rows in order to force a climatology')
    7267        return md
    7368    # }}}
    … …  
    8782            outputs = outputscopy
    8883        WriteData(fid, prefix, 'data', outputs, 'name', 'md.smb.requested_outputs', 'format', 'StringArray')
    89         WriteData(fid, prefix, 'object', self, 'class', 'smb', 'fieldname', 'isclimatology', 'format', 'Boolean')
    9084    # }}}

  • issm/trunk-jpl/src/m/classes/SMBgemb.m

    r25997 r26208  
    2222                isdensification;
    2323                isturbulentflux;
    24                 isclimatology;
    2524                isconstrainsurfaceT;
    2625
    … …  
    6564                % 4: exponential time decay & wetness [Bougamont & Bamber, 2005]
    6665
    67                 swIdx  = NaN; % apply all SW to top grid cell (0) or allow SW to penetrate surface (1) (default 1, with snow density (taken from Bassford, 2004))
     66                swIdx  = NaN; % apply all SW to top grid cell (0) or allow SW to penetrate surface (1) (default 1, if aIdx=2 function of effective radius (Brun et al., 1992) or else dependent on snow density (taken from Bassford, 2002))
    6867
    6968                denIdx = NaN; %densification model to use (default is 2):
    … …  
    7978                % 0 = Original GEMB value, 150 kg/m^3
    8079                % 1 = Antarctica value of fresh snow density, 350 kg/m^3
    81                 % 2 = Greenland value of fresh snow density, 315 kg/m^3, Fausto et al. (2008)
     80                % 2 = Greenland value of fresh snow density, 315 kg/m^3, Fausto et al. (2018)
    8281                % 3 = Antarctica model of Kaspers et al. (2004)
    8382                % 4 = Greenland model of Kuipers Munneke et al. (2015)
    … …  
    217216                        self.isdensification=1;
    218217                        self.isturbulentflux=1;
    219                         self.isclimatology=0;
    220218                        self.isconstrainsurfaceT=0;
    221219
    … …  
    280278                        md = checkfield(md,'fieldname','smb.isdensification','values',[0 1]);
    281279                        md = checkfield(md,'fieldname','smb.isturbulentflux','values',[0 1]);
    282                         md = checkfield(md,'fieldname','smb.isclimatology','values',[0 1]);
    283280                        md = checkfield(md,'fieldname','smb.isconstrainsurfaceT','values',[0 1]);
    284281
    … …  
    290287                        md = checkfield(md,'fieldname','smb.P','timeseries',1,'NaN',1,'Inf',1,'>=',0,'<=',200,'size',size(self.Ta));
    291288                        md = checkfield(md,'fieldname','smb.eAir','timeseries',1,'NaN',1,'Inf',1,'size',size(self.Ta));
    292 
    293                         if (self.isclimatology)
    294                                 md = checkfield(md,'fieldname', 'smb.Ta', 'size',[md.mesh.numberofelements+1],...
    295                                         'message',['Ta must have md.mesh.numberofelements+1 rows in order to force a climatology']);
    296                                 md = checkfield(md,'fieldname', 'smb.V', 'size',[md.mesh.numberofelements+1],...
    297                                         'message',['V must have md.mesh.numberofelements+1 rows in order to force a climatology']);
    298                                 md = checkfield(md,'fieldname', 'smb.dswrf', 'size',[md.mesh.numberofelements+1],...
    299                                         'message',['dswrf must have md.mesh.numberofelements+1 rows in order to force a climatology']);
    300                                 md = checkfield(md,'fieldname', 'smb.dlwrf', 'size',[md.mesh.numberofelements+1],...
    301                                         'message',['dlwrf must have md.mesh.numberofelements+1 rows in order to force a climatology']);
    302                                 md = checkfield(md,'fieldname', 'smb.P', 'size',[md.mesh.numberofelements+1],...
    303                                         'message',['P must have md.mesh.numberofelements+1 rows in order to force a climatology']);
    304                                 md = checkfield(md,'fieldname', 'smb.eAir', 'size',[md.mesh.numberofelements+1],...
    305                                         'message',['eAir must have md.mesh.numberofelements+1 rows in order to force a climatology']);
    306                         end
    307289
    308290                        md = checkfield(md,'fieldname','smb.Tmean','size',[md.mesh.numberofelements 1],'NaN',1,'Inf',1,'>',273-100,'<',273+100); %-100/100 celsius min/max value
    … …  
    371353                        fielddisplay(self,'isturbulentflux','run turbulant heat fluxes module (default true)');
    372354                        fielddisplay(self,'isconstrainsurfaceT','constrain surface temperatures to air temperature, turn off EC and surface flux contribution to surface temperature change');
    373                         fielddisplay(self,'isclimatology','repeat all forcings when past last forcing time (default false)');
    374355                        fielddisplay(self,'Ta','2 m air temperature, in Kelvin');
    375356                        fielddisplay(self,'V','wind speed (m s-1)');
    … …  
    437418                        end
    438419
    439                         fielddisplay(self,'swIdx','apply all SW to top grid cell (0) or allow SW to penetrate surface (1) [default 1, with snow density (taken from Bassford, 2004)]');
     420                        fielddisplay(self,'swIdx','apply all SW to top grid cell (0) or allow SW to penetrate surface (1) [default 1, if aIdx=2 function of effective radius (Brun et al., 1992) or else dependent on snow density (taken from Bassford, 2002)]');
    440421                        fielddisplay(self,'denIdx',{'densification model to use (default is 2):',...
    441422                                '1 = emperical model of Herron and Langway (1980)',...
    … …  
    449430                                '0 = Original GEMB value, 150 kg/m^3',...
    450431                                '1 = Antarctica value of fresh snow density, 350 kg/m^3',...
    451                                 '2 = Greenland value of fresh snow density, 315 kg/m^3, Fausto et al. (2008)',...
     432                                '2 = Greenland value of fresh snow density, 315 kg/m^3, Fausto et al. (2018)',...
    452433                                '3 = Antarctica model of Kaspers et al. (2004), Make sure to set Vmean accurately',...
    453434                                '4 = Greenland model of Kuipers Munneke et al. (2015)'});
    … …  
    476457                        WriteData(fid,prefix,'object',self,'class','smb','fieldname','isdensification','format','Boolean');
    477458                        WriteData(fid,prefix,'object',self,'class','smb','fieldname','isturbulentflux','format','Boolean');
    478                         WriteData(fid,prefix,'object',self,'class','smb','fieldname','isclimatology','format','Boolean');
    479459                        WriteData(fid,prefix,'object',self,'class','smb','fieldname','isconstrainsurfaceT','format','Boolean');
    480460

  • issm/trunk-jpl/src/m/classes/SMBgemb.py

    r25997 r26208  
    7171            # 4: exponential time decay & wetness [Bougamont & Bamber, 2005]
    7272
    73         self.swIdx                  = np.nan    # apply all SW to top grid cell (0) or allow SW to penetrate surface (1) (default 1, with snow density (taken from Bassford, 2004))
     73        self.swIdx                  = np.nan    # apply all SW to top grid cell (0) or allow SW to penetrate surface (1) (default 1, if aIdx=2 function of effective radius (Brun et al., 1992) or else dependent on snow density (taken from Bassford, 2002))
    7474        self.denIdx                 = np.nan    # densification model to use (default is 2):
    7575            # 1 = emperical model of Herron and Langway (1980)
    … …  
    8484            # 0 = Original GEMB value, 150 kg/m^3
    8585            # 1 = Antarctica value of fresh snow density, 350 kg/m^3
    86             # 2 = Greenland value of fresh snow density, 315 kg/m^3, Fausto et al. (2008)
     86            # 2 = Greenland value of fresh snow density, 315 kg/m^3, Fausto et al. (2018)
    8787            # 3 = Antarctica model of Kaspers et al. (2004)
    8888            # 4 = Greenland model of Kuipers Munneke et al. (2015)
    … …  
    156156        string = "%s\n%s" % (string, fielddisplay(self, 'isturbulentflux', 'run turbulant heat fluxes module (default true)'))
    157157        string = "%s\n%s" % (string, fielddisplay(self, 'isconstrainsurfaceT', 'constrain surface temperatures to air temperature, turn off EC and surface flux contribution to surface temperature change'))
    158         string = "%s\n%s" % (string, fielddisplay(self, 'isclimatology', 'repeat all forcings when past last forcing time (default false)'))
    159158        string = "%s\n%s" % (string, fielddisplay(self, 'Ta', '2 m air temperature, in Kelvin'))
    160159        string = "%s\n%s" % (string, fielddisplay(self, 'V', 'wind speed (m s-1)'))
    … …  
    218217            string = "%s\n%s" % (string, fielddisplay(self, 'K', 'time scale temperature coef. (7) [d]'))
    219218
    220         string = "%s\n%s" % (string, fielddisplay(self, 'swIdx', 'apply all SW to top grid cell (0) or allow SW to penetrate surface (1) [default 1, with snow density (taken from Bassford, 2004)]'))
     219        string = "%s\n%s" % (string, fielddisplay(self, 'swIdx', 'apply all SW to top grid cell (0) or allow SW to penetrate surface (1) [default 1, if aIdx=2 function of effective radius (Brun et al., 1992) or else dependent on snow density (taken from Bassford, 2002)]'))
    221220        string = "%s\n%s" % (string, fielddisplay(self, 'denIdx', ['densification model to use (default is 2):',
    222221                                                                   '1 = emperical model of Herron and Langway (1980)',
    … …  
    230229                                                                     '0 = Original GEMB value, 150 kg/m^3',
    231230                                                                     '1 = Antarctica value of fresh snow density, 350 kg/m^3',
    232                                                                      '2 = Greenland value of fresh snow density, 315 kg/m^3, Fausto et al. (2008)',
     231                                                                     '2 = Greenland value of fresh snow density, 315 kg/m^3, Fausto et al. (2018)',
    233232                                                                     '3 = Antarctica model of Kaspers et al. (2004), Make sure to set Vmean accurately',
    234233                                                                     '4 = Greenland model of Kuipers Munneke et al. (2015)']))
    … …  
    304303        self.isdensification = 1
    305304        self.isturbulentflux = 1
    306         self.isclimatology = 0
    307305        self.isconstrainsurfaceT = 0
    308306
    … …  
    368366        md = checkfield(md, 'fieldname', 'smb.isdensification', 'values', [0, 1])
    369367        md = checkfield(md, 'fieldname', 'smb.isturbulentflux', 'values', [0, 1])
    370         md = checkfield(md, 'fieldname', 'smb.isclimatology', 'values', [0, 1])
    371368        md = checkfield(md, 'fieldname', 'smb.isconstrainsurfaceT', 'values', [0, 1])
    372369
    … …  
    378375        md = checkfield(md, 'fieldname', 'smb.P', 'timeseries', 1, 'NaN', 1, 'Inf', 1, '> = ', 0, '< = ', 200, 'size', np.shape(self.Ta))
    379376        md = checkfield(md, 'fieldname', 'smb.eAir', 'timeseries', 1, 'NaN', 1, 'Inf', 1, 'size', np.shape(self.Ta))
    380 
    381         if (self.isclimatology > 0):
    382             md = checkfield(md, 'fieldname', 'smb.Ta', 'size', [md.mesh.numberofelements + 1], 'message', 'Ta must have md.mesh.numberofelements+1 rows in order to force a climatology')
    383             md = checkfield(md, 'fieldname', 'smb.V', 'size', [md.mesh.numberofelements + 1], 'message', 'V must have md.mesh.numberofelements+1 rows in order to force a climatology')
    384             md = checkfield(md, 'fieldname', 'smb.dswrf', 'size', [md.mesh.numberofelements + 1], 'message', 'dswrf must have md.mesh.numberofelements+1 rows in order to force a climatology')
    385             md = checkfield(md, 'fieldname', 'smb.dlwrf', 'size', [md.mesh.numberofelements + 1], 'message', 'dlwrf must have md.mesh.numberofelements+1 rows in order to force a climatology')
    386             md = checkfield(md, 'fieldname', 'smb.P', 'size', [md.mesh.numberofelements + 1], 'message', 'P must have md.mesh.numberofelements+1 rows in order to force a climatology')
    387             md = checkfield(md, 'fieldname', 'smb.eAir', 'size', [md.mesh.numberofelements + 1], 'message', 'eAir must have md.mesh.numberofelements+1 rows in order to force a climatology')
    388377
    389378        md = checkfield(md, 'fieldname', 'smb.Tmean', 'size', [md.mesh.numberofelements], 'NaN', 1, 'Inf', 1, '>', 273 - 100, '<', 273 + 100)  #-100/100 celsius min/max value
    … …  
    451440        WriteData(fid, prefix, 'object', self, 'class', 'smb', 'fieldname', 'isdensification', 'format', 'Boolean')
    452441        WriteData(fid, prefix, 'object', self, 'class', 'smb', 'fieldname', 'isturbulentflux', 'format', 'Boolean')
    453         WriteData(fid, prefix, 'object', self, 'class', 'smb', 'fieldname', 'isclimatology', 'format', 'Boolean')
    454442        WriteData(fid, prefix, 'object', self, 'class', 'smb', 'fieldname', 'isconstrainsurfaceT', 'format', 'Boolean')
    455443        WriteData(fid, prefix, 'object', self, 'class', 'smb', 'fieldname', 'Ta', 'format', 'DoubleMat', 'mattype', 2, 'timeserieslength', md.mesh.numberofelements + 1, 'yts', yts)

  • issm/trunk-jpl/src/m/classes/SMBmeltcomponents.m

    r24806 r26208  
    66classdef SMBmeltcomponents
    77        properties (SetAccess=public)
    8                 isclimatology = 0;
    98                accumulation = NaN;
    109                evaporation = NaN;
    … …  
    7170                        md = checkfield(md,'fieldname','smb.averaging','numel',[1],'values',[0 1 2]);
    7271                        md = checkfield(md,'fieldname','smb.requested_outputs','stringrow',1);
    73                         md = checkfield(md,'fieldname','smb.isclimatology','values',[0 1]);
    74                         if (self.isclimatology)
    75                                 md = checkfield(md,'fieldname', 'smb.accumulation', 'size',[md.mesh.numberofvertices+1],...
    76                                                 'message',['accumulation must have md.mesh.numberofvertices+1 rows in order to force a climatology']);
    77                                 md = checkfield(md,'fieldname', 'smb.melt', 'size',[md.mesh.numberofvertices+1],...
    78                                                 'message',['melt must have md.mesh.numberofvertices+1 rows in order to force a climatology']);
    79                                 md = checkfield(md,'fieldname', 'smb.refreeze', 'size',[md.mesh.numberofvertices+1],...
    80                                                 'message',['refreeze must have md.mesh.numberofvertices+1 rows in order to force a climatology']);
    81                                 md = checkfield(md,'fieldname', 'smb.evaporation', 'size',[md.mesh.numberofvertices+1],...
    82                                                 'message',['evaporation must have md.mesh.numberofvertices+1 rows in order to force a climatology']);
    83                         end
    8472                end % }}}
    8573                function disp(self) % {{{
    … …  
    8977                        fielddisplay(self,'melt','amount of ice melt in ice column [m/yr ice eq]');
    9078                        fielddisplay(self,'refreeze','amount of ice melt refrozen in ice column [m/yr ice eq]');
    91                         fielddisplay(self,'isclimatology','repeat all forcings when past last forcing time (default false)');
    9279                        fielddisplay(self, 'steps_per_step', 'number of smb steps per time step');
    9380                        fielddisplay(self, 'averaging', 'averaging methods from short to long steps');
    … …  
    117104                        end
    118105                        WriteData(fid,prefix,'data',outputs,'name','md.smb.requested_outputs','format','StringArray');
    119                         WriteData(fid,prefix,'object',self,'class','smb','fieldname','isclimatology','format','Boolean');
    120106
    121107                end % }}}

  • issm/trunk-jpl/src/m/classes/SMBmeltcomponents.py

    r24793 r26208  
    1717        self.runoff = float('NaN')
    1818        self.evaporation = float('NaN')
    19         self.isclimatology = 0
    2019        self.steps_per_step = 1
    2120        self.averaging = 0
    … …  
    2928        string = "%s\n%s" % (string, fielddisplay(self, 'melt', 'amount of ice melt in the ice column [m/yr ice eq]'))
    3029        string = "%s\n%s" % (string, fielddisplay(self, 'refreeze', 'amount of ice melt refrozen in the ice column [m/yr ice eq]'))
    31         string = "%s\n%s" % (string, fielddisplay(self, 'isclimatology', 'repeat all forcings when past last forcing time (default false)'))
    3230        string = "%s\n%s" % (string, fielddisplay(self, 'steps_per_step', 'number of smb steps per time step'))
    3331        string = "%s\n%s" % (string, fielddisplay(self, 'averaging', 'averaging methods from short to long steps'))
    … …  
    8785        md = checkfield(md, 'fieldname', 'smb.averaging', 'numel', [1], 'values', [0, 1, 2])
    8886        md = checkfield(md, 'fieldname', 'masstransport.requested_outputs', 'stringrow', 1)
    89         md = checkfield(md, 'fieldname', 'smb.isclimatology', 'values', [0, 1])
    9087        return md
    9188    # }}}
    … …  
    109106            outputs = outputscopy
    110107        WriteData(fid, prefix, 'data', outputs, 'name', 'md.smb.requested_outputs', 'format', 'StringArray')
    111         WriteData(fid, prefix, 'object', self, 'class', 'smb', 'fieldname', 'isclimatology', 'format', 'Boolean')
    112         if (self.isclimatology > 0):
    113             md = checkfield(md, 'fieldname', 'smb.accumulation', 'size', [md.mesh.numberofvertices + 1], 'message', 'accumulation must have md.mesh.numberofvertices+1 rows in order to force a climatology')
    114             md = checkfield(md, 'fieldname', 'smb.melt', 'size', [md.mesh.numberofvertices + 1], 'message', 'melt must have md.mesh.numberofvertices+1 rows in order to force a climatology')
    115             md = checkfield(md, 'fieldname', 'smb.refreeze', 'size', [md.mesh.numberofvertices + 1], 'message', 'refreeze must have md.mesh.numberofvertices+1 rows in order to force a climatology')
    116             md = checkfield(md, 'fieldname', 'smb.evaporation', 'size', [md.mesh.numberofvertices + 1], 'message', 'evaporation must have md.mesh.numberofvertices+1 rows in order to force a climatology')
    117108
    118109    # }}}

  • issm/trunk-jpl/src/m/classes/model.m

    r26161 r26208  
    166166                                end
    167167                        end
    168                         %2019 Mar 28
     168                        %2019 Mar 28, updated 2021 April 23
    169169                        if isa(md.smb,'SMBcomponents') | isa(md.smb,'SMBmeltcomponents') | isa(md.smb,'SMBforcing') | isa(md.smb,'SMBgemb')
    170170                                if isa(md.smb.isclimatology,'double')
    … …  
    172172                                                md.smb.isclimatology = 0;
    173173                                        end
     174                                        md.timestepping.cycle_forcing=md.smb.isclimatology;
    174175                                end
    175176                        end

  • issm/trunk-jpl/src/m/classes/timestepping.m

    r26195 r26208  
    99                final_time      = 0.;
    1010                time_step       = 0.;
    11                 interp_forcings = 1;
     11                interp_forcing  = 1;
    1212                cycle_forcing   = 0;
    1313                coupling_time   = 0.;
    … …  
    3232                        self.final_time=10.*self.time_step;
    3333
    34                         %should we interpolate forcings between timesteps?
    35                         self.interp_forcings=1;
     34                        %should we interpolate forcing between timesteps?
     35                        self.interp_forcing=1;
    3636                        self.cycle_forcing=0;
    3737                end % }}}
    … …  
    4141                        md = checkfield(md,'fieldname','timestepping.final_time','numel',[1],'NaN',1,'Inf',1);
    4242                        md = checkfield(md,'fieldname','timestepping.time_step','numel',[1],'>=',0,'NaN',1,'Inf',1);
    43                         md = checkfield(md,'fieldname','timestepping.interp_forcings','numel',[1],'values',[0 1]);
     43                        md = checkfield(md,'fieldname','timestepping.interp_forcing','numel',[1],'values',[0 1]);
    4444                        md = checkfield(md,'fieldname','timestepping.cycle_forcing','numel',[1],'values',[0 1]);
    4545                        if self.final_time-self.start_time<0,
    … …  
    5858                        fielddisplay(self,'final_time',['final time to stop the simulation [' unit ']']);
    5959                        fielddisplay(self,'time_step',['length of time steps [' unit ']']);
    60                         fielddisplay(self,'interp_forcings','interpolate in time between requested forcing values ? (0 or 1)');
     60                        fielddisplay(self,'interp_forcing','interpolate in time between requested forcing values ? (0 or 1)');
    6161                        fielddisplay(self,'cycle_forcing','cycle through forcing ? (0 or 1)');
    6262                        fielddisplay(self,'coupling_time',['length of coupling time step with ocean model  [' unit ']']);
    … …  
    7070                        WriteData(fid,prefix,'object',self,'fieldname','final_time','format','Double','scale',scale);
    7171                        WriteData(fid,prefix,'object',self,'fieldname','time_step','format','Double','scale',scale);
    72                         WriteData(fid,prefix,'object',self,'fieldname','interp_forcings','format','Boolean');
     72                        WriteData(fid,prefix,'object',self,'fieldname','interp_forcing','format','Boolean');
    7373                        WriteData(fid,prefix,'object',self,'fieldname','cycle_forcing','format','Boolean');
    7474                        WriteData(fid,prefix,'object',self,'fieldname','coupling_time','format','Double','scale',scale);
    … …  
    7979                        writejsdouble(fid,[modelname '.timestepping.final_time'],self.final_time);
    8080                        writejsdouble(fid,[modelname '.timestepping.time_step'],self.time_step);
    81                         writejsdouble(fid,[modelname '.timestepping.interp_forcings'],self.interp_forcings);
     81                        writejsdouble(fid,[modelname '.timestepping.interp_forcing'],self.interp_forcing);
    8282                        writejsdouble(fid,[modelname '.timestepping.cycle_forcing'],self.cycle_forcing);
    8383

  • issm/trunk-jpl/src/m/classes/timestepping.py

    r26195 r26208  
    1616        self.final_time = 0.
    1717        self.time_step = 0.
    18         self.interp_forcings = 1
     18        self.interp_forcing = 1
    1919        self.cycle_forcing = 0
    2020        self.coupling_time = 0.
    … …  
    3030        string = "%s\n%s" % (string, fielddisplay(self, "final_time", "final time to stop the simulation [yr]"))
    3131        string = "%s\n%s" % (string, fielddisplay(self, "time_step", "length of time steps [yr]"))
    32         string = "%s\n%s" % (string, fielddisplay(self, "interp_forcings", "interpolate in time between requested forcing values ? (0 or 1)"))
     32        string = "%s\n%s" % (string, fielddisplay(self, "interp_forcing", "interpolate in time between requested forcing values ? (0 or 1)"))
    3333        string = "%s\n%s" % (string, fielddisplay(self, "cycle_forcing", "cycle through forcing ? (0 or 1)"))
    3434        string = "%s\n%s" % (string, fielddisplay(self, "coupling_time", "length of coupling time steps with ocean model [yr]"))
    … …  
    4141        #final time
    4242        self.final_time = 10. * self.time_step
    43         #should we interpolate forcings between timesteps?
    44         self.interp_forcings = 1
     43        #should we interpolate forcing between timesteps?
     44        self.interp_forcing = 1
    4545        self.cycle_forcing = 0
    4646
    … …  
    5656            md.checkmessage("timestepping.final_time should be larger than timestepping.start_time")
    5757            md = checkfield(md, 'fieldname', 'timestepping.coupling_time', 'numel', [1], '>=', 0, 'NaN', 1, 'Inf', 1)
    58         md = checkfield(md, 'fieldname', 'timestepping.interp_forcings', 'numel', [1], 'values', [0, 1])
     58        md = checkfield(md, 'fieldname', 'timestepping.interp_forcing', 'numel', [1], 'values', [0, 1])
    5959        md = checkfield(md, 'fieldname', 'timestepping.cycle_forcing', 'numel', [1], 'values', [0, 1])
    6060
    … …  
    6969        WriteData(fid, prefix, 'object', self, 'fieldname', 'final_time', 'format', 'Double', 'scale', yts)
    7070        WriteData(fid, prefix, 'object', self, 'fieldname', 'time_step', 'format', 'Double', 'scale', yts)
    71         WriteData(fid, prefix, 'object', self, 'fieldname', 'interp_forcings', 'format', 'Boolean')
     71        WriteData(fid, prefix, 'object', self, 'fieldname', 'interp_forcing', 'format', 'Boolean')
    7272        WriteData(fid, prefix, 'object', self, 'fieldname', 'cycle_forcing', 'format', 'Boolean')
    7373        WriteData(fid, prefix, 'object', self, 'fieldname', 'coupling_time', 'format', 'Double', 'scale', yts)

  • issm/trunk-jpl/src/m/classes/timesteppingadaptive.m

    r26195 r26208  
    1111                time_step_max   = 0.;
    1212                cfl_coefficient = 0.;
    13                 interp_forcings = 1;
     13                interp_forcing = 1;
    1414                cycle_forcing = 1;
    1515                coupling_time   = 0.;
    … …  
    3838                        self.cfl_coefficient=0.5;
    3939
    40                         %should we interpolate forcings between timesteps?
    41                         self.interp_forcings=1;
     40                        %should we interpolate forcing between timesteps?
     41                        self.interp_forcing=1;
    4242                        self.cycle_forcing=0;
    4343                end % }}}
    … …  
    4949                        md = checkfield(md,'fieldname','timestepping.time_step_max','numel',[1],'>=',md.timestepping.time_step_min,'NaN',1,'Inf',1);
    5050                        md = checkfield(md,'fieldname','timestepping.cfl_coefficient','numel',[1],'>',0,'<=',1);
    51                         md = checkfield(md,'fieldname','timestepping.interp_forcings','numel',[1],'values',[0 1]);
     51                        md = checkfield(md,'fieldname','timestepping.interp_forcing','numel',[1],'values',[0 1]);
    5252                        md = checkfield(md,'fieldname','timestepping.cycle_forcing','numel',[1],'values',[0 1]);
    5353                        md = checkfield(md,'fieldname','timestepping.coupling_time','numel',[1],'>=',md.timestepping.coupling_time,'NaN',1,'Inf',1);
    … …  
    6565                        fielddisplay(self,'time_step_max',['maximum length of time step [' unit ']']);
    6666                        fielddisplay(self,'cfl_coefficient','coefficient applied to cfl condition');
    67                         fielddisplay(self,'interp_forcings','interpolate in time between requested forcing values ? (0 or 1)');
     67                        fielddisplay(self,'interp_forcing','interpolate in time between requested forcing values ? (0 or 1)');
    6868                        fielddisplay(self,'cycle_forcing','cycle through forcing ? (0 or 1)');
    6969                        fielddisplay(self,'coupling_time',['coupling time step with ocean model [' unit ']']);
    … …  
    7979                        WriteData(fid,prefix,'object',self,'class','timestepping','fieldname','time_step_max','format','Double','scale',scale);
    8080                        WriteData(fid,prefix,'object',self,'class','timestepping','fieldname','cfl_coefficient','format','Double');
    81                         WriteData(fid,prefix,'object',self,'class','timestepping','fieldname','interp_forcings','format','Boolean');
     81                        WriteData(fid,prefix,'object',self,'class','timestepping','fieldname','interp_forcing','format','Boolean');
    8282                        WriteData(fid,prefix,'object',self,'class','timestepping','fieldname','cycle_forcing','format','Boolean');
    8383                        WriteData(fid,prefix,'object',self,'class','timestepping','fieldname','coupling_time','format','Double','scale',scale);
    … …  
    9090                        writejsdouble(fid,[modelname '.timesteppingadaptive.time_step_max'],self.time_step_max);
    9191                        writejsdouble(fid,[modelname '.timesteppingadaptive.cfl_coefficient'],self.cfl_coefficient);
    92                         writejsdouble(fid,[modelname '.timesteppingadaptive.interp_forcings'],self.interp_forcings);
     92                        writejsdouble(fid,[modelname '.timesteppingadaptive.interp_forcing'],self.interp_forcing);
    9393                        writejsdouble(fid,[modelname '.timesteppingadaptive.cycle_forcing'],self.cycle_forcing);
    9494                        writejsdouble(fid,[modelname '.timesteppingadaptive.coupling_time'],self.time_step_max);

  • issm/trunk-jpl/src/m/classes/timesteppingadaptive.py

    r26195 r26208  
    1919            self.time_step_max = 0.
    2020            self.cfl_coefficient = 0.
    21             self.interp_forcings = 1
     21            self.interp_forcing = 1
    2222            self.cycle_forcing = 0
    2323            self.coupling_time = 0.
    … …  
    3232            self.start_time = old.start_time
    3333            self.final_time = old.final_time
    34             self.interp_forcings = old.interp_forcings
     34            self.interp_forcing = old.interp_forcing
    3535            self.cycle_forcing = old.cycle_forcing
    3636            self.coupling_time = old.coupling_time
    … …  
    4747        string = "%s\n%s" % (string, fielddisplay(self, "time_step_max", "maximum length of time steps [yr]"))
    4848        string = "%s\n%s" % (string, fielddisplay(self, "cfl_coefficient", "coefficient applied to cfl condition"))
    49         string = "%s\n%s" % (string, fielddisplay(self, "interp_forcings", "interpolate in time between requested forcing values ? (0 or 1)"))
     49        string = "%s\n%s" % (string, fielddisplay(self, "interp_forcing", "interpolate in time between requested forcing values ? (0 or 1)"))
    5050        string = "%s\n%s" % (string, fielddisplay(self, "cycle_forcing", "cycle through forcing ? (0 or 1)"))
    5151        string = "%s\n%s" % (string, fielddisplay(self, "coupling_time", "coupling time steps with ocean model [yr]"))
    … …  
    6161        #time adaptation?
    6262        self.cfl_coefficient = 0.5
    63         #should we interpolate forcings between timesteps?
    64         self.interp_forcings = 1
     63        #should we interpolate forcing between timesteps?
     64        self.interp_forcing = 1
    6565        self.cycle_forcing   = 0
    6666        return self
    … …  
    7575        if self.final_time - self.start_time < 0:
    7676            md.checkmessage("timestepping.final_time should be larger than timestepping.start_time")
    77         md = checkfield(md, 'fieldname', 'timestepping.interp_forcings', 'numel', [1], 'values', [0, 1])
     77        md = checkfield(md, 'fieldname', 'timestepping.interp_forcing', 'numel', [1], 'values', [0, 1])
    7878        md = checkfield(md, 'fieldname', 'timestepping.cycle_forcing', 'numel', [1], 'values', [0, 1])
    7979        md = checkfield(md, 'fieldname', 'timestepping.coupling_time', 'numel', [1], '>=', 0, 'NaN', 1, 'Inf', 1)
    … …  
    9090        WriteData(fid, prefix, 'object', self, 'class', 'timestepping', 'fieldname', 'time_step_max', 'format', 'Double', 'scale', yts)
    9191        WriteData(fid, prefix, 'object', self, 'class', 'timestepping', 'fieldname', 'cfl_coefficient', 'format', 'Double')
    92         WriteData(fid, prefix, 'object', self, 'class', 'timestepping', 'fieldname', 'interp_forcings', 'format', 'Boolean')
     92        WriteData(fid, prefix, 'object', self, 'class', 'timestepping', 'fieldname', 'interp_forcing', 'format', 'Boolean')
    9393        WriteData(fid, prefix, 'object', self, 'class', 'timestepping', 'fieldname', 'cycle_forcing', 'format', 'Boolean')
    9494        WriteData(fid, prefix, 'object', self, 'class', 'timestepping', 'fieldname', 'coupling_time', 'format', 'Double', 'scale', yts)

  • issm/trunk-jpl/test/NightlyRun/test240.m

    r24584 r26208  
    3939md.settings.output_frequency=1;
    4040md.timestepping.final_time=2;
    41 md.timestepping.interp_forcings=0;
     41md.timestepping.interp_forcing=0;
    4242
    4343md=setflowequation(md,'SSA','all');

  • issm/trunk-jpl/test/NightlyRun/test240.py

    r24584 r26208  
    4545md.settings.output_frequency = 1
    4646md.timestepping.final_time = 2
    47 md.timestepping.interp_forcings = 0
     47md.timestepping.interp_forcing = 0
    4848
    4949md = setflowequation(md, 'SSA', 'all')

  • issm/trunk-jpl/test/NightlyRun/test241.m

    r21056 r26208  
    99md.settings.output_frequency=1;
    1010md.timestepping.final_time=4.;
    11 md.timestepping.interp_forcings=0;
     11md.timestepping.interp_forcing=0;
    1212
    1313%Set up transient

  • issm/trunk-jpl/test/NightlyRun/test241.py

    r24384 r26208  
    1919md.settings.output_frequency = 1
    2020md.timestepping.final_time = 4.
    21 md.timestepping.interp_forcings = False
     21md.timestepping.interp_forcing = False
    2222
    2323#Set up transient

  • issm/trunk-jpl/test/NightlyRun/test242.m

    r21056 r26208  
    1010md.settings.output_frequency=1;
    1111md.timestepping.final_time=4;
    12 md.timestepping.interp_forcings=0;
     12md.timestepping.interp_forcing=0;
    1313
    1414%Set up transient

  • issm/trunk-jpl/test/NightlyRun/test242.py

    r24384 r26208  
    2020md.settings.output_frequency = 1
    2121md.timestepping.final_time = 4.
    22 md.timestepping.interp_forcings = False
     22md.timestepping.interp_forcing = False
    2323
    2424#Set up transient

  • issm/trunk-jpl/test/NightlyRun/test243.m

    r25853 r26208  
    4242md.timestepping.final_time=1966;
    4343md.timestepping.time_step=1/365.0;
    44 md.timestepping.interp_forcings=0;
     44md.timestepping.interp_forcing=0;
    4545
    4646%Run transient

  • issm/trunk-jpl/test/NightlyRun/test243.py

    r25853 r26208  
    6060md.timestepping.final_time = 1966.
    6161md.timestepping.time_step = 1.0 / 365
    62 md.timestepping.interp_forcings = 0.
     62md.timestepping.interp_forcing = 0.
    6363
    6464#Run transient

  • issm/trunk-jpl/test/NightlyRun/test244.m

    r25005 r26208  
    4040md.timestepping.final_time=1965.75;
    4141md.timestepping.time_step=1/365.0;
    42 md.timestepping.interp_forcings=0;
     42md.timestepping.interp_forcing=0;
    4343
    4444%dakota version

  • issm/trunk-jpl/test/NightlyRun/test244.py

    r25709 r26208  
    6060md.timestepping.final_time = 1965.75
    6161md.timestepping.time_step = 1. / 365.0
    62 md.timestepping.interp_forcings = 0.
     62md.timestepping.interp_forcing = 0.
    6363
    6464#dakota version

  • issm/trunk-jpl/test/NightlyRun/test247.m

    r25374 r26208  
    9999md.settings.output_frequency=1;
    100100md.timestepping.final_time=2;
    101 md.timestepping.interp_forcings=0;
     101md.timestepping.interp_forcing=0;
    102102
    103103%md.transient.requested_outputs={'default','IceVolumeAboveFloatation','IceVolume','TemperaturePDD','SmbMonthlytemperatures','SmbPrecipitation'};

  • issm/trunk-jpl/test/NightlyRun/test247.py

    r25385 r26208  
    113113md.settings.output_frequency = 1
    114114md.timestepping.final_time = 2
    115 md.timestepping.interp_forcings = 0
     115md.timestepping.interp_forcing = 0
    116116
    117117md.transient.requested_outputs = ['default', 'IceVolumeAboveFloatation','IceVolume','TemperaturePDD']

  • issm/trunk-jpl/test/NightlyRun/test252.m

    r25853 r26208  
    3535md.smb.pAir=md.smb.pAir(:,1:365*8);
    3636
    37 md.smb.isclimatology=1;
     37md.timestepping.cycle_forcing=1;
    3838
    3939%smb settings
    … …  
    4949md.timestepping.final_time=1966.6;
    5050md.timestepping.time_step=1/365.0;
    51 md.timestepping.interp_forcings=0;
     51md.timestepping.interp_forcing=0;
    5252
    5353%Run transient

  • issm/trunk-jpl/test/NightlyRun/test252.py

    r25853 r26208  
    5151md.smb.pAir = md.smb.pAir[:, 0:365 * 8]
    5252
    53 md.smb.isclimatology = 1
     53md.timestepping.cycle_forcing = 1
    5454
    5555#smb settings
    … …  
    6565md.timestepping.final_time = 1966.6
    6666md.timestepping.time_step = 1. / 365.0
    67 md.timestepping.interp_forcings = 0.
     67md.timestepping.interp_forcing = 0.
    6868
    6969#Run transient

  • issm/trunk-jpl/test/NightlyRun/test253.m

    r24760 r26208  
    3737md.smb.pAir=md.smb.pAir(:,1:365*8);
    3838
    39 md.smb.isclimatology=1;
     39md.timestepping.cycle_forcing=1;
    4040md.smb.isconstrainsurfaceT=1;
    4141
    … …  
    5252md.timestepping.final_time=1966.6;
    5353md.timestepping.time_step=1/365.0;
    54 md.timestepping.interp_forcings=0;
     54md.timestepping.interp_forcing=0;
    5555
    5656%Run transient

  • issm/trunk-jpl/test/NightlyRun/test253.py

    r25709 r26208  
    5151md.smb.pAir = md.smb.pAir[:, 0:365 * 8]
    5252
    53 md.smb.isclimatology = 1
     53md.timestepping.cycle_forcing = 1
    5454md.smb.isconstrainsurfaceT = 1
    5555
    … …  
    6666md.timestepping.final_time = 1966.6
    6767md.timestepping.time_step = 1. / 365.0
    68 md.timestepping.interp_forcings = 0.
     68md.timestepping.interp_forcing = 0.
    6969
    7070#Run transient

  • issm/trunk-jpl/test/NightlyRun/test292.m

    r22341 r26208  
    77md.basalforcings=linearbasalforcings(md.basalforcings);
    88md.basalforcings.deepwater_melting_rate=[50 100;0 5];
    9 md.timestepping.interp_forcings=0;
     9md.timestepping.interp_forcing=0;
    1010md=solve(md,'Transient');
    1111

  • issm/trunk-jpl/test/NightlyRun/test292.py

    r23793 r26208  
    1919md.basalforcings = linearbasalforcings(md.basalforcings)
    2020md.basalforcings.deepwater_melting_rate = np.array([[50., 100.], [0., 5.]])
    21 md.timestepping.interp_forcings = 0
     21md.timestepping.interp_forcing = 0
    2222md = solve(md, 'Transient')
    2323

  • issm/trunk-jpl/test/NightlyRun/test3201.m

    r25470 r26208  
    1010
    1111%Create real time series for B
    12 md.timestepping.interp_forcings = 0;
     12md.timestepping.interp_forcing = 0;
    1313md.timestepping.final_time = 2*md.timestepping.time_step;
    1414md.materials.rheology_B = 1.8e8*ones(md.mesh.numberofelements,2);

  • issm/trunk-jpl/test/NightlyRun/test3202.m

    r25416 r26208  
    1010
    1111%Create real time series for B
    12 md.timestepping.interp_forcings = 0;
     12md.timestepping.interp_forcing = 0;
    1313md.timestepping.final_time = 2*md.timestepping.time_step;
    1414md.materials.rheology_B = 1.8e8*ones(md.mesh.numberofvertices,2);

  • issm/trunk-jpl/test/NightlyRun/test3480.m

    r25565 r26208  
    3838        'datatime',0.75);
    3939
    40 md.timestepping.interp_forcings=0;
     40md.timestepping.interp_forcing=0;
    4141md.timestepping.time_step=0.5;
    4242md.timestepping.final_time=1.5;

  • issm/trunk-jpl/test/NightlyRun/test3481.m

    r24862 r26208  
    4545        'datatime',0.75);
    4646
    47 md.timestepping.interp_forcings=1;
     47md.timestepping.interp_forcing=1;
    4848md.timestepping.time_step=0.5;
    4949md.timestepping.final_time=1.5;

  • issm/trunk-jpl/test/NightlyRun/test352.m

    r23816 r26208  
    1616md.transient.isthermal=0;
    1717
    18 md.smb.isclimatology=1;
     18md.timestepping.cycle_forcing=1;
    1919
    2020md=solve(md,'Transient');

  • issm/trunk-jpl/test/NightlyRun/test352.py

    r24384 r26208  
    2626md.transient.isthermal = False
    2727
    28 md.smb.isclimatology = 1
     28md.timestepping.cycle_forcing = 1
    2929
    3030md = solve(md, 'Transient')

  • issm/trunk-jpl/test/NightlyRun/test353.m

    r23816 r26208  
    2020md.transient.isthermal=0;
    2121
    22 md.smb.isclimatology=1;
     22md.timestepping.cycle_forcing=1;
    2323
    2424md=solve(md,'Transient');

  • issm/trunk-jpl/test/NightlyRun/test353.py

    r24384 r26208  
    3030md.transient.isthermal = False
    3131
    32 md.smb.isclimatology = 1
     32md.timestepping.cycle_forcing = 1
    3333
    3434md = solve(md, 'Transient')

  • issm/trunk-jpl/test/NightlyRun/test354.m

    r23816 r26208  
    2121md.transient.isthermal=0;
    2222
    23 md.smb.isclimatology=1;
     23md.timestepping.cycle_forcing=1;
    2424
    2525md=solve(md,'Transient');

  • issm/trunk-jpl/test/NightlyRun/test354.py

    r24384 r26208  
    3131md.transient.isthermal = False
    3232
    33 md.smb.isclimatology = 1
     33md.timestepping.cycle_forcing = 1
    3434
    3535md = solve(md, 'Transient')
Note: See TracChangeset for help on using the changeset viewer.