# Créer une règle personnalisée - TranscientDecisionParameter ## Enregistrer une règle personnalisée - TranscientDecisionParameter
Collez le code suivant puis cliquez sur le bouton Enregistrer ![](/files/3dBPjNdK9uJfVmjSW9LE) \`\`python classe TransientDecisionParameter (Parameter) : «" » Renvoie l'une des deux valeurs en fonction du pas de temps actuel ``` 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, « 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) ``` Paramètre de décision transitoire. register () ``` 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
## 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**
Sélectionnez dans **Options** onglet **PYWR \_PARAMÈTRE**
Collez le code suivant et cliquez sur **Enregistrer** ``` { « type » : « Paramètre de décision transitoire », « après\_paramètre » : »**Nouveau réservoir**:max\_volume après », « avant\_paramètre » : »**Nouveau réservoir**:max\_volume avant », « date\_décision » : « 2045-01-01 », « dernière\_date » : « 2045-01-01 » } ``` TranscientDecisionParameter inclut les attributs « avant_paramètre` et `après_parameter` que nous devrons créer comme suit :
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**. \
WaterStrategy ouvrira la fenêtre des paramètres, collez le code suivant et **Enregistrer** **\_\_Nouveau réservoir \_\_:maximum \_volume avant :** ``` { « type » : « Paramètre constant », « valeur » : 120000 } ```
Répétez l'opération pour créer le volume maximum après le paramètre **\_\_Nouveau réservoir \_\_:maximum \_volume après :** ``` { « type » : « Paramètre constant », « valeur » : 240000 } ``` 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**
## 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.

volume simulé (Nouveau réservoir)

``` --- # Agent Instructions: Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://water-strategy.gitbook.io/waterstrategy/francais/tutoriels/pywr-scenarios-reading-external-dataframe-and-adding-custom-rules/create-custom-rule-transcientdecisionparameter.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.