Upload 31 files

app/main.py

@@ -116,6 +116,10 @@ class HVACCalculator:
         self.data_persistence = DataPersistence()
         self.data_export = DataExport()
         
+        # Initialize calculation modules
+        self.cooling_load = CoolingLoad()
+        self.heating_load = HeatingLoad()
+        
         # Set up the application layout
         self.setup_layout()
     
@@ -142,6 +146,10 @@ class HVACCalculator:
         if selected_page != st.session_state.page:
             st.session_state.page = selected_page
         
+        # Add calculate button in sidebar
+        if st.sidebar.button("Run Calculations"):
+            self.run_calculations()
+        
         # Display the selected page
         self.display_page(st.session_state.page)
         
@@ -272,323 +280,48 @@ class HVACCalculator:
         )
         
         st.plotly_chart(fig, use_container_width=True)
-        
-        # Navigation buttons
-        col1, col2 = st.columns(2)
-        with col1:
-            st.button("Back to Building Information", on_click=self.navigate_to, args=["Building Information"])
-        with col2:
-            st.button("Continue to Building Components", on_click=self.navigate_to, args=["Building Components"])
     
     def display_internal_loads(self):
         """Display the internal loads page."""
         st.title("Internal Loads")
         
-        # Check if building components are available
-        if not any(st.session_state.components.values()):
-            st.warning("Please define building components first.")
-            st.button("Go to Building Components", on_click=self.navigate_to, args=["Building Components"])
+        # Check if building information is available
+        if not st.session_state.building_info:
+            st.warning("Please enter building information first.")
+            st.button("Go to Building Information", on_click=self.navigate_to, args=["Building Information"])
             return
         
-        # Tabs for different internal load types
-        tabs = st.tabs(["People", "Lighting", "Equipment"])
+        # Create tabs for different internal load types
+        tab1, tab2, tab3 = st.tabs(["People", "Lighting", "Equipment"])
         
-        # People tab
-        with tabs[0]:
+        with tab1:
             self.display_people_loads()
         
-        # Lighting tab
-        with tabs[1]:
+        with tab2:
             self.display_lighting_loads()
         
-        # Equipment tab
-        with tabs[2]:
+        with tab3:
             self.display_equipment_loads()
         
         # Display summary of internal loads
