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) }