plan2eplus 0.1.0__py3-none-any.whl

plan2eplus/__init__.py

@@ -0,0 +1,2 @@
+def main() -> None:
+    print("Hello from geomeppy!")

plan2eplus/airflow_network/airboundary.py

@@ -0,0 +1,106 @@
+from pathlib import Path
+from eppy.bunch_subclass import EpBunch
+from geomeppy import IDF
+from helpers.helpers import key_from_value
+from helpers.ep_helpers import find_zone_subsurfaces, get_partner_of_surface, get_surface_by_name, PARTNER
+from plan.helpers import create_room_map, load_data_from_json
+from plan.interfaces import GRAPH, GraphEdgeJSON
+from subsurfaces.logic import PairOnly, find_surface_connecting_two_zones
+from airflow_network.modifiers import add_zone, add_subsurface
+
+# TODO see notes on how to make this better.. 
+
+def get_airboundary_wall(airboundary: EpBunch):
+    n = airboundary.Name
+    remain = n.split(" ")[1:]
+    return " ".join(remain)
+
+def handle_edge_airboundary(
+    e: GraphEdgeJSON,
+    room_map: dict[int, str],
+):
+    source, target = e["source"], e["target"]
+    return PairOnly(key_from_value(room_map, source), key_from_value(room_map, target))
+
+
+def get_airboundary_pairs_from_case(path_to_inputs: Path):
+    room_map = create_room_map(path_to_inputs)
+    graph_data = load_data_from_json(path_to_inputs, GRAPH)
+    edges: list[GraphEdgeJSON] = graph_data["links"]
+    return [
+        handle_edge_airboundary(e, room_map) for e in edges if e["details"]["id"] == 0
+    ]
+
+def update_air_boundary_constructions(idf: IDF, path_to_inputs: Path):
+    ab_pairs = get_airboundary_pairs_from_case(path_to_inputs)
+    for pair in ab_pairs:
+        surf = find_surface_connecting_two_zones(idf, pair)
+        assert surf
+
+        o = idf.newidfobject("CONSTRUCTION:AIRBOUNDARY")
+        o.Name = f"AirBoundary {surf.Name}"
+        idf = add_subsurface(idf, surf.Name)
+        surf.Construction_Name = o.Name 
+        partner_surf = get_partner_of_surface(idf, surf)
+        assert partner_surf
+        partner_surf.Construction_Name = o.Name
+
+    return idf
+
+def get_afn_zones(idf: IDF):
+    afn_zones = idf.idfobjects["AIRFLOWNETWORK:MULTIZONE:ZONE"]
+    assert afn_zones, "Subsurface AFN zones have not been added"
+    return [i.Zone_Name for i in afn_zones]
+
+
+
+def update_afn_for_airboundary_zones(idf: IDF):
+    airboundaries =idf.idfobjects["CONSTRUCTION:AIRBOUNDARY"]
+    for ab in airboundaries:
+        wall = get_surface_by_name(idf, get_airboundary_wall(ab))
+        assert wall
+        partner_wall = get_partner_of_surface(idf, wall)
+        assert partner_wall
+
+        afn_zone_names = get_afn_zones(idf)
+        if wall.Zone_Name not in afn_zone_names:
+            print(f"{wall.Zone_Name} not in  original AFN. Adding now.. " ) 
+            idf = add_zone(idf, wall.Zone_Name)
+
+
+        afn_zone_names = get_afn_zones(idf)
+        if partner_wall.Zone_Name not in afn_zone_names:
+            print(f"Partner {partner_wall.Zone_Name} not in  original AFN. Adding now.. " ) 
+            idf = add_zone(idf, partner_wall.Zone_Name)
+
+    return idf
+
+def add_missing_zone_surfaces(idf: IDF, zone: str):
+    zone_subsurfs = find_zone_subsurfaces(zone, idf.getsubsurfaces())
+    afn_surfaces = [i.Surface_Name for i in idf.idfobjects["AIRFLOWNETWORK:MULTIZONE:SURFACE"]]
+    for subsurf in zone_subsurfs:
+        if subsurf not in afn_surfaces and PARTNER not in subsurf and "Window" in subsurf:
+            print(f"Subsurf {subsurf} not in  original AFN. Adding now.. " ) 
+            idf = add_subsurface(idf, subsurf)
+    return idf
+
+
+def update_afn_for_missing_zone_subsurfaces(idf: IDF):
+    afn_zones = get_afn_zones(idf)
+    for zone in afn_zones:
+        idf = add_missing_zone_surfaces(idf, zone)
+
+    return idf
+
+
+# TODO now have added zones, need to update create zone map based on airboundaries..  and look for 
+
+def add_air_boundaries(idf: IDF, path_to_inputs: Path):
+    idf = update_air_boundary_constructions(idf, path_to_inputs)
+    idf = update_afn_for_airboundary_zones(idf)
+    idf = update_afn_for_missing_zone_subsurfaces(idf)
+
+    return idf
+            
+
+

