CIME.SystemTests package

Subpackages

• CIME.SystemTests.test_utils package
  • Submodules
  • CIME.SystemTests.test_utils.user_nl_utils module
    • append_to_user_nl_files()
  • Module contents

Submodules

CIME.SystemTests.dae module

Implementation of the CIME data assimilation test: Compares standard run with run broken into two data assimilation cycles. Runs a simple DA script on each cycle which performs checks but does not change any model state (restart files). Compares answers of two runs.

class CIME.SystemTests.dae.DAE(case, **kwargs)

Bases: SystemTestsCompareTwo

Implementation of the CIME data assimilation test: Compares standard run with a run broken into two data assimilation cycles. Runs a simple DA script on each cycle which performs checks but does not change any model state (restart files). Compares answers of two runs. Refers to a faux data assimilation script in the cime/scripts/data_assimilation directory

run_phase()

Runs both phases of the two-phase test and compares their results If success_change is True, success requires some files to be different

CIME.SystemTests.eri module

CIME ERI test This class inherits from SystemTestsCommon

class CIME.SystemTests.eri.ERI(case, **kwargs)

Bases: SystemTestsCommon

run_phase()

This is the default run phase implementation, it just does an individual run. This is the subclass’ extension point if they need to define a custom run phase.

PLEASE THROW AN EXCEPTION ON FAIL

CIME.SystemTests.erio module

ERIO tests restart with different PIO methods

This class inherits from SystemTestsCommon

class CIME.SystemTests.erio.ERIO(case, **kwargs)

Bases: SystemTestsCommon

run_phase()

This is the default run phase implementation, it just does an individual run. This is the subclass’ extension point if they need to define a custom run phase.

PLEASE THROW AN EXCEPTION ON FAIL

CIME.SystemTests.erp module

CIME ERP test. This class inherits from RestartTest

This is a pes counts hybrid (open-MP/MPI) restart bfb test from startup. This is just like an ERS test but the pe-counts/threading count are modified on restart. (1) Do an initial run with pes set up out of the box (suffix base) (2) Do a restart test with half the number of tasks and threads (suffix rest)

class CIME.SystemTests.erp.ERP(case, **kwargs)

Bases: RestartTest

CIME.SystemTests.err module

CIME ERR test This class inherits from ERS ERR tests short term archiving and restart capabilities

class CIME.SystemTests.err.ERR(case, **kwargs)

Bases: RestartTest

CIME.SystemTests.erri module

CIME ERRI test This class inherits from ERR ERRI tests short term archiving and restart capabilities with “incomplete” (unzipped) log files

class CIME.SystemTests.erri.ERRI(case, **kwargs)

Bases: ERR

CIME.SystemTests.ers module

CIME restart test This class inherits from SystemTestsCommon

class CIME.SystemTests.ers.ERS(case, **kwargs)

Bases: SystemTestsCommon

run_phase()

This is the default run phase implementation, it just does an individual run. This is the subclass’ extension point if they need to define a custom run phase.

PLEASE THROW AN EXCEPTION ON FAIL

CIME.SystemTests.ers2 module

CIME restart test 2 This class inherits from SystemTestsCommon

class CIME.SystemTests.ers2.ERS2(case, **kwargs)

Bases: SystemTestsCommon

run_phase()

This is the default run phase implementation, it just does an individual run. This is the subclass’ extension point if they need to define a custom run phase.

PLEASE THROW AN EXCEPTION ON FAIL

CIME.SystemTests.ert module

CIME production restart test This class inherits from SystemTestsCommon Exact restart from startup, default 2 month + 1 month

class CIME.SystemTests.ert.ERT(case, **kwargs)

Bases: SystemTestsCommon

run_phase()

This is the default run phase implementation, it just does an individual run. This is the subclass’ extension point if they need to define a custom run phase.

PLEASE THROW AN EXCEPTION ON FAIL

CIME.SystemTests.funit module

CIME FUNIT test. This class inherits from SystemTestsCommon. It runs the fortran unit tests; grid and compset are ignored.

class CIME.SystemTests.funit.FUNIT(case, **kwargs)

