wolfhece.mesh2d.wolf2dprev

Author: HECE - University of Liege, Pierre Archambeau Date: 2024

Copyright (c) 2024 University of Liege. All rights reserved.

This script and its content are protected by copyright law. Unauthorized copying or distribution of this file, via any medium, is strictly prohibited.

Module Contents

wolfhece.mesh2d.wolf2dprev.msg

wolfhece.mesh2d.wolf2dprev.PREV_INFILTRATION_NULL = 0

wolfhece.mesh2d.wolf2dprev.PREV_INFILTRATION_SIMPLE = 1

wolfhece.mesh2d.wolf2dprev.PREV_INFILTRATION_MOD_MOMENTUM = 2

wolfhece.mesh2d.wolf2dprev.PREV_INFILTRATION_MOD_MOMENTUM_IMPOSED = 4

wolfhece.mesh2d.wolf2dprev.PREV_INFILTRATION_VAR_SIMPLE

wolfhece.mesh2d.wolf2dprev.PREV_INFILTRATION_VAR_MOD_MOMENTUM

wolfhece.mesh2d.wolf2dprev.PREV_INFILTRATION_VAR_LINKED_ZONES

wolfhece.mesh2d.wolf2dprev.PREV_READ_TXT = 1

wolfhece.mesh2d.wolf2dprev.PREV_READ_FINE = 2

wolfhece.mesh2d.wolf2dprev.PREV_READ_MB = 3

wolfhece.mesh2d.wolf2dprev.NOT_USED

wolfhece.mesh2d.wolf2dprev.NB_GLOB_GEN_PAR = 36

wolfhece.mesh2d.wolf2dprev.NB_BLOCK_GEN_PAR = 23

wolfhece.mesh2d.wolf2dprev.NB_GLOB_DEBUG_PAR = 60

wolfhece.mesh2d.wolf2dprev.NB_BLOCK_DEBUG_PAR = 60

wolfhece.mesh2d.wolf2dprev.find_sep(line: str)

class wolfhece.mesh2d.wolf2dprev.prev_parameters_blocks(parent: prev_parameters_simul = None)

Paramètres de calcul propres aux blocs.

Il y a :

• 23 paramètres généraux - NB_BLOCK_GEN_PAR

• 60 paramètres (potentiels) de “debug” - Tous les paramètres debug ne sont pas utilisés pour le moment - NB_BLOCK_DEBUG_PAR.

:remark : Les noms de variables ne sont pas nécessairement identiques à ceux utilisés dans le code Fortran.

property filegen: str

property has_turbulence

property has_variable_infiltration

property has_infiltration

property has_unknown_topo

property has_modified_surface_friction

property has_lateral_friction

property has_danger_map

property has_bridge

property has_mobile_forcing

property has_pressure_fluxes

property has_unsteady_topo

property has_sediment_model

property has_gravity_discharge

_set_general_debug_params(gen: list, debug: list)

Définit les paramètres généraux et de debug

set_params_topography_operator(op: wolfhece.PyVertexvectors.Literal[Mean, Max, Min, 1, 2, 3] = 'Mean')

Définit le type d’opérateur topographique

get_params_topography_operator() → tuple[int, str]

Retourne le type d’opérateur topographique

check_params_topography_operator() → tuple[bool, str]

Check topography operator

reset_params_topography_operator()

Réinitialise l’opérateur topographique à Mean

set_params_reconstruction_type(reconstruction_intern: wolfhece.PyVertexvectors.Literal[constant rec, linear rec, 0, 1] = 0, reconstruction_frontier: wolfhece.PyVertexvectors.Literal[constant rec, linear limited, linear not limited, 0, 2, 1] = 2, reconstruction_free: wolfhece.PyVertexvectors.Literal[constant rec, linear limited, linear not limited, 0, 2, 1] = 0, limiter_variable: wolfhece.PyVertexvectors.Literal[h, (h+z), 0, 1] = 0, frontier_treatment: wolfhece.PyVertexvectors.Literal[Nothing, Average, 1, 0] = 1, number_neighbors_in_limiting_phase: int = 5)

Définit le type de reconstruction pour différents types de bords

Parameters:

• reconstruction_intern – Reconstruction interne

• reconstruction_frontier – Reconstruction des bords frontière

• reconstruction_free – Reconstruction des bords libres

• limiter_variable – Limiter la hauteur ‘h’ ou ou la surface libre ‘h+z’

• frontier_treatment – Traitement des frontières

• number_neighbors_in_limiting_phase – Nombre de voisins pour la limitation

get_params_reconstruction_type() → dict

Retourne le type de reconstruction

reset_params_reconstruction_type()

Réinitialise le type de reconstruction

check_params_reconstruction_type() → tuple[bool, str]

Check reconstruction type

set_params_flux_type(flux_type: wolfhece.PyVertexvectors.Literal[HECE original, VAM-5, VAM-5 with vertical velocites, VAM-5 with vertical velocites and solid transport, HECE in terms of h, u, v, HECE in terms of Volume, qx, qy, HECE with H "energy formulation" in slope term, HECE under pressure (H), HECE under pressure (Volume instead of H), 1, 2, 3, 4, 5, 6, 7, 8, 9])

get_params_flux_type() → tuple[int, str]

Retourne le type de flux

See : ntypflux in Modules_wolf/2D/Wolf2D-Preprocessing.f90

reset_params_flux_type()

Réinitialise le type de flux

check_params_flux_type() → tuple[bool, str]

Check flux type

set_params_froud_max(froude_max: float)

Définit le Froude maximum

Si, localement, le Froude maximum est dépassé, le code limitera les inconnues de débit spécifique à la valeur du Froude maximum en conservant inchangée la hauteur d’eau.

Valeur par défaut : 20.

get_params_froud_max() → float

Retourne le Froude max

reset_params_froud_max()

Réinitialise le Froude max

check_params_froud_max() → tuple[bool, str]

Check Froude max

set_params_conflict_resolution(mode: wolfhece.PyVertexvectors.Literal[Original, Centered, Nothing, 0, 1, 2])

Définit la résolution des conflits

get_params_conflict_resolution() → tuple[int, str]

Retourne la résolution des conflits

reset_params_conflict_resolution()

Réinitialise la résolution des conflits

check_params_conflict_resolution() → tuple[bool, str]

Check conflict resolution

set_evolutive_domain(evolutive_domain: wolfhece.PyVertexvectors.Literal[No, Yes, 0, 1])

Définit le domaine évolutif

reset_evolutive_domain()

Réinitialise le domaine évolutif – Domaine fixe

set_params_sediment(model: wolfhece.PyVertexvectors.Literal[No sediment model, Drifting, Drifting and suspension, 0, 1, 2] = 'No sediment model', drifting_model: wolfhece.PyVertexvectors.Literal[No drifting, Meyer-Peter-Muller, Rickemann, 0, 1, 2] = 'No drifting', porosity: float = 0.0, d_mean: float = 0.0, s_sedim: float = 2.65, vthetacr: float = 0.0, reduced_slope: float = 0.0, d30: float = 0, d90: float = 0.0)

Définit le modèle sédimentaire

Parameters:

• model – Modèle sédimentaire

• drifting_model – Modèle de transport par charriage

• porosity – Porosité

• d_mean – Diamètre moyen

• s_sedim – Densité relative des sédiments

• vthetacr – Tension adimensionnelle critique pour la mise en mouvement

• reduced_slope – Pente réduite

• d30 – D30

• d90 – D90

_get_params_sediment_model() → tuple[int, str]

Retourne le modèle sédimentaire

_get_params_sediment_drifting_model() → tuple[int, str]