plan2eplus/airflow_network/creator.py

@@ -0,0 +1,21 @@
+from airflow_network.logic import get_afn_zones_and_subsurfaces
+from airflow_network.modifiers import add_simulation_control, add_subsurface, add_zone
+
+
+from geomeppy import IDF
+from copy import deepcopy
+
+
+def add_airflownetwork_to_case(_idf: IDF):
+    idf = deepcopy(_idf)
+    zones, subsurfaces = get_afn_zones_and_subsurfaces(idf)
+
+    idf = add_simulation_control(idf)
+
+    for zone in zones:
+        idf = add_zone(idf, zone)
+
+    for subsurface in subsurfaces:
+        idf = add_subsurface(idf, subsurface)
+
+    return idf

plan2eplus/airflow_network/logic.py

@@ -0,0 +1,14 @@
+from geomeppy import IDF
+from helpers.helpers import set_difference, list_all_dict_values
+from helpers.ep_helpers import create_zone_map_without_partners
+
+
+def get_afn_zones_and_subsurfaces(idf: IDF):
+    # TODO make this more expressive, so know from function name it is mapping subsurfaces to zones.. 
+    zone_map = create_zone_map_without_partners(idf)
+    filtered_zone_map = {k: v for k, v in zone_map.items() if len(v) < 2}
+    afn_zones = set_difference(zone_map.keys(), filtered_zone_map.keys())
+    afn_subsurfaces = set_difference(
+        list_all_dict_values(zone_map), list_all_dict_values(filtered_zone_map)
+    )
+    return afn_zones, afn_subsurfaces

plan2eplus/airflow_network/modifiers.py

@@ -0,0 +1,42 @@
+from copy import deepcopy
+from geomeppy import IDF
+
+def add_simulation_control(idf: IDF):
+    sim_control = idf.newidfobject(
+        "AirflowNetwork:SimulationControl".upper()
+    )
+    sim_control.Name = "AFN_SIM_CONTROL"
+    sim_control.AirflowNetwork_Control = "MultizoneWithoutDistribution"
+    return idf
+
+
+def add_zone(idf: IDF, zone_name:str):
+    zone = idf.newidfobject(
+        "AirflowNetwork:MultiZone:Zone".upper()
+    )
+    zone.Ventilation_Control_Mode = "Constant"
+    zone.Zone_Name = zone_name
+    return idf
+
+def create_simple_opening(idf: IDF, subsurface_name:str):
+    opening = idf.newidfobject(
+        "AirflowNetwork:MultiZone:Component:SimpleOpening".upper()
+    )
+    opening.Name = f"{subsurface_name} SimpleOpening"
+    # taken from defaults
+    opening.Discharge_Coefficient = 1
+    opening.Air_Mass_Flow_Coefficient_When_Opening_is_Closed = 0.001
+    opening.Minimum_Density_Difference_for_TwoWay_Flow = 0.0001
+    return idf, opening
+
+def add_subsurface(idf: IDF, subsurface_name:str):
+    afn_surface = idf.newidfobject(
+        "AirflowNetwork:MultiZone:Surface".upper()
+    )
+    afn_surface.Surface_Name = subsurface_name
+
+    idf, opening = create_simple_opening(idf, subsurface_name)
+    afn_surface.Leakage_Component_Name = opening.Name
+    return idf
+
+

plan2eplus/analysis/analysis_air_boundary.py

