def test_scaling_households_model(self): storage = StorageFactory().get_storage('dict_storage') hhs_table_name = 'households' storage.write_table( table_name=hhs_table_name, table_data={ "household_id": arange(100)+1, "building_id":array(10*[1]+60*[2]+30*[-1]) } ) households = HouseholdDataset(in_storage=storage, in_table_name=hhs_table_name) buildings_table_name = 'buildings' storage.write_table( table_name=buildings_table_name, table_data={"building_id":arange(2)+1} ) buildings = BuildingDataset(in_storage=storage, in_table_name=buildings_table_name) # run model model = ScalingAgentsModel(debuglevel=4) model.run(buildings, households, agents_index = arange(70, 100)) # all households are placed self.assertEqual((households['building_id']>0).all(), True) # get results buildings.compute_variables(["urbansim_parcel.building.number_of_households"], resources = Resources({"household":households})) result = buildings["number_of_households"] self.assertEqual(result.sum(), 100) res_incr = result - array([10, 60]) # building increments # second building should get many more HHs than the first building (at least twice as much) self.assertEqual(res_incr[1] > 2*res_incr[0], True)
def test_scaling_households_model_with_weights(self): storage = StorageFactory().get_storage('dict_storage') hhs_table_name = 'households' storage.write_table( table_name=hhs_table_name, table_data={ "household_id": arange(100)+1, "building_id":array(10*[1]+50*[2]+10*[3]+30*[-1]) } ) households = HouseholdDataset(in_storage=storage, in_table_name=hhs_table_name) buildings_table_name = 'buildings' storage.write_table( table_name=buildings_table_name, table_data={"building_id":arange(3)+1} ) buildings = BuildingDataset(in_storage=storage, in_table_name=buildings_table_name) # run model: Give the first building ten times as much weight as building 2. No weight for building 3. model = ScalingAgentsModel(weights="10*(building.building_id == 1) + (building.building_id == 2)", debuglevel=4) model.run(buildings, households, agents_index = arange(70, 100)) # all households are placed self.assertEqual((households['building_id']>0).all(), True) # get results buildings.compute_variables(["urbansim_parcel.building.number_of_households"], resources = Resources({"household":households})) result = buildings["number_of_households"] self.assertEqual(result.sum(), 100) res_incr = result - array([10, 50, 10]) # building increments self.assertEqual(res_incr[2], 0) # third building should have no increment # first building should get more HHs than the second building self.assertEqual(res_incr[1] < res_incr[0], True)
def test_my_inputs(self): storage = StorageFactory().get_storage('dict_storage') building_types_table_name = 'building_types' storage.write_table( table_name=building_types_table_name, table_data={ 'building_type_id':array([0,2]), 'name': array(['foo', 'commercial']) } ) buildings_table_name = 'buildings' storage.write_table( table_name=buildings_table_name, table_data={ 'building_id':array([1,2,3]), 'building_type_id': array([2,0,2]) } ) building_types = BuildingTypeDataset(in_storage=storage, in_table_name=building_types_table_name) buildings = BuildingDataset(in_storage=storage, in_table_name=buildings_table_name) buildings.compute_variables(self.variable_name, resources=Resources({'building_type':building_types})) values = buildings.get_attribute(self.variable_name) should_be = array([1,0,1]) self.assert_(ma.allequal(values, should_be), 'Error in ' + self.variable_name)
def do_unplace_jobs_with_non_existing_buildings(self, jobs, in_storage): buildings = BuildingDataset(in_storage=in_storage) building_ids = jobs.get_attribute(buildings.get_id_name()[0]) valid_building_ids_idx = where(building_ids > 0)[0] index = buildings.try_get_id_index(building_ids[valid_building_ids_idx]) logger.log_status("%s jobs have non-existing locations and are unplaced from buildings (parcel_id and zone_id are not affected)." % where(index < 0)[0].size) jobs.modify_attribute(name="building_id", data=-1, index=valid_building_ids_idx[index < 0])
def test_my_inputs(self): storage = StorageFactory().get_storage('dict_storage') building_types_table_name = 'building_types' storage.write_table( table_name=building_types_table_name, table_data={ 'building_type_id':array([1,2]), 'name': array(['residential', 'commercial']), 'units': array(['residential_units', 'commercial_sqft']) } ) buildings_table_name = 'buildings' storage.write_table( table_name=buildings_table_name, table_data={ 'building_id': arange(6)+1, 'building_type_id': array([1,2,1,2,1,1]), 'sqft': array([100, 350, 1000, 0, 430, 95]), 'residential_units': array([300, 0, 100, 0, 1000, 600]) } ) building_types = BuildingTypeDataset(in_storage=storage, in_table_name=building_types_table_name) buildings = BuildingDataset(in_storage=storage, in_table_name=buildings_table_name) buildings.compute_variables(self.variable_name, resources=Resources({'building_type': building_types})) should_be = array([300, 350, 100, 0, 1000, 600]) values = buildings.get_attribute(self.variable_name) self.assert_(ma.allequal(values, should_be), 'Error in ' + self.variable_name)
def do_unplace_jobs_with_non_existing_buildings(self, jobs, in_storage): buildings = BuildingDataset(in_storage=in_storage) building_ids = jobs.get_attribute(buildings.get_id_name()[0]) valid_building_ids_idx = where(building_ids > 0)[0] index = buildings.try_get_id_index( building_ids[valid_building_ids_idx]) logger.log_status( "%s jobs have non-existing locations and are unplaced from buildings (parcel_id and zone_id are not affected)." % where(index < 0)[0].size) jobs.modify_attribute(name="building_id", data=-1, index=valid_building_ids_idx[index < 0])
def test_my_inputs(self): storage = StorageFactory().get_storage('dict_storage') building_types_table_name = 'building_types' storage.write_table( table_name=building_types_table_name, table_data={ 'building_type_id':array([1,2]), 'name': array(['residential', 'commercial']), 'units': array(['residential_units', 'commercial_sqft']) } ) buildings_table_name = 'buildings' storage.write_table( table_name=buildings_table_name, table_data={ 'building_id': arange(7)+1, 'building_type_id': array([1,2,1,2,1,1,2]), 'sqft': array([100, 350, 1000, 0, 430, 95, 750]), 'residential_units': array([300, 0, 100, 0, 1300, 600, 10]) }, ) building_types = BuildingTypeDataset(in_storage=storage, in_table_name=building_types_table_name) buildings = BuildingDataset(in_storage=storage, in_table_name=buildings_table_name, resources=Resources({ 'building_categories': { 'residential': array([200, 500, 1200]), 'commercial': array([200, 500]) } }) ) variable_names = map(lambda type: '%s_%s' % (self.variable_name_prefix, type), ['commercial', 'residential']) buildings.compute_variables(variable_names, resources=Resources({'building_type': building_types})) should_be_residential = array([2, 0, 1, 0, 4, 3, 0]) should_be_commercial = array([0, 2, 0, 1, 0, 0, 3]) values_commercial = buildings.get_attribute(variable_names[0]) values_residential = buildings.get_attribute(variable_names[1]) self.assert_(ma.allequal(values_commercial, should_be_commercial), 'Error in ' + variable_names[0]) self.assert_(ma.allequal(values_residential, should_be_residential), 'Error in ' + variable_names[1])
def test_my_inputs(self): storage = StorageFactory().get_storage("dict_storage") building_types_table_name = "building_types" storage.write_table( table_name=building_types_table_name, table_data={"building_type_id": array([0, 2]), "building_type_name": array(["foo", "commercial"])}, ) buildings_table_name = "buildings" storage.write_table( table_name=buildings_table_name, table_data={"building_id": array([1, 2, 3]), "building_type_id": array([2, 0, 2])}, ) building_types = BuildingTypeDataset(in_storage=storage, in_table_name=building_types_table_name) buildings = BuildingDataset(in_storage=storage, in_table_name=buildings_table_name) buildings.compute_variables(self.variable_name, resources=Resources({"building_type": building_types})) values = buildings.get_attribute(self.variable_name) should_be = array([1, 0, 1]) self.assert_(ma.allequal(values, should_be), "Error in " + self.variable_name)
def test_my_inputs(self): storage = StorageFactory().get_storage('dict_storage') building_types_table_name = 'building_types' storage.write_table(table_name=building_types_table_name, table_data={ 'building_type_id': array([1, 2]), 'name': array(['residential', 'commercial']), 'units': array(['residential_units', 'commercial_sqft']) }) buildings_table_name = 'buildings' storage.write_table( table_name=buildings_table_name, table_data={ 'building_id': arange(7) + 1, 'building_type_id': array([1, 2, 1, 2, 1, 1, 2]), 'sqft': array([100, 350, 1000, 0, 430, 95, 750]), 'residential_units': array([300, 0, 100, 0, 1300, 600, 10]) }, ) building_types = BuildingTypeDataset( in_storage=storage, in_table_name=building_types_table_name) buildings = BuildingDataset(in_storage=storage, in_table_name=buildings_table_name, resources=Resources({ 'building_categories': { 'residential': array([200, 500, 1200]), 'commercial': array([200, 500]) } })) variable_names = map( lambda type: '%s_%s' % (self.variable_name_prefix, type), ['commercial', 'residential']) buildings.compute_variables(variable_names, resources=Resources( {'building_type': building_types})) should_be_residential = array([2, 0, 1, 0, 4, 3, 0]) should_be_commercial = array([0, 2, 0, 1, 0, 0, 3]) values_commercial = buildings.get_attribute(variable_names[0]) values_residential = buildings.get_attribute(variable_names[1]) self.assert_(ma.allequal(values_commercial, should_be_commercial), 'Error in ' + variable_names[0]) self.assert_(ma.allequal(values_residential, should_be_residential), 'Error in ' + variable_names[1])
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)
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])}
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
def test_unrolling(self): from urbansim.datasets.gridcell_dataset import GridcellDataset from urbansim.datasets.building_dataset import BuildingDataset from urbansim.datasets.building_type_dataset import BuildingTypeDataset from opus_core.datasets.dataset_pool import DatasetPool from numpy import arange storage = StorageFactory().get_storage('dict_storage') gridcells_table_name = 'gridcells' storage.write_table( table_name = gridcells_table_name, table_data = { 'grid_id':array([1,2,3]), 'commercial_sqft':array([50,50,50]), 'industrial_sqft':array([100,100,100]), 'governmental_sqft':array([0,0,0]), 'residential_units':array([10,0,0]), 'commercial_improvement_value':array([0,0,0]), 'industrial_improvement_value':array([0,0,0]), 'governmental_improvement_value':array([0,0,0]), 'residential_improvement_value':array([0,0,0]), }, ) building_table_name = 'buildings' storage.write_table( table_name = building_table_name, table_data = { 'building_id': arange(6)+1, 'year_built':array([1999,1999,1998,1998,1998,1999]), 'grid_id':array([1,3,2,3,1,1]), 'sqft':array([10,20,30,40,0,20]), 'residential_units':array([0,0,0,0,5,0]), 'improvement_value':array([0,0,0,0,0,0]), 'building_type_id': array([1,2,1,2,3,1]) }, ) building_types_table_name = 'building_types' storage.write_table( table_name = building_types_table_name, table_data = { 'building_type_id':array([1,2,3,4]), 'name': array(['industrial', 'commercial', 'residential', 'governmental']) } ) building_types = BuildingTypeDataset(in_storage=storage, in_table_name=building_types_table_name) gridcells = GridcellDataset(in_storage=storage, in_table_name=gridcells_table_name) buildings = BuildingDataset(in_storage=storage, in_table_name=building_table_name) dataset_pool = DatasetPool() dataset_pool._add_dataset(building_types.get_dataset_name(), building_types) roller = RollbackGridcellsFromBuildings() roller.unroll_gridcells_for_one_year(gridcells, buildings, 2000, dataset_pool) self.assert_(ma.allequal(gridcells.get_attribute('commercial_sqft'), array([50,50,50]))) self.assert_(ma.allequal(gridcells.get_attribute('industrial_sqft'), array([100,100,100]))) self.assert_(ma.allequal(gridcells.get_attribute('residential_units'), array([10, 0, 0]))) roller.unroll_gridcells_for_one_year(gridcells, buildings, 1999, dataset_pool) self.assert_(ma.allequal(gridcells.get_attribute('commercial_sqft'), array([50,50,30])), 'Unexpected results: expected %s; received %s' % (array([50,50,30]), gridcells.get_attribute('commercial_sqft'))) self.assert_(ma.allequal(gridcells.get_attribute('industrial_sqft'), array([70,100,100]))) roller.unroll_gridcells_for_one_year(gridcells, buildings, 1998, dataset_pool) self.assert_(ma.allequal(gridcells.get_attribute('commercial_sqft'), array([50,50,0]))) self.assert_(ma.allequal(gridcells.get_attribute('industrial_sqft'), array([70,70,100]))) self.assert_(ma.allequal(gridcells.get_attribute('residential_units'), array([5, 0, 0])))
def get_resources(self, data_dictionary, dataset): """Create resources for computing a variable. """ resources = Resources() for key in data_dictionary.keys(): if key in self.datasets: data = data_dictionary[key] storage = StorageFactory().get_storage('dict_storage') if self.id_names[key] not in data_dictionary[key].keys( ) and not isinstance(self.id_names[key], list): data[self.id_names[key]] = arange( 1, len(data_dictionary[key][data_dictionary[key].keys() [0]]) + 1) # add id array id_name = self.id_names[key] storage.write_table(table_name='data', table_data=data) if key == "gridcell": gc = GridcellDataset(in_storage=storage, in_table_name='data') # add relative_x and relative_y gc.get_id_attribute() n = int(ceil(sqrt(gc.size()))) if "relative_x" not in data.keys(): x = (indices((n, n)) + 1)[1].ravel() gc.add_attribute(x[0:gc.size()], "relative_x", metadata=1) if "relative_y" not in data.keys(): y = (indices((n, n)) + 1)[0].ravel() gc.add_attribute(y[0:gc.size()], "relative_y", metadata=1) resources.merge({key: gc}) elif key == "household": resources.merge({ key: HouseholdDataset(in_storage=storage, in_table_name='data') }) elif key == "development_project": resources.merge({ key: DevelopmentProjectDataset(in_storage=storage, in_table_name='data') }) elif key == "development_event": resources.merge({ key: DevelopmentEventDataset(in_storage=storage, in_table_name='data') }) elif key == "neighborhood": resources.merge({ key: NeighborhoodDataset(in_storage=storage, in_table_name='data') }) elif key == "job": resources.merge({ key: JobDataset(in_storage=storage, in_table_name='data') }) elif key == "zone": resources.merge({ key: ZoneDataset(in_storage=storage, in_table_name='data') }) elif key == "travel_data": resources.merge({ key: TravelDataDataset(in_storage=storage, in_table_name='data') }) elif key == "faz": resources.merge({ key: FazDataset(in_storage=storage, in_table_name='data') }) elif key == "fazdistrict": resources.merge({ key: FazdistrictDataset(in_storage=storage, in_table_name='data') }) elif key == "race": resources.merge({ key: RaceDataset(in_storage=storage, in_table_name='data') }) elif key == "county": resources.merge({ key: CountyDataset(in_storage=storage, in_table_name='data') }) elif key == "large_area": resources.merge({ key: LargeAreaDataset(in_storage=storage, in_table_name='data') }) elif key == "development_group": resources.merge({ key: DevelopmentGroupDataset(in_storage=storage, in_table_name='data') }) elif key == "employment_sector_group": resources.merge({ key: EmploymentSectorGroupDataset(in_storage=storage, in_table_name='data') }) elif key == "plan_type_group": resources.merge({ key: PlanTypeGroupDataset(in_storage=storage, in_table_name='data') }) elif key == "building": resources.merge({ key: BuildingDataset(in_storage=storage, in_table_name='data') }) else: resources.merge({key: data_dictionary[key]}) if dataset in self.interactions: if dataset == "household_x_gridcell": resources.merge({ "dataset": HouseholdXGridcellDataset(dataset1=resources["household"], dataset2=resources["gridcell"]) }) if dataset == "job_x_gridcell": resources.merge({ "dataset": JobXGridcellDataset(dataset1=resources["job"], dataset2=resources["gridcell"]) }) if dataset == "household_x_zone": resources.merge({ "dataset": HouseholdXZoneDataset(dataset1=resources["household"], dataset2=resources["zone"]) }) if dataset == "household_x_neighborhood": resources.merge({ "dataset": HouseholdXNeighborhoodDataset( dataset1=resources["household"], dataset2=resources["neighborhood"]) }) if dataset == "development_project_x_gridcell": resources.merge({ "dataset": DevelopmentProjectXGridcellDataset( dataset1=resources["development_project"], dataset2=resources["gridcell"]) }) else: resources.merge({"dataset": resources[dataset]}) resources.merge({"check_variables": '*', "debug": 4}) return resources