コード例 #1
0
ファイル: ual.py プロジェクト: wsp-sag/bayarea_urbansim
def correct_alternative_filters_sample(residential_units, households, tenure):
    """
    Creates modified versions of the alternatives and choosers Orca tables
    (residential units and households), so that the parameters that will be
    given to the hlcm_simulate() method are already filtered with the
    alternative filters defined in the hlcm_owner and hlcm_renter yaml files.

    Parameters
    ----------
    residential_units: Orca table
    households: Orca table
    tenure: str, 'rent' or 'own'

    Returns
    -------
    None. New tables of residential units and households by tenure segment
    are registered in Orca, with broadcasts linking them to each other and
    to the 'buildings' table.

    """
    units = residential_units.to_frame()
    units_tenure = units[units.tenure == tenure]
    units_name = tenure + '_units'
    orca.add_table(units_name, units_tenure, cache=True, cache_scope='step')

    hh = households.to_frame()
    hh_tenure = hh[hh.tenure == tenure]
    hh_name = tenure + '_hh'
    orca.add_table(hh_name, hh_tenure, cache=True, cache_scope='step')

    orca.broadcast('buildings',
                   units_name,
                   cast_index=True,
                   onto_on='building_id')
    orca.broadcast(units_name, hh_name, cast_index=True, onto_on='unit_id')
コード例 #2
0
def tours(non_mandatory_tours, mandatory_tours, tdd_alts):

    non_mandatory_df = non_mandatory_tours.local
    mandatory_df = mandatory_tours.local

    # don't expect indexes to overlap
    assert len(non_mandatory_df.index.intersection(mandatory_df.index)) == 0

    # expect non-overlapping indexes (so the tripids dont change)
    assert len(
        np.intersect1d(non_mandatory_df.index,
                       mandatory_df.index,
                       assume_unique=True)) == 0

    tours = pd.concat(
        [non_mandatory_tours.to_frame(),
         mandatory_tours.to_frame()],
        ignore_index=False)

    # go ahead here and add the start, end, and duration here for future use
    chosen_tours = tdd_alts.to_frame().loc[tours.tour_departure_and_duration]
    chosen_tours.index = tours.index

    df = pd.concat([tours, chosen_tours], axis=1)
    assert df.index.name == 'tour_id'

    # replace table function with dataframe
    orca.add_table('tours', df)

    return df
コード例 #3
0
def summarize(pets_merged, history, iter_var):

    pets_row = pets_merged.to_frame()[['pet_name', 'age', 'pet_activity_names']]
    pets_row['timestamp'] = iter_var

    df = history.to_frame().append(pets_row, ignore_index=True)
    orca.add_table(history.name, df)
コード例 #4
0
ファイル: models.py プロジェクト: apdjustino/urbansim_old
def scheduled_development_events(buildings, scheduled_development_events, year):

    sched_dev = scheduled_development_events.to_frame()
    print sched_dev
    sched_dev = sched_dev[sched_dev.year_built == year]
    sched_dev["residential_sqft"] = sched_dev.sqft_per_unit * sched_dev.residential_units
    sched_dev["job_spaces"] = sched_dev.non_residential_sqft / 400
    sched_dev = sched_dev.rename(
        columns={"development_type_id": "building_type_id", "nonres_rent_per_sqft": "unit_price_non_residential"}
    )
    sched_dev["tax_exempt"] = 0
    sched_dev["land_area"] = 0
    sched_dev["bldg_sq_ft"] = sched_dev["residential_sqft"] + sched_dev["non_residential_sqft"]
    sched_dev["unit_price_residential"] = (
        sched_dev["res_price_per_sqft"] * sched_dev["residential_sqft"] / sched_dev.residential_units
    )

    if len(sched_dev) > 0:
        max_bid = buildings.index.values.max()
        idx = np.arange(max_bid + 1, max_bid + len(sched_dev) + 1)
        sched_dev["building_id"] = idx
        sched_dev = sched_dev.set_index("building_id")
        from urbansim.developer.developer import Developer

        merge = Developer(pd.DataFrame({})).merge
        b = buildings.to_frame(buildings.local_columns)
        all_buildings = merge(b, sched_dev[b.columns])
        orca.add_table("buildings", all_buildings)
コード例 #5
0
ファイル: slr.py プロジェクト: urbansim/bayarea_urbansim
def slr_inundate(scenario, parcels, slr_progression_C, slr_progression_R,
                 slr_progression_B, year, slr_parcel_inundation, settings):

    if scenario not in settings["slr_scenarios"]["enable_in"]:
        return

    if scenario in settings["slr_scenarios"]["rtff"]:
        slr_progression = slr_progression_R.to_frame()
    elif scenario in settings["slr_scenarios"]["cag"]:
        slr_progression = slr_progression_C.to_frame()
    elif scenario in settings["slr_scenarios"]["bttf"]:
        slr_progression = slr_progression_B.to_frame()

    orca.add_table("slr_progression", slr_progression)
    inundation_yr = slr_progression.query('year==@year')['inundated'].item()
    print "Inundation in model year is %d inches" % inundation_yr
    slr_parcel_inundation = slr_parcel_inundation.to_frame()
    destroy_parcels = slr_parcel_inundation.\
        query('inundation<=@inundation_yr').astype('bool')
    orca.add_table('destroy_parcels', destroy_parcels)
    print "Number of parcels destroyed: %d" % len(destroy_parcels)

    slr_nodev = pd.Series(False, parcels.index)
    destroy = pd.Series(destroy_parcels['inundation'])
    slr_nodev.update(destroy)
    orca.add_column('parcels', 'slr_nodev', slr_nodev)
    parcels = orca.get_table("parcels")
コード例 #6
0
ファイル: utils.py プロジェクト: SANDAG/urbansim_defaults
def _remove_developed_buildings(old_buildings, new_buildings, unplace_agents):
    redev_buildings = old_buildings.parcel_id.isin(new_buildings.parcel_id)
    l = len(old_buildings)
    drop_buildings = old_buildings[redev_buildings]

    if "dropped_buildings" in orca.orca._TABLES:
        prev_drops = orca.get_table("dropped_buildings").to_frame()
        orca.add_table("dropped_buildings", pd.concat([drop_buildings, prev_drops]))
    else:
        orca.add_table("dropped_buildings", drop_buildings)

    old_buildings = old_buildings[np.logical_not(redev_buildings)]
    l2 = len(old_buildings)
    if l2-l > 0:
        print "Dropped {} buildings because they were redeveloped".\
            format(l2-l)

    for tbl in unplace_agents:
        agents = orca.get_table(tbl).local
        displaced_agents = agents.building_id.isin(drop_buildings.index)
        print "Unplaced {} before: {}".format(tbl, len(agents.query(
                                              "building_id == -1")))
        agents.building_id[displaced_agents] = -1
        print "Unplaced {} after: {}".format(tbl, len(agents.query(
                                             "building_id == -1")))

    return old_buildings
