Index: /issm/trunk-jpl/src/c/Makefile.am =================================================================== --- /issm/trunk-jpl/src/c/Makefile.am (revision 25955) +++ /issm/trunk-jpl/src/c/Makefile.am (revision 25956) @@ -758,5 +758,5 @@ if ANDROID if ANDROIDEXE -bin_PROGRAMS = issm issm_slr +bin_PROGRAMS = issm issm_slc else bin_PROGRAMS = @@ -766,5 +766,5 @@ bin_PROGRAMS = else -bin_PROGRAMS = issm issm_slr +bin_PROGRAMS = issm issm_slc endif endif @@ -786,6 +786,6 @@ issm_CXXFLAGS= $(CXXFLAGS) $(CXXOPTFLAGS) -issm_slr_SOURCES = main/issm_slr.cpp -issm_slr_CXXFLAGS= $(CXXFLAGS) $(CXXOPTFLAGS) +issm_slc_SOURCES = main/issm_slc.cpp +issm_slc_CXXFLAGS= $(CXXFLAGS) $(CXXOPTFLAGS) if OCEAN Index: /issm/trunk-jpl/src/c/analyses/SealevelchangeAnalysis.cpp =================================================================== --- /issm/trunk-jpl/src/c/analyses/SealevelchangeAnalysis.cpp (revision 25955) +++ /issm/trunk-jpl/src/c/analyses/SealevelchangeAnalysis.cpp (revision 25956) @@ -24,5 +24,4 @@ int geodetic=0; int dslmodel=0; - int externalnature=0; int isexternal=0; @@ -171,4 +170,5 @@ int dslmodel=0; int externalnature=0; + int isexternal=0; IssmDouble* G_rigid = NULL; @@ -198,6 +198,6 @@ IssmDouble* partitionice=NULL; IssmDouble* partitionhydro=NULL; - IssmDouble* bslrice_partition=NULL; - IssmDouble* bslrhydro_partition=NULL; + IssmDouble* bslcice_partition=NULL; + IssmDouble* bslchydro_partition=NULL; int npartice,nparthydro,nel; @@ -206,5 +206,6 @@ parameters->AddObject(iomodel->CopyConstantObject("md.dsl.model",DslModelEnum)); parameters->AddObject(iomodel->CopyConstantObject("md.solidearth.isexternal",SolidearthIsExternalEnum)); - parameters->AddObject(iomodel->CopyConstantObject("md.solidearth.external.nature",SolidearthExternalNatureEnum)); + iomodel->FetchData(&isexternal,"md.solidearth.isexternal"); + if(isexternal) parameters->AddObject(iomodel->CopyConstantObject("md.solidearth.external.nature",SolidearthExternalNatureEnum)); parameters->AddObject(iomodel->CopyConstantObject("md.solidearth.settings.runfrequency",SolidearthSettingsRunFrequencyEnum)); parameters->AddObject(iomodel->CopyConstantObject("md.solidearth.settings.reltol",SolidearthSettingsReltolEnum)); @@ -223,8 +224,8 @@ parameters->AddObject(iomodel->CopyConstantObject("md.solidearth.planetradius",SolidearthPlanetRadiusEnum)); parameters->AddObject(iomodel->CopyConstantObject("md.solidearth.settings.glfraction",SolidearthSettingsGlfractionEnum)); - parameters->AddObject(new DoubleParam(CumBslrEnum,0.0)); - parameters->AddObject(new DoubleParam(CumBslrIceEnum,0.0)); - parameters->AddObject(new DoubleParam(CumBslrHydroEnum,0.0)); - parameters->AddObject(new DoubleParam(CumGmtslrEnum,0.0)); + parameters->AddObject(new DoubleParam(CumBslcEnum,0.0)); + parameters->AddObject(new DoubleParam(CumBslcIceEnum,0.0)); + parameters->AddObject(new DoubleParam(CumBslcHydroEnum,0.0)); + parameters->AddObject(new DoubleParam(CumGmtslcEnum,0.0)); /*compute planet area and plug into parameters:*/ @@ -240,6 +241,6 @@ parameters->AddObject(new DoubleMatParam(SolidearthPartitionIceEnum,partitionice,nel,1)); parameters->AddObject(iomodel->CopyConstantObject("md.solidearth.npartice",SolidearthNpartIceEnum)); - bslrice_partition=xNewZeroInit(npartice); - parameters->AddObject(new DoubleMatParam(CumBslrIcePartitionEnum,bslrice_partition,npartice,1)); + bslcice_partition=xNewZeroInit(npartice); + parameters->AddObject(new DoubleMatParam(CumBslcIcePartitionEnum,bslcice_partition,npartice,1)); xDelete(partitionice); } @@ -250,6 +251,6 @@ parameters->AddObject(new DoubleMatParam(SolidearthPartitionHydroEnum,partitionhydro,nel,1)); parameters->AddObject(iomodel->CopyConstantObject("md.solidearth.nparthydro",SolidearthNpartHydroEnum)); - bslrhydro_partition=xNewZeroInit(nparthydro); - parameters->AddObject(new DoubleMatParam(CumBslrHydroPartitionEnum,bslrhydro_partition,nparthydro,1)); + bslchydro_partition=xNewZeroInit(nparthydro); + parameters->AddObject(new DoubleMatParam(CumBslcHydroPartitionEnum,bslchydro_partition,nparthydro,1)); xDelete(partitionhydro); } @@ -274,19 +275,21 @@ } /*}}}*/ /*Deal with external multi-model ensembles: {{{*/ - iomodel->FetchData(&externalnature,"md.solidearth.external.nature"); - if(externalnature>=3){ - IssmDouble modelid; - int nummodels; - - /*create double param, not int param, because Dakota will be updating it as a double potentially: */ - iomodel->FetchData(&modelid,"md.solidearth.external.modelid"); - parameters->AddObject(new DoubleParam(SolidearthExternalModelidEnum,modelid)); - parameters->AddObject(iomodel->CopyConstantObject("md.solidearth.external.nummodels",SolidearthExternalNummodelsEnum)); - iomodel->FetchData(&nummodels,"md.solidearth.external.nummodels"); - - /*quick checks: */ - if(nummodels<=0)_error_("mme solidearth solution object in md.solidearth.external field should contain at least 1 ensemble model!"); - if(modelid<=0 || modelid>nummodels)_error_("modelid field in md.solidearth.external field should be between 1 and the number of ensemble runs!"); - } /*}}}*/ + if(isexternal){ + iomodel->FetchData(&externalnature,"md.solidearth.external.nature"); + if(externalnature>=3){ + IssmDouble modelid; + int nummodels; + + /*create double param, not int param, because Dakota will be updating it as a double potentially: */ + iomodel->FetchData(&modelid,"md.solidearth.external.modelid"); + parameters->AddObject(new DoubleParam(SolidearthExternalModelidEnum,modelid)); + parameters->AddObject(iomodel->CopyConstantObject("md.solidearth.external.nummodels",SolidearthExternalNummodelsEnum)); + iomodel->FetchData(&nummodels,"md.solidearth.external.nummodels"); + + /*quick checks: */ + if(nummodels<=0)_error_("mme solidearth solution object in md.solidearth.external field should contain at least 1 ensemble model!"); + if(modelid<=0 || modelid>nummodels)_error_("modelid field in md.solidearth.external field should be between 1 and the number of ensemble runs!"); + } /*}}}*/ + } /*Deal with elasticity {{{*/ Index: /issm/trunk-jpl/src/c/classes/Elements/Tria.cpp =================================================================== --- /issm/trunk-jpl/src/c/classes/Elements/Tria.cpp (revision 25955) +++ /issm/trunk-jpl/src/c/classes/Elements/Tria.cpp (revision 25956) @@ -5826,5 +5826,5 @@ /*output: */ - IssmDouble bslrice=0; + IssmDouble bslcice=0; /*elastic green function:*/ @@ -5842,6 +5842,6 @@ constant=0; this->AddInput(SealevelBarystaticMaskEnum,&constant,P0Enum); #endif - bslrice=0; - return bslrice; + bslcice=0; + return bslcice; } @@ -5852,6 +5852,6 @@ this->AddInput(SealevelBarystaticMaskEnum,&constant,P0Enum); #endif - bslrice=0; - return bslrice; + bslcice=0; + return bslcice; } @@ -5924,6 +5924,6 @@ _assert_(oceanarea>0.); if(scaleoceanarea) oceanarea=3.619e+14; // use true ocean area, m^2 - bslrice = rho_ice*area*phi*I/(oceanarea*rho_water); - _assert_(!xIsNan(bslrice)); + bslcice = rho_ice*area*phi*I/(oceanarea*rho_water); + _assert_(!xIsNan(bslcice)); if(computerigid){ @@ -5935,11 +5935,11 @@ } - /*Plug bslrice into barystatic contribution vector:*/ + /*Plug bslcice into barystatic contribution vector:*/ if(barystatic_contribution){ id=reCast(partition[this->Sid()])+1; - barystatic_contribution->SetValue(id,bslrice,ADD_VAL); + barystatic_contribution->SetValue(id,bslcice,ADD_VAL); } /*return :*/ - return bslrice; + return bslcice; } /*}}}*/ @@ -5963,17 +5963,17 @@ /*output:*/ - IssmDouble bslrhydro = 0; + IssmDouble bslchydro = 0; /*early return if we are on an ice cap. Nop, we may have hydro * and ice on the same masscon:*/ /*if(masks->isiceonly[this->lid]){ - bslrhydro=0; - return bslrhydro; + bslchydro=0; + return bslchydro; }*/ /*early return if we are fully floating:*/ if (masks->isfullyfloating[this->lid]){ - bslrhydro=0; - return bslrhydro; + bslchydro=0; + return bslchydro; } @@ -6000,6 +6000,6 @@ _assert_(oceanarea>0.); if(scaleoceanarea) oceanarea=3.619e+14; // use true ocean area, m^2 - bslrhydro = rho_freshwater*area*phi*W/(oceanarea*rho_water); - _assert_(!xIsNan(bslrhydro)); + bslchydro = rho_freshwater*area*phi*W/(oceanarea*rho_water); + _assert_(!xIsNan(bslchydro)); if(computeelastic){ @@ -6011,11 +6011,11 @@ } - /*Plug bslrice into barystatic contribution vector:*/ + /*Plug bslcice into barystatic contribution vector:*/ if(barystatic_contribution){ id=reCast(partition[this->Sid()])+1; - barystatic_contribution->SetValue(id,bslrhydro,ADD_VAL); + barystatic_contribution->SetValue(id,bslchydro,ADD_VAL); } /*output:*/ - return bslrhydro; + return bslchydro; } /*}}}*/ Index: /issm/trunk-jpl/src/c/classes/FemModel.cpp =================================================================== --- /issm/trunk-jpl/src/c/classes/FemModel.cpp (revision 25955) +++ /issm/trunk-jpl/src/c/classes/FemModel.cpp (revision 25956) @@ -849,5 +849,5 @@ case TransientSolutionEnum:{ /*We have multiple analyses here, process one by one*/ - bool isSIA,isFS,isthermal,isenthalpy,ismasstransport,isgroundingline,isstressbalance,ismovingfront,ishydrology,isdamage,issmb,isslr,isesa,isgia; + bool isSIA,isFS,isthermal,isenthalpy,ismasstransport,isgroundingline,isstressbalance,ismovingfront,ishydrology,isdamage,issmb,isslc,isesa,isgia; iomodel->FindConstant(&isthermal,"md.transient.isthermal"); iomodel->FindConstant(&ismovingfront,"md.transient.ismovingfront"); @@ -858,5 +858,5 @@ iomodel->FindConstant(&ishydrology,"md.transient.ishydrology"); iomodel->FindConstant(&issmb,"md.transient.issmb"); - iomodel->FindConstant(&isslr,"md.transient.isslr"); + iomodel->FindConstant(&isslc,"md.transient.isslc"); iomodel->FindConstant(&isesa,"md.transient.isesa"); iomodel->FindConstant(&isgia,"md.transient.isgia"); @@ -898,5 +898,5 @@ analyses_temp[numanalyses++]=DamageEvolutionAnalysisEnum; } - if(isslr){ + if(isslc){ analyses_temp[numanalyses++]=GiaAnalysisEnum; analyses_temp[numanalyses++]=SealevelchangeAnalysisEnum; @@ -4813,11 +4813,11 @@ #endif #ifdef _HAVE_SEALEVELRISE_ -void FemModel::SealevelchangeBarystatic(Vector* pRSLgi, IssmDouble* poceanarea, IssmDouble* pbslr,IssmDouble* pbslrice, IssmDouble* pbslrhydro, IssmDouble** pbslrice_partition,IssmDouble** pbslrhydro_partition,SealevelMasks* masks) { /*{{{*/ +void FemModel::SealevelchangeBarystatic(Vector* pRSLgi, IssmDouble* poceanarea, IssmDouble* pbslc,IssmDouble* pbslcice, IssmDouble* pbslchydro, IssmDouble** pbslcice_partition,IssmDouble** pbslchydro_partition,SealevelMasks* masks) { /*{{{*/ /*serialized vectors:*/ - IssmDouble bslrice = 0.; - IssmDouble bslrice_cpu = 0.; - IssmDouble bslrhydro = 0.; - IssmDouble bslrhydro_cpu = 0.; + IssmDouble bslcice = 0.; + IssmDouble bslcice_cpu = 0.; + IssmDouble bslchydro = 0.; + IssmDouble bslchydro_cpu = 0.; IssmDouble area = 0.; IssmDouble oceanarea = 0.; @@ -4825,11 +4825,11 @@ int bp_compute_fingerprints= 0; - Vector* bslrice_partition=NULL; - IssmDouble* bslrice_partition_serial=NULL; + Vector* bslcice_partition=NULL; + IssmDouble* bslcice_partition_serial=NULL; IssmDouble* partitionice=NULL; int npartice,nel; - Vector* bslrhydro_partition=NULL; - IssmDouble* bslrhydro_partition_serial=NULL; + Vector* bslchydro_partition=NULL; + IssmDouble* bslchydro_partition_serial=NULL; IssmDouble* partitionhydro=NULL; int nparthydro; @@ -4859,5 +4859,5 @@ if(npartice){ this->parameters->FindParam(&partitionice,&nel,NULL,SolidearthPartitionIceEnum); - bslrice_partition= new Vector(npartice); + bslcice_partition= new Vector(npartice); } @@ -4865,20 +4865,20 @@ if(nparthydro){ this->parameters->FindParam(&partitionhydro,&nel,NULL,SolidearthPartitionHydroEnum); - bslrhydro_partition= new Vector(nparthydro); + bslchydro_partition= new Vector(nparthydro); } /*Call the barystatic sea level change core for ice : */ - bslrice_cpu=0; + bslcice_cpu=0; for(Object* & object : this->elements->objects){ Element* element = xDynamicCast(object); - bslrice_cpu+=element->SealevelchangeBarystaticIce(RSLgi,masks, bslrice_partition,partitionice,oceanarea); + bslcice_cpu+=element->SealevelchangeBarystaticIce(RSLgi,masks, bslcice_partition,partitionice,oceanarea); } /*Call the barystatic sea level change core for hydro: */ - bslrhydro_cpu=0; + bslchydro_cpu=0; for(int i=0;iSize();i++){ Element* element=xDynamicCast(elements->GetObjectByOffset(i)); - bslrhydro_cpu+=element->SealevelchangeBarystaticHydro(RSLgi,masks, bslrhydro_partition,partitionhydro,oceanarea); + bslchydro_cpu+=element->SealevelchangeBarystaticHydro(RSLgi,masks, bslchydro_partition,partitionhydro,oceanarea); } @@ -4897,20 +4897,20 @@ /*Sum all barystatic components from all cpus:*/ - ISSM_MPI_Reduce (&bslrice_cpu,&bslrice,1,ISSM_MPI_DOUBLE,ISSM_MPI_SUM,0,IssmComm::GetComm() ); - ISSM_MPI_Bcast(&bslrice,1,ISSM_MPI_DOUBLE,0,IssmComm::GetComm()); - _assert_(!xIsNan(bslrice)); - - ISSM_MPI_Reduce (&bslrhydro_cpu,&bslrhydro,1,ISSM_MPI_DOUBLE,ISSM_MPI_SUM,0,IssmComm::GetComm() ); - ISSM_MPI_Bcast(&bslrhydro,1,ISSM_MPI_DOUBLE,0,IssmComm::GetComm()); - _assert_(!xIsNan(bslrhydro)); + ISSM_MPI_Reduce (&bslcice_cpu,&bslcice,1,ISSM_MPI_DOUBLE,ISSM_MPI_SUM,0,IssmComm::GetComm() ); + ISSM_MPI_Bcast(&bslcice,1,ISSM_MPI_DOUBLE,0,IssmComm::GetComm()); + _assert_(!xIsNan(bslcice)); + + ISSM_MPI_Reduce (&bslchydro_cpu,&bslchydro,1,ISSM_MPI_DOUBLE,ISSM_MPI_SUM,0,IssmComm::GetComm() ); + ISSM_MPI_Bcast(&bslchydro,1,ISSM_MPI_DOUBLE,0,IssmComm::GetComm()); + _assert_(!xIsNan(bslchydro)); /*Take care of partition vectors:*/ - if(bslrice_partition){ - bslrice_partition->Assemble(); - bslrice_partition_serial=bslrice_partition->ToMPISerial(); - } - if(bslrhydro_partition){ - bslrhydro_partition->Assemble(); - bslrhydro_partition_serial=bslrhydro_partition->ToMPISerial(); + if(bslcice_partition){ + bslcice_partition->Assemble(); + bslcice_partition_serial=bslcice_partition->ToMPISerial(); + } + if(bslchydro_partition){ + bslchydro_partition->Assemble(); + bslchydro_partition_serial=bslchydro_partition->ToMPISerial(); } @@ -4919,6 +4919,6 @@ xDelete(indices); xDelete(RSLgi); - if(bslrhydro_partition)delete bslrhydro_partition; - if(bslrice_partition)delete bslrice_partition; + if(bslchydro_partition)delete bslchydro_partition; + if(bslcice_partition)delete bslcice_partition; if(partitionhydro)xDelete(partitionhydro); if(partitionice)xDelete(partitionice); @@ -4926,9 +4926,9 @@ /*Assign output pointers:*/ *poceanarea = oceanarea; - *pbslrice = bslrice; - *pbslrhydro = bslrhydro; - *pbslr=bslrhydro+bslrice; - *pbslrice_partition=bslrice_partition_serial; - *pbslrhydro_partition=bslrhydro_partition_serial; + *pbslcice = bslcice; + *pbslchydro = bslchydro; + *pbslc=bslchydro+bslcice; + *pbslcice_partition=bslcice_partition_serial; + *pbslchydro_partition=bslchydro_partition_serial; } Index: /issm/trunk-jpl/src/c/classes/FemModel.h =================================================================== --- /issm/trunk-jpl/src/c/classes/FemModel.h (revision 25955) +++ /issm/trunk-jpl/src/c/classes/FemModel.h (revision 25956) @@ -167,5 +167,5 @@ #endif #ifdef _HAVE_SEALEVELRISE_ - void SealevelchangeBarystatic(Vector* pRSLgi, IssmDouble* poceanarea, IssmDouble* pbslr,IssmDouble* pbslrice, IssmDouble* pbslrhydro, IssmDouble** pbslrice_partition,IssmDouble** pbslrhydro_partition, SealevelMasks* masks); + void SealevelchangeBarystatic(Vector* pRSLgi, IssmDouble* poceanarea, IssmDouble* pbslc,IssmDouble* pbslcice, IssmDouble* pbslchydro, IssmDouble** pbslcice_partition,IssmDouble** pbslchydro_partition, SealevelMasks* masks); void SealevelchangeSal(Vector* pSgo, Vector* pSg_old, SealevelMasks* masks,bool verboseconvolution); void SealevelchangeRotationalFeedback(Vector* pRSLgo_rot, Vector* pRSLg_old, IssmDouble* pIxz, IssmDouble* pIyz, IssmDouble* pIzz, SealevelMasks* masks); Index: /issm/trunk-jpl/src/c/cores/cores.h =================================================================== --- /issm/trunk-jpl/src/c/cores/cores.h (revision 25955) +++ /issm/trunk-jpl/src/c/cores/cores.h (revision 25956) @@ -81,5 +81,5 @@ void TransferSealevel(FemModel* femmodel,int forcingenum); void EarthMassTransport(FemModel* femmodel); -void slrconvergence(bool* pconverged, Vector* RSLg,Vector* RSLg_old,IssmDouble eps_rel,IssmDouble eps_abs); +void slcconvergence(bool* pconverged, Vector* RSLg,Vector* RSLg_old,IssmDouble eps_rel,IssmDouble eps_abs); //solution configuration Index: /issm/trunk-jpl/src/c/cores/sealevelchange_core.cpp =================================================================== --- /issm/trunk-jpl/src/c/cores/sealevelchange_core.cpp (revision 25955) +++ /issm/trunk-jpl/src/c/cores/sealevelchange_core.cpp (revision 25956) @@ -22,5 +22,5 @@ /*Parameters, variables:*/ bool save_results; - bool isslr=0; + bool isslc=0; bool isgia=0; int grd=0; @@ -30,5 +30,5 @@ /*Retrieve parameters:*/ - femmodel->parameters->FindParam(&isslr,TransientIsslrEnum); + femmodel->parameters->FindParam(&isslc,TransientIsslcEnum); femmodel->parameters->FindParam(&solution_type,SolutionTypeEnum); femmodel->parameters->FindParam(&save_results,SaveResultsEnum); @@ -39,10 +39,10 @@ /*in case we are running SealevelchangeSolutionEnum, then bypass transient settings:*/ if(solution_type==SealevelchangeSolutionEnum){ - isslr=1; + isslc=1; isgia=1; } /*Should we be here?:*/ - if(!isslr)return; + if(!isslc)return; /*Verbose: */ @@ -115,10 +115,10 @@ /*parameters: */ - bool isslr=0; + bool isslc=0; int solution_type; IssmDouble dt; /*Retrieve parameters:*/ - femmodel->parameters->FindParam(&isslr,TransientIsslrEnum); + femmodel->parameters->FindParam(&isslc,TransientIsslcEnum); femmodel->parameters->FindParam(&horiz,SolidearthSettingsHorizEnum); femmodel->parameters->FindParam(&dt,TimesteppingTimeStepEnum); @@ -126,8 +126,8 @@ /*in case we are running SealevelchangeSolutionEnum, then bypass transient settings:*/ - if(solution_type==SealevelchangeSolutionEnum)isslr=1; + if(solution_type==SealevelchangeSolutionEnum)isslc=1; /*Should we be here?:*/ - if(!isslr)return; + if(!isslc)return; /*Verbose: */ @@ -331,5 +331,5 @@ /*parameters: */ - bool isslr=0; + bool isslc=0; int solution_type; IssmDouble dt; @@ -337,18 +337,18 @@ IssmDouble time; - IssmDouble cumgmtslr=0; - IssmDouble cumbslr=0; - IssmDouble cumgmslr=0; - IssmDouble gmtslr=0; + IssmDouble cumgmtslc=0; + IssmDouble cumbslc=0; + IssmDouble cumgmslc=0; + IssmDouble gmtslc=0; /*Retrieve parameters:*/ femmodel->parameters->FindParam(&solution_type,SolutionTypeEnum); - femmodel->parameters->FindParam(&isslr,TransientIsslrEnum); + femmodel->parameters->FindParam(&isslc,TransientIsslcEnum); /*in case we are running SealevelchangeSolutionEnum, then bypass transient settings:*/ - if(solution_type==SealevelchangeSolutionEnum)isslr=1; + if(solution_type==SealevelchangeSolutionEnum)isslc=1; /*Should we be here?:*/ - if(!isslr)return; + if(!isslc)return; /*Verbose: */ @@ -366,13 +366,13 @@ /*cumulate thermal steric rate:*/ - femmodel->parameters->FindParam(&cumgmtslr,CumGmtslrEnum); - femmodel->parameters->FindParam(&cumbslr,CumBslrEnum); - - gmtslr=steric_rate_g->Max()*dt; - cumgmtslr+=gmtslr; - cumgmslr=cumbslr+cumgmtslr; - - femmodel->parameters->SetParam(cumgmtslr,CumGmtslrEnum); - femmodel->parameters->SetParam(cumgmslr,CumGmslrEnum); + femmodel->parameters->FindParam(&cumgmtslc,CumGmtslcEnum); + femmodel->parameters->FindParam(&cumbslc,CumBslcEnum); + + gmtslc=steric_rate_g->Max()*dt; + cumgmtslc+=gmtslc; + cumgmslc=cumbslc+cumgmtslc; + + femmodel->parameters->SetParam(cumgmtslc,CumGmtslcEnum); + femmodel->parameters->SetParam(cumgmslc,CumGmslcEnum); /*Outputs some metrics:*/ @@ -380,7 +380,7 @@ femmodel->parameters->FindParam(&time,TimeEnum); - femmodel->results->AddResult(new GenericExternalResult(femmodel->results->Size()+1,GmtslrEnum,gmtslr,step,time)); - femmodel->results->AddResult(new GenericExternalResult(femmodel->results->Size()+1,CumGmtslrEnum,cumgmtslr,step,time)); - femmodel->results->AddResult(new GenericExternalResult(femmodel->results->Size()+1,CumGmslrEnum,cumgmslr,step,time)); + femmodel->results->AddResult(new GenericExternalResult(femmodel->results->Size()+1,GmtslcEnum,gmtslc,step,time)); + femmodel->results->AddResult(new GenericExternalResult(femmodel->results->Size()+1,CumGmtslcEnum,cumgmtslc,step,time)); + femmodel->results->AddResult(new GenericExternalResult(femmodel->results->Size()+1,CumGmslcEnum,cumgmslc,step,time)); /*update element inputs:*/ @@ -480,18 +480,18 @@ /*barystatic contribution:*/ - IssmDouble bslr; - IssmDouble bslrice; - IssmDouble* bslrice_partition=NULL; - IssmDouble bslrhydro; - IssmDouble* bslrhydro_partition=NULL; - IssmDouble cumbslr; - IssmDouble cumbslrice; - IssmDouble cumbslrhydro; - IssmDouble* cumbslrice_partition=NULL; + IssmDouble bslc; + IssmDouble bslcice; + IssmDouble* bslcice_partition=NULL; + IssmDouble bslchydro; + IssmDouble* bslchydro_partition=NULL; + IssmDouble cumbslc; + IssmDouble cumbslcice; + IssmDouble cumbslchydro; + IssmDouble* cumbslcice_partition=NULL; int npartice; - IssmDouble* cumbslrhydro_partition=NULL; + IssmDouble* cumbslchydro_partition=NULL; int nparthydro; - if(VerboseSolution()) _printf0_(" computing bslr components on ice\n"); + if(VerboseSolution()) _printf0_(" computing bslc components on ice\n"); /*Figure out size of g-set deflection vector and allocate solution vector: */ @@ -501,54 +501,54 @@ femmodel->parameters->FindParam(&step,StepEnum); femmodel->parameters->FindParam(&time,TimeEnum); - femmodel->parameters->FindParam(&cumbslr,CumBslrEnum); - femmodel->parameters->FindParam(&cumbslrice,CumBslrIceEnum); - femmodel->parameters->FindParam(&cumbslrhydro,CumBslrHydroEnum); + femmodel->parameters->FindParam(&cumbslc,CumBslcEnum); + femmodel->parameters->FindParam(&cumbslcice,CumBslcIceEnum); + femmodel->parameters->FindParam(&cumbslchydro,CumBslcHydroEnum); femmodel->parameters->FindParam(&npartice,SolidearthNpartIceEnum); femmodel->parameters->FindParam(&nparthydro,SolidearthNpartHydroEnum); - if(npartice) femmodel->parameters->FindParam(&cumbslrice_partition,&npartice,NULL,CumBslrIcePartitionEnum); - if(nparthydro) femmodel->parameters->FindParam(&cumbslrhydro_partition,&nparthydro,NULL,CumBslrHydroPartitionEnum); + if(npartice) femmodel->parameters->FindParam(&cumbslcice_partition,&npartice,NULL,CumBslcIcePartitionEnum); + if(nparthydro) femmodel->parameters->FindParam(&cumbslchydro_partition,&nparthydro,NULL,CumBslcHydroPartitionEnum); /*Initialize:*/ RSLgi = new Vector(gsize); - /*call the bslr main module: */ - femmodel->SealevelchangeBarystatic(RSLgi,&oceanarea,&bslr, &bslrice, &bslrhydro, &bslrice_partition, &bslrhydro_partition,masks); //this computes + /*call the bslc main module: */ + femmodel->SealevelchangeBarystatic(RSLgi,&oceanarea,&bslc, &bslcice, &bslchydro, &bslcice_partition, &bslchydro_partition,masks); //this computes /*we need to average RSLgi over the ocean: RHS term 4 in Eq.4 of Farrel and clarke. Only the elements can do that: */ RSLgi_oceanaverage=femmodel->SealevelchangeOceanAverage(RSLgi,masks, oceanarea); - /*RSLg is the sum of the pure bslr component (term 3) and the contribution from the perturbation to the graviation potential due to the + /*RSLg is the sum of the pure bslc component (term 3) and the contribution from the perturbation to the graviation potential due to the * presence of ice (terms 1 and 4 in Eq.4 of Farrel and Clarke):*/ - RSLgi->Shift(-bslr-RSLgi_oceanaverage); - - /*save bslr and cumulated bslr value for results:{{{ */ - femmodel->results->AddResult(new GenericExternalResult(femmodel->results->Size()+1,BslrEnum,-bslr,step,time)); - femmodel->results->AddResult(new GenericExternalResult(femmodel->results->Size()+1,BslrIceEnum,-bslrice,step,time)); - femmodel->results->AddResult(new GenericExternalResult(femmodel->results->Size()+1,BslrHydroEnum,-bslrhydro,step,time)); + RSLgi->Shift(-bslc-RSLgi_oceanaverage); + + /*save bslc and cumulated bslc value for results:{{{ */ + femmodel->results->AddResult(new GenericExternalResult(femmodel->results->Size()+1,BslcEnum,-bslc,step,time)); + femmodel->results->AddResult(new GenericExternalResult(femmodel->results->Size()+1,BslcIceEnum,-bslcice,step,time)); + femmodel->results->AddResult(new GenericExternalResult(femmodel->results->Size()+1,BslcHydroEnum,-bslchydro,step,time)); //cumulative barystatic contribution: - cumbslr=cumbslr-bslr; - cumbslrice=cumbslrice-bslrice; - cumbslrhydro=cumbslrhydro-bslrhydro; - - femmodel->parameters->SetParam(cumbslr,CumBslrEnum); - femmodel->parameters->SetParam(cumbslrice,CumBslrIceEnum); - femmodel->parameters->SetParam(cumbslrhydro,CumBslrHydroEnum); - - femmodel->results->AddResult(new GenericExternalResult(femmodel->results->Size()+1,CumBslrEnum,cumbslr,step,time)); - femmodel->results->AddResult(new GenericExternalResult(femmodel->results->Size()+1,CumBslrIceEnum,cumbslrice,step,time)); - femmodel->results->AddResult(new GenericExternalResult(femmodel->results->Size()+1,CumBslrHydroEnum,cumbslrhydro,step,time)); + cumbslc=cumbslc-bslc; + cumbslcice=cumbslcice-bslcice; + cumbslchydro=cumbslchydro-bslchydro; + + femmodel->parameters->SetParam(cumbslc,CumBslcEnum); + femmodel->parameters->SetParam(cumbslcice,CumBslcIceEnum); + femmodel->parameters->SetParam(cumbslchydro,CumBslcHydroEnum); + + femmodel->results->AddResult(new GenericExternalResult(femmodel->results->Size()+1,CumBslcEnum,cumbslc,step,time)); + femmodel->results->AddResult(new GenericExternalResult(femmodel->results->Size()+1,CumBslcIceEnum,cumbslcice,step,time)); + femmodel->results->AddResult(new GenericExternalResult(femmodel->results->Size()+1,CumBslcHydroEnum,cumbslchydro,step,time)); //cumulative barystatic contributions by partition: if(npartice){ - for(int i=0;iparameters->SetParam(cumbslrice_partition,npartice,1,CumBslrIcePartitionEnum); - femmodel->results->AddResult(new GenericExternalResult(femmodel->results->Size()+1,CumBslrIcePartitionEnum,cumbslrice_partition,npartice,1,step,time)); + for(int i=0;iparameters->SetParam(cumbslcice_partition,npartice,1,CumBslcIcePartitionEnum); + femmodel->results->AddResult(new GenericExternalResult(femmodel->results->Size()+1,CumBslcIcePartitionEnum,cumbslcice_partition,npartice,1,step,time)); } if(nparthydro){ - for(int i=0;iparameters->SetParam(cumbslrhydro_partition,nparthydro,1,CumBslrHydroPartitionEnum); - femmodel->results->AddResult(new GenericExternalResult(femmodel->results->Size()+1,CumBslrHydroPartitionEnum,cumbslrhydro_partition,nparthydro,1,step,time)); + for(int i=0;iparameters->SetParam(cumbslchydro_partition,nparthydro,1,CumBslcHydroPartitionEnum); + femmodel->results->AddResult(new GenericExternalResult(femmodel->results->Size()+1,CumBslcHydroPartitionEnum,cumbslchydro_partition,nparthydro,1,step,time)); } /*}}}*/ @@ -645,5 +645,5 @@ /*convergence criterion:*/ - slrconvergence(&converged,RSLg,RSLg_old,eps_rel,eps_abs); + slcconvergence(&converged,RSLg,RSLg_old,eps_rel,eps_abs); @@ -1104,5 +1104,5 @@ /*This mass transport module for the Earth is because we might have thickness variations as spcs - * specified in the md.slr class, outside of what we will get from the icecaps. That's why we get t + * specified in the md.solidearth class, outside of what we will get from the icecaps. That's why we get t * the thickness variations from SealevelchangeSpcthicknessEnum.*/ @@ -1135,5 +1135,5 @@ } /*}}}*/ -void slrconvergence(bool* pconverged, Vector* RSLg,Vector* RSLg_old,IssmDouble eps_rel,IssmDouble eps_abs){ /*{{{*/ +void slcconvergence(bool* pconverged, Vector* RSLg,Vector* RSLg_old,IssmDouble eps_rel,IssmDouble eps_abs){ /*{{{*/ bool converged=true; Index: /issm/trunk-jpl/src/c/cores/transient_core.cpp =================================================================== --- /issm/trunk-jpl/src/c/cores/transient_core.cpp (revision 25955) +++ /issm/trunk-jpl/src/c/cores/transient_core.cpp (revision 25956) @@ -24,5 +24,5 @@ /*parameters: */ IssmDouble finaltime,dt,yts; - bool isoceancoupling,iscontrol,isautodiff,isslr; + bool isoceancoupling,iscontrol,isautodiff,isslc; int timestepping; int output_frequency,checkpoint_frequency; @@ -45,5 +45,5 @@ femmodel->parameters->FindParam(&output_frequency,SettingsOutputFrequencyEnum); femmodel->parameters->FindParam(×tepping,TimesteppingTypeEnum); - femmodel->parameters->FindParam(&isslr,TransientIsslrEnum); + femmodel->parameters->FindParam(&isslc,TransientIsslcEnum); femmodel->parameters->FindParam(&isoceancoupling,TransientIsoceancouplingEnum); femmodel->parameters->FindParam(&amr_frequency,TransientAmrFrequencyEnum); @@ -62,5 +62,5 @@ #endif - if(isslr) sealevelchange_geometry(femmodel); + if(isslc) sealevelchange_geometry(femmodel); while(time < finaltime - (yts*DBL_EPSILON)){ //make sure we run up to finaltime. @@ -139,5 +139,5 @@ /*parameters: */ bool isstressbalance,ismasstransport,issmb,isthermal,isgroundingline,isgia,isesa; - bool isslr,ismovingfront,isdamageevolution,ishydrology,isoceancoupling,save_results; + bool isslc,ismovingfront,isdamageevolution,ishydrology,isoceancoupling,save_results; int step,sb_coupling_frequency; int domaintype,numoutputs; @@ -154,5 +154,5 @@ femmodel->parameters->FindParam(&isgia,TransientIsgiaEnum); femmodel->parameters->FindParam(&isesa,TransientIsesaEnum); - femmodel->parameters->FindParam(&isslr,TransientIsslrEnum); + femmodel->parameters->FindParam(&isslc,TransientIsslcEnum); femmodel->parameters->FindParam(&isgroundingline,TransientIsgroundinglineEnum); femmodel->parameters->FindParam(&ismovingfront,TransientIsmovingfrontEnum); @@ -236,5 +236,5 @@ /*Sea level change: */ - if(isslr){ + if(isslc){ if(VerboseSolution()) _printf0_(" computing sea level change\n"); sealevelchange_core(femmodel); @@ -260,5 +260,5 @@ IssmDouble output_value; IssmDouble finaltime,dt,yts,time; - bool isoceancoupling,isslr; + bool isoceancoupling,isslc; int step,timestepping; int checkpoint_frequency; @@ -273,7 +273,7 @@ femmodel->parameters->FindParam(&yts,ConstantsYtsEnum); femmodel->parameters->FindParam(×tepping,TimesteppingTypeEnum); - femmodel->parameters->FindParam(&isslr,TransientIsslrEnum); + femmodel->parameters->FindParam(&isslc,TransientIsslcEnum); femmodel->parameters->FindParam(&checkpoint_frequency,SettingsCheckpointFrequencyEnum); _assert_(checkpoint_frequency>0); - if(isslr) sealevelchange_geometry(femmodel); + if(isslc) sealevelchange_geometry(femmodel); std::vector time_all; Index: /issm/trunk-jpl/src/c/main/issm_slc.cpp =================================================================== --- /issm/trunk-jpl/src/c/main/issm_slc.cpp (revision 25956) +++ /issm/trunk-jpl/src/c/main/issm_slc.cpp (revision 25956) @@ -0,0 +1,135 @@ +/*!\file: issm_slc.cpp + * \brief: ISSM SLR main program. + */ + +#include "./issm.h" +#include + +int main(int argc,char **argv){ + + /*diverse:*/ + int nummodels; + int* commsizes=NULL; + int* rankzeros=NULL; + char** dirnames=NULL; + char** modelnames=NULL; + int modelid; + int earthid; + int my_rank; + int count=0; + ISSM_MPI_Comm worldcomm; + ISSM_MPI_Comm modelcomm; + ISSM_MPI_Comm toearthcomm; + ISSM_MPI_Comm* fromicecomms=NULL; + + /*Initialize exception trapping: */ + ExceptionTrapBegin(); + + /*Initialize environment (MPI, PETSC, MUMPS, etc ...)*/ + worldcomm=EnvironmentInit(argc,argv); + + /*What is my rank?:*/ + ISSM_MPI_Comm_rank(worldcomm,&my_rank); + + /*How many models are we going to run (along with description and number of dedicated cores):{{{*/ + nummodels=(int) strtol(argv[4], (char **)NULL, 10); + commsizes=xNew(nummodels); + dirnames=xNew(nummodels); + modelnames=xNew(nummodels); + rankzeros=xNew(nummodels); + for(int i=0;i(strlen(argv[5+3*i])+1); + xMemCpy(string,argv[5+3*i],strlen(argv[5+3*i])+1); + dirnames[i]=string; + + string=xNew(strlen(argv[5+3*i+1])+1); + xMemCpy(string,argv[5+3*i+1],strlen(argv[5+3*i+1])+1); + modelnames[i]=string; + + commsizes[i]=(int) strtol(argv[5+3*i+2], (char **)NULL, 10); + } + + /*Figure out which model each cpu will belong to: */ + count=0; + for(int i=0;i=count && my_rank<(count+commsizes[i])){ + modelid=i; + break; + } + count+=commsizes[i]; + } + /*Buil array of who is rank 0 of their own group:*/ + count=0; + for(int i=0;i(nummodels-1); + for(int i=0;i(4); + arguments[0]=xNew(strlen(argv[0])+1); xMemCpy(arguments[0],argv[0],strlen(argv[0])+1); //executable name + arguments[1]=xNew(strlen(argv[1])+1); xMemCpy(arguments[1],argv[1],strlen(argv[1])+1); //solution name + arguments[2]=xNew(strlen(argv[5+3*modelid])+1); xMemCpy(arguments[2],argv[5+3*modelid],strlen(argv[5+3*modelid])+1); //directory name + arguments[3]=xNew(strlen(argv[5+3*modelid+1])+1); xMemCpy(arguments[3],argv[5+3*modelid+1],strlen(argv[5+3*modelid+1])+1); //model name + /*}}}*/ + + /*Initialize femmodel from arguments provided command line: */ + FemModel *femmodel = new FemModel(4,arguments,modelcomm); + + /*Now that the models are initialized, keep communicator information in the parameters datasets of each model: */ + femmodel->parameters->AddObject(new GenericParam(worldcomm,WorldCommEnum)); + femmodel->parameters->AddObject(new IntParam(NumModelsEnum,nummodels)); + femmodel->parameters->AddObject(new IntParam(ModelIdEnum,modelid)); + femmodel->parameters->AddObject(new IntParam(EarthIdEnum,earthid)); + if(modelid==earthid) femmodel->parameters->AddObject(new GenericParam(fromicecomms,IcecapToEarthCommEnum)); + else femmodel->parameters->AddObject(new GenericParam(toearthcomm,IcecapToEarthCommEnum)); + + /*Solve: */ + femmodel->Solve(); + + /*Output results: */ + OutputResultsx(femmodel); + + /*Wrap up: */ + femmodel->CleanUp(); + + /*Delete Model: */ + delete femmodel; + + /*Finalize environment:*/ + EnvironmentFinalize(); + + /*Finalize exception trapping: */ + ExceptionTrapEnd(); + + /*Free ressources:*/ + xDelete(commsizes); + for(int i=0;i(string); + string=modelnames[i]; xDelete(string); + } + xDelete(dirnames); + xDelete(modelnames); + + /*Return unix success: */ + return 0; +} Index: sm/trunk-jpl/src/c/main/issm_slr.cpp =================================================================== --- /issm/trunk-jpl/src/c/main/issm_slr.cpp (revision 25955) +++ (revision ) @@ -1,135 +1,0 @@ -/*!\file: issm_slr.cpp - * \brief: ISSM SLR main program. - */ - -#include "./issm.h" -#include - -int main(int argc,char **argv){ - - /*diverse:*/ - int nummodels; - int* commsizes=NULL; - int* rankzeros=NULL; - char** dirnames=NULL; - char** modelnames=NULL; - int modelid; - int earthid; - int my_rank; - int count=0; - ISSM_MPI_Comm worldcomm; - ISSM_MPI_Comm modelcomm; - ISSM_MPI_Comm toearthcomm; - ISSM_MPI_Comm* fromicecomms=NULL; - - /*Initialize exception trapping: */ - ExceptionTrapBegin(); - - /*Initialize environment (MPI, PETSC, MUMPS, etc ...)*/ - worldcomm=EnvironmentInit(argc,argv); - - /*What is my rank?:*/ - ISSM_MPI_Comm_rank(worldcomm,&my_rank); - - /*How many models are we going to run (along with description and number of dedicated cores):{{{*/ - nummodels=(int) strtol(argv[4], (char **)NULL, 10); - commsizes=xNew(nummodels); - dirnames=xNew(nummodels); - modelnames=xNew(nummodels); - rankzeros=xNew(nummodels); - for(int i=0;i(strlen(argv[5+3*i])+1); - xMemCpy(string,argv[5+3*i],strlen(argv[5+3*i])+1); - dirnames[i]=string; - - string=xNew(strlen(argv[5+3*i+1])+1); - xMemCpy(string,argv[5+3*i+1],strlen(argv[5+3*i+1])+1); - modelnames[i]=string; - - commsizes[i]=(int) strtol(argv[5+3*i+2], (char **)NULL, 10); - } - - /*Figure out which model each cpu will belong to: */ - count=0; - for(int i=0;i=count && my_rank<(count+commsizes[i])){ - modelid=i; - break; - } - count+=commsizes[i]; - } - /*Buil array of who is rank 0 of their own group:*/ - count=0; - for(int i=0;i(nummodels-1); - for(int i=0;i(4); - arguments[0]=xNew(strlen(argv[0])+1); xMemCpy(arguments[0],argv[0],strlen(argv[0])+1); //executable name - arguments[1]=xNew(strlen(argv[1])+1); xMemCpy(arguments[1],argv[1],strlen(argv[1])+1); //solution name - arguments[2]=xNew(strlen(argv[5+3*modelid])+1); xMemCpy(arguments[2],argv[5+3*modelid],strlen(argv[5+3*modelid])+1); //directory name - arguments[3]=xNew(strlen(argv[5+3*modelid+1])+1); xMemCpy(arguments[3],argv[5+3*modelid+1],strlen(argv[5+3*modelid+1])+1); //model name - /*}}}*/ - - /*Initialize femmodel from arguments provided command line: */ - FemModel *femmodel = new FemModel(4,arguments,modelcomm); - - /*Now that the models are initialized, keep communicator information in the parameters datasets of each model: */ - femmodel->parameters->AddObject(new GenericParam(worldcomm,WorldCommEnum)); - femmodel->parameters->AddObject(new IntParam(NumModelsEnum,nummodels)); - femmodel->parameters->AddObject(new IntParam(ModelIdEnum,modelid)); - femmodel->parameters->AddObject(new IntParam(EarthIdEnum,earthid)); - if(modelid==earthid) femmodel->parameters->AddObject(new GenericParam(fromicecomms,IcecapToEarthCommEnum)); - else femmodel->parameters->AddObject(new GenericParam(toearthcomm,IcecapToEarthCommEnum)); - - /*Solve: */ - femmodel->Solve(); - - /*Output results: */ - OutputResultsx(femmodel); - - /*Wrap up: */ - femmodel->CleanUp(); - - /*Delete Model: */ - delete femmodel; - - /*Finalize environment:*/ - EnvironmentFinalize(); - - /*Finalize exception trapping: */ - ExceptionTrapEnd(); - - /*Free ressources:*/ - xDelete(commsizes); - for(int i=0;i(string); - string=modelnames[i]; xDelete(string); - } - xDelete(dirnames); - xDelete(modelnames); - - /*Return unix success: */ - return 0; -} Index: /issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateParameters.cpp =================================================================== --- /issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateParameters.cpp (revision 25955) +++ /issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateParameters.cpp (revision 25956) @@ -82,5 +82,5 @@ parameters->AddObject(iomodel->CopyConstantObject("md.transient.ishydrology",TransientIshydrologyEnum)); parameters->AddObject(iomodel->CopyConstantObject("md.transient.ismovingfront",TransientIsmovingfrontEnum)); - parameters->AddObject(iomodel->CopyConstantObject("md.transient.isslr",TransientIsslrEnum)); + parameters->AddObject(iomodel->CopyConstantObject("md.transient.isslc",TransientIsslcEnum)); parameters->AddObject(iomodel->CopyConstantObject("md.transient.iscoupler",TransientIscouplerEnum)); parameters->AddObject(iomodel->CopyConstantObject("md.transient.isoceancoupling",TransientIsoceancouplingEnum)); @@ -356,5 +356,5 @@ parameters->AddObject(iomodel->CopyConstantObject("md.materials.rheology_law",MaterialsRheologyLawEnum)); - /*slr:*/ + /*slc:*/ parameters->AddObject(iomodel->CopyConstantObject("md.materials.earth_density",MaterialsEarthDensityEnum)); break; Index: /issm/trunk-jpl/src/c/shared/Enum/Enum.vim =================================================================== --- /issm/trunk-jpl/src/c/shared/Enum/Enum.vim (revision 25955) +++ /issm/trunk-jpl/src/c/shared/Enum/Enum.vim (revision 25956) @@ -110,11 +110,11 @@ syn keyword cConstant ControlInputSizeNEnum syn keyword cConstant ControlInputInterpolationEnum -syn keyword cConstant CumBslrEnum -syn keyword cConstant CumBslrIceEnum -syn keyword cConstant CumBslrHydroEnum -syn keyword cConstant CumBslrIcePartitionEnum -syn keyword cConstant CumBslrHydroPartitionEnum -syn keyword cConstant CumGmtslrEnum -syn keyword cConstant CumGmslrEnum +syn keyword cConstant CumBslcEnum +syn keyword cConstant CumBslcIceEnum +syn keyword cConstant CumBslcHydroEnum +syn keyword cConstant CumBslcIcePartitionEnum +syn keyword cConstant CumBslcHydroPartitionEnum +syn keyword cConstant CumGmtslcEnum +syn keyword cConstant CumGmslcEnum syn keyword cConstant DamageC1Enum syn keyword cConstant DamageC2Enum @@ -488,5 +488,5 @@ syn keyword cConstant TransientIsmovingfrontEnum syn keyword cConstant TransientIsoceancouplingEnum -syn keyword cConstant TransientIsslrEnum +syn keyword cConstant TransientIsslcEnum syn keyword cConstant TransientIssmbEnum syn keyword cConstant TransientIsstressbalanceEnum @@ -721,9 +721,9 @@ syn keyword cConstant SealevelNEsaRateEnum syn keyword cConstant SealevelRSLEnum -syn keyword cConstant BslrEnum -syn keyword cConstant BslrIceEnum -syn keyword cConstant BslrHydroEnum -syn keyword cConstant BslrRateEnum -syn keyword cConstant GmtslrEnum +syn keyword cConstant BslcEnum +syn keyword cConstant BslcIceEnum +syn keyword cConstant BslcHydroEnum +syn keyword cConstant BslcRateEnum +syn keyword cConstant GmtslcEnum syn keyword cConstant SealevelRSLBarystaticEnum syn keyword cConstant SealevelRSLRateEnum Index: /issm/trunk-jpl/src/c/shared/Enum/EnumDefinitions.h =================================================================== --- /issm/trunk-jpl/src/c/shared/Enum/EnumDefinitions.h (revision 25955) +++ /issm/trunk-jpl/src/c/shared/Enum/EnumDefinitions.h (revision 25956) @@ -104,11 +104,11 @@ ControlInputSizeNEnum, ControlInputInterpolationEnum, - CumBslrEnum, - CumBslrIceEnum, - CumBslrHydroEnum, - CumBslrIcePartitionEnum, - CumBslrHydroPartitionEnum, - CumGmtslrEnum, - CumGmslrEnum, + CumBslcEnum, + CumBslcIceEnum, + CumBslcHydroEnum, + CumBslcIcePartitionEnum, + CumBslcHydroPartitionEnum, + CumGmtslcEnum, + CumGmslcEnum, DamageC1Enum, DamageC2Enum, @@ -482,5 +482,5 @@ TransientIsmovingfrontEnum, TransientIsoceancouplingEnum, - TransientIsslrEnum, + TransientIsslcEnum, TransientIssmbEnum, TransientIsstressbalanceEnum, @@ -717,9 +717,9 @@ SealevelNEsaRateEnum, SealevelRSLEnum, - BslrEnum, - BslrIceEnum, - BslrHydroEnum, - BslrRateEnum, - GmtslrEnum, + BslcEnum, + BslcIceEnum, + BslcHydroEnum, + BslcRateEnum, + GmtslcEnum, SealevelRSLBarystaticEnum, SealevelRSLRateEnum, Index: /issm/trunk-jpl/src/c/shared/Enum/EnumToStringx.cpp =================================================================== --- /issm/trunk-jpl/src/c/shared/Enum/EnumToStringx.cpp (revision 25955) +++ /issm/trunk-jpl/src/c/shared/Enum/EnumToStringx.cpp (revision 25956) @@ -112,11 +112,11 @@ case ControlInputSizeNEnum : return "ControlInputSizeN"; case ControlInputInterpolationEnum : return "ControlInputInterpolation"; - case CumBslrEnum : return "CumBslr"; - case CumBslrIceEnum : return "CumBslrIce"; - case CumBslrHydroEnum : return "CumBslrHydro"; - case CumBslrIcePartitionEnum : return "CumBslrIcePartition"; - case CumBslrHydroPartitionEnum : return "CumBslrHydroPartition"; - case CumGmtslrEnum : return "CumGmtslr"; - case CumGmslrEnum : return "CumGmslr"; + case CumBslcEnum : return "CumBslc"; + case CumBslcIceEnum : return "CumBslcIce"; + case CumBslcHydroEnum : return "CumBslcHydro"; + case CumBslcIcePartitionEnum : return "CumBslcIcePartition"; + case CumBslcHydroPartitionEnum : return "CumBslcHydroPartition"; + case CumGmtslcEnum : return "CumGmtslc"; + case CumGmslcEnum : return "CumGmslc"; case DamageC1Enum : return "DamageC1"; case DamageC2Enum : return "DamageC2"; @@ -490,5 +490,5 @@ case TransientIsmovingfrontEnum : return "TransientIsmovingfront"; case TransientIsoceancouplingEnum : return "TransientIsoceancoupling"; - case TransientIsslrEnum : return "TransientIsslr"; + case TransientIsslcEnum : return "TransientIsslc"; case TransientIssmbEnum : return "TransientIssmb"; case TransientIsstressbalanceEnum : return "TransientIsstressbalance"; @@ -723,9 +723,9 @@ case SealevelNEsaRateEnum : return "SealevelNEsaRate"; case SealevelRSLEnum : return "SealevelRSL"; - case BslrEnum : return "Bslr"; - case BslrIceEnum : return "BslrIce"; - case BslrHydroEnum : return "BslrHydro"; - case BslrRateEnum : return "BslrRate"; - case GmtslrEnum : return "Gmtslr"; + case BslcEnum : return "Bslc"; + case BslcIceEnum : return "BslcIce"; + case BslcHydroEnum : return "BslcHydro"; + case BslcRateEnum : return "BslcRate"; + case GmtslcEnum : return "Gmtslc"; case SealevelRSLBarystaticEnum : return "SealevelRSLBarystatic"; case SealevelRSLRateEnum : return "SealevelRSLRate"; Index: /issm/trunk-jpl/src/c/shared/Enum/StringToEnumx.cpp =================================================================== --- /issm/trunk-jpl/src/c/shared/Enum/StringToEnumx.cpp (revision 25955) +++ /issm/trunk-jpl/src/c/shared/Enum/StringToEnumx.cpp (revision 25956) @@ -112,11 +112,11 @@ else if (strcmp(name,"ControlInputSizeN")==0) return ControlInputSizeNEnum; else if (strcmp(name,"ControlInputInterpolation")==0) return ControlInputInterpolationEnum; - else if (strcmp(name,"CumBslr")==0) return CumBslrEnum; - else if (strcmp(name,"CumBslrIce")==0) return CumBslrIceEnum; - else if (strcmp(name,"CumBslrHydro")==0) return CumBslrHydroEnum; - else if (strcmp(name,"CumBslrIcePartition")==0) return CumBslrIcePartitionEnum; - else if (strcmp(name,"CumBslrHydroPartition")==0) return CumBslrHydroPartitionEnum; - else if (strcmp(name,"CumGmtslr")==0) return CumGmtslrEnum; - else if (strcmp(name,"CumGmslr")==0) return CumGmslrEnum; + 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 if (strcmp(name,"CumBslcIcePartition")==0) return CumBslcIcePartitionEnum; + else if (strcmp(name,"CumBslcHydroPartition")==0) return CumBslcHydroPartitionEnum; + else if (strcmp(name,"CumGmtslc")==0) return CumGmtslcEnum; + else if (strcmp(name,"CumGmslc")==0) return CumGmslcEnum; else if (strcmp(name,"DamageC1")==0) return DamageC1Enum; else if (strcmp(name,"DamageC2")==0) return DamageC2Enum; @@ -499,5 +499,5 @@ else if (strcmp(name,"TransientIsmovingfront")==0) return TransientIsmovingfrontEnum; else if (strcmp(name,"TransientIsoceancoupling")==0) return TransientIsoceancouplingEnum; - else if (strcmp(name,"TransientIsslr")==0) return TransientIsslrEnum; + else if (strcmp(name,"TransientIsslc")==0) return TransientIsslcEnum; else if (strcmp(name,"TransientIssmb")==0) return TransientIssmbEnum; else if (strcmp(name,"TransientIsstressbalance")==0) return TransientIsstressbalanceEnum; @@ -738,9 +738,9 @@ else if (strcmp(name,"SealevelNEsaRate")==0) return SealevelNEsaRateEnum; else if (strcmp(name,"SealevelRSL")==0) return SealevelRSLEnum; - else if (strcmp(name,"Bslr")==0) return BslrEnum; - else if (strcmp(name,"BslrIce")==0) return BslrIceEnum; - else if (strcmp(name,"BslrHydro")==0) return BslrHydroEnum; - else if (strcmp(name,"BslrRate")==0) return BslrRateEnum; - else if (strcmp(name,"Gmtslr")==0) return GmtslrEnum; + else if (strcmp(name,"Bslc")==0) return BslcEnum; + else if (strcmp(name,"BslcIce")==0) return BslcIceEnum; + else if (strcmp(name,"BslcHydro")==0) return BslcHydroEnum; + else if (strcmp(name,"BslcRate")==0) return BslcRateEnum; + else if (strcmp(name,"Gmtslc")==0) return GmtslcEnum; else if (strcmp(name,"SealevelRSLBarystatic")==0) return SealevelRSLBarystaticEnum; else if (strcmp(name,"SealevelRSLRate")==0) return SealevelRSLRateEnum; Index: /issm/trunk-jpl/src/m/classes/additionalsolidearthsolution.m =================================================================== --- /issm/trunk-jpl/src/m/classes/additionalsolidearthsolution.m (revision 25955) +++ /issm/trunk-jpl/src/m/classes/additionalsolidearthsolution.m (revision 25956) @@ -21,5 +21,5 @@ function md = checkconsistency(self,md,solution,analyses) % {{{ - if ~ismember('SealevelriseAnalysis',analyses) | (strcmp(solution,'TransientSolution') & md.solidearth.settings.isgrd==0), + if ~ismember('SealevelchangeAnalysis',analyses) | (strcmp(solution,'TransientSolution') & md.solidearth.settings.isgrd==0), error('additionalsolidearthsolution checkconsistency error message: need to run GRD solution if you are supplying a GRD additional pattern solution'); end Index: /issm/trunk-jpl/src/m/classes/clusters/generic.m =================================================================== --- /issm/trunk-jpl/src/m/classes/clusters/generic.m (revision 25955) +++ /issm/trunk-jpl/src/m/classes/clusters/generic.m (revision 25956) @@ -165,5 +165,5 @@ %what is the executable being called? - executable='issm_slr.exe'; + executable='issm_slc.exe'; if ispc(), error('BuildQueueScriptMultipleModels not support yet on windows machines');end; Index: /issm/trunk-jpl/src/m/classes/clusters/localpfe.m =================================================================== --- /issm/trunk-jpl/src/m/classes/clusters/localpfe.m (revision 25955) +++ /issm/trunk-jpl/src/m/classes/clusters/localpfe.m (revision 25956) @@ -104,5 +104,5 @@ %what is the executable being called? - executable='issm_slr.exe'; + executable='issm_slc.exe'; if ispc(), error('BuildQueueScriptMultipleModels not support yet on windows machines');end; Index: /issm/trunk-jpl/src/m/classes/clusters/pfe.m =================================================================== --- /issm/trunk-jpl/src/m/classes/clusters/pfe.m (revision 25955) +++ /issm/trunk-jpl/src/m/classes/clusters/pfe.m (revision 25956) @@ -214,5 +214,5 @@ %what is the executable being called? - executable='issm_slr.exe'; + executable='issm_slc.exe'; if ispc(), error('BuildQueueScriptMultipleModels not support yet on windows machines');end; Index: /issm/trunk-jpl/src/m/classes/dsl.m =================================================================== --- /issm/trunk-jpl/src/m/classes/dsl.m (revision 25955) +++ /issm/trunk-jpl/src/m/classes/dsl.m (revision 25956) @@ -39,6 +39,6 @@ %Early return - if ~ismember('SealevelriseAnalysis',analyses), return; end - if (strcmp(solution,'TransientSolution') & md.transient.isslr == 0), return; end + if ~ismember('SealevelchangeAnalysis',analyses), return; end + if (strcmp(solution,'TransientSolution') & md.transient.isslc == 0), return; end md = checkfield(md,'fieldname','dsl.global_average_thermosteric_sea_level_change','NaN',1,'Inf',1); md = checkfield(md,'fieldname','dsl.sea_surface_height_change_above_geoid','NaN',1,'Inf',1,'timeseries',1); @@ -46,7 +46,7 @@ md = checkfield(md,'fieldname','dsl.compute_fingerprints','NaN',1,'Inf',1,'values',[0,1]); if self.compute_fingerprints, - %check geodetic flag of slr is on: - if md.slr.geodetic==0, - error('DSL checkconsistency error message: if bottom pressure fingerprints computations are requested, slr class should have geodetic flag on'); + %check geodetic flag of is on: + if md.solidearth.settings.isgrd==0, + error('DSL checkconsistency error message: if bottom pressure fingerprints computations are requested, solidearth class should have grd flag on'); end end Index: /issm/trunk-jpl/src/m/classes/dslmme.m =================================================================== --- /issm/trunk-jpl/src/m/classes/dslmme.m (revision 25955) +++ /issm/trunk-jpl/src/m/classes/dslmme.m (revision 25956) @@ -37,6 +37,6 @@ %Early return - if ~ismember('SealevelriseAnalysis',analyses), return; end - if (strcmp(solution,'TransientSolution') & md.transient.isslr == 0), return; end + if ~ismember('SealevelchangeAnalysis',analyses), return; end + if (strcmp(solution,'TransientSolution') & md.transient.isslc == 0), return; end for i=1:length(self.global_average_thermosteric_sea_level_change), md = checkfield(md,'field',self.global_average_thermosteric_sea_level_change{i},'NaN',1,'Inf',1); @@ -46,7 +46,7 @@ md = checkfield(md,'field',self.modelid,'NaN',1,'Inf',1,'>=',1,'<=',length(self.global_average_thermosteric_sea_level_change)); if self.compute_fingerprints, - %check geodetic flag of slr is on: - if md.solidearth.settings.computesealevelchange==0, - error('DSL checkconsistency error message: if bottom pressure fingerprints computations are requested, slr class should have geodetic flag on'); + %check geodetic flag of solidearth is on: + if md.solidearth.settings.isgrd==0, + error('DSL checkconsistency error message: if bottom pressure fingerprints computations are requested, solidearth class should have geodetic flag on'); end end Index: /issm/trunk-jpl/src/m/classes/geometry.m =================================================================== --- /issm/trunk-jpl/src/m/classes/geometry.m (revision 25955) +++ /issm/trunk-jpl/src/m/classes/geometry.m (revision 25956) @@ -55,5 +55,5 @@ if (strcmp(solution,'TransientSolution') & md.transient.isgia) | strcmp(solution,'GiaSolution'), md = checkfield(md,'fieldname','geometry.thickness','timeseries',1,'NaN',1,'Inf',1); - elseif strcmpi(solution,'SealevelriseSolution'), + elseif strcmpi(solution,'SealevelchangeSolution'), md = checkfield(md,'fieldname','geometry.bed','NaN',1,'Inf',1,'size',[md.mesh.numberofvertices 1]); return; Index: /issm/trunk-jpl/src/m/classes/giamme.m =================================================================== --- /issm/trunk-jpl/src/m/classes/giamme.m (revision 25955) +++ /issm/trunk-jpl/src/m/classes/giamme.m (revision 25956) @@ -34,6 +34,6 @@ %Early return - if ~ismember('SealevelriseAnalysis',analyses), return; end - if (strcmp(solution,'TransientSolution') & md.transient.isslr == 0), return; end + if ~ismember('SealevelchangeAnalysis',analyses), return; end + if (strcmp(solution,'TransientSolution') & md.transient.isslc == 0), return; end md = checkfield(md,'field',self.Ngia,'NaN',1,'Inf',1); md = checkfield(md,'field',self.Ugia,'NaN',1,'Inf',1); Index: /issm/trunk-jpl/src/m/classes/lovenumbers.m =================================================================== --- /issm/trunk-jpl/src/m/classes/lovenumbers.m (revision 25955) +++ /issm/trunk-jpl/src/m/classes/lovenumbers.m (revision 25956) @@ -46,5 +46,5 @@ function md = checkconsistency(self,md,solution,analyses) % {{{ - if ~ismember('SealevelriseAnalysis',analyses) | (strcmp(solution,'TransientSolution') & md.transient.isslr==0), + if ~ismember('SealevelchangeAnalysis',analyses) | (strcmp(solution,'TransientSolution') & md.transient.isslc==0), return; end Index: /issm/trunk-jpl/src/m/classes/matdamageice.m =================================================================== --- /issm/trunk-jpl/src/m/classes/matdamageice.m (revision 25955) +++ /issm/trunk-jpl/src/m/classes/matdamageice.m (revision 25956) @@ -29,5 +29,5 @@ mantle_density = 0.; - %slr + %slc earth_density = 0; @@ -127,5 +127,5 @@ md = checkfield(md,'fieldname','materials.mantle_density','>',0,'numel',1); end - if ismember('SealevelriseAnalysis',analyses), + if ismember('SealevelchangeAnalysis',analyses), md = checkfield(md,'fieldname','materials.earth_density','>',0,'numel',1); end Index: /issm/trunk-jpl/src/m/classes/matenhancedice.m =================================================================== --- /issm/trunk-jpl/src/m/classes/matenhancedice.m (revision 25955) +++ /issm/trunk-jpl/src/m/classes/matenhancedice.m (revision 25956) @@ -130,5 +130,5 @@ md = checkfield(md,'fieldname','materials.mantle_density','>',0,'numel',1); end - if ismember('SealevelriseAnalysis',analyses), + if ismember('SealevelchangeAnalysis',analyses), md = checkfield(md,'fieldname','materials.earth_density','>',0,'numel',1); end Index: /issm/trunk-jpl/src/m/classes/matestar.m =================================================================== --- /issm/trunk-jpl/src/m/classes/matestar.m (revision 25955) +++ /issm/trunk-jpl/src/m/classes/matestar.m (revision 25956) @@ -30,5 +30,5 @@ mantle_density = 0.; - %slr + %slc earth_density = 0; @@ -137,5 +137,5 @@ md = checkfield(md,'fieldname','materials.mantle_density','>',0,'numel',1); end - if ismember('SealevelriseAnalysis',analyses), + if ismember('SealevelchangeAnalysis',analyses), md = checkfield(md,'fieldname','materials.earth_density','>',0,'numel',1); end Index: /issm/trunk-jpl/src/m/classes/matice.m =================================================================== --- /issm/trunk-jpl/src/m/classes/matice.m (revision 25955) +++ /issm/trunk-jpl/src/m/classes/matice.m (revision 25956) @@ -29,5 +29,5 @@ mantle_density = 0.; - %slr + %slc earth_density = 0; @@ -113,5 +113,5 @@ function md = checkconsistency(self,md,solution,analyses) % {{{ - if ~strcmpi(solution,'SealevelriseSolution'), + if ~strcmpi(solution,'SealevelchangeSolution'), md = checkfield(md,'fieldname','materials.rho_ice','>',0); md = checkfield(md,'fieldname','materials.rho_water','>',0); @@ -130,5 +130,5 @@ md = checkfield(md,'fieldname','materials.mantle_density','>',0,'numel',1); end - if ismember('SealevelriseAnalysis',analyses), + if ismember('SealevelchangeAnalysis',analyses), md = checkfield(md,'fieldname','materials.earth_density','>',0,'numel',1); end Index: /issm/trunk-jpl/src/m/classes/mmeadditionalsolidearthsolution.m =================================================================== --- /issm/trunk-jpl/src/m/classes/mmeadditionalsolidearthsolution.m (revision 25955) +++ /issm/trunk-jpl/src/m/classes/mmeadditionalsolidearthsolution.m (revision 25956) @@ -24,5 +24,5 @@ function md = checkconsistency(self,md,solution,analyses) % {{{ - if ~ismember('SealevelriseAnalysis',analyses) | (strcmp(solution,'TransientSolution') & md.solidearth.settings.isgrd==0), + if ~ismember('SealevelchangeAnalysis',analyses) | (strcmp(solution,'TransientSolution') & md.solidearth.settings.isgrd==0), error('mmeadditionalsolidearthsolution checkconsistency error message: need to run GRD solution if you are supplying a GRD additional pattern solution'); end Index: /issm/trunk-jpl/src/m/classes/mmeofflinesolidearthsolution.m =================================================================== --- /issm/trunk-jpl/src/m/classes/mmeofflinesolidearthsolution.m (revision 25955) +++ /issm/trunk-jpl/src/m/classes/mmeofflinesolidearthsolution.m (revision 25956) @@ -24,5 +24,5 @@ function md = checkconsistency(self,md,solution,analyses) % {{{ - if ~ismember('SealevelriseAnalysis',analyses) | (strcmp(solution,'TransientSolution') & md.solidearth.settings.isgrd==1), + if ~ismember('SealevelchangeAnalysis',analyses) | (strcmp(solution,'TransientSolution') & md.solidearth.settings.isgrd==1), error('mmeofflinesolidearthsolution checkconsistency error message: trying to run GRD patterns while supplying an offline solution for those patterns!'); end Index: /issm/trunk-jpl/src/m/classes/nodalvalue.m =================================================================== --- /issm/trunk-jpl/src/m/classes/nodalvalue.m (revision 25955) +++ /issm/trunk-jpl/src/m/classes/nodalvalue.m (revision 25956) @@ -3,7 +3,7 @@ % Usage: % nodalvalue=nodalvalue(); -% nodalvalue=nodalvalue('name','SealevelriseSNodalValue',... +% nodalvalue=nodalvalue('name','SealevelchangeSNodalValue',... % 'definitionstring','Outputdefinition1', -% 'model_string','SealevelriseS', +% 'model_string','SealevelchangeS', % 'node',1); Index: /issm/trunk-jpl/src/m/classes/offlinesolidearthsolution.m =================================================================== --- /issm/trunk-jpl/src/m/classes/offlinesolidearthsolution.m (revision 25955) +++ /issm/trunk-jpl/src/m/classes/offlinesolidearthsolution.m (revision 25956) @@ -21,5 +21,5 @@ function md = checkconsistency(self,md,solution,analyses) % {{{ - if ~ismember('SealevelriseAnalysis',analyses) | (strcmp(solution,'TransientSolution') & md.solidearth.settings.isgrd==1), + if ~ismember('SealevelchangeAnalysis',analyses) | (strcmp(solution,'TransientSolution') & md.solidearth.settings.isgrd==1), error('offlinesolidearthsolution checkconsistency error message: trying to run GRD patterns while supplying an offline solution for those patterns!'); end Index: /issm/trunk-jpl/src/m/classes/qmustatistics.m =================================================================== --- /issm/trunk-jpl/src/m/classes/qmustatistics.m (revision 25955) +++ /issm/trunk-jpl/src/m/classes/qmustatistics.m (revision 25956) @@ -14,5 +14,5 @@ %name: name of method, one of 'None','Histogram','SampleSeries' or 'MeanVariance' - %fields: fields for the statistics being requested, ex: 'Sealevel','BslrIce','BslrHydro' + %fields: fields for the statistics being requested, ex: 'Sealevel','BslcIce','BslcHydro' %steps: time steps at which each field statistic is computed, ex: [1:2,5,20] or 1:100 %nbins: number of bins for 'Histogram' statistics Index: /issm/trunk-jpl/src/m/classes/rotational.m =================================================================== --- /issm/trunk-jpl/src/m/classes/rotational.m (revision 25955) +++ /issm/trunk-jpl/src/m/classes/rotational.m (revision 25956) @@ -30,5 +30,5 @@ function md = checkconsistency(self,md,solution,analyses) % {{{ - if ~ismember('SealevelriseAnalysis',analyses) | (strcmp(solution,'TransientSolution') & md.transient.isslr==0), + if ~ismember('SealevelchangeAnalysis',analyses) | (strcmp(solution,'TransientSolution') & md.transient.isslc==0), return; end Index: /issm/trunk-jpl/src/m/classes/sealevelmodel.m =================================================================== --- /issm/trunk-jpl/src/m/classes/sealevelmodel.m (revision 25955) +++ /issm/trunk-jpl/src/m/classes/sealevelmodel.m (revision 25956) @@ -60,5 +60,5 @@ %check that the transition vectors have the right size: for i=1:length(slm.icecaps), - if slm.icecaps{i}.mesh.numberofvertices ~= length(slm.earth.slr.transitions{i}), + if slm.icecaps{i}.mesh.numberofvertices ~= length(slm.earth.solidearth.transitions{i}), error(['sealevelmodel checkconsistenty issue with size of transition vector for ice cap: ' num2str(i) ' name: ' slm.icecaps{i}.miscellaneous.name]); end @@ -67,5 +67,5 @@ %check that run_frequency is the same everywhere: for i=1:length(slm.icecaps), - if slm.icecaps{i}.slr.geodetic_run_frequency~=slm.earth.slr.geodetic_run_frequency, + if slm.icecaps{i}.solidearth.settings.runfrequency~=slm.earth.solidearth.settings.runfrequency, error(sprintf('sealevelmodel checkconsistenty error: icecap model %s should have the same run frequency as earth!',slm.icecaps{i}.miscellaneous.name)); end @@ -75,5 +75,5 @@ for i=1:length(slm.icecaps), md= slm.icecaps{i}; - if ~isempty(find(md.slr.steric_rate - slm.earth.slr.steric_rate(slm.earth.slr.transitions{i}))), + if ~isempty(find(md.dsl.steric_rate - slm.earth.dsl.steric_rate(slm.earth.dsl.transitions{i}))), error(sprintf('steric rate on ice cap %s is not the same as for the earth\n',md.miscellaneous.name)); end Index: sm/trunk-jpl/src/m/classes/slr.m =================================================================== --- /issm/trunk-jpl/src/m/classes/slr.m (revision 25955) +++ (revision ) @@ -1,257 +1,0 @@ -%SLR class definition -% -% Usage: -% slr=slr(); - -classdef slr - properties (SetAccess=public) - deltathickness = NaN; - sealevel = NaN; - spcthickness = NaN; - maxiter = 0; - reltol = 0; - abstol = 0; - love_h = 0; %provided by PREM model - love_k = 0; %ideam - love_l = 0; %ideam - tide_love_k = 0; %ideam - tide_love_h = 0; %ideam - fluid_love = 0; - equatorial_moi = 0; - polar_moi = 0; - angular_velocity = 0; - rigid = 0; - elastic = 0; - rotation = 0; - ocean_area_scaling = 0; - hydro_rate = 0; %rate of steric expansion from hydrological effects. - geodetic_run_frequency = 1; %how many time steps we skip before we run the geodetic part of the solver during transient - geodetic = 0; %compute geodetic SLR? (in addition to steric?) - degacc = 0; - horiz = 0; - planetradius = planetradius('earth'); - requested_outputs = {}; - transitions = {}; - end - methods - function self = slr(varargin) % {{{ - switch nargin - case 0 - self=setdefaultparameters(self); - otherwise - error('constructor not supported'); - end - end % }}} - function self = setdefaultparameters(self) % {{{ - - %Convergence criterion: absolute, relative and residual - self.reltol=0.01; % 1 per cent - self.abstol=NaN; % default - - %maximum of non-linear iterations. - self.maxiter=5; - - %computational flags: - self.geodetic=0; - self.rigid=1; - self.elastic=1; - self.ocean_area_scaling=0; - self.rotation=1; - - %tidal love numbers: - self.tide_love_h=0.6149; %degree 2 - self.tide_love_k=0.3055; % degree 2 - - %secular fluid love number: - self.fluid_love=0.942; - - %moment of inertia: - self.equatorial_moi=8.0077*10^37; % [kg m^2] - self.polar_moi =8.0345*10^37; % [kg m^2] - - % mean rotational velocity of earth - self.angular_velocity=7.2921*10^-5; % [s^-1] - - %numerical discretization accuracy - self.degacc=.01; - - %hydro - self.hydro_rate=0; - - %how many time steps we skip before we run SLR solver during transient - self.geodetic_run_frequency=1; - - %output default: - self.requested_outputs={'default'}; - - %transitions should be a cell array of vectors: - self.transitions={}; - - %horizontal displacement? (not by default) - self.horiz=0; - - %earth area - self.planetradius= planetradius('earth'); - - end % }}} - function md = checkconsistency(self,md,solution,analyses) % {{{ - - if ~ismember('SealevelriseAnalysis',analyses) | (strcmp(solution,'TransientSolution') & md.transient.isslr==0), - return; - end - - %md = checkfield(md,'fieldname','slr.deltathickness','NaN',1,'Inf',1,'size',[md.mesh.numberofelements 1]); - md = checkfield(md,'fieldname','slr.deltathickness','timeseries',1,'NaN',1,'Inf',1); - md = checkfield(md,'fieldname','slr.sealevel','NaN',1,'Inf',1,'size',[md.mesh.numberofvertices 1]); - md = checkfield(md,'fieldname','slr.spcthickness','Inf',1,'timeseries',1); - md = checkfield(md,'fieldname','slr.love_h','NaN',1,'Inf',1); - md = checkfield(md,'fieldname','slr.love_k','NaN',1,'Inf',1); - md = checkfield(md,'fieldname','slr.love_l','NaN',1,'Inf',1); - md = checkfield(md,'fieldname','slr.tide_love_h','NaN',1,'Inf',1); - md = checkfield(md,'fieldname','slr.tide_love_k','NaN',1,'Inf',1); - md = checkfield(md,'fieldname','slr.fluid_love','NaN',1,'Inf',1); - md = checkfield(md,'fieldname','slr.equatorial_moi','NaN',1,'Inf',1); - md = checkfield(md,'fieldname','slr.polar_moi','NaN',1,'Inf',1); - md = checkfield(md,'fieldname','slr.angular_velocity','NaN',1,'Inf',1); - md = checkfield(md,'fieldname','slr.reltol','size',[1 1]); - md = checkfield(md,'fieldname','slr.abstol','size',[1 1]); - md = checkfield(md,'fieldname','slr.maxiter','size',[1 1],'>=',1); - md = checkfield(md,'fieldname','slr.geodetic_run_frequency','size',[1 1],'>=',1); - md = checkfield(md,'fieldname','slr.hydro_rate','NaN',1,'Inf',1,'size',[md.mesh.numberofvertices 1]); - md = checkfield(md,'fieldname','slr.degacc','size',[1 1],'>=',1e-10); - md = checkfield(md,'fieldname','slr.requested_outputs','stringrow',1); - md = checkfield(md,'fieldname','slr.horiz','NaN',1,'Inf',1,'values',[0 1]); - - %check that love numbers are provided at the same level of accuracy: - if (size(self.love_h,1)~=size(self.love_k,1) | size(self.love_h,1)~=size(self.love_l,1)), - error('slr error message: love numbers should be provided at the same level of accuracy'); - end - - %cross check that whereever we have an ice load, the mask is <0 on each vertex: - %pos=find(self.deltathickness); - %maskpos=md.mask.ice_levelset(md.mesh.elements(pos,:)); - %[els,vertices]=find(maskpos>0); - %if length(els), - % warning('slr checkconsistency fail: there are elements with ice loads where some vertices are not on the ice!'); - %end - - %check that if geodetic is requested, we are a mesh3dsurface model (planet), or if we are not, - %a coupler to a planet model is provided. - if self.geodetic, - if md.transient.iscoupler, - %we are good; - else - if strcmpi(class(md.mesh),'mesh3dsurface'), - %we are good - else - error('model is requesting geodetic computations without being a mesh3dsurface, or being coupled to one!'); - end - end - end - - end % }}} - function list=defaultoutputs(self,md) % {{{ - list = {'Sealevel'}; - end % }}} - function disp(self) % {{{ - disp(sprintf(' slr parameters:')); - - fielddisplay(self,'deltathickness','thickness change: ice height equivalent [m]'); - fielddisplay(self,'sealevel','current sea level (prior to computation) [m]'); - fielddisplay(self,'spcthickness','thickness constraints (NaN means no constraint) [m]'); - fielddisplay(self,'reltol','sea level rise relative convergence criterion, (default, NaN: not applied)'); - fielddisplay(self,'abstol','sea level rise absolute convergence criterion, NaN: not applied'); - fielddisplay(self,'maxiter','maximum number of nonlinear iterations'); - fielddisplay(self,'love_h','load Love number for radial displacement'); - fielddisplay(self,'love_k','load Love number for gravitational potential perturbation'); - fielddisplay(self,'love_l','load Love number for horizontal displacements'); - fielddisplay(self,'tide_love_k','tidal load Love number (deg 2)'); - fielddisplay(self,'tide_love_h','tidal load Love number (deg 2)'); - fielddisplay(self,'fluid_love','secular fluid Love number'); - fielddisplay(self,'equatorial_moi','mean equatorial moment of inertia [kg m^2]'); - fielddisplay(self,'polar_moi','polar moment of inertia [kg m^2]'); - fielddisplay(self,'angular_velocity','mean rotational velocity of earth [per second]'); - fielddisplay(self,'ocean_area_scaling','correction for model representation of ocean area [default: No correction]'); - fielddisplay(self,'hydro_rate','rate of hydrological expansion (in mm/yr)'); - fielddisplay(self,'geodetic','compute geodetic SLR? ( in addition to steric?) default 0'); - fielddisplay(self,'geodetic_run_frequency','how many time steps we skip before we run SLR solver during transient (default: 1)'); - fielddisplay(self,'rigid','rigid earth graviational potential perturbation'); - fielddisplay(self,'elastic','elastic earth graviational potential perturbation'); - fielddisplay(self,'rotation','earth rotational potential perturbation'); - fielddisplay(self,'degacc','accuracy (default .01 deg) for numerical discretization of the Green''s functions'); - fielddisplay(self,'transitions','indices into parts of the mesh that will be icecaps'); - fielddisplay(self,'requested_outputs','additional outputs requested'); - - end % }}} - function marshall(self,prefix,md,fid) % {{{ - %WriteData(fid,prefix,'object',self,'fieldname','deltathickness','format','DoubleMat','mattype',2); - WriteData(fid,prefix,'object',self,'fieldname','deltathickness','format','DoubleMat','mattype',2,'timeserieslength',md.mesh.numberofelements+1,'yts',md.constants.yts); - %WriteData(fid,prefix,'object',self,'fieldname','deltathickness','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofelements+1); - WriteData(fid,prefix,'object',self,'fieldname','sealevel','mattype',1,'format','DoubleMat','timeserieslength',md.mesh.numberofvertices+1,'yts',md.constants.yts); - WriteData(fid,prefix,'object',self,'fieldname','spcthickness','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1,'yts',md.constants.yts); - WriteData(fid,prefix,'object',self,'fieldname','reltol','format','Double'); - WriteData(fid,prefix,'object',self,'fieldname','abstol','format','Double'); - WriteData(fid,prefix,'object',self,'fieldname','maxiter','format','Integer'); - WriteData(fid,prefix,'object',self,'fieldname','love_h','format','DoubleMat','mattype',1); - WriteData(fid,prefix,'object',self,'fieldname','love_k','format','DoubleMat','mattype',1); - WriteData(fid,prefix,'object',self,'fieldname','love_l','format','DoubleMat','mattype',1); - WriteData(fid,prefix,'object',self,'fieldname','tide_love_h','format','Double'); - WriteData(fid,prefix,'object',self,'fieldname','tide_love_k','format','Double'); - WriteData(fid,prefix,'object',self,'fieldname','fluid_love','format','Double'); - WriteData(fid,prefix,'object',self,'fieldname','equatorial_moi','format','Double'); - WriteData(fid,prefix,'object',self,'fieldname','polar_moi','format','Double'); - WriteData(fid,prefix,'object',self,'fieldname','angular_velocity','format','Double'); - WriteData(fid,prefix,'object',self,'fieldname','rigid','format','Boolean'); - WriteData(fid,prefix,'object',self,'fieldname','elastic','format','Boolean'); - WriteData(fid,prefix,'object',self,'fieldname','rotation','format','Boolean'); - WriteData(fid,prefix,'object',self,'fieldname','ocean_area_scaling','format','Boolean'); - WriteData(fid,prefix,'object',self,'fieldname','geodetic_run_frequency','format','Integer'); - WriteData(fid,prefix,'object',self,'fieldname','hydro_rate','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1,'yts',md.constants.yts,'scale',1e-3/md.constants.yts); - WriteData(fid,prefix,'object',self,'fieldname','degacc','format','Double'); - WriteData(fid,prefix,'object',self,'fieldname','transitions','format','MatArray'); - WriteData(fid,prefix,'object',self,'fieldname','horiz','format','Integer'); - WriteData(fid,prefix,'object',self,'fieldname','geodetic','format','Integer'); - WriteData(fid,prefix,'object',self,'fieldname','planetradius','format','Double'); - - %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.slr.requested_outputs','format','StringArray'); - - end % }}} - function savemodeljs(self,fid,modelname) % {{{ - - writejs1Darray(fid,[modelname '.slr.deltathickness'],self.deltathickness); - writejs1Darray(fid,[modelname '.slr.sealevel'],self.sealevel); - writejs1Darray(fid,[modelname '.slr.spcthickness'],self.spcthickness); - writejsdouble(fid,[modelname '.slr.maxiter'],self.maxiter); - writejsdouble(fid,[modelname '.slr.reltol'],self.reltol); - writejsdouble(fid,[modelname '.slr.abstol'],self.abstol); - writejs1Darray(fid,[modelname '.slr.love_h'],self.love_h); - writejs1Darray(fid,[modelname '.slr.love_k'],self.love_k); - writejs1Darray(fid,[modelname '.slr.love_l'],self.love_l); - writejsdouble(fid,[modelname '.slr.tide_love_k'],self.tide_love_k); - writejsdouble(fid,[modelname '.slr.tide_love_h'],self.tide_love_h); - writejsdouble(fid,[modelname '.slr.fluid_love'],self.fluid_love); - writejsdouble(fid,[modelname '.slr.equatorial_moi'],self.equatorial_moi); - writejsdouble(fid,[modelname '.slr.polar_moi'],self.polar_moi); - writejsdouble(fid,[modelname '.slr.angular_velocity'],self.angular_velocity); - writejsdouble(fid,[modelname '.slr.rigid'],self.rigid); - writejsdouble(fid,[modelname '.slr.elastic'],self.elastic); - writejsdouble(fid,[modelname '.slr.rotation'],self.rotation); - writejsdouble(fid,[modelname '.slr.ocean_area_scaling'],self.ocean_area_scaling); - writejsdouble(fid,[modelname '.slr.geodetic_run_frequency'],self.geodetic_run_frequency); - writejs1Darray(fid,[modelname '.slr.hydro_rate'],self.hydro_rate); - writejsdouble(fid,[modelname '.slr.degacc'],self.degacc); - writejscellstring(fid,[modelname '.slr.requested_outputs'],self.requested_outputs); - writejscellarray(fid,[modelname '.slr.transitions'],self.transitions); - end % }}} - function self = extrude(self,md) % {{{ - self.sealevel=project3d(md,'vector',self.sealevel,'type','node'); - end % }}} - end -end Index: /issm/trunk-jpl/src/m/classes/solidearth.m =================================================================== --- /issm/trunk-jpl/src/m/classes/solidearth.m (revision 25955) +++ /issm/trunk-jpl/src/m/classes/solidearth.m (revision 25956) @@ -50,5 +50,5 @@ function md = checkconsistency(self,md,solution,analyses) % {{{ - if ~ismember('SealevelriseAnalysis',analyses) | (strcmp(solution,'TransientSolution') & md.transient.isslr==0), + if ~ismember('SealevelchangeAnalysis',analyses) | (strcmp(solution,'TransientSolution') & md.transient.isslc==0), return; end Index: /issm/trunk-jpl/src/m/classes/solidearthsettings.m =================================================================== --- /issm/trunk-jpl/src/m/classes/solidearthsettings.m (revision 25955) +++ /issm/trunk-jpl/src/m/classes/solidearthsettings.m (revision 25956) @@ -60,5 +60,5 @@ function md = checkconsistency(self,md,solution,analyses) % {{{ - if ~ismember('SealevelriseAnalysis',analyses) | (strcmp(solution,'TransientSolution') & md.transient.isslr==0), + if ~ismember('SealevelchangeAnalysis',analyses) | (strcmp(solution,'TransientSolution') & md.transient.isslc==0), return; end @@ -93,6 +93,6 @@ disp(sprintf(' solidearth settings:')); - fielddisplay(self,'reltol','sea level rise relative convergence criterion, (default, NaN: not applied)'); - fielddisplay(self,'abstol','sea level rise absolute convergence criterion, NaN: not applied'); + fielddisplay(self,'reltol','sea level change relative convergence criterion, (default, NaN: not applied)'); + fielddisplay(self,'abstol','sea level change absolute convergence criterion, NaN: not applied'); fielddisplay(self,'maxiter','maximum number of nonlinear iterations'); fielddisplay(self,'ocean_area_scaling','correction for model representation of ocean area [default: No correction]'); @@ -123,14 +123,14 @@ function savemodeljs(self,fid,modelname) % {{{ - writejsdouble(fid,[modelname '.slr.settings.maxiter'],self.maxiter); - writejsdouble(fid,[modelname '.slr.settings.reltol'],self.reltol); - writejsdouble(fid,[modelname '.slr.settings.abstol'],self.abstol); - writejsdouble(fid,[modelname '.slr.settings.rigid'],self.rigid); - writejsdouble(fid,[modelname '.slr.settings.elastic'],self.elastic); - writejsdouble(fid,[modelname '.slr.settings.rotation'],self.rotation); - writejsdouble(fid,[modelname '.slr.settings.ocean_area_scaling'],self.ocean_area_scaling); - writejsdouble(fid,[modelname '.slr.settings.run_frequency'],self.run_frequency); - writejsdouble(fid,[modelname '.slr.settings.degacc'],self.degacc); - writejsdouble(fid,[modelname '.slr.settings.glfraction'],self.glfraction); + writejsdouble(fid,[modelname '.solidearth.settings.maxiter'],self.maxiter); + writejsdouble(fid,[modelname '.solidearth.settings.reltol'],self.reltol); + writejsdouble(fid,[modelname '.solidearth.settings.abstol'],self.abstol); + writejsdouble(fid,[modelname '.solidearth.settings.rigid'],self.rigid); + writejsdouble(fid,[modelname '.solidearth.settings.elastic'],self.elastic); + writejsdouble(fid,[modelname '.solidearth.settings.rotation'],self.rotation); + writejsdouble(fid,[modelname '.solidearth.settings.ocean_area_scaling'],self.ocean_area_scaling); + writejsdouble(fid,[modelname '.solidearth.settings.run_frequency'],self.run_frequency); + writejsdouble(fid,[modelname '.solidearth.settings.degacc'],self.degacc); + writejsdouble(fid,[modelname '.solidearth.settings.glfraction'],self.glfraction); end % }}} function self = extrude(self,md) % {{{ Index: /issm/trunk-jpl/src/m/classes/surfaceload.m =================================================================== --- /issm/trunk-jpl/src/m/classes/surfaceload.m (revision 25955) +++ /issm/trunk-jpl/src/m/classes/surfaceload.m (revision 25956) @@ -28,5 +28,5 @@ function md = checkconsistency(self,md,solution,analyses) % {{{ - if ~ismember('SealevelriseAnalysis',analyses) | (strcmp(solution,'TransientSolution') & md.transient.isslr==0), + if ~ismember('SealevelchangeAnalysis',analyses) | (strcmp(solution,'TransientSolution') & md.transient.isslc==0), return; end Index: /issm/trunk-jpl/src/m/classes/toolkits.m =================================================================== --- /issm/trunk-jpl/src/m/classes/toolkits.m (revision 25955) +++ /issm/trunk-jpl/src/m/classes/toolkits.m (revision 25956) @@ -105,5 +105,5 @@ case 'LoveAnalysis' case 'EsaAnalysis' - case 'SealevelriseAnalysis' + case 'SealevelchangeAnalysis' otherwise md = checkmessage(md,['md.toolkits.' analyses{i} ' not supported yet']); Index: /issm/trunk-jpl/src/m/classes/transient.m =================================================================== --- /issm/trunk-jpl/src/m/classes/transient.m (revision 25955) +++ /issm/trunk-jpl/src/m/classes/transient.m (revision 25956) @@ -16,5 +16,5 @@ ismovingfront = 0; ishydrology = 0; - isslr = 0; + isslc = 0; iscoupler = 0; amr_frequency = 0; @@ -44,5 +44,5 @@ self.ismovingfront =0; self.ishydrology = 0; - self.isslr = 0; + self.isslc = 0; self.isoceancoupling = 0; self.iscoupler = 0; @@ -65,5 +65,5 @@ self.ismovingfront = 0; self.ishydrology = 0; - self.isslr = 0; + self.isslc = 0; self.isoceancoupling = 0; self.iscoupler = 0; @@ -96,5 +96,5 @@ md = checkfield(md,'fieldname','transient.ishydrology','numel',[1],'values',[0 1]); md = checkfield(md,'fieldname','transient.requested_outputs','stringrow',1); - md = checkfield(md,'fieldname','transient.isslr','numel',[1],'values',[0 1]); + md = checkfield(md,'fieldname','transient.isslc','numel',[1],'values',[0 1]); md = checkfield(md,'fieldname','transient.isoceancoupling','numel',[1],'values',[0 1]); md = checkfield(md,'fieldname','transient.iscoupler','numel',[1],'values',[0 1]); @@ -121,5 +121,5 @@ fielddisplay(self,'ismovingfront','indicates whether a moving front capability is used in the transient'); fielddisplay(self,'ishydrology','indicates whether an hydrology model is used'); - fielddisplay(self,'isslr','indicates whether a sea-level rise solution is used in the transient'); + fielddisplay(self,'isslc','indicates whether a sea-level change solution is used in the transient'); fielddisplay(self,'isoceancoupling','indicates whether a coupling with an ocean model is used in the transient'); fielddisplay(self,'iscoupler','indicates whether different models are being run with need for coupling'); @@ -139,5 +139,5 @@ WriteData(fid,prefix,'object',self,'fieldname','ishydrology','format','Boolean'); WriteData(fid,prefix,'object',self,'fieldname','ismovingfront','format','Boolean'); - WriteData(fid,prefix,'object',self,'fieldname','isslr','format','Boolean'); + WriteData(fid,prefix,'object',self,'fieldname','isslc','format','Boolean'); WriteData(fid,prefix,'object',self,'fieldname','isoceancoupling','format','Boolean'); WriteData(fid,prefix,'object',self,'fieldname','iscoupler','format','Boolean'); @@ -165,5 +165,5 @@ writejsdouble(fid,[modelname '.trans.ismovingfront'],self.ismovingfront); writejsdouble(fid,[modelname '.trans.ishydrology'],self.ishydrology); - writejsdouble(fid,[modelname '.trans.isslr'],self.isslr); + writejsdouble(fid,[modelname '.trans.isslc'],self.isslc); writejsdouble(fid,[modelname '.trans.isoceancoupling'],self.isoceancoupling); writejsdouble(fid,[modelname '.trans.iscoupler'],self.iscoupler); Index: /issm/trunk-jpl/src/m/solve/solveslm.m =================================================================== --- /issm/trunk-jpl/src/m/solve/solveslm.m (revision 25955) +++ /issm/trunk-jpl/src/m/solve/solveslm.m (revision 25956) @@ -7,5 +7,5 @@ % % solution types available comprise: -% - 'Sealevelrise' +% - 'Sealevelchange' % - 'Transient' % @@ -18,6 +18,6 @@ if strcmpi(solutionstringi,'tr') || strcmpi(solutionstringi,'Transient') solutionstring = 'TransientSolution'; -elseif strcmpi(solutionstringi,'slr') || strcmpi(solutionstringi,'Sealevelrise') - solutionstring = 'SealevelriseSolution'; +elseif strcmpi(solutionstringi,'slr') || strcmpi(solutionstringi,'Sealevelchange') + solutionstring = 'SealevelchangeSolution'; else error(['solutionstring ' solutionstringi ' not supported!']); Index: /issm/trunk-jpl/test/NightlyRun/GetIds.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/GetIds.py (revision 25955) +++ /issm/trunk-jpl/test/NightlyRun/GetIds.py (revision 25956) @@ -15,6 +15,6 @@ ids = GetIds('Dakota') ids = GetIds([101, 102...]) - ids = GetIds([\'Dakota\', \'Slr\'...]) - ids = GetIds([[101, 102...], [\'Dakota\', \'Slr\'...]]) + ids = GetIds([\'Dakota\', \'Slc\'...]) + ids = GetIds([[101, 102...], [\'Dakota\', \'Slc\'...]]) """ Index: /issm/trunk-jpl/test/NightlyRun/runme.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/runme.m (revision 25955) +++ /issm/trunk-jpl/test/NightlyRun/runme.m (revision 25956) @@ -21,5 +21,5 @@ % 'qmu' : validation of dakota tests % 'referential' : validation of referential tests -% 'slr' : validation of slr tests +% 'slc' : validation of slc tests % 'thermal' : validation of thermal tests % 'tranforcing' : validation of transient forcing tests @@ -54,5 +54,5 @@ %GET benchmark {{{ benchmark=getfieldvalue(options,'benchmark','nightly'); -if ~ismember(benchmark,{'all','nightly','ismip','eismint','thermal','mesh','validation','tranforcing','adolc','slr','qmu'}) +if ~ismember(benchmark,{'all','nightly','ismip','eismint','thermal','mesh','validation','tranforcing','adolc','slc','qmu'}) disp('runme warning: benchmark not supported, defaulting to test ''nightly''') benchmark='nightly'; @@ -122,5 +122,5 @@ elseif strcmpi(benchmark,'referential'), test_ids=intersect(test_ids,[1601:1602]); -elseif strcmpi(benchmark,'slr'), +elseif strcmpi(benchmark,'slc'), test_ids=intersect(test_ids,[2001:2500]); elseif strcmpi(benchmark,'adolc'), Index: /issm/trunk-jpl/test/NightlyRun/runme.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/runme.py (revision 25955) +++ /issm/trunk-jpl/test/NightlyRun/runme.py (revision 25956) @@ -47,5 +47,5 @@ 'qmu' : validation of qmu tests 'referential' : validation of referential tests - 'slr' : validation of slr tests + 'slc' : validation of slc tests 'thermal' : validation of thermal tests 'tranforcing' : validation of transient forcing tests @@ -63,5 +63,5 @@ ./runme.py -e 2001 ./runme.py -e 'Dakota' --benchmark 'all' - ./runme.py -i [[101, 102], ['Dakota', 'Slr']] + ./runme.py -i [[101, 102], ['Dakota', 'Slc']] TODO: @@ -76,5 +76,5 @@ #Process options #GET benchmark {{{ - if benchmark not in ['all', 'nightly', 'validation', 'adolc', 'eismint', 'ismip', 'mesh', 'slr', 'thermal', 'tranforcing', 'qmu']: + if benchmark not in ['all', 'nightly', 'validation', 'adolc', 'eismint', 'ismip', 'mesh', 'slc', 'thermal', 'tranforcing', 'qmu']: print(("runme warning: benchmark '{}' not supported, defaulting to test 'nightly'.".format(benchmark))) benchmark = 'nightly' @@ -129,5 +129,5 @@ elif benchmark == 'referential': test_ids = test_ids.intersection(set(range(1601, 1603))) - elif benchmark == 'slr': + elif benchmark == 'slc': test_ids = test_ids.intersection(set(range(2001, 2500))) elif benchmark == 'adolc': Index: /issm/trunk-jpl/test/NightlyRun/test2002.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test2002.m (revision 25955) +++ /issm/trunk-jpl/test/NightlyRun/test2002.m (revision 25956) @@ -1,3 +1,3 @@ -%Test Name: EarthSlr +%Test Name: EarthSlc %mesh earth: Index: /issm/trunk-jpl/test/NightlyRun/test2002.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test2002.py (revision 25955) +++ /issm/trunk-jpl/test/NightlyRun/test2002.py (revision 25956) @@ -1,3 +1,3 @@ -#Test Name: EarthSlr +#Test Name: EarthSlc import numpy as np Index: /issm/trunk-jpl/test/NightlyRun/test2003.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test2003.m (revision 25955) +++ /issm/trunk-jpl/test/NightlyRun/test2003.m (revision 25956) @@ -1,3 +1,3 @@ -%Test Name: EarthSlr_rotationalFeedback +%Test Name: EarthSlc_rotationalFeedback %mesh earth: @@ -5,5 +5,5 @@ md.mesh=gmshplanet('radius',6.371012*10^3,'resolution',1000.); %1000 km resolution mesh -%parameterize slr solution: +%parameterize slc solution: %solidearth loading: {{{ md.solidearth.surfaceload.icethicknesschange=zeros(md.mesh.numberofelements,1); Index: /issm/trunk-jpl/test/NightlyRun/test2003.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test2003.py (revision 25955) +++ /issm/trunk-jpl/test/NightlyRun/test2003.py (revision 25956) @@ -1,3 +1,3 @@ -#Test Name: EarthSlr_rotationalFeedback +#Test Name: EarthSlc_rotationalFeedback import numpy as np Index: /issm/trunk-jpl/test/NightlyRun/test2004.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test2004.m (revision 25955) +++ /issm/trunk-jpl/test/NightlyRun/test2004.m (revision 25956) @@ -135,5 +135,5 @@ md.geometry.bed=-ones(md.mesh.numberofvertices,1); end % }}} - %Slr: {{{ + %Slc: {{{ if bas.iscontinentany('antarctica'), if testagainst2002, @@ -244,5 +244,5 @@ % }}} %}}} - %slr loading/calibration: {{{ + %slc loading/calibration: {{{ md.solidearth.surfaceload.icethicknesschange=zeros(md.mesh.numberofelements,1); Index: /issm/trunk-jpl/test/NightlyRun/test2005.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test2005.m (revision 25955) +++ /issm/trunk-jpl/test/NightlyRun/test2005.m (revision 25956) @@ -1,3 +1,3 @@ -%Test Name: EarthSlr +%Test Name: EarthSlc %mesh earth: @@ -72,5 +72,5 @@ md.timestepping.final_time=10; md.timestepping.time_step=1; -md.transient.isslr=1; +md.transient.isslc=1; md.transient.issmb=0; md.transient.isgia=1; @@ -97,5 +97,5 @@ S5=md.results.TransientSolution(5).Sealevel; S10=md.results.TransientSolution(10).Sealevel; -Seus10=md.results.TransientSolution(10).Bslr; +Seus10=md.results.TransientSolution(10).Bslc; %Fields and tolerances to track changes Index: /issm/trunk-jpl/test/NightlyRun/test2005.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test2005.py (revision 25955) +++ /issm/trunk-jpl/test/NightlyRun/test2005.py (revision 25956) @@ -1,3 +1,3 @@ -#Test Name: EarthSlr +#Test Name: EarthSlc import numpy as np @@ -84,5 +84,5 @@ md.timestepping.final_time = 10 md.timestepping.time_step = 1 -md.transient.isslr = 1 +md.transient.isslc = 1 md.transient.issmb = 0 md.transient.isgia = 1 @@ -109,5 +109,5 @@ S5 = md.results.TransientSolution[5 - 1].Sealevel S10 = md.results.TransientSolution[10 - 1].Sealevel -Seus10 = md.results.TransientSolution[10 - 1].Bslr +Seus10 = md.results.TransientSolution[10 - 1].Bslc #Fields and tolerances to track changes Index: /issm/trunk-jpl/test/NightlyRun/test2006.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test2006.m (revision 25955) +++ /issm/trunk-jpl/test/NightlyRun/test2006.m (revision 25956) @@ -1,3 +1,3 @@ -%Test Name: EarthSlr Dakota Sampling glaciers. +%Test Name: EarthSlc Dakota Sampling glaciers. %mesh earth: @@ -73,5 +73,5 @@ md.timestepping.final_time=10; md.timestepping.time_step=1; -md.transient.isslr=1; +md.transient.isslc=1; md.transient.issmb=0; md.transient.isgia=1; @@ -161,14 +161,14 @@ md.qmu.statistics.method(1).name='Histogram'; -md.qmu.statistics.method(1).fields={'Sealevel','BslrIce'}; +md.qmu.statistics.method(1).fields={'Sealevel','BslcIce'}; md.qmu.statistics.method(1).steps=[1:10]; md.qmu.statistics.method(1).nbins=20; md.qmu.statistics.method(2).name='MeanVariance'; -md.qmu.statistics.method(2).fields={'Sealevel','BslrIce'}; +md.qmu.statistics.method(2).fields={'Sealevel','BslcIce'}; md.qmu.statistics.method(2).steps=[1:10]; md.qmu.statistics.method(3).name='SampleSeries'; -md.qmu.statistics.method(3).fields={'Sealevel','BslrIce'}; +md.qmu.statistics.method(3).fields={'Sealevel','BslcIce'}; md.qmu.statistics.method(3).steps=[1:10]; md.qmu.statistics.method(3).indices=locations; Index: /issm/trunk-jpl/test/NightlyRun/test2006.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test2006.py (revision 25955) +++ /issm/trunk-jpl/test/NightlyRun/test2006.py (revision 25956) @@ -1,3 +1,3 @@ -#Test Name: EarthSlr Dakota Sampling glaciers +#Test Name: EarthSlc Dakota Sampling glaciers import numpy as np @@ -87,5 +87,5 @@ md.timestepping.final_time = 10 md.timestepping.time_step = 1 -md.transient.isslr = 1 +md.transient.isslc = 1 md.transient.issmb = 0 md.transient.isgia = 1 @@ -195,5 +195,5 @@ md.qmu.statistics.method[0]['name'] = 'Histogram' -md.qmu.statistics.method[0]['fields'] = ['Sealevel', 'BslrIce'] +md.qmu.statistics.method[0]['fields'] = ['Sealevel', 'BslcIce'] md.qmu.statistics.method[0]['steps'] = np.arange(1, 10 + 1).reshape(1, -1) md.qmu.statistics.method[0]['nbins'] = 20 @@ -201,10 +201,10 @@ md.qmu.statistics.addmethod() md.qmu.statistics.method[1]['name'] = 'MeanVariance' -md.qmu.statistics.method[1]['fields'] = ['Sealevel', 'BslrIce'] +md.qmu.statistics.method[1]['fields'] = ['Sealevel', 'BslcIce'] md.qmu.statistics.method[1]['steps'] = np.arange(1, 10 + 1).reshape(1, -1) md.qmu.statistics.addmethod() md.qmu.statistics.method[2]['name'] = 'SampleSeries' -md.qmu.statistics.method[2]['fields'] = ['Sealevel', 'BslrIce'] +md.qmu.statistics.method[2]['fields'] = ['Sealevel', 'BslcIce'] md.qmu.statistics.method[2]['steps'] = np.arange(1, 10 + 1).reshape(1, -1) md.qmu.statistics.method[2]['indices'] = locations.reshape(1, -1) Index: /issm/trunk-jpl/test/NightlyRun/test2010.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test2010.m (revision 25955) +++ /issm/trunk-jpl/test/NightlyRun/test2010.m (revision 25956) @@ -6,6 +6,6 @@ md.mesh=gmshplanet('radius',rad_e,'resolution',1000.0); % km resolution -%parameterize slr solution: -%slr loading: {{{ +%parameterize slc solution: +%slc loading: {{{ late=sum(md.mesh.lat(md.mesh.elements),2)/3; longe=sum(md.mesh.long(md.mesh.elements),2)/3; @@ -75,6 +75,6 @@ % uncomment following 2 lines for md=solve(md,'Sealevelchange'); -eus=md.results.SealevelchangeSolution.Bslr; -slr=md.results.SealevelchangeSolution.Sealevel; +eus=md.results.SealevelchangeSolution.Bslc; +slc=md.results.SealevelchangeSolution.Sealevel; moixz=md.results.SealevelchangeSolution.SealevelInertiaTensorXZ; moiyz=md.results.SealevelchangeSolution.SealevelInertiaTensorYZ; @@ -82,5 +82,5 @@ % analytical moi => just checking FOR ICE only!!! {{{ -% ...have to mute ** slr induced MOI in Tria.cpp ** prior to the comparison +% ...have to mute ** slc induced MOI in Tria.cpp ** prior to the comparison %rad_e = rad_e*1e3; % now in meters %areas=GetAreasSphericalTria(md.mesh.elements,md.mesh.lat,md.mesh.long,rad_e); @@ -91,6 +91,6 @@ %Fields and tolerances to track changes -field_names ={'eus','slr','moixz','moiyz','moizz'}; +field_names ={'eus','slc','moixz','moiyz','moizz'}; field_tolerances={1e-13,1e-13,1e-13,1e-13,1e-13}; -field_values={eus,slr,moixz,moiyz,moizz}; +field_values={eus,slc,moixz,moiyz,moizz}; Index: /issm/trunk-jpl/test/NightlyRun/test2010.py =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test2010.py (revision 25955) +++ /issm/trunk-jpl/test/NightlyRun/test2010.py (revision 25956) @@ -87,6 +87,6 @@ # uncomment following 2 lines for md = solve(md, 'Sealevelrise') -eus = md.results.SealevelriseSolution.Bslr -slr = md.results.SealevelriseSolution.Sealevel +eus = md.results.SealevelriseSolution.Bslc +slc = md.results.SealevelriseSolution.Sealevel moixz = md.results.SealevelriseSolution.SealevelInertiaTensorXZ moiyz = md.results.SealevelriseSolution.SealevelInertiaTensorYZ @@ -103,5 +103,5 @@ #Fields and tolerances to track changes -field_names = ['eus', 'slr', 'moixz', 'moiyz', 'moizz'] +field_names = ['eus', 'slc', 'moixz', 'moiyz', 'moizz'] field_tolerances = [1e-13, 1e-13, 1e-13, 1e-13, 1e-13] -field_values = [eus, slr, moixz, moiyz, moizz] +field_values = [eus, slc, moixz, moiyz, moizz] Index: /issm/trunk-jpl/test/NightlyRun/test2020.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test2020.m (revision 25955) +++ /issm/trunk-jpl/test/NightlyRun/test2020.m (revision 25956) @@ -1,3 +1,3 @@ -%Test Name: SHslr +%Test Name: SHslc % spherical-harmonic (SH) approach for solving the sea-level equation. % reference: Adhikari et al., 2019, ESSD, https://doi.org/10.5194/essd-11-629-2019 Index: /issm/trunk-jpl/test/NightlyRun/test2021.m =================================================================== --- /issm/trunk-jpl/test/NightlyRun/test2021.m (revision 25955) +++ /issm/trunk-jpl/test/NightlyRun/test2021.m (revision 25956) @@ -1,4 +1,4 @@ -%Test Name: SESAWslr -% SESAW method of solving GRD slr +%Test Name: SESAWslc +% SESAW method of solving GRD slc % reference: Adhikari et al., 2016, GMD, https://doi.org/10.5194/gmd-9-1087-2016 @@ -36,5 +36,5 @@ area_element=GetAreasSphericalTria(md.mesh.elements,md.mesh.lat,md.mesh.long,md.solidearth.planetradius); -% Parameters input for SESAWslr solver. +% Parameters input for SESAWslc solver. para.ocean_element = ocean_element; para.loads_element = loads_element; @@ -61,20 +61,20 @@ % solve: Rigid without rotational feedbacks. -disp(['Solving sesaw-slr for Rigid Earth WITHOUT rotational feedback...']); +disp(['Solving sesaw-slc for Rigid Earth WITHOUT rotational feedback...']); [eus_rigid,rsl_rigid] = SESAWslr(md.mesh.elements,md.mesh.lat,md.mesh.long,greens,para); % solve: Rigid with rotational feedbacks. para.rotational.flag = 1; -disp(['Solving sesaw-slr for Rigid Earth WITH rotational feedback...']); +disp(['Solving sesaw-slc for Rigid Earth WITH rotational feedback...']); [eus_rigid_rot,rsl_rigid_rot] = SESAWslr(md.mesh.elements,md.mesh.lat,md.mesh.long,greens,para); % solve: Elastic with rotational feedbacks. para.solidearth = 'elastic'; -disp(['Solving sesaw-slr for Elastic Earth WITH rotational feedback...']); +disp(['Solving sesaw-slc for Elastic Earth WITH rotational feedback...']); [eus_elast_rot,rsl_elast_rot] = SESAWslr(md.mesh.elements,md.mesh.lat,md.mesh.long,greens,para); % solve: Elastic with rotational feedbacks. para.rotational.flag = 0; -disp(['Solving sesaw-slr for Elastic Earth WITHOUT rotational feedback...']); +disp(['Solving sesaw-slc for Elastic Earth WITHOUT rotational feedback...']); [eus_elast,rsl_elast] = SESAWslr(md.mesh.elements,md.mesh.lat,md.mesh.long,greens,para);