Crear regla personalizada - TranscientDecisionParameter

Registrar regla personalizada: TranscientDecisionParameter

Pegue el siguiente código y luego haga clic en el botón Guardar

clase TransientDecisionParameter (Parámetro):
    «"» Devuelve uno de los dos valores en función del intervalo de tiempo actual

    Este `parámetro` se puede usar para modelar un evento de decisión discreto
     eso ocurre en una fecha determinada. Antes de esta fecha, el «antes»
     se devuelve el valor y, después de esta fecha, se devuelve el valor `posterior`.

    Parámetros
    ----------
    decision_date: cadena o pandas.Timestamp
        La fecha de activación de la decisión.
    before_parameter: Parámetro
        El valor que se utilizará antes de la fecha de la decisión.
    after_parameter: Parámetro
        El valor que se utilizará después de la fecha de la decisión.
    earliest_date: string o pandas.Timestamp o None
        Fecha más temprana en la que se puede establecer la variable. El valor predeterminado es `model.timestepper.start`
    latest_date: string o pandas.Timestamp o None
        Última fecha en la que se puede establecer la variable. El valor predeterminado es `model.timestepper.end`
    decision_freq: cadena de frecuencia de pandas ('AS' predeterminado)
        La resolución de fechas factibles. Por ejemplo, «AS» crearía fechas factibles cada
        año entre el «más temprano»_fecha` y `última_fecha`. Se utilizan las funciones `pandas`
        internamente para los cálculos de fechas delta.

    «»

    def __iniciarlo__(yo, modelo, decisión)_fecha, antes_parámetro, después_parámetro, el más antiguo_fecha=ninguna, más reciente_fecha=ninguna, decisión_freq=' as ', **kwargs):
        super (TransientDecisionParameter, self).__iniciarlo__(modelo, **kwargs)
        uno mismo._decisión_fecha = Ninguna
        autodecisión_fecha = decisión_cita

        si no es instance (before_parameter, Parameter):
            raise ValueError ('El valor `antes` debe ser una instancia de parámetro. ')
        before_parameter.parents.add (uno mismo)
        uno mismo antes_parámetro = antes_parámetro

        si no es instance (after_parameter, Parameter):
            raise ValueError ('El valor `posterior` debe ser una instancia de parámetro. ')
        after_parameter.parents.add (uno mismo)
        después de uno mismo_parámetro = después_parámetro

        # Estos parámetros se utilizan principalmente si esta clase se utiliza como variable.
        uno mismo._más temprano_fecha = Ninguna
        sí mismo.más temprano_fecha = más temprana_cita

        uno mismo._último_fecha = Ninguna
        autoúltimo_fecha = última_cita

        autodecisión_freq = decisión_frecuencia
        uno mismo._factible_fechas = Ninguna
        tamaño_entero propio = 1  # Este parámetro tiene una única variable entera

    def decision_date ():
        def get (self):
            devuélvete yo._decisión_cita

        def fset (self, valor):
            si es instancia (valor, pd.Timestamp):
                uno mismo._decisión_fecha = valor
            otra cosa:
                uno mismo._decisión_date = pd.to_datetime (valor)

        devuelve locales ()

    decisión_fecha = propiedad (**fecha_decisión ()

    define earliest_date ():
        def get (self):
            si es propio._más temprano_la fecha no es Ninguna:
                devuélvete yo._más temprano_cita
            otra cosa:
                devuelve self.model.timestepper.start

        def fset (self, valor):
            si es instancia (valor, pd.Timestamp):
                uno mismo._más temprano_fecha = valor
            otra cosa:
                uno mismo._más temprano_date = pd.to_datetime (valor)

        devuelve locales ()

    más temprano_fecha = propiedad (**fecha_temprana ()

    def latest_date ():
        def get (self):
            si es propio._último_la fecha no es Ninguna:
                devuélvete yo._último_cita
            otra cosa:
                devuelve self.model.timestepper.end

        def fset (self, valor):
            si es instancia (valor, pd.Timestamp):
                uno mismo._último_fecha = valor
            otra cosa:
                uno mismo._último_date = pd.to_datetime (valor)

        devuelve locales ()

    último_fecha = propiedad (**última fecha ()

    configuración de definición (propia):
        super (TransientDecisionParameter, self) .setup ()

        # Ahora configure las fechas factibles para cuando este objeto se utilice como variable.
        uno mismo._factible_fechas = pd.date_range (self.earliest)_fecha, self.latest_date,
                                                 freq=self.decision_freq)

    valor de definición (self, ts, scenario_index):

        si ts es Ninguno:
            v = auto.antes_parámetro.get_valor (scenario_index)
        elif ts.datetime >= self.decision_date:
            v = autodespués_parámetro.get_valor (scenario_index)
        otra cosa:
            v = auto.antes_parámetro.get_valor (scenario_index)
        devuelve v

    definitivamente consigue_entero_límites inferiores (self):
        devuelve np.array ([0,], dtype=np.int)

    definitivamente consigue_entero_límites superiores (uno mismo):
        devuelve np.array ([len (self)._factible_fechas) - 1,], dtype=np.int)

    conjunto def_entero_variables (propias, valores):
        # Actualice la fecha de la decisión con la fecha factible correspondiente
        autodecisión_fecha = propia._factible_dates [valores [0]]

    definitivamente consigue_entero_variables (propias):
        devuelve np.array ([self._factible_dates.get_loc (autodecisión)_fecha),], dtype=np.int)

    def dump (propio):

        datos = {
            'más temprano_fecha': auto.earliest_date.isoformat (),
            «último_fecha»: self.latest_date.isoformat (),
            «decisión_fecha»: autodecisión_date.isoformat (),
            «decisión_frecuencia': autodecisión_frecuencia
        }

        datos de devolución

    @classmethod
    carga definida (cls, modelo, datos):

        delante de_parámetro = carga_parámetro (model, data.pop ('before_parameter'))
        después_parámetro = carga_parámetro (model, data.pop ('after_parameter'))

        return cls (model), antes_parameter=antes_parámetro, después_parámetro = después_parámetro, **datos)

Parámetro de decisión transitoria.register ()

Ahora, al ejecutar esta red en WaterStrategy, se registrará un TranscientDecisionParameter.

Asegúrese de que, después de guardar la regla personalizada, aparezca en el lado izquierdo, en este caso en Parámetro sección

Uso del parámetro TranscientDecisionParameter

En este caso, duplicaremos el volumen máximo de Nuevo embalse storage node empezando en 2045-01-01

Ir a Nuevo embalse storage node y Editar Volumen máximo

Seleccione en Opciones lengüeta PYR_PARÁMETRO

Pegue el siguiente código y haga clic Guardar

{
  	«tipo»: «Parámetro de decisión transitorio»,
	«después_parámetro»:»__Nuevo depósito__:máximo_volumen después de»,
	«antes_parámetro»:»__Nuevo depósito__:máximo_volumen anterior»,
	«fecha_decisión»: «2045-01-01»,
	«última fecha»: «2045-01-01»
}

TranscientDecisionParameter incluye atributos before_parámetro y después_parámetro que tendremos que crear de la siguiente manera:

Se abrirá un pequeño cuadro de texto, cuando podamos escribir el nombre de nuestro nuevo POR_PARÁMETRO, en este caso __Nuevo depósito__:máximo_volumen anterior. Haga clic Entrar. \

WaterStrategy abrirá la ventana de parámetros, pegará el siguiente código y Guardar

**__Nuevo depósito__:máximo_volumen antes: **

{
	«tipo»: «Parámetro constante»,
	«valor»: 120000
}

Repita el procedimiento para crear el volumen máximo después del parámetro

**__Nuevo depósito__:máximo_volumen después de: **

{
	«tipo»: «Parámetro constante»,
	«valor»: 240000
}

Como último paso, TranscientDecisionParameter necesita Proporción de volumen inicial para storage node como parámetro, herede los valores iniciales del nodo, en este caso configuraremos para 0.99

Resultados

Como podemos ver en la siguiente imagen, estamos combinando escenarios de pywr-utilizando el cambio climático y aumentando el volumen de nuestro depósito seleccionado de 120.000 Ml a 240.000 Ml el 1 de enero 2045.

volumen simulado (depósito nuevo)