Retourne le modèle de dérive

get_params_sediment() → dict

Retourne les paramètres du modèle sédimentaire

reset_params_sediment()

Désactive le modèle sédimentaire

check_params_sediment() → tuple[bool, str]

Check sediment model

set_params_gravity_discharge(activated: bool, critical_slope: float, natural_slope: float)

Définit si le modèle de décharge solide gravitaire est activé

Parameters:

• activated – booléen indiquant si le modèle de décharge solide gravitaire doit être activé

• critical_slope – Pente critique

• natural_slope – Pente naturelle

reset_params_gravity_discharge()

Désactive le modèle de décharge solide gravitaire

get_params_gravity_discharge() → dict

Retourne les paramètres du modèle de décharge solide gravitaire

check_params_gravity_discharge() → tuple[bool, str]

Check gravity discharge

set_params_steady_sediment(porosity: float, d_mean: float, s_sedim: float = 2.65, vthetacr: float = 0.0, drifting_mode: wolfhece.PyVertexvectors.Literal[Meyer - Peter - Muller, Rickemann, 1, 2] = 'Meyer-Peter-Muller', epssedim: float = 1e-10, epsstabbed: float = 1e-10, reduced_slope: float = 1.0)

Définit les paramètres du modèle sédimentaire

Loi de Meyer-Peter et Müller pour le charriage :

• $ Q = C * sqrt{s * g * d^3} * (s - Rcr)^{3/2} $

• $ s = rho_sedim / rho_eau $

• $ Rcr = vthetacr $

• $ d = d_moyen $

Parameters:

• porosity – Porosité

• d_moyen – Diamètre moyen

• s_sedim – Densité relative des sédiments

• vthetacr – Tension adimensionnelle critique pour la mise en mouvement

• ntype_charriage – Type de loi de transport par charriage

• epssedim – Epsilon sur h pour recalculer le fond

• epsstabfond – Epsilon pour l’arrêt stationnaire sur base de la variation de la topo de fond

• pente_reduite – Pente réduite – si <= 0, forcé à 1 càd “sans bedforms”

get_params_steady_sediment() → dict

Retourne les paramètres du modèle sédimentaire

reset_params_steady_sediment()

Réinitialise les paramètres du modèle sédimentaire

check_params_steady_sediment() → tuple[bool, str]

Check steady sediment

set_params_unsteady_topo_bathymetry(activated: bool, model: int)

Définit si la topo est variable ou non

• sur base d’une succession de matrices de topo

• sur base d’une triangulation dynamique

see : Modules_wolf/2D/Wolf2D-DonneesInst.f90 “!GESTION DE LA TOPO INSTATIONNAIRE” for more information

get_params_unsteady_topo_bathymetry() → dict

Retourne les paramètres de la topo variable

Les paramètres sont globaux, pas spécifiques à un bloc –> voir les paramètres globaux associés

reset_params_unsteady_topo_bathymetry()

Désactive la topo variable

check_params_unsteady_topo_bathymetry() → tuple[bool, str]

Check unsteady topo

set_params_collapse_building(activated: bool)

Définit si les bâtiments sont effacés ou non

get_params_collapse_building() → dict

Retourne les paramètres de l’effacement des bâtiments

Les paramètres sont globaux, pas spécifiques à un bloc –> voir les paramètres globaux associés

reset_params_collapse_building()

Désactive l’effacement des bâtiments

check_params_collapse_building() → tuple[bool, str]

Check collapse building

set_params_mobile_contour(activated: bool, which: wolfhece.PyVertexvectors.Literal[1, -1] = 1)

Définit si le contour est mobile ou non

CMCH

• text file

• first line : number of points

• next lines : time, x, y, acm

CMXY

• text file

• first line : number of polygons, max number of points (in a polygon)

• for each polygon

  • first line : number of points, index of the polygon

  • next lines : x, y

:remark Only support 1 polygon for now

get_params_mobile_contour() → dict

Retourne les paramètres du contour mobile

reset_params_mobile_contour()

Désactive le contour mobile

check_params_mobile_contour() → tuple[bool, str]

Check mobile contour

set_params_mobile_forcing(activated: bool)

Définit si le forcing mobile est activé ou non

see: Modules_wolf/2D/Wolf2D-DonneesInst.f90 – FORCING_MOB for more information

.fmpar file must be present in the simulation directory .fm file must be present in the simulation directory .fmch file must be present in the simulation directory

FMPAR

• text file

• first line : dx, dy

• second line : nx, ny

FM

• binary file

• sequential arrays of forcing along X, Y and Z – shape of one array = (nx, ny)

• series of 3 arrays for each time

FMCH

• text file

• on each line : time, origx, origy

Track ‘FORCING_MOB’ in the Fortran code for more information

reset_params_mobile_forcing()

Désactive le forcing mobile

check_params_mobile_forcing() → tuple[bool, str]

Check mobile forcing

check_params_forcing() → tuple[bool, str]

Vérifie les paramètres de forcing et la présence du fichier associé

set_params_bridges(activated: bool)

Définit si les ponts sont activés ou non

get_params_bridges() → dict

Retourne les paramètres des ponts

reset_params_bridges()

Désactive les ponts

check_params_bridges() → tuple[bool, str]

Vérifie si les ponts sont activés

set_params_danger_map(activated: bool, hmin: float, which: wolfhece.PyVertexvectors.Literal[(Toa + H), Qx, Qy, with Z and toa_q, with Z, toa_q, v, toa_v] = '(Toa + H), Qx, Qy')

Définit si la carte de risque est activée ou non

Parameters:

• activated – booléen indiquant si la carte de risque doit être calculée

• hmin – incrément de hauteur minimale pour activer la carte de risque de temps d’arrivée

get_params_danger_maps() → dict

Retourne les paramètres de la carte de risque

reset_params_danger_map()

Désactive la carte de risque

check_params_danger_map() → tuple[bool, str]

Check Danger map

set_params_surface_friction(model_type: wolfhece.PyVertexvectors.Literal[Horizontal, Modified surface corrected 2D (HECE), Modified surface corrected 2D + Lateral external borders (HECE), Horizontal and Lateral external borders, Modified surface (slope), Modified surface (slope) + Lateral external borders, Horizontal and Lateral external borders (HECE), Modified surface (slope) + Lateral external borders (HECE), Horizontal -- Bathurst, Horizontal -- Bathurst-Colebrook, Horizontal -- Chezy, Horizontal -- Colebrook, Horizontal -- Barr, Horizontal -- Bingham, Horizontal -- Frictional fluid, Horizontal and Lateral external borders (Colebrook), Horizontal and Lateral external borders (Barr)])

Définit le mode de calcul de surface de friction à utiliser

get_params_surface_friction() → tuple[int, str]

reset_params_surface_friction()

Réinitialise le modèle de surface de friction

chech_params_surface_friction() → tuple[bool, str]

Check surface friction model

set_params_turbulence(model_type: wolfhece.PyVertexvectors.Literal[k-eps HECE, No, Smagorinski, Fisher, k-eps, k, 0, 1, 2, 3, 4, 6], nu_water: float = 1e-06, cnu: float = 0.09, maximum_nut: float = 0.001, c3e: float = 0.8, clk: float = 0.0001, cle: float = 10.0)

Définit le modèle de turbulence à utiliser

Parameters:

• model_type – type de modèle de turbulence

• nu_water – viscosité cinématique de l’eau

• cnu – coefficient de viscosité turbulente

• maximum_nut – valeur maximale de la viscosité turbulente – A utiliser pour éviter les valeurs trop élevées mais une valeur trop basse influencera le résultat

• c3e – coefficient c3e