@@ -0,0 +1,75 @@
+from helpers.variable_interfaces import all_variables
+from setup.data_wrangle import create_dataframe_for_many_cases, join_any_data
+from setup.interfaces import CaseData
+from setup.setup import retrieve_case_data
+import polars as pl
+
+
+def get_qois():
+    qoi1 = all_variables.afn.linkage["flow12"]
+    qoi12 = all_variables.afn.linkage["flow21"]
+    qoi2 = all_variables.afn.zone["ach"]
+    qoi3 = all_variables.afn.zone["vent_vol"]
+    qoi4 = all_variables.zone.temp["zone_mean_air_temp"]
+
+    return qoi1, qoi12, qoi2, qoi3, qoi4
+
+
+def get_df(case_data: CaseData):
+    qois = get_qois()
+    df = create_dataframe_for_many_cases([case_data], qois[0])
+    return join_any_data(df, [case_data], qois[1])
+
+
+def get_zone_df(case_data: CaseData):
+    _, _, ach, vent_vol , *_= get_qois()
+    df = create_dataframe_for_many_cases([case_data], ach)
+    return join_any_data(df, [case_data], vent_vol)
+
+
+def get_airboundary_case():
+    inputs_dir = "case_bol_5"
+    outputs_dir = "tests/test23_airwall"
+    return retrieve_case_data(inputs_dir, outputs_dir, "airwall")
+
+
+def get_airboundary_with_surf_case():
+    inputs_dir = "case_bol_5"
+    outputs_dir = "tests/test25_airwall"
+    return retrieve_case_data(inputs_dir, outputs_dir, "airwall_surf")
+
+
+def get_no_door_case():
+    inputs_dir = "case_bol_5"
+    outputs_dir = "tests/test24_no_door"
+    return retrieve_case_data(inputs_dir, outputs_dir, "no_door")
+
+
+def get_normal_door_case():
+    inputs_dir = "case_bol_5"
+    outputs_dir = "oct_h4h_plans/case_bol_5"
+    return retrieve_case_data(inputs_dir, outputs_dir, "just_door")
+
+
+def create_data(df_select):
+    dfs = [
+        df_select(i)
+        for i in [
+            get_no_door_case(),
+            get_airboundary_case(),
+            get_airboundary_with_surf_case(),
+            get_normal_door_case(),
+        ]
+    ]
+    return pl.concat(dfs, how="vertical")
+
+
+def get_df_many(case_data: list[CaseData]):
+    qois = get_qois()
+    df = create_dataframe_for_many_cases(case_data, qois[0])
+    return join_any_data(df, case_data, qois[1])
+
+def get_zone_df_many(case_data: list[CaseData]):
+    _, _, ach, vent_vol , temp = get_qois()
+    df = create_dataframe_for_many_cases(case_data, temp)
+    return join_any_data(df, case_data, ach)

plan2eplus/analysis/cp_eq.py

@@ -0,0 +1,22 @@
+from math import log, sin, cos, pow, radians
+
+# TO DO, read this paper, how did they fit this? 
+# inc_rad => indident angle in radians, ~ angle between wind direction and and outward normal of wall under consideration.. 
+# side_ratio_fac => log(width of facade / width of adjacent facade)
+def calc_cp(inc_angle, side_ratio_fac=log(1)):
+    # TODO check that side_ratio_fac falls within bounds.. 
+    inc_rad = radians(inc_angle)
+    cos_inc_rad_over_2 = cos(inc_rad / 2)
+    val = 0.6 * log(
+        1.248
+        - 0.703 * sin(inc_rad / 2.0)
+        - 1.175 * pow(sin(inc_rad), 2)
+        + 0.131 * pow(sin(2.0 * inc_rad * side_ratio_fac), 3)
+        + 0.769 * cos_inc_rad_over_2
+        + 0.07 * pow((side_ratio_fac * sin(inc_rad / 2.0)), 2)
+        + 0.717 * pow(cos_inc_rad_over_2, 2)
+    )
+    return val
+
+# side ratios are capped at a certain value.. 
+# how does Cp become pressure? 

plan2eplus/analysis/dataframes.py