Bases: SystemTestsCommon

build_phase(sharedlib_only=False, model_only=False)

This is the default build phase implementation, it just does an individual build. This is the subclass’ extension point if they need to define a custom build phase.

PLEASE THROW EXCEPTION ON FAIL

get_test_spec_dir()

Override this to change what gets tested.

run_phase()

This is the default run phase implementation, it just does an individual run. This is the subclass’ extension point if they need to define a custom run phase.

PLEASE THROW AN EXCEPTION ON FAIL

CIME.SystemTests.homme module

class CIME.SystemTests.homme.HOMME(case, **kwargs)

Bases: HommeBase

CIME.SystemTests.hommebaseclass module

CIME HOMME test. This class inherits from SystemTestsCommon

class CIME.SystemTests.hommebaseclass.HommeBase(case, **kwargs)

Bases: SystemTestsCommon

build_phase(sharedlib_only=False, model_only=False)

This is the default build phase implementation, it just does an individual build. This is the subclass’ extension point if they need to define a custom build phase.

PLEASE THROW EXCEPTION ON FAIL

run_phase()

This is the default run phase implementation, it just does an individual run. This is the subclass’ extension point if they need to define a custom run phase.

PLEASE THROW AN EXCEPTION ON FAIL

CIME.SystemTests.hommebfb module

class CIME.SystemTests.hommebfb.HOMMEBFB(case, **kwargs)

Bases: HommeBase

CIME.SystemTests.icp module

CIME ICP test This class inherits from SystemTestsCommon

class CIME.SystemTests.icp.ICP(case, **kwargs)

Bases: SystemTestsCommon

build_phase(sharedlib_only=False, model_only=False)

This is the default build phase implementation, it just does an individual build. This is the subclass’ extension point if they need to define a custom build phase.

PLEASE THROW EXCEPTION ON FAIL

run_phase()

This is the default run phase implementation, it just does an individual run. This is the subclass’ extension point if they need to define a custom run phase.

PLEASE THROW AN EXCEPTION ON FAIL

CIME.SystemTests.irt module

Implementation of the CIME IRT. (Interim Restart Test) This test the model’s restart capability as well as the short term archiver’s interim restart capability

1. Do a Run of length N with restart at N/2 and DOUT_S_SAVE_INTERIM_RESTART set to TRUE

2. Archive Run using ST archive tools

3. Recover first interim restart to the case2 run directory

4. Start case2 from restart and run to the end of case1

5. compare results.

6. this test does not save or compare history files in baselines.

class CIME.SystemTests.irt.IRT(case, **kwargs)

Bases: RestartTest

CIME.SystemTests.ldsta module

CIME last date short term archiver test. This class inherits from SystemTestsCommon It does a run without restarting, then runs the archiver with various last-date parameters The test verifies the archive directory contains the expected files

class CIME.SystemTests.ldsta.LDSTA(case, **kwargs)

Bases: SystemTestsCommon

run_phase()

This is the default run phase implementation, it just does an individual run. This is the subclass’ extension point if they need to define a custom run phase.

PLEASE THROW AN EXCEPTION ON FAIL

CIME.SystemTests.mcc module

Implemetation of CIME MCC test: Compares ensemble methods

This does two runs: In the first we run a three member ensemble using the

MULTI_DRIVER capability, then we run a second single instance case and compare

class CIME.SystemTests.mcc.MCC(case, **kwargs)

Bases: SystemTestsCompareTwo

CIME.SystemTests.mvk module

Multivariate test for climate reproducibility using the Kolmogrov-Smirnov (K-S) test and based on The CESM/E3SM model’s multi-instance capability is used to conduct an ensemble of simulations starting from different initial conditions.

This class inherits from SystemTestsCommon.

class CIME.SystemTests.mvk.MVK(case, **kwargs)

Bases: SystemTestsCommon

build_phase(sharedlib_only=False, model_only=False)

This is the default build phase implementation, it just does an individual build. This is the subclass’ extension point if they need to define a custom build phase.

PLEASE THROW EXCEPTION ON FAIL

process_evv_output(evv_out_dir)

update_testlog(test_name, case_name, evv_out_dir)

