ARML Forum

Code : Tout sélectionner

import math
from geopy.distance import geodesic
import matplotlib.pyplot as plt
from datetime import datetime
import logging
from iri2016 import IRI

# Configuration du logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')

# Constantes
RAYON_TERRE = 6371  # Rayon moyen de la Terre en kilomètres
HAUTEUR_BASE_IONOSPHERE = 300  # Hauteur de base de l'ionosphère en kilomètres

def calculer_distance(coords_emetteur, coords_recepteur):
    """
    Calcule la distance entre deux coordonnées géographiques.

    Paramètres :
    coords_emetteur (tuple) : Latitude et longitude de l'émetteur.
    coords_recepteur (tuple) : Latitude et longitude du récepteur.

    Retourne :
    float : Distance en kilomètres.
    """
    try:
        return geodesic(coords_emetteur, coords_recepteur).km
    except ValueError as e:
        logging.error(f"Erreur lors du calcul de la distance : {e}")
        return None

def calculer_angle_elevation(distance, hauteur_ionosphere):
    """
    Calcule l'angle d'élévation pour une onde radio.

    Paramètres :
    distance (float) : Distance entre l'émetteur et le récepteur.
    hauteur_ionosphere (float) : Hauteur de l'ionosphère.

    Retourne :
    float : Angle d'élévation en degrés.
    """
    try:
        angle_incidence_rad = math.asin(distance / (2 * (RAYON_TERRE + hauteur_ionosphere)))
        return 90 - math.degrees(angle_incidence_rad)
    except ValueError as e:
        logging.error(f"Erreur lors du calcul de l'angle d'élévation : {e}")
        return None

def calculer_distance_saut(hauteur_ionosphere, angle_elevation_deg):
    """
    Calcule la distance de saut d'une onde radio.

    Paramètres :
    hauteur_ionosphere (float) : Hauteur de l'ionosphère.
    angle_elevation_deg (float) : Angle d'élévation en degrés.

    Retourne :
    float : Distance de saut en kilomètres.
    """
    try:
        angle_incidence_rad = math.radians(90 - angle_elevation_deg)
        return 2 * (RAYON_TERRE + hauteur_ionosphere) * math.sin(angle_incidence_rad)
    except ValueError as e:
        logging.error(f"Erreur lors du calcul de la distance de saut : {e}")
        return None

def calculer_nombre_rebonds(distance_totale, distance_saut):
    """
    Calcule le nombre de rebonds nécessaires pour couvrir une distance totale.

    Paramètres :
    distance_totale (float) : Distance totale entre l'émetteur et le récepteur.
    distance_saut (float) : Distance de saut de l'onde radio.

    Retourne :
    int : Nombre de rebonds.
    """
    try:
        return math.ceil(distance_totale / distance_saut)
    except ZeroDivisionError as e:
        logging.error(f"Erreur lors du calcul du nombre de rebonds : {e}")
        return None

def frequence_critique(densite_electronique):
    """
    Calcule la fréquence critique basée sur la densité électronique.

    Paramètres :
    densite_electronique (float) : Densité électronique.

    Retourne :
    float : Fréquence critique en MHz.
    """
    try:
        return 9 * math.sqrt(densite_electronique) * 1e-6
    except ValueError as e:
        logging.error(f"Erreur lors du calcul de la fréquence critique : {e}")
        return None

def frequence_muf(f_critique, angle_elevation_deg):
    """
    Calcule la Fréquence Maximale Utilisable (MUF).

    Paramètres :
    f_critique (float) : Fréquence critique.
    angle_elevation_deg (float) : Angle d'élévation en degrés.

    Retourne :
    float : MUF en MHz.
    """
    try:
        return f_critique / math.cos(math.radians(angle_elevation_deg))
    except ZeroDivisionError as e:
        logging.error(f"Erreur lors du calcul de la MUF : {e}")
        return None

def plot_zone_reception(coords_emetteur, distance_saut):
    """
    Trace la zone de réception du signal radio.

    Paramètres :
    coords_emetteur (tuple) : Latitude et longitude de l'émetteur.
    distance_saut (float) : Distance de saut de l'onde radio.
    """
    try:
        fig, ax = plt.subplots()
        ax.scatter(coords_emetteur[1], coords_emetteur[0], color='red', label='Émetteur')
        circle = plt.Circle(coords_emetteur[::-1], distance_saut, color='blue', fill=False, linestyle='--', label='Zone de Réception')
        ax.add_patch(circle)
        ax.set_xlim(coords_emetteur[1] - 1.5 * distance_saut, coords_emetteur[1] + 1.5 * distance_saut)
        ax.set_ylim(coords_emetteur[0] - 1.5 * distance_saut, coords_emetteur[0] + 1.5 * distance_saut)
        ax.set_xlabel('Longitude')
        ax.set_ylabel('Latitude')
        ax.set_title('Zone de Réception du Signal Radio')
        ax.legend()
        plt.grid(True)
        plt.show()
    except Exception as e:
        logging.error(f"Erreur lors du tracé de la zone de réception : {e}")

