def test_person_dataset(self):
households_data = {
"household_id":arange(4)+1,
"building_id": array([3,6,1,2], dtype=int32),
"persons": array([1,2,2,4], dtype=int32)
}
household_characteristics_for_ht_data = {
"characteristic": array(2*['persons']),
"min": array([1, 3]),
"max": array([2,-1])
}
person_data = {
"person_id": arange(9)+1,
"household_id": array([1,2,2,3,3,4,4,4,4]),
"job_id": array([30, 50, 0, 1, 23, 54, 78, 2, 6]),
}
annual_household_control_totals_data = {
"year": array(2*[2000]),
"persons": array([0,1]),
"total_number_of_households": array([0, 4])
}
storage = StorageFactory().get_storage('dict_storage')
storage.write_table(table_name='hh_set', table_data=households_data)
hh_set = HouseholdDataset(in_storage=storage, in_table_name='hh_set')
storage.write_table(table_name='prs_set', table_data=person_data)
prs_set = PersonDataset(in_storage=storage, in_table_name='prs_set')
storage.write_table(table_name='hct_set', table_data=annual_household_control_totals_data)
hct_set = ControlTotalDataset(in_storage=storage, in_table_name='hct_set', what="household", id_name=["year", "persons"])
storage.write_table(table_name='hc_set', table_data=household_characteristics_for_ht_data)
hc_set = HouseholdCharacteristicDataset(in_storage=storage, in_table_name='hc_set')
model = HouseholdTransitionModel(debuglevel=3)
model.run(year=2000, person_set=prs_set, household_set=hh_set, control_totals=hct_set, characteristics=hc_set)
# The run should remove the first three households and first 5 persons and add 3 copies of the last household, i.e. 12 persons
self.assertEqual(prs_set.size(), 16, "Error in size of the person_set. Should be 16, is %s." % prs_set.size())
self.assertEqual(ma.allequal(prs_set.get_attribute('household_id'), array([4,4,4,4,5,5,5,5,6,6,6,6,7,7,7,7])), True,
"Error in assigning household_id to new persons.")
def test_controlling_with_one_marginal_characteristic(self):
"""Using the age_of_head as a marginal characteristic, which would partition the 8 groups into two larger groups
(those with age_of_head < 40 and >= 40), ensure that the control totals are met and that the distribution within
each large group is the same before and after running the model
"""
#IMPORTANT: marginal characteristics grouping indices have to start at 0!
#i.e. below, there is one marg. char. "age_of_head". here we indicate that the first "large group" (groups 1-4),
#consisting of those groups with age_of_head < 40 should total 25000 households after running this model for one year,
#and the second large group, those groups with age_of_head > 40, should total 15000 households
annual_household_control_totals_data = {
"year": array([2000, 2000]),
"age_of_head": array([0,1]),
"total_number_of_households": array([25000, 15000])
}
storage = StorageFactory().get_storage('dict_storage')
storage.write_table(table_name='hh_set', table_data=self.households_data)
hh_set = HouseholdDataset(in_storage=storage, in_table_name='hh_set')
storage.write_table(table_name='hct_set', table_data=annual_household_control_totals_data)
hct_set = ControlTotalDataset(in_storage=storage, in_table_name='hct_set', what='household', id_name=['year' ,'age_of_head'])
storage.write_table(table_name='hc_set', table_data=self.household_characteristics_for_ht_data)
hc_set = HouseholdCharacteristicDataset(in_storage=storage, in_table_name='hc_set')
storage.write_table(table_name='prs_set', table_data=self.person_data)
prs_set = PersonDataset(in_storage=storage, in_table_name='prs_set')
model = HouseholdTransitionModel()
model.run(year=2000, person_set=prs_set, household_set=hh_set, control_totals=hct_set, characteristics=hc_set)
#check that there are indeed 40000 total households after running the model
results = hh_set.size()
should_be = [40000]
self.assertEqual(ma.allclose(should_be, results, rtol=1e-1),
True, "Error, should_be: %s, but result: %s" % (should_be, results))
#check that the total number of households within first four groups increased by 10000
#and that the total number of households within last four groups decreased by 3000
results = self.get_count_all_groups(hh_set)
should_be = [25000, 15000]
self.assertEqual(ma.allclose([sum(results[0:4]), sum(results[4:8])], should_be, rtol=1e-1),
True, "Error, should_be: %s, but result: %s" % (should_be, results))
#check that the distribution of households within groups 1-4 and 5-8 are the same before and after
#running the model, respectively
should_be = [6000.0/15000.0*25000.0, 2000.0/15000.0*25000.0, 3000.0/15000.0*25000.0, 4000.0/15000.0*25000.0,
2000.0/18000.0*15000.0, 5000.0/18000.0*15000.0, 3000.0/18000.0*15000.0, 8000.0/18000.0*15000.0]
self.assertEqual(ma.allclose(results, should_be, rtol=0.05),
True, "Error, should_be: %s, but result: %s" % (should_be, results))
def test_controlling_with_three_marginal_characteristics(self):
"""Controlling with all three possible marginal characteristics in this example, age_of_head, income, and persons,
this would partition the 8 groups into the same 8 groups, and with a control total specified for each group, we must
ensure that the control totals for each group exactly meet the specifications.
"""
#IMPORTANT: marginal characteristics grouping indices have to start at 0!
annual_household_control_totals_data = {
"year": array(8*[2000]),
"age_of_head": array(4*[0] + 4*[1]),
"income": array(2*[0] + 2*[1] + 2*[0] + 2*[1]),
"persons": array([0,1,0,1,0,1,0,1]),
"total_number_of_households": array([4000, 5000, 1000, 3000, 0, 6000, 3000, 8000])
}
#size of columns was not even, removed last element of min and max
household_characteristics_for_ht_data = {
"characteristic": array(2*['age_of_head'] + 2*['income'] + 2*['persons']),
"min": array([0, 50, 0, 40000, 0, 3]),
"max": array([49, 100, 39999, -1, 2, -1])
}
storage = StorageFactory().get_storage('dict_storage')
storage.write_table(table_name='hh_set', table_data=self.households_data)
hh_set = HouseholdDataset(in_storage=storage, in_table_name='hh_set')
storage.write_table(table_name='hct_set', table_data=annual_household_control_totals_data)
hct_set = ControlTotalDataset(in_storage=storage, in_table_name='hct_set', what='household', id_name=['year' ,'age_of_head', 'income', 'persons'])
storage.write_table(table_name='hc_set', table_data=household_characteristics_for_ht_data)
hc_set = HouseholdCharacteristicDataset(in_storage=storage, in_table_name='hc_set')
# unplace some households
where10 = where(hh_set.get_attribute("building_id")<>10)[0]
hh_set.modify_attribute(name="building_id", data=zeros(where10.size), index=where10)
storage.write_table(table_name='prs_set', table_data=self.person_data)
prs_set = PersonDataset(in_storage=storage, in_table_name='prs_set')
model = HouseholdTransitionModel()
model.run(year=2000, person_set=prs_set, household_set=hh_set, control_totals=hct_set, characteristics=hc_set)
#check that there are indeed 33000 total households after running the model
results = hh_set.size()
should_be = [30000]
self.assertEqual(ma.allclose(should_be, results, rtol=1e-1),
True, "Error, should_be: %s, but result: %s" % (should_be, results))
#check that the number of households in each group exactly match the control totals specified
results = self.get_count_all_groups(hh_set)
should_be = [4000, 5000, 1000, 3000, 0, 6000, 3000, 8000]
self.assertEqual(ma.allclose(results, should_be),
True, "Error, should_be: %s, but result: %s" % (should_be, results))
def test_same_distribution_after_household_addition(self):
"""Using the control_totals and no marginal characteristics,
add households and ensure that the distribution within each group stays the same
"""
annual_household_control_totals_data = {
"year": array([2000]),
"total_number_of_households": array([50000])
}
storage = StorageFactory().get_storage('dict_storage')
storage.write_table(table_name='hh_set', table_data=self.households_data)
hh_set = HouseholdDataset(in_storage=storage, in_table_name='hh_set')
storage.write_table(table_name='prs_set', table_data=self.person_data)
prs_set = PersonDataset(in_storage=storage, in_table_name='prs_set')
storage.write_table(table_name='hct_set', table_data=annual_household_control_totals_data)
hct_set = ControlTotalDataset(in_storage=storage, in_table_name='hct_set', what="household", id_name="year")
storage.write_table(table_name='hc_set', table_data=self.household_characteristics_for_ht_data)
hc_set = HouseholdCharacteristicDataset(in_storage=storage, in_table_name='hc_set')
model = HouseholdTransitionModel()
model.run(year=2000, person_set=prs_set, household_set=hh_set, control_totals=hct_set, characteristics=hc_set)
#check that there are indeed 50000 total households after running the model
results = hh_set.size()
should_be = [50000]
self.assertEqual(ma.allclose(should_be, results, rtol=1e-1),
True, "Error, should_be: %s, but result: %s" % (should_be, results))
#check that the number of unplaced households is exactly the number of new households created
results = where(hh_set.get_attribute("building_id")<=0)[0].size
should_be = [17000]
self.assertEqual(ma.allclose(should_be, results, rtol=1e-1),
True, "Error, should_be: %s, but result: %s" % (should_be, results))
#check that the distribution of households in each group is the same as before running the model
results = self.get_count_all_groups(hh_set)
should_be = array([6000.0/33000.0*50000.0, 2000.0/33000.0*50000.0, 3000.0/33000.0*50000.0, 4000.0/33000.0*50000.0,
2000.0/33000.0*50000.0, 5000.0/33000.0*50000.0, 3000.0/33000.0*50000.0, 8000.0/33000.0*50000.0])
self.assertEqual(ma.allclose(results, should_be, rtol=0.05),
True, "Error, should_be: %s, but result: %s" % (should_be, results))
# check the types of the attributes
self.assertEqual(hh_set.get_attribute("age_of_head").dtype, int32,
"Error in data type of the new household set. Should be: int32, is: %s" % str(hh_set.get_attribute("age_of_head").dtype))
self.assertEqual(hh_set.get_attribute("income").dtype, int32,
"Error in data type of the new household set. Should be: int32, is: %s" % str(hh_set.get_attribute("income").dtype))
self.assertEqual(hh_set.get_attribute("persons").dtype, int8,
"Error in data type of the new household set. Should be: int8, is: %s" % str(hh_set.get_attribute("persons").dtype))
def get_agent_performance_into_cache(self, year):
""" Imports person/agent performances, like travel durations or distances,
from MATSim into UrbanSim cache (persons table)
"""
logger.log_status('Importing person/agent performances from MATSim ...')
person_data_set = PersonDataset( in_storage=self.in_storage, in_table_name=self.person_data_table )
existing_person_data_set = PersonDataset( in_storage=self.cache_storage, in_table_name=self.person_data_table )
existing_person_data_set.join(person_data_set, person_data_set.get_non_id_primary_attribute_names(), metadata=AttributeType.PRIMARY)
logger.log_status('Writing person data to cache ...')
flt_dir_for_next_year = os.path.join(self.cache_directory, str(year+1))
out_storage = StorageFactory().get_storage('flt_storage', storage_location = flt_dir_for_next_year)
existing_person_data_set.write_dataset(attributes=existing_person_data_set.get_known_attribute_names(),
out_storage=out_storage,
out_table_name=self.person_data_table)
logger.log_status('Finished importing person/agent performances to person dataset.')
def test_same_distribution_after_household_subtraction(self):
"""Using the control_totals and no marginal characteristics,
subtract households and ensure that the distribution within each group stays the same
"""
annual_household_control_totals_data = {
"year": array([2000]),
"total_number_of_households": array([20000])
}
storage = StorageFactory().get_storage('dict_storage')
storage.write_table(table_name='hh_set', table_data=self.households_data)
hh_set = HouseholdDataset(in_storage=storage, in_table_name='hh_set')
storage.write_table(table_name='hct_set', table_data=annual_household_control_totals_data)
hct_set = ControlTotalDataset(in_storage=storage, in_table_name='hct_set', what="household", id_name="year")
storage.write_table(table_name='hc_set', table_data=self.household_characteristics_for_ht_data)
hc_set = HouseholdCharacteristicDataset(in_storage=storage, in_table_name='hc_set')
storage.write_table(table_name='prs_set', table_data=self.person_data)
prs_set = PersonDataset(in_storage=storage, in_table_name='prs_set')
model = HouseholdTransitionModel()
model.run(year=2000, person_set=prs_set, household_set=hh_set, control_totals=hct_set, characteristics=hc_set)
#check that there are indeed 20000 total households after running the model
results = hh_set.size()
should_be = [20000]
self.assertEqual(ma.allclose(should_be, results, rtol=1e-1),
True, "Error, should_be: %s, but result: %s" % (should_be, results))
#check that the distribution of households in each group is the same as before running the model
results = self.get_count_all_groups(hh_set)
should_be = [6000.0/33000.0*20000.0, 2000.0/33000.0*20000.0, 3000.0/33000.0*20000.0, 4000.0/33000.0*20000.0,
2000.0/33000.0*20000.0, 5000.0/33000.0*20000.0, 3000.0/33000.0*20000.0, 8000.0/33000.0*20000.0]
self.assertEqual(ma.allclose(results, should_be, rtol=0.05),
True, "Error, should_be: %s,\n but result: %s" % (should_be, results))
def test_controlling_with_one_marginal_characteristic(self):
"""Using the age_of_head as a marginal characteristic, which would partition the 8 groups into two larger groups
(those with age_of_head < 40 and >= 40), ensure that the control totals are met and that the distribution within
each large group is the same before and after running the model
"""
#IMPORTANT: marginal characteristics grouping indices have to start at 0!
#i.e. below, there is one marg. char. "age_of_head". here we indicate that the first "large group" (groups 1-4),
#consisting of those groups with age_of_head < 40 should total 25000 households after running this model for one year,
#and the second large group, those groups with age_of_head > 40, should total 15000 households
annual_household_control_totals_data = {
"year": array([2000, 2000, 2000, 2000]),
"age_of_head": array([0, 1, 0, 1]),
"total_number_of_households": array([20000, 10000, 5000, 5000]),
"faz_id": array([1, 1, 2, 2])
}
storage = StorageFactory().get_storage('dict_storage')
storage.write_table(table_name='hh_set',
table_data=self.households_data)
hh_set = HouseholdDataset(in_storage=storage, in_table_name='hh_set')
storage.write_table(table_name='hct_set',
table_data=annual_household_control_totals_data)
hct_set = ControlTotalDataset(in_storage=storage,
in_table_name='hct_set',
what='household')
storage.write_table(table_name='prs_set', table_data=self.person_data)
prs_set = PersonDataset(in_storage=storage, in_table_name='prs_set')
storage.write_table(
table_name='hc_set',
table_data=self.household_characteristics_for_ht_data)
hc_set = HouseholdCharacteristicDataset(in_storage=storage,
in_table_name='hc_set')
model = SubareaHouseholdTransitionModel(subarea_id_name="faz_id")
model.run(year=2000,
person_set=prs_set,
household_set=hh_set,
control_totals=hct_set,
characteristics=hc_set)
#check that there are indeed 40000 total households after running the model
areas = hh_set.get_attribute("faz_id")
results = array([0, 0])
for iarea in [0, 1]:
results[iarea] = where(areas == [1, 2][iarea])[0].size
should_be = [30000, 10000]
self.assertEqual(
ma.allclose(should_be, results, rtol=1e-1), True,
"Error, should_be: %s, but result: %s" % (should_be, results))
#check that the number of households within the groups correspond to the control totals
results = self.get_count_all_groups(hh_set)
should_be = [20000, 10000, 5000, 5000]
idx1 = arange(0, 4)
idx2 = arange(4, 8)
idx3 = arange(8, 12)
idx4 = arange(12, 16)
self.assertEqual(
ma.allclose([
results[idx1].sum(), results[idx2].sum(), results[idx3].sum(),
results[idx4].sum()
],
should_be,
rtol=1e-1), True,
"Error, should_be: %s, but result: %s" %
(should_be,
array([
results[idx1].sum(), results[idx2].sum(), results[idx3].sum(),
results[idx4].sum()
])))
#check that the distribution of households within the groups are the same before and after
#running the model, respectively
should_be = [ # area 1
3000.0 / 7500.0 * 20000.0,
1000.0 / 7500.0 * 20000.0,
1500.0 / 7500.0 * 20000.0,
2000.0 / 7500.0 * 20000.0,
1000.0 / 9000.0 * 10000.0,
2500.0 / 9000.0 * 10000.0,
1500.0 / 9000.0 * 10000.0,
4000.0 / 9000.0 * 10000.0,
# area 2
3000.0 / 7500.0 * 5000.0,
1000.0 / 7500.0 * 5000.0,
1500.0 / 7500.0 * 5000.0,
2000.0 / 7500.0 * 5000.0,
1000.0 / 9000.0 * 5000.0,
2500.0 / 9000.0 * 5000.0,
1500.0 / 9000.0 * 5000.0,
4000.0 / 9000.0 * 5000.0
]
self.assertEqual(
ma.allclose(results, should_be, rtol=0.1), True,
"Error, should_be: %s, but result: %s" % (should_be, results))
def test_same_distribution_after_household_subtraction(self):
"""Using the control_totals and no marginal characteristics,
subtract households and ensure that the distribution within each group stays the same
"""
annual_household_control_totals_data = {
"year": array([2000, 2000]),
"total_number_of_households": array([8000, 12000]),
"faz_id": array([1, 2])
}
storage = StorageFactory().get_storage('dict_storage')
storage.write_table(table_name='hh_set',
table_data=self.households_data)
hh_set = HouseholdDataset(in_storage=storage, in_table_name='hh_set')
storage.write_table(table_name='hct_set',
table_data=annual_household_control_totals_data)
hct_set = ControlTotalDataset(in_storage=storage,
in_table_name='hct_set',
what="household")
storage.write_table(
table_name='hc_set',
table_data=self.household_characteristics_for_ht_data)
hc_set = HouseholdCharacteristicDataset(in_storage=storage,
in_table_name='hc_set')
storage.write_table(table_name='prs_set', table_data=self.person_data)
prs_set = PersonDataset(in_storage=storage, in_table_name='prs_set')
model = SubareaHouseholdTransitionModel(subarea_id_name="faz_id")
model.run(year=2000,
person_set=prs_set,
household_set=hh_set,
control_totals=hct_set,
characteristics=hc_set)
#check that there are indeed 8000 (area 1) and 12000 (area 2) total households after running the model
areas = hh_set.get_attribute("faz_id")
results = array([0, 0])
for iarea in [0, 1]:
results[iarea] = where(areas == [1, 2][iarea])[0].size
should_be = [8000, 12000]
self.assertEqual(
ma.allclose(should_be, results, rtol=1e-1), True,
"Error, should_be: %s, but result: %s" % (should_be, results))
#check that the distribution of households in each group is the same as before running the model
results = self.get_count_all_groups(hh_set)
should_be = array([ # area 1
3000.0 / 16500.0 * 8000.0,
1000.0 / 16500.0 * 8000.0,
1500.0 / 16500.0 * 8000.0,
2000.0 / 16500.0 * 8000.0,
1000.0 / 16500.0 * 8000.0,
2500.0 / 16500.0 * 8000.0,
1500.0 / 16500.0 * 8000.0,
4000.0 / 16500.0 * 8000.0,
# area 2
3000.0 / 16500.0 * 12000.0,
1000.0 / 16500.0 * 12000.0,
1500.0 / 16500.0 * 12000.0,
2000.0 / 16500.0 * 12000.0,
1000.0 / 16500.0 * 12000.0,
2500.0 / 16500.0 * 12000.0,
1500.0 / 16500.0 * 12000.0,
4000.0 / 16500.0 * 12000.0
])
self.assertEqual(
ma.allclose(results, should_be, rtol=0.1), True,
"Error, should_be: %s,\n but result: %s" % (should_be, results))
def test_controlling_age_of_head(self):
""" Controls for one marginal characteristics, namely age_of_head.
"""
annual_household_control_totals_data = {
"year": array([2000, 2000, 2000, 2001, 2001, 2001, 2002, 2002, 2002]),
"age_of_head": array([0,1,2,0,1,2, 0,1,2]),
"total_number_of_households": array([25013, 21513, 18227, # 2000
10055, 15003, 17999, # 2001
15678, 14001, 20432]) # 2002
}
household_characteristics_for_ht_data = {
"characteristic": array(3*['age_of_head']),
"min": array([0, 35, 65]),
"max": array([34, 64, -1])
}
households_data = {
"household_id":arange(15000)+1,
"building_id": array(15000*[1]),
"age_of_head": array(1000*[25] + 1000*[28] + 2000*[32] + 1000*[34] +
2000*[35] + 1000*[40] + 1000*[54]+ 1000*[62] +
1000*[65] + 1000*[68] + 2000*[71] + 1000*[98]),
"persons": array(1000*[2] + 2000*[3] + 1000*[1] + 1000*[6] + 1000*[1] + 1000*[4] +
3000*[1]+ 5000*[5], dtype=int8)
}
storage = StorageFactory().get_storage('dict_storage')
storage.write_table(table_name='hh_set', table_data=households_data)
hh_set = HouseholdDataset(in_storage=storage, in_table_name='hh_set')
storage.write_table(table_name='hct_set', table_data=annual_household_control_totals_data)
hct_set = ControlTotalDataset(in_storage=storage, in_table_name='hct_set', what='household',
id_name=['year' ,'age_of_head'])
storage.write_table(table_name='hc_set', table_data=household_characteristics_for_ht_data)
hc_set = HouseholdCharacteristicDataset(in_storage=storage, in_table_name='hc_set')
storage.write_table(table_name='prs_set', table_data=self.person_data)
prs_set = PersonDataset(in_storage=storage, in_table_name='prs_set')
model = HouseholdTransitionModel(debuglevel=3)
# this run should add households in all four categories
model.run(year=2000, person_set=prs_set, household_set=hh_set, control_totals=hct_set, characteristics=hc_set)
results = hh_set.size()
should_be = [(hct_set.get_attribute("total_number_of_households")[0:3]).sum()]
self.assertEqual(ma.allclose(should_be, results, rtol=1e-1),
True, "Error, should_be: %s, but result: %s" % (should_be, results))
results = zeros(hc_set.size(), dtype=int32)
results[0] = where(hh_set.get_attribute('age_of_head') <= hc_set.get_attribute("max")[0], 1,0).sum()
for i in range(1, hc_set.size()-1):
results[i] = logical_and(where(hh_set.get_attribute('age_of_head') >= hc_set.get_attribute("min")[i], 1,0),
where(hh_set.get_attribute('age_of_head') <= hc_set.get_attribute("max")[i], 1,0)).sum()
results[hc_set.size()-1] = where(hh_set.get_attribute('age_of_head') >= hc_set.get_attribute("min")[hc_set.size()-1], 1,0).sum()
should_be = hct_set.get_attribute("total_number_of_households")[0:3]
self.assertEqual(ma.allclose(results, should_be, rtol=1e-6),
True, "Error, should_be: %s, but result: %s" % (should_be, results))
# this run should remove households in all four categories
model.run(year=2001, person_set=prs_set, household_set=hh_set, control_totals=hct_set, characteristics=hc_set)
results = hh_set.size()
should_be = [(hct_set.get_attribute("total_number_of_households")[3:6]).sum()]
self.assertEqual(ma.allclose(should_be, results, rtol=1e-1),
True, "Error, should_be: %s, but result: %s" % (should_be, results))
results = zeros(hc_set.size(), dtype=int32)
results[0] = where(hh_set.get_attribute('age_of_head') <= hc_set.get_attribute("max")[0], 1,0).sum()
for i in range(1, hc_set.size()-1):
results[i] = logical_and(where(hh_set.get_attribute('age_of_head') >= hc_set.get_attribute("min")[i], 1,0),
where(hh_set.get_attribute('age_of_head') <= hc_set.get_attribute("max")[i], 1,0)).sum()
results[hc_set.size()-1] = where(hh_set.get_attribute('age_of_head') >= hc_set.get_attribute("min")[hc_set.size()-1], 1,0).sum()
should_be = hct_set.get_attribute("total_number_of_households")[3:6]
self.assertEqual(ma.allclose(results, should_be, rtol=1e-6),
True, "Error, should_be: %s, but result: %s" % (should_be, results))
# this run should add and remove households
model.run(year=2002, person_set=prs_set, household_set=hh_set, control_totals=hct_set, characteristics=hc_set)
results = hh_set.size()
should_be = [(hct_set.get_attribute("total_number_of_households")[6:9]).sum()]
self.assertEqual(ma.allclose(should_be, results, rtol=1e-1),
True, "Error, should_be: %s, but result: %s" % (should_be, results))
results = zeros(hc_set.size(), dtype=int32)
results[0] = where(hh_set.get_attribute('age_of_head') <= hc_set.get_attribute("max")[0], 1,0).sum()
for i in range(1, hc_set.size()-1):
results[i] = logical_and(where(hh_set.get_attribute('age_of_head') >= hc_set.get_attribute("min")[i], 1,0),
where(hh_set.get_attribute('age_of_head') <= hc_set.get_attribute("max")[i], 1,0)).sum()
results[hc_set.size()-1] = where(hh_set.get_attribute('age_of_head') >= hc_set.get_attribute("min")[hc_set.size()-1], 1,0).sum()
should_be = hct_set.get_attribute("total_number_of_households")[6:9]
self.assertEqual(ma.allclose(results, should_be, rtol=1e-6),
True, "Error, should_be: %s, but result: %s" % (should_be, results))
def test_controlling_income(self):
""" Controls for one marginal characteristics, namely income.
"""
annual_household_control_totals_data = {
"year": array([2000, 2000, 2000, 2000, 2001, 2001, 2001, 2001, 2002, 2002, 2002, 2002]),
"income": array([0,1,2,3,0,1,2,3, 0,1,2,3]),
"total_number_of_households": array([25013, 21513, 18227, 18493, # 2000
10055, 15003, 17999, 17654, # 2001
15678, 14001, 20432, 14500]) # 2002
}
household_characteristics_for_ht_data = {
"characteristic": array(4*['income']),
"min": array([0, 40000, 120000, 70000]), # category 120000 has index 3 and category 70000 has index 2
"max": array([39999, 69999, -1, 119999]) # (testing row invariance)
}
hc_sorted_index = array([0,1,3,2])
households_data = {
"household_id":arange(20000)+1,
"building_id": array(19950*[1] + 50*[0]),
"income": array(1000*[1000] + 1000*[10000] + 2000*[20000] + 1000*[35000] + 2000*[45000] +
1000*[50000] + 2000*[67000]+ 2000*[90000] + 1000*[100005] + 2000*[110003] +
1000*[120000] + 1000*[200000] + 2000*[500000] + 1000*[630000]),
"persons": array(3000*[2] + 2000*[3] + 1000*[1] + 1000*[6] + 1000*[1] + 1000*[4] +
3000*[1]+ 8000*[5], dtype=int8)
}
storage = StorageFactory().get_storage('dict_storage')
storage.write_table(table_name='hh_set', table_data=households_data)
hh_set = HouseholdDataset(in_storage=storage, in_table_name='hh_set')
storage.write_table(table_name='hct_set', table_data=annual_household_control_totals_data)
hct_set = ControlTotalDataset(in_storage=storage, in_table_name='hct_set', what='household', id_name=['year' ,'income'])
storage.write_table(table_name='hc_set', table_data=household_characteristics_for_ht_data)
hc_set = HouseholdCharacteristicDataset(in_storage=storage, in_table_name='hc_set')
storage.write_table(table_name='prs_set', table_data=self.person_data)
prs_set = PersonDataset(in_storage=storage, in_table_name='prs_set')
model = HouseholdTransitionModel(debuglevel=3)
# this run should add households in all four categories
model.run(year=2000, person_set=prs_set, household_set=hh_set, control_totals=hct_set, characteristics=hc_set)
results = hh_set.size()
should_be = [83246]
self.assertEqual(ma.allclose(should_be, results, rtol=1e-1),
True, "Error, should_be: %s, but result: %s" % (should_be, results))
results = zeros(hc_set.size(), dtype=int32)
results[0] = where(hh_set.get_attribute('income') <=
hc_set.get_attribute("max")[hc_sorted_index[0]], 1,0).sum()
for i in range(1, hc_set.size()-1):
results[i] = logical_and(where(hh_set.get_attribute('income') >=
hc_set.get_attribute("min")[hc_sorted_index[i]], 1,0),
where(hh_set.get_attribute('income') <=
hc_set.get_attribute("max")[hc_sorted_index[i]], 1,0)).sum()
results[-1] = where(hh_set.get_attribute('income') >= hc_set.get_attribute("min")[hc_sorted_index[-1]], 1,0).sum()
should_be = hct_set.get_attribute("total_number_of_households")[0:4]
self.assertEqual(ma.allclose(results, should_be, rtol=1e-6),
True, "Error, should_be: %s, but result: %s" % (should_be, results))
# this run should remove households in all four categories
model.run(year=2001, person_set=prs_set, household_set=hh_set, control_totals=hct_set, characteristics=hc_set)
results = hh_set.size()
should_be = [(hct_set.get_attribute("total_number_of_households")[4:8]).sum()]
self.assertEqual(ma.allclose(should_be, results, rtol=1e-1),
True, "Error, should_be: %s, but result: %s" % (should_be, results))
results = zeros(hc_set.size(), dtype=int32)
results[0] = where(hh_set.get_attribute('income') <=
hc_set.get_attribute("max")[hc_sorted_index[0]], 1,0).sum()
for i in range(1, hc_set.size()-1):
results[i] = logical_and(where(hh_set.get_attribute('income') >=
hc_set.get_attribute("min")[hc_sorted_index[i]], 1,0),
where(hh_set.get_attribute('income') <=
hc_set.get_attribute("max")[hc_sorted_index[i]], 1,0)).sum()
results[-1] = where(hh_set.get_attribute('income') >= hc_set.get_attribute("min")[hc_sorted_index[-1]], 1,0).sum()
should_be = hct_set.get_attribute("total_number_of_households")[4:8]
self.assertEqual(ma.allclose(results, should_be, rtol=1e-6),
True, "Error, should_be: %s, but result: %s" % (should_be, results))
# this run should add and remove households
model.run(year=2002, person_set=prs_set, household_set=hh_set, control_totals=hct_set, characteristics=hc_set)
results = hh_set.size()
should_be = [(hct_set.get_attribute("total_number_of_households")[8:13]).sum()]
self.assertEqual(ma.allclose(should_be, results, rtol=1e-1),
True, "Error, should_be: %s, but result: %s" % (should_be, results))
results = zeros(hc_set.size(), dtype=int32)
results[0] = where(hh_set.get_attribute('income') <= hc_set.get_attribute("max")[hc_sorted_index[0]], 1,0).sum()
for i in range(1, hc_set.size()-1):
results[i] = logical_and(where(hh_set.get_attribute('income') >=
hc_set.get_attribute("min")[hc_sorted_index[i]], 1,0),
where(hh_set.get_attribute('income') <=
hc_set.get_attribute("max")[hc_sorted_index[i]], 1,0)).sum()
results[-1] = where(hh_set.get_attribute('income') >= hc_set.get_attribute("min")[hc_sorted_index[-1]], 1,0).sum()
should_be = hct_set.get_attribute("total_number_of_households")[8:13]
self.assertEqual(ma.allclose(results, should_be, rtol=1e-6),
True, "Error, should_be: %s, but result: %s" % (should_be, results))
