def __init__(self, case):
###########################################################################
SystemTestsCompareTwo.__init__(self, case,
separate_builds=False,
run_two_suffix='da',
run_one_description='no data assimilation',
run_two_description='data assimilation')
def __init__(self, case):
self._comp_classes = []
SystemTestsCompareTwo.__init__(self, case,
separate_builds = True,
run_two_suffix = 'multiinst',
run_one_description = 'one instance',
run_two_description = 'two instances')
def run_phase(self):
###########################################################################
# Clean up any da.log files in case this is a re-run.
self._activate_case2()
case_root = self._get_caseroot2()
rundir2 = self._case.get_value("RUNDIR")
da_files = glob.glob(os.path.join(rundir2, 'da.log.*'))
for file_ in da_files:
os.remove(file_)
# End for
# CONTINUE_RUN ends up TRUE, set it back in case this is a re-run.
self._case.set_value("CONTINUE_RUN", False)
# Start normal run here
self._activate_case1()
SystemTestsCompareTwo.run_phase(self)
# Do some checks on the data assimilation 'output' from case2
self._activate_case2()
da_files = glob.glob(os.path.join(rundir2, 'da.log.*'))
if da_files is None:
logger = logging.getLogger(__name__)
logger.warning("No DA files in %s",
os.path.join(case_root, 'da.log.*'))
da_cycles = self._case.get_value("DATA_ASSIMILATION_CYCLES")
expect(
(da_files is not None) and (len(da_files) == da_cycles),
"ERROR: There were %d DA cycles in run but %d DA files were found"
% (da_cycles, len(da_files) if da_files is not None else 0))
da_files.sort()
cycle_num = 0
for fname in da_files:
found_caseroot = False
found_cycle = False
with open(fname) as dfile:
for line in dfile:
expect(line[0:5] != 'ERROR',
"ERROR, error line found in %s" % fname)
if line[0:8] == 'caseroot':
found_caseroot = True
elif line[0:5] == 'cycle':
found_cycle = True
expect(
int(line[7:]) == cycle_num,
"ERROR: Wrong cycle (%d) found in %s (expected %d)"
% (int(line[7:]), fname, cycle_num))
else:
expect(
False,
"ERROR: Unrecognized line ('%s') found in %s" %
(line, fname))
# End of for loop
expect(found_caseroot,
"ERROR: No caseroot found in %s" % fname)
expect(found_cycle, "ERROR: No cycle found in %s" % fname)
# End of with
cycle_num = cycle_num + 1
def __init__(self, case):
self._comp_classes = []
self._test_instances = 3
SystemTestsCompareTwo.__init__(self, case,
separate_builds = True,
run_two_suffix = 'single_instance',
run_two_description = 'single instance',
run_one_description = 'multi driver')
def __init__(self,
case1,
run_one_suffix = 'base',
run_two_suffix = 'test',
case2setup_raises_exception = False,
run_one_should_pass = True,
run_two_should_pass = True):
"""
Initialize a SystemTestsCompareTwoFake object
The core test phases prior to RUN_PHASE are set to TEST_PASS_STATUS;
RUN_PHASE is left unset (as is any later phase)
Args:
case1 (CaseFake): existing case
run_one_suffix (str, optional): Suffix used for first run. Defaults
to 'base'. Currently MUST be 'base'.
run_two_suffix (str, optional): Suffix used for the second run. Defaults to 'test'.
case2setup_raises_exception (bool, optional): If True, then the call
to _case_two_setup will raise an exception. Default is False.
run_one_should_pass (bool, optional): Whether the run_indv method should
pass for the first run. Default is True, meaning it will pass.
run_two_should_pass (bool, optional): Whether the run_indv method should
pass for the second run. Default is True, meaning it will pass.
"""
self._case2setup_raises_exception = case2setup_raises_exception
# NOTE(wjs, 2016-08-03) Currently, due to limitations in the test
# infrastructure, run_one_suffix MUST be 'base'. However, I'm keeping it
# as an explicit argument to the constructor so that it's easy to relax
# this requirement later: To relax this assumption, remove the following
# assertion and add run_one_suffix as an argument to
# SystemTestsCompareTwo.__init__
assert(run_one_suffix == 'base')
SystemTestsCompareTwo.__init__(
self,
case1,
separate_builds = False,
run_two_suffix = run_two_suffix)
# Need to tell test status that all phases prior to the run phase have
# passed, since this is checked in the run call (at least for the build
# phase status)
with self._test_status:
for phase in test_status.CORE_PHASES:
if phase == test_status.RUN_PHASE:
break
self._test_status.set_status(phase, test_status.TEST_PASS_STATUS)
self.run_pass_casenames = []
if run_one_should_pass:
self.run_pass_casenames.append(self._case1.get_value('CASE'))
if run_two_should_pass:
self.run_pass_casenames.append(self._case2.get_value('CASE'))
self.log = []
def __init__(self,
case1,
run_one_suffix='base',
run_two_suffix='test',
case2setup_raises_exception=False,
run_one_should_pass=True,
run_two_should_pass=True):
"""
Initialize a SystemTestsCompareTwoFake object
The core test phases prior to RUN_PHASE are set to TEST_PASS_STATUS;
RUN_PHASE is left unset (as is any later phase)
Args:
case1 (CaseFake): existing case
run_one_suffix (str, optional): Suffix used for first run. Defaults
to 'base'. Currently MUST be 'base'.
run_two_suffix (str, optional): Suffix used for the second run. Defaults to 'test'.
case2setup_raises_exception (bool, optional): If True, then the call
to _case_two_setup will raise an exception. Default is False.
run_one_should_pass (bool, optional): Whether the run_indv method should
pass for the first run. Default is True, meaning it will pass.
run_two_should_pass (bool, optional): Whether the run_indv method should
pass for the second run. Default is True, meaning it will pass.
"""
self._case2setup_raises_exception = case2setup_raises_exception
# NOTE(wjs, 2016-08-03) Currently, due to limitations in the test
# infrastructure, run_one_suffix MUST be 'base'. However, I'm keeping it
# as an explicit argument to the constructor so that it's easy to relax
# this requirement later: To relax this assumption, remove the following
# assertion and add run_one_suffix as an argument to
# SystemTestsCompareTwo.__init__
assert (run_one_suffix == 'base')
SystemTestsCompareTwo.__init__(self,
case1,
separate_builds=False,
run_two_suffix=run_two_suffix)
# Need to tell test status that all phases prior to the run phase have
# passed, since this is checked in the run call (at least for the build
# phase status)
with self._test_status:
for phase in test_status.CORE_PHASES:
if phase == test_status.RUN_PHASE:
break
self._test_status.set_status(phase,
test_status.TEST_PASS_STATUS)
self.run_pass_casenames = []
if run_one_should_pass:
self.run_pass_casenames.append(self._case1.get_value('CASE'))
if run_two_should_pass:
self.run_pass_casenames.append(self._case2.get_value('CASE'))
self.log = []
def run_phase(self): # pylint: disable=arguments-differ
###########################################################################
self._activate_case2()
should_match = (self._case.get_value("DESP_MODE") == "NOCHANGE")
SystemTestsCompareTwo.run_phase(self, success_change=not should_match)
# Look for expected coupler restart files
logger = logging.getLogger(__name__)
self._activate_case1()
rundir1 = self._case.get_value("RUNDIR")
self._activate_case2()
rundir2 = self._case.get_value("RUNDIR")
compare_ok = True
multi_driver = self._case.get_value("MULTI_DRIVER")
comps = self._case.get_values("COMP_CLASSES")
for comp in comps:
if not self._case.get_value("PAUSE_ACTIVE_{}".format(comp)):
continue
if comp == "CPL":
if multi_driver:
ninst = self._case.get_value("NINST_MAX")
else:
ninst = 1
else:
ninst = self._case.get_value("NINST_{}".format(comp))
comp_name = self._case.get_value('COMP_{}'.format(comp))
for index in range(1, ninst + 1):
if ninst == 1:
rname = '*.{}.r.*'.format(comp_name)
else:
rname = '*.{}_{:04d}.r.*'.format(comp_name, index)
restart_files_1 = glob.glob(os.path.join(rundir1, rname))
expect((len(restart_files_1) > 0),
"No case1 restart files for {}".format(comp))
restart_files_2 = glob.glob(os.path.join(rundir2, rname))
expect((len(restart_files_2) > len(restart_files_1)),
"No pause (restart) files found in case2 for {}".format(
comp))
# Do cprnc of restart files.
rfile1 = restart_files_1[len(restart_files_1) - 1]
# rfile2 has to match rfile1 (same time string)
parts = os.path.basename(rfile1).split(".")
glob_str = "*.{}".format(".".join(parts[len(parts) - 4:]))
restart_files_2 = glob.glob(os.path.join(rundir2, glob_str))
expect((len(restart_files_2) == 1),
"Missing case2 restart file, {}", glob_str)
rfile2 = restart_files_2[0]
ok = cprnc(comp, rfile1, rfile2, self._case, rundir2)[0]
logger.warning("CPRNC result for {}: {}".format(
os.path.basename(rfile1), "PASS" if
(ok == should_match) else "FAIL"))
compare_ok = compare_ok and (should_match == ok)
expect(
compare_ok, "Not all restart files {}".format(
"matched" if should_match else "failed to match"))
def __init__(self,
case1,
run_two_suffix = 'test'):
SystemTestsCompareTwo.__init__(
self,
case1,
separate_builds = False,
run_two_suffix = run_two_suffix)
def __init__(self, case):
"""
initialize an NCR test
"""
SystemTestsCompareTwo.__init__(self, case,
separate_builds = True,
run_two_suffix = "singleinst",
run_one_description = "two instances, each with the same number of tasks",
run_two_description = "default build")
def run_phase(self): # pylint: disable=arguments-differ
###########################################################################
self._activate_case2()
should_match = (self._case.get_value("DESP_MODE") == "NOCHANGE")
SystemTestsCompareTwo.run_phase(self, success_change=not should_match)
# Look for expected coupler restart files
logger = logging.getLogger(__name__)
self._activate_case1()
rundir1 = self._case.get_value("RUNDIR")
self._activate_case2()
rundir2 = self._case.get_value("RUNDIR")
compare_ok = True
pause_comps = self._case.get_value("PAUSE_COMPONENT_LIST")
expect((pause_comps != 'none'), "Pause/Resume (PRE) test has no pause components")
if pause_comps == 'all':
pause_comps = self._case.get_values("COMP_CLASSES")
else:
pause_comps = pause_comps.split(':')
multi_driver = self._case.get_value("MULTI_DRIVER")
for comp in pause_comps:
if comp == "cpl":
if multi_driver:
ninst = self._case.get_value("NINST_MAX")
else:
ninst = 1
else:
ninst = self._case.get_value("NINST_{}".format(comp.upper()))
comp_name = self._case.get_value('COMP_{}'.format(comp.upper()))
for index in range(1,ninst+1):
if ninst == 1:
rname = '*.{}.r.*'.format(comp_name)
else:
rname = '*.{}_{:04d}.r.*'.format(comp_name, index)
restart_files_1 = glob.glob(os.path.join(rundir1, rname))
expect((len(restart_files_1) > 0), "No case1 restart files for {}".format(comp))
restart_files_2 = glob.glob(os.path.join(rundir2, rname))
expect((len(restart_files_2) > len(restart_files_1)),
"No pause (restart) files found in case2 for {}".format(comp))
# Do cprnc of restart files.
rfile1 = restart_files_1[len(restart_files_1) - 1]
# rfile2 has to match rfile1 (same time string)
parts = os.path.basename(rfile1).split(".")
glob_str = "*.{}".format(".".join(parts[len(parts)-4:]))
restart_files_2 = glob.glob(os.path.join(rundir2, glob_str))
expect((len(restart_files_2) == 1),
"Missing case2 restart file, {}", glob_str)
rfile2 = restart_files_2[0]
ok = cprnc(comp, rfile1, rfile2, self._case, rundir2)[0]
logger.warning("CPRNC result for {}: {}".format(os.path.basename(rfile1), "PASS" if (ok == should_match) else "FAIL"))
compare_ok = compare_ok and (should_match == ok)
expect(compare_ok,
"Not all restart files {}".format("matched" if should_match else "failed to match"))
def __init__(self, case):
"""
initialize a test object
"""
SystemTestsCompareTwo.__init__(self, case,
separate_builds = False,
run_two_suffix = 'single_thread',
run_one_description = 'default threading',
run_two_description = 'threads set to 1')
def __init__(self, case):
###########################################################################
SystemTestsCompareTwo.__init__(self, case,
separate_builds=False,
run_two_suffix='pr',
run_one_description='no pause/resume',
run_two_description='pause/resume')
self._stopopt = ''
self._stopn = 0
def __init__(self, case):
"""
initialize an object interface to file env_test.xml in the case directory
"""
SystemTestsCompareTwo.__init__(self,
case,
separate_builds=True,
run_two_suffix="seq",
run_one_description = "base",
run_two_description = "sequence")
def run_phase(self): # pylint: disable=arguments-differ
###########################################################################
# Clean up any da.log files in case this is a re-run.
self._activate_case2()
case_root = self._get_caseroot2()
rundir2 = self._case.get_value("RUNDIR")
da_files = glob.glob(os.path.join(rundir2, 'da.log.*'))
for file_ in da_files:
os.remove(file_)
# End for
# CONTINUE_RUN ends up TRUE, set it back in case this is a re-run.
self._case.set_value("CONTINUE_RUN", False)
# Start normal run here
self._activate_case1()
SystemTestsCompareTwo.run_phase(self)
# Do some checks on the data assimilation 'output' from case2
self._activate_case2()
da_files = glob.glob(os.path.join(rundir2, 'da.log.*'))
if da_files is None:
logger = logging.getLogger(__name__)
path = os.path.join(case_root, 'da.log.*')
logger.warning("No DA files in {}".format(path))
da_cycles = self._case.get_value("DATA_ASSIMILATION_CYCLES")
expect((da_files is not None) and (len(da_files) == da_cycles),
"ERROR: There were {:d} DA cycles in run but {:d} DA files were found".format(da_cycles, len(da_files) if da_files is not None else 0))
da_files.sort()
cycle_num = 0
for fname in da_files:
found_caseroot = False
found_cycle = False
with open(fname) as dfile:
for line in dfile:
expect(line[0:5] != 'ERROR', "ERROR, error line found in {}".format(fname))
if line[0:8] == 'caseroot':
found_caseroot = True
elif line[0:5] == 'cycle':
found_cycle = True
expect(int(line[7:]) == cycle_num,
"ERROR: Wrong cycle ({:d}) found in {} (expected {:d})".format(int(line[7:]), fname, cycle_num))
else:
expect(False, "ERROR: Unrecognized line ('{}') found in {}".format(line, fname))
# End of for loop
expect(found_caseroot, "ERROR: No caseroot found in {}".format(fname))
expect(found_cycle, "ERROR: No cycle found in {}".format(fname))
# End of with
cycle_num = cycle_num + 1
def run_phase(self):
###########################################################################
SystemTestsCompareTwo.run_phase(self)
# Look for expected coupler restart files
logger = logging.getLogger(__name__)
self._activate_case1()
rundir1 = self._case.get_value("RUNDIR")
self._activate_case2()
rundir2 = self._case.get_value("RUNDIR")
should_match = (self._case.get_value("DESP_MODE") == "NOCHANGE")
compare_ok = True
pause_comps = self._case.get_value("PAUSE_COMPONENT_LIST")
expect((pause_comps != 'none'),
"Pause/Resume (PRE) test has no pause components")
if pause_comps == 'all':
pause_comps = self._case.get_values("COMP_CLASSES")
else:
pause_comps = pause_comps.split(':')
for comp in pause_comps:
comp_name = self._case.get_value('COMP_%s' % comp.upper())
rname = '*.%s.r.*' % comp_name
restart_files_1 = glob.glob(os.path.join(rundir1, rname))
expect((len(restart_files_1) > 0),
"No case1 restart files for %s" % comp)
restart_files_2 = glob.glob(os.path.join(rundir2, rname))
expect((len(restart_files_2) > len(restart_files_1)),
"No pause (restart) files found in case2 for %s" % comp)
# Do cprnc of restart files.
rfile1 = restart_files_1[len(restart_files_1) - 1]
# rfile2 has to match rfile1 (same time string)
parts = os.path.basename(rfile1).split(".")
glob_str = "*.%s" % ".".join(parts[len(parts) - 4:])
restart_files_2 = glob.glob(os.path.join(rundir2, glob_str))
expect((len(restart_files_2) == 1),
"Missing case2 restart file, %s", glob_str)
rfile2 = restart_files_2[0]
ok, out = cprnc(comp, rfile1, rfile2, self._case, rundir2) # pylint: disable=unused-variable
logger.warning("CPRNC result for %s: %s" %
(os.path.basename(rfile1), "PASS" if
(ok == should_match) else "FAIL"))
compare_ok = compare_ok and (should_match == ok)
expect(
compare_ok, "Not all restart files %s" %
("matched" if should_match else "failed to match"))
def run_phase(self):
###########################################################################
SystemTestsCompareTwo.run_phase(self)
# Do some checks on the data assimilation 'output' from case2
self._activate_case2()
case_root = self._get_caseroot2()
da_files = glob.glob(os.path.join(case_root, 'da.log.*'))
if da_files is None:
logger = logging.getLogger(__name__)
logger.warning("No DA files in %s", os.path.join(case_root, 'da.log.*'))
da_cycles = self._case.get_value("DATA_ASSIMILATION_CYCLES")
expect((da_files is not None) and (len(da_files) == da_cycles),
"ERROR: There were %d DA cycles in run but %d DA files were found"%
(da_cycles, len(da_files) if da_files is not None else 0))
da_files.sort()
cycle_num = 0
for fname in da_files:
found_caseroot = False
found_cycle = False
found_total = False
with open(fname) as dfile:
for line in dfile:
expect(line[0:5] != 'ERROR', "ERROR, error line found in %s"%fname)
if line[0:8] == 'caseroot':
found_caseroot = True
elif line[0:5] == 'cycle':
found_cycle = True
expect(int(line[7:]) == cycle_num,
"ERROR: Wrong cycle (%d) found in %s (expected %d)"%
(int(line[7:]), fname, cycle_num))
elif line[0:12] == 'total_cycles':
found_total = True
expect(int(line[14:]) == da_cycles,
"ERROR: Wrong total cycle count (%d) found in %s (expected %d)"%
(int(line[14:]), fname, da_cycles))
else:
expect(False, "ERROR: Unrecognized line ('%s') found in %s"%(line, fname))
# End of for loop
expect(found_caseroot, "ERROR: No caseroot found in %s"%fname)
expect(found_cycle, "ERROR: No cycle found in %s"%fname)
expect(found_total, "ERROR: No total_cycles found in %s"%fname)
# End of with
cycle_num = cycle_num + 1
def run_phase(self): # pylint: disable=arguments-differ
###########################################################################
# Clean up any da.log files in case this is a re-run.
self._activate_case2()
case_root = self._get_caseroot2()
rundir2 = self._case.get_value("RUNDIR")
da_files = glob.glob(os.path.join(rundir2, 'da.log.*'))
for file_ in da_files:
os.remove(file_)
# End for
# CONTINUE_RUN ends up TRUE, set it back in case this is a re-run.
self._case.set_value("CONTINUE_RUN", False)
# Start normal run here
self._activate_case1()
SystemTestsCompareTwo.run_phase(self)
# Do some checks on the data assimilation 'output' from case2
self._activate_case2()
da_files = glob.glob(os.path.join(rundir2, 'da.log.*'))
if da_files is None:
logger = logging.getLogger(__name__)
path = os.path.join(case_root, 'da.log.*')
logger.warning("No DA files in {}".format(path))
da_cycles = self._case.get_value("DATA_ASSIMILATION_CYCLES")
expect((da_files is not None) and (
len(da_files) == da_cycles
), "ERROR: There were {:d} DA cycles in run but {:d} DA files were found"
.format(da_cycles,
len(da_files) if da_files is not None else 0))
da_files.sort()
cycle_num = 0
for fname in da_files:
found_caseroot = False
found_cycle = False
with gzip.open(fname, "r") as dfile:
for bline in dfile:
line = bline.decode("utf-8")
expect(
not 'ERROR' in line,
"ERROR, error line {} found in {}".format(line, fname))
if 'caseroot' in line[0:8]:
found_caseroot = True
elif 'cycle' in line[0:5]:
found_cycle = True
expect(
int(line[7:]) == cycle_num,
"ERROR: Wrong cycle ({:d}) found in {} (expected {:d})"
.format(int(line[7:]), fname, cycle_num))
else:
expect(
False,
"ERROR: Unrecognized line ('{}') found in {}".
format(line, fname))
# End of for loop
expect(found_caseroot,
"ERROR: No caseroot found in {}".format(fname))
expect(found_cycle,
"ERROR: No cycle found in {}".format(fname))
# End of with
cycle_num = cycle_num + 1
def __init__(self, case):
"""
initialize a test object
"""
SystemTestsCompareTwo.__init__(self, case, True)
def __init__(self, case):
SystemTestsCompareTwo.__init__(self, case,
separate_builds = False,
run_two_suffix = 'interp',
run_one_description = 'use_init_interp set to false',
run_two_description = 'use_init_interp set to true')
def run_phase(self): # pylint: disable=arguments-differ
###########################################################################
# Clean up any da.log files in case this is a re-run.
self._activate_case2()
case_root = self._get_caseroot2()
rundir2 = self._case.get_value("RUNDIR")
da_files = glob.glob(os.path.join(rundir2, 'da.log.*'))
for file_ in da_files:
os.remove(file_)
# End for
# CONTINUE_RUN ends up TRUE, set it back in case this is a re-run.
self._case.set_value("CONTINUE_RUN", False)
# Start normal run here
self._activate_case1()
SystemTestsCompareTwo.run_phase(self)
# Do some checks on the data assimilation 'output' from case2
self._activate_case2()
da_files = glob.glob(os.path.join(rundir2, 'da.log.*'))
if da_files is None:
logger = logging.getLogger(__name__)
path = os.path.join(case_root, 'da.log.*')
logger.warning("No DA files in {}".format(path))
da_cycles = self._case.get_value("DATA_ASSIMILATION_CYCLES")
expect((da_files is not None) and (len(da_files) == da_cycles),
"ERROR: There were {:d} DA cycles in run but {:d} DA files were found".format(da_cycles, len(da_files) if da_files is not None else 0))
da_files.sort()
cycle_num = 0
compset = self._case.get_value("COMPSET")
is_dwav = '_DWAV' in compset
for fname in da_files:
found_caseroot = False
found_cycle = False
found_signal = 0
if is_dwav and (cycle_num > 0):
expected_signal = self._case.get_value("NINST_WAV")
else:
expected_signal = 0
with gzip.open(fname, "r") as dfile:
for bline in dfile:
line = bline.decode("utf-8")
expect(not 'ERROR' in line, "ERROR, error line {} found in {}".format(line, fname))
if 'caseroot' in line[0:8]:
found_caseroot = True
elif 'cycle' in line[0:5]:
found_cycle = True
expect(int(line[7:]) == cycle_num,
"ERROR: Wrong cycle ({:d}) found in {} (expected {:d})".format(int(line[7:]), fname, cycle_num))
elif 'resume signal' in line:
found_signal = found_signal + 1
expect('Post-DA resume signal found' in line[0:27],
"ERROR: bad post-DA message found in {}".format(fname))
else:
expect(False, "ERROR: Unrecognized line ('{}') found in {}".format(line, fname))
# End of for loop
expect(found_caseroot, "ERROR: No caseroot found in {}".format(fname))
expect(found_cycle, "ERROR: No cycle found in {}".format(fname))
expect(found_signal == expected_signal,
"ERROR: Expected {} post-DA resume signal message(s), {} found in {}".format(expected_signal, found_signal, fname))
# End of with
cycle_num = cycle_num + 1
def __init__(self, case):
SystemTestsCompareTwo.__init__(self, case,
separate_builds = False,
run_two_suffix = 'rep2')
def __init__(self, case):
SystemTestsCompareTwo.__init__(self, case,
separate_builds = True,
run_two_suffix = 'modpes',
run_one_description = 'default pe counts',
run_two_description = 'halved pe counts')
def __init__(self, case):
SystemTestsCompareTwo.__init__(self, case,
separate_builds = True,
run_two_suffix = 'mpi-serial',
run_one_description = 'default mpi library',
run_two_description = 'mpi-serial')
def run_phase(self): # pylint: disable=arguments-differ
###########################################################################
# Clean up any da.log files in case this is a re-run.
self._activate_case2()
case_root = self._get_caseroot2()
rundir2 = self._case.get_value("RUNDIR")
da_files = glob.glob(os.path.join(rundir2, 'da.log.*'))
for file_ in da_files:
os.remove(file_)
# End for
# CONTINUE_RUN ends up TRUE, set it back in case this is a re-run.
with self._case:
self._case.set_value("CONTINUE_RUN", False)
# Turn off post DA in case this is a re-run
for comp in self._case.get_values("COMP_CLASSES"):
if comp == "ESP":
continue
else:
self._case.set_value("DATA_ASSIMILATION_{}".format(comp), False)
# Start normal run here
self._activate_case1()
SystemTestsCompareTwo.run_phase(self)
# Do some checks on the data assimilation 'output' from case2
self._activate_case2()
da_files = glob.glob(os.path.join(rundir2, 'da.log.*'))
if da_files is None:
logger = logging.getLogger(__name__)
path = os.path.join(case_root, 'da.log.*')
logger.warning("No DA files in {}".format(path))
da_cycles = self._case.get_value("DATA_ASSIMILATION_CYCLES")
expect((da_files is not None) and (len(da_files) == da_cycles),
"ERROR: There were {:d} DA cycles in run but {:d} DA files were found".format(da_cycles, len(da_files) if da_files is not None else 0))
da_files.sort()
cycle_num = 0
compset = self._case.get_value("COMPSET")
# Special case for DWAV so we can make sure other variables are set
is_dwav = '_DWAV' in compset
for fname in da_files:
found_caseroot = False
found_cycle = False
found_signal = 0
found_init = 0
if is_dwav:
expected_init = self._case.get_value("NINST_WAV")
else:
# Expect a signal from every instance of every DA component
expected_init = 0
for comp in self._case.get_values("COMP_CLASSES"):
if comp == "ESP":
continue
elif self._case.get_value("DATA_ASSIMILATION_{}".format(comp)):
expected_init = expected_init + self._case.get_value("NINST_{}".format(comp))
# Adjust expected initial run and post-DA numbers
if cycle_num == 0:
expected_signal = 0
else:
expected_signal = expected_init
expected_init = 0
with gzip.open(fname, "r") as dfile:
for bline in dfile:
line = bline.decode("utf-8")
expect(not 'ERROR' in line, "ERROR, error line {} found in {}".format(line, fname))
if 'caseroot' in line[0:8]:
found_caseroot = True
elif 'cycle' in line[0:5]:
found_cycle = True
expect(int(line[7:]) == cycle_num,
"ERROR: Wrong cycle ({:d}) found in {} (expected {:d})".format(int(line[7:]), fname, cycle_num))
elif 'resume signal' in line:
found_signal = found_signal + 1
expect('Post-DA resume signal found' in line[0:27],
"ERROR: bad post-DA message found in {}".format(fname))
elif 'Initial run' in line:
found_init = found_init + 1
expect('Initial run signal found' in line[0:24],
"ERROR: bad Initial run message found in {}".format(fname))
else:
expect(False, "ERROR: Unrecognized line ('{}') found in {}".format(line, fname))
# End for
expect(found_caseroot, "ERROR: No caseroot found in {}".format(fname))
expect(found_cycle, "ERROR: No cycle found in {}".format(fname))
expect(found_signal == expected_signal,
"ERROR: Expected {} post-DA resume signal message(s), {} found in {}".format(expected_signal, found_signal, fname))
expect(found_init == expected_init,
"ERROR: Expected {} Initial run message(s), {} found in {}".format(expected_init, found_init, fname))
# End with
cycle_num = cycle_num + 1
def run_phase(self): # pylint: disable=arguments-differ
###########################################################################
# Clean up any da.log files in case this is a re-run.
self._activate_case2()
case_root = self._get_caseroot2()
rundir2 = self._case.get_value("RUNDIR")
da_files = glob.glob(os.path.join(rundir2, "da.log.*"))
for file_ in da_files:
os.remove(file_)
# End for
# CONTINUE_RUN ends up TRUE, set it back in case this is a re-run.
with self._case:
self._case.set_value("CONTINUE_RUN", False)
# Turn off post DA in case this is a re-run
for comp in self._case.get_values("COMP_CLASSES"):
if comp == "ESP":
continue
else:
self._case.set_value("DATA_ASSIMILATION_{}".format(comp),
False)
# Start normal run here
self._activate_case1()
SystemTestsCompareTwo.run_phase(self)
# Do some checks on the data assimilation 'output' from case2
self._activate_case2()
da_files = glob.glob(os.path.join(rundir2, "da.log.*"))
if da_files is None:
logger = logging.getLogger(__name__)
path = os.path.join(case_root, "da.log.*")
logger.warning("No DA files in {}".format(path))
da_cycles = self._case.get_value("DATA_ASSIMILATION_CYCLES")
expect(
(da_files is not None) and (len(da_files) == da_cycles),
"ERROR: There were {:d} DA cycles in run but {:d} DA files were found"
.format(da_cycles,
len(da_files) if da_files is not None else 0),
)
da_files.sort()
cycle_num = 0
compset = self._case.get_value("COMPSET")
# Special case for DWAV so we can make sure other variables are set
is_dwav = "_DWAV" in compset
for fname in da_files:
found_caseroot = False
found_cycle = False
found_signal = 0
found_init = 0
if is_dwav:
expected_init = self._case.get_value("NINST_WAV")
else:
# Expect a signal from every instance of every DA component
expected_init = 0
for comp in self._case.get_values("COMP_CLASSES"):
if comp == "ESP":
continue
elif self._case.get_value(
"DATA_ASSIMILATION_{}".format(comp)):
expected_init = expected_init + self._case.get_value(
"NINST_{}".format(comp))
# Adjust expected initial run and post-DA numbers
if cycle_num == 0:
expected_signal = 0
else:
expected_signal = expected_init
expected_init = 0
with gzip.open(fname, "r") as dfile:
for bline in dfile:
line = bline.decode("utf-8")
expect(
not "ERROR" in line,
"ERROR, error line {} found in {}".format(line, fname),
)
if "caseroot" in line[0:8]:
found_caseroot = True
elif "cycle" in line[0:5]:
found_cycle = True
expect(
int(line[7:]) == cycle_num,
"ERROR: Wrong cycle ({:d}) found in {} (expected {:d})"
.format(int(line[7:]), fname, cycle_num),
)
elif "resume signal" in line:
found_signal = found_signal + 1
expect(
"Post-DA resume signal found" in line[0:27],
"ERROR: bad post-DA message found in {}".format(
fname),
)
elif "Initial run" in line:
found_init = found_init + 1
expect(
"Initial run signal found" in line[0:24],
"ERROR: bad Initial run message found in {}".
format(fname),
)
else:
expect(
False,
"ERROR: Unrecognized line ('{}') found in {}".
format(line, fname),
)
# End for
expect(found_caseroot,
"ERROR: No caseroot found in {}".format(fname))
expect(found_cycle,
"ERROR: No cycle found in {}".format(fname))
expect(
found_signal == expected_signal,
"ERROR: Expected {} post-DA resume signal message(s), {} found in {}"
.format(expected_signal, found_signal, fname),
)
expect(
found_init == expected_init,
"ERROR: Expected {} Initial run message(s), {} found in {}"
.format(expected_init, found_init, fname),
)
# End with
cycle_num = cycle_num + 1
