# Criar regra personalizada - TranscientDecisionParameter ## Registrar regra personalizada - TranscientDecisionParameter
Cole o código a seguir e clique no botão Salvar ![](/files/Kjq8UPwalUWS10AAnKSR) ```python 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)

--- # Agent Instructions: Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://water-strategy.gitbook.io/waterstrategy/portugues/tutoriais/pywr-scenarios-reading-external-dataframe-and-adding-custom-rules/create-custom-rule-transcientdecisionparameter.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.