Criar regra personalizada - TranscientDecisionParameter

Registrar regra personalizada - TranscientDecisionParameter

Cole o código a seguir e clique no botão Salvar

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 Editar Volume máximo

Selecione em Opções aba PYWR_PARAMETER

Cole o código a seguir e clique em Salvar

{
  	“tipo”: “TransientDecisionParameter”,
	“depois_parâmetro”:”__Novo reservatório__:máximo_volume depois de”,
	“antes_parâmetro”:”__Novo reservatório__:máximo_volume antes”,
	“data_de_decisão”: “2045-01-01”,
	“data_recente”: “2045-01-01”
}

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

**__Novo reservatório__:máximo_volume antes: **

{
	“tipo”: “parâmetro constante”,
	“valor”: 120000
}

Repita para criar o volume máximo após o parâmetro

**__Novo reservatório__:máximo_volume após: **

{
	“tipo”: “parâmetro constante”,
	“valor”: 240000
}

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.

volume simulado (Novo reservatório)