def test_create_tag_name(self):
"""
Test create_tag when site_name is given.
"""
single_point = SinglePointCase(
plat=self.plat,
plon=self.plon,
site_name=self.site_name,
create_domain=self.create_domain,
create_surfdata=self.create_surfdata,
create_landuse=self.create_landuse,
create_datm=self.create_datm,
create_user_mods=self.create_user_mods,
dom_pft=self.dom_pft,
pct_pft=self.pct_pft,
num_pft=self.num_pft,
include_nonveg=self.include_nonveg,
uni_snow=self.uni_snow,
cap_saturation=self.cap_saturation,
out_dir=self.out_dir,
overwrite=self.overwrite,
)
single_point.site_name = "foo"
single_point.create_tag()
self.assertEqual(single_point.tag, "foo")
def test_check_dom_pft_too_big(self):
"""
Test check_dom_pft
When one of the given dom_pft(s) are bigger than 78
"""
single_point = SinglePointCase(
plat=self.plat,
plon=self.plon,
site_name=self.site_name,
create_domain=self.create_domain,
create_surfdata=self.create_surfdata,
create_landuse=self.create_landuse,
create_datm=self.create_datm,
create_user_mods=self.create_user_mods,
dom_pft=self.dom_pft,
pct_pft=self.pct_pft,
num_pft=self.num_pft,
include_nonveg=self.include_nonveg,
uni_snow=self.uni_snow,
cap_saturation=self.cap_saturation,
out_dir=self.out_dir,
overwrite=self.overwrite,
)
single_point.dom_pft = [16, 36, 79]
with self.assertRaisesRegex(argparse.ArgumentTypeError,
"values for --dompft should*"):
single_point.check_dom_pft()
def test_modify_surfdata_atpoint_crop_1pft_wetland(self):
"""
Test modify_surfdata_atpoint
Checks WETLAND for one pft
"""
single_point = SinglePointCase(
plat=self.plat,
plon=self.plon,
site_name=self.site_name,
create_domain=self.create_domain,
create_surfdata=self.create_surfdata,
create_landuse=self.create_landuse,
create_datm=self.create_datm,
create_user_mods=self.create_user_mods,
dom_pft=self.dom_pft,
pct_pft=self.pct_pft,
num_pft=self.num_pft,
include_nonveg=self.include_nonveg,
uni_snow=self.uni_snow,
cap_saturation=self.cap_saturation,
out_dir=self.out_dir,
overwrite=self.overwrite,
)
single_point.dom_pft = [17]
ds_out = single_point.modify_surfdata_atpoint(self.ds_test)
self.assertEqual(ds_out["PCT_WETLAND"].data[:, :], 0)
def test_modify_surfdata_atpoint_crop_1pft_unisnow(self):
"""
Test modify_surfdata_atpoint for crop cases
Checks STD_ELV for one pft and unisnow
"""
single_point = SinglePointCase(
plat=self.plat,
plon=self.plon,
site_name=self.site_name,
create_domain=self.create_domain,
create_surfdata=self.create_surfdata,
create_landuse=self.create_landuse,
create_datm=self.create_datm,
create_user_mods=self.create_user_mods,
dom_pft=self.dom_pft,
pct_pft=self.pct_pft,
num_pft=self.num_pft,
include_nonveg=self.include_nonveg,
uni_snow=self.uni_snow,
cap_saturation=self.cap_saturation,
out_dir=self.out_dir,
overwrite=self.overwrite,
)
single_point.dom_pft = [17]
single_point.uni_snow = True
ds_out = single_point.modify_surfdata_atpoint(self.ds_test)
self.assertEqual(ds_out["STD_ELEV"].data[:, :], 20)
def test_modify_surfdata_atpoint_crop_1pft_pctnatpft(self):
"""
Test modify_surfdata_atpoint
Checks PCT_NAT_PFT for one pft
"""
single_point = SinglePointCase(
plat=self.plat,
plon=self.plon,
site_name=self.site_name,
create_domain=self.create_domain,
create_surfdata=self.create_surfdata,
create_landuse=self.create_landuse,
create_datm=self.create_datm,
create_user_mods=self.create_user_mods,
dom_pft=self.dom_pft,
pct_pft=self.pct_pft,
num_pft=self.num_pft,
include_nonveg=self.include_nonveg,
uni_snow=self.uni_snow,
cap_saturation=self.cap_saturation,
out_dir=self.out_dir,
overwrite=self.overwrite,
)
single_point.dom_pft = [19]
ds_out = single_point.modify_surfdata_atpoint(self.ds_test)
expected_out = np.zeros((1, 1, 64))
expected_out[:, :, 4] = 100
# self.assertEqual(ds_out['PCT_NAT_PFT'].data[:,:,5], 100)
np.testing.assert_array_equal(ds_out["PCT_CFT"].data, expected_out)
def test_modify_surfdata_atpoint_nocrop_nopft_include_nonveg(self):
"""
Test modify_surfdata_atpoint
Checks PCT_CROP for no pft and include nonveg
"""
single_point = SinglePointCase(
plat=self.plat,
plon=self.plon,
site_name=self.site_name,
create_domain=self.create_domain,
create_surfdata=self.create_surfdata,
create_landuse=self.create_landuse,
create_datm=self.create_datm,
create_user_mods=self.create_user_mods,
dom_pft=self.dom_pft,
pct_pft=self.pct_pft,
num_pft=self.num_pft,
include_nonveg=self.include_nonveg,
uni_snow=self.uni_snow,
cap_saturation=self.cap_saturation,
out_dir=self.out_dir,
overwrite=self.overwrite,
)
single_point.dom_pft = None
single_point.include_nonveg = True
self.ds_test['PCT_CROP'].values = [[40]]
self.ds_test['PCT_LAKE'].values = [[10]]
self.ds_test['PCT_WETLAND'].values = [[10]]
self.ds_test['PCT_NATVEG'].values = [[40]]
ds_out = single_point.modify_surfdata_atpoint(self.ds_test)
self.assertEqual(ds_out["PCT_CROP"].data[:, :], 40)
def test_modify_surfdata_atpoint_crop_lake_include_nonveg(self):
"""
Test modify_surfdata_atpoint for crop cases
Checks PCT_LAKE for one pft to make sure it is not zerod-out
"""
single_point = SinglePointCase(
plat=self.plat,
plon=self.plon,
site_name=self.site_name,
create_domain=self.create_domain,
create_surfdata=self.create_surfdata,
create_landuse=self.create_landuse,
create_datm=self.create_datm,
create_user_mods=self.create_user_mods,
dom_pft=self.dom_pft,
pct_pft=self.pct_pft,
num_pft=self.num_pft,
include_nonveg=self.include_nonveg,
uni_snow=self.uni_snow,
cap_saturation=self.cap_saturation,
out_dir=self.out_dir,
overwrite=self.overwrite,
)
single_point.include_nonveg = True
single_point.dom_pft = [17]
ds_out = single_point.modify_surfdata_atpoint(self.ds_test)
self.assertNotEqual(ds_out["PCT_LAKE"].data[:, :], 0)
def test_modify_surfdata_atpoint_nocrop_urban_nononveg(self):
"""
Test modify_surfdata_atpoint for crop cases
Checks URBAN for one pft
"""
single_point = SinglePointCase(
plat=self.plat,
plon=self.plon,
site_name=self.site_name,
create_domain=self.create_domain,
create_surfdata=self.create_surfdata,
create_landuse=self.create_landuse,
create_datm=self.create_datm,
create_user_mods=self.create_user_mods,
dom_pft=self.dom_pft,
pct_pft=self.pct_pft,
num_pft=self.num_pft,
include_nonveg=self.include_nonveg,
uni_snow=self.uni_snow,
cap_saturation=self.cap_saturation,
out_dir=self.out_dir,
overwrite=self.overwrite,
)
single_point.include_nonveg = False
single_point.dom_pft = [7]
single_point.plat = [34.05]
single_point.plon = [118.25]
ds_out = single_point.modify_surfdata_atpoint(self.ds_test)
expected_out = np.zeros((1, 1, 3))
# self.assertEqual(ds_out['PCT_NAT_PFT'].data[:,:,5], 100)
np.testing.assert_array_equal(ds_out["PCT_URBAN"].data, expected_out)
def test_check_pct_pft_fraction_topct(self):
"""
Test check_pct_pft
Check if pct_pft is corretly converted to percent.
"""
single_point = SinglePointCase(
plat=self.plat,
plon=self.plon,
site_name=self.site_name,
create_domain=self.create_domain,
create_surfdata=self.create_surfdata,
create_landuse=self.create_landuse,
create_datm=self.create_datm,
create_user_mods=self.create_user_mods,
dom_pft=self.dom_pft,
pct_pft=self.pct_pft,
num_pft=self.num_pft,
include_nonveg=self.include_nonveg,
uni_snow=self.uni_snow,
cap_saturation=self.cap_saturation,
out_dir=self.out_dir,
overwrite=self.overwrite,
)
single_point.dom_pft = [1, 5, 8]
single_point.pct_pft = [0.5, 0.4, 0.1]
single_point.check_pct_pft()
self.assertEqual(single_point.pct_pft, [50, 40, 10])
def test_check_pct_pft_sum_not1(self):
"""
Test check_pct_pft
Check if pct_pft adds up to 1 or 100.
"""
single_point = SinglePointCase(
plat=self.plat,
plon=self.plon,
site_name=self.site_name,
create_domain=self.create_domain,
create_surfdata=self.create_surfdata,
create_landuse=self.create_landuse,
create_datm=self.create_datm,
create_user_mods=self.create_user_mods,
dom_pft=self.dom_pft,
pct_pft=self.pct_pft,
num_pft=self.num_pft,
include_nonveg=self.include_nonveg,
uni_snow=self.uni_snow,
cap_saturation=self.cap_saturation,
out_dir=self.out_dir,
overwrite=self.overwrite,
)
single_point.dom_pft = [1, 5]
single_point.pct_pft = [0.1, 0.5]
with self.assertRaisesRegex(
argparse.ArgumentTypeError,
"Sum of --pctpft values should be equal to 1*"):
single_point.check_pct_pft()
def test_check_pct_pft_notsamenumbers(self):
"""
Test check_pct_pft
Check if pct_pft is the same length as dom_pft
"""
single_point = SinglePointCase(
plat=self.plat,
plon=self.plon,
site_name=self.site_name,
create_domain=self.create_domain,
create_surfdata=self.create_surfdata,
create_landuse=self.create_landuse,
create_datm=self.create_datm,
create_user_mods=self.create_user_mods,
dom_pft=self.dom_pft,
pct_pft=self.pct_pft,
num_pft=self.num_pft,
include_nonveg=self.include_nonveg,
uni_snow=self.uni_snow,
cap_saturation=self.cap_saturation,
out_dir=self.out_dir,
overwrite=self.overwrite,
)
single_point.dom_pft = [1, 5]
single_point.pct_pft = [0.5]
with self.assertRaisesRegex(
argparse.ArgumentTypeError,
"Please provide the same number of inputs*"):
single_point.check_pct_pft()
def test_check_nonveg_nodompft(self):
"""
Test check_nonveg
If include_nonveg =False and no dompft it should complain.
"""
single_point = SinglePointCase(
plat=self.plat,
plon=self.plon,
site_name=self.site_name,
create_domain=self.create_domain,
create_surfdata=self.create_surfdata,
create_landuse=self.create_landuse,
create_datm=self.create_datm,
create_user_mods=self.create_user_mods,
dom_pft=self.dom_pft,
pct_pft=self.pct_pft,
num_pft=self.num_pft,
include_nonveg=self.include_nonveg,
uni_snow=self.uni_snow,
cap_saturation=self.cap_saturation,
out_dir=self.out_dir,
overwrite=self.overwrite,
)
single_point.dom_pft = None
single_point.include_nonveg = False
with self.assertRaisesRegex(
argparse.ArgumentTypeError,
"To include non-veg land units, you need to specify*",
):
single_point.check_nonveg()
def test_check_dom_pft_mixed_range(self):
"""
Test check_dom_pft
Test if all dom_pft(s) are in the same range of either 1-15 or 16-78
"""
single_point = SinglePointCase(
plat=self.plat,
plon=self.plon,
site_name=self.site_name,
create_domain=self.create_domain,
create_surfdata=self.create_surfdata,
create_landuse=self.create_landuse,
create_datm=self.create_datm,
create_user_mods=self.create_user_mods,
dom_pft=self.dom_pft,
pct_pft=self.pct_pft,
num_pft=self.num_pft,
include_nonveg=self.include_nonveg,
uni_snow=self.uni_snow,
cap_saturation=self.cap_saturation,
out_dir=self.out_dir,
overwrite=self.overwrite,
)
single_point.dom_pft = [1, 5, 15]
single_point.num_pft = 78
with self.assertRaisesRegex(argparse.ArgumentTypeError,
"mixed land units is not possible*"):
single_point.check_dom_pft()
def test_check_dom_pft_numpft(self):
"""
Test check_dom_pft
When dom_pft > 15 but no crop (aka num_pft =<15)
"""
single_point = SinglePointCase(
plat=self.plat,
plon=self.plon,
site_name=self.site_name,
create_domain=self.create_domain,
create_surfdata=self.create_surfdata,
create_landuse=self.create_landuse,
create_datm=self.create_datm,
create_user_mods=self.create_user_mods,
dom_pft=self.dom_pft,
pct_pft=self.pct_pft,
num_pft=self.num_pft,
include_nonveg=self.include_nonveg,
uni_snow=self.uni_snow,
cap_saturation=self.cap_saturation,
out_dir=self.out_dir,
overwrite=self.overwrite,
)
single_point.dom_pft = [15, 53]
single_point.num_pft = 16
with self.assertRaisesRegex(argparse.ArgumentTypeError,
"Please use --crop*"):
single_point.check_dom_pft()
def subset_point(args, file_dict: dict):
"""
Subsets surface, domain, land use, and/or DATM files at a single point
"""
logger.info(
"----------------------------------------------------------------------------"
)
logger.info(
"This script extracts a single point from the global CTSM datasets.")
num_pft = int(determine_num_pft(args.crop_flag))
# -- Create SinglePoint Object
single_point = SinglePointCase(
plat=args.plat,
plon=args.plon,
site_name=args.site_name,
create_domain=args.create_domain,
create_surfdata=args.create_surfdata,
create_landuse=args.create_landuse,
create_datm=args.create_datm,
create_user_mods=args.create_user_mods,
dom_pft=args.dom_pft,
pct_pft=args.pct_pft,
num_pft=num_pft,
include_nonveg=args.include_nonveg,
uni_snow=args.uni_snow,
cap_saturation=args.cap_saturation,
out_dir=args.out_dir,
overwrite=args.overwrite,
)
logger.debug(single_point)
# -- Create CTSM domain file
if single_point.create_domain:
single_point.create_domain_at_point(file_dict["main_dir"],
file_dict["fdomain_in"])
# -- Create CTSM surface data file
if single_point.create_surfdata:
single_point.create_surfdata_at_point(file_dict["fsurf_dir"],
file_dict["fsurf_in"],
args.user_mods_dir)
# -- Create CTSM transient landuse data file
if single_point.create_landuse:
single_point.create_landuse_at_point(file_dict["fluse_dir"],
file_dict["fluse_in"],
args.user_mods_dir)
# -- Create single point atmospheric forcing data
if single_point.create_datm:
# subset DATM domain file
single_point.create_datmdomain_at_point(file_dict["datm_tuple"])
# subset the DATM data
nl_datm = os.path.join(args.user_mods_dir, "user_nl_datm_streams")
single_point.create_datm_at_point(file_dict['datm_tuple'],
args.datm_syr, args.datm_eyr,
nl_datm)
# -- Write shell commands
if single_point.create_user_mods:
single_point.write_shell_commands(
os.path.join(args.user_mods_dir, "shell_commands"))
logger.info("Successfully ran script for single point.")
