def pilotageParCotisationsEtAge(self,
                                 Acible=None,
                                 Tcible=None,
                                 Scible=None):
     """
     pilotage 4 : imposer 1) le taux de cotisations, 
     2) l'âge de départ à la retraite et 
     3) le bilan financier. 
     
     Paramètres
     Acible : l'âge de départ à la retraite
     Tcible : le taux de cotisations
     Scible : la situation financière en % de PIB
     
     Description
     Retourne un objet de type SimulateurAnalyse.
     * Si la valeur n'est pas donnée, utilise par défaut la trajectoire du COR.
     * Si la valeur donnée est un flottant, utilise la trajectoire du 
     COR pour les années passées et cette valeur pour les années futures. 
     * Si la valeur donnée est un dictionnaire, considère que c'est 
     une trajectoire et utilise cette trajectoire.         
     """
     # Génère les trajectoires en fonction des paramètres
     As = self.genereTrajectoire("A", Acible)
     Ts = self.genereTrajectoire("T", Tcible)
     Ss = self.genereTrajectoire("S", Scible)
     # Calcule le pilotage
     Ts, Ps, As = self._calcule_fixant_As_Ts_S(As, Ts, Ss)
     # Simule
     S, RNV, REV, Depenses = self._calcule_S_RNV_REV(Ts, Ps, As)
     resultat = SimulateurAnalyse(Ts, Ps, As, S, RNV, REV, Depenses, \
                                  self.scenarios, self.annees_EV, self.annees)
     return resultat
 def pilotageParAgeEtDepenses(self, Acible=None, Dcible=None, Scible=None):
     """
     pilotage 5 : imposer 1) l'âge de départ à la retraite, 
     2) le niveau de dépenses Ds et 
     3) le bilan financier. 
     
     Paramètres
     Acible : l'âge de départ à la retraite
     Dcible : le niveau de dépenses
     Scible : la situation financière en % de PIB
     
     Description
     Retourne un objet de type SimulateurAnalyse.
     Si la valeur n'est pas donnée, conserve la valeur du COR.
     Si une valeur est donnée, utilise cette valeur pour les années 
     futures. 
     """
     # Génère les trajectoires en fonction des paramètres
     As = self.genereTrajectoire("A", Acible)
     Ds = self.genereTrajectoire("Depenses", Dcible)
     Ss = self.genereTrajectoire("S", Scible)
     # Calcule le pilotage
     Ts, Ps, As = self._calcule_fixant_As_Ds_S(As, Ds, Ss)
     # Simule
     S, RNV, REV, Depenses = self._calcule_S_RNV_REV(Ts, Ps, As)
     resultat = SimulateurAnalyse(Ts, Ps, As, S, RNV, REV, Depenses, \
                                  self.scenarios, self.annees_EV, self.annees)
     return resultat
 def pilotageParNiveauDeVieEtCotisations(self,
                                         Tcible=None,
                                         RNVcible=None,
                                         Scible=None):
     """
     pilotage 3 : imposer 1) le taux de cotisations, 
     2) le niveau de vie par rapport à l'ensemble de la population et 
     3) le bilan financier
     
     Paramètres
     Tcible : le taux de cotisations
     RNVcible : le niveau de vie des retraités par rapport à 
     l’ensemble de la population
     Scible : la situation financière en % de PIB
     
     Description
     Retourne un objet de type SimulateurAnalyse.
     * Si la valeur n'est pas donnée, utilise par défaut la trajectoire du COR.
     * Si la valeur donnée est un flottant, utilise la trajectoire du 
     COR pour les années passées et cette valeur pour les années futures. 
     * Si la valeur donnée est un dictionnaire, considère que c'est 
     une trajectoire et utilise cette trajectoire.         
     """
     # Génère les trajectoires en fonction des paramètres
     Ts = self.genereTrajectoire("T", Tcible)
     RNVs = self.genereTrajectoire("RNV", RNVcible)
     Ss = self.genereTrajectoire("S", Scible)
     # Calcule le pilotage
     Ts, Ps, As = self._calcule_fixant_Ts_RNV_S(Ts, RNVs, Ss)
     # Simule
     S, RNV, REV, Depenses = self._calcule_S_RNV_REV(Ts, Ps, As)
     resultat = SimulateurAnalyse(Ts, Ps, As, S, RNV, REV, Depenses, \
                                  self.scenarios, self.annees_EV, self.annees)
     return resultat
    def pilotageParAgeCotisationsDepenses(self,
                                          Acible=None,
                                          Tcible=None,
                                          Dcible=None):
        """
        pilotage 8 : imposer 1) l'âge de départ à la retraite
        2) le taux de cotisations
        3) le niveau de dépenses
            
        Paramètres
        Acible : l'âge de départ à la retraite
        Tcible : le taux de cotisations
        Dcible : le niveau de dépenses
            
        Description
        Retourne un objet de type SimulateurAnalyse.
        * Si la valeur n'est pas donnée, utilise par défaut la trajectoire du COR.
        * Si la valeur donnée est un flottant, utilise la trajectoire du 
        COR pour les années passées et cette valeur pour les années futures. 
        * Si la valeur donnée est un dictionnaire, considère que c'est 
        une trajectoire et utilise cette trajectoire. 
        """
        # Génère les trajectoires en fonction des paramètres
        As = self.genereTrajectoire("A", Acible)
        Ts = self.genereTrajectoire("T", Tcible)
        Ds = self.genereTrajectoire("Depenses", Dcible)

        # Calcule le pilotage
        Ts, Ps, As = self._calcule_fixant_As_Ts_Ds(As, Ts, Ds)
        # Simule
        S, RNV, REV, Depenses = self._calcule_S_RNV_REV(Ts, Ps, As)
        resultat = SimulateurAnalyse(Ts, Ps, As, S, RNV, REV, Depenses, \
                                     self.scenarios, self.annees_EV, self.annees)
        return resultat
    def pilotageParSoldePensionDepenses(self,
                                        Scible=None,
                                        Pcible=None,
                                        Dcible=None):
        """
        pilotage 6 : imposer 1) le bilan financer
        2) le niveau des pensions par rapport aux salaires
        3) le niveau de dépenses
            
        Paramètres
        Scible : la situation financière en % de PIB
        Pcible : le niveau de pension des retraites par rapport aux actifs
        Dcible : le niveau de dépenses
            
        Description
        Retourne un objet de type SimulateurAnalyse.
        * Si la valeur n'est pas donnée, utilise par défaut la trajectoire du COR.
        * Si la valeur donnée est un flottant, utilise la trajectoire du 
        COR pour les années passées et cette valeur pour les années futures. 
        * Si la valeur donnée est un dictionnaire, considère que c'est 
        une trajectoire et utilise cette trajectoire. 
        """
        # Génère les trajectoires en fonction des paramètres
        Ss = self.genereTrajectoire("S", Scible)
        Ps = self.genereTrajectoire("P", Pcible)
        Ds = self.genereTrajectoire("Depenses", Dcible)

        # Calcule le pilotage
        Ts, Ps, As = self._calcule_fixant_Ss_Ps_Ds(Ss, Ps, Ds)
        # Simule
        S, RNV, REV, Depenses = self._calcule_S_RNV_REV(Ts, Ps, As)
        resultat = SimulateurAnalyse(Ts, Ps, As, S, RNV, REV, Depenses, \
                                     self.scenarios, self.annees_EV, self.annees)
        return resultat
    def pilotageParPensionAgeCotisations(self,
                                         Pcible=None,
                                         Acible=None,
                                         Tcible=None):
        """
        pilotage 1 : imposer 1) le niveau des pensions par rapport aux salaires
        2) l'âge de départ à la retraite
        3) le taux de cotisations
            
        Paramètres
        Pcible : le niveau de pension des retraites par rapport aux actifs
        Acible : l'âge de départ à la retraite
        Tcible : le taux de cotisations

        Description
        Retourne un objet de type SimulateurAnalyse.
        * Si la valeur n'est pas donnée, utilise par défaut la trajectoire du COR.
        * Si la valeur donnée est un flottant, utilise la trajectoire du 
        COR pour les années passées et cette valeur pour les années futures. 
        * Si la valeur donnée est un dictionnaire, considère que c'est 
        une trajectoire et utilise cette trajectoire. 
        """
        # Génère les trajectoires en fonction des paramètres
        Ps = self.genereTrajectoire("P", Pcible)
        As = self.genereTrajectoire("A", Acible)
        Ts = self.genereTrajectoire("T", Tcible)

        # Simule
        S, RNV, REV, Depenses = self._calcule_S_RNV_REV(Ts, Ps, As)
        resultat = SimulateurAnalyse(Ts, Ps, As, S, RNV, REV, Depenses, \
                                     self.scenarios, self.annees_EV, self.annees)
        return resultat
 def pilotageCOR(self):
     """
     pilotage 0 : statu quo du COR
     Retourne un objet de type SimulateurAnalyse.
     """
     S, RNV, REV, Depenses = self._calcule_S_RNV_REV(self.T, self.P, self.A)
     resultat = SimulateurAnalyse(self.T, self.P, self.A, S, RNV, REV, Depenses, \
                                  self.scenarios, self.annees_EV, self.annees)
     return resultat