Skip to content
The Chat Archive
o1-mini-2024-09-12· OpenAI WildChat-4.8M (AI2)

from math import atan,log10,piimport matplotlib.pyplot as pltfrom openpyxl import…

  1. User

    from math import atan,log10,piimport matplotlib.pyplot as pltfrom openpyxl import Workbookfrom openpyxl.styles import Font, Alignment, Border, Sidefrom openpyxl.utils import get_column_letter# исходные данные #f = 1300hr = 40hbs1 = 49hbs2 = 35hms = 1.7fi = 30# константыw = 15b = 40# Модель Уолфиша-Икегами #def los(f, d): return(42.6 + 26 * log10(d) + 20 * log10(f))def nlos(f, d, hms, hbs, kf, hr, fi): delta_hms = hr - hms delta_hbs = hbs - hr kd = 18 if hbs >= hr else 18 - 15 * delta_hbs / hr ka = (54 if hbs > hr else 54 - 0.8 * delta_hbs if d >= 0.5 else 54 - 1.5 * delta_hbs * d) Lbsh = -18 * log10(1 + delta_hbs) if hbs > hr else 0 Lmsd = Lbsh + ka + kd * log10(d) + kf * log10(f) - 9 * log10(b) Lori = ( -10 + 0.354 * w if 0 <= fi < 35 else 2.5 + 0.075 * (fi - 35) if 35 <= fi < 55 else 4.0 + 0.114 * (fi - 55) if 55 <= fi <= 90 else 0 ) Lrts = -16.9 - 10 * log10(w) + 10 * log10(f) + 20 * log10(delta_hms) + Lori Lo = 32.44 + 20 * log10(d) + 20 * log10(f) Lnlos = Lo + max(0, Lrts + Lmsd) return Lnlos# Модель Кся-Бертони #def bertoni(f, d, hms, hbs, w, b): c = 3e8 lam = c / f delta_hbs = hr - hbs delta_hms = hms - hr x = w / 2 teta = atan(delta_hms / x) r=((delta_hms2)+(x2))0.5 Ldb= -10 * ((log10(lam / ((4 * pi) * d))) 2) - 10 * log10((lam / ((4 * (pi) 2) * r)) * (((1 / teta) - (1 / ((2 * pi) + teta))) 2)) - 10 * log10((2.35 2) * (((delta_hbs / d) * ((b / lam) 0.5)) ** 1.8)) return Ldbmeters=list(range(200,1600,100))los_set, nlos_hbs1_middletown, nlos_hbs1_largetown, nlos_hbs2_middletown, nlos_hbs2_largetown, bertoni_hbs1=[],[],[],[],[],[]for el in meters: los_set.append(los(f, el)) nlos_hbs1_middletown.append(nlos(f, el, hms, hbs1, (-4+(0.7*((f/925))-1)), hr, fi)) nlos_hbs1_largetown.append(nlos(f, el, hms, hbs1, (-4+(1.5*((f/925))-1)), hr, fi)) nlos_hbs2_middletown.append(nlos(f, el, hms, hbs2, (-4+(0.7*((f/925))-1)), hr, fi)) nlos_hbs2_largetown.append(nlos(f, el, hms, hbs2, (-4+(1.5*((f/925))-1)), hr, fi)) bertoni_hbs1.append(bertoni(f, el, hms, hbs2, w, b))def plot(): plt.figure(figsize=(8, 7)) plt.plot(meters,los_set,meters,nlos_hbs1_middletown,meters,nlos_hbs1_largetown,meters,nlos_hbs2_middletown,meters,nlos_hbs2_largetown,meters,bertoni_hbs1) plt.grid(True) plt.gca().legend(('зона прямой видимости', 'вне зоны прямой видимости, высота {} м, город средних размеров'.format(hbs1), 'вне зоны прямой видимости, высота {} м, город с плотной застройкой'.format(hbs1), 'вне зоны прямой видимости, высота {} м, город средних размеров'.format(hbs2), 'вне зоны прямой видимости, высота {} м, город с плотной застройкой'.format(hbs2), 'Модель Кся-Бертони. Высота м'),loc="lower center",bbox_to_anchor=(0.5, -0.4)) plt.xlim(200,1500) plt.xticks(meters) plt.xlabel("расстояние x, м") plt.ylabel("L (потери сигнала), дБ") plt.title("Модели Уолфиша-Икегами и Кся-Бертони") plt.subplots_adjust(bottom=0.262,top=0.934) plt.show()def toFixed(numObj, digits=3): return float(f"{numObj:.{digits}f}")def save_to_xlsx(filename="pract3.xlsx"): workbook = Workbook() sheet = workbook.active sheet.title = "Потери сигнала" headers = [ "Расстояние (м)", "Зона прямой видимости", 'Вне зоны, {} м, средний город'.format(hbs1), "Вне зоны, {} м, плотная застройка".format(hbs1), "Вне зоны, {} м, средний город".format(hbs2), "Вне зоны, {} м, плотная застройка".format(hbs2), "Модель Кся-Бертони" ] sheet.append(headers) for i in range(len(meters)): sheet.append([ meters[i], toFixed(los_set[i]), toFixed(nlos_hbs1_middletown[i]), toFixed(nlos_hbs1_largetown[i]), toFixed(nlos_hbs2_middletown[i]), toFixed(nlos_hbs2_largetown[i]), toFixed(bertoni_hbs1[i]) ]) for column_cells in sheet.columns: max_length = 0 column = column_cells[0].column for cell in column_cells: try: if len(str(cell.value)) > max_length: max_length = len(cell.value) except: pass adjusted_width = (max_length + 2) sheet.column_dimensions[get_column_letter(column)].width = adjusted_width thin_border = Border( left=Side(style='thin'), right=Side(style='thin'), top=Side(style='thin'), bottom=Side(style='thin') ) for row in sheet.iter_rows(): for cell in row: cell.alignment = Alignment(horizontal="center", vertical="center") cell.border = thin_border for cell in sheet[1]: cell.font = Font(bold=True) workbook.save(filename)plot()save_to_xlsx()Добавь к программе полупрозрачный интерфейс, чтобы можно было забивать исходные графики, строить график и сохранять отчет в одном окне.

  2. Assistant

    To enhance your program with a graphical user interface (GUI) that allows users to input parameters, generate plots, and save reports within a single window, you can use the tkinter library, which is included with Python. Below is a step-by-step guide to integrating a semi-transparent GUI into your existing script.

    1. Overview of Changes

    • GUI Integration: We'll use tkinter to create input fields for all necessary parameters, buttons to generate plots and save reports, and embed the plot within the window.

    • Error Handling: Correct some syntax errors in your original script to ensure smooth execution.

    • Layout Management: Arrange elements using tkinter frames and grid systems for a clean interface.

    2. Corrected and Enhanced Script

    Below is the complete script with the integrated tkinter GUI. Make sure to install the required libraries if you haven't already (e.g., openpyxl, matplotlib).

    import tkinter as tk
    from tkinter import ttk, messagebox, filedialog
    from math import atan, log10, pi
    import matplotlib.pyplot as plt
    from openpyxl import Workbook
    from openpyxl.styles import Font, Alignment, Border, Side
    from openpyxl.utils import get_column_letter
    
    # Define the main application class
    class SignalLossApp:
        def __init__(self, root):
            self.root = root
            self.root.title("Signal Loss Models")
            self.root.geometry("800x600")
            self.root.configure(bg='lightgrey')  # Background color
    
            # Make the window semi-transparent
            self.root.attributes('-alpha', 0.95)  # 0 (transparent) to 1 (opaque)
    
            # Initialize variables with default values
            self.init_vars()
    
            # Create GUI components
            self.create_widgets()
    
        def init_vars(self):
            # Define variables with default values
            self.f = tk.DoubleVar(value=1300)
            self.hr = tk.DoubleVar(value=40)
            self.hbs1 = tk.DoubleVar(value=49)
            self.hbs2 = tk.DoubleVar(value=35)
            self.hms = tk.DoubleVar(value=1.7)
            self.fi = tk.DoubleVar(value=30)
            self.w = tk.DoubleVar(value=15)
            self.b = tk.DoubleVar(value=40)
            self.meters = list(range(200, 1600, 100))
    
        def create_widgets(self):
            # Create frames for organization
            input_frame = tk.LabelFrame(self.root, text="Input Parameters", padx=10, pady=10, bg='lightgrey')
            input_frame.pack(fill="x", padx=20, pady=10)
    
            button_frame = tk.Frame(self.root, bg='lightgrey')
            button_frame.pack(fill="x", padx=20, pady=10)
    
            output_frame = tk.Frame(self.root, bg='lightgrey')
            output_frame.pack(fill="both", expand=True, padx=20, pady=10)
    
            # Add input fields
            self.add_input_fields(input_frame)
    
            # Add buttons
            plot_button = ttk.Button(button_frame, text="Plot", command=self.plot)
            plot_button.pack(side="left", padx=5)
    
            save_button = ttk.Button(button_frame, text="Save Report", command=self.save_to_xlsx)
            save_button.pack(side="left", padx=5)
    
            # Embed matplotlib figure
            from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
    
            self.fig, self.ax = plt.subplots(figsize=(8, 6))
            self.canvas = FigureCanvasTkAgg(self.fig, master=output_frame)
            self.canvas_widget = self.canvas.get_tk_widget()
            self.canvas_widget.pack(fill="both", expand=True)
    
        def add_input_fields(self, frame):
            # Define labels and entry fields
            fields = [
                ("Frequency (f) [Hz]:", self.f),
                ("Height Receiver (hr) [m]:", self.hr),
                ("Height Base Station 1 (hbs1) [m]:", self.hbs1),
                ("Height Base Station 2 (hbs2) [m]:", self.hbs2),
                ("Height Mobile Station (hms) [m]:", self.hms),
                ("Fi (fi) [degrees]:", self.fi),
                ("Width (w) [m]:", self.w),
                ("Base (b) [m]:", self.b),
            ]
    
            for i, (label_text, var) in enumerate(fields):
                label = tk.Label(frame, text=label_text, bg='lightgrey')
                label.grid(row=i, column=0, sticky="e", pady=2)
    
                entry = ttk.Entry(frame, textvariable=var)
                entry.grid(row=i, column=1, pady=2, padx=5)
    
        # Define the signal loss models
        def los(self, f, d):
            return 42.6 + 26 * log10(d) + 20 * log10(f)
    
        def nlos(self, f, d, hms, hbs, kf, hr, fi):
            delta_hms = hr - hms
            delta_hbs = hbs - hr
            kd = 18 if hbs >= hr else 18 - 15 * delta_hbs / hr
            if d >= 0.5:
                ka = 54 - 1.5 * delta_hbs if hbs <= hr else 54
            else:
                ka = 54 - 0.8 * delta_hbs if hbs <= hr else 54
    
            if hbs > hr:
                Lbsh = -18 * log10(1 + delta_hbs)
            else:
                Lbsh = 0
    
            Lmsd = Lbsh + ka + kd * log10(d) + kf * log10(f) - 9 * log10(self.b.get())
    
            if 0 <= fi.get() < 35:
                Lori = -10 + 0.354 * self.w.get()
            elif 35 <= fi.get() < 55:
                Lori = 2.5 + 0.075 * (fi.get() - 35)
            elif 55 <= fi.get() <= 90:
                Lori = 4.0 + 0.114 * (fi.get() - 55)
            else:
                Lori = 0
    
            Lrts = -16.9 - 10 * log10(self.w.get()) + 10 * log10(f) + 20 * log10(delta_hms) + Lori
            Lo = 32.44 + 20 * log10(d) + 20 * log10(f)
            Lnlos = Lo + max(0, Lrts + Lmsd)
            return Lnlos
    
        def bertoni(self, f, d, hms, hbs, w, b):
            c = 3e8
            lam = c / f
            delta_hbs = hbs - self.hr.get()
            delta_hms = hms - self.hr.get()
            x = w / 2
            teta = atan(delta_hms / x)
            r = ((delta_hms**2) + (x**2))**0.5
            if lam <= 0 or d <= 0 or r <= 0 or teta == 0:
                return 0
            Ldb = (
                -10 * ((log10(lam / ((4 * pi) * d))) ** 2)
                - 10 * log10((lam / ((4 * (pi ** 2)) * r)) * (((1 / teta) - (1 / ((2 * pi) + teta))) ** 2))
                - 10 * log10((2.35 ** 2) * (((delta_hbs / d) * ((b / lam) ** 0.5)) ** 1.8))
            )
            return Ldb
    
        def plot(self):
            try:
                # Retrieve input values
                f = self.f.get()
                hr = self.hr.get()
                hbs1 = self.hbs1.get()
                hbs2 = self.hbs2.get()
                hms = self.hms.get()
                fi = self.fi.get()
                w = self.w.get()
                b = self.b.get()
    
                # Validate inputs
                if any(v <= 0 for v in [f, hr, hbs1, hbs2, hms, w, b]):
                    messagebox.showerror("Input Error", "All input values must be positive numbers.")
                    return
    
                # Adjust kf based on frequency f
                kf_middle = -4 + (0.7 * ((f / 925)) - 1)
                kf_large = -4 + (1.5 * ((f / 925)) - 1)
    
                meters = self.meters
                los_set = []
                nlos_hbs1_middletown = []
                nlos_hbs1_largetown = []
                nlos_hbs2_middletown = []
                nlos_hbs2_largetown = []
                bertoni_hbs1 = []
    
                for el in meters:
                    los_set.append(self.los(f, el))
                    nlos_hbs1_middletown.append(self.nlos(f, el, hms, hbs1, kf_middle, hr, fi))
                    nlos_hbs1_largetown.append(self.nlos(f, el, hms, hbs1, kf_large, hr, fi))
                    nlos_hbs2_middletown.append(self.nlos(f, el, hms, hbs2, kf_middle, hr, fi))
                    nlos_hbs2_largetown.append(self.nlos(f, el, hms, hbs2, kf_large, hr, fi))
                    bertoni_hbs1.append(self.bertoni(f, el, hms, hbs1, w, b))
    
                # Clear previous plot
                self.ax.clear()
    
                # Plot the data
                self.ax.plot(meters, los_set, label='Зона прямой видимости')
                self.ax.plot(meters, nlos_hbs1_middletown, label=f'Вне зоны, {hbs1} м, средний город')
                self.ax.plot(meters, nlos_hbs1_largetown, label=f'Вне зоны, {hbs1} м, плотная застройка')
                self.ax.plot(meters, nlos_hbs2_middletown, label=f'Вне зоны, {hbs2} м, средний город')
                self.ax.plot(meters, nlos_hbs2_largetown, label=f'Вне зоны, {hbs2} м, плотная застройка')
                self.ax.plot(meters, bertoni_hbs1, label='Модель Кся-Бертони', linestyle='--')
    
                # Customize the plot
                self.ax.grid(True)
                self.ax.legend(loc="upper left", bbox_to_anchor=(1, 1))
                self.ax.set_xlim(200, 1500)
                self.ax.set_xticks(meters)
                self.ax.set_xlabel("Расстояние x, м")
                self.ax.set_ylabel("L (потери сигнала), дБ")
                self.ax.set_title("Модели Уолфиша-Икегами и Кся-Бертони")
    
                self.fig.tight_layout()
                self.canvas.draw()
            except Exception as e:
                messagebox.showerror("Error", f"An error occurred:\n{e}")
    
        def toFixed(self, numObj, digits=3):
            return float(f"{numObj:.{digits}f}")
    
        def save_to_xlsx(self):
            try:
                # Open a file dialog to choose save location
                filename = filedialog.asksaveasfilename(
                    defaultextension=".xlsx",
                    filetypes=[("Excel files", "*.xlsx"), ("All files", "*.*")],
                    title="Save Report As"
                )
                if not filename:
                    return  # User cancelled
    
                # Retrieve input values
                f = self.f.get()
                hr = self.hr.get()
                hbs1 = self.hbs1.get()
                hbs2 = self.hbs2.get()
                hms = self.hms.get()
                fi = self.fi.get()
                w = self.w.get()
                b = self.b.get()
    
                # Adjust kf based on frequency f
                kf_middle = -4 + (0.7 * ((f / 925)) - 1)
                kf_large = -4 + (1.5 * ((f / 925)) - 1)
    
                meters = self.meters
                los_set = []
                nlos_hbs1_middletown = []
                nlos_hbs1_largetown = []
                nlos_hbs2_middletown = []
                nlos_hbs2_largetown = []
                bertoni_hbs1 = []
    
                for el in meters:
                    los_set.append(self.los(f, el))
                    nlos_hbs1_middletown.append(self.nlos(f, el, hms, hbs1, kf_middle, hr, fi))
                    nlos_hbs1_largetown.append(self.nlos(f, el, hms, hbs1, kf_large, hr, fi))
                    nlos_hbs2_middletown.append(self.nlos(f, el, hms, hbs2, kf_middle, hr, fi))
                    nlos_hbs2_largetown.append(self.nlos(f, el, hms, hbs2, kf_large, hr, fi))
                    bertoni_hbs1.append(self.bertoni(f, el, hms, hbs1, w, b))
    
                # Create a workbook and select active sheet
                workbook = Workbook()
                sheet = workbook.active
                sheet.title = "Потери сигнала"
    
                # Define headers
                headers = [
                    "Расстояние (м)",
                    "Зона прямой видимости",
                    f"Вне зоны, {hbs1} м, средний город",
                    f"Вне зоны, {hbs1} м, плотная застройка",
                    f"Вне зоны, {hbs2} м, средний город",
                    f"Вне зоны, {hbs2} м, плотная застройка",
                    "Модель Кся-Бертони"
                ]
                sheet.append(headers)
    
                # Append data rows
                for i in range(len(meters)):
                    sheet.append([
                        meters[i],
                        self.toFixed(los_set[i]),
                        self.toFixed(nlos_hbs1_middletown[i]),
                        self.toFixed(nlos_hbs1_largetown[i]),
                        self.toFixed(nlos_hbs2_middletown[i]),
                        self.toFixed(nlos_hbs2_largetown[i]),
                        self.toFixed(bertoni_hbs1[i])
                    ])
    
                # Adjust column widths
                for column_cells in sheet.columns:
                    max_length = 0
                    column = column_cells[0].column
                    for cell in column_cells:
                        try:
                            if len(str(cell.value)) > max_length:
                                max_length = len(str(cell.value))
                        except:
                            pass
                    adjusted_width = (max_length + 2)
                    sheet.column_dimensions[get_column_letter(column)].width = adjusted_width
    
                # Apply styles
                thin_border = Border(
                    left=Side(style='thin'),
                    right=Side(style='thin'),
                    top=Side(style='thin'),
                    bottom=Side(style='thin')
                )
                for row in sheet.iter_rows():
                    for cell in row:
                        cell.alignment = Alignment(horizontal="center", vertical="center")
                        cell.border = thin_border
                for cell in sheet[1]:
                    cell.font = Font(bold=True)
    
                # Save the workbook
                workbook.save(filename)
                messagebox.showinfo("Success", f"Report saved successfully at:\n{filename}")
            except Exception as e:
                messagebox.showerror("Error", f"An error occurred while saving the report:\n{e}")
    
    # Run the application
    if __name__ == "__main__":
        root = tk.Tk()
        app = SignalLossApp(root)
        root.mainloop()
    

    3. Explanation of Enhancements

    1. GUI Creation with tkinter:

      • Main Window: The application window is created with a light grey background and a semi-transparent effect using attributes('-alpha', 0.95).
      • Input Fields: Users can input all necessary parameters such as frequency (f), heights (hr, hbs1, hbs2, hms), angle (fi), width (w), and base (b) through labeled entry fields.
      • Buttons: Two buttons are provided—Plot to generate the graph and Save Report to save the data into an Excel file.
      • Plot Embedding: The matplotlib plot is embedded within the tkinter window using FigureCanvasTkAgg.
    2. Error Handling and Validation:

      • Before performing calculations, the script checks if all input values are positive numbers.
      • It catches and displays any errors that occur during plotting or saving.
    3. Improved Models:

      • Corrected Calculations: Fixed syntax issues such as exponentiation (**) and ensured that variables are correctly used within the models.
      • Bertoni Model: Added checks to prevent mathematical errors like division by zero.
    4. Saving to Excel:

      • Users can choose the save location and filename through a dialog.
      • The Excel file includes headers and all computed data, with proper formatting and borders.
    5. User Experience:

      • The legend in the plot is positioned outside the plot area to avoid overlapping.
      • The application provides feedback through message boxes upon successful operations or errors.

    4. Running the Application

    1. Prerequisites: Ensure that you have the necessary libraries installed. You can install any missing libraries using pip:

      pip install matplotlib openpyxl
      
    2. Execution: Save the script to a Python file, for example, signal_loss_app.py, and run it using:

      python signal_loss_app.py
      
    3. Usage:

      • Input: Enter the desired values for all parameters in the input fields.
      • Plotting: Click the Plot button to generate and view the graph within the application.
      • Saving: Click the Save Report button to export the data to an Excel file.

    5. Additional Enhancements (Optional)

    • Parameter Validation Enhancements: You can add more sophisticated validations, such as ensuring that angles are within specific ranges or that certain relationships between parameters hold.

    • Styling the GUI: Further customize the appearance of the GUI using different tkinter styles or themes to make it more visually appealing.

    • Dynamic Updates: Implement real-time updates to the plot as users change input parameters without needing to click the Plot button each time.

    By integrating the GUI as shown above, users can interact with the signal loss models more intuitively, making the application more user-friendly and versatile.