Ejemplo n.º 1
0
    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
Ejemplo n.º 2
0
    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)