コード例 #7
0
def _remove_developed_buildings(old_buildings, new_buildings, unplace_agents):
    redev_buildings = old_buildings.parcel_id.isin(new_buildings.parcel_id)
    l = len(old_buildings)
    drop_buildings = old_buildings[redev_buildings]

    if "dropped_buildings" in orca.orca._TABLES:
        prev_drops = orca.get_table("dropped_buildings").to_frame()
        orca.add_table("dropped_buildings", pd.concat([drop_buildings, prev_drops]))
    else:
        orca.add_table("dropped_buildings", drop_buildings)

    old_buildings = old_buildings[np.logical_not(redev_buildings)]
    l2 = len(old_buildings)
    if l2-l > 0:
        print "Dropped {} buildings because they were redeveloped".\
            format(l2-l)

    for tbl in unplace_agents:
        agents = orca.get_table(tbl).local
        displaced_agents = agents.building_id.isin(drop_buildings.index)
        print "Unplaced {} before: {}".format(tbl, len(agents.query(
                                              "building_id == -1")))
        agents.building_id[displaced_agents] = -1
        print "Unplaced {} after: {}".format(tbl, len(agents.query(
                                             "building_id == -1")))

    return old_buildings
コード例 #8
0
ファイル: models.py プロジェクト: ual/ual_model_workspace
def network_aggregations_small(netsmall):
    """
    This will be turned into a network aggregation template.
    """
    nodessmall = networks.from_yaml(netsmall,
                                    'network_aggregations_small.yaml')
    nodessmall = nodessmall.fillna(0)

    # new variables
    print('compute additional aggregation variables')
    nodessmall['pop_jobs_ratio_10000'] = (nodessmall['pop_10000'] /
                                          (nodessmall['jobs_10000'])).fillna(0)
    nodessmall['pop_jobs_ratio_25000'] = (nodessmall['pop_25000'] /
                                          (nodessmall['jobs_25000'])).fillna(0)
    # fill inf and nan with median
    nodessmall['pop_jobs_ratio_10000'] = nodessmall[
        'pop_jobs_ratio_10000'].replace([np.inf, -np.inf], np.nan).fillna(
            nodessmall['pop_jobs_ratio_10000'].median)
    nodessmall['pop_jobs_ratio_25000'] = nodessmall[
        'pop_jobs_ratio_25000'].replace([np.inf, -np.inf], np.nan).fillna(
            nodessmall['pop_jobs_ratio_25000'].median)

    # end of addition

    print(nodessmall.describe())
    orca.add_table('nodessmall', nodessmall)
コード例 #9
0
def load_tables(h5, year, tables=None):
    """
    Loads tables for the desired year and registers them with orca.

    Parameters:
    -----------
    h5: str
        full path to the h5 file containing the results.
    year: int or str
        Year to grab tables for. Provide 'base' for the base year.
    tables: list of str, default None
        List of tables to load. If None, all tables in that year
        will be loaded.

    """
    with pd.HDFStore(h5, mode='r') as store:

        # grab all the table names in the current year
        if tables is None:
            tables = [
                t.split('/')[-1] for t in store.keys()
                if t.startswith('/{}'.format(year))
            ]

        elif not isinstance(tables, list):
            tables = [tables]

        # read in the table and register it with orca
        for t in tables:
            df = df = store['{}/{}'.format(year, t)]
            orca.add_table(t, df)
コード例 #10
0
ファイル: inject.py プロジェクト: albabnoor/activitysim
def reinject_decorated_tables():
    """
    reinject the decorated tables (and columns)
    """

    logger.info("reinject_decorated_tables")

    # need to clear any non-decorated tables that were added during the previous run
    _ORCA._TABLES.clear()
    _ORCA._COLUMNS.clear()
    _ORCA._TABLE_CACHE.clear()
    _ORCA._COLUMN_CACHE.clear()

    for name, func in _DECORATED_TABLES.items():
        logger.debug("reinject decorated table %s" % name)
        orca.add_table(name, func)

    for column_key, args in _DECORATED_COLUMNS.items():
        table_name, column_name = column_key
        logger.debug("reinject decorated column %s.%s" % (table_name, column_name))
        orca.add_column(table_name, column_name, args['func'], cache=args['cache'])

    for name, args in _DECORATED_INJECTABLES.items():
        logger.debug("reinject decorated injectable %s" % name)
        orca.add_injectable(name, args['func'], cache=args['cache'])
コード例 #11
0
ファイル: test_server.py プロジェクト: UDST/orca
def setup_orca(dfa, dfb, dfa_col, dfb_col, dfa_factor, dfb_factor):
    orca.add_injectable('a_factor', dfa_factor)

    @orca.injectable()
    def b_factor():
        return dfb_factor

    orca.add_table('dfa', dfa)

    @orca.table('dfb')
    def dfb_table():
        return dfb

    orca.add_column('dfa', 'acol', dfa_col)
    orca.add_column('dfb', 'bcol', dfb_col)

    @orca.column('dfa')
    def extra_acol(a_factor):
        return dfa_col * a_factor

    @orca.column('dfb')
    def extra_bcol(b_factor):
        return dfb_col * b_factor

    orca.broadcast('dfb', 'dfa', cast_on='a_id', onto_index=True)

    @orca.step()
    def test_step(dfa, dfb):
        pass
コード例 #12
0
def simple_transition(tbl, rate, location_fname):
    """
    Run a simple growth rate transition model on the table passed in

    Parameters
    ----------
    tbl : DataFrameWrapper
        Table to be transitioned
    rate : float
        Growth rate
    location_fname : str
        The field name in the resulting dataframe to set to -1 (to unplace
        new agents)

    Returns
    -------
    Nothing
    """
    transition = GrowthRateTransition(rate)
    df = tbl.to_frame(tbl.local_columns)

    print "%d agents before transition" % len(df.index)
    df, added, copied, removed = transition.transition(df, None)
    print "%d agents after transition" % len(df.index)

    df.loc[added, location_fname] = -1
    orca.add_table(tbl.name, df)
コード例 #13
0
def neighborhood_vars_first(store):
    # Since this is the first time running neighborhood_vars, take from preproc
    # to save time
    nodes = store['neighborhood_vars_preproc']

    print nodes.describe()
    orca.add_table("nodes", nodes)
コード例 #14
0
def subsidized_residential_feasibility(parcels, settings,
                                       add_extra_columns_func,
                                       parcel_sales_price_sqft_func,
                                       parcel_is_allowed_func,
                                       parcels_geography):

    kwargs = settings['feasibility'].copy()
    kwargs["only_built"] = False
    kwargs["forms_to_test"] = ["residential"]
    # step 1
    utils.run_feasibility(parcels, parcel_sales_price_sqft_func,
                          parcel_is_allowed_func, **kwargs)

    feasibility = orca.get_table("feasibility").to_frame()
    # get rid of the multiindex that comes back from feasibility
    feasibility = feasibility.stack(level=0).reset_index(level=1, drop=True)
    # join to parcels_geography for filtering
    feasibility = feasibility.join(parcels_geography.to_frame())

    # add the multiindex back
    feasibility.columns = pd.MultiIndex.from_tuples([
        ("residential", col) for col in feasibility.columns
    ])

    feasibility = policy_modifications_of_profit(feasibility, parcels)

    orca.add_table("feasibility", feasibility)

    df = orca.get_table("feasibility").to_frame()
    df = df.stack(level=0).reset_index(level=1, drop=True)
    df.to_csv("runs/run{}_feasibility_{}.csv".format(
        orca.get_injectable("run_number"), orca.get_injectable("year")))
