def setUp(self):
TestWithAttributeData.setUp(self)
self.cross_scenario_source_data = SourceData(
cache_directory=self.temp_cache_path,
comparison_cache_directory=self.temp_cache_path2,
years=[1980],
dataset_pool_configuration=DatasetPoolConfiguration(
package_order=['opus_core'], ))
self.source_data = SourceData(
cache_directory=self.temp_cache_path,
years=[1980],
dataset_pool_configuration=DatasetPoolConfiguration(
package_order=['opus_core'], ))
def __my_configuration(self):
tables_to_cache = [
# 'business',
'households',
'buildings',
'parcels',
'zones',
# "households_for_estimation"
]
return {
'cache_directory' : r'/home/lmwang/work/sf/cache_source_0125', # change or leave out
'creating_baseyear_cache_configuration':CreatingBaseyearCacheConfiguration(
# cache_directory_root = '/tmp/urbcache/sandbox_runs/estimation',
unroll_gridcells = False,
cache_from_database = True,
baseyear_cache = BaseyearCacheConfiguration(
existing_cache_to_copy = r'/urbansim_cache/sanfrancisco/cache_source',
),
cache_scenario_database = 'urbansim.model_coordinators.cache_scenario_database',
tables_to_cache = tables_to_cache,
tables_to_copy_to_previous_years = {},
),
'scenario_database_configuration': ScenarioDatabaseConfiguration(
database_name = 'sanfrancisco_baseyear_start',
),
'estimation_database_configuration': EstimationDatabaseConfiguration(
database_name = 'sanfrancisco_baseyear_change_20080121',
),
'dataset_pool_configuration': DatasetPoolConfiguration(
package_order=['sanfrancisco', 'urbansim', 'opus_core'],
),
'base_year': 2001,
}
def go():
from opus_gui.results_manager.run.indicator_framework.representations.indicator import Indicator
import os
indicators = {
'zone_jobs':
Indicator(dataset_name='zone',
attribute='urbansim.zone.number_of_jobs')
}
from opus_core.configurations.dataset_pool_configuration import DatasetPoolConfiguration
from opus_gui.results_manager.run.indicator_framework.maker.source_data import SourceData
project_name = 'eugene_gridcell'
run_name1 = 'base_year_data'
years = [1980, 1980]
source_data = SourceData(
cache_directory=paths.get_opus_data_path_path(project_name, run_name1),
#comparison_cache_directory = '',
years=years,
dataset_pool_configuration=DatasetPoolConfiguration(
package_order=['urbansim', 'opus_core'], ),
project_name=project_name)
################################################################
#COMPUTE indicators
################################################################
from opus_gui.results_manager.run.indicator_framework.maker.maker import Maker
maker = Maker(project_name)
computed_indicators = maker.create_batch(indicators=indicators,
source_data=source_data)
############################################
#VISUALIZE the resulting computed indicators
############################################
from opus_gui.results_manager.run.indicator_framework.visualizer.visualization_factory import VisualizationFactory
visualizer = VisualizationFactory()
visualizations = []
maps = [('zone_jobs', 'matplotlib_chart')]
for item in maps:
vistype = 'mapnik_map' # default to map
if type(item) == type(()): item, vistype = item
print "Generating indicator %s" % item
visualizations += visualizer.visualize(
indicators_to_visualize=[
item
], # override default indicators to visualize (all)
computed_indicators=computed_indicators,
visualization_type=vistype,
name=item)
print "Done generating indicators."
return dict((v.name, v.get_file_path()) for v in visualizations)
def __my_configuration(self):
tables_to_cache = Baseline(
)['creating_baseyear_cache_configuration'].tables_to_cache
tables_to_cache.append('workers_for_estimation')
return {
'cache_directory':
'D:/urbansim_cache/psrc/estimation', # change or leave out
'creating_baseyear_cache_configuration':
CreatingBaseyearCacheConfiguration(
# cache_directory_root = '/tmp/urbcache/sandbox_runs/estimation',
unroll_gridcells=True,
cache_from_database=True,
baseyear_cache=BaseyearCacheConfiguration(
existing_cache_to_copy=r'D:/urbansim_cache/full_psrc', ),
cache_scenario_database=
'urbansim.model_coordinators.cache_scenario_database',
tables_to_cache=tables_to_cache,
tables_to_cache_nchunks={
'parcels': 4,
'gridcells': 5
},
tables_to_copy_to_previous_years={},
),
'scenario_database_configuration':
ScenarioDatabaseConfiguration(
database_name='GSPSRC_2000_baseyear_change_20070102', ),
'dataset_pool_configuration':
DatasetPoolConfiguration(
package_order=['psrc', 'urbansim', 'opus_core'], ),
'base_year':
2000,
}
def __init__(self):
Baseline.__init__(self)
self['config_changes_for_estimation'] = ConfigChangesForEstimation()
## set base_year and years to 2006 for HLCM for the psrc_parcel project
#self['config_changes_for_estimation']['household_location_choice_model'].merge({'base_year': 2006, 'years':(2006, 2006)})
self['cache_directory'] = '/Users/hana/urbansim_cache/psrc/cache_source_parcel'
self['estimation_database_configuration'] = EstimationDatabaseConfiguration(
database_name = 'psrc_2005_parcel_baseyear_change_estimation',
)
self['dataset_pool_configuration'] = DatasetPoolConfiguration(
package_order=['psrc_parcel', 'psrc', 'urbansim_parcel', 'urbansim', 'opus_core'],
)
self['datasets_to_cache_after_each_model'] = []
self["datasets_to_preload"] = {
'zone':{},
'household':{},
'building':{},
'parcel':{'package_name':'urbansim_parcel'},
#'development_template': {'package_name':'urbansim_parcel'},
#'development_template_component': {'package_name':'urbansim_parcel'},
#"job_building_type":{}
'job':{},
'person':{'package_name':'urbansim_parcel'},
"building_type":{'package_name':'urbansim_parcel'},
'travel_data':{},
}
self['base_year'] = 2000
self['years'] = (2000,2000)
#self['low_memory_mode'] = True
if 'models_in_year' in self.keys():
del self['models_in_year']
def setUp(self):
self.temp_cache_path = tempfile.mkdtemp(prefix='opus_tmp')
self.temp_cache_path2 = tempfile.mkdtemp(prefix='opus_tmp')
self.attribute_vals = array([5, 6, 7, 8])
self.attribute_vals2 = array([50, 60, 70, 80])
self.id_vals = array([1, 2, 3, 4])
self.years = [1980, 1981, 1982]
for year in self.years:
self.add_attributes(year, self.attribute_vals,
self.attribute_vals2)
self.attribute_vals_diff = array([10, 12, 14, 16])
self.attribute_vals2_diff = array([100, 120, 140, 160])
self.add_attributes(1983, self.attribute_vals_diff,
self.attribute_vals2_diff)
self.dataset_state = {
'year': None,
'dataset_name': None,
'cache_directory': None
}
self.dataset_pool_configuration = DatasetPoolConfiguration(
package_order=['opus_core'], )
def make_zone_dbfs(cache_directory):
xmlconfig = XMLConfiguration(filename="sanfrancisco.xml",
default_directory=r'C:\opus\project_configs',
is_parent=False)
runconfig = xmlconfig.get_run_configuration("sanfrancisco_baseline2009",
merge_controllers=True)
tm_config = runconfig['travel_model_configuration']
print tm_config['urbansim_to_tm_variable_mapping']
travel_model_years = []
for key in tm_config.iterkeys():
if isinstance(key, int) and tm_config[key].has_key('year_dir'):
travel_model_years.append(key)
travel_model_years.sort()
zonedbfs_source_data = SourceData(
cache_directory=cache_directory,
run_description="Run description is used for what?",
years=travel_model_years,
dataset_pool_configuration=DatasetPoolConfiguration(
package_order=['sanfrancisco', 'urbansim', 'opus_core'], ),
)
attrs = []
for key, val in tm_config['urbansim_to_tm_variable_mapping'].iteritems():
key = key.replace(".", "_")
attrs.append("%s=%s" % (key, val))
attrs.extend([\
"pwac_bus=sanfrancisco.zone.bus_travel_time_weighted_access_by_population",
"pwac_exp=sanfrancisco.zone.exp_travel_time_weighted_access_by_population",
"pwac_lrt=sanfrancisco.zone.lrt_travel_time_weighted_access_by_population",
"pwac_bart=sanfrancisco.zone.bart_travel_time_weighted_access_by_population",
"pwac_hwy=sanfrancisco.zone.hwy_travel_time_weighted_access_by_population",
"ewac_bus=sanfrancisco.zone.bus_travel_time_weighted_access_to_employment",
"ewac_exp=sanfrancisco.zone.exp_travel_time_weighted_access_to_employment",
"ewac_lrt=sanfrancisco.zone.lrt_travel_time_weighted_access_to_employment",
"ewac_bart=sanfrancisco.zone.bart_travel_time_weighted_access_to_employment",
"ewac_hwy=sanfrancisco.zone.hwy_travel_time_weighted_access_to_employment",
"ttpw_bus=sanfrancisco.zone.bus_travel_time_to_751",
"ttpw_exp=sanfrancisco.zone.exp_travel_time_to_751",
"ttpw_lrt=sanfrancisco.zone.lrt_travel_time_to_751",
"ttpw_bart=sanfrancisco.zone.bart_travel_time_to_751",
"ttpw_hwy=sanfrancisco.zone.hwy_travel_time_to_751",
"d2powell=sanfrancisco.zone.dist_travel_time_to_751"
])
zonedbf_indicators = [
DatasetTable(source_data=zonedbfs_source_data,
dataset_name='zone',
name='zone Indicators',
output_type='dbf',
attributes=attrs)
]
IndicatorFactory().create_indicators(indicators=zonedbf_indicators,
display_error_box=False,
show_results=False)
def setUp(self):
TestWithAttributeData.setUp(self)
self.i_results = IndicatorResults()
self.i_results.indicator_documentation_mapping = {}
self.source_data = SourceData(
cache_directory=self.temp_cache_path,
run_description='(opus_core)',
dataset_pool_configuration=DatasetPoolConfiguration(
package_order=['opus_core'], ))
def test__integrity_checker(self):
try:
source_data = SourceData(
cache_directory=self.temp_cache_path,
years=[1980],
dataset_pool_configuration=DatasetPoolConfiguration(
package_order=['opus_core'], ))
except IntegrityError:
self.assertTrue(False)
'''don't have data available for year 1970'''
try:
source_data = SourceData(
cache_directory=self.temp_cache_path,
years=[1970],
dataset_pool_configuration=DatasetPoolConfiguration(
package_order=['opus_core'], ))
except IntegrityError:
pass
else:
self.assertTrue(False)
'''cache dir doesn't exist'''
try:
source_data = SourceData(
cache_directory='null',
years=[1980],
dataset_pool_configuration=DatasetPoolConfiguration(
package_order=['opus_core'], ))
except IntegrityError:
pass
else:
self.assertTrue(False)
'''comparison cache dir doesn't exist'''
try:
source_data = SourceData(
cache_directory=self.temp_cache_path,
comparison_cache_directory='null',
years=[1980],
dataset_pool_configuration=DatasetPoolConfiguration(
package_order=['opus_core'], ))
except IntegrityError:
pass
else:
self.assertTrue(False)
def setUp(self):
TestWithAttributeData.setUp(self)
self.source_data = SourceData(
cache_directory = self.temp_cache_path,
years = [1980],
run_id = -1,
name = 'test',
dataset_pool_configuration = DatasetPoolConfiguration(
package_order=['opus_core'],
)
)
def get_end_year_indicators(cache_directory,
run_description,
years=[2017, 2050],
base_year=2014):
source_data = SourceData(
cache_directory=cache_directory,
run_description=run_description,
years=years,
base_year=base_year,
dataset_pool_configuration=DatasetPoolConfiguration(
package_order=[
'psrc_parcel', 'urbansim_parcel', 'psrc', 'urbansim',
'opus_core'
],
package_order_exceptions={},
),
)
indicators = [
DatasetTable(
source_data=source_data,
dataset_name='building',
name='new_buildings',
attributes=[
'building.building_type_id', 'building.parcel_id',
'urbansim_parcel.building.unit_price',
'urbansim_parcel.building.residential_units',
'urbansim_parcel.building.non_residential_sqft',
'urbansim_parcel.building.year_built', 'building.template_id',
'urbansim_parcel.building.building_sqft'
],
exclude_condition='building.year_built<2015',
),
DatasetTable(
source_data=source_data,
dataset_name='parcel',
name='households_jobs',
attributes=[
'parcel.county_id', 'parcel.minority_id', 'parcel.poverty_id',
'households = urbansim_parcel.parcel.number_of_households',
'urbansim_parcel.parcel.population',
'urbansim_parcel.parcel.residential_units',
'urbansim_parcel.parcel.employment',
'non_home_based_employment = parcel.aggregate(psrc_parcel.building.number_of_non_home_based_jobs)',
'non_residential_sqft = parcel.aggregate(building.non_residential_sqft)',
'building_sqft = parcel.aggregate(urbansim_parcel.building.building_sqft)',
'psrc_parcel.parcel.job_capacity', 'parcel.plan_type_id',
'residential_units_base = parcel.aggregate(building.residential_units * (building.year_built < 2015))'
],
),
]
return indicators
def _get_dataset_pool_configuration(self):
# Grab the dataset_pool_configuration from <general>
package_order_list = self.project.find("general/dataset_pool_configuration/argument[@name='package_order']")
if package_order_list is None:
package_order = []
else:
package_order_list = package_order_list.text
package_order = [p.strip()[1:-1] for p in
package_order_list[1:-1].split(',')]
dataset_pool_configuration = DatasetPoolConfiguration(package_order)
return dataset_pool_configuration
def _get_estimation_changes(self):
return {
'cache_directory':
'C:/urbansim_cache/psrc/estimation', # change or leave out
'estimation_database_configuration':
EstimationDatabaseConfiguration(
database_name='GSPSRC_2000_baseyear_change_20070102', ),
'dataset_pool_configuration':
DatasetPoolConfiguration(
package_order=['psrc', 'urbansim', 'opus_core'], ),
'datasets_to_cache_after_each_model': [],
'low_memory_mode':
False,
'base_year':
2000,
'years': (2000, 2000),
}
def __my_configuration(self):
tables_to_cache = ['business',
'households',
'buildings',
'development_event_history',
'target_vacancies',
'annual_household_control_totals',
'annual_business_control_totals',
'annual_relocation_rates_for_business',
'annual_relocation_rates_for_households',
'household_characteristics_for_ht',
'parcels',
'zones',
"tracts",
"households_for_estimation",
"business_for_estimation",
"persons",
"travel_data",
"annual_relocation_rates_for_business",
"buildings_for_estimation",
"building_use",
"building_use_classification",
'urbansim_constants'
]
return {
'cache_directory' : r'/urbansim_cache/sanfrancisco/cache_source', # change or leave out
'creating_baseyear_cache_configuration':CreatingBaseyearCacheConfiguration(
# cache_directory_root = '/tmp/urbcache/sandbox_runs/estimation',
unroll_gridcells = False,
cache_from_database = True,
baseyear_cache = BaseyearCacheConfiguration(
existing_cache_to_copy = r'/urbansim_cache/sanfrancisco/cache_source',
),
cache_scenario_database = 'urbansim.model_coordinators.cache_scenario_database',
tables_to_cache = tables_to_cache,
tables_to_copy_to_previous_years = {},
),
'scenario_database_configuration': ScenarioDatabaseConfiguration(
database_name = 'sanfrancisco_baseyear',
),
'dataset_pool_configuration': DatasetPoolConfiguration(
package_order=['sanfrancisco', 'urbansim', 'opus_core'],
),
'base_year': 2001,
}
def __init__(self):
BaselineHana.__init__(self)
self['config_changes_for_estimation'] = ConfigChangesForEstimation()
self[
'cache_directory'] = '/Users/hana/urbansim_cache/psrc/parcel/relocation_models_estimation/cache_source_parcel'
self[
'estimation_database_configuration'] = EstimationDatabaseConfiguration(
database_name='psrc_activity2006_ver2_hana_est', )
self['dataset_pool_configuration'] = DatasetPoolConfiguration(
package_order=[
'psrc_parcel', 'psrc', 'urbansim_parcel', 'urbansim',
'opus_core'
], )
self['datasets_to_cache_after_each_model'] = []
self['years'] = (2000, 2000)
if 'models_in_year' in self.keys():
del self['models_in_year']
def test_one_indicator(self):
source_data = SourceData(
cache_directory = self.temp_dir,
run_description = 'test',
years = [self.year],
dataset_pool_configuration = DatasetPoolConfiguration(
package_order=['psrc','urbansim','opus_core'],
),
)
indicator_defs = [
Table(
attribute = 'psrc.large_area.average_land_value_for_plan_type_group_residential',
dataset_name = 'large_area',
source_data = source_data,
),
]
IndicatorFactory().create_indicators(
indicators = indicator_defs,
display_error_box = False,
show_results = False)
def __init__(self):
Baseline.__init__(self)
self['creating_baseyear_cache_configuration'].tables_to_cache.append(
'exogenous_relationships')
self['creating_baseyear_cache_configuration'].tables_to_cache.append(
'weather_exogenous')
self['creating_baseyear_cache_configuration'].tables_to_cache.append(
'consumption_re')
self['creating_baseyear_cache_configuration'].tables_to_cache.append(
'consumption_co')
self['creating_baseyear_cache_configuration'].tables_to_cache.append(
'consumption_mf')
tables_to_copy_to_previous_years = self[
'creating_baseyear_cache_configuration'].tables_to_copy_to_previous_years
for table_name, year in tables_to_copy_to_previous_years.iteritems():
tables_to_copy_to_previous_years[table_name] = 1995
self['cache_directory'] = 'c:/urbansim_cache/water_test'
self['dataset_pool_configuration'] = DatasetPoolConfiguration(
package_order=['waterdemand', 'psrc', 'urbansim', 'opus_core'], )
self[
'scenario_database_configuration'].database_name = 'bellevue_consump_agg_month_year'
in_table_name=persons_table_name)
persons.write_dataset(out_storage=out_storage,
out_table_name=persons_table_name)
if __name__ == '__main__':
config = Baseline()
config.replace(
{
'scenario_database_configuration':
ScenarioDatabaseConfiguration(
database_name='psrc_2005_parcel_baseyear', ),
'estimation_database_configuration':
EstimationDatabaseConfiguration(
database_name='psrc_2005_parcel_baseyear_change_20080219', ),
'dataset_pool_configuration':
DatasetPoolConfiguration(
package_order=['urbansim_parcel', 'urbansim', 'opus_core'], ),
'low_memory_mode':
False,
'cache_directory':
'/urbansim_cache/psrc_parcel/persons',
'debuglevel':
7,
'base_year':
2000,
'years': (2000, 2000),
}, )
# del config['estimation_database_configuration']['db_output_database']
ExpandPersons(config)
def test_run_estimation(self):
cache_dir = mkdtemp(prefix='test_washtenaw_run_estimation_tmp')
try:
# Cache to a temporary folder.
ev = (
'%s "%s" --cache-directory="%s" washtenaw.tests.test_run_estimation_config'
%
(sys.executable, create_baseyear_cache_script_path, cache_dir))
logger.log_status("Invoking '%s'" % ev)
return_code = os.system(ev)
if return_code > 0:
raise EnvironmentError(
'Failed while creating the baseyear cache '
'needed to run Washtenaw estimation tests.')
estimation_config = {
'cache_directory':
cache_dir,
'dataset_pool_configuration':
DatasetPoolConfiguration(
package_order=['washtenaw', 'urbansim', 'opus_core'], ),
'datasets_to_cache_after_each_model': [],
'low_memory_mode':
False,
'base_year':
2000,
'years': (2000, 2000),
}
failed = []
succeeded = []
for model_name in [
'lpm',
'hlcm',
'elcm-industrial',
'elcm-commercial',
# 'elcm-home_based', # fails
'dplcm-industrial',
'dplcm-commercial',
'dplcm-residential',
'rlsm',
]:
try:
self.estimation_runner.run_estimation(
estimation_config,
model_name,
save_estimation_results=False)
succeeded.append(model_name)
except:
logger.log_stack_trace()
failed.append(model_name)
if len(succeeded) > 0:
print 'Succeeded in estimating the following models: %s.' % ', '.join(
succeeded)
if len(failed) > 0:
self.fail('Failed to estimate the following models: %s.' %
', '.join(failed))
finally:
if os.path.exists(cache_dir):
rmtree(cache_dir)
def __init__(self):
config = PsrcParcelConfiguration()
config[
'creating_baseyear_cache_configuration'].cache_directory_root = r'/Users/hana/urbansim_cache/psrc/data_preparation/run_zipcodes'
config[
'creating_baseyear_cache_configuration'].baseyear_cache.existing_cache_to_copy = r'/Users/hana/urbansim_cache/psrc/data_preparation/cache_for_zipcodes'
#config['scenario_database_configuration'].database_name = 'psrc_2005_parcel_baseyear_data_prep_start'
config[
'scenario_database_configuration'].database_name = 'psrc_2005_parcel_baseyear_data_prep_business_zip'
config_changes = {
'description':
'data preparation for PSRC parcel (buildings)',
'flush_variables':
False,
'cache_directory':
'/Users/hana/urbansim_cache/psrc/data_preparation/cache_for_zipcodes',
'dataset_pool_configuration':
DatasetPoolConfiguration(package_order=[
'psrc_parcel', 'urbansim_parcel', 'urbansim', 'opus_core'
], ),
'base_year':
2000,
'years': (2001, 2003),
'models_in_year': {
2001: [
"employment_relocation_model", {
"employment_location_choice_model": {
"group_members": "_all_"
}
}
],
2002: [
"employment_relocation_model",
"governmental_employment_location_choice_model",
],
2003: [
"employment_relocation_model",
"governmental_employment_location_choice_model_without_filter"
]
},
"datasets_to_preload": {
'zone': {},
'job': {},
'building': {},
"job_building_type": {},
"zipcode": {}
},
"datasets_to_cache_after_each_model":
['parcel', 'building', 'job']
}
#use configuration in config as defaults and merge with config_changes
config.replace(config_changes)
self.merge(config)
self['models_configuration'][
'non_home_based_employment_location_choice_model'] = {}
self['models_configuration']['non_home_based_employment_location_choice_model']['controller'] = \
EmploymentLocationChoiceModelByZipcodesConfigurationCreator(
location_set = "building",
input_index = 'erm_index',
sampler = None,
records_per_chunk = 3000,
capacity_string = "urbansim_parcel.building.vacant_non_home_based_job_space",
number_of_units_string = None,
lottery_max_iterations=30
).execute()
self['models_configuration'][
'governmental_employment_location_choice_model'] = {}
self['models_configuration']['governmental_employment_location_choice_model']['controller'] = \
ScalingJobsModelByZipcodesConfigurationCreator(
location_set = "building",
input_index = 'erm_index',
filter = "urbansim_parcel.building.is_governmental"
).execute()
self['models_configuration']['governmental_employment_location_choice_model_without_filter'] = {}
self['models_configuration']['governmental_employment_location_choice_model_without_filter']['controller'] = \
ScalingJobsModelByZipcodesConfigurationCreator(
location_set = "building",
input_index = 'erm_index',
).execute()
self['models_configuration'][
'home_based_employment_location_choice_model'] = {}
self['models_configuration']['home_based_employment_location_choice_model']['controller'] = \
EmploymentLocationChoiceModelByZipcodesConfigurationCreator(
location_set = "building",
input_index = 'erm_index',
sampler = None,
capacity_string = "urbansim_parcel.building.vacant_home_based_job_space",
number_of_units_string = None,
lottery_max_iterations=30
).execute()
self['models_configuration']['employment_relocation_model']['controller'] = \
EmploymentRelocationModelConfigurationCreator(
location_id_name = 'building_id',
probabilities = None,
rate_table=None,
output_index = 'erm_index').execute()
def opusRun(progressCB,logCB,params):
params_dict = {}
for key, val in params.iteritems():
params_dict[str(key)] = str(val)
cache_directory = params_dict['cache_directory']
output_type = params_dict['output_type']
storage_location = params_dict['storage_location']
year = params_dict['year']
if output_type == '':
output_type = 'tab'
""" Prerequisite:
1. run buildingout_query.sql to create building_sqft_per_job_by_zone_generic_land_use_type_id table, or similar table for other geography
2. cache the table to the cache that needs to create buildout indicators for
3. get/create building_sqft_per_job_by_zone_generic_land_use_type_id_dataset.py (in urbansim_parcel/datasets)
4. active/planned/proposed projects are cached in development_project_proposals and development_project_proposal_components
5. add is_redevelopable attribute to parcel
"""
run_description = 'Create indicators for buildout analysis'
source_data = SourceData(
cache_directory = cache_directory,
run_description = run_description,
years = [int(year)],
dataset_pool_configuration = DatasetPoolConfiguration(
package_order=['psrc_parcel','urbansim_parcel','psrc', 'urbansim','opus_core'],
),
)
attrs_by_glu = []
# this loop create indicators for each generic_land_type from 1 to 8
for glu_id in range(3, 9):
attrs_by_glu += [
## existing
"existing_job_spaces_glu%s = zone.aggregate(parcel.aggregate(building.non_residential_sqft)) / zone.disaggregate(building_sqft_per_job_by_zone_generic_land_use_type_id.building_sqft_per_job_glu%s)" % (glu_id, glu_id),
## existing units/job spaces excluding redevelopable parcels
"existing_job_spaces_unredev_glu%s=zone.aggregate(parcel.aggregate(building.non_residential_sqft) * numpy.logical_not(urbansim_parcel.parcel.is_redevelopable).astype(int32) ) / zone.disaggregate(building_sqft_per_job_by_zone_generic_land_use_type_id.building_sqft_per_job_glu%s)" % (glu_id, glu_id),
## redevelopment
"redev_buildout_units_glu%s=zone.aggregate(urbansim_parcel.parcel.max_units_per_acre_capacity_for_generic_land_use_type_%s * parcel.parcel_sqft * (urbansim_parcel.parcel.is_redevelopable).astype(int32) )" % (glu_id, glu_id),
"redev_buildout_job_spaces_glu%s=zone.aggregate(urbansim_parcel.parcel.max_far_capacity_for_generic_land_use_type_%s * parcel.parcel_sqft * (urbansim_parcel.parcel.is_redevelopable).astype(int32) ) / zone.disaggregate(building_sqft_per_job_by_zone_generic_land_use_type_id.building_sqft_per_job_glu%s)" % (glu_id, glu_id, glu_id),
## active(status_id==1)/planned(status_id==3)/proposed(status_id==2)
"proposed_job_spaces_glu%s = zone.aggregate(development_project_proposal.aggregate(urbansim_parcel.development_project_proposal_component.units_proposed * (numpy.logical_not(urbansim_parcel.development_project_proposal_component.is_residential)).astype(int32)) * (urbansim_parcel.development_project_proposal.status_id==2).astype(int32), intermediates=[parcel] ) / zone.disaggregate(building_sqft_per_job_by_zone_generic_land_use_type_id.building_sqft_per_job_glu%s)" % (glu_id, glu_id),
## vacant/agriculture buildout
"va_buildout_glu%s = zone.aggregate( urbansim_parcel.parcel.max_units_per_acre_capacity_for_generic_land_use_type_%s * ( parcel.parcel_sqft / 43560.0 ) * ( parcel.number_of_agents(development_project_proposal) == 0) * numpy.logical_or( parcel.disaggregate(land_use_type.land_use_name)=='vacant', parcel.disaggregate(land_use_type.land_use_name)=='agriculture') )" % (glu_id, glu_id),
"va_buildout_job_spaces_glu%s = zone.aggregate( urbansim_parcel.parcel.max_far_capacity_for_generic_land_use_type_%s * parcel.parcel_sqft * ( parcel.number_of_agents(development_project_proposal) == 0) * numpy.logical_or( parcel.disaggregate(land_use_type.land_use_name)=='vacant', parcel.disaggregate(land_use_type.land_use_name)=='agriculture') ) / zone.disaggregate(building_sqft_per_job_by_zone_generic_land_use_type_id.building_sqft_per_job_glu%s)" % (glu_id, glu_id, glu_id),
]
for glu_id in range(1, 3):
attrs_by_glu += [
## existing
"existing_job_spaces_glu%s = zone.aggregate(parcel.aggregate(building.non_residential_sqft)) / zone.disaggregate(building_sqft_per_job_by_zone_generic_land_use_type_id.building_sqft_per_job_glu%s)" % (glu_id, glu_id),
## existing units/job spaces excluding redevelopable parcels
"existing_job_spaces_unredev_glu%s=zone.aggregate(parcel.aggregate(building.non_residential_sqft) * numpy.logical_not(urbansim_parcel.parcel.is_redevelopable).astype(int32) ) / zone.disaggregate(building_sqft_per_job_by_zone_generic_land_use_type_id.building_sqft_per_job_glu%s)" % (glu_id, glu_id),
## redevelopment
"redev_buildout_units_glu%s=zone.aggregate(urbansim_parcel.parcel.max_units_per_acre_capacity_for_generic_land_use_type_%s * parcel.parcel_sqft * (urbansim_parcel.parcel.is_redevelopable).astype(int32) )" % (glu_id, glu_id),
# "redev_buildout_job_spaces_glu%s=zone.aggregate(urbansim_parcel.parcel.max_far_capacity_for_generic_land_use_type_%s * parcel.parcel_sqft * (urbansim_parcel.parcel.is_redevelopable).astype(int32) ) / zone.disaggregate(building_sqft_per_job_by_zone_generic_land_use_type_id.building_sqft_per_job_glu%s)" % (glu_id, glu_id, glu_id),
## active(status_id==1)/planned(status_id==3)/proposed(status_id==2)
"proposed_job_spaces_glu%s = zone.aggregate(development_project_proposal.aggregate(urbansim_parcel.development_project_proposal_component.units_proposed * (numpy.logical_not(urbansim_parcel.development_project_proposal_component.is_residential)).astype(int32)) * (urbansim_parcel.development_project_proposal.status_id==2).astype(int32), intermediates=[parcel] ) / zone.disaggregate(building_sqft_per_job_by_zone_generic_land_use_type_id.building_sqft_per_job_glu%s)" % (glu_id, glu_id),
## vacant/agriculture buildout
"va_buildout_glu%s = zone.aggregate( urbansim_parcel.parcel.max_units_per_acre_capacity_for_generic_land_use_type_%s * ( parcel.parcel_sqft / 43560.0 ) * ( parcel.number_of_agents(development_project_proposal) == 0) * numpy.logical_or( parcel.disaggregate(land_use_type.land_use_name)=='vacant', parcel.disaggregate(land_use_type.land_use_name)=='agriculture') )" % (glu_id, glu_id),
# "va_buildout_job_spaces_glu%s = zone.aggregate( urbansim_parcel.parcel.max_far_capacity_for_generic_land_use_type_%s * parcel.parcel_sqft * ( parcel.number_of_agents(development_project_proposal) == 0) * numpy.logical_or( parcel.disaggregate(land_use_type.land_use_name)=='vacant', parcel.disaggregate(land_use_type.land_use_name)=='agriculture') ) / zone.disaggregate(building_sqft_per_job_by_zone_generic_land_use_type_id.building_sqft_per_job_glu%s)" % (glu_id, glu_id, glu_id),
]
indicators=[
DatasetTable(
attributes = [
### indicators don't need to iterate by generic_land_use_type
## existing
"existing_units = zone.aggregate(urbansim_parcel.parcel.residential_units)",
#"existing_job_spaces_glu1 = zone.aggregate(parcel.aggregate(building.non_residential_sqft)) / zone.disaggregate(building_sqft_per_job_by_zone_generic_land_use_type_id.building_sqft_per_job_glu1)",
## existing units/job spaces excluding redevelopable parcels
"existing_units_unredev=zone.aggregate(urbansim_parcel.parcel.residential_units * numpy.logical_not(urbansim_parcel.parcel.is_redevelopable).astype(int32) )",
#"existing_job_spaces_unredev_glu1=zone.aggregate(parcel.aggregate(building.non_residential_sqft) * numpy.logical_not(urbansim_parcel.parcel.is_redevelopable).astype(int32) ) / zone.disaggregate(building_sqft_per_job_by_zone_generic_land_use_type_id.building_sqft_per_job_glu1)",
## redevelopment
#"redev_buildout_units_glu1=zone.aggregate(urbansim_parcel.parcel.max_units_per_acre_capacity_for_generic_land_use_type_1 * parcel.parcel_sqft * (urbansim_parcel.parcel.is_redevelopable).astype(int32) )",
#"redev_buildout_job_spaces_glu1=zone.aggregate(urbansim_parcel.parcel.max_far_capacity_for_generic_land_use_type_1 * parcel.parcel_sqft * (urbansim_parcel.parcel.is_redevelopable).astype(int32) ) / zone.disaggregate(building_sqft_per_job_by_zone_generic_land_use_type_id.building_sqft_per_job_glu1)",
## active(status_id==1)/planned(status_id==3)/proposed(status_id==2)
"proposed_units = zone.aggregate(development_project_proposal.aggregate(urbansim_parcel.development_project_proposal_component.units_proposed * (urbansim_parcel.development_project_proposal_component.is_residential).astype(int32)) * (urbansim_parcel.development_project_proposal.status_id==2).astype(int32), intermediates=[parcel] )",
#"proposed_job_spaces_glu1 = zone.aggregate(development_project_proposal.aggregate(urbansim_parcel.development_project_proposal_component.units_proposed * (numpy.logical_not(urbansim_parcel.development_project_proposal_component.is_residential)).astype(int32)) * (urbansim_parcel.development_project_proposal.status_id==2).astype(int32), intermediates=[parcel] ) / zone.disaggregate(building_sqft_per_job_by_zone_generic_land_use_type_id.building_sqft_per_job_glu1)",
## vacant/agriculture buildout
#"va_buildout_glu1 = zone.aggregate( urbansim_parcel.parcel.max_units_per_acre_capacity_for_generic_land_use_type_1 * parcel.parcel_sqft * ( parcel.number_of_agents(development_project_proposal) == 0) * numpy.logical_or( parcel.disaggregate(land_use_type.land_use_name)=='vacant', parcel.disaggregate(land_use_type.land_use_name)=='agriculture') )",
#"va_buildout_job_spaces_glu1 = zone.aggregate( urbansim_parcel.parcel.max_far_capacity_for_generic_land_use_type_1 * parcel.parcel_sqft * ( parcel.number_of_agents(development_project_proposal) == 0) * numpy.logical_or( parcel.disaggregate(land_use_type.land_use_name)=='vacant', parcel.disaggregate(land_use_type.land_use_name)=='agriculture') ) / zone.disaggregate(building_sqft_per_job_by_zone_generic_land_use_type_id.building_sqft_per_job_glu1)",
] + attrs_by_glu,
dataset_name = 'zone',
source_data = source_data,
name = 'zone_buildout',
output_type = output_type,
storage_location = storage_location
),
]
IndicatorFactory().create_indicators(
indicators = indicators,
display_error_box = False,
show_results = False)
def __init__(self):
config = UrbansimParcelConfiguration()
if os.environ.has_key('OPUS_DATA_PATH'):
data_path_prefix = os.path.join(os.environ['OPUS_DATA_PATH'],
'psrc_parcel')
else:
data_path_prefix = os.path.join(os.environ['OPUS_HOME'],
'data/psrc_parcel')
config_changes = {
'project_name':
'psrc_parcel',
'description':
'PSRC parcel baseline',
'cache_directory':
os.path.join(data_path_prefix, 'base_year_data'),
'creating_baseyear_cache_configuration':
CreatingBaseyearCacheConfiguration(
cache_directory_root=os.path.join(data_path_prefix, 'runs'),
cache_from_database=False,
baseyear_cache=BaseyearCacheConfiguration(
years_to_cache=[2000],
#existing_cache_to_copy = r'/urbansim_cache/psrc_parcel/runs/cache_hh_persons_init',
existing_cache_to_copy=os.path.join(
data_path_prefix, 'base_year_data'),
),
cache_scenario_database=
'urbansim.model_coordinators.cache_scenario_database',
tables_to_cache=[
#'business',
'households',
'buildings',
'parcels',
'gridcells',
'zones',
"jobs",
"households_for_estimation",
"households_for_estimation_LAG1",
"jobs_for_estimation",
#"development_event_history",
"persons",
"persons_for_estimation",
"travel_data",
"building_types",
"job_building_types",
'urbansim_constants',
"target_vacancies",
"home_based_employment_location_choice_model_coefficients",
"home_based_employment_location_choice_model_specification",
"non_home_based_employment_location_choice_model_coefficients",
"non_home_based_employment_location_choice_model_specification",
"household_location_choice_model_coefficients",
"household_location_choice_model_specification",
"real_estate_price_model_coefficients",
"real_estate_price_model_specification",
"annual_household_control_totals",
"annual_relocation_rates_for_households",
"household_characteristics_for_ht",
"annual_employment_control_totals",
"annual_relocation_rates_for_jobs",
"land_use_types",
"generic_land_use_types",
'employment_sectors',
'employment_adhoc_sector_groups',
'employment_adhoc_sector_group_definitions',
'development_templates',
'development_template_components',
'development_constraints',
"building_sqft_per_job",
"fazes",
"large_areas",
"demolition_cost_per_sqft",
'constant_taz_columns',
'zipcodes',
'cities',
'districts',
'area_types',
"work_at_home_choice_model_coefficients",
"work_at_home_choice_model_specification",
"workplace_choice_model_for_resident_coefficients",
"workplace_choice_model_for_resident_specification",
"development_project_proposals",
"development_project_proposals_for_estimation",
"school_districts",
"tours",
## some attribute coding lookup tables
"education",
"employment_status",
"grade",
"race_names",
"relationship",
"sex",
"student",
],
tables_to_cache_nchunks={'parcels': 1},
unroll_gridcells=False),
'scenario_database_configuration':
ScenarioDatabaseConfiguration(
database_name='psrc_2005_parcel_baseyear',
#database_name = 'psrc_2005_parcel_baseyear_change_20080804E',
#database_name = 'psrc_2005_parcel_baseyear_change_lmwang',
),
'dataset_pool_configuration':
DatasetPoolConfiguration(package_order=[
'psrc_parcel', 'urbansim_parcel', 'urbansim', 'opus_core'
], ),
# 'models_configuration':models_configuration,
'base_year':
2000,
'years': (2001, 2030),
'models':
[ # models are executed in the same order as in this list
#"process_pipeline_events",
"real_estate_price_model",
"expected_sale_price_model",
"development_proposal_choice_model",
"building_construction_model",
"modify_workers_jobs_after_moving_households", # from demolished buildings
"modify_workers_jobs_after_moving_jobs", # from demolished buildings
"household_transition_model",
"employment_transition_model",
'job_person_consistency_keeper',
"household_relocation_model",
"household_location_choice_model",
"modify_workers_jobs_after_moving_households",
"employment_relocation_model",
#{"employment_location_choice_model":{'group_members': '_all_'}},
{
"employment_location_choice_model": {
'group_members': ['non_home_based']
}
},
'distribute_unplaced_jobs_model',
'distribute_unplaced_mining_utilities_jobs_model',
"modify_workers_jobs_after_moving_jobs",
'work_at_home_choice_model',
'workplace_choice_model_for_resident'
],
'models_in_year': {
2000:
[ # This is not run anymore, since all jobs are located and only a few households are not.
"household_relocation_model_for_2000",
"household_location_choice_model_for_2000",
"employment_relocation_model_for_2000", {
"employment_location_choice_model": {
'group_members': '_all_'
}
}
]
},
'flush_dataset_to_cache_after_each_model':
False,
'flush_variables':
False,
'low_memory_run':
False,
'datasets_to_cache_after_each_model': [
"parcel",
"building",
'household',
'job',
'development_project_proposal_component', #to be cached for diagnostic purpose (lmwang)
'development_project_proposal',
'travel_data',
'persons'
],
'unroll_gridcells':
False,
"datasets_to_preload": {
'zone': {},
'household': {},
'building': {},
'parcel': {
'package_name': 'urbansim_parcel'
},
'development_template': {
'package_name': 'urbansim_parcel'
},
'development_template_component': {
'package_name': 'urbansim_parcel'
},
'job': {},
'person': {
'package_name': 'urbansim_parcel'
},
"building_type": {
'package_name': 'urbansim_parcel'
},
'travel_data': {},
"job_building_type": {}
}
}
config.replace(config_changes)
config['models_configuration']["household_location_choice_model"]["controller"]["import"] = \
{"psrc_parcel.models.household_location_choice_model" : "HouseholdLocationChoiceModel"}
config['models_configuration']["employment_location_choice_model"]['controller']["import"] = \
{"psrc_parcel.models.employment_location_choice_model" : "EmploymentLocationChoiceModel"}
config['models_configuration']["home_based_employment_location_choice_model"]['controller']["import"] = \
{"psrc_parcel.models.employment_location_choice_model" : "EmploymentLocationChoiceModel"}
config['models_configuration'][
'household_relocation_model_for_2000'] = {}
config['models_configuration']['household_relocation_model_for_2000']['controller'] = \
HouseholdRelocationModelConfigurationCreator(
location_id_name = 'building_id',
probabilities = None,
rate_table=None,
output_index = 'hrm_index').execute()
config['models_configuration'][
'household_location_choice_model_for_2000'] = Configuration(
config['models_configuration']
['household_location_choice_model'])
config['models_configuration'][
'household_location_choice_model_for_2000']['controller']['run'][
'arguments']['chunk_specification'] = "{'nchunks':1}"
config['models_configuration'][
'household_location_choice_model_for_2000']['controller']['run'][
'arguments']['maximum_runs'] = 1
config['models_configuration'][
'employment_relocation_model_for_2000'] = {}
config['models_configuration']['employment_relocation_model_for_2000']['controller'] = \
EmploymentRelocationModelConfigurationCreator(
location_id_name = 'building_id',
probabilities = None,
rate_table=None,
output_index = 'erm_index').execute()
self.merge(config)
if self.multiple_runs:
self.sample_inputs()
def __init__(self):
opus_home = os.environ['OPUS_HOME']
config = UrbansimParcelConfiguration()
config_changes = {
'project_name':
'seattle_parcel',
'description':
'Seattle parcel baseline',
'cache_directory':
os.path.join(os.environ['OPUS_HOME'],
'data/vibe_parcel/base_year_data'),
'creating_baseyear_cache_configuration':
CreatingBaseyearCacheConfiguration(
cache_directory_root=os.path.join(os.environ['OPUS_HOME'],
'data/vibe_parcel/runs'),
cache_from_database=True,
baseyear_cache=BaseyearCacheConfiguration(
existing_cache_to_copy=os.path.join(
os.environ['OPUS_HOME'],
'data/vibe_gridcell/base_year_data'), ),
cache_scenario_database=
'urbansim.model_coordinators.cache_scenario_database',
tables_to_cache=[
'households', 'persons', 'buildings', 'parcels',
'gridcells', 'zones', "jobs", "households_for_estimation",
"jobs_for_estimation", "development_event_history",
"travel_data", "building_types", "job_building_types",
'urbansim_constants', "target_vacancies",
"home_based_employment_location_choice_model_coefficients",
"home_based_employment_location_choice_model_specification",
"non_home_based_employment_location_choice_model_coefficients",
"non_home_based_employment_location_choice_model_specification",
"household_location_choice_model_coefficients",
"household_location_choice_model_specification",
"real_estate_price_model_coefficients",
"real_estate_price_model_specification",
"annual_household_control_totals",
"annual_relocation_rates_for_households",
"household_characteristics_for_ht",
"annual_employment_control_totals",
"annual_relocation_rates_for_jobs", "land_use_types",
"generic_land_use_types", 'employment_sectors',
'employment_adhoc_sector_groups',
'employment_adhoc_sector_group_definitions',
'development_templates', 'development_template_components',
'development_constraints', "building_sqft_per_job",
"fazes", "large_areas", "demolition_cost_per_sqft",
'constant_taz_columns'
],
tables_to_cache_nchunks={'parcels': 1},
unroll_gridcells=False),
'scenario_database_configuration':
ScenarioDatabaseConfiguration(
database_name='urbansim_export_test', ),
'dataset_pool_configuration':
DatasetPoolConfiguration(
#package_order=['psrc_parcel', 'urbansim_parcel', 'urbansim', 'opus_core'],
#),
package_order=[
'psrc_parcel', 'urbansim_parcel', 'urbansim', 'opus_core'
], ),
'base_year':
1980,
'years': (1981, 1985),
'models':
[ # models are executed in the same order as in this list
#"process_pipeline_events", # uncomented by model
"real_estate_price_model",
"expected_sale_price_model",
"development_proposal_choice_model",
"building_construction_model",
"household_transition_model",
#"employment_transition_model",
"household_relocation_model",
"household_location_choice_model",
#"employment_relocation_model",
#{"employment_location_choice_model":{'group_members': '_all_'}},
#'distribute_unplaced_jobs_model'
],
'models_in_year': {
1980:
[ # This is not run anymore, since all jobs are located and only a few households are not.
"household_relocation_model_for_1980",
"household_location_choice_model_for_1980",
#"employment_relocation_model_for_1980",
#{"employment_location_choice_model":{'group_members': '_all_'}}
]
},
'flush_dataset_to_cache_after_each_model':
False,
'flush_variables':
False,
'low_memory_run':
False,
'datasets_to_cache_after_each_model': [
"parcel",
"building",
'household', #'job',
'development_project_proposal_component', #to be cached for diagnostic purpose (lmwang)
'development_project_proposal',
'travel_data'
],
'unroll_gridcells':
False,
"datasets_to_preload": {
'zone': {},
'household': {},
'building': {},
'parcel': {
'package_name': 'urbansim_parcel'
},
'person': {
'package_name': 'urbansim_parcel'
},
'development_template': {
'package_name': 'urbansim_parcel'
},
'development_template_component': {
'package_name': 'urbansim_parcel'
},
#'job':{},
"building_type": {
'package_name': 'urbansim_parcel'
},
'travel_data': {},
#"job_building_type":{}
}
}
config.replace(config_changes)
'''config['models_configuration']["household_location_choice_model"]["controller"]["import"] = \
{"psrc_parcel.models.household_location_choice_model" : "HouseholdLocationChoiceModel"}
config['models_configuration']["employment_location_choice_model"]['controller']["import"] = \
{"psrc_parcel.models.employment_location_choice_model" : "EmploymentLocationChoiceModel"}
config['models_configuration']["home_based_employment_location_choice_model"]['controller']["import"] = \
{"psrc_parcel.models.employment_location_choice_model" : "EmploymentLocationChoiceModel"}
config['models_configuration']['household_relocation_model_for_1980'] = {}
config['models_configuration']['household_relocation_model_for_1980']['controller'] = \
HouseholdRelocationModelConfigurationCreator(
location_id_name = 'building_id',
probabilities = None,
rate_table=None,
output_index = 'hrm_index').execute()
config['models_configuration']['household_location_choice_model_for_1980'] = Configuration(
config['models_configuration']['household_location_choice_model']
)
config['models_configuration']['household_location_choice_model_for_1980']['controller']['run']['arguments']['chunk_specification'] = "{'nchunks':1}"
config['models_configuration']['household_location_choice_model_for_1980']['controller']['run']['arguments']['maximum_runs'] = 1
config['models_configuration']['employment_relocation_model_for_1980'] = {}
config['models_configuration']['employment_relocation_model_for_1980']['controller'] = \
EmploymentRelocationModelConfigurationCreator(
location_id_name = 'building_id',
probabilities = None,
rate_table=None,
output_index = 'erm_index').execute()'''
if self.multiple_runs:
from multiple_runs_modification import MultipleRunsModification
MultipleRunsModification().modify_configuration(config)
self.merge(config)
def __init__(self):
UrbansimZoneConfiguration.__init__(self)
config_changes = {
'project_name':
'eugene_zone',
'description':
'Eugene zone baseline',
'base_year':
1980,
'years': (1981, 1985),
'debuglevel':
4,
'models': [
'real_estate_price_model',
'development_project_transition_model',
'commercial_development_project_location_choice_model',
'industrial_development_project_location_choice_model',
'residential_development_project_location_choice_model',
'add_projects_to_buildings',
'household_transition_model',
'employment_transition_model',
'household_relocation_model',
'household_location_choice_model',
'employment_relocation_model',
{
'employment_location_choice_model': {
'group_members': '_all_'
}
},
'distribute_unplaced_jobs_model',
],
'scenario_database_configuration':
ScenarioDatabaseConfiguration(
database_name='eugene_1980_baseyear_zone'),
'cache_directory':
os.path.join(os.environ['OPUS_HOME'],
'data/eugene_zone/base_year_data'),
'creating_baseyear_cache_configuration':
CreatingBaseyearCacheConfiguration(
cache_directory_root=os.path.join(os.environ['OPUS_HOME'],
'data/eugene_zone/runs'),
cache_from_database=False,
baseyear_cache=BaseyearCacheConfiguration(
existing_cache_to_copy=os.path.join(
os.environ['OPUS_HOME'],
'data/eugene_zone/base_year_data')),
cache_scenario_database=
'urbansim.model_coordinators.cache_scenario_database',
tables_to_cache=[
'annual_employment_control_totals',
'annual_household_control_totals',
'households',
'job_building_types',
'building_types',
'jobs',
'travel_data',
'zones',
'pseudo_buildings',
'counties',
'commercial_development_location_choice_model_coefficients',
'commercial_development_location_choice_model_specification',
'commercial_employment_location_choice_model_coefficients',
'commercial_employment_location_choice_model_specification',
'home_based_employment_location_choice_model_specification',
'home_based_employment_location_choice_model_coefficients',
'industrial_employment_location_choice_model_coefficients',
'industrial_employment_location_choice_model_specification',
'industrial_development_location_choice_model_coefficients',
'industrial_development_location_choice_model_specification',
'residential_development_location_choice_model_coefficients',
'residential_development_location_choice_model_specification',
#'fazes',
'urbansim_constants',
'household_location_choice_model_coefficients',
'household_location_choice_model_specification',
'household_characteristics_for_ht',
'annual_relocation_rates_for_households',
'annual_relocation_rates_for_jobs',
'base_year',
'cities',
'development_event_history',
'employment_adhoc_sector_group_definitions',
'employment_adhoc_sector_groups',
'employment_sectors',
'race_names',
'target_vacancies',
'jobs_for_estimation',
'households_for_estimation',
],
unroll_gridcells=False),
'dataset_pool_configuration':
DatasetPoolConfiguration(package_order=[
'eugene_zone', 'eugene', 'urbansim_zone', 'urbansim',
'opus_core'
], ),
}
self.merge(config_changes)
def create_travel_model_input_file(self, config, year, *args, **kwargs):
""""""
logger.start_block('Starting GetCacheDataIntoMatsim.run(...)')
# # When this is called for the first time, the 'matsim_flag' is not there. Will be constructed here:
# if not 'matsim_flag' in persons.get_known_attribute_names():
# persons = SessionConfiguration().get_dataset_from_pool('person')
# persons_size = persons.size()
# sampling_rate = config['travel_model_configuration']['sampling_rate']
# matsim_flag = zeros(persons_size, dtype='int32')
# sampled_person_index = sample_noreplace( arange(persons_size),
# int(sampling_rate * persons_size),
# return_indices=True )
# matsim_flag[sampled_person_index] = 1
# persons.add_attribute(matsim_flag, 'matsim_flag', metadata=AttributeType.PRIMARY)
# persons.flush_attribute('matsim_flag')
# I guess this is access to the full urbansim cache data.
source_data = SourceData(
cache_directory=config['cache_directory'],
years=[year],
dataset_pool_configuration=DatasetPoolConfiguration(package_order=[
'psrc_parcel', 'urbansim_parcel', 'psrc', 'urbansim',
'opus_core'
], ),
)
output_root = os.path.join(os.environ['OPUS_HOME'], "opus_matsim")
if not os.path.exists(output_root):
try:
os.mkdir(output_root)
except:
pass
output_directory = os.path.join(os.environ['OPUS_HOME'], "opus_matsim",
"tmp")
if not os.path.exists(output_directory):
try:
os.mkdir(output_directory)
except:
pass
### PERSONS
export_indicators = [
DatasetTable(
attributes=[
'parcel_id_home = person.disaggregate(parcel.parcel_id, intermediates=[building,household])',
'parcel_id_work = person.disaggregate(parcel.parcel_id, intermediates=[building,job])',
],
dataset_name='person',
# exclude_condition = 'person.matsim_flag==0',
storage_location=output_directory,
source_data=source_data,
output_type='tab',
name='exported_indicators',
)
]
# This is (I assume) executing the export
IndicatorFactory().create_indicators(indicators=export_indicators,
display_error_box=False,
show_results=False)
### "FACILITIES"
export_indicators = [
DatasetTable(
attributes=[
'parcel.x_coord_sp',
'parcel.y_coord_sp',
'parcel.zone_id',
],
dataset_name='parcel',
storage_location=output_directory,
source_data=source_data,
output_type='tab',
name='exported_indicators',
)
]
IndicatorFactory().create_indicators(indicators=export_indicators,
display_error_box=False,
show_results=False)
logger.end_block()
def __init__(self):
config = UrbansimParcelConfiguration()
config_changes = {
'description':
'data preparation for PSRC parcel (buildings)',
'cache_directory':
None,
'creating_baseyear_cache_configuration':
CreatingBaseyearCacheConfiguration(
#cache_directory_root = r'/Users/hana/urbansim_cache/psrc/parcel',
cache_directory_root=r'/urbansim_cache/psrc_parcel',
#cache_directory_root = r'/workspace/urbansim_cache/psrc_parcel',
cache_from_database=False,
baseyear_cache=BaseyearCacheConfiguration(
#existing_cache_to_copy = r'/Users/hana/urbansim_cache/psrc/cache_source_parcel',
existing_cache_to_copy=
r'/urbansim_cache/psrc_parcel/cache_source',
#existing_cache_to_copy = r'/workspace/urbansim_cache/psrc_parcel/estimation',
years_to_cache=[2000]),
cache_scenario_database=
'urbansim.model_coordinators.cache_scenario_database',
),
'dataset_pool_configuration':
DatasetPoolConfiguration(package_order=[
'psrc_parcel', 'urbansim_parcel', 'urbansim', 'opus_core'
], ),
'base_year':
2000,
'years': (2001, 2001),
'models':
[ # models are executed in the same order as in this list
"expected_sale_price_model",
"development_proposal_choice_model",
"building_construction_model",
],
"datasets_to_preload": {
'zone': {},
'household': {},
'building': {},
#'development_project_proposal': {}
},
"datasets_to_cache_after_each_model": [
'parcel', 'building', 'development_project_proposal',
'household', 'job'
]
}
#use configuration in config as defaults and merge with config_changes
config.replace(config_changes)
self.merge(config)
self['models_configuration']['development_proposal_choice_model'][
'controller']["import"] = {
"psrc_parcel.models.development_proposal_sampling_model_by_zones":
"DevelopmentProposalSamplingModelByZones"
}
self['models_configuration']['development_proposal_choice_model']['controller']["init"]["name"] =\
"DevelopmentProposalSamplingModelByZones"
self['models_configuration']['development_proposal_choice_model'][
'controller']['run']['arguments']["zones"] = 'zone'
self['models_configuration']['development_proposal_choice_model'][
'controller']['run']['arguments']["type"] = "'non_residential'"
self['models_configuration']['expected_sale_price_model'][
'controller']["init"]['arguments'][
"filter_attribute"] = "'urbansim_parcel.development_project_proposal.is_size_fit'"
self['models_configuration']['expected_sale_price_model']['controller']["prepare_for_run"]['arguments']["parcel_filter"] = \
"'numpy.logical_and(numpy.logical_or(numpy.logical_not(urbansim_parcel.parcel.is_residential_land_use_type), numpy.logical_and(parcel.land_use_type_id==26, urbansim_parcel.parcel.is_non_residential_plan_type)), urbansim_parcel.parcel.vacant_land_area > 0)'"
#"'numpy.logical_or(parcel.land_use_type_id==26, numpy.logical_and(urbansim_parcel.parcel.is_residential_land_use_type, urbansim_parcel.parcel.vacant_land_area > 0))'"
self['models_configuration']['building_construction_model'][
'controller']["run"]['arguments'][
"consider_amount_built_in_parcels"] = False
self['models_configuration']['building_construction_model'][
'controller']['run']['arguments']["current_year"] = 2000
def _import_indicator_from_file(self, file_path):
'''creates and returns an indicator from the file pointed to in file_path
'''
#TODO: If the additional child parameters are not strings, the current implementation will fail.
f = open(file_path)
version = f.readline()
indicator_class = f.readline().strip()
indicator_class = indicator_class[1:-1]
in_source_data = False
source_data_params = {}
non_constructor_attr = {
'date_computed': None
}
params = {}
for line in f.readlines():
line = line.strip()
if line == '<source_data>':
in_source_data = True
elif line == '</source_data>':
in_source_data = False
elif line != '</%s>'%indicator_class:
(name, value) = self._extract_name_and_value(line)
#TODO: figure out way for each object to know which values to
#reinterpret from string
if name == 'years' or name == 'scale':
if value == 'None' or value == '[]':
value = []
elif name=='scale':
value = [float(y) for y in value[1:-1].split(',')]
elif name=='years':
value = [int(y) for y in value[1:-1].split(',')]
elif name == 'attributes':
if value == 'None' or value == '[]':
value = []
else:
value = [attr.strip().replace("'",'') for attr in value[1:-1].split(';')]
if in_source_data:
if name == 'package_order':
order = [eval(p.strip()) for p in value[1:-1].split(',')]
pool = DatasetPoolConfiguration(
package_order = order,
)
source_data_params['dataset_pool_configuration'] = pool
else:
source_data_params[name] = value
else:
if name == 'dataset_name':
params['dataset_name'] = value
elif name in non_constructor_attr:
non_constructor_attr[name] = value
else:
params[name] = value
f.close()
cache_directory = os.path.split(os.path.dirname(file_path).split()[0])[0]
source_data_params['cache_directory'] = cache_directory
indicator = self._create_indicator(indicator_class,
params,
non_constructor_attr,
source_data_params)
return indicator
#cache_directory = r'D:\urbansim_cache\run_1090.2006_11_14_12_12'
cache_directory = r'C:\cache\run_1090.2006_11_14_12_12'
run_description = '(run 1453 - travel data from full travel model)'
#cache_directory = r'Y:\urbansim_cache\run_1431.2006_12_08_09_45'
#run_description = '(run 1431 - baseyear travel data from travel model run)'
#cache_directory = r'D:\urbansim_cache\run_1154.2006_11_17_20_06'
#run_description = '(run 1154 - no ugb + double highway capacity 11/28/2006)'
#cache_directory = r'D:\urbansim_cache\run_1155.2006_11_17_20_07'
#run_description = '(run 1155 - no ugb 11/28/2006)'
source_data = SourceData(
cache_directory = cache_directory,
run_description = run_description,
years = [2000],
dataset_pool_configuration = DatasetPoolConfiguration(
package_order=['psrc','urbansim','opus_core'],
),
)
single_year_requests = [
DatasetTable(
years = [2000],
source_data = source_data,
dataset_name = 'zone',
name = 'pop_and_ind_sqft',
attributes = [
'urbansim.zone.population',
'urbansim.zone.industrial_sqft',
],
#exclude_condition = '==0' #exclude_condition now accepts opus expressions
),
from opus_core.indicator_framework.image_types.matplotlib_chart import Chart
from opus_core.indicator_framework.image_types.table import Table
from opus_core.indicator_framework.image_types.geotiff_map import GeotiffMap
from opus_core.indicator_framework.image_types.dataset_table import DatasetTable
from opus_core.indicator_framework.image_types.matplotlib_lorenzcurve import LorenzCurve
run_description = '(baseline 06/28/2007)'
cache_directory = r'/Volumes/Data/opus/data/sanfrancisco/runs/run_2.2008_12_30_13_34'
source_data = SourceData(
cache_directory = cache_directory,
run_description = run_description,
years = [2001, 2002, 2005, 2007, 2010, 2020, 2030],
dataset_pool_configuration = DatasetPoolConfiguration(
package_order=['sanfrancisco','urbansim','opus_core'],
),
)
single_year_requests = [
DatasetTable(
source_data = source_data,
dataset_name = 'census_tract',
name = 'Tract Indicators',
output_type='csv',
attributes = [
'households_with_0_workers=census_tract.aggregate(sanfrancisco.building.number_of_households_with_0_workers, intermediates=[parcel])',
'households_with_1_worker =census_tract.aggregate(sanfrancisco.building.number_of_households_with_1_workers, intermediates=[parcel])',
'households_with_2_workers=census_tract.aggregate(sanfrancisco.building.number_of_households_with_2_workers, intermediates=[parcel])',
'households_with_3_workers=census_tract.aggregate(sanfrancisco.building.number_of_households_with_3_workers, intermediates=[parcel])',
'households_with_4_workers=census_tract.aggregate(sanfrancisco.building.number_of_households_with_4_workers, intermediates=[parcel])',
def __my_configuration(self):
# tables_to_cache = Baseline()['creating_baseyear_cache_configuration'].tables_to_cache
tables_to_cache =[
#'development_event_history',
'edges',
'parcels',
'gridcells',
'households',
'households_for_estimation',
'jobs',
'travel_data',
'persons', #need to cache
'persons_for_estimation',
'zones',
'cities',
'buildings',
'building_types',
'urbansim_constants',
'job_building_types',
'tours',
#'land_price_model_coefficients',
#'land_price_model_specification',]
]
return {
'cache_directory' : 'C:/tmp/urbansim_cache/psrc_parcel', # change or leave out
'creating_baseyear_cache_configuration':CreatingBaseyearCacheConfiguration(
# cache_directory_root = '/tmp/urbcache/sandbox_runs/estimation',
unroll_gridcells = False,
cache_from_database = True,
baseyear_cache = BaseyearCacheConfiguration(
existing_cache_to_copy = r'D:/urbansim_cache/full_psrc',
),
cache_scenario_database = 'urbansim.model_coordinators.cache_scenario_database',
tables_to_cache = tables_to_cache,
tables_to_cache_nchunks = {
'parcels':8,
'gridcells':5,
'buildings':10,
},
# tables_to_copy_to_previous_years = {
# 'development_type_groups': 1995,
# 'development_types': 1995,
# 'development_type_group_definitions': 1995,
# 'development_constraints': 1995,
# 'urbansim_constants': 1995,
# },
),
'scenario_database_configuration': ScenarioDatabaseConfiguration(
database_name = "psrc_activity2006_ver2" # 2006 PSRC Activity Survey for households_for_estimation,
),
'estimation_database_configuration':EstimationDatabaseConfiguration(
database_name = 'PSRC_2000_parcels_estimation_output',
),
'dataset_pool_configuration': DatasetPoolConfiguration(
package_order=['psrc', 'urbansim', 'opus_core'],
),
'base_year': 2000,
'years': (2000,2000),
'datasets_to_preload' :{
'gridcell':{
'package_name':'urbansim',
'nchunks':2,
},
'parcel':{
'package_name':'psrc',
'nchunks':3,
},
'household':{
'package_name':'urbansim',
},
'person':{
'package_name':'psrc',
},
'zone':{
'package_name':'urbansim',
},
'travel_data':{
'package_name':'urbansim',
},
'building':{
'package_name':'urbansim',
},
# 'edge':{
# 'package_name':'transit_accessibility',
# }
},
'seed':1,#(1,1)
}