Simulation et analyse de lancement de fusées à l'aide de Rocketpy - Analytics Vidhya

Simuler les lancements de fusée avec Rocketpy: un guide complet

Cet article vous guide à travers la simulation des lancements de fusées haute puissance à l'aide de Rocketpy, une puissante bibliothèque Python. Nous couvrirons tout, de la définition des composants de fusée à l'analyse des résultats de simulation et à la visualisation des données. Que vous soyez étudiant ou ingénieur chevronné, ce tutoriel offre une expérience pratique et pratique.

Objectifs d'apprentissage:

• Master Rocketpy pour les simulations de lancement de fusées.
• Configurez les composants de fusée (moteur, corps, ailettes, parachutes).
• Effectuer et interpréter les simulations de vol.
• Visualisez les données à l'aide de Matplotlib et effectuez une analyse de Fourier.
• Dépanner les problèmes de simulation courants.

(Cet article fait partie du blogathon de la science des données.)

Table des matières:

• Introduction
• Qu'est-ce que Rocketpy?
• Télécharger les données nécessaires
• Importation de bibliothèques et de configuration d'environnement
• Comprendre les spécifications moteurs solides
• Configuration des dimensions et parties de fusées
• Ajout et configuration des parachutes
• Courir et analyser la simulation
• Exportation de la trajectoire vers KML
• Analyse et visualisation des données
• Conclusion
• Questions fréquemment posées

Qu'est-ce que Rocketpy?

Rocketpy est une bibliothèque Python pour simuler et analyser les vols de fusée haute puissance. Il modélise les composants de fusée (moteurs solides, ailettes, parachutes) et simule leur comportement pendant le lancement et le vol. Les utilisateurs définissent les paramètres de fusée, exécutent des simulations et visualisent les résultats via des parcelles et des exportations de données.

Télécharger les données requises:

Téléchargez ces fichiers pour la simulation:

 ! Pip installer Rocketpy
! Curl -o naca0012-radians.csv https://raw.githubusercontent.com/rocketpy-team/rocketpy/master/data/calisto/naca0012-dians.csv
! Curl -o Cesaroni_M1670.eng https://raw.githubusercontent.com/rocketpy-team/rocketpy/master/data/motors/cesaroni_m1670.eng
! Curl -o Poweroffdragcurve.csv https://raw.githubusercontent.com/rocketpy-team/rocketpy/master/data/calisto/powoffoffdragcurve.csv
! Curl -o Powerondragcurve.csv https://raw.githubusercontent.com/rocketpy-team/rocketpy/master/data/calisto/powerondragcurve.csv

Importer des bibliothèques et configurer l'environnement:

Importer les bibliothèques nécessaires et définir des conditions de localisation et atmosphériques:

 de Rocketpy Import Environment, Solidmotor, Rocket, Flight
Importer DateTime

# Initialiser l'environnement
Environ Environ (latitude = 32,990254, longitude = -106.974998, élévation = 1400)
Tomorrow = DateTime.Date.Today () DateTime.Timedelta (Days = 1)
env.set_date ((demain.year, demain.month, demain.Day, 12))
env.set_atmosphericric_model (type = "prévision", file = "gfs")
Env.info () 

La classe Environment définit l'emplacement géographique et les conditions atmosphériques pour des simulations précises.

Comprendre les caractéristiques moteurs solides:

Définissez les paramètres du moteur (poussée, dimensions, propriétés):

 Pro75m1670 = solidemotor (
    thrust_source = "cesaroni_m1670.eng",
    Dry_mass = 1,815,
    Dry_inertia = (0,125, 0,125, 0,002),
    buse_radius = 33/1000,
    grain_number = 5,
    grain_density = 1815,
    grain_outer_radius = 33/1000,
    grain_initial_inner_radius = 15/1000,
    grain_initial_height = 120/1000,
    grain_separse = 5/1000,
    grains_center_of_mass_position = 0,397,
    CENTER_OF_DRY_MASS_POSITION = 0,317,
    buse_position = 0,
    Burn_time = 3,9,
    gorge_radius = 11/1000,
    coordinate_system_orientation = "busez_to_combustion_chamber",
)
Pro75m1670.info () 

