Incolla il codice seguente e fai clic sul pulsante Salva
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 ModificaVolume massimo
Seleziona in Opzioni linguetta PYWR_PARAMETRO
Incolla il codice seguente e fai clic Salva
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
Ripetere l'operazione per creare il volume massimo dopo il parametro
**__Nuovo serbatoio__:massimo_volume dopo: **
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.
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 ()