• clk – coefficient clk

• cle – coefficient cle

_get_params_turbulence_modelname() → str

get_params_turbulence() → dict

Retourne les paramètres de turbulence

reset_params_turbulence()

Réinitialise les paramètres de turbulence

check_params_turbulence() → tuple[bool, str]

Vérifie les paramètres de turbulence

set_params_vam5_turbulence(nu_vertical: float, turbulence_model: int)

Définit les paramètres du modèle VAM5

Parameters:

• nu_vertical – viscosité verticale pour VAM5

• turbulence_model – modèle de turbulence pour VAM5

get_params_vam5_turbulence() → dict

Retourne les paramètres du modèle VAM5

reset_params_vam5_turbulence()

Réinitialise les paramètres du modèle VAM5

get_params_infiltration() → dict

Retourne les paramètres d’infiltration

check_params_infiltration() → tuple[bool, str]

Vérifie les paramètres d’infiltration

set_params_infiltration_momentum_correction(ux: float, vy: float)

Définit les corrections de moment pour l’infiltration

get_params_infiltration_momentum_correction() → dict

Retourne les corrections de moment pour l’infiltration

reset_params_infiltration_momentum_correction()

Réinitialise les corrections de moment pour l’infiltration

set_params_infiltration_bridge(a: float, cd: float, zseuil: float, width: float)

Définit les paramètres de transfert entre 2 zones d’infiltration/exfiltration de part et d’autre d’un pont

Le débit échangé est calculé sur base de la somme de 2 contributions :

• un écoulement sous pression Q_1 = sqrt{a * |Z_1 - Z_2|} * sign(Z_1 - Z_2)

• un écoulement de type déversoir Q_2 = cd * sqrt{2 * g * (Z_1 + U^2 / {2g} - Zseuil)^3} * width

La somme des 2 débits est ensuite répartie sur les mailles des 2 zones d’infiltration/exfiltration.

Il est prélevé dans les zones impaires et injecté dans les zones paires suivantes.

see : Modules_wolf/2D/Wolf2D-DonneesInst.f90 - CALC_CHARGE_ET_DEBIT_2

reset_params_infiltration_bridges()

Réinitialise les paramètres de transfert entre 2 zones d’infiltration/exfiltration de part et d’autre d’un pont

set_params_infiltration_weir(cd: float, zseuil: float, width: float)

Définit les paramètres d’un déversoir pour l’exfiltration variable

$ Q = cd * sqrt{2 * g * (Z + U^2 / {2g} - Zseuil)^3} * width $

avec :

• Z : altitude de surface libre moyenne sur la zone d’infiltration

• U : vitesse moyenne sur la zone d’infiltration

• cd : coefficient de débit

• zseuil : altitude du seuil

• width : largeur du déversoir

Le débit est ensuite réparti sur les mailles de la zone d’exfiltration (retrait de matière si Q>0).

reset_params_infiltration_weir()

Réinitialise les paramètres du déversoir

set_params_infiltration_weir_poly3(a: float, b: float, c: float, d: float, zseuil: float, width: float)

Définit les paramètres d’un déversoir pour l’exfiltration variable de type polynomiale

$ H = Z - Z_seuil $

$ Cd = a * H^3 + b * H^2 + c * H + d $

$ Q = 2/3 * Cd * sqrt{2 * g * H^3} * width $

avec :

• Z : altitude de surface libre moyenne sur la zone d’infiltration

• a, b, c, d : coefficients

• zseuil : altitude du seuil

• width : largeur du déversoir

Le débit est ensuite réparti sur les mailles de la zone d’exfiltration (retrait de matière si Q>0).

reset_params_infiltration_weir_poly3()

Réinitialise les paramètres du déversoir

set_params_infiltration_polynomial2(a: float, b: float, c: float)

Définit les paramètres d’une infiltration variable de type polynomiale

$ Q = a * Z^2 + b * Z + c $

avec

• Z : altitude de surface libre moyenne sur la zone d’infiltration

• a, b, c : coefficients

Le débit est ensuite réparti sur les mailles de la zone d’infiltration (apport de matière si Q>0).

reset_params_infiltration_polynomial2()

Réinitialise les paramètres de l’infiltration polynomiale

set_params_infiltration_power(d: float, e: float)

Définit les paramètres d’une infiltration variable de type puissance

$ Q = d * sqrt{Z-e} $

avec :

• Z : altitude de surface libre moyenne sur la zone d’infiltration

• d : coefficient

• e : hauteur minimale de l’infiltration variable (si Z <= e, l’infiltration est nulle)

Le débit est ensuite réparti sur les mailles de la zone d’infiltration (apport de matière si Q>0).

reset_params_infiltration_power()

Réinitialise les paramètres de l’infiltration de type puissance

set_params_bingham_model(rho: float)

Définit les paramètres du modèle de Bingham

Parameters:

rho – viscosité plastique

reset_params_bingham_model()

Réinitialise les paramètres du modèle de Bingham

set_params_frictional_model(hs: float, cv: float, ru0: float)

Set the frictional model parameters

get_params_frictional() → dict

Get the frictional model parameters

reset_params_frictional_model()

Reset the frictional model parameters

_get_debug_params() → list

_set_debug_params(values: list)

Définition des paramètres de débogage sur base d’une liste de valeurs

_get_general_params() → list

Liste des 23 paramètres généraux - NB_BLOCK_GEN_PAR

_set_general_params(values: list)

Définition des 23 paramètres généraux sur base d’une liste de valeurs

write_file(f)

Writing the general parameters in a file

:remark The order of the parameters is important

write_debug(f)

Writing the debug parameters in a file

Parameters:

f – file to write in

:remark The order of the parameters is important

apply_changes_to_memory()

Apply the changes made in the GUI to the memory.

This method is called when the user clicks on the “Apply” button in the GUI.

Effective transfer will be done in the _callback_param_from_gui method.

_callback_param_from_gui()

Set the parameters from the Wolf_Param object.

Callback routine set in the PyParams instance.

get_parameter(group: str, name: str) → wolfhece.PyVertexvectors.Union[int, float]

Get a parameter value

set_parameter(group: str, name: str, value: wolfhece.PyVertexvectors.Union[int, float]) → None

Set a parameter value

_get_groups() → list[str]

Retourne la liste des groupes de paramètres

_get_param_names() → list[str]

Retourne la liste des noms de paramètres

_get_groups_and_names() → list[tuple[str, str]]

Retourne la liste des couples (group, name)

get_active_params() → dict

Retourne les paramètres qui sont différents des valeurs par défaut

get_all_params() → dict

Retourne tous les paramètres, y compris les valeurs par défaut

_set_block_params(toShow=True, force=False) → wolfhece.PyParams.Wolf_Param

Création d’un objet Wolf_Param et, si souhaité, affichage des paramètres via GUI wxPython

Parameters:

toShow – booléen indiquant si les paramètres doivent être affichés via GUI wxPython

_fillin_general_parameters()

General parameters

Create list of groups ans parameter names to be used in the GUI/Wolf_Params object

:remark The order of the parameters is important

_fillin_debug_parameters()

Debug parameters

Create list of groups ans parameter names to be used in the GUI/Wolf_Params object

:remark The order of the parameters is important

check_all() → tuple[bool, str]

Call all check_params* routines in this class

show(show_in_active_if_default: bool = False)

Show the parameters of the block in a WX frame

is_like(other: prev_parameters_blocks) → bool

Check if two prev_parameters_blocks are similar

copy(other: prev_parameters_blocks) → None

Copy the parameters of another prev_parameters_blocks