La classe SolidMotor définit les caractéristiques physiques et de performances du moteur.

Configuration des dimensions et des composants de la fusée:

Définissez les paramètres de fusée (dimensions, composants, intégration du moteur):

 calsto = fusée (
    rayon = 127/2000,
    masse = 14,426,
    inertie = (6,321, 6,321, 0,034),
    power_off_drag = "poweroffdragcurve.csv",
    power_on_drag = "Powerondragcurve.csv",
    CENTER_OF_MASS_WITHOUT_MOTOR = 0,
    coordonner_system_orientation = "tail_to_nose",
)

calisto.set_rail_buttons (upper_button_position = 0,0818, bower_button_position = -0,618, angular_position = 45)
calisto.add_motor (pro75m1670, position = -1,255)
calisto.add_nose (longueur = 0,55829, kind = "vonkarman", position = 1,278)
calisto.add_trapezoidal_fins (n ​​= 4, root_chord = 0,120, tip_chord = 0,060, span = 0,110, position = -1,04956, cant_ang
calisto.add_tail (top_radius = 0,0635, inférieur_radius = 0,0435, longueur = 0,060, position = -1,194656)

calisto.all_info () 

La classe Rocket définit la structure de la fusée (ailettes, cône de nez), impactant la stabilité et l'aérodynamique. Les parcelles de masse suivent.

Ajout et configuration des parachutes:

Ajouter des parachutes pour une récupération sûre:

 Main = calsto.add_parachute (
    "Principal",
    CD_S = 10.0,
    Trigger = 800,
    sampling_rate = 105,
    LAG = 1,5,
    bruit = (0, 8,3, 0,5),
)

Drogue = calsto.add_parachute (
    "Ancre flottante",
    cd_s = 1.0,
    Trigger = "apogee",
    sampling_rate = 105,
    LAG = 1,5,
    bruit = (0, 8,3, 0,5),
) 

Les parachutes sont cruciaux pour la descente contrôlée. Les paramètres comme le coefficient de glisser et l'altitude de déploiement sont essentiels.

Exécution et analyse de la simulation:

Exécutez la simulation de vol:

 test_flight = vol (
    fusée = calsto, environnement = env, rail_length = 5,2, inclination = 85, tête = 0
)
test_flight.all_info () 

La classe Flight simule la trajectoire.

Exportation de la trajectoire vers KML:

Exporter la trajectoire pour la visualisation dans Google Earth:

 test_flight.export_kml (file_name = "trajectory.kml", extrude = true, altitude_mode = "relative_to_ground")

Analyse et visualisation des données:

Effectuer une analyse et visualiser les résultats (apogée par masse, vitesse de décollage, analyse de Fourier):

 de Rocketpy.Utilities import apogee_by_mass, lelefoff_speed_by_mass
Importer Numpy comme NP
Importer Matplotlib.pyplot en tant que plt
# ... (code pour le traçage et analyse de Fourier) ... 

La visualisation aide à comprendre les performances et la dynamique des fusées.

Conclusion:

Rocketpy fournit un cadre puissant pour la simulation et l'analyse du vol Rocket. Ce tutoriel fournit une procédure pas à pas complète, permettant aux utilisateurs d'effectuer des simulations, d'analyser les résultats et de visualiser efficacement les données.

Les principaux plats à retenir:

• Processus complet de simulation de fusée.
• Exemples de code python pratique.
• Importance de la configuration des composants pour des simulations précises.
• Visualisation des données pour une meilleure compréhension de la dynamique des vols.
• Dépannage des conseils et des ressources.

Questions fréquemment posées:

• Q1: Qu'est-ce que Rocketpy? R: Une bibliothèque Python pour simuler et analyser les vols de fusées haute puissance.
• Q2: Comment installer Rocketpy? R: Utilisez pip install rocketpy .
• Q3: Que faire si des erreurs se produisent? R: Vérifiez les paramètres, les fichiers de données et les chemins. Reportez-vous au dépannage des ressources.
• Q4: Comment visualiser les résultats? R: Exportez-vous vers KML pour Google Earth et utilisez Matplotlib pour les parcelles personnalisées.

(Remarque: les images ne sont pas détenues par cette réponse et sont utilisées comme prévu dans l'entrée.)

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!