コード例 #15
0
ファイル: slr.py プロジェクト: UDST/bayarea_urbansim
def slr_remove_dev(buildings, destroy_parcels, year, parcels,
                   households, jobs):
    slr_demolish = buildings.local[buildings.parcel_id.isin
                                   (destroy_parcels.index)]
    orca.add_table("slr_demolish", slr_demolish)

    print "Demolishing %d buildings" % len(slr_demolish)
    households = households.to_frame()
    hh_unplaced = households[households["building_id"] == -1]
    jobs = jobs.to_frame()
    jobs_unplaced = jobs[jobs["building_id"] == -1]
    l1 = len(buildings)
    buildings = utils._remove_developed_buildings(
        buildings.to_frame(buildings.local_columns),
        slr_demolish,
        unplace_agents=["households", "jobs"])
    households = orca.get_table("households")
    households = households.to_frame()
    hh_unplaced_slr = households[households["building_id"] == -1]
    hh_unplaced_slr = hh_unplaced_slr[~hh_unplaced_slr.index.isin
                                      (hh_unplaced.index)]
    orca.add_injectable("hh_unplaced_slr", hh_unplaced_slr)
    jobs = orca.get_table("jobs")
    jobs = jobs.to_frame()
    jobs_unplaced_slr = jobs[jobs["building_id"] == -1]
    jobs_unplaced_slr = jobs_unplaced_slr[~jobs_unplaced_slr.index.isin
                                          (jobs_unplaced.index)]
    orca.add_injectable("jobs_unplaced_slr", jobs_unplaced_slr)
    orca.add_table("buildings", buildings)
    buildings = orca.get_table("buildings")
    print "Demolished %d buildings" % (l1 - len(buildings))
コード例 #16
0
ファイル: utils.py プロジェクト: AZMAG/urbansim_defaults
def simple_transition(tbl, rate, location_fname):
    """
    Run a simple growth rate transition model on the table passed in

    Parameters
    ----------
    tbl : DataFrameWrapper
        Table to be transitioned
    rate : float
        Growth rate
    location_fname : str
        The field name in the resulting dataframe to set to -1 (to unplace
        new agents)

    Returns
    -------
    Nothing
    """
    transition = GrowthRateTransition(rate)
    df = tbl.to_frame(tbl.local_columns)

    print "%d agents before transition" % len(df.index)
    df, added, copied, removed = transition.transition(df, None)
    print "%d agents after transition" % len(df.index)

    df.loc[added, location_fname] = -1
    orca.add_table(tbl.name, df)
コード例 #17
0
def slr_remove_dev(buildings, destroy_parcels, year, parcels, households,
                   jobs):
    slr_demolish = buildings.local[buildings.parcel_id.isin(
        destroy_parcels.index)]
    orca.add_table("slr_demolish", slr_demolish)

    print "Demolishing %d buildings" % len(slr_demolish)
    households = households.to_frame()
    hh_unplaced = households[households["building_id"] == -1]
    jobs = jobs.to_frame()
    jobs_unplaced = jobs[jobs["building_id"] == -1]
    l1 = len(buildings)
    buildings = utils._remove_developed_buildings(
        buildings.to_frame(buildings.local_columns),
        slr_demolish,
        unplace_agents=["households", "jobs"])
    households = orca.get_table("households")
    households = households.to_frame()
    hh_unplaced_slr = households[households["building_id"] == -1]
    hh_unplaced_slr = hh_unplaced_slr[~hh_unplaced_slr.index.isin(hh_unplaced.
                                                                  index)]
    orca.add_injectable("hh_unplaced_slr", hh_unplaced_slr)
    jobs = orca.get_table("jobs")
    jobs = jobs.to_frame()
    jobs_unplaced_slr = jobs[jobs["building_id"] == -1]
    jobs_unplaced_slr = jobs_unplaced_slr[~jobs_unplaced_slr.index.
                                          isin(jobs_unplaced.index)]
    orca.add_injectable("jobs_unplaced_slr", jobs_unplaced_slr)
    orca.add_table("buildings", buildings)
    buildings = orca.get_table("buildings")
    print "Demolished %d buildings" % (l1 - len(buildings))
コード例 #18
0
ファイル: models.py プロジェクト: yonran/bayarea_urbansim
def price_vars(net):
    nodes2 = networks.from_yaml(net["walk"], "price_vars.yaml")
    nodes2 = nodes2.fillna(0)
    print nodes2.describe()
    nodes = orca.get_table('nodes')
    nodes = nodes.to_frame().join(nodes2)
    orca.add_table("nodes", nodes)
コード例 #19
0
def setup_orca(dfa, dfb, dfa_col, dfb_col, dfa_factor, dfb_factor):
    orca.add_injectable('a_factor', dfa_factor)

    @orca.injectable()
    def b_factor():
        return dfb_factor

    orca.add_table('dfa', dfa)

    @orca.table('dfb')
    def dfb_table():
        return dfb

    orca.add_column('dfa', 'acol', dfa_col)
    orca.add_column('dfb', 'bcol', dfb_col)

    @orca.column('dfa')
    def extra_acol(a_factor):
        return dfa_col * a_factor

    @orca.column('dfb')
    def extra_bcol(b_factor):
        return dfb_col * b_factor

    orca.broadcast('dfb', 'dfa', cast_on='a_id', onto_index=True)

    @orca.step()
    def test_step(dfa, dfb):
        pass
コード例 #20
0
def regional_vars_first(store):
    # Since this is the first time running regional_vars, take from preproc
    # to save time
    nodes = store['regional_vars_preproc']

    print nodes.describe()
    orca.add_table("tmnodes", nodes)
コード例 #21
0
def _remove_developed_buildings(old_buildings, new_buildings, unplace_agents):
    redev_buildings = old_buildings.parcel_id.isin(new_buildings.parcel_id)
    l = len(old_buildings)
    drop_buildings = old_buildings[redev_buildings]
    old_buildings = old_buildings[np.logical_not(redev_buildings)]
    l2 = len(old_buildings)
    if l2-l > 0:
        print "Dropped {} buildings because they were redeveloped".\
            format(l2-l)

    for tbl in unplace_agents:
        agents = orca.get_table(tbl)
        cols = agents.local_columns
        if "building_id" not in cols:
            # if it's a unit-level model, need to add building_id
            # explicitly
            cols += ["building_id"]
        agents = agents.to_frame(cols)
        displaced_agents = agents.building_id.isin(drop_buildings.index)
        print "Unplaced {} before: {}".format(tbl, len(agents.query(
                                              "building_id == -1")))
        agents.building_id[displaced_agents] = -1
        print "Unplaced {} after: {}".format(tbl, len(agents.query(
                                             "building_id == -1")))
        orca.add_table(tbl, agents)

    return old_buildings
コード例 #22
0
ファイル: models.py プロジェクト: ual/bayarea_urbansim
def price_vars(net):
    nodes2 = networks.from_yaml(net["walk"], "price_vars.yaml")
    nodes2 = nodes2.fillna(0)
    print nodes2.describe()
    nodes = orca.get_table('nodes')
    nodes = nodes.to_frame().join(nodes2)
    orca.add_table("nodes", nodes)
