def population_callback(value): set_variable('population_forecast_correction', value) pop_df = get_adjusted_population_forecast() target_year = get_variable('target_year') pop_in_target_year = pop_df.loc[target_year].Population last_hist = pop_df[~pop_df.Forecast].iloc[-1] fig = generate_population_forecast_graph(pop_df) cd = CardDescription() cd.set_values( pop_in_target_year=pop_in_target_year, pop_adj=get_variable('population_forecast_correction'), pop_diff=(1 - last_hist.Population / pop_in_target_year) * 100, ) cd.set_variables(last_year=last_hist.name) pop_desc = cd.render(""" {municipality_genitive} väkiluku vuonna {target_year} on {pop_in_target_year}. Muutos viralliseen väestöennusteeseen on {pop_adj:noround} %. Väkiluvun muutos vuoteen {last_year} verrattuna on {pop_diff} %. """) bar = StickyBar( label="Väkiluku %s" % get_variable('municipality_locative'), value=pop_in_target_year, unit='asukasta', ) # return fig, pop_in_target_year.round() return [fig, dbc.Col(pop_desc), bar.render()]
def population_callback(value): set_variable('population_forecast_correction', value) pop_df = get_population_forecast() pop_in_target_year = pop_df.loc[[get_variable('target_year')]].Population fig = generate_population_forecast_graph(pop_df) return fig, pop_in_target_year.round()
def run_simulation_callback(n_clicks, simulation_days): print('run simulation (days %d)' % simulation_days) print(generate_cache_key(simulate_individuals)) set_variable('simulation_days', simulation_days) if n_clicks: set_variable('random_seed', n_clicks) df = simulate_individuals(only_if_in_cache=True) if df is not None: return render_results(df) if settings.RESTRICT_TO_PRESET_SCENARIOS: return [html.Div('Palvelussa ruuhkaa, osa simulaatiotoiminnallisuuksista on pois käytöstä')] existing_thread_id = session.get('thread_id', None) if existing_thread_id: cache.set('thread-%s-kill' % existing_thread_id, True) process = SimulationThread(variables=session.copy()) session['thread_id'] = process.uuid process.start() return [ dcc.Interval(id='simulation-output-interval', interval=500, max_intervals=60), html.Div(id='simulation-output-results'), ]
def run_simulation_callback(n_clicks, simulation_days): from flask import session from common import cache print('run simulation (days %d)' % simulation_days) set_variable('simulation_days', simulation_days) if n_clicks: set_variable('random_seed', n_clicks) df = simulate_individuals(only_if_in_cache=True) if df is not None: return render_results(df) existing_thread_id = session.get('thread_id', None) if existing_thread_id: cache.set('thread-%s-kill' % existing_thread_id, True) process = SimulationThread(variables=session.copy()) session['thread_id'] = process.uuid process.start() return [ dcc.Interval(id='simulation-output-interval', interval=500, max_intervals=60), html.Div(id='simulation-output-results'), ]
def population_callback(value): set_variable('population_forecast_correction', value) pop_df = predict_population() target_year = get_variable('target_year') pop_in_target_year = pop_df.loc[target_year].Population last_hist = pop_df[~pop_df.Forecast].iloc[-1] fig = generate_population_forecast_graph(pop_df) cd = CardDescription() cd.set_values( pop_in_target_year=pop_in_target_year, pop_adj=get_variable('population_forecast_correction'), pop_diff=(1 - last_hist.Population / pop_in_target_year) * 100, ) cd.set_variables(last_year=last_hist.name) pop_desc = cd.render(""" The population of {municipality} in the year {target_year} will be {pop_in_target_year}. The difference compared to the official population forecast is {pop_adj:noround} %. Population change compared to {last_year} is {pop_diff} %. """) # pop_desc = cd.render(""" # {municipality_genitive} väkiluku vuonna {target_year} on {pop_in_target_year}. # Muutos viralliseen väestöennusteeseen on {pop_adj:noround} %. # Väkiluvun muutos vuoteen {last_year} verrattuna on {pop_diff} %. #""") bar = StickyBar( label=gettext('Population in %(municipality)s') % dict(municipality=get_variable('municipality_name')), value=pop_in_target_year, unit=gettext('residents'), ) # return fig, pop_in_target_year.round() return [fig, dbc.Col(pop_desc), bar.render()]
def mutate(root, info, event_id): iv_id = int(event_id) iv_list = list(get_variable('interventions')) if iv_id >= len(iv_list): raise GraphQLError('invalid intervention ID') del iv_list[iv_id] set_variable('interventions', iv_list) return dict(ok=True)
def simulate_monte_carlo(seed): from variables import allow_set_variable, get_variable, set_variable with allow_set_variable(): set_variable('random_seed', seed) print(seed) df = simulate_individuals(skip_cache=True) df['run'] = seed return df
def apply(self): super().apply() ivs = get_variable('interventions') out = [] for iv in ivs: iv = list(iv) if iv[0] == 'limit-mobility': iv[2] = iv[2] // 2 out.append(iv) set_variable('interventions', out)
def mutate(root, info, event): iv_type = event.type.value iv_list = list(get_variable('interventions')) obj = get_intervention(iv_type).copy() obj.date = event.date for p in event.parameters: obj.set_param(p.id, p.choice or p.value) iv_list.append(obj.make_iv_tuple()) set_variable('interventions', iv_list) return dict(id=len(iv_list) - 1)
def interventions_callback(ts, reset_clicks, add_intervention_clicks, rows, new_date, new_id, new_val): ctx = dash.callback_context is_reset = False changed = False if ctx.triggered: c_id = ctx.triggered[0]['prop_id'].split('.')[0] if reset_clicks is not None and c_id == 'interventions-reset-defaults': reset_variable('interventions') is_reset = True if add_intervention_clicks is not None and c_id == 'new-intervention-add': d = date.fromisoformat(new_date) sstart = date.fromisoformat(get_variable('start_date')) if d < sstart or d > sstart + timedelta( days=get_variable('simulation_days')): raise dash.exceptions.PreventUpdate() if new_id in ('test-all-with-symptoms', ): new_val = None elif new_id == ('test-with-contact-tracing', 'test-only-severe-symptoms'): if new_val > 100 or new_val < 0: raise dash.exceptions.PreventUpdate() elif new_id in ('limit-mobility', ): if new_val > 100 or new_val < 0: raise dash.exceptions.PreventUpdate() elif new_id in ('limit-mass-gatherings', 'import-infections', 'build-new-icu-units', 'build-new-hospital-beds'): if new_val < 0: raise dash.exceptions.PreventUpdate() else: raise dash.exceptions.PreventUpdate() changed = True rows.append(dict(name=new_id, date=d.isoformat(), value=new_val)) if c_id == 'interventions-table': changed = True if not is_reset and changed: ivs = [] for row in sorted(rows, key=lambda x: x['date']): val = row['value'] if isinstance(val, str): val = int(val) ivs.append([row['name'], row['date'], val]) set_variable('interventions', ivs) rows = interventions_to_rows() return rows
def mutate(root, info, scenario_id): scenarios = get_variable('scenarios') if scenario_id: for s in scenarios: if scenario_id == s['id']: break else: raise GraphQLError('invalid scenario ID') else: scenario_id = '' reset_variables() set_variable('active_scenario', scenario_id) return dict(ok=True)
def ghg_slider_callback(*values): sectors = [x.id.split('-')[1] for x in ghg_sliders] new_values = {s: val for s, val in zip(sectors, values)} set_variable('ghg_reductions_weights', new_values) df = get_ghg_emissions_forecast() fig = generate_ghg_emission_graph(df) df['Yhteensä'] = df.sum(axis=1) last_hist_year = df[~df.Forecast].index.max() data_columns = list(df.loc[df.index == last_hist_year].stack().sort_values( ascending=False).index.get_level_values(1)) data_columns.remove('Forecast') data_columns.insert(0, 'Vuosi') data_columns.remove('Yhteensä') data_columns.append('Yhteensä') last_forecast_year = df[df.Forecast].index.max() table_df = df.loc[df.index.isin([ last_hist_year, last_forecast_year - 5, last_forecast_year - 10, last_forecast_year ])] table_data = table_df.reset_index().to_dict('rows') table_cols = [] for col_name in data_columns: col = dict(id=col_name, name=col_name) if col_name == 'Vuosi': pass else: col['type'] = 'numeric' col['format'] = Format(precision=0, scheme=Scheme.fixed) table_cols.append(col) table = dash_table.DataTable( data=table_data, columns=table_cols, # style_as_list_view=True, style_cell={'padding': '5px'}, style_header={'fontWeight': 'bold'}, style_cell_conditional=[{ 'if': { 'column_id': 'Vuosi' }, 'fontWeight': 'bold', }]) return [fig, table]
def electricity_consumption_callback(value): set_variable('electricity_consumption_per_capita_adjustment', value / 10) df = predict_electricity_consumption_emissions() graph = PredictionGraph(sector_name='ElectricityConsumption', title='Sähkönkulutus asukasta kohti', unit_name='kWh/as.') graph.add_series(df=df, trace_name='Sähkönkulutus/as.', column_name='ElectricityConsumptionPerCapita') per_capita_fig = graph.get_figure() graph = PredictionGraph( sector_name='ElectricityConsumption', title='Kulutussähkön kulutus', unit_name='GWh', ) graph.add_series(df=df, trace_name='Sähkönkulutus', column_name='ElectricityConsumption') consumption_fig = graph.get_figure() graph = PredictionGraph( sector_name='ElectricityConsumption', title='Sähköntuotannon päästökerroin', unit_name='g/kWh', smoothing=True, ) graph.add_series(df=df, trace_name='Päästökerroin', column_name='EmissionFactor') factor_fig = graph.get_figure() print(factor_fig) graph = PredictionGraph( sector_name='ElectricityConsumption', title='Kulutussähkön päästöt', unit_name='kt (CO2e)', smoothing=True, ) graph.add_series(df=df, trace_name='Päästöt', column_name='Emissions') emission_fig = graph.get_figure() return [per_capita_fig, consumption_fig, factor_fig, emission_fig]
def district_heating_consumption_callback(existing_building_perc, new_building_perc): set_variable('district_heating_existing_building_efficiency_change', existing_building_perc / 10) set_variable('district_heating_new_building_efficiency_change', new_building_perc / 10) df = predict_district_heat_consumption() fig1 = draw_existing_building_unit_heat_factor_graph(df) fig2 = draw_new_building_unit_heat_factor_graph(df) fig3 = draw_heat_consumption(df) df = predict_district_heating_emissions() unit_emissions_card = make_unit_emissions_card(df) fig4 = draw_district_heat_consumption_emissions(df) sticky = make_bottom_bar(df) return [fig1, fig2, fig3, unit_emissions_card, fig4, sticky]
def disease_params_data_callback(ts, reset_clicks, rows): ctx = dash.callback_context if ctx.triggered: c_id = ctx.triggered[0]['prop_id'].split('.')[0] if reset_clicks is not None and c_id == 'disease-params-reset-defaults': for row in rows: reset_variable(row['id']) row['value'] = get_variable(row['id']) for row in rows: if not isinstance(row['value'], (int, float)): row['value'] = get_variable(row['id']) if row['value'] < 0: row['value'] = 0 elif row['value'] > 100: row['value'] = 100 set_variable(row['id'], float(row['value'])) return rows
def mutate(root, info, event_id): iv_objs = get_active_interventions() for iv in iv_objs: if iv.id and event_id == iv.id: break iv_tuple = iv.make_iv_tuple() iv_id = int(event_id) iv_list = list(get_variable('interventions')) for iv in iv_list: if iv == iv_tuple: break else: raise GraphQLError('invalid intervention ID') iv_list.remove(iv) set_variable('interventions', iv_list) return dict(ok=True)
def district_heating_callback(bio_emission_factor, *args): set_variable('bio_emission_factor', bio_emission_factor) ratios = get_variable('district_heating_target_production_ratios') total_sum = sum(args) shares = [val / total_sum for val in args] for slider, share in zip(ratio_sliders, shares): ratios[slider.method] = int(share * 100) diff = 100 - sum(ratios.values()) ratios[list(ratios.keys())[0]] += diff set_variable('district_heating_target_production_ratios', ratios) production_stats, production_source = calc_district_heating_unit_emissions_forecast( ) fig = generate_district_heating_forecast_graph(production_stats) table = generate_district_heating_forecast_table(production_stats) fuel_fig = generate_production_mix_graph(production_source) return [fig, table, fuel_fig]
def apply(self): reset_variables() ivs = get_variable('interventions') if self.interventions: ivs += self.interventions set_variable('interventions', ivs) if self.variables: for key, val in self.variables.items(): set_variable(key, val) set_variable('preset_scenario', self.id)
def district_heating_callback(demand_value, heat_pump_value, emissionless_bio): set_variable('district_heating_target_demand_change', demand_value) set_variable('bio_is_emissionless', emissionless_bio) ratios = get_variable('district_heating_target_production_ratios') ratios.pop('Lämpöpumput') rest_sum = sum(ratios.values()) rest_shares = {key: val / rest_sum for key, val in ratios.items()} heat_pump_share = heat_pump_value / 100 for_rest = 1 - heat_pump_share new_ratios = { key: int(100 * val * for_rest) for key, val in rest_shares.items() } new_ratios['Lämpöpumput'] = 100 - sum(new_ratios.values()) set_variable('district_heating_target_production_ratios', new_ratios) df = get_district_heating_unit_emissions_forecast() fig = generate_district_heating_forecast_graph(df) table = generate_district_heating_forecast_table(df) return fig, table
def solar_power_callback(existing_building_perc, new_building_perc): # First see what the maximum solar production capacity is to set the # Y axis maximum. set_variable('solar_power_existing_buildings_percentage', 100) set_variable('solar_power_new_buildings_percentage', 100) kwp_max = predict_solar_power_production() # Then predict with the given percentages. set_variable('solar_power_existing_buildings_percentage', existing_building_perc) set_variable('solar_power_new_buildings_percentage', new_building_perc) kwp_df = predict_solar_power_production() ymax = kwp_max.SolarPowerExisting.iloc[-1] fig_old = generate_solar_power_graph(kwp_df, "Vanhan", "SolarPowerExisting", ymax, True) ymax = kwp_max.SolarPowerNew.iloc[-1] fig_new = generate_solar_power_graph(kwp_df, "Uuden", "SolarPowerNew", ymax, False) fig_tot, ekwpa, nkwpa = generate_solar_power_stacked(kwp_df) ef_df = predict_electricity_emission_factor() kwp_df['EmissionReductions'] = ef_df['EmissionFactor'] * kwp_df[ 'SolarPowerAll'] / 1000 graph = PredictionGraph( sector_name='ElectricityConsumption', unit_name='kt', title='Aurinkopaneelien päästövähennykset', ) graph.add_series(kwp_df, trace_name='Päästövähennykset', column_name='EmissionReductions') fig_emissions = graph.get_figure() s = kwp_df.SolarPowerAll forecast = s.iloc[-1] * get_variable('yearly_pv_energy_production_kwh_wp') existing_kwpa = html.Div([ html.Span("Kun aurinkopaneeleita rakennetaan "), html.Span('%d %%' % existing_building_perc, className='summary-card__value'), html.Span( " kaikesta vanhan rakennuskannan kattopotentiaalista, Helsingin kaupunkikonsernin tulee rakentaa aurinkopaneeleja " ), html.Span("%d kWp" % (1000 * ekwpa * CITY_OWNED / 100), className='summary-card__value'), html.Span( " vuodessa skenaarion toteutumiseksi. Muiden kuin Helsingin kaupungin tulee rakentaa " ), html.Span("%d kWp" % (1000 * ekwpa * (100 - CITY_OWNED) / 100), className='summary-card__value'), html.Span(" vuodessa."), ]) new_kwpa = html.Div([ html.Span("Kun uuteen rakennuskantaan rakennetaan aurinkopaneeleja "), html.Span('%d %%' % new_building_perc, className='summary-card__value'), html.Span( " kaikesta kattopotentiaalista, Helsingin kaupunkikonsernin tulee rakentaa aurinkopaneeleja " ), html.Span("%d kWp" % (1000 * nkwpa * CITY_OWNED / 100), className='summary-card__value'), html.Span( " vuodessa skenaarion toteutumiseksi. Muiden kuin Helsingin kaupungin tulee rakentaa " ), html.Span("%d kWp" % (1000 * nkwpa * (100 - CITY_OWNED) / 100), className='summary-card__value'), html.Span(" vuodessa."), ]) sticky = StickyBar( label='Aurinkosähkön tuotanto', value=forecast, goal=SOLAR_POWER_GOAL, unit='GWh', current_page=page, below_goal_good=False, ) return [ fig_old, fig_new, fig_tot, fig_emissions, existing_kwpa, new_kwpa, sticky.render() ]
def set_variable(self, name, val): return set_variable(name, val)
def person_age_callback(age, mobility_limit): set_variable('sample_limit_mobility', mobility_limit) return render_model_param_graphs(age)
dfs = pool.map(simulate_monte_carlo, range(1000)) df = pd.concat(dfs) df.index.name = 'date' df = df.reset_index() df['scenario'] = scenario.id df.to_csv('reina_%s.csv' % scenario.id, index=False) return df if __name__ == '__main__': if False: from variables import allow_set_variable, get_variable, set_variable with allow_set_variable(): set_variable('simulation_days', 50) df = simulate_individuals() exit() if False: from scenarios import SCENARIOS for scenario in SCENARIOS: df = run_monte_carlo(scenario.id) print(df[df.date == df.date.max()]) last = df[df.date == df.date.max()] print(last.dead.describe(percentiles=[.25, .5, .75])) exit() if False: sample_model_parameters('symptom_severity', 90) exit()
def district_heating_consumption_callback(existing_building_perc, new_building_perc): set_variable('district_heating_existing_building_efficiency_change', existing_building_perc / 10) set_variable('district_heating_new_building_efficiency_change', new_building_perc / 10) df = predict_district_heat_consumption() geo_df = predict_geothermal_production() geo_df = geo_df[geo_df.Forecast] df['GeoEnergyProductionExisting'] = geo_df['GeoEnergyProductionExisting'] df['GeoEnergyProductionNew'] = geo_df['GeoEnergyProductionNew'] df['ExistingBuildingHeatUse'] -= df['GeoEnergyProductionExisting'].fillna( 0) df['NewBuildingHeatUse'] -= df['GeoEnergyProductionNew'].fillna(0) first_forecast = df[df.Forecast].iloc[0] last_forecast = df[df.Forecast].iloc[-1] last_history = df[~df.Forecast].iloc[-1] cd = CardDescription() org_owned = get_variable('building_area_owned_by_org') / 100 geo_production = last_forecast.GeoEnergyProductionExisting + last_forecast.GeoEnergyProductionNew cd.set_values( existing_renovation=get_variable( 'district_heating_existing_building_efficiency_change'), new_improvement=get_variable( 'district_heating_new_building_efficiency_change'), existing_next_year_reduction=(1 - (first_forecast.ExistingBuildingHeatUse - last_history.ExistingBuildingHeatUse)) * org_owned, new_area=last_forecast.NewBuildingNetArea, existing_area=last_forecast.ExistingBuildingNetArea, geo_production=geo_production, geo_percentage=(geo_production / last_forecast.TotalHeatConsumption) * 100, ) existing_desc = cd.render(""" Skenaarion mukaan nykyistä rakennuskantaa remontoidaan siten, että rakennuksien energiatehokkuus paranee {existing_renovation:noround} % vuodessa. Ensi vuonna {org_genitive} omistamien rakennuksien lämmönkulutuksen pitää pudota {existing_next_year_reduction} GWh. """) new_desc = cd.render(""" Uuden rakennuskannan energiatehokkuus paranee skenaariossa {new_improvement:noround} % vuodessa. Vuonna {target_year} nykyistä rakennuskantaa on {existing_area} milj. kem² ja uutta rakennuskantaa {new_area} milj. kem². """) geo_desc = cd.render(""" Vanhassa ja uudessa rakennuskannassa korvataan kaukolämpöä paikallisesti tuotetulla maalämmöllä siten, että vuonna {target_year} kaukolämpöä korvataan {geo_production} GWh ({geo_percentage} % sen vuoden kaukolämmönkulutuksesta). """) fig1 = draw_existing_building_unit_heat_factor_graph(df) fig2 = draw_new_building_unit_heat_factor_graph(df) geo_fig = PredictionFigure( sector_name='BuildingHeating', unit_name='GWh', title='Maalämmöllä korvattu kaukolämpö', fill=True, ) geo_fig.add_series( df=geo_df, column_name='GeoEnergyProduction', trace_name='Maalämpötuotanto', ) fig3 = draw_heat_consumption(df) df = predict_district_heating_emissions() unit_emissions_card = make_unit_emissions_card(df) fig4 = draw_district_heat_consumption_emissions(df) sticky = make_bottom_bar(df) return [ fig1, dbc.Col(existing_desc, style=dict(minHeight='8rem')), fig2, dbc.Col(new_desc, style=dict(minHeight='8rem')), geo_fig.get_figure(), dbc.Col(geo_desc, style=dict(minHeight='8rem')), fig3, unit_emissions_card, fig4, sticky ]
def electricity_consumption_callback(value): set_variable('electricity_consumption_per_capita_adjustment', value / 10) df = predict_electricity_consumption_emissions() graph = PredictionFigure(sector_name='ElectricityConsumption', title=_('Electricity consumption per resident'), unit_name='kWh/as.') graph.add_series(df=df, trace_name=_('Consumption/res.'), column_name='ElectricityConsumptionPerCapita') per_capita_fig = graph.get_figure() graph = PredictionFigure( sector_name='ElectricityConsumption', title=_('Electricity consumption'), unit_name='GWh', fill=True, ) graph.add_series(df=df, trace_name=_('Electricity consumption'), column_name='NetConsumption') consumption_fig = graph.get_figure() graph = PredictionFigure( sector_name='ElectricityConsumption', title=_('Electricity production emission factor'), unit_name='g/kWh', smoothing=True, ) graph.add_series(df=df, trace_name=_('Emission factor'), column_name='EmissionFactor') factor_fig = graph.get_figure() graph = PredictionFigure( sector_name='ElectricityConsumption', title=_('Electricity consumption emissions'), unit_name='kt', smoothing=True, fill=True, ) graph.add_series(df=df, trace_name='Päästöt', column_name='NetEmissions') emission_fig = graph.get_figure() graph = PredictionFigure( sector_name='ElectricityConsumption', title=_('Local PV production'), unit_name='GWh', smoothing=True, fill=True, ) graph.add_series(df=df, trace_name='Tuotanto', column_name='SolarProduction') solar_fig = graph.get_figure() first_forecast = df[df.Forecast].iloc[0] last_forecast = df[df.Forecast].iloc[-1] last_history = df[~df.Forecast].iloc[-1] last_history_year = df[~df.Forecast].index.max() cd = CardDescription() cd.set_values( per_resident_adj=get_variable( 'electricity_consumption_per_capita_adjustment'), per_resident_change=( (last_forecast.ElectricityConsumptionPerCapita / last_history.ElectricityConsumptionPerCapita) - 1) * 100, last_history_year=last_history.name, solar_production_target=last_forecast.SolarProduction, solar_production_perc=(last_forecast.SolarProduction * 100) / last_forecast.ElectricityConsumption, solar_production_hist=last_history.SolarProduction, ) per_resident_desc = cd.render(""" Skenaariossa asukaskohtainen sähkönkulutus pienenee {per_resident_adj:noround} % vuodessa. Vuonna {target_year} asukaskohtainen kulutus on muuttunut {per_resident_change} % nykyhetkestä. """) solar_desc = cd.render(""" Vuonna {target_year} {municipality_locative} sijaitsevilla aurinkopaneeleilla tuotetaan {solar_production_target} GWh, joka on {solar_production_perc} % kaikesta vuoden {target_year} kulutussähköstä. """) bar = StickyBar(label=_('Electicity consumption emissions'), value=last_forecast.NetEmissions, unit='kt', current_page=page) return [ per_capita_fig, dbc.Col(per_resident_desc, style=dict(minHeight='6rem')), solar_fig, dbc.Col(solar_desc, style=dict(minHeight='6rem')), consumption_fig, factor_fig, emission_fig, bar.render() ]
def refresh_graph_cards(self): # First see what the maximum solar production capacity is to set the # Y axis maximum. set_variable('solar_power_existing_buildings_percentage', 100) set_variable('solar_power_new_buildings_percentage', 100) kwp_max_df = predict_solar_power_production() # Then predict with the given percentages. existing_card = self.get_card('existing-buildings') set_variable('solar_power_existing_buildings_percentage', existing_card.get_slider_value()) future_card = self.get_card('new-buildings') set_variable('solar_power_new_buildings_percentage', future_card.get_slider_value()) df = predict_solar_power_production() forecast_df = df[df.Forecast] hist_df = df[~df.Forecast] years_left = forecast_df.index.max() - hist_df.index.max() ekwpa = (forecast_df.SolarPowerExisting.iloc[-1] - hist_df.SolarPowerExisting.iloc[-1]) / years_left nkwpa = forecast_df.SolarPowerNew.iloc[-1] / years_left cd = CardDescription() city_owned = get_variable('building_area_owned_by_org') / 100 cd.set_values( existing_building_perc=existing_card.get_slider_value(), org_existing_building_kwp=1000 * ekwpa * city_owned, others_existing_building_kwp=1000 * ekwpa * (1 - city_owned) ) existing_card.set_description(cd.render(""" Kun aurinkopaneeleita rakennetaan {existing_building_perc:noround} % kaikesta vanhan rakennuskannan kattopotentiaalista, {org_genitive} tulee rakentaa aurinkopaneeleita {org_existing_building_kwp} kWp vuodessa skenaarion toteutumiseksi. Muiden kuin {org_genitive} tulee rakentaa {others_existing_building_kwp} kWp aurinkopaneeleita vuodessa. """)) cd.set_values( new_building_perc=future_card.get_slider_value(), org_new_building_kwp=1000 * nkwpa * city_owned, others_new_building_kwp=1000 * nkwpa * (1 - city_owned) ) future_card.set_description(cd.render(""" Kun uuteen rakennuskantaan rakennetaan aurinkopaneeleja {new_building_perc:noround} % kaikesta kattopotentiaalista, {org_genitive} tulee rakentaa aurinkopaneeleja {org_new_building_kwp} kWp vuodessa skenaarion toteutumiseksi. Muiden kuin {org_genitive} tulee rakentaa {others_new_building_kwp} kWp aurinkopaneeleita vuodessa. """)) ymax = kwp_max_df.SolarPowerExisting.iloc[-1] fig = PredictionFigure( sector_name='ElectricityConsumption', unit_name='MWp', y_max=ymax, color_scale=2 ) fig.add_series(df=df, trace_name=_('Peak power'), column_name='SolarPowerExisting', color_idx=0) existing_card.set_figure(fig) fig = PredictionFigure( sector_name='ElectricityConsumption', unit_name='MWp', y_max=ymax, color_scale=2 ) fig.add_series(df=df, trace_name=_('Peak power'), column_name='SolarPowerNew', color_idx=1) future_card.set_figure(fig) pv_kwh_wp = get_variable('yearly_pv_energy_production_kwh_wp') df.SolarPowerNew = df.SolarPowerNew * pv_kwh_wp df.SolarPowerExisting = df.SolarPowerExisting * pv_kwh_wp df.loc[~df.Forecast, 'SolarPowerNew'] = np.nan card = self.get_card('production') fig = PredictionFigure( sector_name='ElectricityConsumption', unit_name='GWh', stacked=True, fill=True, color_scale=2 ) fig.add_series(df=df, trace_name=_('Existing buildings'), column_name='SolarPowerExisting', color_idx=0) fig.add_series(df=df, trace_name=_('Future buildings'), column_name='SolarPowerNew', color_idx=1) card.set_figure(fig) card = self.get_card('emission-impact') fig = PredictionFigure( sector_name='ElectricityConsumption', unit_name='kt', fill=True ) ef_df = predict_electricity_emission_factor() df['NetEmissions'] = -df['SolarProduction'] * ef_df['EmissionFactor'] / 1000 fig.add_series(df=df, column_name='NetEmissions', trace_name=_('Emissions')) card.set_figure(fig) s = df.SolarProduction self.solar_production_forecast = s.iloc[-1] * get_variable('yearly_pv_energy_production_kwh_wp')
def set_extra_input_values(self, args): bio = args[0] set_variable('bio_emission_factor', bio)
def cars_callback(bev_percentage, mileage_adj): set_variable('cars_bev_percentage', bev_percentage) set_variable('cars_mileage_per_resident_adjustment', mileage_adj) df = predict_cars_emissions() df['Mileage'] /= 1000000 bev_chart = draw_bev_chart(df) """ graph = PredictionFigure( sector_name='Transportation', unit_name='%', title='Biopolttoaineiden osuus myydyissä polttoaineissa', ) graph.add_series( df=df, column_name='electric', trace_name='Bion osuus' ) biofuel_chart = graph.get_figure() """ graph = PredictionFigure( sector_name='Transportation', unit_name='km/as.', title='Ajokilometrit asukasta kohti', ) graph.add_series( df=df, column_name='PerResident', trace_name='Suorite/as.', ) per_resident_chart = graph.get_figure() # Total mileage graph = PredictionFigure( sector_name='Transportation', unit_name='milj. km', title='%s ajetut henkilöautokilometrit' % get_variable('municipality_locative'), fill=True, ) graph.add_series( df=df, column_name='Mileage', trace_name='Ajosuorite', ) mileage_chart = graph.get_figure() # Total emissions graph = PredictionFigure( sector_name='Transportation', unit_name='g/km', title='Henkilöautojen päästökerroin', ) graph.add_series( df=df, column_name='EmissionFactor', trace_name='Päästökerroin', ) emission_factor_chart = graph.get_figure() # Total emissions graph = PredictionFigure( sector_name='Transportation', unit_name='kt (CO₂e.)', title='Henkilöautoilun päästöt', fill=True, ) graph.add_series( df=df, column_name='Emissions', trace_name='Päästöt', ) emissions_chart = graph.get_figure() cd = CardDescription() first_forecast = df[df.Forecast].iloc[0] last_forecast = df[df.Forecast].iloc[-1] last_history = df[~df.Forecast].iloc[-1] cd.set_values( bev_percentage=get_variable('cars_bev_percentage'), bev_mileage=last_forecast.Mileage * last_forecast.electric, per_resident_adjustment=get_variable('cars_mileage_per_resident_adjustment'), target_population=last_forecast.Population, ) bev_desc = cd.render(""" Skenaariossa polttomoottorihenkilöautot korvautuvat sähköautoilla siten, että vuonna {target_year} {municipality_genitive} kaduilla ja teillä ajetaan sähköautoilla {bev_percentage:noround} % kaikista ajokilometreistä ({bev_mileage} milj. km). """) pr_desc = cd.render(""" Vuonna {target_year} {municipality_locative} asuu {target_population} ihmistä. Skenaariossa ajokilometrit asukasta kohti muuttuvat vuoteen {target_year} mennessä {per_resident_adjustment:noround} %. """) sticky = make_bottom_bar(df) return [ bev_chart, dbc.Col(bev_desc), emission_factor_chart, per_resident_chart, dbc.Col(pr_desc), mileage_chart, emissions_chart, sticky ]
def solar_power_callback(existing_building_perc, new_building_perc): # First see what the maximum solar production capacity is to set the # Y axis maximum. set_variable('solar_power_existing_buildings_percentage', 100) set_variable('solar_power_new_buildings_percentage', 100) kwp_max = predict_solar_power_production() # Then predict with the given percentages. set_variable('solar_power_existing_buildings_percentage', existing_building_perc) set_variable('solar_power_new_buildings_percentage', new_building_perc) kwp_df = predict_solar_power_production() ymax = kwp_max.SolarPowerExisting.iloc[-1] fig_old = generate_solar_power_graph(kwp_df, "Vanhan", "SolarPowerExisting", ymax, True) # ymax = kwp_max.SolarPowerNew.iloc[-1] fig_new = generate_solar_power_graph(kwp_df, "Uuden", "SolarPowerNew", ymax, False) fig_tot, ekwpa, nkwpa = generate_solar_power_stacked(kwp_df) graph = PredictionFigure(sector_name='ElectricityConsumption', unit_name='kt', title='Aurinkopaneelien päästövaikutukset', fill=True) ef_df = predict_electricity_emission_factor() kwp_df['NetEmissions'] = -kwp_df['SolarProduction'] * ef_df[ 'EmissionFactor'] / 1000 graph.add_series(df=kwp_df, column_name='NetEmissions', trace_name='Päästövaikutukset') fig_emissions = graph.get_figure() s = kwp_df.SolarProduction cd = CardDescription() city_owned = get_variable('building_area_owned_by_org') / 100 cd.set_values(existing_building_perc=existing_building_perc, org_existing_building_kwp=1000 * ekwpa * city_owned, others_existing_building_kwp=1000 * ekwpa * (1 - city_owned)) existing_kwpa = cd.render(""" Kun aurinkopaneeleita rakennetaan {existing_building_perc:noround} % kaikesta vanhan rakennuskannan kattopotentiaalista, {org_genitive} tulee rakentaa aurinkopaneeleita {org_existing_building_kwp} kWp vuodessa skenaarion toteutumiseksi. Muiden kuin {org_genitive} tulee rakentaa {others_existing_building_kwp} kWp aurinkopaneeleita vuodessa. """) cd.set_values(new_building_perc=new_building_perc, org_new_building_kwp=1000 * nkwpa * city_owned, others_new_building_kwp=1000 * nkwpa * (1 - city_owned)) new_kwpa = cd.render(""" Kun uuteen rakennuskantaan rakennetaan aurinkopaneeleja {new_building_perc:noround} % kaikesta kattopotentiaalista, {org_genitive} tulee rakentaa aurinkopaneeleja {org_new_building_kwp} kWp vuodessa skenaarion toteutumiseksi. Muiden kuin {org_genitive} tulee rakentaa {others_new_building_kwp} kWp aurinkopaneeleita vuodessa. """) forecast = s.iloc[-1] * get_variable('yearly_pv_energy_production_kwh_wp') sticky = StickyBar( label='Aurinkosähkön tuotanto', value=forecast, unit='GWh', current_page=page, ) return [ fig_old, fig_new, fig_tot, fig_emissions, existing_kwpa, new_kwpa, sticky.render() ]
def set_extra_input_values(self, args): cop = args[0] set_variable('district_heating_heat_pump_cop', float(cop / 10))