diff(other: wolfhece.PyVertexvectors.Union[prev_parameters_blocks, list[prev_parameters_blocks]]) → dict

Return the differences between two prev_parameters_blocks

diff_print(other: wolfhece.PyVertexvectors.Union[prev_parameters_blocks, list[prev_parameters_blocks]]) → str

Return the differences between two prev_parameters_blocks as a string

class wolfhece.mesh2d.wolf2dprev.boundary_condition_2D(i: int, j: int, ntype: int, val: float, direction: int = 1)

Type des CL générales, faibles et fortes @author Pierre Archambeau

vec: wolfhece.PyVertexvectors.vector

class wolfhece.mesh2d.wolf2dprev.prev_boundary_conditions(parent: prev_parameters_simul)

Classe pour le stockage des CL générales, faibles et fortes

@author pierre archambeau

property nb_bc

property dx

property dy

property origx

property origy

property translx

property transly

mybc: list[boundary_condition_2D]

myzones: wolfhece.PyVertexvectors.Zones

reset()

fillgrid(gridto: wolfhece.CpGrid.CpGrid)

add(i: int, j: int, ntype: wolfhece.mesh2d.cst_2D_boundary_conditions.BCType_2D, value: float, orient: str)

Add a new constraint i,j : indices ntype: type of the constraint orient: oritentation, used for drawing

read_file(lines: list, orient)

Lecture du fichier de paramètres

get_xy(i, j, orient, aswolf=False)

list_bc()

Liste des CL existantes

bc2text()

Convert the BC’s to a text representation

list_bc_ij()

Liste des indices CL existantes

:return : 2 listes distinctes avec les indices i et j des CL

exists(i: int, j: int)

Vérifie si une CL existe aux indices i et j

get_bc(i: int, j: int)

Récupère la/les CL aux indices i et j

remove(i: int, j: int)

Supprime une CL existante

change(i: int, j: int, ntype: wolfhece.mesh2d.cst_2D_boundary_conditions.BCType_2D, value: float)

Remplace une CL existante

class wolfhece.mesh2d.wolf2dprev.prev_parameters_simul(parent: prev_sim2D = None)

Paramètres de simulation d’un modèle WOLF2D original

@author pierre archambeau

property dx

property dy

property nbx

property nby

property origx

property origy

property translx

property transly

property nblocks

property nb_computed_blocks

Nombre de blocs calculés

property partial_calculation

property bc_nb_strong

property bc_nbx_weak

property bc_nby_weak

property clf

property clfbx

property clfby

property has_turbulence

Check if the simulation has turbulence

Remark : Turbulence is a bloc parameter, so we need to check all blocks

blocks: list[prev_parameters_blocks]

strong_bc: prev_boundary_conditions

weak_bc_x: prev_boundary_conditions

weak_bc_y: prev_boundary_conditions

check_all(verbosity=0) → tuple[bool, str]

Call all check_params* routines in this class and all blocks

Parameters:

verbosity – 0 = errors only, 1 = errors and warnings, 2 = everything, 3 = everything + group names

set_mesh_only()

Set the mesher only flag

When launched, the Fortran program will only generate the mesh and stop.

unset_mesh_only()

add_block(block: prev_parameters_blocks = None, name: str = '')

show(show_in_active_if_default=False)

Show the parameters of the simulation in a WX frame

is_like(other: prev_parameters_simul) → bool

Check if two prev_parameters_simul are similar

copy(other: prev_parameters_simul) → None

Copy the parameters of another prev_parameters_simul

diff(other: prev_parameters_simul) → dict

Return the differences between two prev_parameters_simul

diff_print(other: prev_parameters_simul) → str

Return the differences between two prev_parameters_simul as a string

set_params_geometry(dx: float, dy: float, nbx: int, nby: int, origx: float, origy: float, translx: float = 0.0, transly: float = 0.0)

Set the geometry parameters of the simulation.

set_params_time_iterations(nb_timesteps: int = 1000, optimize_timestep: bool = True, first_timestep_duration: float = 0.1, writing_frequency: wolfhece.PyVertexvectors.Union[int, float] = 1, writing_mode: wolfhece.PyVertexvectors.Literal[Iterations, Seconds, 0, 1] = 0, writing_type: wolfhece.PyVertexvectors.Literal[Binary compressed, Binary Full, Text, 1, 2, 3] = 3, initial_cond_reading_mode: wolfhece.PyVertexvectors.Literal[Binary, Binary per blocks, Text, 0, 1, 2] = 2, writing_force_onlyonestep: bool = False)

Set the time/iterations parameters of the simulation.

Parameters:

• nb_timesteps – Number of timesteps to perform

• optimize_timestep – Optimize the timestep

• first_timestep_duration – Duration of the first timestep

• writing_frequency – Writing frequency of the results

• writing_mode – Writing mode of the results

• writing_type – Writing type of the results

• initial_cond_reading_mode – Initial condition reading mode

• writing_force_onlyonestep – Force writing only one step

get_params_time_iterations() → dict

Get the time/iterations parameters of the simulation.

reset_params_time_iterations()

Reset the time/iterations parameters of the simulation.

check_params_time_iterations() → tuple[bool, str]

Check the time/iterations parameters of the simulation.

set_params_temporal_scheme(RungeKutta: wolfhece.PyVertexvectors.Literal[RK21, RK22, RK31a, RK31b, RK31c, RK41a, RK41b, RK44, Euler] = 0.3, CourantNumber: float = 0.25, dt_factor: float = 100.0)

Set the temporal scheme parameters of the simulation.

get_params_temporal_scheme() → dict

Get the temporal scheme parameters of the simulation.

reset_params_temporal_scheme()

Reset the temporal scheme parameters of the simulation.

check_params_temporal_scheme() → tuple[bool, str]

Check the temporal scheme parameters of the simulation.

set_params_collapsible_building(hmax_bat: float = 7.0, vmax_bat: float = 2.0, qmax_bat: float = 7.0)

Set the parameters for the collapsible buildings.

get_params_collapsible_building() → dict

check_params_collapsible_building() → tuple[bool, str]

Check the collapsible building parameters.

reset_all_boundary_conditions()

Resets strong as well as weak boundary conditions.

reset_blocks()

setvaluesbc(event)

getvaluesx(event)

getvaluesy(event)

editing_bc(mysimuls)

get_help(group, name)

Récupère l’aide associée à un paramètre

is_global(group, name)

Indique si un paramètre est global ou non

is_general(group, name)

Indique si un paramètre est général ou non

is_debug(group, name)

Indique si un paramètre est de débogage ou non

is_block(group, name)

Indique si un paramètre est associé à un bloc ou non

get_json_values(group, name)

Récupère les valeurs possibles associées à un paramètre

read_file(fn='')

Lecture du fichier de paramètres

write_file(fn='')

Ecriture du fichier de paramètres

add_weak_bc_x(i: int, j: int, ntype: wolfhece.mesh2d.cst_2D_boundary_conditions.BCType_2D, value: float)

Add a boundary condition on a left vertical border of cell. i,j: coordinate of the cell where the left border must be set

as a boundary. i,j are 1-based (grid coordinates.)

add_weak_bc_y(i: int, j: int, ntype: wolfhece.mesh2d.cst_2D_boundary_conditions.BCType_2D, value: float)

Add a boundary condition on a bottom horizontal border of cell. i,j: coordinate of the cell where the left border must be set

as a boundary. i,j are 1-based (grid coordinates.)

to_yaml()

apply_changes_to_memory()

Apply the changes made in the GUI to the memory.

This method is called when the user clicks on the “Apply” button in the GUI.

Effective transfer will be done in the _callback_param_from_gui method.