class CIME.SystemTests.mvk.MVKConfig

Bases: ConfigBase

evv_test_config(case, config)

Customize the evv4esm configuration.

This method is used to customize the default evv4esm configuration or generate a completely new one.

The return configuration will be written to $RUNDIR/$CASE.json.

Args:

case (CIME.case.case.Case): The case instance. config (dict): Default evv4esm configuration.

Returns:

dict: Dictionary with test configuration.

generate_namelist(case, component, i, filename)

Generate per instance namelist.

This method is called for each instance to generate the desired modifications.

Args:

case (CIME.case.case.Case): The case instance. component (str): Component the namelist belongs to. i (int): Instance unique number. filename (str): Name of the namelist that needs to be created.

CIME.SystemTests.nck module

Implementation of the CIME NCK test: Tests multi-instance

This does two runs: In the first, we use one instance per component; in the second, we use two instances per components. NTASKS are changed in each run so that the number of tasks per instance is the same for both runs.

Lay all of the components out sequentially

class CIME.SystemTests.nck.NCK(case, **kwargs)

Bases: SystemTestsCompareTwo

CIME.SystemTests.ncr module

Implementation of the CIME NCR test. This class inherits from SystemTestsCommon

Build two exectuables for this test: The first runs two instances for each component with the same total number of tasks, and runs each of them concurrently The second is a default build

NOTE: This is currently untested, and may not be working properly

class CIME.SystemTests.ncr.NCR(case, **kwargs)

Bases: SystemTestsCompareTwo

CIME.SystemTests.nodefail module

CIME restart upon failed node test.

class CIME.SystemTests.nodefail.NODEFAIL(case, **kwargs)

Bases: ERS

run_phase()

This is the default run phase implementation, it just does an individual run. This is the subclass’ extension point if they need to define a custom run phase.

PLEASE THROW AN EXCEPTION ON FAIL

CIME.SystemTests.pea module

Implementation of the CIME PEA test.

Builds runs and compares a single processor mpi model to a model built using mpi-serial (1) do a run with default mpi library (suffix base) (2) do a run with mpi-serial (suffix mpi-serial)

class CIME.SystemTests.pea.PEA(case, **kwargs)

Bases: SystemTestsCompareTwo

CIME.SystemTests.pem module

Implementation of the CIME PEM test: Tests bfb with different MPI processor counts

This is just like running a smoke test twice - but the pe-counts are modified the second time. (1) Run with pes set up out of the box (suffix base) (2) Run with half the number of tasks (suffix modpes)

class CIME.SystemTests.pem.PEM(case, **kwargs)

Bases: SystemTestsCompareTwo

CIME.SystemTests.pet module

Implementation of the CIME PET test. This class inherits from SystemTestsCommon

This is an openmp test to determine that changing thread counts does not change answers. (1) do an initial run where all components are threaded by default (suffix: base) (2) do another initial run with nthrds=1 for all components (suffix: single_thread)

class CIME.SystemTests.pet.PET(case, **kwargs)

Bases: SystemTestsCompareTwo

CIME.SystemTests.pfs module

CIME performance test This class inherits from SystemTestsCommon

20 days performance test, no restart files written

class CIME.SystemTests.pfs.PFS(case, **kwargs)

Bases: SystemTestsCommon

run_phase()

This is the default run phase implementation, it just does an individual run. This is the subclass’ extension point if they need to define a custom run phase.

PLEASE THROW AN EXCEPTION ON FAIL

CIME.SystemTests.pgn module

Perturbation Growth New (PGN) - The CESM/ACME model’s multi-instance capability is used to conduct an ensemble of simulations starting from different initial conditions.

This class inherits from SystemTestsCommon.

class CIME.SystemTests.pgn.PGN(case, **kwargs)

Bases: SystemTestsCommon

build_phase(sharedlib_only=False, model_only=False)

This is the default build phase implementation, it just does an individual build. This is the subclass’ extension point if they need to define a custom build phase.

PLEASE THROW EXCEPTION ON FAIL

get_var_list()

Get variable list for pergro specific output vars

run_phase()