def ajuster_densite_electronique(heure, saison, indice_f107):
    """
    Ajuste la densité électronique en fonction de l'heure, de la saison et de l'activité solaire.

    Paramètres :
    heure (int) : Heure de la journée.
    saison (str) : Saison ("été" ou "hiver").
    indice_f107 (float) : Indice d'activité solaire.

    Retourne :
    float : Facteur de densité électronique ajusté.
    """
    try:
        facteur_jour = 1.2 if 6 <= heure <= 18 else 1.0
        facteur_saison = 1.1 if saison == "été" else 1.0
        facteur_solaire = 1 + 0.05 * (indice_f107 - 70) / 100
        return facteur_jour * facteur_saison * facteur_solaire
    except Exception as e:
        logging.error(f"Erreur lors de l'ajustement de la densité électronique : {e}")
        return None

def obtenir_donnees_iri_local(latitude, longitude, heure, date):
    """
    Obtient les données IRI en utilisant la bibliothèque locale IRI-2016.

    Paramètres :
    latitude (float) : Latitude de l'émetteur.
    longitude (float) : Longitude de l'émetteur.
    heure (int) : Heure de la journée.
    date (str) : Date au format AAAA-MM-JJ.

    Retourne :
    dict : Données IRI incluant la hauteur de l'ionosphère.
    """
    try:
        # Initialisation du modèle IRI
        iri = IRI()

        # Configuration des paramètres
        iri.set_date_time(date, heure)
        iri.set_geographic(latitude, longitude)

        # Exécution du modèle
        result = iri.run()

        # Extraction de la hauteur de l'ionosphère
        hauteur_ionosphere = result['hmF2']  # Exemple d'extraction, à adapter
        return {'hauteur_ionosphere': hauteur_ionosphere}

    except Exception as e:
        logging.error(f"Erreur lors de la récupération des données IRI locales : {e}")
        return None

def validate_coordinates(latitude, longitude):
    """
    Valide les valeurs de latitude et de longitude.

    Paramètres :
    latitude (float) : Valeur de la latitude.
    longitude (float) : Valeur de la longitude.

    Retourne :
    bool : True si valide, False sinon.
    """
    if not (-90 <= latitude <= 90):
        logging.error("Latitude invalide. Doit être comprise entre -90 et 90.")
        return False
    if not (-180 <= longitude <= 180):
        logging.error("Longitude invalide. Doit être comprise entre -180 et 180.")
        return False
    return True

def validate_heure(heure):
    """
    Valide l'heure de la journée.

    Paramètres :
    heure (int) : Heure de la journée.

    Retourne :
    bool : True si valide, False sinon.
    """
    if not (0 <= heure < 24):
        logging.error("Heure invalide. Doit être comprise entre 0 et 23.")
        return False
    return True

def main():
    try:
        lat_emetteur = float(input("Entrez la latitude de l'émetteur : "))
        lon_emetteur = float(input("Entrez la longitude de l'émetteur : "))
        lat_recepteur = float(input("Entrez la latitude du récepteur : "))
        lon_recepteur = float(input("Entrez la longitude du récepteur : "))

        if not (validate_coordinates(lat_emetteur, lon_emetteur) and validate_coordinates(lat_recepteur, lon_recepteur)):
            return

        print("Sélectionnez le type d'antenne : ")
        print("1. Filaire (Dipôle)")
        print("2. Yagi")
        print("3. Log-Périodique")
        print("4. Verticale")
        print("5. Boucle")
        type_antenne = int(input("Entrez le numéro correspondant au type d'antenne : "))

        if type_antenne not in [1, 2, 3, 4, 5]:
            logging.error("Type d'antenne invalide. Veuillez sélectionner un nombre entre 1 et 5.")
            return

        coords_emetteur = (lat_emetteur, lon_emetteur)
        coords_recepteur = (lat_recepteur, lon_recepteur)

        heure = datetime.now().hour
        if not validate_heure(heure):
            return

        saison = "été" if 6 <= datetime.now().month <= 8 else "hiver"
        indice_f107 = 150  # Peut être configurable

        # Utilisation de la date actuelle pour les données en temps réel
        date_actuelle = datetime.now().strftime('%Y-%m-%d')

        # Tentative d'obtenir les données IRI
        donnees_iri = obtenir_donnees_iri_local(lat_emetteur, lon_emetteur, heure, date_actuelle)
        hauteur_ionosphere = donnees_iri['hauteur_ionosphere'] if donnees_iri else HAUTEUR_BASE_IONOSPHERE

        densite_electronique = 1e12 * ajuster_densite_electronique(heure, saison, indice_f107)

        distance_totale = calculer_distance(coords_emetteur, coords_recepteur)
        angle_elevation = calculer_angle_elevation(distance_totale, hauteur_ionosphere)

        if type_antenne in [2, 3]:
            angle_elevation = min(angle_elevation, 15)

        distance_saut = calculer_distance_saut(hauteur_ionosphere, angle_elevation)
        nombre_rebonds = calculer_nombre_rebonds(distance_totale, distance_saut)
        f_critique = frequence_critique(densite_electronique)
        muf = frequence_muf(f_critique, angle_elevation)

        print(f"Distance entre l'émetteur et le récepteur : {distance_totale:.2f} km")
        print(f"Angle d'élévation optimal : {angle_elevation:.2f} degrés")
        print(f"Nombre de rebonds nécessaires : {nombre_rebonds}")
        print(f"Fréquence critique : {f_critique:.2f} MHz")
        print(f"Fréquence maximale utilisable (MUF) : {muf:.2f} MHz")

        plot_zone_reception(coords_emetteur, distance_saut)

    except ValueError as e:
        logging.error(f"Entrée invalide : {e}")
    except Exception as e:
        logging.error(f"Une erreur inattendue s'est produite : {e}")

if __name__ == "__main__":
    main()