_callback_param_from_gui()

Set the parameters from the Wolf_Param object.

Callback routine set in the Wolf_Param object.

_set_sim_params(toShow=True) → wolfhece.PyParams.Wolf_Param

Création d’un objet Wolf_Param et, si souhaité, affichage des paramètres via GUI wxPython

Parameters:

toShow – booléen indiquant si les paramètres doivent être affichés via GUI wxPython

_get_debug_params() → list

_set_debug_params(values: list)

_get_general_params() → list

Liste des 36 paramètres généraux – NB_GLOB_GEN_PAR

_set_general_params(values: list)

Définition des 36 paramètres généraux sur base d’une liste de valeurs

_fillin_general_parameters()

General parameters

Create list of groups ans parameter names to be used in the GUI/Wolf_Params object

:remark The order of the parameters is important

_fillin_debug_parameters()

Debug parameters

Create list of groups ans parameter names to be used in the GUI/Wolf_Params object

:remark The order of the parameters is important

_get_groups() → list[str]

Retourne la liste des groupes de paramètres

_get_param_names() → list[str]

Retourne la liste des noms de paramètres

_get_groups_and_names(sort=True) → list[tuple[str, str]]

Retourne la liste des couples (group, name)

get_active_params() → tuple[dict, dict]

Retourne les paramètres qui sont différents des valeurs par défaut

get_all_params() → tuple[dict, dict]

Retourne tous les paramètres, y compris les valeurs par défaut

get_active_params_extended() → dict

Retourne tous les paramètres actifs aisi que ceux des blocs dans une clé spécifique à chaque bloc

get_all_params_extended() → dict

Retourne tous les paramètres aisi que ceux des blocs dans une clé spécifique à chaque bloc

get_active_params_block(i_block: int) → dict

Retourne les paramètres actifs du bloc i_block (1-based)

get_all_params_block(i_block: int) → dict

Retourne tous les paramètres du bloc i_block (1-based)

get_parameter(group: str, name: str) → wolfhece.PyVertexvectors.Union[int, float]

Set a parameter value

set_parameter(group: str, name: str, value: wolfhece.PyVertexvectors.Union[int, float]) → None

Set a parameter value

show_params(which: wolfhece.PyVertexvectors.Literal[all, simulation, block i])

help(group: str, name: str) → list[str]

Retourne l’aide associée à un paramètre

frequent_params() → list[tuple[str, str]]

Retourne les paramètres fréquemment utilisés

class wolfhece.mesh2d.wolf2dprev.prev_infiltration(parent: prev_sim2D = None, fn: str = '', to_read: bool = True)

Infiltration

Gère à la fois le fichier ‘.fil’ (quantités au cours du temps) et accès au ‘.inf’ (matrice) via ‘parent’ ou en autonomie

Author:

Pierre Archambeau

property nb_zones

Number of infiltration zones

property nb_steps

Number of time steps

property zoning

Return the zoninf array

property infiltrations_chronology: wolfhece.PyVertexvectors.np.ndarray

property _chronology_for_gpu: list[float, list[float]]

_infiltrations_chronology: wolfhece.PyVertexvectors.np.ndarray

_read_zoning()

Lecture du fichier .inf – en mode “autonome” si parent n’est pas défini

read_file()

Lecture du fichier .fil

write_file()

Ecriture du fichier .fil

zones_values_at_time(t)

Retourne les valeurs des zones à un temps donné

plot_plt(figax=None, show=True)

Plot the infiltration data

add_infiltration(time_start: float, zones_values: list[float])

Add an infiltration point in the infiltration chronology.

Param:

time_start start time of the infiltration (in seconds)

Param:

zones_values an array representing the quantity of water per second to add to each infiltration zones, starting at time_start. The first item corrsesponds to the zone 1, second item corresponds to zone 2 and so on.

clear_infiltration_chronology()

Clear the infiltration chronology. Useful if one wants to build a new simulation starting with an existing one.

class wolfhece.mesh2d.wolf2dprev.prev_suxsuy(parent: prev_sim2D)

Enumération des bords potentiellement conditions limites selon X et Y

Dans WOLF, un bord X est un segment géométrique orienté selon Y –> le débit normal au bord est orienté selon X Dans WOLF, un bord Y est un segment géométrique orienté selon X –> le débit normal au bord est orienté selon Y

La logique d’appellation est donc “hydraulique”

@remark Utile pour l’interface VB6/Python pour l’affichage

property filenamesux: str

property filenamesuy: str

property Zones

myborders: Zones

mysux: wolfhece.PyVertexvectors.zone

mysuy: wolfhece.PyVertexvectors.zone

reset()

read_file()

Read the SUX/SUY files

is_like(other: prev_suxsuy) → tuple[bool, str]

Compare two prev_suxsuy objects

list_pot_bc_x() → list[int, int]

Liste des conditions limites potentielles sur le bord X

list_pot_bc_y() → list[int, int]

Liste des conditions limites potentielles sur le bord X

class wolfhece.mesh2d.wolf2dprev.blocks_file(parent: wolfhece.PyVertexvectors.Union[prev_sim2D] = None)

Objet permettant la lecture et la manipulation d’un fichier .BLOC

***

Objectif :

• fournir l’information nécessaire au code Fortran pour mailler le domaine en MB

• contient des informations géométriques

  • domaine de calcul

  • contour de bloc

• contient des informations de résolution de maillage

  • tailles de maille souhaitées selon X et Y pour chaque bloc

***

Contenu du fichier :

• nombre de blocs, nombre maximum de vertices contenu dans les polygones présents (soit contour extérieur, soit contour de bloc)

• nombre de vertices à lire pour le contour général (une valeur négative indique que 3 colonnes sont à lire)

  • liste de vertices du contour général (sur 2 – X,Y – ou 3 colonnes – X,Y, flag – la 3ème colonne ne devrait contenir que 0 ou 1 – 1==segment à ignorer dans les calcul d’intersection du mailleur)

    @remark En pratique, le “flag” sera stocké dans la propriété “z” du vertex –> sans doute pas optimal pour la compréhension –> à modifier ??

• informations pour chaque bloc

  • nombre de vertices du polygone de contour

  • liste de vertices (2 colonnes – X et Y)

  • extension du bloc calé sur la grille magnétique et étendu afin de permettre le stockage des relations de voisinage (2 lignes avec 2 valeurs par ligne)

    • xmin, xmax

    • ymin, ymax

    @remark L’extension, sur tout le pourtour, vaut 2*dx_bloc+dx_max_bloc selon X et 2*dy_bloc+dy_max_bloc selon Y @remark Pour une taille de maille uniforme on ajoute donc l’équivalent de 6 mailles selon chaque direction (3 avant et 3 après)

• résolution pour chaque bloc (“nb_blocs” lignes)

  • dx, dy

***

Remarques :

• nb_blocs n’est pas un invariant. Il faut donc faire attention lors de la création/manipulation de l’objet –> A fixer?

• pour les simulations existantes, la taille de la grille magnétique n’est pas une information sauvegardée dans les fichiers mais provient du VB6 au moment de la création de la simulation @TODO : coder/rendre une grille magnétique et sans doute définir où stocker l’info pour garantir un archivage correct

property nb_blocks: int

property dx_dy: tuple[list[float], list[float]]

property dx_max: float

property dy_max: float

property filename: str

property Zones

property general_contour_zone: wolfhece.PyVertexvectors.zone

property blocks_extents_zone: wolfhece.PyVertexvectors.zone

property external_border: wolfhece.PyVertexvectors.vector

Return the external border of the simulation

property max_size_cont

Maximal number of vertices in a contour

property has_interior

