def SlancerSimulation(self, _reseau, _show_html):
"""
Permet de lancer le processus de simulation de la vie du réseau. Cf diagramme d'activité pour connaitre son
fonctionnement algorithmique.
:param _reseau: Reseau, le réseau à traiter
:param _show_html: bool, Permet de définir si l'état du réseau doit être affiché pendant la simulation
:return: Reseau, le réseau une fois traité
"""
_log.Linfo("Début ## Simulateur.SlancerSimulation")
from Modele.Reseau import Reseau
if type(_reseau) is not Reseau:
_log.Lerror("Valeur Argument errone _reseau")
raise Exception("Valeur Argument errone _reseau")
if type(_show_html) is not bool:
_log.Lerror("Valeur Argument errone _show_html")
raise Exception("Valeur Argument errone _show_html")
from Controleur.Statistiques import Statistiques
_statistiques = Statistiques()
_file_manager = FileManager()
# Chrono pour savoir combien de temps la simulation a durée
_start = time.time()
_dernier_roulement = 0
_reseau_simulation = _reseau
self.S_duree_simulation = 0
self.S_duree_de_vie = 0
self.S_intervalle_roulement = 0
# Initialisation des compteurs
_etat = 0
_total = 1
_cycle = 0
while not self.__SmaximumAtteint():
_log.Linfo("Info ## Cycle " + str(_cycle))
self.S_connecteur.emit(Signaux.INITIALISATION_SIMULATION, dict())
_reseau_simulation = copy.deepcopy(_reseau)
# Détermination de l'intervalle de temps
self.__SdeterminationIntervalleTemps()
_text_progression = "Simulation en cours.. " \
"\nCycle " + str(_cycle) + \
"\nintervalle utilisé : " + str(self.S_intervalle_roulement) + " unité(s) de temps"
self.S_connecteur.emit(
Signaux.PROGRESSION_SIMULATION,
dict({
"avancee": 0,
"text": _text_progression
}))
# Configuration topologique du réseau (routage et ensemble dominant)
_reseau_simulation = self.SconfigurationTopologique(
_reseau_simulation)
_fin_de_vie_atteinte, _capteurs_deconnectes = self.SfinDeVieAtteinte(
_reseau_simulation, self.S_intervalle_roulement)
self.S_duree_de_vie = 0
# Tant que la fin de vie du réseau n'a pas été atteinte, on simule la consommation énergétique en
# enregistrant les étapes intermédiaires
while not _fin_de_vie_atteinte:
_log.Linfo("Info ## état " + str(_etat))
# Cas où le temps écoulé correspond à l'intervalle de temps de changement de rôles des capteurs :
# le rôle des capteurs est modifié et l'état est enregistré
if self.S_intervalle_roulement != 0:
if self.S_duree_de_vie == 0 \
or self.S_duree_de_vie - _dernier_roulement >= self.S_intervalle_roulement:
_dernier_roulement = self.S_duree_de_vie
_reseau_simulation = self.SconfigurationTopologique(
_reseau_simulation)
_etat += 1
_total += 1
_file_manager.FMenregistrerEtat(
_reseau_simulation, _show_html)
_statistiques.SajouterDonnees(_reseau_simulation,
_cycle,
self.S_duree_simulation)
self.S_connecteur.emit(
Signaux.NOUVEL_ETAT,
dict({
"etat": _etat,
"total": _total
}))
# On simule la consommation énergétique des capteurs puis on regarde si la fin de vie a été atteinte
_reseau_simulation = self.__SsimulationSurUnRoulement(
_reseau_simulation, _capteurs_deconnectes)
_fin_de_vie_atteinte, _capteurs_deconnectes = self.SfinDeVieAtteinte(
_reseau_simulation, self.S_intervalle_roulement)
_ratio = len(_capteurs_deconnectes) / _reseau.R_nbr_noeuds - (
1 - self.S_fin_de_vie)
self.S_connecteur.emit(
Signaux.PROGRESSION_SIMULATION,
dict({
"avancee": int(_ratio * 100),
"text": _text_progression
}))
# Fin premier While : la fin de vie du réseau a été atteinte, on sauvegarde les états et on recommence avec
# un nouvel intervalle
# Ajout de l'état de la fin de vie du réseau
_etat += 1
_total += 1
_file_manager.FMenregistrerEtat(_reseau_simulation, _show_html)
_statistiques.SajouterDonnees(_reseau_simulation, _cycle,
self.S_duree_simulation)
self.S_resultats.append(
dict({
"intervalle": self.S_intervalle_roulement,
"resultat": self.S_duree_de_vie
}))
_statistiques.SajouterResultat(self.S_intervalle_roulement,
self.S_duree_de_vie)
self.S_connecteur.emit(Signaux.NOUVEL_ETAT,
dict({
"etat": _etat,
"total": _total
}))
# On met la barre de progression à 100%
self.S_connecteur.emit(
Signaux.PROGRESSION_SIMULATION,
dict({
"avancee": 100,
"text": _text_progression
}))
self.S_duree_simulation += self.S_intervalle_recolte * 100 # Pour séparer les résultats d'un cycle à lautre
_cycle += 1
# Fin while, cad fin de la simulation, le maximum a été trouvé
# Si les étapes intermédiaires n'ont pas été enregistrées sous format html, en enregistre quand même le dernier
# état afin d'avoir le premier et le dernier état d'affiché
if not _show_html:
_etat += 1
_total += 1
_file_manager.FMenregistrerEtat(_reseau_simulation, True)
self.S_connecteur.emit(Signaux.NOUVEL_ETAT,
dict({
"etat": _etat,
"total": _total
}))
FileManager.FMsauvegarderStatistiques()
# Informations sur la durée de la simulation
_end = time.time()
_temps = (_end - _start) // 1
self.S_connecteur.emit(Signaux.FIN_SIMULATION,
dict({"duree": abs(_temps)}))
_log.Linfo("Info ## Fin simulation")
return _reseau_simulation
def FMchargerStatistiques(self):
"""
Permet de charger en local depuis un fichier XML les informations contenues dans le singleton Statistique
Les données sont stockées sous la forme suivante :
<statistique>
<nbretats>
<nbrresultats>
<etats>
<etat>
<numero_etat>
</numero_etat>
<niveau_de_batterie_moyen>
</niveau_de_batterie_moyen>
<nbr_actifs>
</nbr_actifs>
<cycle>
</cycle>
<moment_insertion>
</moment_insertion>
</etat>
<etat>
...
</etat>
...
</etats>
<resultats>
<resultat>
<intervalle></intervalle>
<dureedevie></dureedevie>
</resultat>
<resultats>
</statistique>
"""
_log.Linfo("Début ## FileManager.FMchargerStatistiques")
from Controleur.ReseauControleur import ReseauControleur
_chemin = self.FM_chemin_local + "\\resultats simulation\\statistiques.xml"
if os.path.exists(_chemin):
from Controleur.Statistiques import Statistiques
_statistiques = Statistiques()
_racine = parse(_chemin)
# Récupération des états
for _etat in _racine.iter("etat"):
_netat = int(next(_etat.iter("numero_etat")).text)
_niveau_batterie_moyen = int(
next(_etat.iter("niveau_de_batterie_moyen")).text)
_nbr_actifs = int(next(_etat.iter("nbr_actifs")).text)
_cycle = int(next(_etat.iter("cycle")).text)
_moment = int(next(_etat.iter("moment_insertion")).text)
_statistiques.SajouterDonneesBrutes(_niveau_batterie_moyen,
_nbr_actifs, _cycle,
_moment)
# Récupérations des résultats de performance de la simulation
for _resultat in _racine.iter("resultat"):
_intervalle = float(next(_resultat.iter("intervalle")).text)
_dureedevie = float(next(_resultat.iter("duree")).text)
_statistiques.SajouterResultat(_intervalle, _dureedevie)
# Test si le nombre d'états détectés et celui donné correspondent
_nbr_etats = int(next(_racine.iter("nbretats")).text)
if _statistiques.S_nombre_etats != _nbr_etats:
ReseauControleur.RCmessageInformation(
"Le nombre d'état en meta et réél ne correspondent pas. "
"Chargement des informations statistiques échoué")
_statistiques.SviderEtats(False)
# Test si le nombre de résultats détecté et celui donné correspondent
_nbr_resultats = int(next(_racine.iter("nbrresultats")).text)
if len(_statistiques.S_resultats) != _nbr_resultats:
ReseauControleur.RCmessageInformation(
"Le nombre de résultats en meta et réél ne correspondent pas. "
"Chargement des informations statistiques échoué")
_statistiques.SviderEtats(False)