# Crea regola personalizzata - TranscientDecisionParameter ## Registra regola personalizzata - TranscientDecisionParameter
Incolla il codice seguente e fai clic sul pulsante Salva ![](/files/VeixhTNLvRkhATwkTcxJ) ```pitone classe TransientDecisionParameter (parametro): «"» Restituisce uno dei due valori in base alla fase temporale corrente Questo `Parametro` può essere usato per modellare un evento decisionale discreto ciò accade in una determinata data. Prima di questa data il «prima» viene restituito il valore e dopo questa data viene restituito il valore «dopo». Parametri ---------- decision_date: stringa o pandas.timestamp La data di inizio della decisione. before_parameter: Parametro Il valore da utilizzare prima della data della decisione. after_parameter: Parametro Il valore da utilizzare dopo la data della decisione. earliest_date: string o pandas.Timestamp o None Prima data in cui è possibile impostare la variabile. Il valore predefinito è `model.timestepper.start` latest_date: string o pandas.Timestamp o None Ultima data in cui è possibile impostare la variabile. Il valore predefinito è `model.timestepper.end` decision_freq: stringa di frequenza panda (impostazione predefinita 'AS') La risoluzione delle date possibili. Ad esempio «AS» creerebbe date fattibili ogni anno compreso tra il «primo»_data` e `ultima_data`. Vengono utilizzate le funzioni `pandas` internamente per il calcolo della data delta. «"» def __init__(sé, modello, decisione_data, prima_parametro, dopo_parametro, il primo_data=nessuna, ultima_data=Nessuno, decisione_freq='as', **kwargs): super (TransientDecisionParameter, self).__init__(modello, **kwargs) sé stesso._decisione_data = Nessuna decisione personale_data = decisione_data se non è istanza (before_parameter, Parameter): raise ValueError ('Il valore `before` dovrebbe essere un'istanza di Parameter. ') before_parameter.parents.add (self) se stesso. prima_parametro = prima_parametro se non è istanza (after_parameter, Parameter): raise ValueError ('Il valore `after` dovrebbe essere un'istanza di Parameter. ') after_parameter.parents.add (sé) se stesso dopo_parametro = dopo_parametro # Questi parametri vengono utilizzati principalmente se questa classe viene utilizzata come variabile. sé stesso._il più presto possibile_data = Nessuna sé stesso. Il più presto_data = prima_data sé stesso._più recente_data = Nessuna auto.più recente_data = più recente_data decisione personale_freq = decisione_frequenza sé stesso._fattibile_date = Nessuna self.dimensione_intero = 1 # Questo parametro ha una singola variabile intera def data_decisione (): def fget (auto): restituire se stessi._decisione_data def fset (self, valore): if isinstance (value, pd.timestamp): sé stesso._decisione_data = valore altro: sé stesso._decisione_date = pd.to_datetime (valore) restituisci locali () decisione_data = proprietà (**data_decisione ()) def data_precedente (): def fget (auto): se stesso._il più presto possibile_la data non è Nessuna: restituire se stessi._il più presto possibile_data altro: return self.model.timestepper.start def fset (self, valore): if isinstance (value, pd.timestamp): sé stesso._il più presto possibile_data = valore altro: sé stesso._il più presto possibile_date = pd.to_datetime (valore) restituisci locali () il più presto possibile_data = proprietà (**data_più recente () def data_ultima (): def fget (auto): se stesso._più recente_la data non è Nessuna: restituire se stessi._più recente_data altro: restituisce self.model.timestepper.end def fset (self, valore): if isinstance (value, pd.timestamp): sé stesso._più recente_data = valore altro: sé stesso._più recente_date = pd.to_datetime (valore) restituisci locali () più recente_data = proprietà (**data_ultima ()) impostazione def (self): super (transientDecisionParameter, self) .setup () # Ora imposta le date possibili per l'utilizzo di questo oggetto come variabile. sé stesso._fattibile_date = pd.date_intervallo (self._data, self.latest_date, freq=self.decision_freq) valore def (self, ts, scenario_index): se ts è Nessuno: v = sé stesso. prima_parametro.get_valore (scenario_index) elif ts.datetime >= self.decision_date: v = auto.dopo_parametro.get_valore (scenario_index) altro: v = sé stesso. prima_parametro.get_valore (scenario_index) ritorno v def get_intero_lower_bounds (self): restituisce np.array ([0,], dtype=np.int) def get_intero_upper_bounds (auto): restituisce np.array ([len (self._fattibile_date) - 1,], dtype=np.int) impostazione def_intero_variabili (self, valori): # Aggiorna la data della decisione con la data possibile corrispondente decisione personale_data = sé._feasible_dates [valori [0]] def get_intero_variabili (self): restituisce np.array ([self._fattibile_date.get_loc (decisione autonoma)_data),], dtype=np.int) def dump (auto): dati = { «prima_data': self.earliest_data.isoformat (), 'più recente_data': self.latest_data.isoformat (), «decisione_data': decisione personale_data.isoformat (), «decisione_frequenza': decisione personale_frequenza } dati di ritorno @classmethod def load (cls, modello, dati): prima_parametro = carico_parametro (model, data.pop ('before_parameter')) dopo_parametro = carico_parametro (model, data.pop ('after_parameter')) return cls (model), prima_parametro=prima_parametro, dopo_parametro=dopo_parametro, **dati) TransientDecisionParameter.register () ``` Ora, quando si esegue questa rete in WaterStrategy, verrà registrato un TranscientDecisionParameter. Assicurati che dopo aver salvato la tua regola personalizzata, sia visualizzata sul lato sinistro, in questo caso sotto **Parametro** sezione
## Utilizzo del parametro TranscientDecision In questo caso, raddoppieremo il volume massimo di **Nuovo serbatoio** storage node a partire da `2045-01-01` Vai a **Nuovo serbatoio** storage node e `Modifica` **Volume massimo**
Seleziona in **Opzioni** linguetta **PYWR\_PARAMETRO**
Incolla il codice seguente e fai clic **Salva** ``` { «type»: «TransientDecisionParameter», «dopo_parametro»:»__Nuovo serbatoio__:massimo_volume dopo», «prima_parametro»:»__Nuovo serbatoio__:massimo_volume precedente», «data_decisione»: «2045-01-__-01», «data_ultima»: «2045-01-__-01» } ``` TranscientDecisionParameter include gli attributi `before_parametro` e `dopo_parametro` che dovremo creare come segue:
Si aprirà una piccola casella di testo, quando potremo scrivere il nome del nostro nuovo **PWR\_PARAMETER**, in questo caso\ \_\_**Nuovo serbatoio\_\_:massimo\_volume precedente.** Fare clic **Entra**. \\
WaterStrategy aprirà la finestra dei parametri, incollerà il seguente codice e **Salva** \*\*\_\_Nuovo serbatoio\_\_:massimo\_volume precedente: \*\* ``` { «type»: «ConstantParameter», «valore»: 120000 } ```
Ripetere l'operazione per creare il volume massimo dopo il parametro \*\*\_\_Nuovo serbatoio\_\_:massimo\_volume dopo: \*\* ``` { «type»: «ConstantParameter», «valore»: 240000 } ``` Come ultimo passaggio, `TranscientDecisionParameter` deve **Proporzione iniziale del volume** per il storage node poiché il parametro eredita i valori iniziali dal nodo, in questo caso imposteremo **0.99**
## Risultati Come possiamo vedere nella figura seguente, stiamo combinando scenari pywr utilizzando Climate Change e aumentando il volume del nostro serbatoio selezionato da 120.000 Ml a 240.000 Ml il 1° gennaio 2045.

volume simulato (New Reservoir)

--- # 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/italiano/tutorial/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.