Check if the bloc file has interior segments

my_blocks: list[block_description]

my_vec_blocks: Zones

force_legends()

Force the legends of the zones

align2grid(x: float, y: float)

Aligns a point to the grid

set_external_border(contour: wolfhece.PyVertexvectors.vector)

Set the external contour – Replace the existing one if any

reset_external_border()

Reset the external contour

add_block(contour: wolfhece.PyVertexvectors.zone, dx: float, dy: float)

Add a block to the list of blocks

reset_blocks()

Reset the list of blocks

delete_block(idx: int)

Delete a block from the list

Parameters:

idx – index of the block to delete - 1-based

insert_block(idx: int, contour: wolfhece.PyVertexvectors.zone, dx: float, dy: float)

Insert a block in the list

Parameters:

idx – index where to insert the block - 1-based

search_magnetic_grid()

Search the magnetic grid properties

get_contour_block(idx: int) → wolfhece.PyVertexvectors.vector

Get the contour of a block

read_file()

Lecture du fichier .bloc

write_file()

Writing bloc file

modify_extent()

is_like(other: blocks_file) → tuple[bool, str]

Check if the bloc file is like another one

class wolfhece.mesh2d.wolf2dprev.block_contour(lines: list = ..., is2D=True, name='', parentzone=None)

Bases: wolfhece.PyVertexvectors.vector

Extension d’un vecteur afin de stocker un polygone de contour soit du domaine de calcul, soit d’un bloc

L’extension est utile pour définir la propriété :

• mylimits

et les routines:

• set_limits

• verify_limits

set_limits()

Retain current limits before any modification

verify_limits()

Verify that the current vertices are inside the set block’s limits

