Ce « paramètre » peut être utilisé pour modéliser un événement de décision discret
 cela se produit à une date donnée. Avant cette date, le « avant »
 la valeur est renvoyée, et après cette date, la valeur « after » est renvoyée.

Paramètres
----------
decision_date : chaîne ou pandas.Timestamp
    Date de déclenchement de la décision.
before_parameter : Paramètre
    La valeur à utiliser avant la date de décision.
after_parameter : Paramètre
    La valeur à utiliser après la date de décision.
earliest_date : chaîne ou Pandas.Timestamp ou None
    Date la plus proche à laquelle la variable peut être définie. La valeur par défaut est `model.timestepper.start`
latest_date : chaîne ou Pandas.Timestamp ou None
    Dernière date à laquelle la variable peut être définie. La valeur par défaut est model.timestepper.end
decision_freq : chaîne de fréquence pandas (par défaut « AS »)
    La résolution de dates réalisables. Par exemple, « AS » créerait des dates réalisables tous les
    année entre « la plus ancienne »_date` et `dernière_date`. Les fonctions « pandas » sont utilisées
    en interne pour les calculs de date delta.

« »

def __init__(soi, modèle, décision_date, avant_paramètre, après_paramètre, le plus tôt_Date = aucune, la plus récente_Date = aucune, décision_freq='As, **kwargs) :
    super (TransientDecisionParameter, self).__init__(modèle, **kwargs)
    soi._décision_date = Aucune
    décision personnelle_date = décision_date

    sinon isinstance (before_parameter, Parameter) :
        raise ValueError (« La valeur « avant » doit être une instance de paramètre. »)
    before_parameter.parents.add (lui-même)
    soi. Avant_paramètre = avant_paramètre

    sinon isinstance (after_parameter, Parameter) :
        raise ValueError (« La valeur « après » doit être une instance de paramètre. »)
    after_parameter.parents.add (lui-même)
    après soi_paramètre = après_paramètre

    # Ces paramètres sont principalement utilisés si cette classe est utilisée comme variable.
    soi._plus tôt_date = Aucune
    le plus tôt possible_date = la plus ancienne_date

    soi._dernier_date = Aucune
    le plus récent de lui-même_date = la plus récente_date

    décision personnelle_freq = décision_freq
    soi._faisable_dates = Aucune
    self.integer_size = 1  # Ce paramètre possède une seule variable entière

def decision_date () :
    def fget (self) :
        retournez-vous._décision_date

    def fset (self, valeur) :
        if isinstance (valeur, PD.timestamp) :
            soi._décision_date = valeur
        autre :
            soi._décision_date = pd.to_datetime (valeur)

    renvoyer les locaux ()

décision_date = propriété (**date_décision ()

def earliest_date () :
    def fget (self) :
        si soi._plus tôt_la date n'est pas Aucune :
            retournez-vous._plus tôt_date
        autre :
            renvoie self.model.timestepper.start

    def fset (self, valeur) :
        if isinstance (valeur, PD.timestamp) :
            soi._plus tôt_date = valeur
        autre :
            soi._plus tôt_date = pd.to_datetime (valeur)

    renvoyer les locaux ()

plus tôt_date = propriété (**date_la plus ancienne ()

def latest_date () :
    def fget (self) :
        si soi._dernier_la date n'est pas Aucune :
            retournez-vous._dernier_date
        autre :
            renvoie self.model.timestepper.end

    def fset (self, valeur) :
        if isinstance (valeur, PD.timestamp) :
            soi._dernier_date = valeur
        autre :
            soi._dernier_date = pd.to_datetime (valeur)

    renvoyer les locaux ()

dernier_date = propriété (**dernière_date ()

configuration def (self) :
    super (TransientDecisionParameter, self) .setup ()

    # Configurez maintenant les dates possibles pour lesquelles cet objet est utilisé comme variable.
    soi._faisable_dates = date de mise à jour_gamme (self.early)_date, self.latest_date,
                                             freq=self.decision_freq)

valeur de définition (self, ts, scenario_index) :

    si ts vaut None :
        v = soi avant_paramètre.get_valeur (scenario_index)
    elif ts.datetime >= self.decision_date :
        v = soi après_paramètre.get_valeur (scenario_index)
    autre :
        v = soi avant_paramètre.get_valeur (scenario_index)
    retour v

def get_entier_limites inférieures (soi) :
    renvoie np.array ([0,], dtype=np.int)

def get_entier_upper_bounds (lui-même) :
    renvoie np.array ([len (self._faisable_dates) - 1,], dtype=np.int)

set de définition_entier_variables (soi, valeurs) :
    # Mettre à jour la date de décision avec la date réalisable correspondante
    décision personnelle_date = soi._feasible_dates [valeurs [0]]

def get_entier_variables (soi) :
    renvoie np.array ([self._faisable_dates.get_loc (autodécision)_date),], dtype=np.int)

def dump (self) :

    données = {
        « le plus tôt_date : « self.early »_date.iso format (),
        « le plus récent_« date » : self.latest_date.iso format (),
        « décision_« date » : auto.decision_date.iso format (),
        « décision_fréquence' : self.decision_freq
    }

    données de retour

@classmethod
charge de définition (cls, modèle, données) :

    avant_paramètre = charge_paramètre (modèle, data.pop ('before_parameter'))
    après_paramètre = charge_paramètre (modèle, data.pop ('after_parameter'))

    return cls (model), avant_paramètre=avant_paramètre, après_paramètre=après_paramètre, **données)

Désormais, lors de l'exécution de ce réseau dans WaterStrategy, un TranscientDecisionParameter sera enregistré. 

Après avoir enregistré votre règle personnalisée, assurez-vous qu'elle s'affiche sur le côté gauche, dans ce cas sous **Paramètre** section

<figure><img src="../../.gitbook/assets/image (52).png" alt=""><figcaption></figcaption></figure>

## Utilisation du paramètre TranscientDecisionParameter

Dans ce cas, nous doublerons le volume maximum de **Nouveau réservoir** storage node en commençant par `2045-01-01`

Accédez à **Nouveau réservoir** storage node et `Modifier` **Volume maximum**

<figure><img src="../../.gitbook/assets/image (53).png" alt="" width="446"><figcaption></figcaption></figure>

Sélectionnez dans **Options** onglet **PYWR \_PARAMÈTRE**

<figure><img src="../../.gitbook/assets/image (54).png" alt="" width="271"><figcaption></figcaption></figure>

Collez le code suivant et cliquez sur **Enregistrer**

TranscientDecisionParameter inclut les attributs « avant_paramètre` et `après_parameter` que nous devrons créer comme suit :