-        self.display_internal_loads_summary()
-        
-        # Navigation buttons
-        col1, col2 = st.columns(2)
-        with col1:
-            st.button("Back to Building Components", on_click=self.navigate_to, args=["Building Components"])
-        with col2:
-            # Validate internal loads before proceeding
-            if self.data_validation.validate_internal_loads(st.session_state.get("internal_loads", {})):
-                st.button("Continue to Calculation Results", on_click=self.navigate_to, args=["Calculation Results"])
-            else:
-                st.button("Continue to Calculation Results", disabled=True)
-    
-    def display_people_loads(self):
-        """Display the people loads section."""
-        st.subheader("People")
-        
-        # Form for adding people loads
-        with st.form("people_load_form"):
-            col1, col2 = st.columns(2)
-            
-            with col1:
-                name = st.text_input("Name", "Occupants")
-                num_people = st.number_input("Number of People", min_value=1, value=10)
-            
-            with col2:
-                activity_level = st.selectbox(
-                    "Activity Level",
-                    options=["Seated, resting", "Seated, light work", "Office work", "Standing, light work", "Walking", "Heavy work"]
-                )
-                zone_type = st.selectbox(
-                    "Zone Type",
-                    options=["Office", "Residential", "Retail", "Educational", "Healthcare"]
-                )
-            
-            hours_in_operation = st.slider("Hours in Operation", min_value=1, max_value=24, value=8)
-            
-            submitted = st.form_submit_button("Add People Load")
-            
-            if submitted:
-                # Create people load
-                people_load = {
-                    "id": f"people_{len(st.session_state.internal_loads['people'])}",
-                    "name": name,
-                    "num_people": num_people,
-                    "activity_level": activity_level,
-                    "zone_type": zone_type,
-                    "hours_in_operation": hours_in_operation
-                }
-                
-                # Add to session state
-                st.session_state.internal_loads['people'].append(people_load)
-                st.success(f"Added {name} with {num_people} people")
-        
-        # Display existing people loads
-        if st.session_state.internal_loads['people']:
-            st.subheader("Existing People Loads")
-            
-            people_data = []
-            for load in st.session_state.internal_loads['people']:
-                people_data.append({
-                    "Name": load['name'],
-                    "Number of People": load['num_people'],
-                    "Activity Level": load['activity_level'],
-                    "Zone Type": load['zone_type'],
-                    "Hours in Operation": load['hours_in_operation'],
-                    "Actions": load['id']
-                })
-            
-            df = pd.DataFrame(people_data)
-            
-            # Display table with edit and delete buttons
-            for i, row in df.iterrows():
-                col1, col2, col3, col4, col5, col6, col7 = st.columns([2, 1, 2, 2, 1, 1, 1])
-                
-                with col1:
-                    st.write(row["Name"])
-                with col2:
-                    st.write(row["Number of People"])
-                with col3:
-                    st.write(row["Activity Level"])
-                with col4:
-                    st.write(row["Zone Type"])
-                with col5:
-                    st.write(row["Hours in Operation"])
-                with col6:
-                    if st.button("Edit", key=f"edit_{row['Actions']}"):
-                        # Set session state for editing
-                        st.session_state.editing_people = row['Actions']
-                with col7:
-                    if st.button("Delete", key=f"delete_{row['Actions']}"):
-                        # Remove from session state
-                        st.session_state.internal_loads['people'] = [
-                            load for load in st.session_state.internal_loads['people']
-                            if load['id'] != row['Actions']
-                        ]
-                        st.experimental_rerun()
-    
-    def display_lighting_loads(self):
-        """Display the lighting loads section."""
-        st.subheader("Lighting")
-        
-        # Form for adding lighting loads
-        with st.form("lighting_load_form"):
-            col1, col2 = st.columns(2)
-            
-            with col1:
-                name = st.text_input("Name", "General Lighting")
-                power = st.number_input("Power (W)", min_value=0.0, value=1000.0)
-            
-            with col2:
-                usage_factor = st.slider("Usage Factor", min_value=0.0, max_value=1.0, value=0.8, step=0.1)
-                zone_type = st.selectbox(
-                    "Zone Type",
-                    options=["Office", "Residential", "Retail", "Educational", "Healthcare"]
-                )
-            
-            hours_in_operation = st.slider("Hours in Operation", min_value=1, max_value=24, value=8)
-            
-            submitted = st.form_submit_button("Add Lighting Load")
-            
-            if submitted:
-                # Create lighting load
-                lighting_load = {
-                    "id": f"lighting_{len(st.session_state.internal_loads['lighting'])}",
-                    "name": name,
-                    "power": power,
-                    "usage_factor": usage_factor,
-                    "zone_type": zone_type,
-                    "hours_in_operation": hours_in_operation
-                }
-                
-                # Add to session state
-                st.session_state.internal_loads['lighting'].append(lighting_load)
-                st.success(f"Added {name} with {power} W")
-        
-        # Display existing lighting loads
-        if st.session_state.internal_loads['lighting']:
-            st.subheader("Existing Lighting Loads")
-            
-            lighting_data = []
-            for load in st.session_state.internal_loads['lighting']:
-                lighting_data.append({
-                    "Name": load['name'],
-                    "Power (W)": load['power'],
-                    "Usage Factor": load['usage_factor'],
-                    "Zone Type": load['zone_type'],
-                    "Hours in Operation": load['hours_in_operation'],
-                    "Actions": load['id']
-                })
-            
-            df = pd.DataFrame(lighting_data)
-            
-            # Display table with edit and delete buttons
-            for i, row in df.iterrows():
-                col1, col2, col3, col4, col5, col6, col7 = st.columns([2, 1, 1, 2, 1, 1, 1])
-                
-                with col1:
-                    st.write(row["Name"])
-                with col2:
-                    st.write(f"{row['Power (W)']:.1f}")
-                with col3:
-                    st.write(f"{row['Usage Factor']:.1f}")
-                with col4:
-                    st.write(row["Zone Type"])
-                with col5:
-                    st.write(row["Hours in Operation"])
-                with col6:
-                    if st.button("Edit", key=f"edit_{row['Actions']}"):
-                        # Set session state for editing
-                        st.session_state.editing_lighting = row['Actions']
-                with col7:
-                    if st.button("Delete", key=f"delete_{row['Actions']}"):
-                        # Remove from session state
-                        st.session_state.internal_loads['lighting'] = [
-                            load for load in st.session_state.internal_loads['lighting']
-                            if load['id'] != row['Actions']
-                        ]
-                        st.experimental_rerun()
-    
-    def display_equipment_loads(self):
-        """Display the equipment loads section."""
-        st.subheader("Equipment")
-        
-        # Form for adding equipment loads
-        with st.form("equipment_load_form"):
-            col1, col2 = st.columns(2)
-            
-            with col1:
-                name = st.text_input("Name", "Office Equipment")
-                power = st.number_input("Power (W)", min_value=0.0, value=500.0)
-            
-            with col2:
-                usage_factor = st.slider("Usage Factor", min_value=0.0, max_value=1.0, value=0.7, step=0.1)
-                radiation_fraction = st.slider("Radiation Fraction", min_value=0.0, max_value=1.0, value=0.3, step=0.1)
-            
-            zone_type = st.selectbox(
-                "Zone Type",
-                options=["Office", "Residential", "Retail", "Educational", "Healthcare"]
-            )
-            
-            hours_in_operation = st.slider("Hours in Operation", min_value=1, max_value=24, value=8)
-            
-            submitted = st.form_submit_button("Add Equipment Load")
-            
-            if submitted:
-                # Create equipment load
-                equipment_load = {
-                    "id": f"equipment_{len(st.session_state.internal_loads['equipment'])}",
-                    "name": name,
-                    "power": power,
-                    "usage_factor": usage_factor,
-                    "radiation_fraction": radiation_fraction,
-                    "zone_type": zone_type,
-                    "hours_in_operation": hours_in_operation
-                }
-                
-                # Add to session state
-                st.session_state.internal_loads['equipment'].append(equipment_load)
-                st.success(f"Added {name} with {power} W")
-        
-        # Display existing equipment loads
-        if st.session_state.internal_loads['equipment']:
-            st.subheader("Existing Equipment Loads")
-            
-            equipment_data = []
-            for load in st.session_state.internal_loads['equipment']:
-                equipment_data.append({
-                    "Name": load['name'],
-                    "Power (W)": load['power'],
-                    "Usage Factor": load['usage_factor'],
-                    "Radiation Fraction": load['radiation_fraction'],
-                    "Zone Type": load['zone_type'],
-                    "Hours in Operation": load['hours_in_operation'],
-                    "Actions": load['id']
-                })
-            
-            df = pd.DataFrame(equipment_data)
-            
-            # Display table with edit and delete buttons
-            for i, row in df.iterrows():
-                col1, col2, col3, col4, col5, col6, col7, col8 = st.columns([2, 1, 1, 1, 2, 1, 1, 1])
-                
-                with col1:
-                    st.write(row["Name"])
-                with col2:
-                    st.write(f"{row['Power (W)']:.1f}")
-                with col3:
-                    st.write(f"{row['Usage Factor']:.1f}")
-                with col4:
-                    st.write(f"{row['Radiation Fraction']:.1f}")
-                with col5:
-                    st.write(row["Zone Type"])
-                with col6:
-                    st.write(row["Hours in Operation"])
-                with col7:
-                    if st.button("Edit", key=f"edit_{row['Actions']}"):
-                        # Set session state for editing
-                        st.session_state.editing_equipment = row['Actions']
-                with col8:
-                    if st.button("Delete", key=f"delete_{row['Actions']}"):
-                        # Remove from session state
-                        st.session_state.internal_loads['equipment'] = [
-                            load for load in st.session_state.internal_loads['equipment']
-                            if load['id'] != row['Actions']
-                        ]
-                        st.experimental_rerun()
-    
-    def display_internal_loads_summary(self):
-        """Display a summary of all internal loads."""
         st.subheader("Internal Loads Summary")
         
