dwind 0.3__py3-none-any.whl

dwind/resource.py

@@ -0,0 +1,166 @@
+import h5py as h5
+import pandas as pd
+
+from dwind import Configuration
+
+
+class ResourcePotential:
+    def __init__(
+        self, parcels, model_config: Configuration, tech="wind", application="fom", year="2018"
+    ):
+        self.df = parcels
+        self.tech = tech
+        self.application = application
+        self.year = year
+        self.config = model_config
+
+        if self.tech not in ("wind", "solar"):
+            raise ValueError("`tech` must be one of 'solar' or 'wind'.")
+
+    def create_rev_gid_to_summary_lkup(self, configs, save_csv=True):
+        config_dfs = []
+        for c in configs:
+            file_str = self.config.rev.DIR / f"rev_{c}_generation_{self.year}.h5"
+
+            with h5.File(file_str, "r") as hf:
+                rev_index = pd.DataFrame(hf["meta"][...]).index.to_series()
+                gids = pd.DataFrame(hf["meta"][...])[["gid"]]
+                annual_energy = pd.DataFrame(hf["annual_energy"][...])
+                cf_mean = pd.DataFrame(hf["cf_mean"][...])
+
+            config_df = pd.concat([rev_index, gids, annual_energy, cf_mean], axis=1)
+            config_df.columns = [
+                f"rev_index_{self.tech}",
+                f"rev_gid_{self.tech}",
+                f"{self.tech}_naep",
+                f"{self.tech}_cf",
+            ]
+
+            config_df["config"] = c
+            config_dfs.append(config_df)
+
+        summary_df = pd.concat(config_dfs)
+
+        if save_csv:
+            save_name = (
+                self.config.rev.generation[f"{self.tech}_DIR"]
+                / f"lkup_rev_gid_to_summary_{self.tech}_{self.year}.csv"
+            )
+            summary_df.to_csv(save_name, index=False)
+
+        return summary_df
+
+    def find_rev_summary_table(self):
+        if self.tech == "solar":
+            configs = self.config.rev.settings.solar
+            config_col = "solar_az_tilt"
+            col_list = ["gid", f"rev_gid_{self.tech}", config_col]
+            self.df[config_col] = self.df[f"azimuth_{self.application}"].map(
+                self.config.rev.settings.azimuth_direction_to_degree
+            )
+            self.df[config_col] = (
+                self.df[config_col].astype(str) + "_" + self.df[f"tilt_{self.tech}"].astype(str)
+            )
+        elif self.tech == "wind":
+            configs = self.rev.settings.wind
+            config_col = "turbine_class"
+            col_list = [
+                "gid",
+                f"rev_gid_{self.tech}",
+                config_col,
+                "turbine_height_m",
+                "wind_turbine_kw",
+            ]
+            self.df[config_col] = self.df["wind_turbine_kw"].map(self.config.rev.turbine_class_dict)
+
+        out_cols = [*col_list, f"rev_index_{self.tech}", f"{self.tech}_naep", f"{self.tech}_cf"]
+
+        f_gen = (
+            self.config.rev.generation[f"{self.tech}_DIR"]
+            / f"lkup_rev_gid_to_summary_{self.tech}_{self.year}.csv"
+        )
+
+        if f_gen.exists():
+            generation_summary = pd.read_csv(f_gen)
+        else:
+            generation_summary = self.create_rev_gid_to_summary_lkup(configs)
+
+        generation_summary = (
+            generation_summary.reset_index(drop=True)
+            .drop_duplicates(subset=[f"rev_index_{self.tech}", "config"])
+            .rename(columns={"config": config_col})
+        )
+        agents = self.df.merge(
+            generation_summary, how="left", on=[f"rev_index_{self.tech}", config_col]
+        )
+        return agents[out_cols]
+
+    def prepare_agents_for_gen(self):
+        # create lookup column based on each tech
+        if self.tech == "wind":
+            # drop wind turbine size duplicates
+            # SINCE WE ASSUME ANY TURBINE IN A GIVEN CLASS HAS THE SAME POWER CURVE
+            self.df.drop_duplicates(subset=["gid", "wind_size_kw"], keep="last", inplace=True)
+            # if running FOM application, only consider a single (largest) turbine size
+            if self.application == "fom":
+                self.df = self.df.loc[self.df["wind_size_kw"] == self.df["wind_size_kw_fom"]]
+
+            self.df["turbine_class"] = self.df["wind_turbine_kw"].map(
+                self.config.rev.turbine_class_dict
+            )
+
+        if self.tech == "solar":
+            # NOTE: tilt and azimuth are application-specific
+            self.df["solar_az_tilt"] = self.df[f"azimuth_{self.application}"].map(
+                self.config.rev.settings.azimuth_direction_to_degree
+            )
+            self.df["solar_az_tilt"] = self.df["solar_az_tilt"].astype(str)
+            self.df["solar_az_tilt"] = (
+                self.df["solar_az_tilt"] + "_" + self.df[f"tilt_{self.application}"].astype(str)
+            )
+
+    def merge_gen_to_agents(self, tech_agents):
+        if self.tech == "wind":
+            cols = ["turbine_height_m", "wind_turbine_kw", "turbine_class"]
+        else:
+            # NOTE: need to drop duplicates in solar agents
+            # since multiple rows exist due to multiple turbine configs for a given parcel
+            tech_agents = tech_agents.drop_duplicates(
+                subset=["gid", "rev_gid_solar", "solar_az_tilt"]
+            )
+            cols = ["solar_az_tilt"]
+
+        cols.extend(["gid", f"rev_index_{self.tech}"])
+
+        self.df = self.df.merge(tech_agents, how="left", on=cols)
+
+    def match_rev_summary_to_agents(self):
+        self.prepare_agents_for_gen()
+        tech_agents = self.find_rev_summary_table()
+        self.merge_gen_to_agents(tech_agents)
+
+        if self.tech == "wind":
+            # fill nan generation values
+            self.df = self.df.loc[
+                ~((self.df["wind_naep"].isnull()) & (self.df["turbine_class"] != "none"))
+            ]
+            self.df["wind_naep"] = self.df["wind_naep"].fillna(0.0)
+            self.df["wind_cf"] = self.df["wind_cf"].fillna(0.0)
+            # self.df['wind_cf_hourly'] = self.df['wind_cf_hourly'].fillna(0.)
+            # calculate annual energy production (aep)
+            self.df["wind_aep"] = self.df["wind_naep"] * self.df["wind_turbine_kw"]
+            # self.df = self.df.drop(columns="turbine_class")
+        else:
+            # fill nan generation values
+            self.df = self.df.loc[~(self.df["solar_naep"].isnull())]
+            # size groundmount system to equal wind aep
+            # self.df['solar_size_kw_fom'] = np.where(
+            # self.df['solar_groundmount'],
+            # self.df['wind_aep'] / (self.df['solar_cf'] * 8760),
+            # self.df['solar_size_kw_fom']
+            # )
+
+            # calculate annual energy production (aep)
+            self.df["solar_aep"] = self.df["solar_naep"] * self.df["solar_size_kw_fom"]
+
+        return self.df