<figure><img src="../../.gitbook/assets/image (55).png" alt=""><figcaption></figcaption></figure>

Une petite zone de texte s'ouvrira, lorsque nous pourrons écrire le nom de notre nouveau **PAR \_PARAMÈTRE**, dans ce cas \
\_\_**Nouveau réservoir \_\_:maximum \_volume précédent.** Cliquez **Entrez**. \


<figure><img src="../../.gitbook/assets/image (57).png" alt="" width="375"><figcaption></figcaption></figure>

WaterStrategy ouvrira la fenêtre des paramètres, collez le code suivant et **Enregistrer**

**\_\_Nouveau réservoir \_\_:maximum \_volume avant :**

<figure><img src="../../.gitbook/assets/image (58).png" alt=""><figcaption></figcaption></figure>

Répétez l'opération pour créer le volume maximum après le paramètre

**\_\_Nouveau réservoir \_\_:maximum \_volume après :**

Comme dernière étape, TranscientDecisionParameter doit **Proportion volumique initiale** pour le storage node en tant que paramètre hérite des valeurs initiales du nœud. Dans ce cas, nous allons configurer **0.99**

<figure><img src="../../.gitbook/assets/image (59).png" alt="" width="423"><figcaption></figcaption></figure>



## Résultats

Comme le montre l'image suivante, nous combinons des scénarios pywr utilisant le changement climatique et augmentons le volume du réservoir que nous avons sélectionné de 120.000 ml à 240.000 ml au 1er janvier 2045.

<figure><img src="../../.gitbook/assets/image (60).png" alt=""><figcaption><p>volume simulé (Nouveau réservoir)</p></figcaption></figure>