@@ -0,0 +1,99 @@
+import polars as pl
+from analysis.helpers import (
+    extract_times,
+    link_dfs_for_qois,
+    map_linkage_names_to_G,
+    map_zone_names,
+)
+from setup.interfaces import CaseData
+from helpers.variable_interfaces import all_variables
+from setup.data_wrangle import (
+    create_dataframe_for_many_cases,
+    join_any_data,
+    create_dataframe_for_case,
+)
+
+
+def create_zone_vol_df_many(case_data: list[CaseData]):
+    vent_vol = all_variables.afn.zone["vent_vol"]
+    mix_vol = all_variables.afn.zone["mix_vol"]
+    temp = all_variables.zone.temp["zone_mean_air_temp"]
+
+    df = create_dataframe_for_many_cases(case_data, vent_vol)
+    df2 = join_any_data(df, case_data, mix_vol)
+    return join_any_data(df2, case_data, temp, 1)
+
+
+def create_zone_rate_df(case: CaseData):
+    zq = all_variables.afn.zone
+    qois = [
+        zq["vent_heat_gain"],
+        zq["vent_heat_loss"],
+        zq["mix_heat_gain"],
+        zq["mix_heat_loss"],
+    ]
+
+    dfs = [create_dataframe_for_case(case.case_name, case.sql, qoi) for qoi in qois]
+    return pl.concat(dfs, how="vertical")
+
+
+def create_site_df(case: CaseData):
+    sq = all_variables.site
+    qois = [
+        sq.temp["db"],
+        sq.solar["direct_rad"],
+        sq.wind["speed"],
+        sq.wind["direction"],
+    ]
+
+    dfs = [create_dataframe_for_case(case.case_name, case.sql, qoi) for qoi in qois]
+    return pl.concat(dfs, how="vertical")
+
+
+
+
+
+
+
+
+
+### above are df helpers.. ^
+
+
+def create_pressure_df(case: CaseData):
+    av = all_variables.afn
+    qois = [av.node["total_pressure"], av.node["wind_pressure"], av.node["temp"]]
+
+    df = link_dfs_for_qois(case, qois)
+    df = extract_times(df)
+    df = map_zone_names(case.path_to_input, df)
+    df = df.with_columns(
+        is_ext=pl.when(pl.col("room_names").str.contains("ExtNode"))
+        .then(True)
+        .otherwise(False)
+    )
+    return df
+
+
+def create_linkage_df(case: CaseData) -> pl.DataFrame:
+    av = all_variables.afn
+    qois = [
+        av.linkage["flow12"],
+        av.linkage["flow21"],
+    ]
+    df = create_dataframe_for_case(case.case_name, case.sql, qois[0])
+    df = join_any_data(df, [case], qois[1])
+    df = df.with_columns(net_linkage=pl.col("values") - pl.col("values_0"))
+
+    df = map_linkage_names_to_G(case.idf, case.path_to_input, df)
+
+    def flip_edge(e):
+        return [e[1], e[0]]
+
+    flipped_edges = [
+        flip_edge(e) if v < 0 else e
+        for e, v in zip(df["room_pairs"], df["net_linkage"])
+    ]
+    df = df.hstack([pl.Series("directed_pairs", flipped_edges)])
+    # )
+    return df

plan2eplus/analysis/dataframes2.py

@@ -0,0 +1,49 @@
+import polars as pl
+import polars.selectors as cs
+from setup.interfaces import CaseData
+from setup.materials_setup import retrieve_cases
+from setup.data_wrangle2 import create_wide_dataframe_for_many_qois, add_site_qois_wide
+from analysis.helpers import map_zone_names, extract_times, map_linkage_names_to_G
+from helpers.variable_interfaces import all_variables as vars
+
+
+def get_redwood_case():
+    cases = retrieve_cases()
+    medium_cases = [i for i in cases if "Medium" in i.case_name]
+    [case] = [i for i in medium_cases if "red" in i.case_name]
+    return case
+
+
+# # TODO zone temp data..
+# def get_col_regex(name):
+#     return pl.col(f"^{name}.*$")
+
+
+def create_linkage_df(case: CaseData) -> pl.DataFrame:
+    av = vars.afn
+    qois = [
+        av.linkage["flow12"],
+        av.linkage["flow21"],
+    ]
+    df = create_wide_dataframe_for_many_qois(case, qois)
+    df = df.with_columns(net_linkage=(cs.contains(qois[0]) - cs.contains(qois[1]))) # TODO check this calculation may be wrong
+
+    df = map_linkage_names_to_G(case.idf, case.path_to_input, df)
+
+    def flip_edge(e):
+        return [e[1], e[0]]
+
+    directed_pairs = [
+        flip_edge(e) if v < 0 else e
+        for e, v in zip(df["room_pairs"], df["net_linkage"])
+    ]
+    df = df.hstack([pl.Series("directed_pairs", directed_pairs)])
+    return df
+
+
+def get_external_node_df(case: CaseData):
+    df =  create_wide_dataframe_for_many_qois(case, [vars.afn.node["wind_pressure"]])
+    return add_site_qois_wide(df, case, [vars.site.wind["speed"], vars.site.wind["direction"]])
+
+
+# def create_vol_df_for_many_cases():

plan2eplus/analysis/ep_wind_cp.cpp