dwind/run.py

@@ -0,0 +1,288 @@
+"""Enables running dwind as a CLI tool, the primary interface for working with dwind."""
+
+from __future__ import annotations
+
+import sys
+import tomllib
+from enum import Enum
+from typing import Annotated
+from pathlib import Path
+
+import typer
+import pandas as pd
+
+
+# from memory_profiler import profile
+
+
+app = typer.Typer()
+
+DWIND = Path("/projects/dwind/agents")
+
+
+class Sector(str, Enum):
+    """Typer helper for validating the sector input.
+
+    - "fom": Front of meter
+    - "btm": Behind the meter
+    """
+
+    fom = "fom"
+    btm = "btm"
+
+
+class Scenario(str, Enum):
+    """Scenario to run.
+
+    The only current option is "baseline".
+    """
+
+    baseline = "baseline"
+
+
+def year_callback(ctx: typer.Context, param: typer.CallbackParam, value: int):
+    """Typer helper to validate the year input.
+
+    Parameters
+    ----------
+    ctx : typer.Context
+        The Typer context.
+    param : typer.CallbackParam
+        The Typer parameter.
+    value : int
+        User input for the analysis year basis, must be one of 2022, 2024, or 2025.
+
+    Returns:
+    -------
+    int
+        The input :py:param:`value`, if it is a valid input.
+
+    Raises:
+    ------
+    typer.BadParameter
+        Raised if the input is not one of 2022, 2024, or 2025.
+    """
+    valid_years = (2022, 2024, 2025, 2035, 2040)
+    if ctx.resilient_parsing:
+        return
+    if value not in valid_years:
+        raise typer.BadParameter(f"Only {valid_years} are valid options for `year`, not {value}.")
+    return value
+
+
+def load_agents(
+    file_name: str | Path | None = None,
+    location: str | None = None,
+    sector: str | None = None,
+) -> pd.DataFrame:
+    """Load the agent file based on a filename or the location and sector to a Pandas DataFrame,
+    and return the data frame.
+
+    Args:
+        file_name (str | Path | None, optional): Name of the agent file, if not auto-generating from
+            the :py:attr:`location` and :py:attr:`sector` inputs. Defaults to None.
+        location (str | None, optional): The name of the location or grouping, such as
+            "colorado_larimer" or "priority1". Defaults to None.
+        sector (str | None, optional): The name of the section. Must be one of "btm" or "fom".
+            Defaults to None.
+
+    Returns:
+        pd.DataFrame: The agent DataFrame.
+    """
+    from dwind.model import Agents
+
+    if file_name is None and (location is None or sector is None):
+        raise ValueError("One of `file_name` or `location` and `sector` must be provided.")
+
+    f_agents = (
+        file_name if file_name is not None else DWIND / f"{location}/agents_dwind_{sector}.parquet"
+    )
+    if not f_agents.exists():
+        f_agents = f_agents.with_suffix(".pickle")
+    agents = Agents(agent_file=f_agents).agents
+    return agents
+
+
+@app.command()
+def run_hpc(
+    location: Annotated[
+        str, typer.Option(help="The state, state_county, or priority region to run.")
+    ],
+    sector: Annotated[
+        Sector, typer.Option(help="One of fom (front of meter) or btm (back-of-the-meter).")
+    ],
+    scenario: Annotated[
+        Scenario,
+        typer.Option(help="The scenario to run (baseline is the current only option)."),
+    ],
+    year: Annotated[
+        int,
+        typer.Option(
+            callback=year_callback,
+            help="The assumption year for the analysis. Options are 2022, 2024, and 2025.",
+        ),
+    ],
+    repository: Annotated[
+        str, typer.Option(help="Path to the dwind repository to use when running the model.")
+    ],
+    nodes: Annotated[
+        int,
+        typer.Option(
+            help="Number of HPC nodes or CPU nodes to run on. -1 indicates 75% of CPU limit."
+        ),
+    ],
+    allocation: Annotated[str, typer.Option(help="HPC allocation name.")],
+    memory: Annotated[int, typer.Option(help="Node memory, in GB (HPC only).")],
+    walltime: Annotated[int, typer.Option(help="Node walltime request, in hours.")],
+    feature: Annotated[
+        str,
+        typer.Option(
+            help=(
+                "Additional flags for the SLURM job, using formatting such as"
+                " --qos=high or --depend=[state:job_id]."
+            )
+        ),
+    ],
+    env: Annotated[
+        str,
+        typer.Option(
+            help="The path to the dwind Python environment that should be used to run the model."
+        ),
+    ],
+    model_config: Annotated[
+        str, typer.Option(help="Complete file name and path of the model configuration file")
+    ],
+    dir_out: Annotated[
+        str, typer.Option(help="Path to where the chunked outputs should be saved.")
+    ],
+    stdout_path: Annotated[str | None, typer.Option(help="The path to write stdout logs.")] = None,
+):
+    """Run dwind via the HPC multiprocessing interface."""
+    sys.path.append(repository)
+    from dwind.mp import MultiProcess
+
+    # NOTE: collect_by_priority has been removed but may need to be reinstated
+
+    mp = MultiProcess(
+        location=location,
+        sector=sector,
+        scenario=scenario,
+        year=year,
+        env=env,
+        n_nodes=nodes,
+        memory=memory,
+        walltime=walltime,
+        allocation=allocation,
+        feature=feature,
+        repository=repository,
+        model_config=model_config,
+        dir_out=dir_out,
+        stdout_path=stdout_path,
+    )
+
+    agent_df = load_agents(location=location, sector=sector)
+    mp.run_jobs(agent_df)
+
+
+@app.command("run-config")
+def run_hpc_from_config(
+    config_path: Annotated[
+        str, typer.Argument(help="Path to configuration TOML with run and model parameters.")
+    ],
+):
+    """Run dwind via the HPC multiprocessing interface from a configuration file."""
+    config_path = Path(config_path).resolve()
+    with config_path.open("rb") as f:
+        config = tomllib.load(f)
+    print(config)
+
+    run_hpc(**config)
+
+
+@app.command()
+def run_chunk(
+    # start: Annotated[int, typer.Option(help="chunk start index")],
+    # end: Annotated[int, typer.Option(help="chunk end index")],
+    location: Annotated[
+        str, typer.Option(help="The state, state_county, or priority region to run.")
+    ],
+    sector: Annotated[
+        Sector, typer.Option(help="One of fom (front of meter) or btm (back-of-the-meter).")
+    ],
+    scenario: Annotated[str, typer.Option(help="The scenario to run, such as baseline.")],
+    year: Annotated[
+        int, typer.Option(callback=year_callback, help="The year basis of the scenario.")
+    ],
+    chunk_ix: Annotated[int, typer.Option(help="Chunk number/index. Used for logging.")],
+    out_path: Annotated[str, typer.Option(help="save path")],
+    repository: Annotated[
+        str, typer.Option(help="Path to the dwind repository to use when running the model.")
+    ],
+    model_config: Annotated[
+        str, typer.Option(help="Complete file name and path of the model configuration file")
+    ],
+):
+    """Run a chunk of a dwind model. Internal only, do not run outside the context of a
+    chunked analysis.
+    """
+    # Import the correct version of the library
+    sys.path.append(repository)
+    from dwind.model import Model
+
+    agent_file = Path(out_path).resolve() / f"agents_{chunk_ix}.pqt"
+    agents = load_agents(file_name=agent_file)
+    agent_file.unlink()
+
+    model = Model(
+        agents=agents,
+        location=location,
+        sector=sector,
+        scenario=scenario,
+        year=year,
+        chunk_ix=chunk_ix,
+        out_path=out_path,
+        model_config=model_config,
+    )
+    model.run()
+
+
+@app.command()
+def run(
+    location: Annotated[
+        str, typer.Option(help="The state, state_county, or priority region to run.")
+    ],
+    sector: Annotated[
+        Sector, typer.Option(help="One of fom (front of meter) or btm (back-of-the-meter).")
+    ],
+    scenario: Annotated[str, typer.Option(help="The scenario to run, such as 'baseline'.")],
+    year: Annotated[int, typer.Option(help="The year basis of the scenario.")],
+    out_path: Annotated[str, typer.Option(help="save path")],
+    repository: Annotated[
+        str, typer.Option(help="Path to the dwind repository to use when running the model.")
+    ],
+    model_config: Annotated[
+        str, typer.Option(help="Complete file name and path of the model configuration file")
+    ],
+):
+    """Run the dwind model. Does not yet work, do not run unless dwind has been configured
+    to not rely on Kestrel usage.
+    """
+    # Import the correct version of the library
+    sys.path.append(repository)
+    from dwind.model import Model
+
+    agents = load_agents(location=location, sector=sector)
+    model = Model(
+        agents=agents,
+        location=location,
+        sector=sector,
+        scenario=scenario,
+        year=year,
+        out_path=out_path,
+        model_config=model_config,
+    )
+    model.run()
+
+
+if __name__ == "__main__":
+    app()

