> For the complete documentation index, see [llms.txt](https://water-strategy.gitbook.io/waterstrategy/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://water-strategy.gitbook.io/waterstrategy/deutsch/tutorials/pywr-scenarios-reading-external-dataframe-and-adding-custom-rules/create-custom-rule-transcientdecisionparameter.md). # Benutzerdefinierte Regel erstellen - TranscientDecisionParameter ## Benutzerdefinierte Regel registrieren - TranscientDecisionParameter
Fügen Sie den folgenden Code ein und klicken Sie dann auf die Schaltfläche Speichern ![](/files/4f7FZR17wUlFrIhKA0Cx) ```python Klasse TransientDecisionParameter (Parameter): „"“ Gibt abhängig vom aktuellen Zeitschritt einen von zwei Werten zurück Dieser `Parameter` kann verwendet werden, um ein diskretes Entscheidungsereignis zu modellieren das passiert zu einem bestimmten Zeitpunkt. Vor diesem Datum das `Vorher` Der Wert wird zurückgegeben, und nach diesem Datum wird der Wert „nach“ zurückgegeben. Parameter ---------- decision_date: Zeichenfolge oder pandas.TimeStamp Das Auslösedatum für die Entscheidung. before_parameter: Parameter Der Wert, der vor dem Entscheidungsdatum verwendet werden soll. after_parameter: Parameter Der Wert, der nach dem Entscheidungsdatum verwendet werden soll. earliest_date: string oder pandas.TimeStamp oder None Frühestes Datum, auf das die Variable gesetzt werden kann. Die Standardeinstellung ist `model.timestepper.start` latest_date: string oder pandas.Timestamp oder None Spätestes Datum, auf das die Variable gesetzt werden kann. Die Standardeinstellung ist `model.timestepper.end` decision_freq: Pandas-Frequenzstring (Standard 'AS') Die Auflösung möglicher Termine. Zum Beispiel würde 'AS' jedes Mal mögliche Termine erstellen Jahr zwischen `frühestens_datum` und `spätestes_datum`. Die `Pandas`-Funktionen werden verwendet intern für Delta-Datumsberechnungen. „"“ def __initiieren__(Selbst, Modell, Entscheidung_Datum, vorher_Parameter, nach_Parameter, frühester_Datum=Kein, spätestes_Date=None, Entscheidung_Freq='as', **kwargs): super (transientDecisionParameter, self).__initiieren__(Modell, **kwargs) selbst._Entscheidung_Datum = Keines Selbstentscheidung_Datum = Entscheidung_Datum wenn nicht isinstance (before_parameter, Parameter): raise ValueError ('Der `vorher`-Wert sollte eine Parameter-Instanz sein. ') before_parameter.parents.add (selbst) selbst.vorher_Parameter = vorher_Einstellung wenn nicht isinstance (after_parameter, Parameter): raise ValueError ('Der Wert `nach` sollte eine Parameter-Instanz sein. ') after_parameter.parents.add (selbst) selbst.danach_Parameter = nach_Einstellung # Diese Parameter werden hauptsächlich verwendet, wenn diese Klasse als Variable verwendet wird. selbst._frühestens_Datum = Keines selbst.frühestens_Datum = frühestes_Datum selbst._neueste_Datum = Keines selbst.latest_Datum = spätestes_Datum Selbstentscheidung_freq = Entscheidung_Frequenz selbst._machbar_Termine = Keine self.integer_size = 1 # Dieser Parameter hat eine einzelne Integer-Variable def decision_date (): def fget (selbst): kehre dich selbst zurück._Entscheidung_Datum def fset (selbst, Wert): wenn isinstance (Wert, pd.Timestamp): selbst._Entscheidung_Datum = Wert sonst: selbst._Entscheidung_Datum = pd.to_datetime (Wert) gib Einheimische zurück () Entscheidung_Datum = Eigentum (**Datum der Entscheidung () def earliest_date (): def fget (selbst): wenn ich selbst._frühestens_Datum ist nicht Keines: kehre dich selbst zurück._frühestens_Datum sonst: gib self.model.timestepper.start zurück def fset (selbst, Wert): wenn isinstance (Wert, pd.Timestamp): selbst._frühestens_Datum = Wert sonst: selbst._frühestens_Datum = pd.to_datetime (Wert) gib Einheimische zurück () frühestens_Datum = Eigentum (**frühestes Datum () def latest_date (): def fget (selbst): wenn ich selbst._neueste_Datum ist nicht Keines: kehre dich selbst zurück._neueste_Datum sonst: gib self.model.timestepper.end zurück def fset (selbst, Wert): wenn isinstance (Wert, pd.Timestamp): selbst._neueste_Datum = Wert sonst: selbst._neueste_Datum = pd.to_datetime (Wert) gib Einheimische zurück () neueste_Datum = Eigentum (**neuestes_datum () def setup (selbst): super (transientDecisionParameter, self) .setup () # Richten Sie nun die möglichen Daten ein, an denen dieses Objekt als Variable verwendet wird. selbst._machbar_daten = pd.date_Reichweite (selbst.frühestens)_Datum, self.latest_date, freq=selbst.entscheidungsfreq) def-Wert (self, ts, scenario_index): wenn ts None ist: v = selbst.before_parameter.get_Wert (scenario_index) elif ts.datetime => self.decision_date: v = selbst.danach_parameter.get_Wert (scenario_index) sonst: v = selbst.before_parameter.get_Wert (scenario_index) gib v zurück auf jeden Fall_Ganzzahl_lower_bounds (selbst): gib np.array ([0,], dtype=np.int) zurück auf jeden Fall_Ganzzahl_upper_bounds (selbst): gib np.array ([len (self) zurück._machbar_Daten) - 1,], dtype=np.int) definitv gesetzt_Ganzzahl_Variablen (selbst, Werte): # Aktualisieren Sie das Entscheidungsdatum mit dem entsprechenden möglichen Datum Selbstentscheidung_Datum = selbst._easible_dates [Werte [0]] auf jeden Fall_Ganzzahl_Variablen (selbst): gib np.array ([self._machbar_dates.get_loc (Selbstentscheidung)_Datum),], dtype=np.int) def dump (selbst): daten = { 'frühestens_'Datum': selbst.frühestes_date.isoformat (), 'neuestes_'Datum': self.latest_date.isoformat (), 'Entscheidung_'Datum': Selbstentscheidung_date.isoformat (), 'Entscheidung_'Frequenz': Selbstentscheidung_Frequenz } Daten zurückgeben @classmethod def load (cls, modell, daten): vor_Parameter = laden_parameter (Modell, data.pop ('before_parameter')) nach_Parameter = laden_parameter (Modell, data.pop ('after_parameter')) gibt cls (model) zurück, vorher_parameter=vorher_Parameter, nach_parameter=nach_Parameter, **Daten) TransientDecisionParameter.register () ``` Wenn Sie dieses Netzwerk jetzt in WaterStrategy ausführen, wird ein TranscientDecisionParameter registriert. Vergewissern Sie sich, dass Ihre benutzerdefinierte Regel nach dem Speichern auf der linken Seite angezeigt wird, in diesem Fall unter **Parameter** Abschnitt
## Verwenden des TranscientDecisionParameters In diesem Fall verdoppeln wir die maximale Lautstärke von **Neues Reservoir** storage node beginnt mit `2045-01-01` Gehe zu **Neues Reservoir** storage node und `Edit` **Max. Lautstärke**
Wählen Sie in **Optionen** Registerkarte **PYWR\_PARAMETER**
Fügen Sie den folgenden Code ein und klicken Sie auf **Speichern** ``` { „type“: „TransientDecisionParameter“, „nach_Parameter“:“__Neues Reservoir__:maximal_Lautstärke nach“, „vor_Parameter“:“__Neues Reservoir__:maximal_Lautstärke vor“, „Entscheidungsdatum“: „2045-01-__1234567890__“, „neuestes_datum“: „2045-01-__1234567890__“ } ``` TranscientDecisionParameter beinhaltet Attribute `before_Parameter` und `danach_Parameter` den wir wie folgt erstellen müssen:
Es öffnet sich ein kleines Textfeld, in dem wir den Namen unseres neuen schreiben können **VON\_PARAMETER**, in diesem Fall\ \_\_**Neues Reservoir\_\_:maximal\_Volumen vorher.** Klicken Sie **Geben Sie ein**. \\
WaterStrategy öffnet das Parameterfenster, fügen Sie den folgenden Code ein und **Speichern** \*\*\_\_Neues Reservoir\_\_:maximal\_Volumen vorher: \*\* ``` { „Typ“: „Konstanter Parameter“, „Wert“: 120000 } ```
Wiederholen Sie den Vorgang, um die maximale Lautstärke nach dem Parameter zu erstellen \*\*\_\_Neues Reservoir\_\_:maximal\_Volumen nach: \*\* ``` { „Typ“: „Konstanter Parameter“, „Wert“: 240000 } ``` Als letzten Schritt benötigt `TranscientDecisionParameter` **Ursprünglicher Volumenanteil** für den storage node als Parameter erben wir die Anfangswerte vom Knoten, in diesem Fall richten wir das so ein **0.99**
## Ergebnisse Wie wir im folgenden Bild sehen können, kombinieren wir Pywr-Szenarien unter Verwendung des Klimawandels und erhöhen das Volumen unseres ausgewählten Reservoirs von 120.000 Ml auf 240.**1234567890**□ Ml am 1. Januar **1234567890**□ Ml.

simuliertes Volumen (New Reservoir)

--- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## 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/deutsch/tutorials/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.