first commit

app.py

@@ -0,0 +1,489 @@
+# app.py
+
+import streamlit as st
+import pandas as pd
+import numpy as np
+from typing import Dict
+from PIL import Image
+import matplotlib.pyplot as plt
+
+from src.models import TrafficData, ClimateData, SubgradeProperties, MaterialProperties, Pavement
+from src.performance import design_new_pavement
+from src.lcca import perform_LCCA
+from src.reporting import generate_report, export_report_to_pdf
+from src.design import design_pavement_structure
+from src.utils.helpers import read_excel, save_pdf
+from src.utils.logger import setup_logger
+
+logger = setup_logger(__name__)
+
+st.set_page_config(page_title="ME Pavement Design Tool", layout="wide")
+
+st.title("🛣️ Mechanistic-Empirical Pavement Design Tool for Highways and Airports")
+
+image = Image.open('Pavement.jpg')
+
+# Display the image at the top of the sidebar
+st.sidebar.image(image, use_container_width=True)
+
+# Sidebar for Navigation
+st.sidebar.title("Navigation")
+app_mode = st.sidebar.selectbox("Choose the app mode",
+                                ["Home", "Input Data", "Design Pavement", "Run Simulation", "View Results", "Generate Report"])
+
+# Initialize session state
+if 'simulation_results' not in st.session_state:
+    st.session_state.simulation_results = {}
+if 'lcc' not in st.session_state:
+    st.session_state.lcc = 0.0
+if 'maintenance_costs' not in st.session_state:
+    st.session_state.maintenance_costs = {}
+if 'lcc_over_time' not in st.session_state:
+    st.session_state.lcc_over_time = {}
+if 'pavement_design' not in st.session_state:
+    st.session_state.pavement_design = {}
+
+# Home Page
+if app_mode == "Home":
+    st.markdown("""
+    ## Welcome to the Mechanistic-Empirical Pavement Design Tool
+
+    This tool allows you to design new pavements and evaluate their performance based on traffic, material, and environmental data. Follow the navigation steps on the sidebar to input data, design pavement structures, run simulations, view results, and generate comprehensive reports.
+    """)
+
+# Input Data Page
+elif app_mode == "Input Data":
+    st.header("Input Data")
+
+    st.markdown("""
+    ### 📋 Dataset Format Instructions
+    
+    Please ensure that your Excel file contains the following sheets with the specified columns like the example dataset.
+
+    **Example Dataset**:
+    
+    - **Traffic Sheet**:
+    
+        | Axle_Loads | Traffic_Growth_Rate | Analysis_Period |
+        |------------|---------------------|------------------|
+        | 80         | 2.0                 | 20               |
+        | 100        |                     |                  |
+        | 120        |                     |                  |
+    
+    - **Climate Sheet**:
+    
+        | Average_Temperature | Temperature_Variation | Rainfall |
+        |---------------------|-----------------------|----------|
+        | 15                  | 10                    | 500      |
+    
+    - **Subgrade Sheet**:
+    
+        | Modulus | CBR |
+        |---------|-----|
+        | 3000    | 10  |
+    
+    - **Materials Sheet**:
+    
+        | Asphalt_Modulus | Concrete_Strength | Thermal_Coeff |
+        |-----------------|--------------------|---------------|
+        | 3000            | 30                 | 0.0001        |
+    """)
+
+    st.subheader("Upload Input Data Excel File")
+    uploaded_file = st.file_uploader("Choose an Excel file with required data", type=["xlsx"])
+
+    if uploaded_file:
+        try:
+            data_sheets = read_excel(uploaded_file)
+            # Assuming sheets named 'Traffic', 'Climate', 'Subgrade', 'Materials'
+            traffic_df = data_sheets.get('Traffic') or data_sheets.get('Sheet1')  # Fallback to first sheet
+            climate_df = data_sheets.get('Climate') or data_sheets.get('Sheet2')
+            subgrade_df = data_sheets.get('Subgrade') or data_sheets.get('Sheet3')
+            materials_df = data_sheets.get('Materials') or data_sheets.get('Sheet4')
+
+            # Create data model instances
+            traffic_data = TrafficData.from_dataframe(traffic_df)
+            climate_data = ClimateData.from_dataframe(climate_df)
+            subgrade_props = SubgradeProperties.from_dataframe(subgrade_df)
+            material_props = MaterialProperties.from_dataframe(materials_df)
+
+            # Store in session state
+            st.session_state.traffic_data = traffic_data
+            st.session_state.climate_data = climate_data
+            st.session_state.subgrade_props = subgrade_props
+            st.session_state.material_props = material_props
+
+            st.success("Data loaded successfully from the uploaded Excel file.")
+        except Exception as e:
+            st.error(f"Failed to load data: {e}")
+
+    st.markdown("""
+    ### Alternatively, Enter Data Manually
+    """)
+
+    with st.form("manual_data_form"):
+        st.subheader("Traffic Data")
+        axle_loads = st.text_input("Axle Loads (comma-separated in kN)", value="80, 100, 120")
+        traffic_growth_rate = st.number_input("Traffic Growth Rate (% per annum)", min_value=0.0, max_value=100.0, value=2.0, step=0.1)
+        analysis_period = st.number_input("Analysis Period (Years)", min_value=1, max_value=100, value=20, step=1)
+
+        st.subheader("Climate Data")
+        average_temperature = st.number_input("Average Temperature (°C)", value=15.0)
+        temperature_variation = st.number_input("Temperature Variation (°C)", value=10.0)
+        rainfall = st.number_input("Annual Rainfall (mm)", value=500.0)
+
+        st.subheader("Subgrade Properties")
+        modulus = st.number_input("Modulus of Subgrade Reaction (kPa/m)", value=3000.0)
+        CBR = st.number_input("California Bearing Ratio (CBR %)", value=10.0)
+
+        st.subheader("Material Properties")
+        asphalt_modulus = st.number_input("Asphalt Modulus (MPa)", value=3000.0)
+        concrete_strength = st.number_input("Concrete Strength (MPa)", value=30.0)
+        thermal_coeff = st.number_input("Thermal Coefficient (°C^-1)", value=0.0001)
+
+        submitted = st.form_submit_button("Submit Data")
+        if submitted:
+            try:
+                axle_loads_list = [float(load.strip()) for load in axle_loads.split(",")]
+                traffic_data = TrafficData(axle_loads=axle_loads_list,
+                                           traffic_growth_rate=traffic_growth_rate / 100,
+                                           analysis_period=int(analysis_period))
+                climate_data = ClimateData(average_temperature=average_temperature,
+                                           temperature_variation=temperature_variation,
+                                           rainfall=rainfall)
+                subgrade_props = SubgradeProperties(modulus=modulus, CBR=CBR)
+                material_props = MaterialProperties(asphalt_modulus=asphalt_modulus,
+                                                   concrete_strength=concrete_strength,
+                                                   thermal_coeff=thermal_coeff)
+
+                # Store in session state
+                st.session_state.traffic_data = traffic_data
+                st.session_state.climate_data = climate_data
+                st.session_state.subgrade_props = subgrade_props
+                st.session_state.material_props = material_props
+
+                st.success("Data entered successfully.")
+            except Exception as e:
+                st.error(f"Error in data entry: {e}")
+
+
+# Design Pavement Page
+elif app_mode == "Design Pavement":
+    st.header("Design Pavement Structure")
+
+    if ('traffic_data' in st.session_state and 
+        'climate_data' in st.session_state and 
+        'subgrade_props' in st.session_state and 
+        'material_props' in st.session_state):
+
+        st.subheader("Define Pavement Layers")
+        with st.form("pavement_design_form"):
+            # User inputs the number of pavement layers
+            num_layers = st.number_input(
+                "Number of Pavement Layers", 
+                min_value=1, 
+                max_value=10, 
+                value=3, 
+                step=1,
+                help="Specify the total number of pavement layers you wish to design."
+            )
+
+            layers = []
+            st.markdown("### Define Each Layer")
+            for i in range(1, int(num_layers) + 1):
+                st.markdown(f"**Layer {i}**")
+                
+                # Select layer type
+                layer_type = st.selectbox(
+                    f"Layer {i} Type", 
+                    options=["Asphalt", "Concrete", "Base", "Sub-base"], 
+                    key=f"layer_type_{i}",
+                    help="Select the material type for this pavement layer."
+                )
+                
+                # Input layer thickness
+                thickness = st.number_input(
+                    f"Layer {i} Thickness (mm)", 
+                    min_value=1.0, 
+                    max_value=1000.0, 
+                    value=100.0, 
+                    step=1.0, 
+                    key=f"layer_thickness_{i}",
+                    help="Enter the thickness of this layer in millimeters."
+                )
+                
+                layers.append((layer_type, thickness))  # Store as tuple
+
+            st.markdown("### Define Cost per Layer Type")
+            st.write("Enter the cost per millimeter for each layer type. These costs will be used to calculate the total estimated cost of the pavement.")
+
+            # Input costs for each layer type
+            asphalt_cost = st.number_input(
+                "Asphalt Cost per mm ($)", 
+                min_value=0.0, 
+                value=50.0, 
+                step=1.0,
+                help="Enter the cost per millimeter for Asphalt layers."
+            )
+            concrete_cost = st.number_input(
+                "Concrete Cost per mm ($)", 
+                min_value=0.0, 
+                value=80.0, 
+                step=1.0,
+                help="Enter the cost per millimeter for Concrete layers."
+            )
+            base_cost = st.number_input(
+                "Base Cost per mm ($)", 
+                min_value=0.0, 
+                value=40.0, 
+                step=1.0,
+                help="Enter the cost per millimeter for Base layers."
+            )
+            subbase_cost = st.number_input(
+                "Sub-base Cost per mm ($)", 
+                min_value=0.0, 
+                value=30.0, 
+                step=1.0,
+                help="Enter the cost per millimeter for Sub-base layers."
+            )
+
+            # Submit button to define pavement structure
+            submitted = st.form_submit_button("Define Pavement Structure")
+            if submitted:
+                try:
+                    # Create a dictionary for layer costs based on user input
+                    layer_costs = {
+                        "Asphalt": asphalt_cost,
+                        "Concrete": concrete_cost,
+                        "Base": base_cost,
+                        "Sub-base": subbase_cost
+                    }
+
+                    # Store pavement design and layer costs in session state
+                    st.session_state.pavement_design = layers
+                    st.session_state.layer_costs = layer_costs
+                    st.success("Pavement structure defined successfully.")
+                except Exception as e:
+                    st.error(f"Error in pavement design: {e}")
+
+        if 'pavement_design' in st.session_state and 'layer_costs' in st.session_state:
+            st.subheader("Pavement Design Summary")
+            design_summary = st.session_state.pavement_design
+            layer_costs = st.session_state.layer_costs
+
+            # Perform Calculations Based on User Input
+            total_thickness = sum([thickness for _, thickness in design_summary])
+            total_cost = sum([layer_costs.get(layer_type, 0) * thickness for layer_type, thickness in design_summary])
+
+            # Predict Distresses (Simplified Example Formulas)
+            fatigue_cracking = total_thickness * 0.05  # Placeholder formula
+            rutting = total_thickness * 0.03
+            thermal_cracking = total_thickness * 0.02
+
+            # Display Calculation Results
+            st.write(f"**Total Pavement Thickness:** {total_thickness} mm")
+            st.write(f"**Estimated Total Cost:** ${total_cost:,.2f}")
+            st.write(f"**Predicted Fatigue Cracking:** {fatigue_cracking:.2f} cracks")
+            st.write(f"**Predicted Rutting:** {rutting:.2f} mm")
+            st.write(f"**Predicted Thermal Cracking:** {thermal_cracking:.2f} cracks")
+
+            st.subheader("Detailed Pavement Layers")
+            design_df = pd.DataFrame(design_summary, columns=["Layer Type", "Thickness (mm)"])
+            st.table(design_df)
+
+            # Optional: Visual Representation of Pavement Layers
+            st.markdown("### Pavement Structure Visualization")
+            fig, ax = plt.subplots(figsize=(6, 3))
+            current_y = 0
+            for layer_type, thickness in design_summary:
+                ax.barh(1, thickness, left=current_y, height=0.5, label=layer_type)
+                current_y += thickness
+            ax.set_xlabel("Thickness (mm)")
+            ax.set_yticks([])
+            ax.legend()
+            st.pyplot(fig)
+
+
+# Run Simulation Page
+elif app_mode == "Run Simulation":
+    st.header("Run Simulation")
+
+    if 'pavement_design' in st.session_state and 'traffic_data' in st.session_state and 'climate_data' in st.session_state and \
+       'subgrade_props' in st.session_state and 'material_props' in st.session_state:
+
+        st.subheader("Simulation Parameters")
+        with st.form("simulation_parameters_form"):
+            initial_cost = st.number_input("Initial Construction Cost ($)", min_value=0.0, value=1000000.0, step=1000.0)
+            maintenance_costs_input = st.text_area("Maintenance Costs (Year:Cost, separated by commas)", 
+                                                   value="5:100000, 10:150000, 15:200000, 20:250000")
+            discount_rate = st.number_input("Discount Rate (% per annum)", min_value=0.0, max_value=100.0, value=3.0, step=0.1)
+            analysis_period = st.number_input("Lifecycle Analysis Period (Years)", min_value=1, max_value=100, value=20, step=1)
+
+            submitted = st.form_submit_button("Run Simulation")
+            if submitted:
+                try:
+                    # Parse maintenance costs
+                    maintenance_costs = {}
+                    for item in maintenance_costs_input.split(","):
+                        if ':' in item:
+                            year, cost = item.strip().split(":")
+                            maintenance_costs[int(year)] = float(cost)
+                        else:
+                            st.warning(f"Ignoring invalid maintenance cost entry: '{item}'")
+
+                    # Retrieve data from session state
+                    pavement_design = st.session_state.pavement_design
+                    traffic_data = st.session_state.traffic_data
+                    climate_data = st.session_state.climate_data
+                    subgrade_props = st.session_state.subgrade_props
+                    material_props = st.session_state.material_props
+
+                    # Run simulation
+                    simulation_results = design_new_pavement(pavement_design, traffic_data, climate_data, subgrade_props, material_props)
+                    st.session_state.simulation_results = simulation_results
+
+                    # Perform LCCA
+                    lcc = perform_LCCA(initial_cost, maintenance_costs, discount_rate / 100, analysis_period)
+                    st.session_state.lcc = lcc
+                    st.session_state.maintenance_costs = maintenance_costs
+
+                    # Calculate LCCA over time for visualization
+                    lcc_over_time = []
+                    cumulative_lcc = initial_cost
+                    for year in range(1, analysis_period + 1):
+                        maintenance_cost = maintenance_costs.get(year, 0)
+                        discounted_cost = maintenance_cost / ((1 + discount_rate / 100) ** year)
+                        cumulative_lcc += discounted_cost
+                        lcc_over_time.append(cumulative_lcc)
+                    st.session_state.lcc_over_time = lcc_over_time
+
+                    st.success("Simulation and LCCA completed successfully.")
+
+                except Exception as e:
+                    st.error(f"Error during simulation: {e}")
+    else:
+        st.warning("Please input the necessary data in the 'Input Data' and 'Design Pavement' sections before running simulations.")
+
+# View Results Page
+elif app_mode == "View Results":
+    st.header("Simulation Results")
+
+    if 'simulation_results' in st.session_state and st.session_state.simulation_results:
+        simulation_results = st.session_state.simulation_results
+        lcc = st.session_state.lcc
+        maintenance_costs = st.session_state.maintenance_costs
+        lcc_over_time = st.session_state.lcc_over_time
+
+        st.subheader("Pavement Performance Predictions")
+        df_results = pd.DataFrame(list(simulation_results.items()), columns=["Distress Type", "Value"])
+        st.table(df_results)
+
+        st.subheader("Lifecycle Cost Analysis (LCCA)")
+        st.write(f"**Total Lifecycle Cost:** ${lcc:,.2f}")
+
+        # Visualization 1: Pie Chart of Distress Types
+        st.subheader("Distribution of Pavement Distresses")
+        pie_chart_data = df_results.set_index('Distress Type')
+        st.pyplot(pie_chart_data.plot.pie(y='Value', autopct='%1.1f%%', figsize=(6, 6)).figure)
+
+        # Visualization 2: Bar Chart of Distress Types
+        st.subheader("Pavement Distresses Overview")
+        st.bar_chart(df_results.set_index('Distress Type'))
+
+        # Visualization 3: Line Chart of Lifecycle Cost Over Time
+        if lcc_over_time:
+            st.subheader("Lifecycle Cost Over Time")
+            years = list(range(1, len(lcc_over_time) + 1))
+            cost_data = pd.DataFrame({
+                'Year': years,
+                'Cumulative LCC': lcc_over_time
+            })
+            st.line_chart(cost_data.set_index('Year'))
+
+            # Detailed Breakdown Table
+            st.subheader("Maintenance Costs Over Time")
+            maintenance_df = pd.DataFrame({
+                'Year': list(maintenance_costs.keys()),
+                'Maintenance Cost ($)': list(maintenance_costs.values())
+            }).sort_values('Year')
+            st.table(maintenance_df)
+
+            # Visualization 4: Line Chart of Cumulative LCCA
+            st.subheader("Cumulative Lifecycle Cost Analysis")
+            st.line_chart(cost_data.set_index('Year'))
+
+        # Visualization 5: Comparison of Initial Cost vs LCCA
+        st.subheader("Initial Cost vs Total Lifecycle Cost")
+        initial_cost = st.session_state.get('initial_cost', 0)
+        comparison_df = pd.DataFrame({
+            'Cost Type': ['Initial Construction Cost', 'Total Lifecycle Cost'],
+            'Amount ($)': [initial_cost, lcc]
+        })
+        st.bar_chart(comparison_df.set_index('Cost Type'))
+
+        # Additional Visualization: Pie Chart of Maintenance Cost Distribution
+        if maintenance_costs:
+            st.subheader("Maintenance Cost Distribution")
+            maintenance_df_pie = pd.DataFrame({
+                'Year': list(maintenance_costs.keys()),
+                'Maintenance Cost ($)': list(maintenance_costs.values())
+            }).sort_values('Year')
+            st.pyplot(maintenance_df_pie.plot.pie(y='Maintenance Cost ($)', labels=maintenance_df_pie['Year'], autopct='%1.1f%%', figsize=(6,6)).figure)
+
+        # Pavement Design Results
+        if 'pavement_design' in st.session_state and st.session_state.pavement_design:
+            st.subheader("Pavement Design Results")
+            pavement_design = st.session_state.pavement_design
+            design_df = pd.DataFrame(pavement_design, columns=["Layer Type", "Thickness (mm)"])
+            st.table(design_df)
+
+    else:
+        st.warning("No simulation results to display. Please run a simulation first.")
+
+# Generate Report Page
+elif app_mode == "Generate Report":
+    st.header("Generate Report")
+
+    if 'simulation_results' in st.session_state and st.session_state.simulation_results and \
+       'lcc' in st.session_state and st.session_state.lcc > 0 and \
+       'maintenance_costs' in st.session_state and st.session_state.maintenance_costs:
+        simulation_results = st.session_state.simulation_results
+        lcc = st.session_state.lcc
+        maintenance_costs = st.session_state.maintenance_costs
+        lcc_over_time = st.session_state.lcc_over_time
+
+        st.subheader("Review Results Before Report Generation")
+        df_results = pd.DataFrame(list(simulation_results.items()), columns=["Distress Type", "Value"])
+        st.table(df_results)
+        st.write(f"**Lifecycle Cost Analysis (LCCA):** ${lcc:,.2f}")
+
+        st.subheader("Maintenance Costs Breakdown")
+        maintenance_df = pd.DataFrame({
+            'Year': list(maintenance_costs.keys()),
+            'Maintenance Cost ($)': list(maintenance_costs.values())
+        }).sort_values('Year')
+        st.table(maintenance_df)
+
+        st.subheader("Lifecycle Cost Over Time")
+        if lcc_over_time:
+            years = list(range(1, len(lcc_over_time) + 1))
+            cost_data = pd.DataFrame({
+                'Year': years,
+                'Cumulative LCC': lcc_over_time
+            })
+            st.line_chart(cost_data.set_index('Year'))
+
+        generate_report_btn = st.button("Generate and Download Report")
+        if generate_report_btn:
+            try:
+                report_content = generate_report(simulation_results, lcc)
+                report_path = "pavement_design_report.pdf"
+                export_report_to_pdf(report_content, report_path)
+                with open(report_path, "rb") as pdf_file:
+                    PDFbyte = pdf_file.read()
+                st.download_button(label="Download Report as PDF", data=PDFbyte, file_name="pavement_design_report.pdf", mime='application/octet-stream')
+                st.success("Report generated and ready for download.")
+            except Exception as e:
+                st.error(f"Failed to generate report: {e}")
+    else:
+        st.warning("No simulation results available. Please run a simulation first.")