コード例 #23
0
ファイル: utils.py プロジェクト: paladin74/urbansim_defaults
def _remove_developed_buildings(old_buildings, new_buildings, unplace_agents):
    redev_buildings = old_buildings.parcel_id.isin(new_buildings.parcel_id)
    l = len(old_buildings)
    drop_buildings = old_buildings[redev_buildings]
    old_buildings = old_buildings[np.logical_not(redev_buildings)]
    l2 = len(old_buildings)
    if l2 - l > 0:
        print "Dropped {} buildings because they were redeveloped".\
            format(l2-l)

    for tbl in unplace_agents:
        agents = orca.get_table(tbl)
        cols = agents.local_columns
        if "building_id" not in cols:
            # if it's a unit-level model, need to add building_id
            # explicitly
            cols += ["building_id"]
        agents = agents.to_frame(cols)
        displaced_agents = agents.building_id.isin(drop_buildings.index)
        print "Unplaced {} before: {}".format(
            tbl, len(agents.query("building_id == -1")))
        agents.building_id[displaced_agents] = -1
        print "Unplaced {} after: {}".format(
            tbl, len(agents.query("building_id == -1")))
        orca.add_table(tbl, agents)

    return old_buildings
コード例 #24
0
ファイル: slr.py プロジェクト: xyzjayne/bayarea_urbansim
def slr_inundate(scenario, parcels, slr_progression_C, slr_progression_R,
                 slr_progression_B, slr_parcel_inundation,
                 slr_parcel_inundation_mf, slr_parcel_inundation_mp,
                 slr_progression_d_b, slr_parcel_inundation_d_b,
                 slr_parcel_inundation_d_bb, slr_parcel_inundation_d_bp, year,
                 hazards):

    if scenario not in hazards["slr_scenarios"]["enable_in"]:
        return

    # horizon
    if scenario in hazards["slr_scenarios"]["rtff_prog"]:
        slr_progression = slr_progression_R.to_frame()
    elif scenario in hazards["slr_scenarios"]["cag_prog"]:
        slr_progression = slr_progression_C.to_frame()
    elif scenario in hazards["slr_scenarios"]["bttf_prog"]:
        slr_progression = slr_progression_B.to_frame()
    # draft blueprint
    elif scenario in hazards["slr_scenarios"]["d_b_prog"]:
        slr_progression = slr_progression_d_b.to_frame()
    orca.add_table("slr_progression", slr_progression)

    inundation_yr = slr_progression.query('year==@year')['inundated'].item()
    print("Inundation in model year is %d inches" % inundation_yr)

    # horizon
    if scenario in hazards["slr_scenarios"]["horizon_scenarios"]:
        if scenario in hazards["slr_scenarios"]["mitigation_full"]:
            slr_parcel_inundation = slr_parcel_inundation_mf.to_frame()
            orca.add_injectable("slr_mitigation", 'full mitigation')
        elif scenario in hazards["slr_scenarios"]["mitigation_partial"]:
            slr_parcel_inundation = slr_parcel_inundation_mp.to_frame()
            orca.add_injectable("slr_mitigation", 'partial mitigation')
        else:
            slr_parcel_inundation = slr_parcel_inundation.to_frame()
            orca.add_injectable("slr_mitigation", 'none')
    # draft blueprint
    if scenario in hazards["slr_scenarios"]["draft_blueprint_scenarios"]:
        if scenario in hazards["slr_scenarios"]["d_bb_mitigation"]:
            slr_parcel_inundation = slr_parcel_inundation_d_bb.to_frame()
            orca.add_injectable("slr_mitigation",
                                'draft blueprint basic mitigation')
        elif scenario in hazards["slr_scenarios"]["d_bp_mitigation"]:
            slr_parcel_inundation = slr_parcel_inundation_d_bp.to_frame()
            orca.add_injectable("slr_mitigation",
                                'draft blueprint plus mitigation')
        else:
            slr_parcel_inundation = slr_parcel_inundation_d_b.to_frame()
            orca.add_injectable("slr_mitigation", 'none')

    destroy_parcels = slr_parcel_inundation.\
        query('inundation<=@inundation_yr').astype('bool')
    orca.add_table('destroy_parcels', destroy_parcels)
    print("Number of parcels destroyed: %d" % len(destroy_parcels))

    slr_nodev = pd.Series(False, parcels.index)
    destroy = pd.Series(destroy_parcels['inundation'])
    slr_nodev.update(destroy)
    orca.add_column('parcels', 'slr_nodev', slr_nodev)
    parcels = orca.get_table("parcels")
コード例 #25
0
ファイル: models.py プロジェクト: SANDAG/sandag_urbansim
def build_networks(settings , store, parcels, intersections):
    edges, nodes = store['edges'], store['nodes']
    net = pdna.Network(nodes["x"], nodes["y"], edges["from"], edges["to"],
                       edges[["weight"]])

    max_distance = settings['build_networks']['max_distance']
    net.precompute(max_distance)

    #SETUP POI COMPONENTS
    on_ramp_nodes = nodes[nodes.on_ramp]
    net.init_pois(num_categories=4, max_dist=max_distance, max_pois=1)
    net.set_pois('onramps', on_ramp_nodes.x, on_ramp_nodes.y)

    parks = store.parks
    net.set_pois('parks', parks.x, parks.y)

    schools = store.schools
    net.set_pois('schools', schools.x, schools.y)

    transit = store.transit
    net.set_pois('transit', transit.x, transit.y)

    orca.add_injectable("net", net)

    p = parcels.to_frame(parcels.local_columns)
    i = intersections.to_frame(intersections.local_columns)

    p['node_id'] = net.get_node_ids(p['x'], p['y'])
    i['node_id'] = net.get_node_ids(i['x'], i['y'])

    #p.to_csv('data/parcels.csv')
    orca.add_table("parcels", p)
    orca.add_table("intersections", i)
コード例 #26
0
def subsidized_residential_feasibility(
        parcels, settings,
        add_extra_columns_func, parcel_sales_price_sqft_func,
        parcel_is_allowed_func, parcels_geography):

    kwargs = settings['feasibility'].copy()
    kwargs["only_built"] = False
    kwargs["forms_to_test"] = ["residential"]
    # step 1
    utils.run_feasibility(parcels,
                          parcel_sales_price_sqft_func,
                          parcel_is_allowed_func,
                          **kwargs)

    feasibility = orca.get_table("feasibility").to_frame()
    # get rid of the multiindex that comes back from feasibility
    feasibility = feasibility.stack(level=0).reset_index(level=1, drop=True)
    # join to parcels_geography for filtering
    feasibility = feasibility.join(parcels_geography.to_frame())

    # add the multiindex back
    feasibility.columns = pd.MultiIndex.from_tuples(
            [("residential", col) for col in feasibility.columns])

    feasibility = policy_modifications_of_profit(feasibility, parcels)

    orca.add_table("feasibility", feasibility)
コード例 #27
0
ファイル: run_indicators_AY.py プロジェクト: psrc/urbansim2
def groupby_person(my_person_geo):
    df = my_person_geo.to_frame()
    df5 = df.groupby(by=geo_id)['persons'].count().to_frame()
    #df5[my_col[-1]] = df5.index
    df5.columns = my_col
    print df5.head()
    orca.add_table(file_name, df5)