-        # Check if any internal loads exist
-        if not any(st.session_state.internal_loads.values()):
-            st.info("No internal loads defined yet.")
-            return
+        # Calculate total people
+        total_people = 0
+        for people_load in st.session_state.internal_loads.get('people', []):
+            total_people += people_load.get('count', 0)
+        
+        # Calculate total lighting power
+        total_lighting_power = 0
+        for lighting_load in st.session_state.internal_loads.get('lighting', []):
+            total_lighting_power += lighting_load.get('power', 0) * lighting_load.get('usage_factor', 1.0)
         
-        # Calculate total loads
-        total_people = sum(load['num_people'] for load in st.session_state.internal_loads['people'])
-        total_lighting_power = sum(load['power'] * load['usage_factor'] for load in st.session_state.internal_loads['lighting'])
-        total_equipment_power = sum(load['power'] * load['usage_factor'] for load in st.session_state.internal_loads['equipment'])
+        # Calculate total equipment power
+        total_equipment_power = 0
+        for equipment_load in st.session_state.internal_loads.get('equipment', []):
+            total_equipment_power += equipment_load.get('power', 0) * equipment_load.get('usage_factor', 1.0)
         
-        # Display summary
+        # Display metrics
         col1, col2, col3 = st.columns(3)
         
         with col1:
@@ -623,6 +356,65 @@ class HVACCalculator:
         """
         st.session_state.page = page
         st.experimental_rerun()
+    
+    def run_calculations(self):
+        """Run HVAC load calculations and update session state with results."""
+        # Check if required data is available
+        if not self.data_validation.validate_calculation_inputs(st.session_state):
+            st.error("Cannot run calculations. Please complete all required inputs first.")
+            return
+        
+        # Get building components and design conditions
+        building_components = st.session_state.components
+        building_info = st.session_state.building_info
+        internal_loads = st.session_state.internal_loads
+        
+        # Extract design conditions
+        design_conditions = building_info.get('design_conditions', {})
+        
+        # Run cooling load calculations
+        cooling_results = self.cooling_load.calculate_total_cooling_load(
+            building_components=building_components,
+            outdoor_temp=design_conditions.get('summer_outdoor_db', 35),
+            indoor_temp=design_conditions.get('summer_indoor_db', 24),
+            outdoor_humidity=design_conditions.get('summer_outdoor_wb', 25),  # Using wet-bulb for outdoor humidity
+            indoor_humidity=design_conditions.get('summer_indoor_rh', 50),
+            ground_temp=design_conditions.get('summer_ground_temp', 20),
+            daily_range=design_conditions.get('summer_daily_range', 8),
+            month=design_conditions.get('summer_design_month', 7),
+            hour=design_conditions.get('summer_design_hour', 15),
+            latitude=building_info.get('latitude', 40),
+            internal_loads=internal_loads
+        )
+        
+        # Run heating load calculations
+        heating_results = self.heating_load.calculate_design_heating_load(
+            building_components=building_components,
+            outdoor_temp=design_conditions.get('winter_outdoor_db', 0),
+            indoor_temp=design_conditions.get('winter_indoor_db', 22),
+            outdoor_humidity=design_conditions.get('winter_outdoor_rh', 80),
+            indoor_humidity=design_conditions.get('winter_indoor_rh', 40),
+            ground_temp=design_conditions.get('winter_ground_temp', 10),
+            safety_factor=design_conditions.get('heating_safety_factor', 15)
+        )
+        
+        # Calculate load per area
+        floor_area = building_info.get('floor_area', 100)  # Default to 100 m² if not specified
+        
+        cooling_results['load_per_area'] = cooling_results['total_load'] * 1000 / floor_area  # Convert kW to W/m²
+        heating_results['load_per_area'] = heating_results['total_load'] * 1000 / floor_area  # Convert kW to W/m²
+        
+        # Update session state with calculation results
+        st.session_state.calculation_results = {
+            'cooling': cooling_results,
+            'heating': heating_results
+        }
+        
+        # Show success message
+        st.success("Calculations completed successfully!")
+        
+        # Navigate to results page
+        self.navigate_to("Calculation Results")
 
 
 if __name__ == "__main__":

utils/psychrometric_visualization.py

@@ -225,13 +225,7 @@ class PsychrometricVisualization:
                     marker=dict(size=10, color=color),
                     text=[name],
                     textposition="top center",
-                    name=name,
-                    hovertemplate=(
-                        f"<b>{name}</b><br>" +
-                        "Temperature: %{x:.1f}°C<br>" +
-                        "Humidity Ratio: %{y:.5f} kg/kg<br>" +
-                        f"Relative Humidity: {rh:.1f}%<br>"
-                    )
+                    name=name
                 ))
         
         # Add processes if specified
@@ -256,380 +250,185 @@ class PsychrometricVisualization:
                     y=[start_w, end_w],
                     mode="lines+markers",
                     line=dict(color=color, width=2, dash="solid"),
-                    marker=dict(size=8, color=color),
+                    marker=dict(size=8),
                     name=name
                 ))
-                
-                # Add arrow to indicate direction
-                fig.add_annotation(
-                    x=end_temp,
-                    y=end_w,
-                    ax=start_temp,
-                    ay=start_w,
-                    xref="x",
-                    yref="y",
-                    axref="x",
-                    ayref="y",
-                    showarrow=True,
-                    arrowhead=2,
-                    arrowsize=1,
-                    arrowwidth=2,
-                    arrowcolor=color
-                )
         
         # Update layout
         fig.update_layout(
             title="Psychrometric Chart",
             xaxis_title="Dry-Bulb Temperature (°C)",
             yaxis_title="Humidity Ratio (kg/kg)",
-            xaxis=dict(
-                range=[self.temp_min, self.temp_max],
-                gridcolor="rgba(0, 0, 0, 0.1)",
-                showgrid=True
-            ),
-            yaxis=dict(
-                range=[self.w_min, self.w_max],
-                gridcolor="rgba(0, 0, 0, 0.1)",
-                showgrid=True
-            ),
+            legend_title="Legend",
             height=700,
-            margin=dict(l=50, r=50, b=50, t=50),
-            legend=dict(
-                orientation="h",
-                yanchor="bottom",
-                y=1.02,
-                xanchor="right",
-                x=1
-            ),
-            hovermode="closest"
+            margin=dict(l=50, r=50, t=50, b=50),
+            plot_bgcolor="white",
+            paper_bgcolor="white",
+            font=dict(size=12)
         )
         
+        # Set axis ranges
+        fig.update_xaxes(range=[self.temp_min, self.temp_max], gridcolor="lightgray")
+        fig.update_yaxes(range=[self.w_min, self.w_max], gridcolor="lightgray")
+        
         return fig
-    
-    def create_process_visualization(self, process: Dict[str, Any]) -> go.Figure:
+
+    def display_psychrometric_chart(self, calculation_results: Dict[str, Any], design_conditions: Dict[str, Any]) -> None:
         """
-        Create a visualization of a psychrometric process.
+        Display psychrometric chart with calculation results.
         
         Args:
-            process: Dictionary with process parameters
-            
-        Returns:
-            Plotly figure with process visualization
+            calculation_results: Dictionary containing calculation results
+            design_conditions: Dictionary containing design conditions
         """
-        # Extract process parameters
-        start_point = process.get("start", {})
-        end_point = process.get("end", {})
-        
-        start_temp = start_point.get("temp", 0)
-        start_rh = start_point.get("rh", 0)
-        
-        end_temp = end_point.get("temp", 0)
-        end_rh = end_point.get("rh", 0)
-        
-        # Calculate psychrometric properties
-        start_props = self.psychrometrics.moist_air_properties(start_temp, start_rh, self.pressure)
-        end_props = self.psychrometrics.moist_air_properties(end_temp, end_rh, self.pressure)
-        
-        # Calculate process changes
-        delta_t = end_temp - start_temp
-        delta_w = end_props["humidity_ratio"] - start_props["humidity_ratio"]
-        delta_h = end_props["enthalpy"] - start_props["enthalpy"]
-        
-        # Determine process type
-        process_type = "Unknown"
-        if abs(delta_w) < 0.0001:  # Sensible heating/cooling
-            if delta_t > 0:
-                process_type = "Sensible Heating"
-            else:
-                process_type = "Sensible Cooling"
-        elif abs(delta_t) < 0.1:  # Humidification/Dehumidification
-            if delta_w > 0:
-                process_type = "Humidification"
-            else:
-                process_type = "Dehumidification"
-        elif delta_t > 0 and delta_w > 0:
-            process_type = "Heating and Humidification"
-        elif delta_t < 0 and delta_w < 0:
-            process_type = "Cooling and Dehumidification"
-        elif delta_t > 0 and delta_w < 0:
-            process_type = "Heating and Dehumidification"
-        elif delta_t < 0 and delta_w > 0:
-            process_type = "Cooling and Humidification"
-        
-        # Create figure
-        fig = go.Figure()
-        
-        # Add process to psychrometric chart
-        chart_fig = self.create_psychrometric_chart(
-            points=[
-                {"temp": start_temp, "rh": start_rh, "name": "Start", "color": "blue"},
-                {"temp": end_temp, "rh": end_rh, "name": "End", "color": "red"}
-            ],
-            processes=[
-                {"start": {"temp": start_temp, "rh": start_rh}, 
-                 "end": {"temp": end_temp, "rh": end_rh}, 
-                 "name": process_type, 
-                 "color": "green"}
-            ]
-        )
-        
-        # Create process diagram
-        # Create data for process parameters
-        params = [
-            "Dry-Bulb Temperature (°C)",
-            "Relative Humidity (%)",
-            "Humidity Ratio (g/kg)",
-            "Enthalpy (kJ/kg)",
-            "Wet-Bulb Temperature (°C)",
-            "Dew Point Temperature (°C)",
-            "Specific Volume (m³/kg)"
-        ]
-        
-        start_values = [
-            start_props["dry_bulb_temperature"],
-            start_props["relative_humidity"],
-            start_props["humidity_ratio"] * 1000,  # Convert to g/kg
-            start_props["enthalpy"] / 1000,  # Convert to kJ/kg
-            start_props["wet_bulb_temperature"],
-            start_props["dew_point_temperature"],
-            start_props["specific_volume"]
-        ]
-        
-        end_values = [
-            end_props["dry_bulb_temperature"],
-            end_props["relative_humidity"],
-            end_props["humidity_ratio"] * 1000,  # Convert to g/kg
-            end_props["enthalpy"] / 1000,  # Convert to kJ/kg
-            end_props["wet_bulb_temperature"],
-            end_props["dew_point_temperature"],
-            end_props["specific_volume"]
+        # Extract design conditions
+        summer_outdoor_db = design_conditions.get("summer_outdoor_db", 35)
+        summer_outdoor_wb = design_conditions.get("summer_outdoor_wb", 25)
+        summer_indoor_db = design_conditions.get("summer_indoor_db", 24)
+        summer_indoor_rh = design_conditions.get("summer_indoor_rh", 50)
+        
+        winter_outdoor_db = design_conditions.get("winter_outdoor_db", 0)
+        winter_outdoor_rh = design_conditions.get("winter_outdoor_rh", 80)
+        winter_indoor_db = design_conditions.get("winter_indoor_db", 22)
+        winter_indoor_rh = design_conditions.get("winter_indoor_rh", 40)
+        
+        # Calculate humidity ratios
+        summer_outdoor_w = self.psychrometrics.humidity_ratio_from_wb(summer_outdoor_db, summer_outdoor_wb, self.pressure)
+        summer_indoor_w = self.psychrometrics.humidity_ratio(summer_indoor_db, summer_indoor_rh, self.pressure)
+        winter_outdoor_w = self.psychrometrics.humidity_ratio(winter_outdoor_db, winter_outdoor_rh, self.pressure)
+        winter_indoor_w = self.psychrometrics.humidity_ratio(winter_indoor_db, winter_indoor_rh, self.pressure)
+        
+        # Create points for psychrometric chart
+        points = [
+            {
+                "temp": summer_outdoor_db,
+                "w": summer_outdoor_w,
+                "name": "Summer Outdoor",
+                "color": "red"
+            },
+            {
+                "temp": summer_indoor_db,
+                "w": summer_indoor_w,
+                "name": "Summer Indoor",
+                "color": "blue"
+            },
+            {
+                "temp": winter_outdoor_db,
+                "w": winter_outdoor_w,
+                "name": "Winter Outdoor",
+                "color": "purple"
+            },
+            {
+                "temp": winter_indoor_db,
+                "w": winter_indoor_w,
+                "name": "Winter Indoor",
+                "color": "green"
+            }
         ]
         
-        delta_values = [end - start for start, end in zip(start_values, end_values)]
-        
-        # Create table
-        table_fig = go.Figure(data=[go.Table(
-            header=dict(
-                values=["Parameter", "Start", "End", "Change"],
-                fill_color="paleturquoise",
-                align="left",
-                font=dict(size=12)
-            ),
-            cells=dict(
-                values=[
-                    params,
-                    [f"{val:.2f}" for val in start_values],
-                    [f"{val:.2f}" for val in end_values],
-                    [f"{val:.2f}" for val in delta_values]
-                ],
-                fill_color="lavender",
-                align="left",
-                font=dict(size=11)
-            )
-        )])
-        
-        table_fig.update_layout(
-            title=f"Process Parameters: {process_type}",
-            height=300,
-            margin=dict(l=0, r=0, b=0, t=30)
-        )
-        
-        return chart_fig, table_fig
-    
-    def display_psychrometric_visualization(self) -> None:
-        """
-        Display psychrometric visualization in Streamlit.
-        """
-        st.header("Psychrometric Visualization")
-        
-        # Create tabs for different visualizations
-        tab1, tab2, tab3 = st.tabs([
-            "Interactive Psychrometric Chart", 
-            "Process Visualization", 
-            "Comfort Zone Analysis"
-        ])
-        
-        with tab1:
-            st.subheader("Interactive Psychrometric Chart")
-            
-            # Add controls for points
-            st.write("Add points to the chart:")
-            
-            col1, col2, col3 = st.columns(3)
-            
-            with col1:
-                point1_temp = st.number_input("Point 1 Temperature (°C)", -10.0, 50.0, 20.0, key="point1_temp")
-                point1_rh = st.number_input("Point 1 RH (%)", 0.0, 100.0, 50.0, key="point1_rh")
-            
-            with col2:
-                point2_temp = st.number_input("Point 2 Temperature (°C)", -10.0, 50.0, 30.0, key="point2_temp")
-                point2_rh = st.number_input("Point 2 RH (%)", 0.0, 100.0, 40.0, key="point2_rh")
-            
-            with col3:
-                show_process = st.checkbox("Show Process Line", True, key="show_process")
-                process_name = st.text_input("Process Name", "Cooling Process", key="process_name")
-            
-            # Create points
-            points = [
-                {"temp": point1_temp, "rh": point1_rh, "name": "Point 1", "color": "blue"},
-                {"temp": point2_temp, "rh": point2_rh, "name": "Point 2", "color": "red"}
-            ]
-            
-            # Create process if enabled
-            processes = []
-            if show_process:
-                processes.append({
-                    "start": {"temp": point1_temp, "rh": point1_rh},
-                    "end": {"temp": point2_temp, "rh": point2_rh},
-                    "name": process_name,
-                    "color": "green"
-                })
-            
-            # Create and display chart
-            fig = self.create_psychrometric_chart(points=points, processes=processes)
-            st.plotly_chart(fig, use_container_width=True)
-            
-            # Display point properties
-            col1, col2 = st.columns(2)
-            
-            with col1:
-                st.subheader("Point 1 Properties")
-                props1 = self.psychrometrics.moist_air_properties(point1_temp, point1_rh, self.pressure)
-                st.write(f"Dry-Bulb Temperature: {props1['dry_bulb_temperature']:.2f} °C")
-                st.write(f"Relative Humidity: {props1['relative_humidity']:.2f} %")
-                st.write(f"Humidity Ratio: {props1['humidity_ratio']*1000:.2f} g/kg")
-                st.write(f"Enthalpy: {props1['enthalpy']/1000:.2f} kJ/kg")
-                st.write(f"Wet-Bulb Temperature: {props1['wet_bulb_temperature']:.2f} °C")
-                st.write(f"Dew Point Temperature: {props1['dew_point_temperature']:.2f} °C")
-            
-            with col2:
-                st.subheader("Point 2 Properties")
-                props2 = self.psychrometrics.moist_air_properties(point2_temp, point2_rh, self.pressure)
-                st.write(f"Dry-Bulb Temperature: {props2['dry_bulb_temperature']:.2f} °C")
-                st.write(f"Relative Humidity: {props2['relative_humidity']:.2f} %")
-                st.write(f"Humidity Ratio: {props2['humidity_ratio']*1000:.2f} g/kg")
-                st.write(f"Enthalpy: {props2['enthalpy']/1000:.2f} kJ/kg")
-                st.write(f"Wet-Bulb Temperature: {props2['wet_bulb_temperature']:.2f} °C")
-                st.write(f"Dew Point Temperature: {props2['dew_point_temperature']:.2f} °C")
-        
-        with tab2:
-            st.subheader("Process Visualization")
-            
-            # Add controls for process
-            st.write("Define a psychrometric process:")
-            
-            col1, col2 = st.columns(2)
-            
-            with col1:
-                st.write("Starting Point")
-                start_temp = st.number_input("Temperature (°C)", -10.0, 50.0, 24.0, key="start_temp")
-                start_rh = st.number_input("RH (%)", 0.0, 100.0, 50.0, key="start_rh")
-            
-            with col2:
-                st.write("Ending Point")
-                end_temp = st.number_input("Temperature (°C)", -10.0, 50.0, 14.0, key="end_temp")
-                end_rh = st.number_input("RH (%)", 0.0, 100.0, 90.0, key="end_rh")
-            
-            # Create process
-            process = {
-                "start": {"temp": start_temp, "rh": start_rh},
-                "end": {"temp": end_temp, "rh": end_rh}
+        # Create processes for psychrometric chart
+        processes = [
+            {
+                "start": {"temp": summer_outdoor_db, "w": summer_outdoor_w},
+                "end": {"temp": summer_indoor_db, "w": summer_indoor_w},
+                "name": "Cooling Process",
+                "color": "blue"
+            },
+            {
+                "start": {"temp": winter_outdoor_db, "w": winter_outdoor_w},
+                "end": {"temp": winter_indoor_db, "w": winter_indoor_w},
+                "name": "Heating Process",
+                "color": "red"
             }
-            
-            # Create and display process visualization
-            chart_fig, table_fig = self.create_process_visualization(process)
-            
-            st.plotly_chart(chart_fig, use_container_width=True)
-            st.plotly_chart(table_fig, use_container_width=True)
-            
-            # Calculate process energy requirements
-            start_props = self.psychrometrics.moist_air_properties(start_temp, start_rh, self.pressure)
-            end_props = self.psychrometrics.moist_air_properties(end_temp, end_rh, self.pressure)
-            
-            delta_h = end_props["enthalpy"] - start_props["enthalpy"]  # J/kg
-            
-            st.subheader("Energy Calculations")
-            
-            air_flow = st.number_input("Air Flow Rate (m³/s)", 0.1, 100.0, 1.0, key="air_flow")
-            
-            # Calculate mass flow rate
-            density = start_props["density"]  # kg/m³
-            mass_flow = air_flow * density  # kg/s
-            
-            # Calculate energy rate
-            energy_rate = mass_flow * delta_h  # W
-            
-            st.write(f"Air Density: {density:.2f} kg/m³")
-            st.write(f"Mass Flow Rate: {mass_flow:.2f} kg/s")
-            st.write(f"Enthalpy Change: {delta_h/1000:.2f} kJ/kg")
-            st.write(f"Energy Rate: {energy_rate/1000:.2f} kW")
+        ]
         
-        with tab3:
-            st.subheader("Comfort Zone Analysis")
-            
-            # Add controls for comfort zone
-            st.write("Define comfort zone parameters:")
-            
-            col1, col2 = st.columns(2)
-            
-            with col1:
-                temp_min = st.number_input("Minimum Temperature (°C)", 10.0, 30.0, 20.0, key="temp_min")
-                temp_max = st.number_input("Maximum Temperature (°C)", 10.0, 30.0, 26.0, key="temp_max")
-            
-            with col2:
-                rh_min = st.number_input("Minimum RH (%)", 0.0, 100.0, 30.0, key="rh_min")
-                rh_max = st.number_input("Maximum RH (%)", 0.0, 100.0, 60.0, key="rh_max")
-            
-            # Create comfort zone
-            comfort_zone = {
-                "temp_min": temp_min,
-                "temp_max": temp_max,
-                "rh_min": rh_min,
-                "rh_max": rh_max
-            }
-            
-            # Add point to check if it's in comfort zone
-            st.write("Check if a point is within the comfort zone:")
-            
-            col1, col2 = st.columns(2)
-            
-            with col1:
-                check_temp = st.number_input("Temperature (°C)", -10.0, 50.0, 22.0, key="check_temp")
-                check_rh = st.number_input("RH (%)", 0.0, 100.0, 45.0, key="check_rh")
-            
-            # Check if point is in comfort zone
-            in_comfort_zone = (
-                temp_min <= check_temp <= temp_max and
-                rh_min <= check_rh <= rh_max
-            )
-            
-            with col2:
-                if in_comfort_zone:
-                    st.success("✅ Point is within the comfort zone")
-                else:
-                    st.error("❌ Point is outside the comfort zone")
-                
-                # Calculate properties
-                check_props = self.psychrometrics.moist_air_properties(check_temp, check_rh, self.pressure)
-                st.write(f"Humidity Ratio: {check_props['humidity_ratio']*1000:.2f} g/kg")
-                st.write(f"Enthalpy: {check_props['enthalpy']/1000:.2f} kJ/kg")
-                st.write(f"Wet-Bulb Temperature: {check_props['wet_bulb_temperature']:.2f} °C")
-            
-            # Create and display chart with comfort zone
-            fig = self.create_psychrometric_chart(
-                points=[{"temp": check_temp, "rh": check_rh, "name": "Test Point", "color": "purple"}],
-                comfort_zone=comfort_zone
-            )
-            
-            st.plotly_chart(fig, use_container_width=True)
-
-
-# Create a singleton instance
-psychrometric_visualization = PsychrometricVisualization()
-
-# Example usage
-if __name__ == "__main__":
-    import streamlit as st
-    
-    # Display psychrometric visualization
-    psychrometric_visualization.display_psychrometric_visualization()
+        # Create comfort zone
+        comfort_zone = {
+            "temp_min": 20,
+            "temp_max": 26,
+            "rh_min": 30,
+            "rh_max": 60
+        }
+        
+        # Create psychrometric chart
+        fig = self.create_psychrometric_chart(points, processes, comfort_zone)
+        
+        # Display chart in Streamlit
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # Display psychrometric properties
+        st.subheader("Psychrometric Properties")
+        
+        # Create dataframe for properties
+        properties = []
+        
+        # Summer outdoor properties
+        summer_outdoor_rh = self.psychrometrics.relative_humidity_from_wb(summer_outdoor_db, summer_outdoor_wb, self.pressure)
+        summer_outdoor_dp = self.psychrometrics.dew_point(summer_outdoor_db, summer_outdoor_rh, self.pressure)
+        summer_outdoor_h = self.psychrometrics.enthalpy(summer_outdoor_db, summer_outdoor_w)
+        summer_outdoor_v = self.psychrometrics.specific_volume(summer_outdoor_db, summer_outdoor_w, self.pressure)
+        
+        properties.append({
+            "Point": "Summer Outdoor",
+            "Dry-Bulb (°C)": f"{summer_outdoor_db:.1f}",
+            "Wet-Bulb (°C)": f"{summer_outdoor_wb:.1f}",
+            "Relative Humidity (%)": f"{summer_outdoor_rh:.1f}",
+            "Humidity Ratio (g/kg)": f"{summer_outdoor_w*1000:.1f}",
+            "Dew Point (°C)": f"{summer_outdoor_dp:.1f}",
+            "Enthalpy (kJ/kg)": f"{summer_outdoor_h/1000:.1f}",
+            "Specific Volume (m³/kg)": f"{summer_outdoor_v:.3f}"
+        })
+        
+        # Summer indoor properties
+        summer_indoor_wb = self.psychrometrics.wet_bulb_temperature(summer_indoor_db, summer_indoor_rh, self.pressure)
+        summer_indoor_dp = self.psychrometrics.dew_point(summer_indoor_db, summer_indoor_rh, self.pressure)
+        summer_indoor_h = self.psychrometrics.enthalpy(summer_indoor_db, summer_indoor_w)
+        summer_indoor_v = self.psychrometrics.specific_volume(summer_indoor_db, summer_indoor_w, self.pressure)
+        
+        properties.append({
+            "Point": "Summer Indoor",
+            "Dry-Bulb (°C)": f"{summer_indoor_db:.1f}",
+            "Wet-Bulb (°C)": f"{summer_indoor_wb:.1f}",
+            "Relative Humidity (%)": f"{summer_indoor_rh:.1f}",
+            "Humidity Ratio (g/kg)": f"{summer_indoor_w*1000:.1f}",
+            "Dew Point (°C)": f"{summer_indoor_dp:.1f}",
+            "Enthalpy (kJ/kg)": f"{summer_indoor_h/1000:.1f}",
+            "Specific Volume (m³/kg)": f"{summer_indoor_v:.3f}"
+        })
+        
+        # Winter outdoor properties
+        winter_outdoor_wb = self.psychrometrics.wet_bulb_temperature(winter_outdoor_db, winter_outdoor_rh, self.pressure)
+        winter_outdoor_dp = self.psychrometrics.dew_point(winter_outdoor_db, winter_outdoor_rh, self.pressure)
+        winter_outdoor_h = self.psychrometrics.enthalpy(winter_outdoor_db, winter_outdoor_w)
+        winter_outdoor_v = self.psychrometrics.specific_volume(winter_outdoor_db, winter_outdoor_w, self.pressure)
+        
+        properties.append({
+            "Point": "Winter Outdoor",
+            "Dry-Bulb (°C)": f"{winter_outdoor_db:.1f}",
+            "Wet-Bulb (°C)": f"{winter_outdoor_wb:.1f}",
+            "Relative Humidity (%)": f"{winter_outdoor_rh:.1f}",
+            "Humidity Ratio (g/kg)": f"{winter_outdoor_w*1000:.1f}",
+            "Dew Point (°C)": f"{winter_outdoor_dp:.1f}",
+            "Enthalpy (kJ/kg)": f"{winter_outdoor_h/1000:.1f}",
+            "Specific Volume (m³/kg)": f"{winter_outdoor_v:.3f}"
+        })
+        
+        # Winter indoor properties
+        winter_indoor_wb = self.psychrometrics.wet_bulb_temperature(winter_indoor_db, winter_indoor_rh, self.pressure)
+        winter_indoor_dp = self.psychrometrics.dew_point(winter_indoor_db, winter_indoor_rh, self.pressure)
+        winter_indoor_h = self.psychrometrics.enthalpy(winter_indoor_db, winter_indoor_w)
+        winter_indoor_v = self.psychrometrics.specific_volume(winter_indoor_db, winter_indoor_w, self.pressure)
+        
+        properties.append({
+            "Point": "Winter Indoor",
+            "Dry-Bulb (°C)": f"{winter_indoor_db:.1f}",
+            "Wet-Bulb (°C)": f"{winter_indoor_wb:.1f}",
+            "Relative Humidity (%)": f"{winter_indoor_rh:.1f}",
+            "Humidity Ratio (g/kg)": f"{winter_indoor_w*1000:.1f}",
+            "Dew Point (°C)": f"{winter_indoor_dp:.1f}",
+            "Enthalpy (kJ/kg)": f"{winter_indoor_h/1000:.1f}",
+            "Specific Volume (m³/kg)": f"{winter_indoor_v:.3f}"
+        })
+        
+        # Display properties table
+        st.dataframe(pd.DataFrame(properties), use_container_width=True)