def run(self):
dataset_pool = SessionConfiguration().get_dataset_pool()
current_year = SimulationState().get_current_time()
building_set = dataset_pool.get_dataset('building')
parcel_set = dataset_pool.get_dataset('parcel')
proposal_set = dataset_pool.get_dataset('proposed_development_event')
parcels = proposal_set.get_attribute('parcel_id')
amount = proposal_set.get_attribute('amount')
year = proposal_set.get_attribute('year')
proposal_in_current_year = (year==current_year)
building_type_id = proposal_set.get_attribute('building_type_id')
proposed_sf_units = amount * (building_type_id == 1)*proposal_in_current_year
proposed_townhome_units = amount * (building_type_id == 2)*proposal_in_current_year
proposed_mf_units = amount * (building_type_id == 3)*proposal_in_current_year
proposal_zone = proposal_in_current_year * proposal_set.compute_variables('_proposal_zone = proposed_development_event.disaggregate(parcel.zone_id)')
parcel_zone = parcel_set.get_attribute('zone_id')
zone_ids = unique(parcel_zone)
in_zone = None
for zone_id in zone_ids:
# proposals_in_zone = where(proposal_zone==zone_id)[0]
# logger.log_status("proposals_in_zone %s: %s" % (zone_id,proposals_in_zone.size))
# if proposals_in_zone.size > 0:
# logger.log_status("sf units in zone %s: %s" % (zone_id,proposed_sf_units[proposals_in_zone].sum()))
# logger.log_status("townhome units in zone %s: %s" % (zone_id,proposed_townhome_units[proposals_in_zone].sum()))
# logger.log_status("mf units in zone %s: %s" % (zone_id,proposed_mf_units[proposals_in_zone].sum()))
######Need to come back and look at the treatment of proposed projects. But this won't affect calibration/validation, so proceed for now.
if in_zone is not None:
building_set.delete_computed_attributes()
parcel_set.delete_computed_attributes()
in_zone = building_set.compute_variables('_in_zone = building.disaggregate(parcel.zone_id)==%s'% (zone_id))
idx_in_zone = where(in_zone)[0]
max_building_id = (building_set.get_attribute('building_id')).max()
attribs = building_set.get_known_attribute_names()
table_data={}
for name in attribs:
table_data["%s"%(name)]=building_set.get_attribute("%s" %(name))[idx_in_zone]
storage = StorageFactory().get_storage('dict_storage')
table_name = 'buildings_zone'
storage.write_table(
table_name=table_name,
table_data=table_data
)
buildings_zone = BuildingDataset(in_storage=storage, in_table_name=table_name)
if buildings_zone.size() > 0:
dptm = RealEstateTransitionModel(target_vancy_dataset=dataset_pool.get_dataset('target_vacancy'))
results, index = dptm.run(realestate_dataset = buildings_zone,
year = current_year,
occupied_spaces_variable = 'occupied_spaces',
total_spaces_variable = 'total_spaces',
target_attribute_name = 'target_vacancy_rate',
sample_from_dataset = dataset_pool.get_dataset('building'),
dataset_pool=dataset_pool,
append_to_realestate_dataset = False,
reset_attribute_value={'parcel_id':-1},
sample_filter="(building.building_type_id==1)*(building.year_built>1989) + (building.building_type_id==3)*(building.year_built>1979) + (building.building_type_id==2)*(building.year_built>1989)+ (building.building_type_id>3)*(building.building_type_id<12)"
)
#This is where, now that we know the demand for sqft, I'd want to insert the appropriate amount of permitted/proposed projects.
if results is not None:
results.modify_attribute('year_built', array(index.size*[current_year]))
attribs2 = results.get_known_attribute_names()
table_data2={}
for name in attribs2:
if name in attribs:
table_data2["%s"%(name)]=results.get_attribute("%s" %(name))
building_set.add_elements(data=table_data2, require_all_attributes=False, change_ids_if_not_unique=True)
index_new_sf_units = where(logical_and(building_set['building_id']>max_building_id, building_set['building_type_id']==1))[0]
index_new_mf_units = where(logical_and(building_set['building_id']>max_building_id, (building_set['building_type_id']==2)+(building_set['building_type_id']==3)))[0]
index_new_industrial_units = where(logical_and(building_set['building_id']>max_building_id, (building_set['building_type_id']==6)+(building_set['building_type_id']==7)))[0]
index_new_commercial_units = where(logical_and(building_set['building_id']>max_building_id, (building_set['building_type_id']==9)+(building_set['building_type_id']==8)))[0]
if index_new_sf_units.size > 0:
for building in index_new_sf_units:
has_available_sf_capacity = parcel_set.compute_variables('_has_available_sf_capacity = (parcel.zone_id==%s) * parcel.disaggregate(zoning.allow_sf==1) * (((safe_array_divide(parcel.parcel_sqft,parcel.disaggregate(zoning.min_lot_size)).round().astype(int32)) - (parcel.number_of_agents(building)))>0)'%(zone_id))
idx_has_available_sf_capacity = where(has_available_sf_capacity)[0]
if idx_has_available_sf_capacity.size < 1:
logger.log_status("No more single-family capacity remaining in this zone")
break
parcel_ids_available_sf_capacity=(parcel_set.get_attribute('parcel_id'))[idx_has_available_sf_capacity]
shuffle(parcel_ids_available_sf_capacity)
parcel_id_to_assign = parcel_ids_available_sf_capacity[:1]
building_set.modify_attribute('parcel_id', parcel_id_to_assign, building)
if index_new_commercial_units.size > 0:
for building in index_new_commercial_units:
available_commercial_capacity = parcel_set.compute_variables('_available_commercial_capacity = (parcel.zone_id==%s) * parcel.disaggregate(zoning.allow_comm==1) * clip_to_zero((((parcel.parcel_sqft)*parcel.disaggregate(zoning.max_far)).round().astype(int32)-(parcel.aggregate(1000*building.residential_units))) - (parcel.aggregate(building.non_residential_sqft)))'%(zone_id))
####update the capacity calcs to account for sqft per unit of hotel/resort units
building_sqft = building_set['non_residential_sqft'][building]
idx_building_would_fit = where(available_commercial_capacity>=building_sqft)[0]
if idx_building_would_fit.size < 1:
logger.log_status("No more commercial capacity remaining in this zone")
break
parcel_ids_with_enough_capacity = (parcel_set.get_attribute('parcel_id'))[idx_building_would_fit]
shuffle(parcel_ids_with_enough_capacity) #replace with code involving random/uniform/cumprob/searchsorted etc... I think it would be faster
parcel_id_to_assign = parcel_ids_with_enough_capacity[:1]
building_set.modify_attribute('parcel_id', parcel_id_to_assign, building)
if index_new_industrial_units.size > 0:
for building in index_new_industrial_units:
available_industrial_capacity = parcel_set.compute_variables('_available_industrial_capacity = (parcel.zone_id==%s) * parcel.disaggregate(zoning.allow_indust==1) * clip_to_zero((((parcel.parcel_sqft)*parcel.disaggregate(zoning.max_far)).round().astype(int32)-(parcel.aggregate(1000*building.residential_units))) - (parcel.aggregate(building.non_residential_sqft)))'%(zone_id))
building_sqft = building_set['non_residential_sqft'][building]
idx_building_would_fit = where(available_industrial_capacity>=building_sqft)[0]
if idx_building_would_fit.size < 1:
logger.log_status("No more industrial capacity remaining in this zone")
break
parcel_ids_with_enough_capacity = (parcel_set.get_attribute('parcel_id'))[idx_building_would_fit]
shuffle(parcel_ids_with_enough_capacity)
parcel_id_to_assign = parcel_ids_with_enough_capacity[:1]
building_set.modify_attribute('parcel_id', parcel_id_to_assign, building)
if index_new_mf_units.size > 0:
for building in index_new_mf_units:
available_mf_capacity = parcel_set.compute_variables('_available_mf_capacity = (parcel.zone_id==%s) * parcel.disaggregate(zoning.allow_mf==1) * clip_to_zero(((((parcel.parcel_sqft)*parcel.disaggregate(zoning.max_far)).round().astype(int32)) - (parcel.aggregate(building.non_residential_sqft)))/1000 - (parcel.aggregate(building.residential_units)))'%(zone_id))
building_resunits = building_set['residential_units'][building]
idx_building_would_fit = where(available_mf_capacity>=building_resunits)[0]
if idx_building_would_fit.size < 1:
logger.log_status("No more multifamily capacity remaining in this zone")
break
parcel_ids_with_enough_capacity = (parcel_set.get_attribute('parcel_id'))[idx_building_would_fit]
shuffle(parcel_ids_with_enough_capacity)
parcel_id_to_assign = parcel_ids_with_enough_capacity[:1]
building_set.modify_attribute('parcel_id', parcel_id_to_assign, building)
index_unplaced_buildings = where(logical_and(building_set['building_id']>max_building_id, building_set['parcel_id']<=0))[0]
logger.log_status("Number of unplaced buildings to be removed from zone%s: %s" % (zone_id,index_unplaced_buildings.size))
building_set.remove_elements(index_unplaced_buildings)
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