コード例 #28
0
ファイル: models.py プロジェクト: SANDAG/sandag_urbansim
def scheduled_development_events(scheduled_development_events, buildings, parcels):
    year = get_year()
    sched_dev = scheduled_development_events.to_frame()
    sched_dev = sched_dev.groupby('siteID').apply(lambda x: x.iloc[np.random.randint(0, len(x))])
    phasein = pd.read_csv('data/schdev.csv')
    sched_dev = sched_dev.merge(phasein,left_on = 'siteID',right_on = 'siteID')
    sched_dev = sched_dev.loc[sched_dev['Units'] > 0]
    sched_dev = sched_dev[sched_dev.Year==year]
    #TODO: The simple division here is not consistent with other job_spaces calculations
    sched_dev['job_spaces'] = sched_dev.non_residential_sqft/400
    if len(sched_dev) > 0:
        max_bid = buildings.index.values.max()
        idx = np.arange(max_bid + 1,max_bid+len(sched_dev)+1)
        sched_dev['building_id'] = idx
        sched_dev['building_type_id'] = np.where(sched_dev['Htype'] == 'MF', 21, 19)
        sched_dev = sched_dev.set_index('building_id')
        sched_dev['new_bldg'] = True
        sched_dev['year_built'] = year
        sched_dev['new_units'] = sched_dev['Units']
        sched_dev['sch_dev'] = True
        sched_dev['residential_units'] = sched_dev['Units']
        b = buildings.to_frame(buildings.local_columns)
        if 'residential_price' in b.columns:
            sched_dev['residential_price'] = 0
        if 'non_residential_price' in b.columns:
            sched_dev['non_residential_price'] = 0
        all_buildings = developer.Developer.merge(b,sched_dev[b.columns])
        all_buildings = all_buildings.fillna(0)
        orca.add_table("buildings", all_buildings)
コード例 #29
0
def workplace_location_sample(asim_persons_merged,
                              workplace_location_sample_spec,
                              workplace_location_settings,
                              skim_dict,
                              destination_size_terms,
                              chunk_size,
                              trace_hh_id):
    """
    build a table of workers * all zones in order
    to select a sample of alternative work locations.

    PERID,  dest_TAZ, rand,            pick_count
    23750,  14,       0.565502716034,  4
    23750,  16,       0.711135838871,  6
    ...
    23751,  12,       0.408038878552,  1
    23751,  14,       0.972732479292,  2
    """

    trace_label = 'workplace_location_sample'

    choosers = asim_persons_merged.to_frame()
    alternatives = destination_size_terms.to_frame()

    constants = asim_utils.get_model_constants(workplace_location_settings)

    sample_size = workplace_location_settings["SAMPLE_SIZE"]
    alt_col_name = workplace_location_settings["ALT_COL_NAME"]

    print("Running workplace_location_sample with %d persons" % len(choosers))

    # create wrapper with keys for this lookup - in this case there is a TAZ
    # in the choosers and a TAZ in the alternatives which get merged during
    # interaction the skims will be available under the name "skims" for any
    # @ expressions
    skims = skim_dict.wrap("TAZ", "TAZ_r")

    locals_d = {
        'skims': skims
    }
    if constants is not None:
        locals_d.update(constants)

    # FIXME - MEMORY HACK - only include columns actually used in spec
    chooser_columns = workplace_location_settings['SIMULATE_CHOOSER_COLUMNS']
    choosers = choosers[chooser_columns]

    choices = interaction_sample(
        choosers,
        alternatives,
        sample_size=sample_size,
        alt_col_name=alt_col_name,
        spec=workplace_location_sample_spec,
        skims=skims,
        locals_d=locals_d,
        chunk_size=chunk_size,
        trace_label=trace_label)

    orca.add_table('workplace_location_sample', choices)
コード例 #30
0
def test_all_cols_orca(df):
    """
    Confirm that all_cols() works with Orca input.
    
    """
    orca.add_table('df', df)
    cols = utils.all_cols('df')
    assert sorted(cols) == sorted(['id', 'val1', 'val2'])
コード例 #31
0
def test_get_df_str(df):
    """
    Confirm that get_df() works with str input.
    
    """
    orca.add_table('df', df)
    df_out = utils.get_df('df')
    pd.testing.assert_frame_equal(df, df_out)
コード例 #32
0
ファイル: models.py プロジェクト: ual/bayarea_urbansim
def neighborhood_vars(net):
    nodes = networks.from_yaml(net["walk"], "neighborhood_vars.yaml")
    nodes = nodes.replace(-np.inf, np.nan)
    nodes = nodes.replace(np.inf, np.nan)
    nodes = nodes.fillna(0)

    print nodes.describe()
    orca.add_table("nodes", nodes)
コード例 #33
0
ファイル: models.py プロジェクト: yonran/bayarea_urbansim
def neighborhood_vars(net):
    nodes = networks.from_yaml(net["walk"], "neighborhood_vars.yaml")
    nodes = nodes.replace(-np.inf, np.nan)
    nodes = nodes.replace(np.inf, np.nan)
    nodes = nodes.fillna(0)

    print nodes.describe()
    orca.add_table("nodes", nodes)
