Benutzerdefinierte Regel erstellen - TranscientDecisionParameter

Benutzerdefinierte Regel registrieren - TranscientDecisionParameter

Fügen Sie den folgenden Code ein und klicken Sie dann auf die Schaltfläche Speichern

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)