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)