コード例 #34
0
def initialize_new_units(buildings, residential_units):
    """
    This data maintenance step initializes units for buildings that have been
    newly created, conforming to the data requirements of the
    'residential_units' table.

    Data expectations
    -----------------
    - 'buildings' table has the following columns:
        - index that serves as its identifier
        - 'residential_units' (int, count of units in building)
    - 'residential_units' table has the following columns:
        - index named 'unit_id' that serves as its identifier
        - 'building_id' corresponding to the index of the 'buildings' table

    Results
    -------
    - extends the 'residential_units' table, following the same schema as the
      'initialize_residential_units' model step
    """

    # Verify initial data characteristics
    '''
    ot.assert_orca_spec(OrcaSpec(
        '',
        TableSpec(
            'buildings',
            ColumnSpec('building_id', primary_key=True),
            ColumnSpec('residential_units', min=0)),
        TableSpec(
            'residential_units',
            ColumnSpec('unit_id', primary_key=True),
            ColumnSpec('building_id', foreign_key='buildings.building_id'))))
    '''

    old_units = residential_units.to_frame(residential_units.local_columns)
    bldgs = buildings.to_frame(['residential_units', 'deed_restricted_units', 'building_id'])

    # Filter for residential buildings not currently represented in
    # the units table
    new_bldgs = bldgs[~bldgs.building_id.isin(old_units.building_id)]
    new_bldgs = new_bldgs[new_bldgs.residential_units > 0]
    
    if len(new_bldgs) == 0:
        return

    # Create new units, merge them, and update the table
    new_units = _create_empty_units(new_bldgs)
    all_units = dev.merge(old_units, new_units)
    all_units.index.name = 'unit_id'

    print "Creating %d residential units for %d new buildings" % \
        (len(new_units), len(new_bldgs))

    orca.add_table('residential_units', all_units)

    # Verify final data characteristics
    '''
コード例 #35
0
ファイル: create_trips.py プロジェクト: stefancoe/activitysim
def create_simple_trips(tours, households, persons, trace_hh_id):
    """
    Create a simple trip table
    """

    logger.info("Running simple trips table creation with %d tours" %
                len(tours.index))

    tours_df = tours.to_frame()

    # we now have a tour_id column
    tours_df.reset_index(inplace=True)

    tours_df['household_id'] = reindex(persons.household_id,
                                       tours_df.person_id)
    tours_df['TAZ'] = reindex(households.TAZ, tours_df.household_id)

    # create inbound and outbound records
    trips = pd.concat([tours_df, tours_df], ignore_index=True)

    # first half are outbound, second half are inbound
    trips['INBOUND'] = np.repeat([False, True], len(trips.index) / 2)

    # TRIPID for outbound trips = 1, inbound_trips = 2
    trips['trip_num'] = np.repeat([1, 2], len(trips.index) / 2)

    # set key fields from tour fields: 'TAZ','destination','start','end'
    trips['OTAZ'] = trips.TAZ
    trips['OTAZ'][trips.INBOUND] = trips.destination[trips.INBOUND]

    trips['DTAZ'] = trips.destination
    trips['DTAZ'][trips.INBOUND] = trips.TAZ[trips.INBOUND]

    trips['start_trip'] = trips.start
    trips['start_trip'][trips.INBOUND] = trips.end[trips.INBOUND]

    trips['end_trip'] = trips.end
    trips['end_trip'][trips.INBOUND] = trips.start[trips.INBOUND]

    # create a stable (predictable) index based on tour_id and trip_num
    possible_trips_count = 2
    trips['trip_id'] = (trips.tour_id *
                        possible_trips_count) + (trips.trip_num - 1)
    trips.set_index('trip_id', inplace=True, verify_integrity=True)

    trip_columns = [
        'tour_id', 'INBOUND', 'trip_num', 'OTAZ', 'DTAZ', 'start_trip',
        'end_trip'
    ]
    trips = trips[trip_columns]

    orca.add_table("trips", trips)

    tracing.register_traceable_table('trips', trips)
    pipeline.get_rn_generator().add_channel(trips, 'trips')

    if trace_hh_id:
        tracing.trace_df(trips, label="trips", warn_if_empty=True)
コード例 #36
0
def full_transition(agents,
                    agent_controls,
                    totals_column,
                    year,
                    location_fname,
                    linked_tables=None,
                    accounting_column=None,
                    set_year_built=False):
    """
    Run a transition model based on control totals specified in the usual
    UrbanSim way
    Parameters
    ----------
    agents : DataFrameWrapper
        Table to be transitioned
    agent_controls : DataFrameWrapper
        Table of control totals
    totals_column : str
        String indicating the agent_controls column to use for totals.
    year : int
        The year, which will index into the controls
    location_fname : str
        The field name in the resulting dataframe to set to -1 (to unplace
        new agents)
    linked_tables : dict, optional
        Sets the tables linked to new or removed agents to be updated with
        dict of {'table_name':(DataFrameWrapper, 'link_id')}
    accounting_column : str, optional
        Name of column with accounting totals/quantities to apply toward the
        control. If not provided then row counts will be used for accounting.
    set_year_built: boolean
        Indicates whether to update 'year_built' columns with current
        simulation year
    Returns
    -------
    Nothing
    """
    ct = agent_controls.to_frame()
    agnt = agents.local
    print("Total agents before transition: {}".format(len(agnt)))
    tran = transition.TabularTotalsTransition(ct, totals_column,
                                              accounting_column)
    updated, added, copied, removed = tran.transition(agnt, year)
    updated.loc[added, location_fname] = -1
    if set_year_built:
        updated.loc[added, 'year_built'] = year

    updated_links = {}
    if linked_tables:
        for table_name, (table, col) in linked_tables.iteritems():
            print('updating linked table {}'.format(table_name))
            updated_links[table_name] = \
                update_linked_table(table, col, added, copied, removed)
            orca.add_table(table_name, updated_links[table_name])

    print("Total agents after transition: {}".format(len(updated)))
    orca.add_table(agents.name, updated[agents.local_columns])
    return updated, added, copied, removed
コード例 #37
0
def network_aggregations_beam(netbeam):
    """
    This will be turned into a network aggregation template.
    """

    nodesbeam = networks.from_yaml(netbeam, 'network_aggregations_beam.yaml')
    nodesbeam = nodesbeam.fillna(0)
    print(nodesbeam.describe())
    orca.add_table('nodesbeam', nodesbeam)
コード例 #38
0
def network_aggregations_small(netsmall):
    """
    This will be turned into a network aggregation template.
    """
    nodessmall = networks.from_yaml(
        netsmall, 'network_aggregations_small.yaml')
    nodessmall = nodessmall.fillna(0)
    print(nodessmall.describe())
    orca.add_table('nodessmall', nodessmall)
コード例 #39
0
def orca_session():
    """
    Set up a clean Orca session, with a data table.
    
    """
    orca.clear_all()

    df = pd.DataFrame({'a': [0.1, 1.33, 2.4]}, index=[1, 2, 3])
    orca.add_table('tab', df)
コード例 #40
0
def households_transition(households, annual_household_control_totals, year):
    ct = annual_household_control_totals.to_frame()
    tran = transition.TabularTotalsTransition(ct, 'total_number_of_households')
    model = transition.TransitionModel(tran)
    hh = households.to_frame(households.local_columns + ['activity_id'])
    new, added_hh_idx, empty_dict = \
        model.transition(hh, year,)
    new.loc[added_hh_idx, "building_id"] = -1
    orca.add_table("households", new)
コード例 #41
0
def test_validation_multiindex_unique(orca_session):
    """
    Table validation should pass with a MultiIndex whose combinations are unique.
    
    """
    d = {'id': [1, 1, 1], 'sub_id': [1, 2, 3], 'value': [4, 4, 4]}
    orca.add_table('tab', pd.DataFrame(d).set_index(['id', 'sub_id']))

    validate_table('tab')
コード例 #42
0
def test_all_cols_extras(df):
    """
    Confirm that all_cols() includes columns not part of the Orca core table.
    
    """
    orca.add_table('df', df)
    orca.add_column('df', 'newcol', pd.Series())
    cols = utils.all_cols('df')
    assert sorted(cols) == sorted(['id', 'val1', 'val2', 'newcol'])
コード例 #43
0
def households_transition(households, annual_household_control_totals, year):
    ct = annual_household_control_totals.to_frame()
    tran = transition.TabularTotalsTransition(ct, 'total_number_of_households')
    model = transition.TransitionModel(tran)
    hh = households.to_frame(households.local_columns + ['activity_id'])
    new, added_hh_idx, empty_dict = \
        model.transition(hh, year,)
    new.loc[added_hh_idx, "building_id"] = -1
    orca.add_table("households", new)
コード例 #44
0
ファイル: models.py プロジェクト: wsp-sag/bayarea_urbansim
def scheduled_development_events(buildings, development_projects,
                                 demolish_events, summary, year, parcels,
                                 mapping, years_per_iter, parcels_geography,
                                 building_sqft_per_job, vmt_fee_categories,
                                 static_parcels):
    # first demolish
    demolish = demolish_events.to_frame().\
        query("%d <= year_built < %d" % (year, year + years_per_iter))
    print("Demolishing/building %d buildings" % len(demolish))
    l1 = len(buildings)
    buildings = utils._remove_developed_buildings(
        buildings.to_frame(buildings.local_columns),
        demolish,
        unplace_agents=["households", "jobs"])
    orca.add_injectable(
        'static_parcels',
        np.append(static_parcels, demolish.loc[demolish.action == 'build',
                                               'parcel_id']))
    orca.add_table("buildings", buildings)
    buildings = orca.get_table("buildings")
    print("Demolished %d buildings" % (l1 - len(buildings)))
    print("    (this number is smaller when parcel has no existing buildings)")

    # then build
    dps = development_projects.to_frame().\
        query("%d <= year_built < %d" % (year, year + years_per_iter))

    if len(dps) == 0:
        return

    new_buildings = utils.scheduled_development_events(
        buildings,
        dps,
        remove_developed_buildings=False,
        unplace_agents=['households', 'jobs'])
    new_buildings["form"] = new_buildings.building_type.map(
        mapping['building_type_map']).str.lower()
    new_buildings["job_spaces"] = new_buildings.non_residential_sqft / \
        new_buildings.building_type.fillna("OF").map(building_sqft_per_job)
    new_buildings["job_spaces"] = new_buildings.job_spaces.\
        fillna(0).astype('int')
    new_buildings["geom_id"] = parcel_id_to_geom_id(new_buildings.parcel_id)
    new_buildings["SDEM"] = True
    new_buildings["subsidized"] = False

    new_buildings["zone_id"] = misc.reindex(parcels.zone_id,
                                            new_buildings.parcel_id)
    new_buildings["vmt_res_cat"] = misc.reindex(vmt_fee_categories.res_cat,
                                                new_buildings.zone_id)
    del new_buildings["zone_id"]
    new_buildings["pda"] = parcels_geography.pda_id.loc[
        new_buildings.parcel_id].values
    new_buildings["juris_trich"] = parcels_geography.juris_trich.loc[
        new_buildings.parcel_id].values

    summary.add_parcel_output(new_buildings)
コード例 #45
0
ファイル: models.py プロジェクト: ual/bayarea_urbansim
def regional_vars(net):
    nodes = networks.from_yaml(net["drive"], "regional_vars.yaml")
    nodes = nodes.fillna(0)

    nodes2 = pd.read_csv('data/regional_poi_distances.csv',
                         index_col="tmnode_id")
    nodes = pd.concat([nodes, nodes2], axis=1)

    print nodes.describe()
    orca.add_table("tmnodes", nodes)
コード例 #46
0
def simple_transition(tbl, rate, location_fname):
    transition = GrowthRateTransition(rate)
    df = tbl.to_frame(tbl.local_columns)

    print "%d agents before transition" % len(df.index)
    df, added, copied, removed = transition.transition(df, None)
    print "%d agents after transition" % len(df.index)

    df.loc[added, location_fname] = -1
    orca.add_table(tbl.name, df)
コード例 #47
0
ファイル: models.py プロジェクト: psrc/urbansim2
def add_lag_tables(lag, year, base_year, filename, table_names):
    store = pd.HDFStore(filename, mode="r")
    prefix = max(year-lag, base_year)
    if prefix == base_year:
        prefix = "base"
    key_template = '{}/{{}}'.format(prefix)
    for table in table_names:
        orca.add_table("{}_lag1".format(table),
                       store[key_template.format(table)], cache=True)
    store.close()
コード例 #48
0
def initialize_new_units(buildings, residential_units):
    """
    This data maintenance step initializes units for buildings that have been
    newly created, conforming to the data requirements of the
    'residential_units' table.

    Data expectations
    -----------------
    - 'buildings' table has the following columns:
        - index that serves as its identifier
        - 'residential_units' (int, count of units in building)
    - 'residential_units' table has the following columns:
        - index named 'unit_id' that serves as its identifier
        - 'building_id' corresponding to the index of the 'buildings' table

    Results
    -------
    - extends the 'residential_units' table, following the same schema as the
      'initialize_residential_units' model step
    """

    # Verify initial data characteristics
    '''
    ot.assert_orca_spec(OrcaSpec(
        '',
        TableSpec(
            'buildings',
            ColumnSpec('building_id', primary_key=True),
            ColumnSpec('residential_units', min=0)),
        TableSpec(
            'residential_units',
            ColumnSpec('unit_id', primary_key=True),
            ColumnSpec('building_id', foreign_key='buildings.building_id'))))
    '''

    old_units = residential_units.to_frame(residential_units.local_columns)
    bldgs = buildings.to_frame(['residential_units', 'deed_restricted_units'])

    # Filter for residential buildings not currently represented in
    # the units table
    new_bldgs = bldgs[~bldgs.index.isin(old_units.building_id)]
    new_bldgs = new_bldgs[new_bldgs.residential_units > 0]

    # Create new units, merge them, and update the table
    new_units = _create_empty_units(new_bldgs)
    all_units = dev.merge(old_units, new_units)
    all_units.index.name = 'unit_id'

    print "Creating %d residential units for %d new buildings" % \
        (len(new_units), len(new_bldgs))

    orca.add_table('residential_units', all_units)

    # Verify final data characteristics
    '''