dwind/scenarios.py

@@ -0,0 +1,139 @@
+import json
+from pathlib import Path
+
+import pandas as pd
+
+
+def config_nem(scenario, year):
+    # NEM_SCENARIO_CSV
+    nem_opt_scens = ["highrecost", "lowrecost", "re100"]
+    # nem_opt_scens = ['der_value_HighREcost', 'der_value_LowREcost', 're_100']
+    if scenario in nem_opt_scens:
+        nem_scenario_csv = "nem_optimistic_der_value_2035.csv"
+    elif scenario == "baseline" and year in (2022, 2025, 2035):
+        nem_scenario_csv = f"nem_baseline_{year}.csv"
+    else:
+        nem_scenario_csv = "nem_baseline_2035.csv"
+
+    return nem_scenario_csv
+
+
+def config_cambium(scenario):
+    # CAMBIUM_SCENARIO
+    if scenario == "highrecost" or scenario == "re100":
+        cambium_scenario = "StdScen20_HighRECost"
+    elif scenario == "lowrecost":
+        cambium_scenario = "StdScen20_LowRECost"
+    else:
+        # cambium_scenario = "StdScen20_MidCase"
+        cambium_scenario = "Cambium23_MidCase"
+
+    return cambium_scenario
+
+
+def config_costs(scenario, year):
+    # COST_INPUTS
+    f = Path(f"/projects/dwind/configs/costs/atb24/ATB24_costs_{scenario}_{year}.json").resolve()
+    with f.open("r") as f_in:
+        cost_inputs = json.load(f_in)
+
+    return cost_inputs
+
+
+def config_performance(scenario, year):
+    # PERFORMANCE_INPUTS
+    if scenario == "baseline" and year == 2022:
+        performance_inputs = {
+            "solar": pd.DataFrame(
+                [
+                    ["res", 0.017709659, 0.005],
+                    ["com", 0.017709659, 0.005],
+                    ["ind", 0.017709659, 0.00],
+                ],
+                columns=["sector_abbr", "pv_kw_per_sqft", "pv_degradation_factor"],
+            ),
+            "wind": pd.DataFrame(
+                [
+                    [2.5, 0.083787756, 0.85],
+                    [5.0, 0.083787756, 0.85],
+                    [10.0, 0.083787756, 0.85],
+                    [20.0, 0.083787756, 0.85],
+                    [50.0, 0.116657183, 0.85],
+                    [100.0, 0.116657183, 0.85],
+                    [250.0, 0.106708234, 0.85],
+                    [500.0, 0.106708234, 0.85],
+                    [750.0, 0.106708234, 0.85],
+                    [1000.0, 0.106708234, 0.85],
+                    [1500.0, 0.106708234, 0.85],
+                ],
+                columns=["wind_turbine_kw_btm", "perf_improvement_factor", "wind_derate_factor"],
+            ),
+        }
+    else:
+        performance_inputs = {
+            "solar": {
+                "pv_kw_per_sqft": {"res": 0.021677397, "com": 0.021677397, "ind": 0.021677397},
+                "pv_degradation_factor": {"res": 0.005, "com": 0.005, "ind": 0.005},
+            },
+            "wind": {
+                "perf_improvement_factor": {
+                    2.5: 0.23136759,
+                    5.0: 0.23136759,
+                    10.0: 0.23136759,
+                    20.0: 0.23136759,
+                    50.0: 0.23713196,
+                    100.0: 0.23713196,
+                    250.0: 0.23617185,
+                    500.0: 0.23617185,
+                    750.0: 0.23617185,
+                    1000.0: 0.23617185,
+                    1500.0: 0.23617185,
+                },
+                "wind_derate_factor": {
+                    2.5: 0.85,
+                    5.0: 0.85,
+                    10.0: 0.85,
+                    20.0: 0.85,
+                    50.0: 0.85,
+                    100.0: 0.85,
+                    250.0: 0.85,
+                    500.0: 0.85,
+                    750.0: 0.85,
+                    1000.0: 0.85,
+                    1500.0: 0.85,
+                },
+            },
+        }
+
+    return performance_inputs
+
+
+def config_financial(scenario, year):
+    # FINANCIAL_INPUTS
+    scenarios = ("baseline", "metering", "billing")
+    if scenario in scenarios and year == 2025:
+        f = f"/projects/dwind/configs/costs/atb24/ATB24_financing_baseline_{year}.json"
+        i = Path("/projects/dwind/data/incentives/2025_incentives.json").resolve()
+        with i.open("r") as i_in:
+            incentives = json.load(i_in)
+    elif scenario in scenarios and year in (2035, 2040):
+        f = "/projects/dwind/configs/costs/atb24/ATB24_financing_baseline_2035.json"
+    else:
+        # use old assumptions
+        f = "/projects/dwind/configs/costs/atb20/ATB20_financing_baseline_2035.json"
+    f = Path(f).resolve()
+
+    with f.open("r") as f_in:
+        financials = json.load(f_in)
+    if year == 2025:
+        financials["BTM"]["itc_fraction_of_capex"] = incentives
+        financials["FOM"]["itc_fraction_of_capex"] = incentives
+        financials["FOM"]["ptc_fed_dlrs_per_kwh"]["solar"] = 0.0
+        financials["FOM"]["ptc_fed_dlrs_per_kwh"]["wind"] = 0.0
+    else:
+        financials["BTM"]["itc_fraction_of_capex"] = 0.3
+        financials["FOM"]["itc_fraction_of_capex"] = 0.3
+        financials["FOM"]["ptc_fed_dlrs_per_kwh"]["solar"] = 0.0
+        financials["FOM"]["ptc_fed_dlrs_per_kwh"]["wind"] = 0.0
+
+    return financials