wolfhece.mesh2d.wolf2dprev.COLOURS_BLOCKS = [(0, 0, 255), (255, 0, 0), (0, 255, 0), (255, 255, 0), (255, 0, 255), (0, 255, 255), (0, 125,...

class wolfhece.mesh2d.wolf2dprev.block_description(parent: blocks_file, lines=[], idx: int = 0)

parent: blocks_file

contour: block_contour

dx: float

dy: float

xmin: float

xmax: float

ymin: float

ymax: float

Classe permettant de contenir:

• le polygone de définition du bloc

• les bornes de l’étendue augmentée

Ici xmin, xmax, ymin, ymax sont à dissocier des propriétés du vecteur contour et ne représentent donc pas les coordonnées min et max des vertices mais bien une zone rectangulaire contenant tout le bloc

align2grid(x: float, y: float)

Aligns a point to the grid

setup(contour: wolfhece.PyVertexvectors.vector, dx: float, dy: float)

Fill in the block with a given value

Parameters:

• contour – vector representing the block contour

• dx – resolution along X

• dy – resolution along Y

set_bounds()

Retain current limits before any modification

set_dx_dy(dx: float, dy: float)

Set the resolution of the block

class wolfhece.mesh2d.wolf2dprev.xy_file(simparent: wolfhece.PyVertexvectors.Union[prev_sim2D] = None)

Contour du domaine

Les infos de cette classe sont redondantes avec le contour contenu dans le fichier .bloc Dans l’interface VB6, il est cependant généré avant le fichier .bloc

@remark Le fichier n’est pas utilisé par le code de calcul Fortran –> principalement pré-traitement/visualisation

property filename

property translx

property transly

property contour_zone

property contour_vector

property Zones

myzones: Zones

read_file()

Lecture du fichier .xy

class wolfhece.mesh2d.wolf2dprev.prev_lst_file(parent: prev_sim2D = None)

property filename

property filenamegen

read_file(forcefilename: str = None)

Lecture du fichier .lst

write_file(forcefilename: str = None)

Writing lst file

check()

Check the lst file

class wolfhece.mesh2d.wolf2dprev.prev_sim2D(fname: wolfhece.PyVertexvectors.Union[str, pathlib.Path] = None, parent=None, clear=False)

Modélisation 2D CPU – version 2D originale non OO

Cette classe est en construction et ne contient pas encore toutes les fonctionnalités.

Elle devrait à terme être utilisée dans l’objet Wolf2DModel de PyGui afin de séparer le stockage des données de la visualisation et interface WX.

property common_mask_MB: list[wolfhece.PyVertexvectors.np.ndarray]

Common mask for multiblock arrays

property common_mask: wolfhece.PyVertexvectors.np.ndarray

Common mask for fine arrays

property fine_arrays: list[wolfhece.wolf_array.WolfArray]

List of fine arrays

property MB_arrays: list[wolfhece.wolf_array.WolfArrayMB]

List of multiblock arrays

property mymnap: wolfhece.wolf_array.WolfArrayMNAP

property mnap: wolfhece.wolf_array.WolfArrayMNAP

property hbinb

property qxbinb

property qybinb

property frotini

property epsbinb

property kbinb

property topini

property hbin

property zbin

property zbinb

property qxbin

property qybin

property frot

property inf

property top

property napbin

property epsbin

property kbin

property translate_origin2zero

Translate the origin to zero

property filenamegen

property dx

property dy

property origx

property endx

property endy

property origy

property nbx

property nby

property translx

property transly

property external_border: wolfhece.PyVertexvectors.vector

Return the external border of the simulation

property is_multiblock

property nb_blocks

property nb_weak_bc_x: int

Nombre de conditions limites faibles sur le bord X

Alias de myparam.weak_bc_x.nb_bc

property nb_weak_bc_y: int

Nombre de conditions limites faibles sur le bord Y

Alias de myparam.weak_bc_y.nb_bc

get_Zones_from_extension(extension: str) → wolfhece.PyVertexvectors.Zones

Get the Zones from the extension

get_wolf_array(extension: str) → wolfhece.wolf_array.WolfArray

Get the WolfArray from the extension

force_reload(which_one: wolfhece.PyVertexvectors.Union[str, wolfhece.wolf_array.WolfArray, wolfhece.wolf_array.WolfArrayMB])

Force the reload of the WolfArray

zbinb2hbinb()

Convert the zbinb to hbinb

hbinb2zbinb()

Convert the hbinb to zbinb

zbin2hbin()

Convert the zbin to hbin

hbin2zbin()

Convert the hbin to zbin

force_mask()

Copy mask

force_load(force_reload=False)

Force the (re)loading of the fine arrays

Params force_reload:

force the reloading of the fine arrays

force_unload()

Force the unloading of the fine arrays

save_arrays_modifications()

Save the modifications of the arrays

search_magnetic_grid()

Search the magnetic grid properties

create_fine_arrays(default_frot: float = 0.04, with_tubulence=False)

Create the fine arrays

Parameters:

• default_frot – default value for the roughness coefficient

• with_tubulence – create the turbulence arrays (epsbin and kbin)

create_napbin()

Create the napbin file

Based on the external border, it will create a napbin file with fine mesh size.

create_sux_suy()

Create the X and Y borders

set_mesh_fine_size(dx: float, dy: float)

Set the mesh size and origin

Parameters:

• dx – mesh size along X

• dy – mesh size along Y

set_external_border_vector(contour: wolfhece.PyVertexvectors.vector)

Add the external border to the bloc file

set_external_border_xy(xmin: float, xmax: float, ymin: float, ymax: float)

Set the external border to the bloc file

set_external_border_nxny(xmin: float, ymin: float, nbx: int, nby: int, dx: float, dy: float)

Set the external border to the bloc file

set_external_border_header(header: wolfhece.wolf_array.header_wolf)

Set the external border to the bloc file

set_external_border_wolfarray(src_array: wolfhece.wolf_array.WolfArray, mode: wolfhece.PyVertexvectors.Literal[prev_sim2D.set_external_border_wolfarray.header, prev_sim2D.set_external_border_wolfarray.contour], abs: bool = True)

Set the external border to the bloc file

Parameters:

• src_array – source array

• mode – mode to use

• abs – if True, use the World coordinates – (ox+trlx, oy+trly), else use the local coordinates – (ox, oy)

add_block(contour: wolfhece.PyVertexvectors.vector, dx: float, dy: float, name: str = '')

Add a block to the bloc file

modify_block(idx: int, contour: wolfhece.PyVertexvectors.vector, dx: float, dy: float)

Modify a block in the bloc file

reset_blocks()

Reset the bloc file

reset_external_border()

Reset the external border

set_mesh_only()

Set the simulation to mesh only

unset_mesh_only()

Unset the simulation to mesh only

clear_directory()

Clear the directory

_set_nbx_nby()

Set the number of cells along X and Y

classmethod check_wolfcli()

Check if wolfcli is available

run_wolfcli(command: str = '')

Run wolfcli

mesh(force_meshonly=True)

Mesh the domain

set_magnetic_grid(dx: float, dy: float, origx: float, origy: float)

Définition de la grille magnétique

Parameters:

• dx (float) – taille de maille selon X

• dy (float) – taille de maille selon Y

• origx (float) – origine selon X (coordonnée du noeud d’intersection)

• origy (float) – origine selon Y (coordonnée du noeud d’intersection)

align2grid(x: float, y: float)

Alignement sur la grille magnétique

read_infil()

Lecture du fichier .fil si présent

read_lst()

Lecture du fichier .lst si présent

read_mnap()

Lecture du fichier .mnap si présent

reset_mnap()

Réinitialisation du fichier .mnap

read_parameters()

Lecture des paramètres de simulation

save_parameters()

Sauvegarde des paramètres de simulation

Les conditions limites sont contenues dans le fichier .par

save()

Sauvegarde des données

get_parameters_groups()

Renvoi des groupes de paramètres de simulation

get_parameters_in_group(group: str)

Renvoi des paramètres d’un groupe de paramètres de simulation

get_parameters_groups_and_names()

Renvoi des groupes et des noms de paramètres de simulation

get_active_parameters()

Renvoi des paramètres de simulation actifs

get_active_parameters_block(block: int)

Renvoi des paramètres de simulation actifs pour un bloc donné

get_active_parameters_extended()

Renvoi des paramètres de simulation actifs

get_all_parameters()

Renvoi de tous les paramètres de simulation

get_all_parameters_block(block: int)

Renvoi de tous les paramètres de simulation pour un bloc donné

get_parameter(group: str, name: str, block: int = None)

Renvoi d’un paramètre de simulation

Parameters:

• group (str) – groupe du paramètre

• name (str) – nom du paramètre

• block (int) – numéro du bloc (1-based)

set_parameter(group: str, name: str, value: wolfhece.PyVertexvectors.Union[float, int], block: int = None)

Modification d’un paramètre de simulation

Parameters:

• group (str) – groupe du paramètre

• name (str) – nom du paramètre

• value (Union[float, int]) – valeur du paramètre

• block (int) – numéro du bloc (1-based) – -1 == all blocks

get_group_name_from_list(target: wolfhece.PyVertexvectors.Literal[Global, Block] = 'Global', which: wolfhece.PyVertexvectors.Literal[General, Debug] = 'General')

Get group and name from a list for VB6 nostalgia / specialist mode

get_parameters_from_list(target: wolfhece.PyVertexvectors.Literal[Global, Block] = 'Global', which: wolfhece.PyVertexvectors.Literal[General, Debug] = 'General', idx_block: int = 0)

Get parameters from a list for VB6 nostalgia / specialist mode

Parameters:

• target (Literal['Global', 'Block']) – target of the parameters

• which (Literal['General', 'Debug']) – which parameters to get

• idx_block (int) – index of the block (1-based)

set_parameters_from_list(target: wolfhece.PyVertexvectors.Literal[Global, Block] = 'Global', which: wolfhece.PyVertexvectors.Literal[General, Debug] = 'General', values: list[int, float] = [], idx_block: int = 0)

Set parameters from a list for VB6 nostalgia / specialist mode

Parameters:

• target (Literal['Global', 'Block']) – target of the parameters

• which (Literal['General', 'Debug']) – which parameters to set

• values (list[int, float]) – list of values

• idx_block (int) – index of the block (1-based)

get_mapviewer()

get_header(abs=False)

Renvoi d’un header avec les infos géométriques de la simulation

Version monobloc et résolution fine

Parameters:

abs (bool) – si True, les origines sont décalées des translations et les translations sont mises à 0

get_header_MB(abs=False)

Renvoi d’un header avec les infos multi-blocs

Parameters:

abs (bool) – si True, les origines sont décalées des translations et les translations sont mises à 0

verify_files()

Vérification de la présence des en-têtes dans les différents fichiers présents sur disque.

Cette routine est nécessaire pour s’assurer de la cohérence des headers. Certaines versions de l’interface VB6 présentaient un bug lors de la sauvegarde des fichiers ce qui peut avoir comme conséquence de décaler les données (double application des translations vers le monde réel).

get_filepath(which: wolfhece.PyVertexvectors.Literal[.top, .hbin, .qxbin, .qybin, .napbin, .topini_fine, .frot, .inf, .kbin, .epsbin, .hbinb, .qxbinb, .qybinb, .kbinb, .epsbinb, .topini, .frotini] = '')

Renvoi du chemin complet d’un fichier

exists_file(which: wolfhece.PyVertexvectors.Literal[.top, .hbin, .qxbin, .qybin, .napbin, .topini_fine, .frot, .inf, .kbin, .epsbin, .hbinb, .qxbinb, .qybinb, .kbinb, .epsbinb, .topini, .frotini] = '') → bool

Vérification de l’existence d’un fichier

last_modification_date(which: wolfhece.PyVertexvectors.Literal[.top, .hbin, .qxbin, .qybin, .napbin, .topini_fine, .frot, .inf, .kbin, .epsbin, .hbinb, .qxbinb, .qybinb, .kbinb, .epsbinb, .topini, .frotini] = '', tz=tz.utc) → str

Renvoi de la date de dernière modification d’un fichier

read_fine_array(which: wolfhece.PyVertexvectors.Literal[.top, .hbin, .qxbin, .qybin, .napbin, .topini_fine, .frot, .inf, .kbin, .epsbin] = '') → wolfhece.wolf_array.WolfArray

Lecture d’une matrice fine

Parameters:

which (str -- extension with point (e.g. '.hbin')) – suffixe du fichier

Returns:

WolfArray

read_MB_array(which: wolfhece.PyVertexvectors.Literal[.hbinb, .qxbinb, .qybinb, .frotini, .topini, .epsbinb, .kbinb] = '') → wolfhece.wolf_array.WolfArrayMB

Lecture d’une matrice MB

Parameters:

which (str -- extension with point (e.g. '.hbinb')) – suffixe du fichier

Returns:

WolfArrayMB

help_files() → str

Informations sur les fichiers et les types de données qu’ils contiennent.

check_infiltration() → str

Informations sur les zones d’infiltration :

• nombre de zones dans le fichier .inf et .fil

• nombre de cellules de chaque zone

• première maille de chaque zone

• nombre de temps énumérés dans le fichier .fil

• Warning si le nombre de zones est différent entre les fichiers .inf et .fil

copy2gpu(dirout: str = '') → str

Copie des matrices d’une simulation CPU pour le code GPU

Parameters:

dirout (str) – répertoire de sortie

copy_parameters(other: prev_sim2D)

Copie des paramètres d’une simulation à une autre

Parameters:

other (prev_sim2D) – autre simulation

is_like(other: prev_sim2D) → tuple[bool, str]

Vérification de la similarité de deux simulations

Parameters:

other (prev_sim2D) – autre simulation

Returns:

True si les simulations sont similaires

add_weak_bc_x(i: int, j: int, ntype: wolfhece.mesh2d.cst_2D_boundary_conditions.BCType_2D, value: float)

Ajout d’une condition limite faible sur le bord X

Alias de myparam.add_weak_bc_x

add_weak_bc_y(i: int, j: int, ntype: wolfhece.mesh2d.cst_2D_boundary_conditions.BCType_2D, value: float)

Ajout d’une condition limite faible sur le bord Y

Alias de myparam.add_weak_bc_y

remove_weak_bc_x(i: int, j: int)

Suppression d’une condition limite faible sur le bord X

Alias de myparam.weak_bc_x.remove

remove_weak_bc_y(i: int, j: int)

Suppression d’une condition limite faible sur le bord Y

Alias de myparam.weak_bc_y.remove

change_weak_bc_x(i: int, j: int, ntype: wolfhece.mesh2d.cst_2D_boundary_conditions.BCType_2D, value: float)

Modification d’une condition limite faible sur le bord X

Alias de myparam.weak_bc_x.change

change_weak_bc_y(i: int, j: int, ntype: wolfhece.mesh2d.cst_2D_boundary_conditions.BCType_2D, value: float)

Modification d’une condition limite faible sur le bord Y

Alias de myparam.weak_bc_y.change

exists_weak_bc_x(i: int, j: int) → bool

Vérification de l’existence d’une condition limite faible sur le bord X

Alias de myparam.weak_bc_x.exists

exists_weak_bc_y(i: int, j: int) → bool

Vérification de l’existence d’une condition limite faible sur le bord Y

Alias de myparam.weak_bc_y.exists

list_bc_x() → list[boundary_condition_2D]

Liste des conditions limites existantes sur les bords X

list_bc_y() → list[boundary_condition_2D]

Liste des conditions limites existantes sur les bords X

list_bc_x_ij() → tuple[list[int], list[int]]

Liste des conditions limites existantes sur les bords X

list_bc_y_ij() → tuple[list[int], list[int]]

Liste des conditions limites existantes sur les bords X

list_bc_ij() → tuple[tuple[list[int], list[int]], tuple[list[int], list[int]]]

Liste des conditions limites existantes sur les bords X et Y

Returns:

tuple avec les indices des conditions limites [entiers 32 bits]

list_bc() → tuple[list[boundary_condition_2D], list[boundary_condition_2D]]

Liste des conditions limites existantes sur les bords X et Y

Returns:

tuple avec instances “boundary_condition_2D”

get_bc_x(i: int, j: int) → list[boundary_condition_2D]

Renvoi d’une condition limite faible sur le bord X

Alias de myparam.weak_bc_x.get_bc

get_bc_y(i: int, j: int) → list[boundary_condition_2D]

Renvoi d’une condition limite faible sur le bord Y

Alias de myparam.weak_bc_y.get_bc

list_pot_bc_x() → tuple[wolfhece.PyVertexvectors.np.ndarray, wolfhece.PyVertexvectors.np.ndarray]

Liste des conditions limites potentielles sur le bord X

Return i,j:

indices des conditions limites potentielles [entiers 32 bits]

list_pot_bc_y() → tuple[wolfhece.PyVertexvectors.np.ndarray, wolfhece.PyVertexvectors.np.ndarray]

Liste des conditions limites potentielles sur le bord X

Return i,j:

indices des conditions limites potentielles [entiers 32 bits]

get_borders_x()

Compute segments coordinates for borders along X

get_borders_y()

Compute segments coordinates for borders along Y

plot_borders(xy_or_ij: wolfhece.PyVertexvectors.Literal[xy, ij] = 'xy', figax: tuple[wolfhece.PyVertexvectors.plt.Figure, wolfhece.PyVertexvectors.plt.Axes] = None, xcolor: str = 'b', ycolor: str = 'r')

Plot the borders

help_bc_type()

Aide sur les types de conditions limites

_sanitize_group(group: str)

Sanitize group name

_sanitize_parameter(name: str)

Sanitize parameter name

sanitize_group_name(group: str, name: str)

get_frequent_parameters() → tuple[list[tuple[str, str]], list[tuple[str, str]], tuple[list[int], list[int], list[int], list[int]]]

Renvoi des paramètres de simulation fréquents

Les valeurs retournées sont :

• les groupes et noms des paramètres globaux

• les groupes et noms des paramètres de blocs

• les indices des paramètres globaux (generaux et debug) et de blocs (generaux et debug)

check_all(verbosity=0) → str

Vérification de la cohérence des paramètres de simulation.

Si les tests ne passent pas, un log d’erreur est généré.

Parameters:

verbosity – 0 = errors only, 1 = errors and warnings, 2 = everything, 3 = everything + group names

Returns:

message de log

Return type:

str

help_parameter(group: str, name: str)

Aide sur les paramètres de simulation

help_values_parameter(group: str, name: str)

Aide sur les valeurs possibles des paramètres de simulation

help_useful_fct() → tuple[str, dict[str:dict[str, list[str]]]]

Useful functions/routines for parameters manipulation

:return (ret, dict) : ret is a string with the description of the function, dict is a dictionary with the function names sorted by category (Global, Block) and type (set, get, reset, check)

_from_params_gpu(imported_params: prev_parameters_simul = None)

This is a __init__ helper. This will be used in the constructor to create a mono-block model from scratch (i.e. not reading from disk; providing base matrices).

Parameters:

myparam – The parameters to build the model with.

set_gpu_test(dt: float = None, n_timesteps: int = None, writing_frequency: wolfhece.PyVertexvectors.Union[int, float] = None, reset_bc: bool = False, optimize_dt: bool = None, Runge_Kutta_pond: float = None, Courant_number: float = None, max_Froude: float = None, writing_mode: wolfhece.PyVertexvectors.Literal[seconds, timesteps, 0, 1] = None)

Usual settings for a GPU test

reset_all_boundary_conditions()

Reset all boundary conditions

add_boundary_condition(i: int, j: int, bc_type: wolfhece.mesh2d.cst_2D_boundary_conditions.BCType_2D, bc_value: float, border: wolfhece.mesh2d.cst_2D_boundary_conditions.Direction)

Add a weak boundary condition to the model.

Parameters:

• i – i-position of the boundary condition (1-based)

• j – j-position of the boundary condition (1-based)

• bc_type – type of boundary condition

• bc_value – value/parameter of the boundary condition

• border – mesh’s border on which the boundary condtion applies

setup_oneblock(contour: wolfhece.PyVertexvectors.Union[wolfhece.PyVertexvectors.vector, wolfhece.wolf_array.WolfArray, tuple, dict, wolfhece.wolf_array.header_wolf], block_spatial_stepsize: float, friction_coefficient: float = 0.04, translate_contour: bool = True)

Setup a single block model

Parameters:

• contour (Union[vector, WolfArray, tuple, dict, header_wolf]) – contour of the model

• dx – spatial step [m]

• frot (float) – friction coefficient

• translate_contour (bool) – translate the contour to have the first point at (0, 0)

get_wizard_text(lang: str = 'en') → str

Get the wizard text

bc2txt() → str

“ Get the text for the boundary conditions Manager

mimic_mask(source: wolfhece.wolf_array.WolfArray)

Copy the mask of the source array to all arrays in the model.