def test_run_model_with_known_buildings(self):
storage = self.storage
storage.write_table(
table_name = 'buildings',
table_data = {
'building_id': array([1,2,3,4,5,6,7]),
'parcel_id': array([1,1,2,2,2,3,3]),
'is_residential': array([0,0,0,1,1,0,0])
}
)
storage.write_table(
table_name = 'employment_events',
table_data = {
'parcel_id': array([2, 2, -1, -1, 1]),
'building_id': array([-1, -1, 6, 7, -1]),
'scheduled_year': array([2006, 2006, 2006, 2006, 2006]),
'number_of_non_home_based_jobs': array([3500, 500, -100, 0, 100]),
'number_of_home_based_jobs': array([0, 20, 0, 10, 0]),
'sector_id': array([1, 2, 15, 2, 1]),
'replace_non_home_based_jobs': array([0, 0, 0, 1, 0])
}
)
# change in 2006
############
# parcel/sector 1 2 3
# 1 +100nhb +3500nhb --
# 2 =0nhb +500nhb/+20hb +10hb
# 15 -- -- -100nhb
dataset_pool = DatasetPool(storage=storage, package_order=['urbansim_parcel', 'urbansim'])
job_set = JobDataset(in_storage=storage)
job_set.modify_attribute('building_id', array(6000*[1] + 4000*[3] + 3000*[6]))
dataset_pool.add_datasets_if_not_included({'job':job_set})
model = EmploymentEventsModel(dataset_pool=dataset_pool)
model.run(dataset_pool.get_dataset('employment_event'), job_set, current_year=2006)
buildings = dataset_pool.get_dataset('building')
jobs_in_sec_1 = buildings.compute_variables(['urbansim_parcel.building.number_of_jobs_of_sector_1'],
dataset_pool=dataset_pool)
jobs_in_sec_2 = buildings.compute_variables(['urbansim_parcel.building.number_of_jobs_of_sector_2'],
dataset_pool=dataset_pool)
jobs_in_sec_15 = buildings.compute_variables(['urbansim_parcel.building.number_of_jobs_of_sector_15'],
dataset_pool=dataset_pool)
self.assertEqual(jobs_in_sec_1[0:2].sum()==4100, True) # parcel 1
self.assertEqual(jobs_in_sec_1[2] == 5500, True) # parcel 2 non-residential
self.assertEqual(jobs_in_sec_1[5:7].sum()==1000, True) # parcel 3
self.assertEqual(jobs_in_sec_2[0:2].sum()==1000, True) # parcel 1
self.assertEqual(jobs_in_sec_2[2] == 1500, True) # parcel 2 non-residential
self.assertEqual(jobs_in_sec_2[3:5].sum() == 20, True) # parcel 2 residential
self.assertEqual(jobs_in_sec_2[5]==100, True) # parcel 3, building 6
self.assertEqual(jobs_in_sec_2[6]==10, True) # parcel 3, building 7
self.assertEqual(jobs_in_sec_15[0:2].sum()==1000, True) # parcel 2 non-residential
self.assertEqual(jobs_in_sec_15[2] == 1000, True) # parcel 2 residential
self.assertEqual(jobs_in_sec_15[5]==900, True) # parcel 3, building 6
aggr_var2 = "neighborhood.aggregate(gridcell.capacity, intermediates=[zone], function=sum)"
neighborhoods.compute_variables(aggr_var2, dataset_pool=dataset_pool)
neighborhoods.add_primary_attribute(name="is_cbd", data=[0,0,1])
disaggr_var = "is_cbd = gridcell.disaggregate(neighborhood.is_cbd, intermediates=[zone])"
locations.compute_variables(disaggr_var, dataset_pool=dataset_pool)
from opus_core.datasets.alldata_dataset import AlldataDataset
alldata = AlldataDataset(dataset_name="alldata")
alldata.compute_variables(
"total_capacity = alldata.aggregate_all(gridcell.capacity, function=sum)",
dataset_pool=dataset_pool)
# Number of agents
households.modify_attribute(name="location", data=[2, 8, 3, 1, 5, 4, 9, 7, 3, 6])
dataset_pool.add_datasets_if_not_included({'household': households})
locations.compute_variables("gridcell.number_of_agents(household)",
dataset_pool=dataset_pool)
neighborhoods.compute_variables("neighborhood.number_of_agents(zone)",
dataset_pool=dataset_pool)
# Creating a model
from opus_core.model import Model
from opus_core.logger import logger
class MyModel(Model):
model_name = "my model"
def run(self):
logger.log_status("I'm running!")
return
MyModel().run()
def test_run_model_with_known_buildings(self):
storage = self.storage
storage.write_table(table_name='buildings',
table_data={
'building_id': array([1, 2, 3, 4, 5, 6, 7]),
'parcel_id': array([1, 1, 2, 2, 2, 3, 3]),
'is_residential': array([0, 0, 0, 1, 1, 0, 0])
})
storage.write_table(table_name='employment_events',
table_data={
'parcel_id':
array([2, 2, -1, -1, 1]),
'building_id':
array([-1, -1, 6, 7, -1]),
'scheduled_year':
array([2006, 2006, 2006, 2006, 2006]),
'number_of_non_home_based_jobs':
array([3500, 500, -100, 0, 100]),
'number_of_home_based_jobs':
array([0, 20, 0, 10, 0]),
'sector_id':
array([1, 2, 15, 2, 1]),
'replace_non_home_based_jobs':
array([0, 0, 0, 1, 0])
})
# change in 2006
############
# parcel/sector 1 2 3
# 1 +100nhb +3500nhb --
# 2 =0nhb +500nhb/+20hb +10hb
# 15 -- -- -100nhb
dataset_pool = DatasetPool(
storage=storage, package_order=['urbansim_parcel', 'urbansim'])
job_set = JobDataset(in_storage=storage)
job_set.modify_attribute('building_id',
array(6000 * [1] + 4000 * [3] + 3000 * [6]))
dataset_pool.add_datasets_if_not_included({'job': job_set})
model = EmploymentEventsModel(dataset_pool=dataset_pool)
model.run(dataset_pool.get_dataset('employment_event'),
job_set,
current_year=2006)
buildings = dataset_pool.get_dataset('building')
jobs_in_sec_1 = buildings.compute_variables(
['urbansim_parcel.building.number_of_jobs_of_sector_1'],
dataset_pool=dataset_pool)
jobs_in_sec_2 = buildings.compute_variables(
['urbansim_parcel.building.number_of_jobs_of_sector_2'],
dataset_pool=dataset_pool)
jobs_in_sec_15 = buildings.compute_variables(
['urbansim_parcel.building.number_of_jobs_of_sector_15'],
dataset_pool=dataset_pool)
self.assertEqual(jobs_in_sec_1[0:2].sum() == 4100, True) # parcel 1
self.assertEqual(jobs_in_sec_1[2] == 5500,
True) # parcel 2 non-residential
self.assertEqual(jobs_in_sec_1[5:7].sum() == 1000, True) # parcel 3
self.assertEqual(jobs_in_sec_2[0:2].sum() == 1000, True) # parcel 1
self.assertEqual(jobs_in_sec_2[2] == 1500,
True) # parcel 2 non-residential
self.assertEqual(jobs_in_sec_2[3:5].sum() == 20,
True) # parcel 2 residential
self.assertEqual(jobs_in_sec_2[5] == 100, True) # parcel 3, building 6
self.assertEqual(jobs_in_sec_2[6] == 10, True) # parcel 3, building 7
self.assertEqual(jobs_in_sec_15[0:2].sum() == 1000,
True) # parcel 2 non-residential
self.assertEqual(jobs_in_sec_15[2] == 1000,
True) # parcel 2 residential
self.assertEqual(jobs_in_sec_15[5] == 900,
True) # parcel 3, building 6
class BTMTests(StochasticTestCase):
def setUp( self ):
"""here, we simulate 50 residential units
and 5000 commercial, industrial, and governmental sqft added to each of the gridcells in previous years.
"""
### TODO: do not redefine these constants.
self.comc = 1
self.indc = 3
self.govc = 2
self.sfhc = 4
self.mfhc = 5
storage = StorageFactory().get_storage('dict_storage')
gridcells_table_name = 'gridcells'
# create 100 gridcells, each with 200 residential units and space for 100 commercial jobs,
# 100 industrial jobs, and residential, industrial, and commercial value at $500,000 each
storage.write_table(
table_name=gridcells_table_name,
table_data={
"grid_id": arange( 1, 100+1 ),
"commercial_sqft_per_job":array( 100*[100] ),
"industrial_sqft_per_job":array( 100*[100] ),
"single_family_improvement_value":array( 100*[500000] ),
"commercial_improvement_value":array( 100*[500000] ),
"industrial_improvement_value":array( 100*[500000] )
}
)
self.gridcells = GridcellDataset(in_storage=storage, in_table_name=gridcells_table_name)
buildings_table_name = 'buildings'
# 2000 buildings (1000 with 20 residential units each, 500 with 20 commercial job and 500 with 20 industrial job each)
storage.write_table(
table_name=buildings_table_name,
table_data={
"building_id":arange( 1, 2000+1 ), # 2000 buildings
"grid_id":array( 20*range( 1, 100+1 ), dtype=int32 ), # spread evenly across 100 gridcells
"building_type_id":array(1000*[self.sfhc] +
500*[self.comc] +
500*[self.indc], dtype=int8),
"sqft": array(1000*[0] +
500*[2000] +
500*[2000], dtype=int32),
"residential_units": array(1000*[20] +
500* [0] +
500* [0], dtype=int32),
"improvement_value": array(1000*[50] +
500* [50] +
500* [50], dtype=float32),
"year_built": array(1000*[1940] +
500* [1940] +
500* [1940], dtype=int32)
}
)
self.buildings = BuildingDataset(in_storage=storage, in_table_name=buildings_table_name)
households_table_name = 'households'
# create 10000 households, 100 in each of the 100 gridcells.
# there will initially be 100 vacant residential units in each gridcell then.
storage.write_table(
table_name=households_table_name,
table_data={
"household_id":arange( 1, 10000+1 ),
"grid_id":array( 100*range( 1, 100+1 ), dtype=int32 )
}
)
self.households = HouseholdDataset(in_storage=storage, in_table_name=households_table_name)
building_types_table_name = 'building_types'
storage.write_table(
table_name=building_types_table_name,
table_data={
"building_type_id":array([self.govc,self.comc,self.indc, self.sfhc, self.mfhc], dtype=int8),
"name": array(["governmental", "commercial", "industrial", "single_family","multiple_family"]),
"units": array(["governmental_sqft", "commercial_sqft", "industrial_sqft", "residential_units", "residential_units"]),
"is_residential": array([0,0,0,1,1], dtype='?')
}
)
self.building_types = BuildingTypeDataset(in_storage=storage, in_table_name=building_types_table_name)
job_building_types_table_name = 'job_building_types'
storage.write_table(
table_name=job_building_types_table_name,
table_data={
"id":array([self.govc,self.comc,self.indc, self.sfhc, self.mfhc], dtype=int8),
"name": array(["governmental", "commercial", "industrial", "single_family","multiple_family"])
}
)
self.job_building_types = JobBuildingTypeDataset(in_storage=storage, in_table_name=job_building_types_table_name)
jobs_table_name = 'jobs'
# create 2500 commercial jobs and distribute them equally across the 100 gridcells,
# 25 commercial buildings/gridcell
storage.write_table(
table_name=jobs_table_name,
table_data={
"job_id":arange( 1, 2500+1 ),
"grid_id":array( 25*range( 1, 100+1 ), dtype=int32 ),
"sector_id":array( 2500*[1], dtype=int32 ),
"building_type":array(2500*[self.comc], dtype=int8)
}
)
self.jobs = JobDataset(in_storage=storage, in_table_name=jobs_table_name)
self.dataset_pool = DatasetPool()
self.dataset_pool.add_datasets_if_not_included({
"household":self.households,
"job":self.jobs,
"building":self.buildings,
"building_type": self.building_types,
"job_building_type": self.job_building_types})
self.building_categories = {'commercial': array([1000,5000]),
'industrial': array([500,800,1000])}
def test_no_development_with_zero_target_vacancy( self ):
"""If the target vacany ratest are 0%, then no development should occur and thus,
the building set should remain unchanged (should have the same size).
"""
"""specify that the target vacancies for the year 2000 should be 0% for
commercial building type."""
storage = StorageFactory().get_storage('dict_storage')
target_vacancies_table_name = 'target_vacancies'
storage.write_table(
table_name=target_vacancies_table_name,
table_data={
"year":array( [2000] ),
"target_total_commercial_vacancy":array( [0.0] )
}
)
target_vacancies = TargetVacancyDataset(in_storage=storage, in_table_name=target_vacancies_table_name)
nbuildings = self.buildings.size()
btm = BuildingTransitionModel()
results = btm.run(self.buildings, self.building_types,
target_vacancies,
2000,
self.gridcells, building_categories=self.building_categories,
dataset_pool=self.dataset_pool)
self.assertEqual( results, 0, "No buildings should've been added/developed" )
self.assertEqual( nbuildings, self.buildings.size(), "No buildings should've been added/developed" )
def test_development_with_nonzero_target_vacancy( self ):
"""Test basic cases, where current single family vacancy = 50%, target single family vacancy is 75%,
current commercial vacancy is 75%, and target commercial vacancy is 50%.
Single family development projects should occur, and none for commercial"""
storage = StorageFactory().get_storage('dict_storage')
target_vacancies_table_name = 'target_vacancies'
storage.write_table(
table_name=target_vacancies_table_name,
table_data={
"year":array( [2001], dtype=int32 ),
"target_total_single_family_vacancy":array( [0.75] ),
"target_total_commercial_vacancy":array( [0.50] )
}
)
target_vacancies = TargetVacancyDataset(in_storage=storage, in_table_name=target_vacancies_table_name)
resunits_before, commercial_before, industrial_before, tmp1, tmp2, tmp3 = self.get_residential_commercial_industrial_units(self.buildings)
btm = BuildingTransitionModel()
results = btm.run(self.buildings, self.building_types,
target_vacancies,
2001,
self.gridcells, building_categories=self.building_categories,
dataset_pool=self.dataset_pool )
"""20000 residential units should've been added because current ratio of
10000 unoccupied / 20000 total = 0.5, and target residential vacancy rate
is 0.75. add 20000 to numerator and denominator, and 30000 / 40000 = 0.75"""
resunits_after, commercial_after, industrial_after, tmp1, tmp2, tmp3 = self.get_residential_commercial_industrial_units(self.buildings)
self.assertEqual( resunits_after-resunits_before, 20000,
"""Exactly 20000 residential units should've been added/developed.
Instead, got %s""" % ( resunits_after-resunits_before, ) )
"""Anytime the target vacancy rate is less than the current vacancy rate,
no new development should occur."""
self.assertEqual( commercial_before - commercial_after, 0,
"No commercial units should've been added/developed." )
self.assertEqual( industrial_before-industrial_after, 0,
"No industrial units should've been added/developed." )
"""Check categories"""
self.assertEqual(ma.allequal(self.buildings.get_categories("commercial"), self.building_categories["commercial"]), True,
"Error in creating categories for commercial buildings.")
self.assertEqual(ma.allequal(self.buildings.get_categories("industrial"), self.building_categories["industrial"]), True,
"Error in creating categories for industrial buildings.")
def test_development_with_99_percent_target_vacancy( self ):
"""Not too different from the basic case above, just trying the other extreme.
Notice that a 100% target vacancy rate doesn't really make sense and is not possible unless
the current vacancy rate is also 100% (also not feasible)."""
storage = StorageFactory().get_storage('dict_storage')
storage.write_table(
table_name='target_vacancies',
table_data={
'year':array([2001], dtype=int32),
'target_total_single_family_vacancy':array([0.99]),
'target_total_commercial_vacancy':array([0.99]),
'target_total_industrial_vacancy':array([0.99])
},
)
target_vacancies = TargetVacancyDataset(in_storage=storage, in_table_name='target_vacancies')
resunits_before, commercial_before, industrial_before, tmp1, tmp2, tmp3 = self.get_residential_commercial_industrial_units(self.buildings)
btm = BuildingTransitionModel()
results = btm.run(self.buildings, self.building_types,
target_vacancies,
2001,
self.gridcells, building_categories=self.building_categories,
dataset_pool=self.dataset_pool)
"""20000 residential units should've been added because current ratio of
10000 unoccupied / 20000 total = 0.5, and target residential vacancy rate
is 0.75. add 20000 to numerator and denominator, and 30000 / 40000 = 0.75"""
resunits_after, commercial_after, industrial_after, tmp1, tmp2, tmp3 = self.get_residential_commercial_industrial_units(self.buildings)
"""
.01 = 10000 / (20000 + x)
x = (10000 - (.01*20000))/.01
"""
residential_units_developed = (10000 - (.01*20000))/.01
max_difference = 50
self.assert_(self.is_close(resunits_after - resunits_before, residential_units_developed, max_difference),
"""Approximately %s residential units should've been added/developed.
Instead, got %s""" % (residential_units_developed, resunits_after - resunits_before))
"""
2500 commercial jobs * 100 occupied square feet per commercial job is
250,000 commercial square feet occupied
250,000 / (1,000,000 + x) = .01
which converts into:
x = (250,000 - .01*1,000,000)/.01
x = 24,000,000
"""
commercial_sqft_developed = (250000 - (.01*1000000))/.01
max_difference = 5000
self.assert_(self.is_close(commercial_after - commercial_before, commercial_sqft_developed, max_difference),
"""Approximately %s commercial sqft should've been added/developed.
Instead, got %s""" % (commercial_sqft_developed, commercial_after - commercial_before))
self.assertEqual(industrial_before - industrial_after, 0,
"No industrial units should've been added/developed.")
def get_residential_commercial_industrial_units(self, buildings):
resunits = buildings.get_attribute("residential_units").sum()
buildings.compute_variables([
"urbansim.building.is_building_type_commercial", "urbansim.building.is_building_type_industrial",
"urbansim.building.is_building_type_single_family"],
dataset_pool=self.dataset_pool)
commercial = (buildings.get_attribute("sqft")*buildings.get_attribute("is_building_type_commercial")).sum()
industrial = (buildings.get_attribute("sqft")*buildings.get_attribute("is_building_type_industrial")).sum()
return (resunits, commercial, industrial,
buildings.get_attribute("is_building_type_single_family").sum(),
buildings.get_attribute("is_building_type_commercial").sum(),
buildings.get_attribute("is_building_type_industrial").sum())
def is_close(self, first_value, second_value, max_difference):
return abs(first_value - second_value) <= max_difference
aggr_var2 = "neighborhood.aggregate(gridcell.capacity, intermediates=[zone], function=sum)"
neighborhoods.compute_variables(aggr_var2, dataset_pool=dataset_pool)
neighborhoods.add_primary_attribute(name="is_cbd", data=[0,0,1])
disaggr_var = "is_cbd = gridcell.disaggregate(neighborhood.is_cbd, intermediates=[zone])"
locations.compute_variables(disaggr_var, dataset_pool=dataset_pool)
from opus_core.datasets.alldata_dataset import AlldataDataset
alldata = AlldataDataset(dataset_name="alldata")
alldata.compute_variables(
"total_capacity = alldata.aggregate_all(gridcell.capacity, function=sum)",
dataset_pool=dataset_pool)
# Number of agents
households.modify_attribute(name="location", data=[2, 8, 3, 1, 5, 4, 9, 7, 3, 6])
dataset_pool.add_datasets_if_not_included({'household': households})
locations.compute_variables("gridcell.number_of_agents(household)",
dataset_pool=dataset_pool)
neighborhoods.compute_variables("neighborhood.number_of_agents(zone)",
dataset_pool=dataset_pool)
# Creating a model
from opus_core.model import Model
from opus_core.logger import logger
class MyModel(Model):
model_name = "my model"
def run(self):
logger.log_status("I'm running!")
return
MyModel().run()
