Créer une règle personnalisée - TranscientDecisionParameter
Enregistrer une règle personnalisée - TranscientDecisionParameter
Collez le code suivant puis cliquez sur le bouton Enregistrer 
``python classe TransientDecisionParameter (Parameter) : «" » Renvoie l'une des deux valeurs en fonction du pas de temps actuel
Ce « paramètre » peut être utilisé pour modéliser un événement de décision discret
cela se produit à une date donnée. Avant cette date, le « avant »
la valeur est renvoyée, et après cette date, la valeur « after » est renvoyée.
Paramètres
----------
decision_date : chaîne ou pandas.Timestamp
Date de déclenchement de la décision.
before_parameter : Paramètre
La valeur à utiliser avant la date de décision.
after_parameter : Paramètre
La valeur à utiliser après la date de décision.
earliest_date : chaîne ou Pandas.Timestamp ou None
Date la plus proche à laquelle la variable peut être définie. La valeur par défaut est `model.timestepper.start`
latest_date : chaîne ou Pandas.Timestamp ou None
Dernière date à laquelle la variable peut être définie. La valeur par défaut est model.timestepper.end
decision_freq : chaîne de fréquence pandas (par défaut « AS »)
La résolution de dates réalisables. Par exemple, « AS » créerait des dates réalisables tous les
année entre « la plus ancienne »_date` et `dernière_date`. Les fonctions « pandas » sont utilisées
en interne pour les calculs de date delta.
« »
def __init__(soi, modèle, décision_date, avant_paramètre, après_paramètre, le plus tôt_Date = aucune, la plus récente_Date = aucune, décision_freq='As, **kwargs) :
super (TransientDecisionParameter, self).__init__(modèle, **kwargs)
soi._décision_date = Aucune
décision personnelle_date = décision_date
sinon isinstance (before_parameter, Parameter) :
raise ValueError (« La valeur « avant » doit être une instance de paramètre. »)
before_parameter.parents.add (lui-même)
soi. Avant_paramètre = avant_paramètre
sinon isinstance (after_parameter, Parameter) :
raise ValueError (« La valeur « après » doit être une instance de paramètre. »)
after_parameter.parents.add (lui-même)
après soi_paramètre = après_paramètre
# Ces paramètres sont principalement utilisés si cette classe est utilisée comme variable.
soi._plus tôt_date = Aucune
le plus tôt possible_date = la plus ancienne_date
soi._dernier_date = Aucune
le plus récent de lui-même_date = la plus récente_date
décision personnelle_freq = décision_freq
soi._faisable_dates = Aucune
self.integer_size = 1 # Ce paramètre possède une seule variable entière
def decision_date () :
def fget (self) :
retournez-vous._décision_date
def fset (self, valeur) :
if isinstance (valeur, PD.timestamp) :
soi._décision_date = valeur
autre :
soi._décision_date = pd.to_datetime (valeur)
renvoyer les locaux ()
décision_date = propriété (**date_décision ()
def earliest_date () :
def fget (self) :
si soi._plus tôt_la date n'est pas Aucune :
retournez-vous._plus tôt_date
autre :
renvoie self.model.timestepper.start
def fset (self, valeur) :
if isinstance (valeur, PD.timestamp) :
soi._plus tôt_date = valeur
autre :
soi._plus tôt_date = pd.to_datetime (valeur)
renvoyer les locaux ()
plus tôt_date = propriété (**date_la plus ancienne ()
def latest_date () :
def fget (self) :
si soi._dernier_la date n'est pas Aucune :
retournez-vous._dernier_date
autre :
renvoie self.model.timestepper.end
def fset (self, valeur) :
if isinstance (valeur, PD.timestamp) :
soi._dernier_date = valeur
autre :
soi._dernier_date = pd.to_datetime (valeur)
renvoyer les locaux ()
dernier_date = propriété (**dernière_date ()
configuration def (self) :
super (TransientDecisionParameter, self) .setup ()
# Configurez maintenant les dates possibles pour lesquelles cet objet est utilisé comme variable.
soi._faisable_dates = date de mise à jour_gamme (self.early)_date, self.latest_date,
freq=self.decision_freq)
valeur de définition (self, ts, scenario_index) :
si ts vaut None :
v = soi avant_paramètre.get_valeur (scenario_index)
elif ts.datetime >= self.decision_date :
v = soi après_paramètre.get_valeur (scenario_index)
autre :
v = soi avant_paramètre.get_valeur (scenario_index)
retour v
def get_entier_limites inférieures (soi) :
renvoie np.array ([0,], dtype=np.int)
def get_entier_upper_bounds (lui-même) :
renvoie np.array ([len (self._faisable_dates) - 1,], dtype=np.int)
set de définition_entier_variables (soi, valeurs) :
# Mettre à jour la date de décision avec la date réalisable correspondante
décision personnelle_date = soi._feasible_dates [valeurs [0]]
def get_entier_variables (soi) :
renvoie np.array ([self._faisable_dates.get_loc (autodécision)_date),], dtype=np.int)
def dump (self) :
données = {
« le plus tôt_date : « self.early »_date.iso format (),
« le plus récent_« date » : self.latest_date.iso format (),
« décision_« date » : auto.decision_date.iso format (),
« décision_fréquence' : self.decision_freq
}
données de retour
@classmethod
charge de définition (cls, modèle, données) :
avant_paramètre = charge_paramètre (modèle, data.pop ('before_parameter'))
après_paramètre = charge_paramètre (modèle, data.pop ('after_parameter'))
return cls (model), avant_paramètre=avant_paramètre, après_paramètre=après_paramètre, **données)Paramètre de décision transitoire. register ()
Désormais, lors de l'exécution de ce réseau dans WaterStrategy, un TranscientDecisionParameter sera enregistré. 
Après avoir enregistré votre règle personnalisée, assurez-vous qu'elle s'affiche sur le côté gauche, dans ce cas sous **Paramètre** section
<figure><img src="../../.gitbook/assets/image (52).png" alt=""><figcaption></figcaption></figure>
## Utilisation du paramètre TranscientDecisionParameter
Dans ce cas, nous doublerons le volume maximum de **Nouveau réservoir** storage node en commençant par `2045-01-01`
Accédez à **Nouveau réservoir** storage node et `Modifier` **Volume maximum**
<figure><img src="../../.gitbook/assets/image (53).png" alt="" width="446"><figcaption></figcaption></figure>
Sélectionnez dans **Options** onglet **PYWR \_PARAMÈTRE**
<figure><img src="../../.gitbook/assets/image (54).png" alt="" width="271"><figcaption></figcaption></figure>
Collez le code suivant et cliquez sur **Enregistrer**
{ « type » : « Paramètre de décision transitoire », « après_paramètre » : »Nouveau réservoir:max_volume après », « avant_paramètre » : »Nouveau réservoir:max_volume avant », « date_décision » : « 2045-01-01 », « dernière_date » : « 2045-01-01 » }
TranscientDecisionParameter inclut les attributs « avant_paramètre` et `après_parameter` que nous devrons créer comme suit :
<figure><img src="../../.gitbook/assets/image (55).png" alt=""><figcaption></figcaption></figure>
Une petite zone de texte s'ouvrira, lorsque nous pourrons écrire le nom de notre nouveau **PAR \_PARAMÈTRE**, dans ce cas \
\_\_**Nouveau réservoir \_\_:maximum \_volume précédent.** Cliquez **Entrez**. \
<figure><img src="../../.gitbook/assets/image (57).png" alt="" width="375"><figcaption></figcaption></figure>
WaterStrategy ouvrira la fenêtre des paramètres, collez le code suivant et **Enregistrer**
**\_\_Nouveau réservoir \_\_:maximum \_volume avant :**
{ « type » : « Paramètre constant », « valeur » : 120000 }
<figure><img src="../../.gitbook/assets/image (58).png" alt=""><figcaption></figcaption></figure>
Répétez l'opération pour créer le volume maximum après le paramètre
**\_\_Nouveau réservoir \_\_:maximum \_volume après :**
{ « type » : « Paramètre constant », « valeur » : 240000 }
Comme dernière étape, TranscientDecisionParameter doit **Proportion volumique initiale** pour le storage node en tant que paramètre hérite des valeurs initiales du nœud. Dans ce cas, nous allons configurer **0.99**
<figure><img src="../../.gitbook/assets/image (59).png" alt="" width="423"><figcaption></figcaption></figure>
## Résultats
Comme le montre l'image suivante, nous combinons des scénarios pywr utilisant le changement climatique et augmentons le volume du réservoir que nous avons sélectionné de 120.000 ml à 240.000 ml au 1er janvier 2045.
<figure><img src="../../.gitbook/assets/image (60).png" alt=""><figcaption><p>volume simulé (Nouveau réservoir)</p></figcaption></figure>
Last updated
Was this helpful?