@@ -0,0 +1,41 @@
+// SUBROUTINE LOCAL VARIABLE DECLARATIONS:
+int FacadeNum;         // Facade number
+int ExtNum;            // External number
+int AFNZnNum;          // Zone number
+Real64 SideRatio;      // For vertical facades, width of facade / width of adjacent facade
+Real64 SR;             // SideRatio restricted to 0.25 to 4.0 range
+Real64 SideRatioFac;   // LOG(SideRatio)
+Real64 IncRad;         // IncAng in radians
+int IAng;              // Incidence angle index; used in interpolation
+Real64 DelAng;         // Incidence angle difference; used in interpolation
+Real64 WtAng;          // Incidence angle weighting factor; used in interpolation
+int ISR;               // Side ratio index, for interpolation
+Real64 WtSR;           // Side ratio weighting factor; used in interpolation
+int SurfNum;           // Surface number
+int SurfDatNum;        // Surface data number
+Real64 SurfAng;        // Azimuth angle of surface normal (degrees clockwise from North)
+int FacadeNumThisSurf; // Facade number for a particular surface
+Real64 AngDiff;        // Angle difference between wind and surface direction (deg)
+Real64 AngDiffMin;     // Minimum angle difference between wind and surface direction (deg)
+std::vector<int> curveIndex = {0, 0, 0, 0, 0};
+
+
+
+std::vector<Real64> vals(13);
+for (int windDirNum = 1; windDirNum <= 12; ++windDirNum) {
+    Real64 WindAng = (windDirNum - 1) * 30.0;
+    IncAng = std::abs(WindAng - FacadeAng(FacadeNum));
+    if (IncAng > 180.0) IncAng = 360.0 - IncAng;
+    IAng = int(IncAng / 30.0) + 1;
+    DelAng = mod(IncAng, 30.0);
+    WtAng = 1.0 - DelAng / 30.0;
+
+    // Wind-pressure coefficients for vertical facades, low-rise building
+
+    if (Util::SameString(simulation_control.BldgType, "LowRise") && FacadeNum <= 4) {
+        IncRad = IncAng * Constant::DegToRadians;
+        Real64 const cos_IncRad_over_2(std::cos(IncRad / 2.0));
+        vals[windDirNum - 1] = 0.6 * std::log(1.248 - 0.703 * std::sin(IncRad / 2.0) - 1.175 * pow_2(std::sin(IncRad)) +
+        0.131 * pow_3(std::sin(2.0 * IncRad * SideRatioFac)) + 0.769 * cos_IncRad_over_2 +
+        0.07 * pow_2(SideRatioFac * std::sin(IncRad / 2.0)) + 0.717 * pow_2(cos_IncRad_over_2));
+    }

plan2eplus/analysis/helpers.py

@@ -0,0 +1,80 @@
+from pathlib import Path
+from geomeppy import IDF
+import polars as pl
+from helpers.ep_helpers import get_zone_num
+from sklearn.preprocessing import MinMaxScaler
+import numpy as np
+from helpers.geometry_interfaces import Domain
+from network.network import create_base_graph, get_node_partners
+from plan.helpers import create_room_map
+from setup.data_wrangle import create_dataframe_for_case
+from setup.interfaces import CaseData
+
+
+def get_domains_lim(zone_domains: list[Domain], PAD_BASE = 1.4):
+    PAD = PAD_BASE * 1.1
+    min_x = min([i.width.min for i in zone_domains]) - PAD
+    max_x = max([i.width.max for i in zone_domains]) + PAD
+    min_y = min([i.height.min for i in zone_domains]) - PAD
+    max_y = max([i.height.max for i in zone_domains]) + PAD
+    return (min_x, max_x), (min_y, max_y)
+
+
+def get_min_max(medians: pl.DataFrame, col=None):
+    if not col:
+        numeric_values = medians.select(pl.selectors.numeric())
+        min_val = numeric_values.min_horizontal().min()
+        max_val = numeric_values.max_horizontal().max()
+
+    else:
+        series = medians[col]
+        return series.min(), series.max()
+
+    return min_val, max_val
+
+
+def true_min_max(min_max_pairs: list[tuple[float, float]]):
+    min_val = min([m[0] for m in min_max_pairs])
+    max_val = max([m[1] for m in min_max_pairs])
+    return min_val, max_val
+
+
+def convert_zone_space_name(room_map: dict[int, str], name):
+    try:
+        ix = get_zone_num(name)
+        room_name = room_map[ix]
+        return f"{ix}-{room_name}"
+    except:
+        return name
+
+
+def normalize_column(df: pl.DataFrame, col: str, range=(1, 3)):
+    vals = np.absolute(df[col].to_numpy().reshape(-1, 1))
+    scaler = MinMaxScaler(feature_range=range)
+    scaler.fit(vals)
+    return scaler.transform(vals).reshape(1, -1)[0]
+
+
+def link_dfs_for_qois(case: CaseData, qois: list[str]):
+    df = [create_dataframe_for_case(case.case_name, case.sql, qoi) for qoi in qois]
+    return pl.concat(df, how="vertical")
+
+
+def map_zone_names(path_to_input: Path, df: pl.DataFrame):
+    room_map = create_room_map(path_to_input)
+    fx = lambda name: convert_zone_space_name(room_map, name)
+    return df.with_columns(
+        room_names=pl.col("space_names").map_elements(fx, return_dtype=pl.String),
+    )
+
+
+def map_linkage_names_to_G(idf: IDF, path_to_input: Path, df: pl.DataFrame):
+    G, _ = create_base_graph(idf, path_to_input)
+    fx = lambda surf_name: get_node_partners(idf, G, surf_name)
+    return df.with_columns(
+        room_pairs=pl.col("space_names").map_elements(fx, return_dtype=pl.Object)
+    )
+
+
+def extract_times(df: pl.DataFrame):
+    return df.with_columns(time=pl.col("datetimes").dt.to_string("%H:%M"))

plan2eplus/analysis/materials_compare.py

@@ -0,0 +1,47 @@
+from pathlib import Path
+import seaborn as sns
+import seaborn.objects as so
+import polars as pl
+import numpy as np
+import matplotlib.pyplot as plt
+
+from analysis.volumes import aggregate_and_compare
+from setup.data_wrangle import get_plot_labels
+
+# from setup.materials_setup import *
+from analysis.dataframes import create_zone_vol_df_many
+from setup.interfaces import CaseData
+from setup.materials_setup import retrieve_cases
+
+
+def get_save_details():
+    FOLDER = "materials_compare"
+    return Path.cwd() / "figures" / FOLDER
+
+
+def init_df():
+    cases = retrieve_cases()
+    df_vol = create_zone_vol_df_many(cases)
+    sc = cases[0]
+    return df_vol, sc
+
+
+def aggregate_and_compare_materials(df_vol):
+    figures_root = get_save_details()
+    df_agg = aggregate_and_compare(df_vol)
+    df_agg2 = df_agg.with_columns(
+        material_type=pl.when(pl.col("case_names").str.contains("Light"))
+        .then(pl.lit("Light"))
+        .when(pl.col("case_names").str.contains("Medium"))
+        .then(pl.lit("Medium"))
+        .otherwise(pl.lit("Heavy")),
+        case_type = pl.when(pl.col("case_names").str.contains("amb"))
+        .then(pl.lit("amb"))
+        .when(pl.col("case_names").str.contains("bol"))
+        .then(pl.lit("bol"))
+        .otherwise(pl.lit("red")),
+    )
+    g = (so.Plot(df_agg2, x="temp", y="combined_vent", color="case_type", marker="material_type" ).add(so.Dot(pointsize=15)).scale(color="flare").plot().save(figures_root / f"vent_v_temp")) # type: ignore
+    g.show()
+    return df_agg2, g
+

plan2eplus/analysis/plan_details.py

@@ -0,0 +1,31 @@
+
+from case_edits.epcase import EneryPlusCaseEditor
+from case_edits.ezcase import get_path_to_inputs, get_path_to_outputs
+from experiments.comparisons import get_input_dir
+from helpers.ep_geom_helpers import get_zone_domains
+from analysis.helpers import get_domains_lim
+from helpers.geometry_interfaces import Range, Domain
+from plan.plan_to_eppy import add_eppy_blocks_to_case
+from setup.setup import get_case_names
+
+
+output_path = get_path_to_outputs("test/plan_details")
+
+def get_input_paths():
+    input_dirs = [get_input_dir(i) for i in get_case_names()]
+    return [get_path_to_inputs(i) for i in input_dirs]
+
+def init_case(input_path):
+    case = EneryPlusCaseEditor(output_path)
+    case.idf =  add_eppy_blocks_to_case(case.idf, input_path)
+    return get_zone_domains(case.idf)
+
+
+def get_plan_area(zone_domains:list[Domain]):
+    return sum([z.area for z in zone_domains])
+
+def get_plan_aspect_ratio(zone_domains:list[Domain]):
+    x_diff, y_diff = get_domains_lim(zone_domains, 0)
+    plan_domain = Domain(Range(*x_diff), Range(*y_diff))
+    return plan_domain.aspect_ratio
+