def check_case(case):
check_lockedfiles(case)
create_namelists(case) # Must be called before check_all_input_data
logger.info("Checking that inputdata is available as part of case submission")
check_all_input_data(case)
expect(case.get_value("BUILD_COMPLETE"), "Build complete is "
"not True please rebuild the model by calling case.build")
logger.info("Check case OK")
def check_case(case, caseroot):
check_lockedfiles(caseroot)
create_namelists(case) # Must be called before check_all_input_data
check_all_input_data(case)
# Now that we have baselines, do baseline operations
if case.get_value("TEST"):
case_cmpgen_namelists(case)
expect(case.get_value("BUILD_COMPLETE"), "Build complete is "
"not True please rebuild the model by calling case.build")
logger.info("Check case OK")
def run_phase(self):
caseroot = self._case.get_value("CASEROOT")
clone1_path = "%s.ref1" % caseroot
clone2_path = "%s.ref2" % caseroot
#self._case.set_value("CHECK_TIMING", False)
#
# clone the main case to create ref1 and ref2 cases
#
for clone_path in [clone1_path, clone2_path]:
if os.path.exists(clone_path):
shutil.rmtree(clone_path)
clone1, clone2 = [self._case.create_clone(clone_path, keepexe=True) for clone_path in [clone1_path, clone2_path]]
orig_case = self._case
orig_casevar = orig_case.get_value("CASE")
#
# determine run lengths needed below
#
stop_n = self._case.get_value("STOP_N")
stop_option = self._case.get_value("STOP_OPTION")
run_startdate = self._case.get_value("RUN_STARTDATE")
stop_n1 = stop_n / 6
rest_n1 = stop_n1
start_1 = run_startdate
stop_n2 = stop_n - stop_n1
rest_n2 = stop_n2 / 2 + 1
hist_n = stop_n2
start_1_year, start_1_month, start_1_day = [int(item) for item in start_1.split("-")]
start_2_year = start_1_year + 2
start_2 = "%04d-%02d-%02d" % (start_2_year, start_1_month, start_1_day)
stop_n3 = stop_n2 - rest_n2
rest_n3 = stop_n3 / 2 + 1
stop_n4 = stop_n3 - rest_n3
expect(stop_n4 >= 1 and stop_n1 >= 1, "Run length too short")
#
# (1) Test run:
# do an initial ref1 case run
# cloned the case and running there
# (NOTE: short term archiving is on)
#
os.chdir(clone1_path)
self._set_active_case(clone1)
logger.info("ref1 startup: doing a %s %s startup run from %s and 00000 seconds" % (stop_n1, stop_option, start_1))
logger.info(" writing restarts at %s %s" % (rest_n1, stop_option))
logger.info(" short term archiving is on ")
clone1.set_value("CONTINUE_RUN", False)
clone1.set_value("RUN_STARTDATE", start_1)
clone1.set_value("STOP_N", stop_n1)
clone1.set_value("REST_OPTION", stop_option)
clone1.set_value("REST_N", rest_n1)
clone1.set_value("HIST_OPTION", "never")
clone1.flush()
# if the initial case is hybrid this will put the reference data in the correct location
check_all_input_data(clone1)
dout_sr1 = clone1.get_value("DOUT_S_ROOT")
# force cam namelist to write out initial file at end of run
if os.path.exists("user_nl_cam"):
if "inithist" not in open("user_nl_cam", "r").read():
with open("user_nl_cam", "a") as fd:
fd.write("inithist = 'ENDOFRUN'\n")
self.run_indv(st_archive=True, suffix=None)
#
# (2) Test run:
# do a hybrid ref2 case run
# cloned the main case and running with ref1 restarts
# (NOTE: short term archiving is on)
#
os.chdir(clone2_path)
self._set_active_case(clone2)
# Set startdate to start2, set ref date based on ref1 restart
refdate_2 = run_cmd_no_fail(r'ls -1dt %s/rest/*-00000* | head -1 | sed "s/-00000.*//" | sed "s/^.*rest\///"' % dout_sr1)
refsec_2 = "00000"
logger.info("ref2 hybrid: doing a %s %s startup hybrid run" % (stop_n2, stop_option))
logger.info(" starting from %s and using ref1 %s and %s seconds" % (start_2, refdate_2, refsec_2))
logger.info(" writing restarts at %s %s" % (rest_n2, stop_option))
logger.info(" short term archiving is on ")
# setup ref2 case
clone2.set_value("RUN_TYPE", "hybrid")
clone2.set_value("RUN_STARTDATE", start_2)
clone2.set_value("RUN_REFCASE", "%s.ref1" % orig_casevar)
clone2.set_value("RUN_REFDATE", refdate_2)
clone2.set_value("RUN_REFTOD", refsec_2)
clone2.set_value("GET_REFCASE", False)
clone2.set_value("CONTINUE_RUN", False)
clone2.set_value("STOP_N", stop_n2)
clone2.set_value("REST_OPTION", stop_option)
clone2.set_value("REST_N", rest_n2)
clone2.set_value("HIST_OPTION", stop_option)
clone2.set_value("HIST_N", hist_n)
clone2.flush()
rundir = clone2.get_value("RUNDIR")
dout_sr2 = clone2.get_value("DOUT_S_ROOT")
if not os.path.exists(rundir):
os.makedirs(rundir)
_helper(dout_sr1, refdate_2, refsec_2, rundir)
# run ref2 case (all component history files will go to short term archiving)
self.run_indv(suffix="hybrid", st_archive=True)
#
# (3a) Test run:
# do a branch run from ref2 restart (short term archiving is off)
#
os.chdir(caseroot)
self._set_active_case(orig_case)
refdate_3 = run_cmd_no_fail(r'ls -1dt %s/rest/*-00000* | head -1 | sed "s/-00000.*//" | sed "s/^.*rest\///"' % dout_sr2)
refsec_3 = "00000"
logger.info("branch: doing a %s %s branch" % (stop_n3, stop_option))
logger.info(" starting from ref2 %s and %s seconds restarts" % (refdate_3, refsec_3))
logger.info(" writing restarts at %s %s" % (rest_n3, stop_option))
logger.info(" short term archiving is off")
self._case.set_value("RUN_TYPE" , "branch")
self._case.set_value("RUN_REFCASE" , "%s.ref2" % self._case.get_value("CASE"))
self._case.set_value("RUN_REFDATE" , refdate_3)
self._case.set_value("RUN_REFTOD" , refsec_3)
self._case.set_value("GET_REFCASE" , False)
self._case.set_value("CONTINUE_RUN" , False)
self._case.set_value("STOP_N" , stop_n3)
self._case.set_value("REST_OPTION" , stop_option)
self._case.set_value("REST_N" , rest_n3)
self._case.set_value("HIST_OPTION" , stop_option)
self._case.set_value("HIST_N" , stop_n2)
self._case.set_value("DOUT_S" , False)
self._case.flush()
rundir = self._case.get_value("RUNDIR")
if not os.path.exists(rundir):
os.makedirs(rundir)
_helper(dout_sr2, refdate_3, refsec_3, rundir)
# the following lines creates the initial component history files for the restart test
for item in glob.glob("%s/*/hist/*nc" % dout_sr2):
newfile = "%s" % item.replace(".ref2", "")
newfile = os.path.basename(newfile)
os.symlink(item, os.path.join(rundir, newfile))
self._component_compare_copy("hybrid")
# run branch case (short term archiving is off)
self.run_indv()
#
# (3b) Test run:
# do a restart continue from (3a) (short term archiving off)
#
logger.info("branch restart: doing a %s %s continue restart test" % (stop_n4, stop_option))
self._case.set_value("CONTINUE_RUN", True)
self._case.set_value("STOP_N", stop_n4)
self._case.set_value("REST_OPTION", "never")
self._case.set_value("DOUT_S", False)
self._case.set_value("HIST_OPTION", stop_option)
self._case.set_value("HIST_N", hist_n)
self._case.flush()
# do the restart run (short term archiving is off)
self.run_indv(suffix="rest")
self._component_compare_test("base", "hybrid")
self._component_compare_test("base", "rest")
def case_build(caseroot, case, sharedlib_only=False, model_only=False):
###############################################################################
t1 = time.time()
expect(not (sharedlib_only and model_only),
"Contradiction: both sharedlib_only and model_only")
logger.info("sharedlib_only is %s" % sharedlib_only)
logger.info("model_only is %s" % model_only)
expect(os.path.isdir(caseroot), "'%s' is not a valid directory" % caseroot)
os.chdir(caseroot)
expect(os.path.exists("case.run"),
"ERROR: must invoke case.setup script before calling build script ")
cimeroot = case.get_value("CIMEROOT")
comp_classes = case.get_values("COMP_CLASSES")
if not sharedlib_only:
check_all_input_data(case)
run_cmd_no_fail("./Tools/check_lockedfiles --caseroot %s" % caseroot)
# Retrieve relevant case data
# This environment variable gets set for cesm Make and
# needs to be unset before building again.
if "MODEL" in os.environ.keys():
del os.environ["MODEL"]
build_threaded = case.get_value("BUILD_THREADED")
casetools = case.get_value("CASETOOLS")
exeroot = case.get_value("EXEROOT")
incroot = case.get_value("INCROOT")
libroot = case.get_value("LIBROOT")
sharedlibroot = case.get_value("SHAREDLIBROOT")
complist = []
for comp_class in comp_classes:
if comp_class == "DRV":
comp_class = "CPL"
ninst = 1
config_dir = None
else:
ninst = case.get_value("NINST_%s"%comp_class)
config_dir = os.path.dirname(case.get_value("CONFIG_%s_FILE"%comp_class))
comp = case.get_value("COMP_%s"%comp_class)
thrds = case.get_value("NTHRDS_%s"%comp_class)
complist.append((comp_class.lower(), comp, thrds, ninst, config_dir ))
os.environ["COMP_%s"%comp_class] = comp
machines_file = case.get_value("MACHINES_SPEC_FILE")
ocn_submodel = case.get_value("OCN_SUBMODEL")
profile_papi_enable = case.get_value("PROFILE_PAPI_ENABLE")
compiler = case.get_value("COMPILER")
comp_interface = case.get_value("COMP_INTERFACE")
mpilib = case.get_value("MPILIB")
use_esmf_lib = case.get_value("USE_ESMF_LIB")
debug = case.get_value("DEBUG")
ninst_build = case.get_value("NINST_BUILD")
smp_value = case.get_value("SMP_VALUE")
clm_use_petsc = case.get_value("CLM_USE_PETSC")
cism_use_trilinos = case.get_value("CISM_USE_TRILINOS")
mpasli_use_albany = case.get_value("MPASLI_USE_ALBANY")
clm_config_opts = case.get_value("CLM_CONFIG_OPTS")
cam_config_opts = case.get_value("CAM_CONFIG_OPTS")
pio_config_opts = case.get_value("PIO_CONFIG_OPTS")
ninst_value = case.get_value("NINST_VALUE")
mach = case.get_value("MACH")
os_ = case.get_value("OS")
# Load some params into env
os.environ["CIMEROOT"] = cimeroot
os.environ["CASETOOLS"] = casetools
os.environ["EXEROOT"] = exeroot
os.environ["INCROOT"] = incroot
os.environ["LIBROOT"] = libroot
os.environ["SHAREDLIBROOT"] = sharedlibroot
os.environ["CASEROOT"] = caseroot
os.environ["COMPILER"] = compiler
os.environ["COMP_INTERFACE"] = comp_interface
os.environ["NINST_VALUE"] = str(ninst_value)
os.environ["BUILD_THREADED"] = stringify_bool(build_threaded)
os.environ["MACH"] = mach
os.environ["USE_ESMF_LIB"] = stringify_bool(use_esmf_lib)
os.environ["MPILIB"] = mpilib
os.environ["DEBUG"] = stringify_bool(debug)
os.environ["OS"] = os_
os.environ["CLM_CONFIG_OPTS"] = clm_config_opts if clm_config_opts is not None else ""
os.environ["CAM_CONFIG_OPTS"] = cam_config_opts if cam_config_opts is not None else ""
os.environ["PIO_CONFIG_OPTS"] = pio_config_opts if pio_config_opts is not None else ""
os.environ["OCN_SUBMODEL"] = ocn_submodel if ocn_submodel is not None else ""
os.environ["PROFILE_PAPI_ENABLE"] = stringify_bool(profile_papi_enable)
os.environ["CLM_USE_PETSC"] = stringify_bool(clm_use_petsc)
os.environ["CISM_USE_TRILINOS"] = stringify_bool(cism_use_trilinos)
os.environ["MPASLI_USE_ALBANY"] = stringify_bool(mpasli_use_albany)
# This is a timestamp for the build , not the same as the testid,
# and this case may not be a test anyway. For a production
# experiment there may be many builds of the same case.
lid = run_cmd_no_fail("date +%y%m%d-%H%M%S")
os.environ["LID"] = lid
# Set the overall USE_PETSC variable to TRUE if any of the
# *_USE_PETSC variables are TRUE.
# For now, there is just the one CLM_USE_PETSC variable, but in
# the future there may be others -- so USE_PETSC will be true if
# ANY of those are true.
use_petsc = clm_use_petsc
case.set_value("USE_PETSC", use_petsc)
os.environ["USE_PETSC"] = stringify_bool(use_petsc)
# Set the overall USE_TRILINOS variable to TRUE if any of the
# *_USE_TRILINOS variables are TRUE.
# For now, there is just the one CISM_USE_TRILINOS variable, but in
# the future there may be others -- so USE_TRILINOS will be true if
# ANY of those are true.
use_trilinos = False if cism_use_trilinos is None else cism_use_trilinos
case.set_value("USE_TRILINOS", use_trilinos)
os.environ["USE_TRILINOS"] = stringify_bool(use_trilinos)
# Set the overall USE_ALBANY variable to TRUE if any of the
# *_USE_ALBANY variables are TRUE.
# For now, there is just the one MPASLI_USE_ALBANY variable, but in
# the future there may be others -- so USE_ALBANY will be true if
# ANY of those are true.
use_albany = stringify_bool(mpasli_use_albany)
case.set_value("USE_ALBANY", use_albany)
os.environ["USE_ALBANY"] = use_albany
# Load modules
env_module = case.get_env("mach_specific")
env_module.load_env_for_case(compiler=case.get_value("COMPILER"),
debug=case.get_value("DEBUG"),
mpilib=case.get_value("MPILIB"))
# Need to flush case xml to disk before calling preview_namelists
case.flush()
if not sharedlib_only:
preview_namelists(case)
build_checks(case, build_threaded, comp_interface, use_esmf_lib, debug, compiler, mpilib,
sharedlibroot, complist, ninst_build, smp_value)
t2 = time.time()
logs = []
if not model_only:
logs = build_libraries(case, exeroot, caseroot, cimeroot, libroot, mpilib, lid,
machines_file)
if not sharedlib_only:
logs.extend(build_model(build_threaded, exeroot, clm_config_opts, incroot, complist,
lid, caseroot, cimeroot))
if not sharedlib_only:
post_build(case, logs)
t3 = time.time()
logger.info("Time spent not building: %f sec" % (t2 - t1))
logger.info("Time spent building: %f sec" % (t3 - t2))
return True
