def test_GIVEN_categories_have_land_cover_regions_WHEN_get_categories_THEN_category_has_regions_loaded(self):
model_run = self.model_run_service.get_model_being_created_with_non_default_parameter_values(self.user)
with session_scope() as session:
cat1 = LandCoverRegionCategory()
cat1.name = "Countries"
cat1.driving_dataset_id = model_run.driving_dataset_id
region1 = LandCoverRegion()
region1.mask_file = "filepath"
region1.name = "Wales"
region1.category = cat1
cat2 = LandCoverRegionCategory()
cat2.name = "Rivers"
cat2.driving_dataset_id = model_run.driving_dataset_id
region2 = LandCoverRegion()
region2.mask_file = "filepath2"
region2.name = "Thames"
region2.category = cat2
session.add_all([region1, region2])
categories = self.land_cover_service.get_land_cover_categories(model_run.driving_dataset_id)
assert_that(len(categories[0].regions), is_(1))
assert_that(categories[0].regions[0].name, is_("Wales"))
def _create_watch_regions(watch_driving_dataset, regions_csv_file):
categories = []
f = open(regions_csv_file, "r")
for line in f:
stripped_line = line.strip()
if not stripped_line.startswith('#') and len(stripped_line) > 0:
values = line.split(',')
if len(values) != 3:
log.error("Regions csv file has incorrect number of elements on line reading %s" % stripped_line)
exit(-1)
category_name = values[0].strip()
cat = None
for category in categories:
if category.name == category_name:
cat = category
if cat is None:
log.info(" adding category {}".format(category_name))
cat = LandCoverRegionCategory(name=category_name)
cat.driving_dataset = watch_driving_dataset
categories.append(cat)
region = LandCoverRegion()
region.name = values[1].strip()
region.mask_file = "data/WATCH_2D/masks/{}".format(values[2].strip())
region.category = cat
log.info(" adding region {} to {} with file {}".format(region.name, category_name, region.mask_file))
f.close()
def add_land_cover_region(self, model_run):
with session_scope() as session:
land_cover_cat = LandCoverRegionCategory()
land_cover_cat.name = "Countries"
land_cover_cat.driving_dataset_id = model_run.driving_dataset_id
land_cover_region = LandCoverRegion()
land_cover_region.mask_file = "filepath"
land_cover_region.name = "Wales"
land_cover_region.category = land_cover_cat
session.add(land_cover_region)
return land_cover_region
def _update_or_create_region(self, category, region, session):
"""
Update or create a land cover region
:param category: category for the region
:param region: a dictionry of region parameters
:param session: the session
:return: nothing
"""
existing_region_id = region.get("id")
if existing_region_id is not None and existing_region_id is not "":
region_in_db = self._get_land_cover_region_by_id_in_session(existing_region_id, session)
else:
region_in_db = LandCoverRegion()
region_in_db.category = category
region_in_db.name = region["name"]
region_in_db.mask_file = region["path"]
def test_GIVEN_data_set_with_a_region_WHEN_list_THEN_returns_mask(self):
with session_scope() as session:
category = LandCoverRegionCategory()
category.driving_dataset = self.driving_dataset
category.name = "mycategory"
region = LandCoverRegion()
region.name = "myregion"
region.category = category
region.mask_file = "data/file_path"
session.add(category)
self.login(access_level=constants.USER_ACCESS_LEVEL_ADMIN)
response = self.app.get(
url=url(controller='driving_data', action='edit', id=self.driving_dataset.id),
expect_errors=True
)
assert_that(response.normal_body, contains_string(category.name))
assert_that(response.normal_body, contains_string(region.name))
assert_that(response.normal_body, contains_string(region.mask_file))
def test_GIVEN_model_with_land_cover_actions_WHEN_convert_to_dictionary_THEN_land_cover_actions_present(self):
job_runner_client = JobRunnerClient(config)
def _alter_yearly_monthly_output_profiles(params):
return params
def _alter_driving_data_start(params):
return params
job_runner_client.alter_yearly_monthly_output_profiles = _alter_yearly_monthly_output_profiles
job_runner_client.alter_driving_data_start = _alter_driving_data_start
parameter = Parameter(name='file')
expected_parameter_value = "'base_frac_file.nc'"
parameter.parameter_values = [ParameterValue(value=expected_parameter_value)]
parameter2 = Parameter(name='frac_name')
expected_parameter_value2 = "'frac'"
parameter2.parameter_values = [ParameterValue(value=expected_parameter_value2)]
parameter3 = Parameter(name='latlon_region')
expected_parameter_value3 = ".true."
parameter3.parameter_values = [ParameterValue(value=expected_parameter_value3)]
namelist = Namelist(name='JULES_FRAC')
namelist_file = NamelistFile(filename='filename')
expected_index = 3
namelist.parameters = [parameter, parameter2]
namelist.namelist_file = namelist_file
namelist.index_in_file = expected_index
namelist2 = Namelist(name='JULES_MODEL_GRID')
namelist_file = NamelistFile(filename='filename')
expected_index = 3
namelist2.parameters = [parameter3]
namelist2.namelist_file = namelist_file
namelist2.index_in_file = expected_index
model_run = ModelRun()
model_run.id = 101
code_version = CodeVersion(name='Jules v3.4.1')
model_run.code_version = code_version
code_version.parameters = [parameter, parameter2, parameter3]
user = User()
user.id = 1
user.email = "email"
user.username = "******"
model_run.user = user
lcr1 = LandCoverRegion()
lcr1.mask_file = "region1.nc"
lca1 = LandCoverAction()
lca1.value_id = 9
lca1.order = 1
lca1.region = lcr1
lcr2 = LandCoverRegion()
lcr2.mask_file = "region2.nc"
lca2 = LandCoverAction()
lca2.value_id = 5
lca2.order = 2
lca2.region = lcr2
land_cover_actions = [lca1, lca2]
result = job_runner_client.convert_model_to_dictionary(model_run, code_version.parameters, land_cover_actions)
result_lc = result[constants.JSON_LAND_COVER]
assert_that(result_lc[constants.JSON_LAND_COVER_BASE_FILE], is_("base_frac_file.nc"))
assert_that(result_lc[constants.JSON_LAND_COVER_BASE_KEY], is_("frac"))
assert_that(result_lc[constants.JSON_LAND_COVER_ICE_INDEX], is_(9))
result_lc_actions = result_lc[constants.JSON_LAND_COVER_ACTIONS]
assert_that(len(result_lc_actions), is_(2))
action1 = result_lc_actions[0]
assert_that(action1[constants.JSON_LAND_COVER_MASK_FILE], is_("region1.nc"))
assert_that(action1[constants.JSON_LAND_COVER_ORDER], is_(1))
assert_that(action1[constants.JSON_LAND_COVER_VALUE], is_(9))
action2 = result_lc_actions[1]
assert_that(action2[constants.JSON_LAND_COVER_MASK_FILE], is_("region2.nc"))
assert_that(action2[constants.JSON_LAND_COVER_ORDER], is_(2))
assert_that(action2[constants.JSON_LAND_COVER_VALUE], is_(5))
namelist_file_result = result[constants.JSON_MODEL_NAMELIST_FILES][0]
parameters_result = namelist_file_result[constants.JSON_MODEL_NAMELISTS][0][constants.JSON_MODEL_PARAMETERS]
assert_that(parameters_result['file'], is_("'" + constants.USER_EDITED_FRACTIONAL_FILENAME + "'"))
assert_that(parameters_result['frac_name'], is_("'frac'"))