コード例 #49
0
ファイル: run_indicators.py プロジェクト: psrc/urbansim2
def compute_indicators(settings, iter_var):
    # loop over indicators and datasets from settings and store into file
    for ind, value in settings['indicators'].iteritems():
        for ds in value['dataset']:
            ds_tablename = '%s_%s_%s' % (ds, ind, str(iter_var))
            df = orca.get_table(ds)[ind]
            #print 'ds is %s and ind is %s' % (ds, ind)
            #print orca.get_table(ds)[ind].to_frame().head()
            orca.add_table(ds_tablename, df)
            ind_table_list.append(ds_tablename)
    orca.clear_cache()      
コード例 #50
0
ファイル: models.py プロジェクト: akselx/bayarea_urbansim-1
def neighborhood_vars(net):
    nodes = networks.from_yaml(net["walk"], "neighborhood_vars.yaml")
    nodes = nodes.replace(-np.inf, np.nan)
    nodes = nodes.replace(np.inf, np.nan)
    nodes = nodes.fillna(0)

    # nodes2 = pd.read_csv('data/local_poi_distances.csv', index_col="node_id")
    # nodes = pd.concat([nodes, nodes2], axis=1)

    print nodes.describe()
    orca.add_table("nodes", nodes)
コード例 #51
0
def build_networks(parcels):
    st = pd.HDFStore(os.path.join(misc.data_dir(), "osm_sandag.h5"), "r")
    nodes, edges = st.nodes, st.edges
    net = pdna.Network(nodes["x"], nodes["y"], edges["from"], edges["to"],
                       edges[["weight"]])
    net.precompute(3000)
    orca.add_injectable("net", net)
    
    p = parcels.to_frame(parcels.local_columns)
    p['node_id'] = net.get_node_ids(p['x'], p['y'])
    orca.add_table("parcels", p)
コード例 #52
0
ファイル: workplace_models.py プロジェクト: psrc/urbansim2
def wplcm_simulate(persons, households, jobs):
    # can only send in jobs that have a valid building_id, so remove unlocated jobs for now
    jobs_df = jobs.to_frame()
    jobs_df = jobs_df[jobs_df.building_id>0]
    jobs_df.index.name = 'job_id'
    orca.add_table('located_jobs', jobs_df)
    located_jobs =  orca.get_table('located_jobs')
    res = utils.lcm_simulate("wplcmcoef.yaml", persons, located_jobs, None,
                              "job_id", "number_of_jobs", "vacant_jobs", cast=True)
        
    orca.clear_cache()
コード例 #53
0
ファイル: run_indicators_AY.py プロジェクト: psrc/urbansim2
def get_person_geo():
    # join person data with hourshold data
    df4 = orca.merge_tables(target='my_household', tables=['my_person', 'my_household'])
    # geographic info to dictionary 
    faz_dict = dict(zip(df3['census_2010_block_group_id'], df3['faz_id']))
    zone_dict = dict(zip(df3['census_2010_block_group_id'], df3['zone_id']))
    city_dict = dict(zip(df3['census_2010_block_group_id'], df3['city_id']))
    # map geo info to person table
    df4['faz_id'] = df4['census_2010_block_group_id'].map(faz_dict)
    df4['zone_id'] = df4['census_2010_block_group_id'].map(zone_dict)
    df4['city_id'] = df4['census_2010_block_group_id'].map(city_dict)
    orca.add_table('my_person_geo', df4)