This is the default run phase implementation, it just does an individual run. This is the subclass’ extension point if they need to define a custom run phase.

PLEASE THROW AN EXCEPTION ON FAIL

CIME.SystemTests.pre module

Implementation of the CIME pause/resume test: Tests having driver ‘pause’ (write cpl restart file) and ‘resume’ (read cpl restart file) possibly changing the restart file. Compared to non-pause/resume run. Test can also be run with other component combinations. Test requires DESP component to function correctly.

class CIME.SystemTests.pre.PRE(case, **kwargs)

Bases: SystemTestsCompareTwo

Implementation of the CIME pause/resume test: Tests having driver ‘pause’ (write cpl and/or other restart file(s)) and ‘resume’ (read cpl and/or other restart file(s)) possibly changing restart file. Compare to non-pause/resume run.

run_phase()

Runs both phases of the two-phase test and compares their results If success_change is True, success requires some files to be different

CIME.SystemTests.rep module

Implementation of the CIME REP test

This test verifies that two identical runs give bit-for-bit results

class CIME.SystemTests.rep.REP(case, **kwargs)

Bases: SystemTestsCompareTwo

CIME.SystemTests.restart_tests module

Abstract class for restart tests

class CIME.SystemTests.restart_tests.RestartTest(case, separate_builds, run_two_suffix='restart', run_one_description='initial', run_two_description='restart', multisubmit=False, **kwargs)

Bases: SystemTestsCompareTwo

CIME.SystemTests.reuseinitfiles module

Implementation of the CIME REUSEINITFILES test

This test does two runs:

1. A standard initial run

2. A run that reuses the init-generated files from run (1).

This verifies that it works to reuse these init-generated files, and that you can get bit-for-bit results by doing so. This is important because these files are typically reused whenever a user reruns an initial case.

class CIME.SystemTests.reuseinitfiles.REUSEINITFILES(case, **kwargs)

Bases: SystemTestsCompareTwo

CIME.SystemTests.seq module

sequencing bfb test (10 day seq,conc tests)

class CIME.SystemTests.seq.SEQ(case, **kwargs)

Bases: SystemTestsCompareTwo

CIME.SystemTests.sms module

CIME smoke test This class inherits from SystemTestsCommon It does a startup run with restarts off and optionally compares to or generates baselines

class CIME.SystemTests.sms.SMS(case, **kwargs)

Bases: SystemTestsCommon

CIME.SystemTests.system_tests_common module

Base class for CIME system tests

class CIME.SystemTests.system_tests_common.FakeTest(case, expected=None, **kwargs)

Bases: SystemTestsCommon

Inheriters of the FakeTest Class are intended to test the code.

All members of the FakeTest Class must have names beginning with “TEST” this is so that the find_system_test in utils.py will work with these classes.

build_phase(sharedlib_only=False, model_only=False)

This is the default build phase implementation, it just does an individual build. This is the subclass’ extension point if they need to define a custom build phase.

PLEASE THROW EXCEPTION ON FAIL

run_indv(suffix='base', st_archive=False, submit_resubmits=None, keep_init_generated_files=False)

Perform an individual run. Raises an EXCEPTION on fail.

keep_init_generated_files: If False (the default), we remove the init_generated_files subdirectory of the run directory before running the case. This is usually what we want for tests, but some specific tests may want to leave this directory in place, so can set this variable to True to do so.

class CIME.SystemTests.system_tests_common.SystemTestsCommon(case, expected=None, **kwargs)

Bases: object

build(sharedlib_only=False, model_only=False, ninja=False, dry_run=False, separate_builds=False, skip_submit=False)

Do NOT override this method, this method is the framework that controls the build phase. build_phase is the extension point that subclasses should use.

build_indv(sharedlib_only=False, model_only=False)

Perform an individual build

build_phase(sharedlib_only=False, model_only=False)

This is the default build phase implementation, it just does an individual build. This is the subclass’ extension point if they need to define a custom build phase.

PLEASE THROW EXCEPTION ON FAIL

clean_build(comps=None)

compare_env_run(expected=None)

Compare env_run file to original and warn about differences

run(skip_pnl=False)