me_pavement_design.log

@@ -0,0 +1,99 @@
+2024-12-22 12:01:33,543 - src.performance - INFO - Total Fatigue Damage: 0.004472024810545181
+2024-12-22 12:01:33,544 - src.performance - INFO - Total Rutting: 1.2148684899458864 mm
+2024-12-22 12:01:33,546 - src.performance - INFO - Thermal Cracking Index: 0.001
+2024-12-22 12:01:33,546 - src.performance - INFO - Pavement design simulation completed.
+2024-12-22 12:01:33,546 - src.lcca - INFO - Starting Life-Cycle Cost Analysis (LCCA).
+2024-12-22 12:01:33,547 - src.lcca - INFO - Initial Cost: $1,000,000.00
+2024-12-22 12:01:33,547 - src.lcca - INFO - Total Lifecycle Cost (LCCA): $1,464,666.29
+2024-12-22 12:09:07,879 - src.performance - INFO - Total Fatigue Damage: 0.01724620834913378
+2024-12-22 12:09:07,879 - src.performance - INFO - Total Rutting: 2.0822954143592756 mm
+2024-12-22 12:09:07,880 - src.performance - INFO - Thermal Cracking Index: 0.001
+2024-12-22 12:09:07,880 - src.performance - INFO - Pavement design simulation completed.
+2024-12-22 12:09:07,881 - src.lcca - INFO - Starting Life-Cycle Cost Analysis (LCCA).
+2024-12-22 12:09:07,881 - src.lcca - INFO - Initial Cost: $1,000,000.00
+2024-12-22 12:09:07,882 - src.lcca - INFO - Total Lifecycle Cost (LCCA): $1,464,666.29
+2024-12-22 12:38:41,947 - src.performance - INFO - Total Fatigue Damage: 0.004472024810545181
+2024-12-22 12:38:41,950 - src.performance - INFO - Total Rutting: 1.2148684899458864 mm
+2024-12-22 12:38:41,950 - src.performance - INFO - Thermal Cracking Index: 0.001
+2024-12-22 12:38:41,950 - src.performance - INFO - Pavement design simulation completed.
+2024-12-22 12:38:41,950 - src.lcca - INFO - Starting Life-Cycle Cost Analysis (LCCA).
+2024-12-22 12:38:41,951 - src.lcca - INFO - Initial Cost: $1,000,000.00
+2024-12-22 12:38:41,951 - src.lcca - INFO - Total Lifecycle Cost (LCCA): $1,464,666.29
+2024-12-22 13:01:04,873 - src.performance - INFO - Total Fatigue Damage: 0.004472024810545181
+2024-12-22 13:01:04,875 - src.performance - INFO - Total Rutting: 1.2148684899458864 mm
+2024-12-22 13:01:04,877 - src.performance - INFO - Thermal Cracking Index: 0.001
+2024-12-22 13:01:04,877 - src.performance - INFO - Pavement design simulation completed.
+2024-12-22 13:01:04,877 - src.lcca - INFO - Starting Life-Cycle Cost Analysis (LCCA).
+2024-12-22 13:01:04,878 - src.lcca - INFO - Initial Cost: $1,000,000.00
+2024-12-22 13:01:04,878 - src.lcca - INFO - Total Lifecycle Cost (LCCA): $1,464,666.29
+2024-12-22 13:01:35,819 - src.reporting - INFO - Report generated successfully.
+2024-12-22 13:01:35,820 - src.reporting - ERROR - ReportLab is not installed. Please install it using 'pip install reportlab'
+2024-12-22 13:02:54,979 - src.performance - INFO - Total Fatigue Damage: 0.004472024810545181
+2024-12-22 13:02:54,982 - src.performance - INFO - Total Rutting: 1.2148684899458864 mm
+2024-12-22 13:02:54,982 - src.performance - INFO - Thermal Cracking Index: 0.001
+2024-12-22 13:02:54,982 - src.performance - INFO - Pavement design simulation completed.
+2024-12-22 13:02:54,983 - src.lcca - INFO - Starting Life-Cycle Cost Analysis (LCCA).
+2024-12-22 13:02:54,983 - src.lcca - INFO - Initial Cost: $1,000,000.00
+2024-12-22 13:02:54,983 - src.lcca - INFO - Total Lifecycle Cost (LCCA): $1,464,666.29
+2024-12-22 13:03:14,347 - src.reporting - INFO - Report generated successfully.
+2024-12-22 13:03:14,371 - src.reporting - INFO - Report exported to PDF at pavement_design_report.pdf
+2024-12-22 13:11:53,158 - src.performance - INFO - Total Fatigue Damage: 0.004472024810545181
+2024-12-22 13:11:53,161 - src.performance - INFO - Total Rutting: 1.2148684899458864 mm
+2024-12-22 13:11:53,161 - src.performance - INFO - Thermal Cracking Index: 0.001
+2024-12-22 13:11:53,161 - src.performance - INFO - Pavement design simulation completed.
+2024-12-22 13:11:53,162 - src.lcca - INFO - Starting Life-Cycle Cost Analysis (LCCA).
+2024-12-22 13:11:53,162 - src.lcca - INFO - Initial Cost: $1,000,000.00
+2024-12-22 13:11:53,162 - src.lcca - INFO - Total Lifecycle Cost (LCCA): $1,464,666.29
+2024-12-22 13:12:17,973 - src.reporting - INFO - Report generated successfully.
+2024-12-22 13:12:17,995 - src.reporting - INFO - Report exported to PDF at pavement_design_report.pdf
+2024-12-22 13:37:33,916 - src.performance - INFO - Total Fatigue Damage: 0.004472024810545181
+2024-12-22 13:37:33,917 - src.performance - INFO - Total Rutting: 1.2148684899458864 mm
+2024-12-22 13:37:33,918 - src.performance - INFO - Thermal Cracking Index: 0.001
+2024-12-22 13:37:33,919 - src.performance - INFO - Pavement design simulation completed.
+2024-12-22 13:37:33,920 - src.lcca - INFO - Starting Life-Cycle Cost Analysis (LCCA).
+2024-12-22 13:37:33,920 - src.lcca - INFO - Initial Cost: $1,000,000.00
+2024-12-22 13:37:33,920 - src.lcca - INFO - Total Lifecycle Cost (LCCA): $1,464,666.29
+2024-12-22 13:47:26,229 - src.performance - INFO - Total Fatigue Damage: 0.004472024810545181
+2024-12-22 13:47:26,230 - src.performance - INFO - Total Rutting: 1.2148684899458864 mm
+2024-12-22 13:47:26,230 - src.performance - INFO - Thermal Cracking Index: 0.001
+2024-12-22 13:47:26,231 - src.performance - INFO - Pavement design simulation completed.
+2024-12-22 13:47:26,231 - src.lcca - INFO - Starting Life-Cycle Cost Analysis (LCCA).
+2024-12-22 13:47:26,232 - src.lcca - INFO - Initial Cost: $1,000,000.00
+2024-12-22 13:47:26,232 - src.lcca - INFO - Total Lifecycle Cost (LCCA): $1,464,666.29
+2024-12-22 14:01:58,282 - src.performance - INFO - Total Fatigue Damage: 0.004472024810545181
+2024-12-22 14:01:58,284 - src.performance - INFO - Total Rutting: 1.2148684899458864 mm
+2024-12-22 14:01:58,284 - src.performance - INFO - Thermal Cracking Index: 0.001
+2024-12-22 14:01:58,284 - src.performance - INFO - Pavement design simulation completed.
+2024-12-22 14:01:58,285 - src.lcca - INFO - Starting Life-Cycle Cost Analysis (LCCA).
+2024-12-22 14:01:58,285 - src.lcca - INFO - Initial Cost: $1,000,000.00
+2024-12-22 14:01:58,285 - src.lcca - INFO - Total Lifecycle Cost (LCCA): $1,464,666.29
+2024-12-22 14:02:55,470 - src.reporting - INFO - Report generated successfully.
+2024-12-22 14:02:55,493 - src.reporting - INFO - Report exported to PDF at pavement_design_report.pdf
+2024-12-22 14:04:45,178 - src.performance - INFO - Total Fatigue Damage: 0.004472024810545181
+2024-12-22 14:04:45,179 - src.performance - INFO - Total Rutting: 1.2148684899458864 mm
+2024-12-22 14:04:45,180 - src.performance - INFO - Thermal Cracking Index: 0.001
+2024-12-22 14:04:45,180 - src.performance - INFO - Pavement design simulation completed.
+2024-12-22 14:04:45,181 - src.lcca - INFO - Starting Life-Cycle Cost Analysis (LCCA).
+2024-12-22 14:04:45,181 - src.lcca - INFO - Initial Cost: $1,000,000.00
+2024-12-22 14:04:45,182 - src.lcca - INFO - Total Lifecycle Cost (LCCA): $1,464,666.29
+2024-12-22 14:15:49,886 - src.performance - INFO - Total Fatigue Damage: 0.004472024810545181
+2024-12-22 14:15:49,887 - src.performance - INFO - Total Rutting: 1.2148684899458864 mm
+2024-12-22 14:15:49,887 - src.performance - INFO - Thermal Cracking Index: 0.001
+2024-12-22 14:15:49,887 - src.performance - INFO - Pavement design simulation completed.
+2024-12-22 14:15:49,889 - src.lcca - INFO - Starting Life-Cycle Cost Analysis (LCCA).
+2024-12-22 14:15:49,890 - src.lcca - INFO - Initial Cost: $1,000,000.00
+2024-12-22 14:15:49,891 - src.lcca - INFO - Total Lifecycle Cost (LCCA): $1,464,666.29
+2024-12-22 14:30:46,841 - src.performance - INFO - Total Fatigue Damage: 0.004472024810545181
+2024-12-22 14:30:46,843 - src.performance - INFO - Total Rutting: 1.2148684899458864 mm
+2024-12-22 14:30:46,843 - src.performance - INFO - Thermal Cracking Index: 0.001
+2024-12-22 14:30:46,843 - src.performance - INFO - Pavement design simulation completed.
+2024-12-22 14:30:46,845 - src.lcca - INFO - Starting Life-Cycle Cost Analysis (LCCA).
+2024-12-22 14:30:46,845 - src.lcca - INFO - Initial Cost: $1,000,000.00
+2024-12-22 14:30:46,845 - src.lcca - INFO - Total Lifecycle Cost (LCCA): $1,464,666.29
+2024-12-22 14:49:36,575 - src.performance - INFO - Total Fatigue Damage: 0.004472024810545181
+2024-12-22 14:49:36,576 - src.performance - INFO - Total Rutting: 1.2148684899458864 mm
+2024-12-22 14:49:36,577 - src.performance - INFO - Thermal Cracking Index: 0.001
+2024-12-22 14:49:36,577 - src.performance - INFO - Pavement design simulation completed.
+2024-12-22 14:49:36,577 - src.lcca - INFO - Starting Life-Cycle Cost Analysis (LCCA).
+2024-12-22 14:49:36,577 - src.lcca - INFO - Initial Cost: $1,000,000.00
+2024-12-22 14:49:36,578 - src.lcca - INFO - Total Lifecycle Cost (LCCA): $1,464,666.29

