openstudio-ee 0.12.0 → 0.12.4

data/lib/measures/window_enhancement/resources/EC3_lookup.py

@@ -0,0 +1,321 @@
+# EC3 API Lookup Script
+import json
+import re
+from typing import Dict, Any, List
+from pathlib import Path
+import configparser
+from datetime import datetime
+import numpy as np
+import os
+
+script_dir = os.path.dirname(os.path.abspath(__file__))
+repo_root = os.path.abspath(os.path.join(script_dir, "../../../.."))
+config_path = os.path.join(repo_root, "config.ini")
+
+# this measure doesn't function without EC3 token and required Python libraries installed
+if not os.path.exists(config_path):
+    raise FileNotFoundError(f"Config file not found: {config_path}. Please setup your EC3 token before attempting to run this measure.")
+
+# load custom libraries after confirming if config.ini 
+import requests
+
+config = configparser.ConfigParser()
+config.read(config_path)
+API_TOKEN= config["EC3_API_TOKEN"]["API_TOKEN"]
+
+# #find material_name by category
+# material_category = {"concrete":{"ReadyMix","PrecastConcrete","CementGrout","FlowableFill"},
+#                      "masonry":{"Brick", "CMU"},
+#                      "steel":{"RebarSteel","WireMeshSteel","ColdFormedSteel","StructuralSteel"},
+#                      "aluminum":{"AluminiumExtrusions"},
+#                      "wood":{"PrefabricatedWood","DimensionLumbe","SheathingPanels","CompositeLumber","MassTimber","NonStructuralWood"},
+#                      "sheathing":{"GypsumSheathingBoard","CementitiousSheathingBoard"},
+#                      "thermal_moisture_protection":{"Insulation","MembraneRoofing"},
+#                      "cladding":{"RoofPanels","InsulatedRoofPanels","WallPanels","InsulatedWallPanels"},
+#                      "openings":{"glazing":["InsulatingGlazingUnits","FlatGlassPanes","ProcessedNonInsulatingGlassPanes"],
+#                                  "extrusions":["AluminiumExtrusions"]},
+#                      "finishes":{"CementBoard","Gypsum","Tiling","CeilingPanel","Flooring","PaintingAndCoating"}
+#                      }
+# for testing use, do not delete
+material_category = {
+                     "test":["InsulatingGlazingUnits"]
+                     }
+
+def generate_url(material_name, endpoint ="materials", page_number=1, page_size=250, jurisdiction="021", date=None, option=None, boolean="yes",
+                  glass_panes=None, epd_type="Product"):
+    '''
+    jurisdiction = "021" means Northern America region
+    '''
+    if date is None:
+        date = datetime.today().strftime("%Y-%m-%d")  # use today's date as default
+    url = (
+        f"https://api.buildingtransparency.org/api/{endpoint}"
+        f"?page_number={page_number}&page_size={page_size}"
+        f"&mf=!EC3%20search(%22{material_name}%22)%20WHERE%20"
+        f"%0A%20%20jurisdiction%3A%20IN(%22{jurisdiction}%22)%20AND%0A%20%20"
+        f"epd__date_validity_ends%3A%20%3E%20%22{date}%22%20AND%0A%20%20"
+        f"epd_types%3A%20IN(%22{epd_type}%20EPDs%22)%20"
+    )
+    conditions = []
+    if option and boolean:
+        conditions.append(f"{option}%3A%20{boolean}")
+
+    if glass_panes:
+        conditions.append(f"glass_panes%3A%20%3E~%20{glass_panes}")
+
+    if conditions:
+        url += "AND%0A%20%20" + "%20AND%0A%20%20".join(conditions) + "%20%0A"
+
+    url += "!pragma%20eMF(%222.0%2F1%22)%2C%20lcia(%22TRACI%202.1%22)"
+    
+    return url
+
+def fetch_epd_data(url,api_token):
+    """
+    input url address generted by generate_url()
+    Fetch EPD data from the EC3 API.
+    return: Parsed JSON response or empty list on failure.
+    """
+    try: 
+        print(f"Fetching data from URL: {url}")  # Log the URL being fetched
+        # API configuration
+        HEADERS = {"Accept": "application/json", "Authorization": "Bearer " + api_token}
+        response = requests.get(url, headers=HEADERS, verify=False)
+        response.raise_for_status() # HTTPError if failure 
+        return response.json()
+    except requests.exceptions.RequestException as e:
+        print(f"Error fetching data from {url}: {e}")
+        if 'response' in locals():  # Check if response was defined
+            print(f"Response content: {response.text}")
+        else:
+            print("No response content available.")
+        return []
+
+def parse_product_epd(epd: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Parse GWP data for a given EPD.
+    :param epd: EPD dictionary
+    :return: Parsed GWP data
+    """
+    # initialize parameters and dictionary
+    parsed_data = {}
+    gwp_per_m3 = 0.0
+    gwp_per_m2 = 0.0
+    gwp_per_kg = 0.0
+
+    # extract information from EPD's json repsonse
+    declared_unit = epd.get("declared_unit")
+    thickness = epd.get("thickness")
+    gwp_per_declared_unit = epd.get("gwp")
+    mass_per_declared_unit = epd.get("mass_per_declared_unit")
+    density = epd.get("density")
+    gwp_per_kg = epd.get("gwp_per_kg")
+    epd_name = epd.get('name')
+    description = epd.get('description')
+    original_ec3_link = epd['manufacturer']['original_ec3_link']
+
+    # Per mass
+    if gwp_per_kg != None:
+        gwp_per_kg = extract_numeric_value(gwp_per_kg)
+
+    elif gwp_per_kg == None and "t" in declared_unit:
+        gwp_per_kg = divide(gwp_per_declared_unit, declared_unit)
+        gwp_per_kg = gwp_per_kg/1000 # convert from t to kg
+
+    elif gwp_per_kg == None and "kg" in declared_unit:
+        gwp_per_kg = divide(gwp_per_declared_unit, declared_unit)
+
+    elif mass_per_declared_unit != None and gwp_per_kg == None and not any(unit in declared_unit for unit in ["kg", "t"]):
+        gwp_per_kg = divide(gwp_per_declared_unit, mass_per_declared_unit)
+
+    # Per volume
+    if "m3" in declared_unit:
+        gwp_per_m3 = divide(gwp_per_declared_unit, declared_unit)
+
+    elif "cf" in declared_unit:
+        gwp_per_m3 = divide(gwp_per_declared_unit, declared_unit)
+        gwp_per_m3 = gwp_per_m3 * 35.3147 # convert from cubic feet to m3
+
+    elif "m2" in declared_unit and thickness and "mm" in thickness:
+        gwp_per_m2 = divide(gwp_per_declared_unit, declared_unit)
+        gwp_per_m3 = gwp_per_m2/(extract_numeric_value(thickness)/1000)
+
+    elif density and "kg / m3" in density and gwp_per_kg:
+        gwp_per_m3 = multiply(gwp_per_kg, density)
+
+    # Per area
+    if "m2" in declared_unit:
+        gwp_per_m2 = divide(gwp_per_declared_unit, declared_unit)
+
+    elif "sf" in declared_unit:
+        gwp_per_m2 = divide(gwp_per_declared_unit, declared_unit)
+        gwp_per_m2 = gwp_per_m2 * 10.7639 # convert from square feet to m2
+
+    elif "m3" in declared_unit and thickness and "mm" in thickness:
+        gwp_per_m3 = divide(gwp_per_declared_unit, declared_unit)
+        gwp_per_m2 = gwp_per_m3 * (extract_numeric_value(thickness)/1000)
+    
+    parsed_data["epd_name"] = epd_name
+    parsed_data["declared_unit"] = declared_unit
+    parsed_data["gwp_per_declared_unit"] = gwp_per_declared_unit
+    parsed_data["mass_per_declared_unit"] = mass_per_declared_unit
+    parsed_data["thickness"] = thickness
+    parsed_data["density"] = density
+    parsed_data["gwp_per_m3 (kg CO2 eq/m3)"] = gwp_per_m3
+    parsed_data["gwp_per_m2 (kg CO2 eq/m2)"] = gwp_per_m2
+    parsed_data["gwp_per_kg (kg CO2 eq/kg)"] = gwp_per_kg 
+    parsed_data["original_ec3_link"] = original_ec3_link
+    parsed_data["description"] = description
+
+    return parsed_data
+
+def parse_industrial_epd(epd: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Parse GWP data for a given EPD.
+    :param epd: EPD dictionary
+    :return: Parsed GWP data
+    """
+
+    parsed_data = {}
+    gwp_per_m3 = 0.0
+    gwp_per_m2 = 0.0
+    gwp_per_kg = 0.0
+
+    declared_unit = epd.get("declared_unit")
+    gwp_per_kg = epd.get("gwp_per_kg")
+    gwp_per_declared_unit = epd.get("gwp")
+    epd_name = epd.get('name')
+    original_ec3_link = epd.get('original_ec3_link')
+    description = epd.get('description')
+    density_min = epd.get('density_min')
+    density_max = epd.get('density_max')
+    area = epd.get('area')
+
+    if density_min is not None and density_max is not None:
+        density_avg = (extract_numeric_value(density_max) + extract_numeric_value(density_min))/2
+    elif density_min is not None:
+        density_avg = extract_numeric_value(density_min)
+    elif density_max is not None:
+        density_avg = extract_numeric_value(density_max)
+    else:
+        density_avg = None
+
+    # Per area (stop using this becasue the area value is not sensible)
+    # if "m^2" in area:
+    #     gwp_per_m2 = extract_numeric_value(gwp_per_declared_unit)/extract_numeric_value(area)
+
+    # Per mass
+    if "t" in declared_unit:
+        gwp_per_kg = divide(gwp_per_declared_unit, declared_unit)
+        gwp_per_kg = gwp_per_kg / 1000 # convert to kg
+    elif "kg" in declared_unit:
+        gwp_per_kg = divide(gwp_per_declared_unit, declared_unit)
+
+    # Per volume
+    if gwp_per_kg != None and density_avg != None:
+        gwp_per_m3 = gwp_per_kg * density_avg
+        
+    parsed_data["epd_name"] = epd_name
+    parsed_data["declared_unit"] = declared_unit
+    parsed_data["gwp_per_declared_unit"] = gwp_per_declared_unit
+    parsed_data["density_min"] = density_min
+    parsed_data["density_max"] = density_max
+    parsed_data["area"] = area
+    parsed_data["gwp_per_m3 (kg CO2 eq/m3)"] = gwp_per_m3
+    parsed_data["gwp_per_m2 (kg CO2 eq/m2)"] = gwp_per_m2
+    parsed_data["gwp_per_kg (kg CO2 eq/kg)"] = gwp_per_kg 
+    parsed_data["original_ec3_link"] = original_ec3_link
+    parsed_data["description"] = description
+
+    return parsed_data
+
+def extract_numeric_value(value: Any) -> float:
+    """
+    Extract numeric value from a string or number.
+    :param value: Value to process
+    :return: Extracted numeric value
+    """
+    match = re.search(r"[-+]?\d*\.?\d+", str(value))
+    return float(match.group()) if match else 0.0
+
+# extract numeric values then divide
+def divide(member: Any, denominator: Any) -> float:
+    try:
+        member_value = extract_numeric_value(member)
+        denominator_value = extract_numeric_value(denominator)
+        return round(member_value/denominator_value, 2)
+    except ZeroDivisionError:
+        return 0.0
+
+# extract numeric values then multiply
+def multiply(multiplicand: Any, multiplier: Any) -> float:
+
+    multiplicand_value = extract_numeric_value(multiplicand)
+    multiplier_value = extract_numeric_value(multiplier)
+    return round(multiplicand_value * multiplier_value, 2)
+
+def calculate_geometry(self, sub_surface):
+    """
+    Calculate the length, width, perimeter, and area of the window from its vertices.
+    Assumes the window is a quadrilateral (typically a rectangle).
+    """
+    vertices = sub_surface.vertices()
+    if len(vertices) != 4:
+        return {
+            "length": 0.0,
+            "width": 0.0,
+            "perimeter": 0.0,
+            "area": 0.0
+        }
+
+    # Calculate all edge lengths
+    edge_lengths = []
+    perimeter = 0.0
+    for i in range(4):
+        v1 = vertices[i]
+        v2 = vertices[(i + 1) % 4]
+        edge = v2 - v1
+        length = edge.length()
+        edge_lengths.append(length)
+        perimeter += length
+
+    # Assume opposite edges are equal, so we can group into two unique lengths
+    length = max(edge_lengths)
+    width = min(edge_lengths)
+
+    # Area = length × width
+    area = length * width
+
+    return {
+        "length": length,
+        "width": width,
+        "perimeter": perimeter,
+        "area": area
+    }
+
+def main():
+    """
+    Main function to execute the script.
+    """
+    print("Fetching EC3 EPD data...")
+
+    for category, list in material_category.items():
+        print(material_category[category])
+        for name in list:
+            print(name)
+            product_url = generate_url(name, endpoint="materials", epd_type="Product")
+            industry_url = generate_url(name, endpoint="industry_epds", epd_type="Industry")
+
+            product_epd_data = fetch_epd_data(product_url,API_TOKEN) 
+            industrial_epd_data = fetch_epd_data(industry_url,API_TOKEN)
+            print(f"Number of  product EPDs for {name}: {len(product_epd_data)}")
+            print(f"Number of  industrial EPDs for {name}: {len(industrial_epd_data)}")
+            for idx, epd in enumerate(product_epd_data, start=1):
+                parsed_data = parse_product_epd(epd)
+                print(f"Product EPD #{idx}: {json.dumps(parsed_data, indent=4)}")
+            for idx, epd in enumerate(industrial_epd_data, start=1):
+                parsed_data = parse_industrial_epd(epd)
+                print(f"Industrial EPD #{idx}: {json.dumps(parsed_data, indent=4)}")
+
+if __name__ == "__main__":
+    main()

data/lib/measures/window_enhancement/resources/Test_API.py

@@ -0,0 +1,32 @@
+# Test EC3 API Call
+import requests
+import pprint
+import os
+import configparser
+
+script_dir = os.path.dirname(os.path.abspath(__file__))
+repo_root = os.path.abspath(os.path.join(script_dir, "../../../.."))
+config_path = os.path.join(repo_root, "config.ini")
+
+if not os.path.exists(config_path):
+    raise FileNotFoundError(f"Config file not found: {config_path}")
+
+config = configparser.ConfigParser()
+config.read(config_path)
+API_TOKEN= config["EC3_API_TOKEN"]["API_TOKEN"]
+
+test_url = ("https://api.buildingtransparency.org/api/materials?page_number=1&page_size=25&mf=!EC3%20search(%22InsulatingGlazingUnits%22)%20WHERE%20%0A%20%20jurisdiction%3A%20IN(%22021%22)%20AND%0A%20%20epd__date_validity_ends%3A%20%3E%20%222025-04-18%22%20AND%0A%20%20epd_types%3A%20IN(%22Product%20EPDs%22)%20%0A!pragma%20eMF(%222.0%2F1%22)%2C%20lcia(%22TRACI%202.1%22)")
+# Headers for the request
+headers = {
+    "Accept": "application/json",
+    "Authorization": "Bearer "+ API_TOKEN
+}
+
+# Execute the GET request
+test_response = requests.get(test_url, headers=headers, verify=False)
+
+# Parse the JSON response
+test_response = test_response.json()
+pprint.pp(test_response)
+# Print the response and the number of EPDs
+print(f"Number of EPDs: {len(test_response)}")

data/lib/measures/window_enhancement/resources/__pycache__/Original_EC3_lookup.py

@@ -0,0 +1,322 @@
+# EC3 API Call
+import requests
+import json
+import re
+import pprint
+import statistics
+
+print("EC3 API Call:")
+
+EC3_category_array = {
+    "ConstructionMaterials": {
+        "Concrete": [
+            "ReadyMix",
+            "Shotcrete",
+            "CementGrout",
+            "FlowableFill",
+            "Precast",
+            "Rebar",
+            "WireMeshSteel",
+            "SCM",
+            "Cement",
+            "Aggregates"
+        ],
+        "Masonry": [
+            "Brick",
+            "ConcreteUnitMasonry",
+            "Mortar",
+            "Cementitious",
+            "Aggregates"
+        ],
+        "Steel": [],
+        "Aluminum": [],
+        "Wood": [],
+        "Sheathing": [],
+        "ThermalMoistureProtection": [], 
+        "Cladding": [],
+        "Openings": [], 
+        "Finishes": [],
+        "ConveyingEquipment": [],
+        "NetworkInfrastrucure": [], 
+        "Asphalt": [],
+        "Accessories": [], 
+        "ManufacturingInputs": [],
+        "BulkMaterials": [],
+        "Placeholders": []
+    },
+    "BuildingAssemblies": {
+        "NewCoustomAssembly": [],
+        "ReinforcedConcrete": [], 
+        "Walls": [],
+        "Floors": [], 
+        "GlazingFenesration": [], 
+    },
+}
+
+# Define the URL with query parameters (FIXME: Not including API key in public repo. Will need to be included in a gitignored config.ini file)
+windows_url = (
+    "https://api.buildingtransparency.org/api/epds"
+    "?page_number=1&page_size=25&fields=id%2Copen_xpd_uuid%2Cis_failed%2Cfailures%2Cerrors%2Cwarnings"
+    "%2Cdate_validity_ends%2Ccqd_sync_unlocked%2Cmy_capabilities%2Coriginal_data_format%2Ccategory"
+    "%2Cdisplay_name%2Cmanufacturer%2Cplant_or_group%2Cname%2Cdescription%2Cprogram_operator"
+    "%2Cprogram_operator_fkey%2Cverifier%2Cdeveloper%2Cmatched_plants_count%2Cplant_geography%2Cpcr"
+    "%2Cshort_name%2Cversion%2Cdate_of_issue%2Clanguage%2Cgwp%2Cuncertainty_adjusted_gwp%2Cdeclared_unit"
+    "%2Cupdated_on%2Ccorrections_count%2Cdeclaration_type%2Cbox_id%2Cis_downloadable"
+    "&sort_by=-updated_on&name__like=window&description__like=window&q=windows&plant_geography=US&declaration_type=Product%20EPD"
+)
+
+igu_url =  (
+    "https://api.buildingtransparency.org/api/materials"
+    "?page_number=1&page_size=100"
+    "&mf=!EC3%20search(%22InsulatingGlazingUnits%22)%20WHERE%20"
+    "%0A%20%20jurisdiction%3A%20IN(%22021%22)%20AND%0A%20%20"
+    "epd__date_validity_ends%3A%20%3E%20%222024-12-05%22%20AND%0A%20%20"
+    "epd_types%3A%20IN(%22Product%20EPDs%22)%20"
+    "!pragma%20eMF(%222.0%2F1%22)%2C%20lcia(%22TRACI%202.1%22)"
+)
+
+wframe_url = (
+    "https://api.buildingtransparency.org/api/materials"
+    "?page_number=1&page_size=25"
+    "&mf=!EC3%20search(%22AluminiumExtrusions%22)%20WHERE%20"
+    "%0A%20%20jurisdiction%3A%20IN(%22021%22)%20AND%0A%20%20"
+    "epd__date_validity_ends%3A%20%3E%20%222024-12-09%22%20AND%0A%20%20"
+    "epd_types%3A%20IN(%22Product%20EPDs%22)%20"
+    "!pragma%20eMF(%222.0%2F1%22)%2C%20lcia(%22TRACI%202.1%22)"
+)
+
+
+gypsum_url = (
+    "https://api.buildingtransparency.org/api/materials"
+    "?page_number=1&page_size=25"
+    "&mf=!EC3%20search(%22Gypsum%22)%20WHERE%20"
+    "%0A%20%20jurisdiction%3A%20IN(%22US%22%2C%20%22CA%22)%20AND%0A%20%20"
+    "epd__date_validity_ends%3A%20%3E%20%222024-12-24%22%20AND%0A%20%20"
+    "epd_types%3A%20IN(%22Product%20EPDs%22)%20AND%0A%20%20"
+    "gypsum_fire_rating%3A%20IN(%22X%22)%20AND%0A%20%20"
+    "gypsum_thickness%3A%20IN(%220.625%20in%22)%20AND%0A%20%20"
+    "gypsum_facing%3A%20IN(%22Paper%22)%20"
+    "!pragma%20eMF(%222.0%2F1%22)%2C%20lcia(%22TRACI%202.1%22)"
+)
+
+# Headers for the request
+headers = {
+    "Accept": "application/json",
+    "Authorization": "Bearer 5fk7wP4cJg6pcmx6ncZN0ftMdoVR8u"
+}
+
+# Execute the GET request
+igu_response = requests.get(igu_url, headers=headers, verify=False)
+wframe_response = requests.get(wframe_url, headers=headers, verify=False)
+
+# Parse the JSON response
+igu_response = igu_response.json()
+wframe_response = wframe_response.json()
+#print(igu_response)
+# Print the response and the number of EPDs
+print(f"Number of EPDs for IGU: {len(igu_response)}")
+print(f"Number of EPDs for window frame: {len(wframe_response)}")
+
+# Exception for EPD: 0
+if len(igu_response) == 0:
+    print("No EPD returned for IGU, please change the search terms")
+if len(wframe_response) == 0:
+    print("No EPD returned for window frame, please change the search terms")
+
+# List of keys to exclude
+exclude_keys = [
+    'manufacturer', 
+    'plant_or_group', 
+    'category',
+    'created_on',
+    'updated_on',
+    'gwp',
+    'gwp_z',
+    'pct80_gwp_per_category_declared_unit',
+    'conservative_estimate',
+    'best_practice',
+    'standard_deviation',
+    'uncertainty_factor',
+    'uncertainty_adjusted_gwp',
+    'lowest_plausible_gwp',
+    ]
+
+# Create an empty list to store EPDs of IGU
+igu_epd_data = {}
+igu_gwp_per_volume = []
+igu_gwp_per_mass = []
+igu_gwp_per_area = []
+wframe_epd_data = {}
+wframe_gwp_per_volume = []
+wframe_gwp_per_mass = []
+wframe_gwp_per_area = []
+
+for igu_epd_no, igu_epd in enumerate(igu_response, start=1):
+    print(f"========================================EPD No. {igu_epd_no}:==========================================")
+    # Initialize gwp per unit volume of IGU  
+    gwp_per_unit_volume = "Not specified"
+    gwp_per_unit_area = "Not specified"
+    gwp_per_unit_mass = "Not specified"
+    # Create an empty list to store each key,value pair in an individual EPD object 
+    igu_object = {}
+
+    for key, value in igu_epd.items():
+        if value is not None and key not in exclude_keys:
+            # Append the key-value pair to the list
+            igu_object[key] = value
+            # Extract the relevant keys
+            declared_unit = igu_epd.get("declared_unit")
+            thickness_unit = igu_epd.get("thickness")
+            gwp_per_category_declared_unit = igu_epd.get("gwp_per_category_declared_unit")
+            warnings = igu_epd.get("warnings")
+            mass_per_declared_unit = igu_epd.get("mass_per_declared_unit")
+            density_unit = igu_epd.get("density")
+            gwp_per_unit_mass = igu_epd.get("gwp_per_kg")
+
+            # Per volume
+            if declared_unit and "m3" in declared_unit:
+                gwp_per_category_declared_unit_value = float(re.search(r"[-+]?\d*\.?\d+", str(gwp_per_category_declared_unit)).group())
+                declared_unit_value = float(re.search(r"[-+]?\d*\.?\d+", str(declared_unit)).group())
+                gwp_per_unit_volume = gwp_per_category_declared_unit_value/declared_unit_value
+
+            elif declared_unit and "m2" in declared_unit and thickness_unit and "mm" in str(thickness_unit):
+                thickness = float(re.search(r"[-+]?\d*\.?\d+", thickness_unit).group())  # Extract numeric part
+                gwp_per_category_declared_unit_value = float(re.search(r"[-+]?\d*\.?\d+", str(gwp_per_category_declared_unit)).group())
+                thickness = thickness * 1e-3 # Convert thickness to meters
+                gwp_per_unit_volume = round(gwp_per_category_declared_unit_value / thickness,2)
+
+            elif density_unit and gwp_per_unit_mass:
+                density = float(re.search(r"[-+]?\d*\.?\d+", density_unit).group())  # Extract numeric part
+                gwp_per_unit_mass = float(re.search(r"[-+]?\d*\.?\d+", str(gwp_per_unit_mass)).group())
+                gwp_per_unit_volume = gwp_per_unit_mass*density
+                gwp_per_unit_volume = round(gwp_per_unit_volume,2)
+            
+            elif declared_unit and "t" in declared_unit and density_unit:
+                density = float(re.search(r"[-+]?\d*\.?\d+", density_unit).group())  # Extract numeric part
+                gwp_per_category_declared_unit_value = float(re.search(r"[-+]?\d*\.?\d+", str(gwp_per_category_declared_unit)).group())
+                gwp_per_unit_volume = (gwp_per_category_declared_unit_value / 1000) * density
+                gwp_per_unit_volume = round(gwp_per_unit_volume,2)
+
+            # Per area    
+            if declared_unit and "sf" in declared_unit:
+                gwp_per_category_declared_unit_value = float(re.search(r"[-+]?\d*\.?\d+", str(gwp_per_category_declared_unit)).group())
+                declared_unit_value = float(re.search(r"[-+]?\d*\.?\d+", str(declared_unit)).group())
+                gwp_per_unit_area = (gwp_per_category_declared_unit_value/declared_unit_value)/0.092903
+                gwp_per_unit_area = round(gwp_per_unit_area,2)
+
+    igu_object["gwp_per_unit_volume"] = f"{gwp_per_unit_volume} kg CO2 e/m3"
+    
+    if declared_unit and "m2" in declared_unit:
+        gwp_per_category_declared_unit_value = float(re.search(r"[-+]?\d*\.?\d+", str(gwp_per_category_declared_unit)).group())
+        igu_object["gwp_per_unit_area"] = f"{gwp_per_category_declared_unit_value} kg CO2 e/m2"
+    else:
+        igu_object["gwp_per_unit_area"] = f"{gwp_per_unit_area} kg CO2 e/m2"
+
+    if gwp_per_unit_mass:
+        gwp_per_unit_mass = float(re.search(r"[-+]?\d*\.?\d+", str(gwp_per_unit_mass)).group())
+        gwp_per_unit_mass = round(gwp_per_unit_mass,2)
+        igu_object["gwp_per_unit_mass"] = f"{gwp_per_unit_mass} kg CO2 e/kg"
+    else:
+        igu_object["gwp_per_unit_mass"] = "Not avaialble in this EPD"
+    object_key = "object" + str(igu_epd_no)
+    igu_epd_data[object_key] = igu_object
+    igu_gwp_per_volume.append(gwp_per_unit_volume)
+    igu_gwp_per_area.append(gwp_per_unit_area)
+    igu_gwp_per_mass.append(gwp_per_unit_mass)
+    pprint.pp(igu_object)
+#print all gwp per volume
+igu_gwp_per_volume = [float(item) for item in igu_gwp_per_volume if isinstance(item, (int, float)) or item.replace('.', '', 1).isdigit()]
+# Calculate the mean
+if igu_gwp_per_volume:  # Check if the list is not empty
+    mean_value = statistics.mean(igu_gwp_per_volume)
+    print("Mean of GWP per volume:", mean_value)
+else:
+    print("No numeric values to calculate mean.")
+print(igu_gwp_per_volume)
+
+for wframe_epd_no, wframe_epd in enumerate(wframe_response, start=1):
+    print(f"========================================EPD No. {wframe_epd_no}:==========================================")
+    # Initialize gwp per unit volume of window frame 
+    gwp_per_unit_volume = "Not specified"
+    gwp_per_unit_area = "Not specified"
+    gwp_per_unit_mass = "Not specified"
+    # Create an empty list to store each key,value pair in an individual EPD object 
+    wframe_object = {}
+
+    for key, value in wframe_epd.items():
+        if value is not None and key not in exclude_keys:
+            # Append the key-value pair to the list
+            wframe_object[key] = value
+            # Extract the relevant keys
+            declared_unit = wframe_epd.get("declared_unit")
+            thickness_unit = wframe_epd.get("thickness")
+            gwp_per_category_declared_unit = wframe_epd.get("gwp_per_category_declared_unit")
+            warnings = wframe_epd.get("warnings")
+            mass_per_declared_unit = wframe_epd.get("mass_per_declared_unit")
+            density_unit = wframe_epd.get("density")
+            gwp_per_unit_mass = wframe_epd.get("gwp_per_kg")
+
+            # Per volume
+            if declared_unit and "m3" in declared_unit:
+                gwp_per_category_declared_unit_value = float(re.search(r"[-+]?\d*\.?\d+", str(gwp_per_category_declared_unit)).group())
+                declared_unit_value = float(re.search(r"[-+]?\d*\.?\d+", str(declared_unit)).group())
+                gwp_per_unit_volume = gwp_per_category_declared_unit_value/declared_unit_value
+
+            elif declared_unit and "m2" in declared_unit and thickness_unit and "mm" in str(thickness_unit):
+                thickness = float(re.search(r"[-+]?\d*\.?\d+", thickness_unit).group())  # Extract numeric part
+                gwp_per_category_declared_unit_value = float(re.search(r"[-+]?\d*\.?\d+", str(gwp_per_category_declared_unit)).group())
+                thickness = thickness * 1e-3 # Convert thickness to meters
+                gwp_per_unit_volume = round(gwp_per_category_declared_unit_value / thickness,2)
+
+            elif density_unit and gwp_per_unit_mass:
+                density = float(re.search(r"[-+]?\d*\.?\d+", density_unit).group())  # Extract numeric part
+                gwp_per_unit_mass = float(re.search(r"[-+]?\d*\.?\d+", str(gwp_per_unit_mass)).group())
+                gwp_per_unit_volume = gwp_per_unit_mass*density
+                gwp_per_unit_volume = round(gwp_per_unit_volume,2)
+            
+            elif declared_unit and "t" in declared_unit and density_unit:
+                density = float(re.search(r"[-+]?\d*\.?\d+", density_unit).group())  # Extract numeric part
+                gwp_per_category_declared_unit_value = float(re.search(r"[-+]?\d*\.?\d+", str(gwp_per_category_declared_unit)).group())
+                gwp_per_unit_volume = (gwp_per_category_declared_unit_value / 1000) * density
+                gwp_per_unit_volume = round(gwp_per_unit_volume,2)
+
+            # Per area    
+            if declared_unit and "sf" in declared_unit:
+                gwp_per_category_declared_unit_value = float(re.search(r"[-+]?\d*\.?\d+", str(gwp_per_category_declared_unit)).group())
+                declared_unit_value = float(re.search(r"[-+]?\d*\.?\d+", str(declared_unit)).group())
+                gwp_per_unit_area = (gwp_per_category_declared_unit_value/declared_unit_value)/0.092903
+                gwp_per_unit_area = round(gwp_per_unit_area,2)
+
+    wframe_object["gwp_per_unit_volume"] = f"{gwp_per_unit_volume} kg CO2 e/m3"
+    
+    if declared_unit and "m2" in declared_unit:
+        gwp_per_category_declared_unit_value = float(re.search(r"[-+]?\d*\.?\d+", str(gwp_per_category_declared_unit)).group())
+        wframe_object["gwp_per_unit_area"] = f"{gwp_per_category_declared_unit_value} kg CO2 e/m2"
+    else:
+        wframe_object["gwp_per_unit_area"] = f"{gwp_per_unit_area} kg CO2 e/m2"
+
+    if gwp_per_unit_mass:
+        gwp_per_unit_mass = float(re.search(r"[-+]?\d*\.?\d+", str(gwp_per_unit_mass)).group())
+        gwp_per_unit_mass = round(gwp_per_unit_mass,2)
+        wframe_object["gwp_per_unit_mass"] = f"{gwp_per_unit_mass} kg CO2 e/kg"
+    else:
+        wframe_object["gwp_per_unit_mass"] = "Not avaialble in this EPD"
+    object_key = "object" + str(wframe_epd_no)
+    wframe_epd_data[object_key] = wframe_object
+    wframe_gwp_per_volume.append(gwp_per_unit_volume)
+    wframe_gwp_per_area.append(gwp_per_unit_area)
+    wframe_gwp_per_mass.append(gwp_per_unit_mass)
+    pprint.pp(wframe_object)
+
+#print all gwp per volume
+wframe_gwp_per_volume = [float(item) for item in wframe_gwp_per_volume if isinstance(item, (int, float)) or item.replace('.', '', 1).isdigit()]
+# Calculate the mean
+if wframe_gwp_per_volume:  # Check if the list is not empty
+    mean_value = statistics.mean(wframe_gwp_per_volume)
+    min_value = min(wframe_gwp_per_volume)
+    max_value = max(wframe_gwp_per_volume)
+    print("Mean of GWP per m3:", mean_value)
+    print("Minimum GWP per m3:", min_value)
+    print("Maximum GWP per m3:", max_value)
+else:
+    print("No numeric values to calculate statistical parameters.")