Do NOT override this method, this method is the framework that controls the run phase. run_phase is the extension point that subclasses should use.

run_indv(suffix='base', st_archive=False, submit_resubmits=None, keep_init_generated_files=False)

Perform an individual run. Raises an EXCEPTION on fail.

keep_init_generated_files: If False (the default), we remove the init_generated_files subdirectory of the run directory before running the case. This is usually what we want for tests, but some specific tests may want to leave this directory in place, so can set this variable to True to do so.

run_phase()

This is the default run phase implementation, it just does an individual run. This is the subclass’ extension point if they need to define a custom run phase.

PLEASE THROW AN EXCEPTION ON FAIL

class CIME.SystemTests.system_tests_common.TESTBUILDFAIL(case, expected=None, **kwargs)

Bases: TESTRUNPASS

build_phase(sharedlib_only=False, model_only=False)

This is the default build phase implementation, it just does an individual build. This is the subclass’ extension point if they need to define a custom build phase.

PLEASE THROW EXCEPTION ON FAIL

class CIME.SystemTests.system_tests_common.TESTBUILDFAILEXC(case, **kwargs)

Bases: FakeTest

class CIME.SystemTests.system_tests_common.TESTMEMLEAKFAIL(case, expected=None, **kwargs)

Bases: FakeTest

build_phase(sharedlib_only=False, model_only=False)

This is the default build phase implementation, it just does an individual build. This is the subclass’ extension point if they need to define a custom build phase.

PLEASE THROW EXCEPTION ON FAIL

class CIME.SystemTests.system_tests_common.TESTMEMLEAKPASS(case, expected=None, **kwargs)

Bases: FakeTest

build_phase(sharedlib_only=False, model_only=False)

This is the default build phase implementation, it just does an individual build. This is the subclass’ extension point if they need to define a custom build phase.

PLEASE THROW EXCEPTION ON FAIL

class CIME.SystemTests.system_tests_common.TESTRUNDIFF(case, expected=None, **kwargs)

Bases: FakeTest

You can generate a diff with this test as follows: 1) Run the test and generate a baseline 2) set TESTRUNDIFF_ALTERNATE environment variable to TRUE 3) Re-run the same test from step 1 but do a baseline comparison instead of generation

3.a) This should give you a DIFF

build_phase(sharedlib_only=False, model_only=False)

This is the default build phase implementation, it just does an individual build. This is the subclass’ extension point if they need to define a custom build phase.

PLEASE THROW EXCEPTION ON FAIL

class CIME.SystemTests.system_tests_common.TESTRUNDIFFRESUBMIT(case, expected=None, **kwargs)

Bases: TESTRUNDIFF

class CIME.SystemTests.system_tests_common.TESTRUNFAIL(case, expected=None, **kwargs)

Bases: FakeTest

build_phase(sharedlib_only=False, model_only=False)

This is the default build phase implementation, it just does an individual build. This is the subclass’ extension point if they need to define a custom build phase.

PLEASE THROW EXCEPTION ON FAIL

class CIME.SystemTests.system_tests_common.TESTRUNFAILEXC(case, expected=None, **kwargs)

Bases: TESTRUNPASS

run_phase()

This is the default run phase implementation, it just does an individual run. This is the subclass’ extension point if they need to define a custom run phase.

PLEASE THROW AN EXCEPTION ON FAIL

class CIME.SystemTests.system_tests_common.TESTRUNFAILRESET(case, expected=None, **kwargs)

Bases: TESTRUNFAIL

This fake test can fail for two reasons: 1. As in the TESTRUNFAIL test: If the environment variable TESTRUNFAIL_PASS is not set 2. Even if that environment variable is set, it will fail if STOP_N differs from the

original value

The purpose of (2) is to ensure that test’s values get properly reset if the test is rerun after an initial failure.

run_indv(suffix='base', st_archive=False, submit_resubmits=None, keep_init_generated_files=False)

Perform an individual run. Raises an EXCEPTION on fail.

keep_init_generated_files: If False (the default), we remove the init_generated_files subdirectory of the run directory before running the case. This is usually what we want for tests, but some specific tests may want to leave this directory in place, so can set this variable to True to do so.

