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 EditarVolumen 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
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.