コード例 #54
0
ファイル: test_job_variables.py プロジェクト: psrc/urbansim2
def inputs(input_jobs, input_sectors, input_groups, input_group_def):
    orca.clear_all()
    orca.add_table('jobs', input_jobs)
    orca.add_table('employment_sectors', input_sectors)
    orca.add_table('employment_sector_groups', input_groups)
    orca.add_table('employment_sector_group_definitions', input_group_def)    
    import psrc_urbansim.vars.variables_jobs
コード例 #55
0
ファイル: models.py プロジェクト: ual/bayarea_urbansim
def scheduled_development_events(buildings, development_projects,
                                 demolish_events, summary, year, parcels,
                                 settings, years_per_iter, parcels_geography,
                                 building_sqft_per_job, vmt_fee_categories):

    # first demolish
    demolish = demolish_events.to_frame().\
        query("%d <= year_built < %d" % (year, year + years_per_iter))
    print "Demolishing/building %d buildings" % len(demolish)
    l1 = len(buildings)
    buildings = utils._remove_developed_buildings(
        buildings.to_frame(buildings.local_columns),
        demolish,
        unplace_agents=["households", "jobs"])
    orca.add_table("buildings", buildings)
    buildings = orca.get_table("buildings")
    print "Demolished %d buildings" % (l1 - len(buildings))
    print "    (this number is smaller when parcel has no existing buildings)"

    # then build
    dps = development_projects.to_frame().\
        query("%d <= year_built < %d" % (year, year + years_per_iter))

    if len(dps) == 0:
        return

    new_buildings = utils.scheduled_development_events(
        buildings, dps,
        remove_developed_buildings=False,
        unplace_agents=['households', 'jobs'])
    new_buildings["form"] = new_buildings.building_type.map(
        settings['building_type_map']).str.lower()
    new_buildings["job_spaces"] = new_buildings.non_residential_sqft / \
        new_buildings.building_type.fillna("OF").map(building_sqft_per_job)
    new_buildings["job_spaces"] = new_buildings.job_spaces.\
        fillna(0).astype('int')
    new_buildings["geom_id"] = parcel_id_to_geom_id(new_buildings.parcel_id)
    new_buildings["SDEM"] = True
    new_buildings["subsidized"] = False

    new_buildings["zone_id"] = misc.reindex(
        parcels.zone_id, new_buildings.parcel_id)
    new_buildings["vmt_res_cat"] = misc.reindex(
        vmt_fee_categories.res_cat, new_buildings.zone_id)
    del new_buildings["zone_id"]
    new_buildings["pda"] = parcels_geography.pda_id.loc[
        new_buildings.parcel_id].values

    summary.add_parcel_output(new_buildings)
コード例 #56
0
ファイル: utils.py プロジェクト: ual/bayarea_urbansim
def add_buildings(buildings, new_buildings,
                  remove_developed_buildings=True):

    old_buildings = buildings.to_frame(buildings.local_columns)
    new_buildings = new_buildings[buildings.local_columns]

    if remove_developed_buildings:
        unplace_agents = ["households", "jobs"]
        old_buildings = \
            _remove_developed_buildings(old_buildings, new_buildings,
                                        unplace_agents)

    all_buildings = dev.merge(old_buildings, new_buildings)

    orca.add_table("buildings", all_buildings)
コード例 #57
0
def scheduled_development_events(buildings, scheduled_development_events):
    year = get_year()
    sched_dev = scheduled_development_events.to_frame()
    sched_dev = sched_dev[sched_dev.year_built==year]
    sched_dev['residential_sqft'] = sched_dev.sqft_per_unit*sched_dev.residential_units
    sched_dev['job_spaces'] = sched_dev.non_residential_sqft/400
    if len(sched_dev) > 0:
        max_bid = buildings.index.values.max()
        idx = np.arange(max_bid + 1,max_bid+len(sched_dev)+1)
        sched_dev['building_id'] = idx
        sched_dev = sched_dev.set_index('building_id')
        from urbansim.developer.developer import Developer
        merge = Developer(pd.DataFrame({})).merge
        b = buildings.to_frame(buildings.local_columns)
        all_buildings = merge(b,sched_dev[b.columns])
        orca.add_table("buildings", all_buildings)
コード例 #58
0
def inputs(input_pcl, input_bld, input_jobs, input_gcl, input_settings):
    #orca.clear_all()
    orca.add_table('parcels', input_pcl)
    orca.add_table('buildings', input_bld)
    orca.add_table('jobs', input_jobs)
    orca.add_table('gridcells', input_gcl)
    orca.add_injectable('settings', input_settings)
    import psrc_urbansim.vars.variables_jobs
    import psrc_urbansim.vars.variables_parcels
コード例 #59
0
ファイル: utils.py プロジェクト: UDST/sanfran_urbansim
def run_feasibility(parcels, parcel_price_callback,
                    parcel_use_allowed_callback, residential_to_yearly=True):
    """
    Execute development feasibility on all parcels

    Parameters
    ----------
    parcels : DataFrame Wrapper
        The data frame wrapper for the parcel data
    parcel_price_callback : function
        A callback which takes each use of the pro forma and returns a series
        with index as parcel_id and value as yearly_rent
    parcel_use_allowed_callback : function
        A callback which takes each form of the pro forma and returns a series
        with index as parcel_id and value and boolean whether the form
        is allowed on the parcel
    residential_to_yearly : boolean (default true)
        Whether to use the cap rate to convert the residential price from total
        sales price per sqft to rent per sqft

    Returns
    -------
    Adds a table called feasibility to the sim object (returns nothing)
    """
    pf = sqftproforma.SqFtProForma()

    df = parcels.to_frame()

    # add prices for each use
    for use in pf.config.uses:
        df[use] = parcel_price_callback(use)

    # convert from cost to yearly rent
    if residential_to_yearly:
        df["residential"] *= pf.config.cap_rate

    print("Describe of the yearly rent by use")
    print(df[pf.config.uses].describe())

    d = {}
    for form in pf.config.forms:
        print("Computing feasibility for form %s" % form)
        d[form] = pf.lookup(form, df[parcel_use_allowed_callback(form)])

    far_predictions = pd.concat(d.values(), keys=d.keys(), axis=1)

    orca.add_table("feasibility", far_predictions)
コード例 #60
0
ファイル: models.py プロジェクト: psrc/urbansim2
def governmental_jobs_scaling(jobs, buildings, year):
    orca.add_column('buildings', 'existing', np.zeros(len(buildings),
                    dtype="int32"))
    alloc = AgentAllocationModel('existing', 'number_of_governmental_jobs',
                                 as_delta=False)
    jobs_to_place = jobs.local[np.logical_and(np.in1d(jobs.sector_id,
                                              [18, 19]), jobs.building_id < 0)]
    print "Locating %s governmental jobs" % len(jobs_to_place)
    loc_ids, loc_allo = alloc.locate_agents(orca.get_table
                                            ("buildings").to_frame
                                            (buildings.local_columns +
                                             ['number_of_governmental_jobs',
                                              'existing']), jobs_to_place,
                                            year=year)
    jobs.local.loc[loc_ids.index, buildings.index.name] = loc_ids
    print "Number of unplaced governmental jobs: %s" % np.logical_or(np.isnan(loc_ids), loc_ids < 0).sum()
    orca.add_table(jobs.name, jobs.local)