class CIME.SystemTests.system_tests_common.TESTRUNPASS(case, expected=None, **kwargs)

Bases: FakeTest

build_phase(sharedlib_only=False, model_only=False)

This is the default build phase implementation, it just does an individual build. This is the subclass’ extension point if they need to define a custom build phase.

PLEASE THROW EXCEPTION ON FAIL

class CIME.SystemTests.system_tests_common.TESTRUNSLOWPASS(case, expected=None, **kwargs)

Bases: FakeTest

build_phase(sharedlib_only=False, model_only=False)

This is the default build phase implementation, it just does an individual build. This is the subclass’ extension point if they need to define a custom build phase.

PLEASE THROW EXCEPTION ON FAIL

class CIME.SystemTests.system_tests_common.TESTRUNSTARCFAIL(case, expected=None, **kwargs)

Bases: TESTRUNPASS

class CIME.SystemTests.system_tests_common.TESTRUNUSERXMLCHANGE(case, expected=None, **kwargs)

Bases: FakeTest

build_phase(sharedlib_only=False, model_only=False)

This is the default build phase implementation, it just does an individual build. This is the subclass’ extension point if they need to define a custom build phase.

PLEASE THROW EXCEPTION ON FAIL

run_phase()

This is the default run phase implementation, it just does an individual run. This is the subclass’ extension point if they need to define a custom run phase.

PLEASE THROW AN EXCEPTION ON FAIL

class CIME.SystemTests.system_tests_common.TESTTESTDIFF(case, expected=None, **kwargs)

Bases: FakeTest

build_phase(sharedlib_only=False, model_only=False)

This is the default build phase implementation, it just does an individual build. This is the subclass’ extension point if they need to define a custom build phase.

PLEASE THROW EXCEPTION ON FAIL

run_phase()

This is the default run phase implementation, it just does an individual run. This is the subclass’ extension point if they need to define a custom run phase.

PLEASE THROW AN EXCEPTION ON FAIL

CIME.SystemTests.system_tests_common.fix_single_exe_case(case)

Fixes cases created with –single-exe.

When tests are created using –single-exe, the test_scheduler will set BUILD_COMPLETE to True, but some tests require calls to case.case_setup which can resets BUILD_COMPLETE to false. This function will check if a case was created with –single-exe and ensure BUILD_COMPLETE is True.

Returns:

True when case required modification otherwise False.

CIME.SystemTests.system_tests_common.is_single_exe_case(case)

Determines if the case was created with the –single-exe option.

If CASEROOT is not part of EXEROOT and the TEST variable is True, then its safe to assume the case was created with ./create_test and the –single-exe option.

Returns:

True when the case was created with –single-exe otherwise false.

CIME.SystemTests.system_tests_common.perf_check_for_memory_leak(case, tolerance)

CIME.SystemTests.system_tests_compare_n module

Base class for CIME system tests that involve doing multiple runs and comparing the base run (index=0) with the subsequent runs (indices=1..N-1).

NOTE: Below is the flow of a multisubmit test. Non-batch: case_submit -> case_run # PHASE 1

-> case_run # PHASE 2 … -> case_run # PHASE N

batch: case_submit -> case_run # PHASE 1 case_run -> case_submit case_submit -> case_run # PHASE 2 … case_submit -> case_run # PHASE N

In the __init__ method for your test, you MUST call

SystemTestsCompareN.__init__

See the documentation of that method for details.

Classes that inherit from this are REQUIRED to implement the following method:

1. _case_setup This method will be called to set up case i, where i==0 corresponds to the base case and i=={1,..N-1} corresponds to subsequent runs to be compared with the base.

In addition, they MAY require the following methods:

1. _common_setup This method will be called to set up all cases. It should contain any setup that’s needed in all cases. This is called before _case_setup_config

2. _case_custom_prerun_action(self, i): Use this to do arbitrary actions immediately before running case i

3. _case_custom_postrun_action(self, i): Use this to do arbitrary actions immediately after running case one

