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(['foo', 'commercial'])
}
)
building_types = BuildingTypeDataset(in_storage=storage, in_table_name=building_types_table_name)
values = VariableTestToolbox().compute_variable(self.variable_name,
data_dictionary = {
'zone':{
'zone_id':array([1,2,3,4]),
},
'building': {
'building_type_id': array([1,2,1,2,1,1]),
'zone_id': array([2,3,1,1,2,1])
},
'building_type': building_types
},
dataset = 'zone'
)
should_be = array([0, 0, 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([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 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([1, 2]),
'name':
array(['residential', 'commercial']),
'units':
array(['residential_units', 'commercial_sqft'])
})
building_types = BuildingTypeDataset(
in_storage=storage, in_table_name=building_types_table_name)
values = VariableTestToolbox().compute_variable(
self.variable_name,
data_dictionary={
'zone': {
'zone_id': array([1, 2])
},
'gridcell': {
'developable_maximum_commercial_sqft':
array([1200, 16, 3900, 15]),
'zone_id':
array([1, 1, 2, 2])
},
'building_type': building_types
},
dataset='zone')
should_be = array([1216, 3915])
self.assert_(ma.allequal(values, should_be),
'Error in ' + self.variable_name)
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_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 __init__ (self, *args, **kwargs):
BuildingTypeDataset.__init__(self, *args, **kwargs)
self.add_elements(data={self.get_id_name()[0]:array([self.get_id_attribute().max()+1]),
"name": array(["vacant_land"])}, require_all_attributes=False)
def __init__ (self, *args, **kwargs):
BuildingTypeDataset.__init__(self, *args, **kwargs)
self.add_elements(data={self.get_id_name()[0]:array([self.get_id_attribute().max()+1]),
"name": array(["vacant_land"])}, require_all_attributes=False)
