classe TransientDecisionParameter (Parameter):
“"” Retorna um dos dois valores, dependendo do intervalo de tempo atual
Este `Parâmetro` pode ser usado para modelar um evento de decisão discreto
isso acontece em uma determinada data. Antes desta data, o `antes`
o valor é retornado e, após essa data, o valor `depois` é retornado.
Parâmetros
----------
decision_date: string ou pandas.Timestamp
A data de ativação da decisão.
before_parameter: Parâmetro
O valor a ser usado antes da data da decisão.
after_parameter: Parâmetro
O valor a ser usado após a data da decisão.
earliest_date: string ou pandas.Timestamp ou None
Data mais antiga para a qual a variável pode ser definida. O padrão é `model.timestepper.start`
latest_date: string ou pandas.Timestamp ou None
Data mais recente para a qual a variável pode ser definida. O padrão é `model.timestepper.end`
decision_freq: string de frequência de pandas (padrão 'AS')
A resolução de datas viáveis. Por exemplo, 'AS' criaria datas viáveis a cada
ano entre `mais cedo_data` e `mais recente_encontro`. As funções `pandas` são usadas
internamente para cálculos de data delta.
“"”
definitivamente __inicializá-lo__(eu, modelo, decisão)_data, antes_parâmetro, depois_parâmetro, mais antigo_Data = nenhuma, mais recente_Data = nenhuma, decisão_freq='as', **kwargs):
super (TransientDecisionParameter, self).__inicializá-lo__(modelo, **kwargs)
eu._decisão_data = Nenhuma
autodecisão_data = decisão_data
se não for isinstance (before_parameter, Parameter):
raise ValueError ('O valor `antes' deve ser uma instância de parâmetro. ')
before_parameter.parents.add (self)
sel. antes_parâmetro = antes_parâmetro
se não for isinstance (after_parameter, Parameter):
raise ValueError ('O valor `after` deve ser uma instância de parâmetro. ')
after_parameter.parents.add (self)
self. depois_parâmetro = depois_parâmetro
# Esses parâmetros são usados principalmente se essa classe for usada como variável.
eu._mais cedo_data = Nenhuma
self. mais antigo_data = mais antiga_data
eu._mais recente_data = Nenhuma
self.latest_data = mais recente_data
autodecisão_freq = decisão_freq
eu._viável_datas = Nenhuma
self.integer_size = 1 # Esse parâmetro tem uma única variável inteira
def decision_date ():
def fget (self):
devolva a si mesmo._decisão_data
def fset (self, valor):
if isinstance (valor, pd.timestamp):
eu._decisão_data = valor
senão:
eu._decisão_data = pd.to_datetime (valor)
retornar locais ()
decisão_data = propriedade (**data_de_decisão ()
def earliest_date ():
def fget (self):
se eu mesmo._mais cedo_a data não é Nenhuma:
devolva a si mesmo._mais cedo_data
senão:
retornar self.model.timestepper.start
def fset (self, valor):
if isinstance (valor, pd.timestamp):
eu._mais cedo_data = valor
senão:
eu._mais cedo_data = pd.to_datetime (valor)
retornar locais ()
mais cedo_data = propriedade (**data_anterior ()
def latest_date ():
def fget (self):
se eu mesmo._mais recente_a data não é Nenhuma:
devolva a si mesmo._mais recente_data
senão:
retornar self.model.timestepper.end
def fset (self, valor):
if isinstance (valor, pd.timestamp):
eu._mais recente_data = valor
senão:
eu._mais recente_data = pd.to_datetime (valor)
retornar locais ()
mais recente_data = propriedade (**data_mais recente ()
configuração de definição (self):
super (TransientDecisionParameter, self) .setup ()
# Agora, configure as datas possíveis para quando esse objeto for usado como uma variável.
eu._viável_datas = pd.date_intervalo (self.mais antigo)_data, self.latest_date,
freq = self.decision_freq)
valor def (self, ts, scenario_index):
se ts for Nenhum:
v = self.antes_parameter.get_valor (scenario_index)
elif ts.datetime >= self.decision_date:
v = self.after_parameter.get_valor (scenario_index)
senão:
v = self.antes_parameter.get_valor (scenario_index)
retornar v
definitivamente obter_inteira_lower_bounds (self):
retornar np.array ([0,], dtype=np.int)
definitivamente obter_inteira_limites superiores (self):
retorna np.array ([len (self)._viável_datas) - 1,], dtype=np.int)
conjunto de definição_inteira_variáveis (self, valores):
# Atualize a data da decisão com a data viável correspondente
autodecisão_encontro = eu mesmo._datas_viáveis [valores [0]]
definitivamente obter_inteira_variáveis (self):
return np.array ([self._viável_datas.get_loc (autodecisão)_data),], dtype = np.int)
def dump (self):
dados = {
'mais cedo_'data': self.mais cedo_formato data.iso (),
'mais recente_'data': self.latest_formato data.iso (),
'decisão_'data': autodecisão_formato data.iso (),
'decisão_'frequência': autodecisão_freq
}
dados de retorno
@classmethod
carga definida (cls, modelo, dados):
antes_parâmetro = carga_parâmetro (modelo, data.pop ('before_parameter'))
depois_parâmetro = carga_parâmetro (modelo, data.pop ('after_parameter'))
return cls (modelo), antes_parâmetro = antes_parâmetro, depois_parâmetro = depois_parâmetro, **dados)
Parâmetro de decisão transitória.register ()
Agora, ao executar essa rede em WaterStrategy, um TranscientDecisionParameter será registrado.
Certifique-se de que, depois de salvar sua regra personalizada, ela seja exibida no lado esquerdo, neste caso em Parâmetro seção
Usando o TranscientDecisionParameter
Nesse caso, dobraremos o volume máximo de Novo reservatório storage node começando em 2045-01-01
Vá para Novo reservatório storage node e EditarVolume máximo
O TranscientDecisionParameter inclui atributos antes_parametro e depois_parameter que teremos que criar da seguinte forma:
Uma pequena caixa de texto se abrirá, quando pudermos escrever o nome do nosso novo POR_PARÂMETRO, neste caso
__Novo reservatório__:máximo_volume anterior. Clique Entrar. \
WaterStrategy abrirá a janela de parâmetros, colará o seguinte código e Salvar
Como última etapa, TranscientDecisionParameter precisa Proporção de volume inicial para o storage node, pois o parâmetro herda os valores iniciais do nó, neste caso, configuraremos para 0.99
Resultados
Como podemos ver na figura a seguir, estamos combinando cenários pywr usando a Mudança Climática e aumentando o volume do nosso reservatório selecionado de 120.000 Ml para 240.000 Ml em 1º de janeiro 2045.