pavement_design_report.pdf

@@ -0,0 +1,68 @@
+%PDF-1.3
+%���� ReportLab Generated PDF document http://www.reportlab.com
+1 0 obj
+<<
+/F1 2 0 R
+>>
+endobj
+2 0 obj
+<<
+/BaseFont /Helvetica /Encoding /WinAnsiEncoding /Name /F1 /Subtype /Type1 /Type /Font
+>>
+endobj
+3 0 obj
+<<
+/Contents 7 0 R /MediaBox [ 0 0 612 792 ] /Parent 6 0 R /Resources <<
+/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
+>> /Rotate 0 /Trans <<
+
+>> 
+  /Type /Page
+>>
+endobj
+4 0 obj
+<<
+/PageMode /UseNone /Pages 6 0 R /Type /Catalog
+>>
+endobj
+5 0 obj
+<<
+/Author (anonymous) /CreationDate (D:20241222140255+00'00') /Creator (ReportLab PDF Library - www.reportlab.com) /Keywords () /ModDate (D:20241222140255+00'00') /Producer (ReportLab PDF Library - www.reportlab.com) 
+  /Subject (unspecified) /Title (untitled) /Trapped /False
+>>
+endobj
+6 0 obj
+<<
+/Count 1 /Kids [ 3 0 R ] /Type /Pages
+>>
+endobj
+7 0 obj
+<<
+/Filter [ /ASCII85Decode /FlateDecode ] /Length 385
+>>
+stream
+Gat$s9l%X#%))C:kcdE9g+3_:7KY_o=aTG,'H_\l>d`,EO3DbOrV,n=)NkO6Q&WW.H[=])%+;XfHV+b:`8PUQJ7ZM,_"&`U^4mpU`B<HP\aHU2=kmlV06-oAng"Y>5]X<_2*$gd_+&gH7MF\t4WOuJZ*l8YJA2-"L%43REM9i5Y58FZ_)a0,7+aKSP71u]00>l\^X9ku,1*S\W18t<A<%t38Xef9*FRWTd,nJoZ$bEiq$Eh/qF+rZ@,*U[:nFM@rN-U70LD<nH.\,.<OLIRXr`qa&2f5[9=SEZ]Z@!>;'ahB0L03/</lsiPl8^t^A,5<GpSFe4G6gVpsDnp'^D:-dSW8"!a^SA-#6\_-f$3@m<`C>7KoFV`T,9rd2.J,Z#p~>endstream
+endobj
+xref
+0 8
+0000000000 65535 f 
+0000000073 00000 n 
+0000000104 00000 n 
+0000000211 00000 n 
+0000000404 00000 n 
+0000000472 00000 n 
+0000000768 00000 n 
+0000000827 00000 n 
+trailer
+<<
+/ID 
+[<0765494f4f6e22fe0b5d4856b52b1ee6><0765494f4f6e22fe0b5d4856b52b1ee6>]
+% ReportLab generated PDF document -- digest (http://www.reportlab.com)
+
+/Info 5 0 R
+/Root 4 0 R
+/Size 8
+>>
+startxref
+1302
+%%EOF

src/design.py

@@ -0,0 +1,16 @@
+# src/design.py
+
+from typing import List, Tuple
+
+def design_pavement_structure(layers: List[Tuple[str, float]]) -> List[Tuple[str, float]]:
+    """
+    Process the defined pavement layers and structure.
+
+    :param layers: List of tuples containing layer type and thickness.
+    :return: List of tuples representing the pavement design.
+    """
+    try:
+        pavement_design = layers  # In this simple case, just return the layers as is
+        return pavement_design
+    except Exception as e:
+        raise ValueError(f"Error in pavement structure design: {e}")

src/lcca.py

@@ -0,0 +1,44 @@
+# src/lcca.py
+
+import logging
+from typing import Dict
+
+from src.utils.logger import setup_logger
+
+logger = setup_logger(__name__)
+
+
+def calculate_LCCA(initial_cost: float, maintenance_costs: Dict[int, float], discount_rate: float, analysis_period: int) -> float:
+    """
+    Calculate the Life-Cycle Cost Analysis (LCCA) for the pavement.
+
+    :param initial_cost: Initial construction cost.
+    :param maintenance_costs: Maintenance costs with year as key.
+    :param discount_rate: Annual discount rate (decimal, e.g., 0.03 for 3%).
+    :param analysis_period: Number of years to analyze.
+    :return: Present value of total lifecycle costs.
+    """
+    lcc = initial_cost
+    logger.info(f"Initial Cost: ${initial_cost:,.2f}")
+    for year in range(1, analysis_period + 1):
+        maintenance_cost = maintenance_costs.get(year, 0)
+        discounted_cost = maintenance_cost / ((1 + discount_rate) ** year)
+        lcc += discounted_cost
+        if maintenance_cost > 0:
+            logger.debug(f"Year {year}: Maintenance Cost ${maintenance_cost:,.2f}, Discounted Cost ${discounted_cost:,.2f}")
+    logger.info(f"Total Lifecycle Cost (LCCA): ${lcc:,.2f}")
+    return lcc
+
+
+def perform_LCCA(initial_cost: float, maintenance_costs: Dict[int, float], discount_rate: float, analysis_period: int) -> float:
+    """
+    Wrapper function to perform LCCA.
+
+    :param initial_cost: Initial construction cost.
+    :param maintenance_costs: Maintenance costs with year as key.
+    :param discount_rate: Annual discount rate.
+    :param analysis_period: Number of years to analyze.
+    :return: Present value of total lifecycle costs.
+    """
+    logger.info("Starting Life-Cycle Cost Analysis (LCCA).")
+    return calculate_LCCA(initial_cost, maintenance_costs, discount_rate, analysis_period)

src/models.py

@@ -0,0 +1,195 @@
+# src/models.py
+
+import numpy as np
+import pandas as pd
+from typing import List, Dict
+import logging
+
+from src.utils.logger import setup_logger
+
+logger = setup_logger(__name__)
+
+
+class TrafficData:
+    def __init__(self, axle_loads: List[float], traffic_growth_rate: float, analysis_period: int):
+        """
+        Initialize TrafficData with axle loads, growth rate, and analysis period.
+
+        :param axle_loads: List of axle loads in kN.
+        :param traffic_growth_rate: Annual traffic growth rate (decimal, e.g., 0.02 for 2%).
+        :param analysis_period: Number of years for analysis.
+        """
+        self.axle_loads = axle_loads
+        self.traffic_growth_rate = traffic_growth_rate
+        self.analysis_period = analysis_period
+
+    def get_total_axle_loads(self) -> List[List[float]]:
+        """
+        Project total axle loads over the analysis period considering growth rate.
+
+        :return: A list of lists, each sublist represents axle loads for a year.
+        """
+        total_loads = []
+        for year in range(self.analysis_period):
+            growth_factor = (1 + self.traffic_growth_rate) ** year
+            projected_loads = [load * growth_factor for load in self.axle_loads]
+            total_loads.append(projected_loads)
+            logger.debug(f"Year {year + 1}: {projected_loads}")
+        return total_loads
+
+    @staticmethod
+    def from_dataframe(df: pd.DataFrame) -> 'TrafficData':
+        """
+        Create TrafficData instance from a pandas DataFrame.
+
+        :param df: DataFrame with columns 'Axle_Loads', 'Traffic_Growth_Rate', 'Analysis_Period'.
+        :return: TrafficData instance.
+        """
+        try:
+            axle_loads = df['Axle_Loads'].dropna().tolist()
+            traffic_growth_rate = float(df['Traffic_Growth_Rate'].iloc[0])
+            analysis_period = int(df['Analysis_Period'].iloc[0])
+            logger.info("TrafficData loaded successfully from DataFrame.")
+            return TrafficData(axle_loads, traffic_growth_rate, analysis_period)
+        except Exception as e:
+            logger.error(f"Error creating TrafficData from DataFrame: {e}")
+            raise ValueError(f"Invalid Traffic Data: {e}")
+
+
+class ClimateData:
+    def __init__(self, average_temperature: float, temperature_variation: float, rainfall: float):
+        """
+        Initialize ClimateData with average temperature, temperature variation, and rainfall.
+
+        :param average_temperature: Average temperature in °C.
+        :param temperature_variation: Temperature variation in °C.
+        :param rainfall: Annual rainfall in mm.
+        """
+        self.average_temperature = average_temperature
+        self.temperature_variation = temperature_variation
+        self.rainfall = rainfall
+
+    @staticmethod
+    def from_dataframe(df: pd.DataFrame) -> 'ClimateData':
+        """
+        Create ClimateData instance from a pandas DataFrame.
+
+        :param df: DataFrame with columns 'Average_Temperature', 'Temperature_Variation', 'Rainfall'.
+        :return: ClimateData instance.
+        """
+        try:
+            average_temperature = float(df['Average_Temperature'].iloc[0])
+            temperature_variation = float(df['Temperature_Variation'].iloc[0])
+            rainfall = float(df['Rainfall'].iloc[0])
+            logger.info("ClimateData loaded successfully from DataFrame.")
+            return ClimateData(average_temperature, temperature_variation, rainfall)
+        except Exception as e:
+            logger.error(f"Error creating ClimateData from DataFrame: {e}")
+            raise ValueError(f"Invalid Climate Data: {e}")
+
+
+class SubgradeProperties:
+    def __init__(self, modulus: float, CBR: float):
+        """
+        Initialize SubgradeProperties with modulus and California Bearing Ratio (CBR).
+
+        :param modulus: Modulus of subgrade reaction in kPa/m.
+        :param CBR: California Bearing Ratio in %.
+        """
+        self.modulus = modulus
+        self.CBR = CBR
+
+    @staticmethod
+    def from_dataframe(df: pd.DataFrame) -> 'SubgradeProperties':
+        """
+        Create SubgradeProperties instance from a pandas DataFrame.
+
+        :param df: DataFrame with columns 'Modulus', 'CBR'.
+        :return: SubgradeProperties instance.
+        """
+        try:
+            modulus = float(df['Modulus'].iloc[0])
+            CBR = float(df['CBR'].iloc[0])
+            logger.info("SubgradeProperties loaded successfully from DataFrame.")
+            return SubgradeProperties(modulus, CBR)
+        except Exception as e:
+            logger.error(f"Error creating SubgradeProperties from DataFrame: {e}")
+            raise ValueError(f"Invalid Subgrade Properties Data: {e}")
+
+
+class MaterialProperties:
+    def __init__(self, asphalt_modulus: float, concrete_strength: float, thermal_coeff: float):
+        """
+        Initialize MaterialProperties with asphalt modulus, concrete strength, and thermal coefficient.
+
+        :param asphalt_modulus: Asphalt modulus in MPa.
+        :param concrete_strength: Concrete strength in MPa.
+        :param thermal_coeff: Thermal coefficient (°C^-1).
+        """
+        self.asphalt_modulus = asphalt_modulus
+        self.concrete_strength = concrete_strength
+        self.thermal_coeff = thermal_coeff
+
+    @staticmethod
+    def from_dataframe(df: pd.DataFrame) -> 'MaterialProperties':
+        """
+        Create MaterialProperties instance from a pandas DataFrame.
+
+        :param df: DataFrame with columns 'Asphalt_Modulus', 'Concrete_Strength', 'Thermal_Coeff'.
+        :return: MaterialProperties instance.
+        """
+        try:
+            asphalt_modulus = float(df['Asphalt_Modulus'].iloc[0])
+            concrete_strength = float(df['Concrete_Strength'].iloc[0])
+            thermal_coeff = float(df['Thermal_Coeff'].iloc[0])
+            logger.info("MaterialProperties loaded successfully from DataFrame.")
+            return MaterialProperties(asphalt_modulus, concrete_strength, thermal_coeff)
+        except Exception as e:
+            logger.error(f"Error creating MaterialProperties from DataFrame: {e}")
+            raise ValueError(f"Invalid Material Properties Data: {e}")
+
+
+class Pavement:
+    def __init__(self, layers: List[float], pavement_type: str = 'Flexible'):
+        """
+        Initialize Pavement structure.
+
+        :param layers: List of layer thicknesses in mm.
+        :param pavement_type: Type of pavement ('Flexible', 'Rigid', 'Composite').
+        """
+        self.layers = layers
+        self.pavement_type = pavement_type
+
+    def add_layer(self, thickness: float):
+        """
+        Add a new layer to the pavement structure.
+
+        :param thickness: Thickness of the new layer in mm.
+        """
+        self.layers.append(thickness)
+        logger.debug(f"Added layer: {thickness} mm. Total layers: {self.layers}")
+
+    def remove_layer(self, index: int):
+        """
+        Remove a layer from the pavement structure by index.
+
+        :param index: Index of the layer to remove.
+        """
+        if 0 <= index < len(self.layers):
+            removed = self.layers.pop(index)
+            logger.debug(f"Removed layer at index {index}: {removed} mm. Remaining layers: {self.layers}")
+        else:
+            logger.warning(f"Attempted to remove non-existent layer at index {index}.")
+
+    def set_pavement_type(self, pavement_type: str):
+        """
+        Set the type of pavement.
+
+        :param pavement_type: Type of pavement ('Flexible', 'Rigid', 'Composite').
+        """
+        if pavement_type in ['Flexible', 'Rigid', 'Composite']:
+            self.pavement_type = pavement_type
+            logger.debug(f"Pavement type set to {pavement_type}.")
+        else:
+            logger.error(f"Invalid pavement type: {pavement_type}. Must be 'Flexible', 'Rigid', or 'Composite'.")
+            raise ValueError("Invalid pavement type. Choose from 'Flexible', 'Rigid', or 'Composite'.")

src/performance.py

@@ -0,0 +1,103 @@
+# src/performance.py
+
+import logging
+from typing import Dict
+
+from src.models import Pavement, TrafficData, ClimateData, SubgradeProperties, MaterialProperties
+from src.utils.logger import setup_logger
+
+logger = setup_logger(__name__)
+
+
+def predict_fatigue_cracking(pavement: Pavement, traffic_data: TrafficData, material_props: MaterialProperties) -> float:
+    """
+    Predict fatigue cracking based on axle loads and material properties.
+
+    :param pavement: Pavement structure.
+    :param traffic_data: Traffic data.
+    :param material_props: Material properties.
+    :return: Total fatigue damage.
+    """
+    total_damage = 0
+    axle_loads = traffic_data.get_total_axle_loads()
+    for year, loads in enumerate(axle_loads):
+        for load in loads:
+            damage = (load / material_props.asphalt_modulus) ** 3  # Simplified relationship
+            total_damage += damage
+            logger.debug(f"Year {year + 1}, Load {load} kN: Damage {damage}")
+    logger.info(f"Total Fatigue Damage: {total_damage}")
+    return total_damage
+
+
+def predict_rutting(pavement: Pavement, traffic_data: TrafficData, climate_data: ClimateData, subgrade_props: SubgradeProperties) -> float:
+    """
+    Predict rutting based on axle loads, climate data, and subgrade properties.
+
+    :param pavement: Pavement structure.
+    :param traffic_data: Traffic data.
+    :param climate_data: Climate data.
+    :param subgrade_props: Subgrade properties.
+    :return: Total rutting depth.
+    """
+    total_rut = 0
+    axle_loads = traffic_data.get_total_axle_loads()
+    for year, loads in enumerate(axle_loads):
+        for load in loads:
+            rut = (load / subgrade_props.modulus) * (climate_data.rainfall / 1000)  # Simplified relationship
+            total_rut += rut
+            logger.debug(f"Year {year + 1}, Load {load} kN: Rut {rut} mm")
+    logger.info(f"Total Rutting: {total_rut} mm")
+    return total_rut
+
+
+def predict_thermal_cracking(pavement: Pavement, climate_data: ClimateData, material_props: MaterialProperties) -> float:
+    """
+    Predict thermal cracking based on temperature variation and material properties.
+
+    :param pavement: Pavement structure.
+    :param climate_data: Climate data.
+    :param material_props: Material properties.
+    :return: Thermal cracking index.
+    """
+    thermal_crack = material_props.thermal_coeff * climate_data.temperature_variation
+    logger.info(f"Thermal Cracking Index: {thermal_crack}")
+    return thermal_crack
+
+
+def design_new_pavement(pavement: Pavement, traffic_data: TrafficData, climate_data: ClimateData,
+                       subgrade_props: SubgradeProperties, material_props: MaterialProperties) -> Dict[str, float]:
+    """
+    Design a new pavement by predicting various distresses.
+
+    :param pavement: Pavement structure.
+    :param traffic_data: Traffic data.
+    :param climate_data: Climate data.
+    :param subgrade_props: Subgrade properties.
+    :param material_props: Material properties.
+    :return: Dictionary with predicted distresses.
+    """
+    fatigue = predict_fatigue_cracking(pavement, traffic_data, material_props)
+    rutting = predict_rutting(pavement, traffic_data, climate_data, subgrade_props)
+    thermal = predict_thermal_cracking(pavement, climate_data, material_props)
+    logger.info("Pavement design simulation completed.")
+    return {
+        'Fatigue Cracking': fatigue,
+        'Rutting': rutting,
+        'Thermal Cracking': thermal
+    }
+
+
+def evaluate_performance(pavement: Pavement, traffic_data: TrafficData, climate_data: ClimateData,
+                        subgrade_props: SubgradeProperties, material_props: MaterialProperties) -> Dict[str, float]:
+    """
+    Evaluate pavement performance, currently mirrors design_new_pavement.
+
+    :param pavement: Pavement structure.
+    :param traffic_data: Traffic data.
+    :param climate_data: Climate data.
+    :param subgrade_props: Subgrade properties.
+    :param material_props: Material properties.
+    :return: Dictionary with predicted distresses.
+    """
+    logger.info("Evaluating pavement performance.")
+    return design_new_pavement(pavement, traffic_data, climate_data, subgrade_props, material_props)

src/reporting.py

@@ -0,0 +1,68 @@
+# src/reporting.py
+
+from typing import Dict
+import logging
+
+from src.utils.logger import setup_logger
+from src.utils.helpers import save_pdf
+
+logger = setup_logger(__name__)
+
+
+def generate_report(simulation_results: Dict[str, float], lcc: float) -> str:
+    """
+    Generate a textual report based on simulation results and LCCA.
+
+    :param simulation_results: Dictionary containing simulation results.
+    :param lcc: Lifecycle Cost Analysis result.
+    :return: Formatted report content as a string.
+    """
+    report = "Mechanistic-Empirical Pavement Design Report\n"
+    report += "="*50 + "\n\n"
+
+    report += "Pavement Performance Predictions:\n"
+    report += "-"*30 + "\n"
+    for key, value in simulation_results.items():
+        report += f"{key}: {value:.4f}\n"
+
+    report += f"\nLifecycle Cost Analysis (LCCA):\n"
+    report += "-"*30 + "\n"
+    report += f"Total Lifecycle Cost: ${lcc:,.2f}\n"
+
+    report += "\nConclusion:\n"
+    report += "The pavement design meets the required performance criteria based on the simulation results.\n"
+
+    logger.info("Report generated successfully.")
+    return report
+
+
+def export_report_to_pdf(report_content: str, file_path: str):
+    """
+    Export the report content to a PDF file.
+
+    :param report_content: The content of the report as a string.
+    :param file_path: The path where the PDF will be saved.
+    """
+    try:
+        from reportlab.lib.pagesizes import letter
+        from reportlab.pdfgen import canvas
+        from reportlab.lib.units import inch
+
+        c = canvas.Canvas(file_path, pagesize=letter)
+        width, height = letter
+        textobject = c.beginText()
+        textobject.setTextOrigin(inch, height - inch)
+        textobject.setFont("Helvetica", 12)
+
+        for line in report_content.split('\n'):
+            textobject.textLine(line)
+        c.drawText(textobject)
+        c.showPage()
+        c.save()
+        logger.info(f"Report exported to PDF at {file_path}")
+    except ImportError:
+        logger.error("ReportLab is not installed. Please install it using 'pip install reportlab'")
+        raise
+    except Exception as e:
+        logger.error(f"Failed to export report to PDF: {e}")
+        raise

src/utils/helpers.py

@@ -0,0 +1,53 @@
+# src/utils/helpers.py
+
+import pandas as pd
+import logging
+from src.utils.logger import setup_logger
+
+logger = setup_logger(__name__)
+
+
+def read_excel(file_path: str) -> pd.DataFrame:
+    """
+    Reads an Excel file and returns a pandas DataFrame.
+
+    :param file_path: Path to the Excel file.
+    :return: pandas DataFrame.
+    """
+    try:
+        df = pd.read_excel(file_path, sheet_name=None)  # Read all sheets
+        logger.info(f"Excel file '{file_path}' read successfully.")
+        return df
+    except Exception as e:
+        logger.error(f"Error reading Excel file '{file_path}': {e}")
+        raise IOError(f"Error reading Excel file: {e}")
+
+
+def save_pdf(file_path: str, content: str):
+    """
+    Saves content to a PDF file using ReportLab.
+
+    :param file_path: Path to save the PDF.
+    :param content: Content to write into the PDF.
+    """
+    try:
+        from reportlab.lib.pagesizes import letter
+        from reportlab.pdfgen import canvas
+
+        c = canvas.Canvas(file_path, pagesize=letter)
+        width, height = letter
+        textobject = c.beginText(50, height - 50)
+        textobject.setFont("Helvetica", 12)
+
+        for line in content.split('\n'):
+            textobject.textLine(line)
+        c.drawText(textobject)
+        c.showPage()
+        c.save()
+        logger.info(f"PDF saved successfully at {file_path}.")
+    except ImportError:
+        logger.error("ReportLab library is not installed.")
+        raise
+    except Exception as e:
+        logger.error(f"Failed to save PDF: {e}")
+        raise

src/utils/logger.py

@@ -0,0 +1,35 @@
+# src/utils/logger.py
+
+import logging
+import os
+
+def setup_logger(name: str, log_file: str = 'me_pavement_design.log', level: int = logging.INFO) -> logging.Logger:
+    """
+    Sets up a logger with the specified name and log file.
+
+    :param name: Name of the logger.
+    :param log_file: File where logs will be saved.
+    :param level: Logging level.
+    :return: Configured logger.
+    """
+    logger = logging.getLogger(name)
+    logger.setLevel(level)
+
+    # Avoid adding multiple handlers to the logger
+    if not logger.handlers:
+        # Create handlers
+        fh = logging.FileHandler(log_file)
+        fh.setLevel(level)
+        ch = logging.StreamHandler()
+        ch.setLevel(level)
+
+        # Create formatter and add it to handlers
+        formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+        fh.setFormatter(formatter)
+        ch.setFormatter(formatter)
+
+        # Add handlers to the logger
+        logger.addHandler(fh)
+        logger.addHandler(ch)
+
+    return logger