class CIME.SystemTests.system_tests_compare_n.SystemTestsCompareN(case, N=2, separate_builds=False, run_suffixes=None, run_descriptions=None, multisubmit=False, ignore_fieldlist_diffs=False, dry_run=False, **kwargs)

Bases: SystemTestsCommon

build_phase(sharedlib_only=False, model_only=False)

This is the default build phase implementation, it just does an individual build. This is the subclass’ extension point if they need to define a custom build phase.

PLEASE THROW EXCEPTION ON FAIL

run_phase(success_change=False)

Runs all phases of the N-phase test and compares base results with subsequent ones If success_change is True, success requires some files to be different

CIME.SystemTests.system_tests_compare_two module

Base class for CIME system tests that involve doing two runs and comparing their output.

NOTE: Below is the flow of a multisubmit test. Non-batch: case_submit -> case_run # PHASE 1

-> case_run # PHASE 2

batch: case_submit -> case_run # PHASE 1 case_run -> case_submit case_submit -> case_run # PHASE 2

In the __init__ method for your test, you MUST call

SystemTestsCompareTwo.__init__

See the documentation of that method for details.

Classes that inherit from this are REQUIRED to implement the following methods:

1. _case_one_setup This method will be called to set up case 1, the “base” case

2. _case_two_setup This method will be called to set up case 2, the “test” case

Note that the base class will always call case_setup(reset=True) on both case1 and case2 during setup.

In addition, they MAY require the following methods:

1. _common_setup This method will be called to set up both cases. It should contain any setup that’s needed in both cases. This is called before _case_one_setup or _case_two_setup.

2. _case_one_custom_prerun_action(self): Use this to do arbitrary actions immediately before running case one

3. _case_two_custom_prerun_action(self): Use this to do arbitrary actions immediately before running case two

4. _case_one_custom_postrun_action(self): Use this to do arbitrary actions immediately after running case one

5. _case_two_custom_postrun_action(self): Use this to do arbitrary actions immediately after running case two

class CIME.SystemTests.system_tests_compare_two.SystemTestsCompareTwo(case, separate_builds=False, run_two_suffix='test', run_one_description='', run_two_description='', multisubmit=False, ignore_fieldlist_diffs=False, case_two_keep_init_generated_files=False, dry_run=False, **kwargs)

Bases: SystemTestsCommon

build_phase(sharedlib_only=False, model_only=False)

This is the default build phase implementation, it just does an individual build. This is the subclass’ extension point if they need to define a custom build phase.

PLEASE THROW EXCEPTION ON FAIL

copy_case1_restarts_to_case2()

Makes a copy (or symlink) of restart files and related files (necessary history files, rpointer files) from case1 to case2.

This is not done automatically, but can be called by individual tests where case2 does a continue_run using case1’s restart files.

run_phase(success_change=False)

Runs both phases of the two-phase test and compares their results If success_change is True, success requires some files to be different

CIME.SystemTests.test_mods module

CIME.SystemTests.test_mods.find_test_mods(comp_interface, test_mods)

Finds paths from names of testmods.

Testmod format is ${component}-${testmod}. Each testmod is search for it it’s component respective TESTS_MODS_DIR and USER_MODS_DIR.

Args:

comp_interface (str): Name of the component interface. test_mods (list): List of testmods names.

Returns:

List of paths for each testmod.

Raises:

CIMEError: If a testmod is not in correct format. CIMEError: If testmod could not be found.

CIME.SystemTests.tsc module

Solution reproducibility test based on time-step convergence The CESM/ACME model’s multi-instance capability is used to conduct an ensemble of simulations starting from different initial conditions.

This class inherits from SystemTestsCommon.

class CIME.SystemTests.tsc.TSC(case, **kwargs)

Bases: SystemTestsCommon

build_phase(sharedlib_only=False, model_only=False)

This is the default build phase implementation, it just does an individual build. This is the subclass’ extension point if they need to define a custom build phase.

PLEASE THROW EXCEPTION ON FAIL

run_phase()

This is the default run phase implementation, it just does an individual run. This is the subclass’ extension point if they need to define a custom run phase.

PLEASE THROW AN EXCEPTION ON FAIL

Module contents